reactronic 0.24.110 → 0.24.112

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

@@ -12,46 +12,49 @@ export declare const enum Priority {
     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 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 RxElement {
+    node: RxNode<any>;
 }
-export interface RxNodeDecl<T = unknown> {
-    preset?: RxNodeDecl<T>;
+export interface RxNode<E extends RxElement = any> {
+    readonly key: string;
+    readonly driver: RxNodeDriver<E>;
+    readonly declaration: Readonly<RxNodeDecl<E>>;
+    readonly level: number;
+    readonly owner: RxNode;
+    element: E;
+    readonly host: RxNode;
+    readonly children: MergeListReader<RxNode>;
+    readonly seat: MergedItem<RxNode<E>> | undefined;
+    readonly stamp: number;
+    readonly outer: RxNode;
+    readonly context: RxNodeContext | undefined;
+    readonly isInitialUpdate: boolean;
+    priority?: Priority;
+    childrenShuffling: boolean;
+    strictOrder: boolean;
+    has(mode: Mode): boolean;
+    configureReactronic(options: Partial<MemberOptions>): MemberOptions;
+}
+export interface RxNodeDecl<E extends RxElement> {
+    preset?: RxNodeDecl<E>;
     key?: string;
     mode?: Mode;
     triggers?: unknown;
-    specify?: Delegate<T>;
-    create?: Delegate<T>;
-    initialize?: Delegate<T>;
-    update?: Delegate<T>;
-    finalize?: Delegate<T>;
+    specify?: Delegate<E>;
+    create?: Delegate<E>;
+    initialize?: Delegate<E>;
+    update?: Delegate<E>;
+    finalize?: Delegate<E>;
 }
-export interface RxNodeDriver<T> {
+export interface RxNodeDriver<E extends RxElement> {
     readonly name: string;
     readonly isPartitionSeparator: boolean;
-    readonly predefine?: SimpleDelegate<T>;
-    allocate(node: RxNode<T>): T;
-    initialize(element: T): void;
-    mount(element: T): void;
-    update(element: T): void | Promise<void>;
-    finalize(element: T, isLeader: boolean): boolean;
+    readonly predefine?: SimpleDelegate<E>;
+    allocate(node: RxNode<E>): E;
+    initialize(element: E): void;
+    mount(element: E): void;
+    update(element: E): void | Promise<void>;
+    finalize(element: E, isLeader: boolean): boolean;
 }
 export interface RxNodeContext<T extends Object = Object> {
     value: T;

package/build/dist/source/RxNode.js

@@ -10,5 +10,3 @@ export var Priority;
     Priority[Priority["Normal"] = 1] = "Normal";
     Priority[Priority["Background"] = 2] = "Background";
 })(Priority || (Priority = {}));
-export class RxNode {
-}

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

@@ -1,33 +1,29 @@
 import { LoggingOptions } from './Logging.js';
-import { Priority, RxNodeDecl, RxNodeDriver, SimpleDelegate, RxNode } from './RxNode.js';
+import { Priority, RxNodeDecl, RxNodeDriver, SimpleDelegate, RxNode, RxElement } 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 declare<E extends RxElement>(driver: RxNodeDriver<E>, declaration?: RxNodeDecl<E>, preset?: RxNodeDecl<E>): E;
+    static triggerUpdate(element: RxElement, 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 findMatchingHost<E extends RxElement, R extends RxElement>(node: RxNode<E>, match: SimpleDelegate<RxNode<E>, boolean>): RxNode<R> | undefined;
+    static findMatchingPrevSibling<E extends RxElement, R extends RxElement>(node: RxNode<E>, match: SimpleDelegate<RxNode<E>, boolean>): RxNode<R> | undefined;
+    static forEachChildRecursively<E extends RxElement>(node: RxNode<E>, action: SimpleDelegate<RxNode<E>>): void;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
-export declare abstract class BaseDriver<T extends {
-    node: RxNode;
-}> implements RxNodeDriver<T> {
+export declare abstract class BaseDriver<E extends RxElement> implements RxNodeDriver<E> {
     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;
-    initialize(element: T): void;
-    mount(element: T): void;
-    update(element: T): void | Promise<void>;
-    finalize(element: T, isLeader: boolean): boolean;
+    readonly predefine?: SimpleDelegate<E> | undefined;
+    constructor(name: string, isPartitionSeparator: boolean, predefine?: SimpleDelegate<E> | undefined);
+    abstract allocate(node: RxNode<E>): E;
+    initialize(element: E): void;
+    mount(element: E): void;
+    update(element: E): void | Promise<void>;
+    finalize(element: E, isLeader: boolean): boolean;
 }
 export declare class RxNodeVariable<T extends Object = Object> {
     readonly defaultValue: T | undefined;

package/build/dist/source/RxTree.js

@@ -54,24 +54,24 @@ export class RxTree {
             }
             else {
                 const node = new RxNodeImpl(key || generateKey(owner), driver, declaration, owner);
-                node.slot = children.mergeAsAdded(node);
+                node.seat = children.mergeAsAdded(node);
                 result = node.element;
             }
         }
         else {
             const node = new RxNodeImpl(key || '', driver, declaration, owner);
-            node.slot = MergeList.createItem(node);
+            node.seat = MergeList.createItem(node);
             result = node.element;
-            triggerUpdate(node.slot);
+            triggerUpdateGivenSeat(node.seat);
         }
         return result;
     }
     static triggerUpdate(element, triggers) {
-        const el = element;
-        const declaration = el.node.declaration;
+        const node = element.node;
+        const declaration = node.declaration;
         if (!triggersAreEqual(triggers, declaration.triggers)) {
             declaration.triggers = triggers;
-            triggerUpdate(el.node.slot);
+            triggerUpdateGivenSeat(node.seat);
         }
     }
     static updateNestedTreesThenDo(action) {
@@ -84,7 +84,7 @@ export class RxTree {
         return p;
     }
     static findMatchingPrevSibling(node, match) {
-        let p = node.slot.prev;
+        let p = node.seat.prev;
         while (p && !match(p.instance))
             p = p.prev;
         return p === null || p === void 0 ? void 0 : p.instance;
@@ -213,7 +213,7 @@ class RxNodeImpl {
         this.element = driver.allocate(this);
         this.host = this;
         this.children = new MergeList(getNodeKey, true);
-        this.slot = undefined;
+        this.seat = undefined;
         this.stamp = Number.MAX_SAFE_INTEGER;
         this.context = undefined;
         this.numerator = 0;
@@ -226,12 +226,12 @@ class RxNodeImpl {
     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); }
+    get isMoved() { return this.owner.children.isMoved(this.seat); }
     has(mode) {
         return (getModeViaPresetChain(this.declaration) & mode) === mode;
     }
     update(_triggers) {
-        updateNow(this.slot);
+        updateNow(this.seat);
     }
     configureReactronic(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.PinpointUpdate))
@@ -247,7 +247,7 @@ class RxNodeImpl {
         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;
+            node = node.outer.seat.instance;
         return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
     static useNodeVariableValue(variable) {
@@ -308,8 +308,8 @@ function runUpdateNestedTreesThenDo(error, action) {
         let promised = undefined;
         try {
             children.endMerge(error);
-            for (const slot of children.removedItems(true))
-                triggerFinalization(slot, true, true);
+            for (const child of children.removedItems(true))
+                triggerFinalization(child, true, true);
             if (!error) {
                 const sequential = children.isStrict;
                 let p1 = undefined;
@@ -326,7 +326,7 @@ function runUpdateNestedTreesThenDo(error, action) {
                     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);
+                        triggerUpdateGivenSeat(child);
                     else if (p === Priority.Normal)
                         p1 = push(child, p1);
                     else
@@ -344,27 +344,27 @@ function runUpdateNestedTreesThenDo(error, action) {
         }
     }
 }
-function markToMountIfNecessary(mounting, host, slot, children, sequential) {
-    const node = slot.instance;
+function markToMountIfNecessary(mounting, host, seat, children, sequential) {
+    const node = seat.instance;
     const el = node.element;
     if (el.native && !node.has(Mode.ManualMount)) {
         if (mounting || node.host !== host) {
-            children.markAsMoved(slot);
+            children.markAsMoved(seat);
             mounting = false;
         }
     }
-    else if (sequential && children.isMoved(slot))
+    else if (sequential && children.isMoved(seat))
         mounting = true;
     node.host = host;
     return mounting;
 }
-function startIncrementalUpdate(ownerSlot, allChildren, priority1, priority2) {
+function startIncrementalUpdate(ownerSeat, allChildren, priority1, priority2) {
     return __awaiter(this, void 0, void 0, function* () {
-        const stamp = ownerSlot.instance.stamp;
+        const stamp = ownerSeat.instance.stamp;
         if (priority1)
-            yield updateIncrementally(ownerSlot, stamp, allChildren, priority1, Priority.Normal);
+            yield updateIncrementally(ownerSeat, stamp, allChildren, priority1, Priority.Normal);
         if (priority2)
-            yield updateIncrementally(ownerSlot, stamp, allChildren, priority2, Priority.Background);
+            yield updateIncrementally(ownerSeat, stamp, allChildren, priority2, Priority.Background);
     });
 }
 function updateIncrementally(owner, stamp, allChildren, items, priority) {
@@ -380,7 +380,7 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
                 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);
+                    triggerUpdateGivenSeat(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
                         RxTree.currentUpdatePriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
@@ -398,8 +398,8 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
         }
     });
 }
-function triggerUpdate(slot) {
-    const node = slot.instance;
+function triggerUpdateGivenSeat(seat) {
+    const node = seat.instance;
     if (node.stamp >= 0) {
         if (node.has(Mode.PinpointUpdate)) {
             if (node.stamp === Number.MAX_SAFE_INTEGER) {
@@ -414,7 +414,7 @@ function triggerUpdate(slot) {
             unobs(node.update, node.declaration.triggers);
         }
         else
-            updateNow(slot);
+            updateNow(seat);
     }
 }
 function mountOrRemountIfNecessary(node) {
@@ -435,12 +435,12 @@ function mountOrRemountIfNecessary(node) {
     else if (node.isMoved && !node.has(Mode.ManualMount) && element.node.host !== element.node)
         unobs(() => driver.mount(element));
 }
-function updateNow(slot) {
-    const node = slot.instance;
+function updateNow(seat) {
+    const node = seat.instance;
     const el = node.element;
     if (node.stamp >= 0) {
         let result = undefined;
-        runInside(slot, () => {
+        runInside(seat, () => {
             mountOrRemountIfNecessary(node);
             if (node.stamp < Number.MAX_SAFE_INTEGER - 1) {
                 try {
@@ -463,8 +463,8 @@ function updateNow(slot) {
         });
     }
 }
-function triggerFinalization(slot, isLeader, individual) {
-    const node = slot.instance;
+function triggerFinalization(seat, isLeader, individual) {
+    const node = seat.instance;
     const el = node.element;
     if (node.stamp >= 0) {
         const driver = node.driver;
@@ -475,14 +475,14 @@ function triggerFinalization(slot, isLeader, individual) {
         el.native = null;
         el.controller = null;
         if (node.has(Mode.PinpointUpdate)) {
-            slot.aux = undefined;
+            seat.aux = undefined;
             const last = gLastToDispose;
             if (last)
-                gLastToDispose = last.aux = slot;
+                gLastToDispose = last.aux = seat;
             else
-                gFirstToDispose = gLastToDispose = slot;
-            if (gFirstToDispose === slot)
-                Transaction.run({ separation: 'disposal', hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
+                gFirstToDispose = gLastToDispose = seat;
+            if (gFirstToDispose === seat)
+                Transaction.run({ separation: 'disposal', hint: `runDisposalLoop(initiator=${seat.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }
@@ -494,12 +494,12 @@ function triggerFinalization(slot, isLeader, individual) {
 function runDisposalLoop() {
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
-        let slot = gFirstToDispose;
-        while (slot !== undefined) {
+        let seat = gFirstToDispose;
+        while (seat !== undefined) {
             if (Transaction.isFrameOver(500, 5))
                 yield Transaction.requestNextFrame();
-            RxSystem.dispose(slot.instance);
-            slot = slot.aux;
+            RxSystem.dispose(seat.instance);
+            seat = seat.aux;
             RxNodeImpl.disposableNodeCount--;
         }
         gFirstToDispose = gLastToDispose = undefined;
@@ -516,10 +516,10 @@ function wrapToRunInside(func) {
         wrappedToRunInside = func;
     return wrappedToRunInside;
 }
-function runInside(slot, func, ...args) {
+function runInside(seat, func, ...args) {
     const outer = gCurrent;
     try {
-        gCurrent = slot;
+        gCurrent = seat;
         return func(...args);
     }
     finally {

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

@@ -18,6 +18,6 @@ export { Monitor } from './impl/Monitor.js';
 export { Journal } from './impl/Journal.js';
 export { RxSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from './RxSystem.js';
 export { Mode, Priority } from './RxNode.js';
-export type { Delegate, SimpleDelegate, RxNode, RxNodeDecl, RxNodeDriver, RxNodeContext } from './RxNode.js';
+export type { Delegate, SimpleDelegate, RxElement, RxNode, RxNodeDecl, RxNodeDriver, RxNodeContext } from './RxNode.js';
 export { RxTree, BaseDriver, RxNodeVariable } from './RxTree.js';
 export { Clock } from './Clock.js';

package/package.json

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