implab/implabjs-djx Commit - r110:1a190b3a757d

corrected tear down logic handling in observables. Added support for observable query results

cin -

r110:1a190b3a757d v1.4.0 default

parent child

Context file:

r110:1a190b3a757d

Collapse all files

The requested changes are too big and content was truncated. Show full diff

playground/src/main/ts/logging.ts created 644 0 0

	1	NO CONTENT: new file 100644			NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

djx/package-lock.json 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

djx/package.json +1 0

             {
                 "name": "@implab/djx",
                 "version": "0.0.1-dev",
                 "description": "Supports using dojo version 1 with typescript and .tsx files",
                 "keywords": [
                     "dojo",
                     "tsx",
                     "typescript",
                     "widgets"
                 ],
                 "author": "Implab team",
                 "license": "BSD-2-Clause",
                 "repository": "https://code.implab.org/implab/implabjs-djx",
                 "publishConfig": {
                     "access": "public"
                 },
                 "peerDependencies": {
                     "@implab/core-amd": "^1.4.0",
                     "dojo": "^1.10.0"
                 },
                 "devDependencies": {
                     "@implab/core-amd": "^1.4.0",
                     "@types/chai": "4.1.3",
                     "@types/requirejs": "2.1.31",
                     "@types/yaml": "1.2.0",
                     "@types/tap": "15.0.7",
+                    "rxjs": "7.5.6",
                     "dojo": "1.16.0",
                     "@implab/dojo-typings": "1.0.3",
                     "@typescript-eslint/eslint-plugin": "^5.23.0",
                     "@typescript-eslint/parser": "^5.23.0",
                     "eslint": "^8.23.0",
                     "eslint-config-standard": "^17.0.0",
                     "eslint-plugin-import": "^2.26.0",
                     "eslint-plugin-n": "^15.2.0",
                     "eslint-plugin-promise": "^6.0.0",
                     "eslint-plugin-react": "^7.29.4",
                     "requirejs": "2.3.6",
                     "typescript": "4.8.3",
                     "yaml": "~1.7.2",
                     "tap": "16.3.0"
                 }
             }

djx/src/main/ts/observable.ts +133 -51

+            import { PromiseOrValue } from "@implab/core-amd/interfaces";
+            import { isPromise } from "@implab/core-amd/safe";
             /**
              * The interface for the consumer of an observable sequence
              */
             export interface Observer<T> {
                 /**
                  * Called for the next element in the sequence
                  */
                 next: (value: T) => void;
                 /**
                  * Called once when the error occurs in the sequence.
                  */
                 error: (e: unknown) => void;
                 /**
                  * Called once at the end of the sequence.
                  */
                 complete: () => void;
             }
             /**
-             * The group of functions to feed an observable. This methods are provided to
+             * The group of functions to feed an observable. These methods are provided to
              * the producer to generate a stream of events.
              */
             export type Sink<T> = {
-                [k in keyof Observer<T>]: (this: void, ...args: Parameters<Observer<T>[k]>) => void;
+                /**
+                 * Call to send the next element in the sequence
+                 */
+                 next: (value: T) => void;
+                 /**
+                  * Call to notify about the error occurred in the sequence.
+                  */
+                 error: (e: unknown) => void;
+                 /**
+                  * Call to signal the end of the sequence.
+                  */
+                 complete: () => void;
+                 /**
+                  * Checks whether the sink is accepting new elements. It's safe to
+                  * send elements to the closed sink.
+                  */
+                 isClosed: () => boolean;
             };
             export type Producer<T> = (sink: Sink<T>) => (void | (() => void));
             export interface Unsubscribable {
                 unsubscribe(): void;
             }
             export const isUnsubsribable = (v: unknown): v is Unsubscribable =>
                 v !== null && v !== undefined && typeof (v as Unsubscribable).unsubscribe === "function";
             export const isSubsribable = <T = unknown>(v: unknown): v is Subscribable<T> =>
                 v !== null && v !== undefined && typeof (v as Subscribable<unknown>).subscribe === "function";
             export interface Subscribable<T> {
                 subscribe(consumer: Partial<Observer<T>>): Unsubscribable;
             }
             /** The observable source of items. */
             export interface Observable<T> extends Subscribable<T> {
                 /** Transforms elements of the sequence with the specified mapper
                  *
                  * @param mapper The mapper used to transform the values
                  */
                 map<T2>(mapper: (value: T) => T2): Observable<T2>;
                 /** Filters elements of the sequence. The resulting sequence will
                  * contain only elements which match the specified predicate.
                  *
                  * @param predicate The filter predicate.
                  */
                 filter(predicate: (value: T) => boolean): Observable<T>;
                 /** Applies accumulator to each value in the sequence and
                  * emits the accumulated value for each source element
                  *
                  * @param accumulator
                  * @param initial
                  */
                 scan<A>(accumulator: (acc: A, value: T) => A, initial: A): Observable<A>;
+                cat(...seq: Subscribable<T>[]): Observable<T>;
             }
             const noop = () => { };
             const sink = <T>(consumer: Partial<Observer<T>>) => {
                 const { next, error, complete } = consumer;
                 return {
                     next: next ? next.bind(consumer) : noop,
                     error: error ? error.bind(consumer) : noop,
-                    complete: complete ? complete.bind(consumer) : noop
+                    complete: complete ? complete.bind(consumer) : noop,
+                    isClosed: () => false
                 };
             };
-            const fuse = <T>({ next, error, complete }: Sink<T>) => {
+            /** Wraps the producer to handle tear down logic and subscription management
+             *
+             * @param producer The producer to wrap
+             * @returns The wrapper producer
+             */
+            const fuse = <T>(producer: Producer<T>) => ({ next, error, complete }: Sink<T>) => {
                 let done = false;
-                return {
+                let cleanup = noop;
+                const _fin = <A extends unknown[]>(fn: (...args: A) => void) =>
+                    (...args: A) => done ?
+                        void (0) :
+                        (done = true, cleanup(), fn(...args));
+                const safeSink = {
                     next: (value: T) => { !done && next(value); },
-                    error: (e: unknown) => { !done && (done = true, error(e)); },
+                    error: _fin(error),
-                    complete: () => { !done && (done = true, complete()); }
+                    complete: _fin(complete),
+                    isClosed: () => done
                 };
+                cleanup = producer(safeSink) ?? noop;
+                return done ?
+                    (cleanup(), noop) :
+                    _fin(noop);
             };
             const _observe = <T>(producer: Producer<T>): Observable<T> => ({
                 subscribe: (consumer: Partial<Observer<T>>) => ({
                     unsubscribe: producer(sink(consumer)) ?? noop
                 }),
-                map: (mapper) => _observe(({ next, error, complete }) =>
+                map: (mapper) => _observe(({ next, ...rest }) =>
                     producer({
                         next: next !== noop ? (v: T) => next(mapper(v)) : noop,
-                        error,
+                        ...rest
-                        complete
+                    })
+                ),
+                filter: (predicate) => _observe(({ next, ...rest }) =>
+                    producer({
+                        next: next !== noop ? (v: T) => predicate(v) ? next(v) : void (0) : noop,
+                        ...rest
                     })
                 ),
-                filter: (predicate) => _observe(({ next, error, complete }) =>
+                scan: (accumulator, initial) => _observe(({ next, ...rest }) => {
-                    producer({
-                        next: next !== noop ?
-                            (v: T) => predicate(v) ? next(v) : void (0) : noop,
-                        error,
-                        complete
-                    })
-                ),
-                scan: (accumulator, initial) => _observe(({ next, error, complete }) => {
                     let _acc = initial;
                     return producer({
-                        next: next !== noop ?
+                        next: next !== noop ? (v: T) => next(_acc = accumulator(_acc, v)) : noop,
-                            (v: T) => next(_acc = accumulator(_acc, v)) : noop,
+                        ...rest
-                        error,
-                        complete
                     });
+                }),
+                cat: (...seq) => _observe(({ next, complete: final, ...rest }) => {
+                    let cleanup: () => void;
+                    const complete = () => {
+                        const continuation = seq.shift();
+                        if (continuation) {
+                            // if we have a next sequence, subscribe to it
+                            const subscription = continuation.subscribe({ next, complete, ...rest });
+                            cleanup = subscription.unsubscribe.bind(subscription);
+                        } else {
+                            // otherwise notify the consumer about completion
+                            final();
+                        }
+                    };
+                    cleanup = producer({ next, complete, ...rest }) ?? noop;
+                    return () => cleanup();
                 })
             });
-            export const observe = <T>(producer: Producer<T>): Observable<T> => ({
+            export interface OrderUpdate<T> {
-                subscribe: (consumer: Partial<Observer<T>>) => ({
+                /** The item is being updated */
-                    unsubscribe: producer(fuse(sink(consumer))) ?? noop
+                item: T;
-                }),
-                map: (mapper) => _observe(({ next, error, complete }) =>
+                /** The previous index of the item, -1 in case it is inserted */
-                    producer(fuse({
+                prevIndex: number;
-                        next: next !== noop ?
-                            (v: T) => next(mapper(v)) : noop,
+                /** The new index of the item, -1 in case it is deleted */
-                        error,
+                newIndex: number;
-                        complete
-                    }))
-                ),
+            interface ObservableResults<T> {
-                filter: (predicate) => _observe(({ next, error, complete }) =>
+                /**
-                    producer(fuse({
+                 * Allows observation of results
-                        next: next !== noop ?
+                 */
-                            (v: T) => predicate(v) ? next(v) : void (0) : noop,
+                observe(listener: (object: T, previousIndex: number, newIndex: number) => void, includeUpdates?: boolean): {
-                        error,
+                    remove(): void;
-                        complete
+                };
-                    }))
-                ),
-                scan: (accumulator, initial) => observe(({ next, error, complete }) => {
+            interface Queryable<T, A extends unknown[]> {
-                    let _acc = initial;
+                query(...args: A): PromiseOrValue<T[]>;
-                    return producer(fuse({
-                        next: next !== noop ? (v: T) => next(_acc = accumulator(_acc, v)) : noop,
-                        error,
+            export const isObservableResults = <T>(v: object): v is ObservableResults<T> =>
-                        complete
+                v && (typeof (v as { observe?: unknown; }).observe === "function");
-                    }));
-                })
+            export const observe = <T>(producer: Producer<T>) => _observe(fuse(producer));
+            export const empty = observe<never>(({ complete }) => complete());
+            export const query = <T, A extends unknown[]>(store: Queryable<T, A>) =>
+                (...args: A) => {
+                    return observe<OrderUpdate<T>>(({ next, complete, error }) => {
+                        try {
+                            const results = store.query(...args);
+                            if (isPromise(results)) {
+                                results.then(items => items.forEach((item, newIndex) => next({ item, newIndex, prevIndex: -1 })))
+                                    .then(undefined, error);
+                            } else {
+                                results.forEach((item, newIndex) => next({ item, newIndex, prevIndex: -1 }));
+                            }
+                            if (isObservableResults<T>(results)) {
+                                const h = results.observe((item, prevIndex, newIndex) => next({ item, prevIndex, newIndex }));
+                                return () => h.remove();
+                            } else {
+                                complete();
+                            }
+                        } catch (err) {
+                            error(err);
+                        }
                     });
+                };

djx/src/main/ts/tsx.ts +2 -13

             import { Constructor } from "@implab/core-amd/interfaces";
             import { HtmlRendition } from "./tsx/HtmlRendition";
             import { WidgetRendition } from "./tsx/WidgetRendition";
             import { isElementNode, isWidget, isWidgetConstructor, Rendition } from "./tsx/traits";
             import { FunctionRendition } from "./tsx/FunctionRendition";
             import Stateful = require("dojo/Stateful");
             import _WidgetBase = require("dijit/_WidgetBase");
             import { DjxWidgetBase } from "./tsx/DjxWidgetBase";
             import { WatchRendition } from "./tsx/WatchRendition";
-            import { Observable, observe, Subscribable } from "./observable";
+            import { Observable, observe, OrderUpdate, Subscribable } from "./observable";
             import djAttr = require("dojo/dom-attr");
             import djClass = require("dojo/dom-class");
             import { AnimationAttrs, WatchForRendition } from "./tsx/WatchForRendition";
             export function createElement<T extends Constructor | string | ((props: object) => Element)>(elementType: T, ...args: unknown[]): Rendition {
                 if (typeof elementType === "string") {
                     const ctx = new HtmlRendition(elementType);
                     if (args)
                         args.forEach(x => ctx.visitNext(x));
                     return ctx;
                 } else if (isWidgetConstructor(elementType)) {
                     const ctx = new WidgetRendition(elementType);
                     if (args)
                         args.forEach(x => ctx.visitNext(x));
                     return ctx;
                 } else if (typeof elementType === "function") {
                     const ctx = new FunctionRendition(elementType as (props: unknown) => Element);
                     if (args)
                         args.forEach(x => ctx.visitNext(x));
                     return ctx;
                 } else {
                     throw new Error(`The element type '${String(elementType)}' is unsupported`);
                 }
             }
             export interface EventDetails<T = unknown> {
                 detail: T;
             }
             export interface EventSelector {
                 selectorTarget: HTMLElement;
                 target: HTMLElement;
             }
-            export interface QueryResultUpdate<T> {
-                /** The item is being updated */
-                item: T;
-                /** The previous index of the item, -1 in case it is inserted */
-                prevIndex: number;
-                /** The new index of the item, -1 in case it is deleted */
-                newIndex: number;
             export type DojoMouseEvent<T = unknown> = MouseEvent & EventSelector & EventDetails<T>;
             type StatefulProps<T> = T extends Stateful<infer A> ? A :
                 T extends _WidgetBase ? T : never;
             /**
              * Observers the property and calls render callback each change.
              *
              * @param target The target object which property will be observed.
              * @param prop The name of the property.
              * @param render The callback which will be called every time the value is changed
              * @returns Rendition which is created instantly
              */
             export function watch<W extends _WidgetBase, K extends keyof W>(
                 target: W,
                 prop: K,
                 render: (model: W[K]) => unknown
             ): Rendition;
             /**
              * Observers the property and calls render callback each change.
              *
              * @param target The target object which property will be observed.
              * @param prop The name of the property.
              * @param render The callback which will be called every time the value is changed
              * @returns Rendition which is created instantly
              */
             export function watch<T extends Stateful, K extends keyof StatefulProps<T>>(
                 target: T,
                 prop: K,
                 render: (model: StatefulProps<T>[K]) => unknown
             ): Rendition;
             export function watch<V>(subj: Subscribable<V>, render: (model: V) => unknown): Rendition;
             export function watch(
                 ...args: [Stateful, string, (model: unknown) => unknown] |
                     [Subscribable<unknown>, (model: unknown) => unknown]
             ) {
                 if (args.length === 3) {
                     const [target, prop, render] = args;
                     return new WatchRendition(
                         render,
                         observe(({next}) => {
                             const h = target.watch(
                                 prop,
                                 (_prop, oldValue, newValue) => oldValue !== newValue && next(newValue)
                             );
                             next(target.get(prop));
                             return () => h.remove();
                         })
                     );
                 } else {
                     const [subj, render] = args;
                     return new WatchRendition(render, subj);
                 }
             }
-            export const watchFor = <T>(source: T[] | Subscribable<QueryResultUpdate<T>>, render: (item: T, index: number) => unknown, opts:  AnimationAttrs = {}) => {
+            export const watchFor = <T>(source: T[] | Subscribable<OrderUpdate<T>>, render: (item: T, index: number) => unknown, opts:  AnimationAttrs = {}) => {
                 return new WatchForRendition({
                     ...opts,
                     subject: source,
                     component: render
                 });
             };
             export const prop: {
                 <T extends Stateful, K extends string & keyof StatefulProps<T>>(target: T, name: K): Observable<StatefulProps<T>[K]>;
                 <T extends _WidgetBase, K extends keyof T>(target: T, name: K): Observable<T[K]>;
             } = (target: Stateful, name: string) => {
                 return observe(({next}) => {
                     const h = target.watch(
                         name,
                         (_prop, oldValue, newValue) => oldValue !== newValue && next(newValue)
                     );
                     next(target.get(name));
                     return () => h.remove();
                 });
             };
             export const attach = <W extends DjxWidgetBase, K extends keyof W>(target: W, name: K) => (v: W[K]) => target.set(name, v);
             export const bind = <K extends string, T>(attr: K, subj: Subscribable<T>) => {
                 let h = { unsubscribe() { } };
                 return (el: Element | { set(name: K, value: T): void; } | undefined) => {
                     if (el) {
                         if (isElementNode(el)) {
                             h = subj.subscribe({
                                 next: value => djAttr.set(el, attr, value)
                             });
                         } else {
                             h = subj.subscribe({
                                 next: value => el.set(attr, value)
                             });
                         }
                     } else {
                         h.unsubscribe();
                     }
                 };
             };
             export const toggleClass = (className: string, subj: Subscribable<boolean>) => {
                 let h = { unsubscribe() { } };
                 return (elOrWidget: HTMLElement | _WidgetBase | undefined) => {
                     const el = isWidget(elOrWidget) ? elOrWidget.domNode : elOrWidget;
                     if (el) {
                         h = subj.subscribe({
                             next: v => djClass.toggle(el, className, v)
                         });
                     } else {
                         h.unsubscribe();
                     }
                 };
             };
             export const all = <T, A extends JSX.Ref<T>[]>(...cbs: A): JSX.Ref<T> => (arg: T | undefined) => cbs.forEach(cb => cb(arg));
             /** Decorates the method which will be registered as the handle for the specified event.
              * This decorator can be applied to DjxWidgetBase subclass methods.
              *
              * ```
              *  @on("click")
              *  _onClick(eventObj: MouseEvent) {
              *      // ...
              *  }
              * ```
              */
             export const on = <E extends string>(...eventNames: E[]) =>
                 <K extends string,
                     T extends DjxWidgetBase<object, { [p in E]: EV }>,
                     EV extends Event
                 >(
                     target: T,
                     key: K,
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
                     _descriptor: TypedPropertyDescriptor<(eventObj: EV) => void> | TypedPropertyDescriptor<() => void>
                 ) => {
                     const handlers = eventNames.map(eventName => ({ eventName, handlerMethod: key }));
                     target._eventHandlers = target._eventHandlers ? target._eventHandlers.concat(handlers) : handlers;
                 };

djx/src/main/ts/tsx/WatchForRendition.ts +6 -18

             import { id as mid } from "module";
             import { TraceSource } from "@implab/core-amd/log/TraceSource";
             import { argumentNotNull } from "@implab/core-amd/safe";
             import { getScope, render } from "./render";
             import { RenditionBase } from "./RenditionBase";
             import { Scope } from "./Scope";
             import { Cancellation } from "@implab/core-amd/Cancellation";
             import { collectNodes, destroy as safeDestroy, isDocumentFragmentNode, isElementNode, isMounted, placeAt, startupWidgets } from "./traits";
             import { IDestroyable } from "@implab/core-amd/interfaces";
             import { play } from "../play";
             import * as fx from "dojo/fx";
-            import { isSubsribable, Subscribable } from "../observable";
+            import { isObservableResults, isSubsribable, OrderUpdate, Subscribable } from "../observable";
-            import { QueryResultUpdate } from "../tsx";
             const trace = TraceSource.get(mid);
             interface ItemRendition {
                 nodes: Node[];
                 scope: IDestroyable;
                 destroy(): void;
             }
-            interface ObservableResults<T> {
+            interface RenderTask<T> extends OrderUpdate<T> {
-                /**
-                 * Allows observation of results
-                 */
-                observe(listener: (object: T, previousIndex: number, newIndex: number) => void, includeUpdates?: boolean): {
-                    remove(): void;
-                };
-            interface RenderTask<T> extends QueryResultUpdate<T> {
                 animate: boolean;
             }
             export interface AnimationAttrs {
                 animate?: boolean;
                 animateIn?: (nodes: Node[]) => Promise<void>;
                 animateOut?: (nodes: Node[]) => Promise<void>;
             }
             export interface WatchForRenditionAttrs<T> extends AnimationAttrs {
-                subject: T[] | Subscribable<QueryResultUpdate<T>>;
+                subject: T[] | Subscribable<OrderUpdate<T>>;
                 component: (arg: T, index: number) => unknown;
             }
-            const isObservable = <T>(v: ArrayLike<T>): v is ArrayLike<T> & ObservableResults<T> =>
-                v && (typeof (v as { observe?: unknown; }).observe === "function");
             const noop = () => { };
             const fadeIn = (nodes: Node[]) => Promise.all(nodes
                 .filter(isElementNode)
                 .map(el => play(fx.fadeIn({ node: el as HTMLElement })))
             ).then(noop);
             const fadeOut = (nodes: Node[]) => Promise.all(nodes
                 .filter(isElementNode)
                 .map(el => play(fx.fadeOut({ node: el as HTMLElement })))
             ).then(noop);
             export class WatchForRendition<T> extends RenditionBase<Node> {
                 private readonly _component: (arg: T, index: number) => unknown;
                 private readonly _node: Node;
                 private readonly _itemRenditions: ItemRendition[] = [];
-                private readonly _subject: T[] | Subscribable<QueryResultUpdate<T>>;
+                private readonly _subject: T[] | Subscribable<OrderUpdate<T>>;
                 private readonly _renderTasks: RenderTask<T>[] = [];
                 private readonly _animate: boolean;
                 private readonly _animateIn: (nodes: Node[]) => Promise<void>;
                 private readonly _animateOut: (nodes: Node[]) => Promise<void>;
                 private _ct = Cancellation.none;
                 constructor({ subject, component, animate, animateIn, animateOut }: WatchForRenditionAttrs<T>) {
                     super();
                     argumentNotNull(component, "component");
                     argumentNotNull(subject, "component");
                     this._component = component;
                     this._subject = subject;
                     this._node = document.createComment("[WatchFor]");
                     this._animate = !!animate;
                     this._animateIn = animateIn ?? fadeIn;
                     this._animateOut = animateOut ?? fadeOut;
                 }
                 protected _create() {
                     const scope = getScope();
                     scope.own(() => {
                         this._itemRenditions.forEach(safeDestroy);
                         safeDestroy(this._node);
                     });
                     const result = this._subject;
                     if (result) {
-                        if (isSubsribable<QueryResultUpdate<T>>(result)) {
+                        if (isSubsribable<OrderUpdate<T>>(result)) {
                             let animate = false;
                             const subscription = result.subscribe({
                                 next: ({ item, prevIndex, newIndex }) => this._onItemUpdated({ item, prevIndex, newIndex, animate })
                             });
                             scope.own(subscription);
                             animate = this._animate;
                         } else {
-                            if (isObservable(result))
+                            if (isObservableResults<T>(result))
                                 scope.own(result.observe((item, prevIndex, newIndex) => this._onItemUpdated({ item, prevIndex, newIndex, animate: false }), true));
                             for (let i = 0, n = result.length; i < n; i++)
                                 this._onItemUpdated({ item: result[i], prevIndex: -1, newIndex: i, animate: this._animate });
                         }
                     }
                     this._ct = new Cancellation(cancel => scope.own(cancel));
                 }
                 private readonly _onItemUpdated = (item: RenderTask<T>) => {
                     if (!this._renderTasks.length) {
                         // schedule a new job
                         this._renderTasks.push(item);
                         this._render().catch(e => trace.error(e));
                     } else {
                         // update existing job
                         this._renderTasks.push(item);
                     }
                 };
                 private async _render() {
                     // fork
                     await Promise.resolve();
                     // don't render destroyed rendition
                     if (this._ct.isRequested())
                         return;
                     this._renderTasks.forEach(this._onRenderItem);
                     this._renderTasks.length = 0;
                 }
                 private readonly _onRenderItem = ({ item, newIndex, prevIndex, animate: _animate }: RenderTask<T>) => {
                     const animate = _animate && prevIndex !== newIndex;
                     if (prevIndex > -1) {
                         // if we need to delete previous rendition
                         const [{ nodes, destroy }] = this._itemRenditions.splice(prevIndex, 1);
                         if (animate) {
                             this._animateOut(nodes)
                                 .then(destroy)
                                 .catch(e => trace.error(e));
                         } else {
                             destroy();
                         }
                     }
                     if (newIndex > -1) {
                         // if we need to create the new rendition
                         // 1. create a new scope for rendering a content
                         const scope = new Scope();
                         // 2. render the content
                         const itemNode = render(this._component(item, newIndex), scope);
                         // 3. track nodes
                         const nodes = isDocumentFragmentNode(itemNode) ?
                             collectNodes(itemNode.childNodes) :
                             [itemNode];
                         // 5. insert node at the correct position
                         const { nodes: [beforeNode] } = this._itemRenditions[newIndex] ?? { nodes: [] };
                         if (beforeNode)
                             placeAt(itemNode, beforeNode, "before");
                         else
                             placeAt(itemNode, this._node, "before");
                         // 6. store information about rendition
                         this._itemRenditions.splice(newIndex, 0, {
                             scope,
                             nodes,
                             destroy: () => {
                                 scope.destroy();
                                 nodes.forEach(safeDestroy);
                             }
                         });
                         // 7. startup widgets if needed
                         if (isMounted(this._node))
                             nodes.forEach(n => startupWidgets(n));
                         // 8. optionally play the animation
                         if (animate)
                             this._animateIn(nodes).catch(e => trace.error(e));
                     }
                 };
                 protected _getDomNode() {
                     if (!this._node)
                         throw new Error("The instance of the widget isn't created");
                     return this._node;
                 }
             }

djx/src/test/ts/observable-tests.ts +1 -1

             import { observe } from "./observable";
             import * as t from "tap";
             const subj1 = observe<number>(({ next, complete }) => {
                 next(1);
                 complete();
                 next(2);
             });
             const consumer1 = {
                 sum: 0,
                 next(v: number) {
                     this.sum += v;
                 }
             };
             subj1.subscribe(consumer1);
             t.equal(consumer1.sum, 1, "Should get only one value");
             subj1.subscribe(consumer1);
             t.equal(consumer1.sum, 2, "Should get the value again");
             const consumer2 = {
                 value: 0,
                 completed: false,
                 next(v: number) { this.value = v; },
                 complete() { this.completed = true; }
             };
             let maps = 0;
             subj1
                 .map(v => {
                     t.comment(`map1: ${v * 2}`);
                     maps++;
                     return v * 2;
                 })
                 .map (v => {
                     t.comment(`map2: ${v * 2}`);
                     maps++;
                     return v * 2;
                 })
                 .map(v => {
                     t.comment(`map3: ${v * 2}`);
                     maps++;
                     return v * 2;
                 })
                 .subscribe(consumer2);
             t.equal(consumer2.value, 8, "Should map");
             t.equal(maps, 3, "The map chain should not be executed after completion");
-            t.ok(consumer2.completed, "The completion signal should pass through");
  No newline at end of file
+            t.ok(consumer2.completed, "The completion signal should pass through");

playground/build.gradle 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

playground/package-lock.json 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

playground/package.json 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

playground/src/bundle/config.js 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

playground/src/main/ts/main.ts 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

playground/src/main/ts/model/Appointment.ts 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

playground/src/main/ts/model/MainContext.ts 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

playground/src/main/ts/model/MainModel.ts 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

playground/src/main/ts/view/MainWidget.tsx 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

playground/src/tsconfig.json 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

djx/src/main/ts/store/Observable.ts removed 0 -3

NO CONTENT: file was removed

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages