reactronic 0.23.115 → 0.24.101

package/build/dist/source/RxNode.d.ts

@@ -0,0 +1,59 @@
+import { MergeListReader, MergedItem } from './util/MergeList.js';
+import { MemberOptions } from './Options.js';
+export type Delegate<T> = (element: T, base: () => void) => void;
+export type SimpleDelegate<T = unknown, R = void> = (element: T) => R;
+export declare enum Mode {
+    Default = 0,
+    PinpointUpdate = 1,
+    ManualMount = 2
+}
+export declare const enum Priority {
+    Realtime = 0,
+    Normal = 1,
+    Background = 2
+}
+export declare abstract class RxNode<T = any> {
+    abstract readonly key: string;
+    abstract readonly driver: RxNodeDriver<T>;
+    abstract readonly declaration: Readonly<RxNodeDecl<T>>;
+    abstract readonly level: number;
+    abstract readonly owner: RxNode;
+    abstract readonly element: T;
+    abstract readonly host: RxNode;
+    abstract readonly children: MergeListReader<RxNode>;
+    abstract readonly slot: MergedItem<RxNode<T>> | undefined;
+    abstract readonly stamp: number;
+    abstract readonly outer: RxNode;
+    abstract readonly context: RxNodeContext | undefined;
+    abstract readonly isInitialUpdate: boolean;
+    abstract priority?: Priority;
+    abstract childrenShuffling: boolean;
+    abstract strictOrder: boolean;
+    abstract has(mode: Mode): boolean;
+    abstract configureReactronic(options: Partial<MemberOptions>): MemberOptions;
+}
+export interface RxNodeDecl<T = unknown> {
+    preset?: RxNodeDecl<T>;
+    key?: string;
+    mode?: Mode;
+    triggers?: unknown;
+    specify?: Delegate<T>;
+    create?: Delegate<T>;
+    initialize?: Delegate<T>;
+    update?: Delegate<T>;
+    finalize?: Delegate<T>;
+}
+export interface RxNodeDriver<T> {
+    readonly name: string;
+    readonly isPartitionSeparator: boolean;
+    readonly predefine?: SimpleDelegate<T>;
+    allocate(node: RxNode<T>): T;
+    assign(element: T): void;
+    initialize(element: T): void;
+    mount(element: T): void;
+    update(element: T): void | Promise<void>;
+    finalize(element: T, isLeader: boolean): boolean;
+}
+export interface RxNodeContext<T extends Object = Object> {
+    value: T;
+}

package/build/dist/source/RxNode.js

@@ -0,0 +1,14 @@
+export var Mode;
+(function (Mode) {
+    Mode[Mode["Default"] = 0] = "Default";
+    Mode[Mode["PinpointUpdate"] = 1] = "PinpointUpdate";
+    Mode[Mode["ManualMount"] = 2] = "ManualMount";
+})(Mode || (Mode = {}));
+export var Priority;
+(function (Priority) {
+    Priority[Priority["Realtime"] = 0] = "Realtime";
+    Priority[Priority["Normal"] = 1] = "Normal";
+    Priority[Priority["Background"] = 2] = "Background";
+})(Priority || (Priority = {}));
+export class RxNode {
+}

package/build/dist/source/RxNodeImpl.d.ts

@@ -0,0 +1,39 @@
+import { LoggingOptions } from './Logging.js';
+import { Priority, RxNodeDecl, RxNodeDriver, SimpleDelegate, RxNode } from './RxNode.js';
+export declare class RxTree {
+    static readonly shortFrameDuration = 16;
+    static readonly longFrameDuration = 300;
+    static currentUpdatePriority: Priority;
+    static frameDuration: number;
+    static declare<T = undefined>(driver: RxNodeDriver<T>, declaration?: RxNodeDecl<T>, preset?: RxNodeDecl<T>): T;
+    static triggerUpdate(element: {
+        node: RxNode;
+    }, triggers: unknown): void;
+    static updateNestedTreesThenDo(action: (error: unknown) => void): void;
+    static findMatchingHost<T, R>(node: RxNode<T>, match: SimpleDelegate<RxNode<T>, boolean>): RxNode<R> | undefined;
+    static findMatchingPrevSibling<T, R>(node: RxNode<T>, match: SimpleDelegate<RxNode<T>, boolean>): RxNode<R> | undefined;
+    static forEachChildRecursively<T>(node: RxNode<T>, action: SimpleDelegate<RxNode<T>>): void;
+    static getDefaultLoggingOptions(): LoggingOptions | undefined;
+    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
+}
+export declare abstract class BaseDriver<T extends {
+    node: RxNode;
+}> implements RxNodeDriver<T> {
+    readonly name: string;
+    readonly isPartitionSeparator: boolean;
+    readonly predefine?: SimpleDelegate<T> | undefined;
+    constructor(name: string, isPartitionSeparator: boolean, predefine?: SimpleDelegate<T> | undefined);
+    abstract allocate(node: RxNode<T>): T;
+    assign(element: T): void;
+    initialize(element: T): void;
+    mount(element: T): void;
+    update(element: T): void | Promise<void>;
+    finalize(element: T, isLeader: boolean): boolean;
+}
+export declare class RxNodeVariable<T extends Object = Object> {
+    readonly defaultValue: T | undefined;
+    constructor(defaultValue?: T);
+    set value(value: T);
+    get value(): T;
+    get valueOrUndefined(): T | undefined;
+}

package/build/dist/source/RxNodeImpl.js

@@ -0,0 +1,594 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { MergeList } from './util/MergeList.js';
+import { Priority, Mode } from './RxNode.js';
+import { emitLetters, getCallerInfo } from './util/RxNodeUtils.js';
+import { Reentrance } from './Options.js';
+import { ObservableObject } from './impl/Mvcc.js';
+import { Transaction } from './impl/Transaction.js';
+import { Rx, options, raw, reactive, unobs } from './Rx.js';
+export class RxTree {
+    static declare(driver, declaration, preset) {
+        var _a;
+        let result;
+        if (declaration)
+            declaration.preset = preset;
+        else
+            declaration = preset !== null && preset !== void 0 ? preset : {};
+        let key = declaration.key;
+        const owner = gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance;
+        if (owner) {
+            let existing = undefined;
+            const children = owner.children;
+            if (driver.isPartitionSeparator) {
+                const last = children.lastMergedItem();
+                if (((_a = last === null || last === void 0 ? void 0 : last.instance) === null || _a === void 0 ? void 0 : _a.driver) === driver)
+                    existing = last;
+            }
+            existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(key = key || generateKey(owner), undefined, 'nested elements can be declared inside update function only'));
+            if (existing) {
+                const node = existing.instance;
+                result = node.element;
+                if (node.driver !== driver && driver !== undefined)
+                    throw new Error(`changing element driver is not yet supported: "${node.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
+                const exTriggers = node.declaration.triggers;
+                if (triggersAreEqual(declaration.triggers, exTriggers))
+                    declaration.triggers = exTriggers;
+                node.declaration = declaration;
+            }
+            else {
+                const node = new RxNodeImpl(key || generateKey(owner), driver, declaration, owner);
+                node.slot = children.mergeAsAdded(node);
+                result = node.element;
+            }
+        }
+        else {
+            const node = new RxNodeImpl(key || '', driver, declaration, owner);
+            node.slot = MergeList.createItem(node);
+            result = node.element;
+            triggerUpdate(node.slot);
+        }
+        return result;
+    }
+    static triggerUpdate(element, triggers) {
+        const el = element;
+        const declaration = el.node.declaration;
+        if (!triggersAreEqual(triggers, declaration.triggers)) {
+            declaration.triggers = triggers;
+            triggerUpdate(el.node.slot);
+        }
+    }
+    static updateNestedTreesThenDo(action) {
+        runUpdateNestedTreesThenDo(undefined, action);
+    }
+    static findMatchingHost(node, match) {
+        let p = node.host;
+        while (p !== p.host && !match(p))
+            p = p.host;
+        return p;
+    }
+    static findMatchingPrevSibling(node, match) {
+        let p = node.slot.prev;
+        while (p && !match(p.instance))
+            p = p.prev;
+        return p === null || p === void 0 ? void 0 : p.instance;
+    }
+    static forEachChildRecursively(node, action) {
+        action(node);
+        for (const child of node.children.items())
+            RxTree.forEachChildRecursively(child.instance, action);
+    }
+    static getDefaultLoggingOptions() {
+        return RxNodeImpl.logging;
+    }
+    static setDefaultLoggingOptions(logging) {
+        RxNodeImpl.logging = logging;
+    }
+}
+RxTree.shortFrameDuration = 16;
+RxTree.longFrameDuration = 300;
+RxTree.currentUpdatePriority = Priority.Realtime;
+RxTree.frameDuration = RxTree.longFrameDuration;
+export class BaseDriver {
+    constructor(name, isPartitionSeparator, predefine) {
+        this.name = name;
+        this.isPartitionSeparator = isPartitionSeparator;
+        this.predefine = predefine;
+    }
+    assign(element) {
+        assignViaPresetChain(element, element.node.declaration);
+    }
+    initialize(element) {
+        var _a;
+        (_a = this.predefine) === null || _a === void 0 ? void 0 : _a.call(this, element);
+        initializeViaPresetChain(element, element.node.declaration);
+    }
+    mount(element) {
+    }
+    update(element) {
+        updateViaPresetChain(element, element.node.declaration);
+    }
+    finalize(element, isLeader) {
+        finalizeViaPresetChain(element, element.node.declaration);
+        return isLeader;
+    }
+}
+export class RxNodeVariable {
+    constructor(defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+    set value(value) {
+        RxNodeImpl.setNodeVariableValue(this, value);
+    }
+    get value() {
+        return RxNodeImpl.useNodeVariableValue(this);
+    }
+    get valueOrUndefined() {
+        return RxNodeImpl.tryUseNodeVariableValue(this);
+    }
+}
+function generateKey(owner) {
+    const n = owner.numerator++;
+    const lettered = emitLetters(n);
+    let result;
+    if (Rx.isLogging)
+        result = `·${getCallerInfo(lettered)}`;
+    else
+        result = `·${lettered}`;
+    return result;
+}
+function getModeViaPresetChain(declaration) {
+    var _a;
+    return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.preset) ? getModeViaPresetChain(declaration === null || declaration === void 0 ? void 0 : declaration.preset) : Mode.Default);
+}
+function assignViaPresetChain(element, declaration) {
+    const preset = declaration.preset;
+    const create = declaration.create;
+    if (create)
+        create(element, preset ? () => assignViaPresetChain(element, preset) : NOP);
+    else if (preset)
+        assignViaPresetChain(element, preset);
+}
+function initializeViaPresetChain(element, declaration) {
+    const preset = declaration.preset;
+    const initialize = declaration.initialize;
+    if (initialize)
+        initialize(element, preset ? () => initializeViaPresetChain(element, preset) : NOP);
+    else if (preset)
+        initializeViaPresetChain(element, preset);
+}
+function updateViaPresetChain(element, declaration) {
+    const preset = declaration.preset;
+    const update = declaration.update;
+    if (update)
+        update(element, preset ? () => updateViaPresetChain(element, preset) : NOP);
+    else if (preset)
+        updateViaPresetChain(element, preset);
+}
+function finalizeViaPresetChain(element, declaration) {
+    const preset = declaration.preset;
+    const finalize = declaration.finalize;
+    if (finalize)
+        finalize(element, preset ? () => finalizeViaPresetChain(element, preset) : NOP);
+    else if (preset)
+        finalizeViaPresetChain(element, preset);
+}
+class RxNodeContextImpl extends ObservableObject {
+    constructor(variable, value) {
+        super();
+        this.next = undefined;
+        this.variable = variable;
+        this.value = value;
+    }
+}
+__decorate([
+    raw,
+    __metadata("design:type", Object)
+], RxNodeContextImpl.prototype, "next", void 0);
+__decorate([
+    raw,
+    __metadata("design:type", RxNodeVariable)
+], RxNodeContextImpl.prototype, "variable", void 0);
+class RxNodeImpl {
+    constructor(key, driver, declaration, owner) {
+        this.key = key;
+        this.driver = driver;
+        this.declaration = declaration;
+        if (owner) {
+            const node = owner;
+            this.level = node.level + 1;
+            this.owner = owner;
+            this.outer = node.context ? owner : node.outer;
+        }
+        else {
+            this.level = 1;
+            this.owner = owner = this;
+            this.outer = this;
+        }
+        this.element = driver.allocate(this);
+        this.host = this;
+        this.children = new MergeList(getNodeKey, true);
+        this.slot = undefined;
+        this.stamp = Number.MAX_SAFE_INTEGER;
+        this.context = undefined;
+        this.numerator = 0;
+        this.priority = Priority.Realtime;
+        this.childrenShuffling = false;
+        RxNodeImpl.grandNodeCount++;
+        if (this.has(Mode.PinpointUpdate))
+            RxNodeImpl.disposableNodeCount++;
+    }
+    get isInitialUpdate() { return this.stamp === 1; }
+    get strictOrder() { return this.children.isStrict; }
+    set strictOrder(value) { this.children.isStrict = value; }
+    get isMoved() { return this.owner.children.isMoved(this.slot); }
+    has(mode) {
+        return (getModeViaPresetChain(this.declaration) & mode) === mode;
+    }
+    update(_triggers) {
+        updateNow(this.slot);
+    }
+    configureReactronic(options) {
+        if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.PinpointUpdate))
+            throw new Error('reactronic can be configured only for elements with pinpoint update mode and only inside initialize');
+        return Rx.getReaction(this.update).configure(options);
+    }
+    static get current() {
+        if (!gCurrent)
+            throw new Error('current element is undefined');
+        return gCurrent;
+    }
+    static tryUseNodeVariableValue(variable) {
+        var _a, _b;
+        let node = RxNodeImpl.current.instance;
+        while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
+            node = node.outer.slot.instance;
+        return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
+    }
+    static useNodeVariableValue(variable) {
+        var _a;
+        const result = (_a = RxNodeImpl.tryUseNodeVariableValue(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
+        if (!result)
+            throw new Error('unknown node variable');
+        return result;
+    }
+    static setNodeVariableValue(variable, value) {
+        const node = RxNodeImpl.current.instance;
+        const owner = node.owner;
+        const hostCtx = unobs(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
+        if (value && value !== hostCtx) {
+            if (hostCtx)
+                node.outer = owner;
+            else
+                node.outer = owner.outer;
+            Transaction.run({ separation: true }, () => {
+                const ctx = node.context;
+                if (ctx) {
+                    ctx.variable = variable;
+                    ctx.value = value;
+                }
+                else
+                    node.context = new RxNodeContextImpl(variable, value);
+            });
+        }
+        else if (hostCtx)
+            node.outer = owner;
+        else
+            node.outer = owner.outer;
+    }
+}
+RxNodeImpl.logging = undefined;
+RxNodeImpl.grandNodeCount = 0;
+RxNodeImpl.disposableNodeCount = 0;
+__decorate([
+    reactive,
+    options({
+        reentrance: Reentrance.CancelPrevious,
+        triggeringArgs: true,
+        noSideEffects: false,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], RxNodeImpl.prototype, "update", null);
+function getNodeKey(node) {
+    return node.stamp >= 0 ? node.key : undefined;
+}
+function runUpdateNestedTreesThenDo(error, action) {
+    var _a;
+    const curr = RxNodeImpl.current;
+    const owner = curr.instance;
+    const children = owner.children;
+    if (children.isMergeInProgress) {
+        let promised = undefined;
+        try {
+            children.endMerge(error);
+            for (const slot of children.removedItems(true))
+                triggerFinalization(slot, true, true);
+            if (!error) {
+                const sequential = children.isStrict;
+                let p1 = undefined;
+                let p2 = undefined;
+                let mounting = false;
+                let partition = owner;
+                for (const child of children.items()) {
+                    if (Transaction.isCanceled)
+                        break;
+                    const node = child.instance;
+                    const el = node.element;
+                    const isPart = node.driver.isPartitionSeparator;
+                    const host = isPart ? owner : partition;
+                    const p = (_a = el.node.priority) !== null && _a !== void 0 ? _a : Priority.Realtime;
+                    mounting = markToMountIfNecessary(mounting, host, child, children, sequential);
+                    if (p === Priority.Realtime)
+                        triggerUpdate(child);
+                    else if (p === Priority.Normal)
+                        p1 = push(child, p1);
+                    else
+                        p2 = push(child, p2);
+                    if (isPart)
+                        partition = node;
+                }
+                if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
+                    promised = startIncrementalUpdate(curr, children, p1, p2).then(() => action(error), e => action(e));
+            }
+        }
+        finally {
+            if (!promised)
+                action(error);
+        }
+    }
+}
+function markToMountIfNecessary(mounting, host, slot, children, sequential) {
+    const node = slot.instance;
+    const el = node.element;
+    if (el.native && !node.has(Mode.ManualMount)) {
+        if (mounting || node.host !== host) {
+            children.markAsMoved(slot);
+            mounting = false;
+        }
+    }
+    else if (sequential && children.isMoved(slot))
+        mounting = true;
+    node.host = host;
+    return mounting;
+}
+function startIncrementalUpdate(ownerSlot, allChildren, priority1, priority2) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stamp = ownerSlot.instance.stamp;
+        if (priority1)
+            yield updateIncrementally(ownerSlot, stamp, allChildren, priority1, Priority.Normal);
+        if (priority2)
+            yield updateIncrementally(ownerSlot, stamp, allChildren, priority2, Priority.Background);
+    });
+}
+function updateIncrementally(owner, stamp, allChildren, items, priority) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Transaction.requestNextFrame();
+        const node = owner.instance;
+        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, RxTree.shortFrameDuration / 3)) {
+            let outerPriority = RxTree.currentUpdatePriority;
+            RxTree.currentUpdatePriority = priority;
+            try {
+                if (node.childrenShuffling)
+                    shuffle(items);
+                const frameDurationLimit = priority === Priority.Background ? RxTree.shortFrameDuration : Infinity;
+                let frameDuration = Math.min(frameDurationLimit, Math.max(RxTree.frameDuration / 4, RxTree.shortFrameDuration));
+                for (const child of items) {
+                    triggerUpdate(child);
+                    if (Transaction.isFrameOver(1, frameDuration)) {
+                        RxTree.currentUpdatePriority = outerPriority;
+                        yield Transaction.requestNextFrame(0);
+                        outerPriority = RxTree.currentUpdatePriority;
+                        RxTree.currentUpdatePriority = priority;
+                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, RxTree.frameDuration));
+                    }
+                    if (Transaction.isCanceled && Transaction.isFrameOver(1, RxTree.shortFrameDuration / 3))
+                        break;
+                }
+            }
+            finally {
+                RxTree.currentUpdatePriority = outerPriority;
+            }
+        }
+    });
+}
+function triggerUpdate(slot) {
+    const node = slot.instance;
+    if (node.stamp >= 0) {
+        if (node.has(Mode.PinpointUpdate)) {
+            if (node.stamp === Number.MAX_SAFE_INTEGER) {
+                Transaction.outside(() => {
+                    if (Rx.isLogging)
+                        Rx.setLoggingHint(node.element, node.key);
+                    Rx.getReaction(node.update).configure({
+                        order: node.level,
+                    });
+                });
+            }
+            unobs(node.update, node.declaration.triggers);
+        }
+        else
+            updateNow(slot);
+    }
+}
+function mountOrRemountIfNecessary(node) {
+    const element = node.element;
+    const driver = node.driver;
+    if (node.stamp === Number.MAX_SAFE_INTEGER) {
+        node.stamp = Number.MAX_SAFE_INTEGER - 1;
+        unobs(() => {
+            driver.assign(element);
+            driver.initialize(element);
+            if (!node.has(Mode.ManualMount)) {
+                node.stamp = 0;
+                if (element.node.host !== element.node)
+                    driver.mount(element);
+            }
+            node.stamp = 0;
+        });
+    }
+    else if (node.isMoved && !node.has(Mode.ManualMount) && element.node.host !== element.node)
+        unobs(() => driver.mount(element));
+}
+function updateNow(slot) {
+    const node = slot.instance;
+    const el = node.element;
+    if (node.stamp >= 0) {
+        let result = undefined;
+        runInside(slot, () => {
+            mountOrRemountIfNecessary(node);
+            if (node.stamp < Number.MAX_SAFE_INTEGER - 1) {
+                try {
+                    node.stamp++;
+                    node.numerator = 0;
+                    el.prepareForUpdate();
+                    node.children.beginMerge();
+                    const driver = node.driver;
+                    result = driver.update(el);
+                    if (result instanceof Promise)
+                        result.then(v => { runUpdateNestedTreesThenDo(undefined, NOP); return v; }, e => { console.log(e); runUpdateNestedTreesThenDo(e !== null && e !== void 0 ? e : new Error('unknown error'), NOP); });
+                    else
+                        runUpdateNestedTreesThenDo(undefined, NOP);
+                }
+                catch (e) {
+                    runUpdateNestedTreesThenDo(e, NOP);
+                    console.log(`Update failed: ${node.key}`);
+                    console.log(`${e}`);
+                }
+            }
+        });
+    }
+}
+function triggerFinalization(slot, isLeader, individual) {
+    const node = slot.instance;
+    const el = node.element;
+    if (node.stamp >= 0) {
+        const driver = node.driver;
+        if (individual && node.key !== node.declaration.key && !driver.isPartitionSeparator)
+            console.log(`WARNING: it is recommended to assign explicit key for conditional element in order to avoid unexpected side effects: ${node.key}`);
+        node.stamp = ~node.stamp;
+        const childrenAreLeaders = unobs(() => driver.finalize(el, isLeader));
+        el.native = null;
+        el.controller = null;
+        if (node.has(Mode.PinpointUpdate)) {
+            slot.aux = undefined;
+            const last = gLastToDispose;
+            if (last)
+                gLastToDispose = last.aux = slot;
+            else
+                gFirstToDispose = gLastToDispose = slot;
+            if (gFirstToDispose === slot)
+                Transaction.run({ separation: 'disposal', hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
+                    void runDisposalLoop().then(NOP, error => console.log(error));
+                });
+        }
+        for (const child of node.children.items())
+            triggerFinalization(child, childrenAreLeaders, false);
+        RxNodeImpl.grandNodeCount--;
+    }
+}
+function runDisposalLoop() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Transaction.requestNextFrame();
+        let slot = gFirstToDispose;
+        while (slot !== undefined) {
+            if (Transaction.isFrameOver(500, 5))
+                yield Transaction.requestNextFrame();
+            Rx.dispose(slot.instance);
+            slot = slot.aux;
+            RxNodeImpl.disposableNodeCount--;
+        }
+        gFirstToDispose = gLastToDispose = undefined;
+    });
+}
+function wrapToRunInside(func) {
+    let wrappedToRunInside;
+    const current = gCurrent;
+    if (current)
+        wrappedToRunInside = (...args) => {
+            return runInside(current, func, ...args);
+        };
+    else
+        wrappedToRunInside = func;
+    return wrappedToRunInside;
+}
+function runInside(slot, func, ...args) {
+    const outer = gCurrent;
+    try {
+        gCurrent = slot;
+        return func(...args);
+    }
+    finally {
+        gCurrent = outer;
+    }
+}
+function triggersAreEqual(a1, a2) {
+    let result = a1 === a2;
+    if (!result) {
+        if (Array.isArray(a1)) {
+            result = Array.isArray(a2) &&
+                a1.length === a2.length &&
+                a1.every((t, i) => t === a2[i]);
+        }
+        else if (a1 === Object(a1) && a2 === Object(a2)) {
+            for (const p in a1) {
+                result = a1[p] === a2[p];
+                if (!result)
+                    break;
+            }
+        }
+    }
+    return result;
+}
+function push(item, array) {
+    if (array == undefined)
+        array = new Array();
+    array.push(item);
+    return array;
+}
+function shuffle(array) {
+    const n = array.length - 1;
+    let i = n;
+    while (i >= 0) {
+        const j = Math.floor(Math.random() * n);
+        const t = array[i];
+        array[i] = array[j];
+        array[j] = t;
+        i--;
+    }
+    return array;
+}
+const ORIGINAL_PROMISE_THEN = Promise.prototype.then;
+function reactronicDomHookedThen(resolve, reject) {
+    resolve = resolve ? wrapToRunInside(resolve) : defaultResolve;
+    reject = reject ? wrapToRunInside(reject) : defaultReject;
+    return ORIGINAL_PROMISE_THEN.call(this, resolve, reject);
+}
+function defaultResolve(value) {
+    return value;
+}
+function defaultReject(error) {
+    throw error;
+}
+Promise.prototype.then = reactronicDomHookedThen;
+const NOP = (...args) => { };
+let gCurrent = undefined;
+let gFirstToDispose = undefined;
+let gLastToDispose = undefined;

package/build/dist/source/util/RxNodeUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function emitLetters(n: number): string;
+export declare function objectHasMember<T>(obj: any, member: string): obj is T;
+export declare function getCallerInfo(prefix: string): string;

package/build/dist/source/util/RxNodeUtils.js

@@ -0,0 +1,46 @@
+export function emitLetters(n) {
+    if (n < 0)
+        throw new Error(`emitLetters: argument (${n}) should not be negative or zero`);
+    let result = '';
+    while (n >= 0) {
+        const r = n % 26;
+        n = Math.floor(n / 26) - 1;
+        result = String.fromCharCode(65 + r) + result;
+    }
+    return result;
+}
+export function objectHasMember(obj, member) {
+    return obj === Object(obj) && !Array.isArray(obj) && member in obj;
+}
+export function getCallerInfo(prefix) {
+    const restore = Error.stackTraceLimit = 20;
+    const error = new Error();
+    const stack = error.stack || '';
+    Error.stackTraceLimit = restore;
+    const lines = stack.split('\n');
+    let i = lines.findIndex(x => x.indexOf('.declare') >= 0);
+    i = i >= 0 ? i + 2 : 5;
+    let caller = extractFunctionAndLocation(lines[i]);
+    let location = caller;
+    if (caller.func.endsWith('.update')) {
+        i = i - 1;
+        caller = extractFunctionAndLocation(lines[i]);
+        location = extractFunctionAndLocation(lines[i + 1]);
+    }
+    else {
+        while (!caller.func && i > 0) {
+            i = i - 1;
+            caller = extractFunctionAndLocation(lines[i]);
+        }
+        location = extractFunctionAndLocation(lines[i + 1]);
+    }
+    const result = `${prefix}·${caller.func}@${location.file}`;
+    return result;
+}
+function extractFunctionAndLocation(s) {
+    const match = s.match(/(?:\s*at\s+)?(?:(\S+)\s\()?(?:.*?)([^\/\(\):]+)(?:(:|\d)*\)?)$/);
+    return {
+        func: (match === null || match === void 0 ? void 0 : match[1]) || '',
+        file: (match === null || match === void 0 ? void 0 : match[2]) || '',
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.23.115",
+  "version": "0.24.101",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",