reactronic 0.24.114 → 0.24.116

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

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

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

@@ -12,10 +12,7 @@ export declare const enum Priority {
     Normal = 1,
     Background = 2
 }
-export interface RxElement {
-    node: RxNode<any>;
-}
-export interface RxNode<E extends RxElement = any> {
+export interface RxNode<E = unknown> {
     readonly key: string;
     readonly driver: RxNodeDriver<E>;
     readonly declaration: Readonly<RxNodeDecl<E>>;
@@ -28,14 +25,13 @@ export interface RxNode<E extends RxElement = any> {
     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> {
+export interface RxNodeDecl<E = unknown> {
     preset?: RxNodeDecl<E>;
     key?: string;
     mode?: Mode;
@@ -44,15 +40,15 @@ export interface RxNodeDecl<E extends RxElement> {
     update?: Delegate<E>;
     finalize?: Delegate<E>;
 }
-export interface RxNodeDriver<E extends RxElement> {
+export interface RxNodeDriver<E = unknown> {
     readonly name: string;
     readonly isPartitionSeparator: 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;
+    initialize(node: RxNode<E>): void;
+    mount(node: RxNode<E>): void;
+    update(node: RxNode<E>): void | Promise<void>;
+    finalize(node: RxNode<E>, isLeader: boolean): boolean;
 }
 export interface RxNodeContext<T extends Object = Object> {
     value: T;

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

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

package/build/dist/source/tree/RxTree.js

@@ -43,35 +43,39 @@ export class RxTree {
             }
             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;
+                result = existing.instance;
+                if (result.driver !== driver && driver !== undefined)
+                    throw new Error(`changing element driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
+                const exTriggers = result.declaration.triggers;
                 if (triggersAreEqual(declaration.triggers, exTriggers))
                     declaration.triggers = exTriggers;
-                node.declaration = declaration;
+                result.declaration = declaration;
             }
             else {
-                const node = new RxNodeImpl(key || generateKey(owner), driver, declaration, owner);
-                node.seat = children.mergeAsAdded(node);
-                result = node.element;
+                result = new RxNodeImpl(key || generateKey(owner), driver, declaration, owner);
+                result.seat = children.mergeAsAdded(result);
             }
         }
         else {
-            const node = new RxNodeImpl(key || '', driver, declaration, owner);
-            node.seat = MergeList.createItem(node);
-            result = node.element;
-            triggerSeatUpdate(node.seat);
+            result = new RxNodeImpl(key || '', driver, declaration, owner);
+            result.seat = MergeList.createItem(result);
+            triggerUpdateViaSeat(result.seat);
         }
         return result;
     }
-    static triggerUpdate(element, triggers) {
-        const node = element.node;
-        const declaration = node.declaration;
+    static get isFirstUpdate() {
+        return (gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance.stamp) === 1;
+    }
+    static get nodeStamp() {
+        var _a;
+        return (_a = gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance.stamp) !== null && _a !== void 0 ? _a : -1;
+    }
+    static triggerUpdate(node, triggers) {
+        const impl = node;
+        const declaration = impl.declaration;
         if (!triggersAreEqual(triggers, declaration.triggers)) {
             declaration.triggers = triggers;
-            triggerSeatUpdate(node.seat);
+            triggerUpdateViaSeat(impl.seat);
         }
     }
     static updateNestedTreesThenDo(action) {
@@ -111,18 +115,18 @@ export class BaseDriver {
         this.isPartitionSeparator = isPartitionSeparator;
         this.predefine = predefine;
     }
-    initialize(element) {
+    initialize(node) {
         var _a;
-        (_a = this.predefine) === null || _a === void 0 ? void 0 : _a.call(this, element);
-        initializeViaPresetChain(element, element.node.declaration);
+        (_a = this.predefine) === null || _a === void 0 ? void 0 : _a.call(this, node.element);
+        initializeViaPresetChain(node.element, node.declaration);
     }
-    mount(element) {
+    mount(node) {
     }
-    update(element) {
-        updateViaPresetChain(element, element.node.declaration);
+    update(node) {
+        updateViaPresetChain(node.element, node.declaration);
     }
-    finalize(element, isLeader) {
-        finalizeViaPresetChain(element, element.node.declaration);
+    finalize(node, isLeader) {
+        finalizeViaPresetChain(node.element, node.declaration);
         return isLeader;
     }
 }
@@ -196,6 +200,7 @@ __decorate([
 ], RxNodeContextImpl.prototype, "variable", void 0);
 class RxNodeImpl {
     constructor(key, driver, declaration, owner) {
+        const thisAsUnknown = this;
         this.key = key;
         this.driver = driver;
         this.declaration = declaration;
@@ -207,11 +212,11 @@ class RxNodeImpl {
         }
         else {
             this.level = 1;
-            this.owner = owner = this;
-            this.outer = this;
+            this.owner = owner = thisAsUnknown;
+            this.outer = thisAsUnknown;
         }
         this.element = driver.allocate(this);
-        this.host = this;
+        this.host = thisAsUnknown;
         this.children = new MergeList(getNodeKey, true);
         this.seat = undefined;
         this.stamp = Number.MAX_SAFE_INTEGER;
@@ -223,7 +228,6 @@ class RxNodeImpl {
         if (this.has(Mode.IndependentUpdate))
             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.seat); }
@@ -325,7 +329,7 @@ function runUpdateNestedTreesThenDo(error, action) {
                     const p = (_a = childNode.priority) !== null && _a !== void 0 ? _a : Priority.Realtime;
                     mounting = markToMountIfNecessary(mounting, host, child, children, sequential);
                     if (p === Priority.Realtime)
-                        triggerSeatUpdate(child);
+                        triggerUpdateViaSeat(child);
                     else if (p === Priority.Normal)
                         p1 = push(child, p1);
                     else
@@ -378,7 +382,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) {
-                    triggerSeatUpdate(child);
+                    triggerUpdateViaSeat(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
                         RxTree.currentUpdatePriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
@@ -396,7 +400,7 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
         }
     });
 }
-function triggerSeatUpdate(seat) {
+function triggerUpdateViaSeat(seat) {
     const node = seat.instance;
     if (node.stamp >= 0) {
         if (node.has(Mode.IndependentUpdate)) {
@@ -416,26 +420,24 @@ function triggerSeatUpdate(seat) {
     }
 }
 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.initialize(element);
+            driver.initialize(node);
             if (!node.has(Mode.ManualMount)) {
                 node.stamp = 0;
-                if (element.node.host !== element.node)
-                    driver.mount(element);
+                if (node.host !== node)
+                    driver.mount(node);
             }
             node.stamp = 0;
         });
     }
-    else if (node.isMoved && !node.has(Mode.ManualMount) && element.node.host !== element.node)
-        unobs(() => driver.mount(element));
+    else if (node.isMoved && !node.has(Mode.ManualMount) && node.host !== node)
+        unobs(() => driver.mount(node));
 }
 function updateNow(seat) {
     const node = seat.instance;
-    const el = node.element;
     if (node.stamp >= 0) {
         let result = undefined;
         runInside(seat, () => {
@@ -446,7 +448,7 @@ function updateNow(seat) {
                     node.numerator = 0;
                     node.children.beginMerge();
                     const driver = node.driver;
-                    result = driver.update(el);
+                    result = driver.update(node);
                     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
@@ -463,13 +465,12 @@ function updateNow(seat) {
 }
 function triggerFinalization(seat, isLeader, individual) {
     const node = seat.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));
+        const childrenAreLeaders = unobs(() => driver.finalize(node, isLeader));
         if (node.has(Mode.IndependentUpdate)) {
             seat.aux = undefined;
             const last = gLastToDispose;

package/package.json

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