reactronic 0.24.115 → 0.24.117

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

@@ -17,7 +17,6 @@ export { Transaction } from './core/Transaction.js';
 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, RxNode, RxNodeDecl, RxNodeDriver, RxNodeContext } from './tree/RxNode.js';
-export { RxTree, BaseDriver, RxNodeVariable } from './tree/RxTree.js';
+export { RxNode, Mode, Priority, BaseDriver, RxNodeVariable } from './tree/RxTree.js';
+export type { Delegate, SimpleDelegate, RxNodeDecl, RxNodeDriver, RxNodeContext } from './tree/RxTree.js';
 export { Clock } from './Clock.js';

package/build/dist/source/api.js

@@ -13,6 +13,5 @@ export { Transaction } from './core/Transaction.js';
 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 { RxTree, BaseDriver, RxNodeVariable } from './tree/RxTree.js';
+export { RxNode, Mode, Priority, BaseDriver, RxNodeVariable } from './tree/RxTree.js';
 export { Clock } from './Clock.js';

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

@@ -1,6 +1,36 @@
 import { LoggingOptions } from '../Logging.js';
-import { Priority, RxNodeDecl, RxNodeDriver, SimpleDelegate, RxNode } from './RxNode.js';
-export declare class RxTree {
+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,
+    IndependentUpdate = 1,
+    ManualMount = 2
+}
+export declare const enum Priority {
+    Realtime = 0,
+    Normal = 1,
+    Background = 2
+}
+export declare abstract class RxNode<E = unknown> {
+    abstract readonly key: string;
+    abstract readonly driver: RxNodeDriver<E>;
+    abstract readonly declaration: Readonly<RxNodeDecl<E>>;
+    abstract readonly level: number;
+    abstract readonly owner: RxNode;
+    abstract element: E;
+    abstract readonly host: RxNode;
+    abstract readonly children: MergeListReader<RxNode>;
+    abstract readonly seat: MergedItem<RxNode<E>> | undefined;
+    abstract readonly stamp: number;
+    abstract readonly outer: RxNode;
+    abstract readonly context: RxNodeContext | undefined;
+    abstract priority?: Priority;
+    abstract childrenShuffling: boolean;
+    abstract strictOrder: boolean;
+    abstract has(mode: Mode): boolean;
+    abstract configureReactronic(options: Partial<MemberOptions>): MemberOptions;
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
     static currentUpdatePriority: Priority;
@@ -16,11 +46,33 @@ export declare class RxTree {
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
+export interface RxNodeDecl<E = unknown> {
+    preset?: RxNodeDecl<E>;
+    key?: string;
+    mode?: Mode;
+    triggers?: unknown;
+    initialize?: Delegate<E>;
+    update?: Delegate<E>;
+    finalize?: Delegate<E>;
+}
+export interface RxNodeDriver<E = unknown> {
+    readonly name: string;
+    readonly isPartitionSeparator: boolean;
+    readonly predefine?: SimpleDelegate<E>;
+    allocate(node: RxNode<E>): E;
+    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;
+}
 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);
+    readonly predefine?: SimpleDelegate<E, void> | undefined;
+    constructor(name: string, isPartitionSeparator: boolean, predefine?: SimpleDelegate<E, void> | undefined);
     abstract allocate(node: RxNode<E>): E;
     initialize(node: RxNode<E>): void;
     mount(node: RxNode<E>): void;

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

@@ -22,8 +22,19 @@ import { Reentrance } from '../Options.js';
 import { ObservableObject } from '../core/Mvcc.js';
 import { Transaction } from '../core/Transaction.js';
 import { RxSystem, options, raw, reactive, unobs } from '../RxSystem.js';
-import { Priority, Mode } from './RxNode.js';
-export class RxTree {
+export var Mode;
+(function (Mode) {
+    Mode[Mode["Default"] = 0] = "Default";
+    Mode[Mode["IndependentUpdate"] = 1] = "IndependentUpdate";
+    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 {
     static declare(driver, declaration, preset) {
         var _a;
         let result;
@@ -96,7 +107,7 @@ export class RxTree {
     static forEachChildRecursively(node, action) {
         action(node);
         for (const child of node.children.items())
-            RxTree.forEachChildRecursively(child.instance, action);
+            RxNode.forEachChildRecursively(child.instance, action);
     }
     static getDefaultLoggingOptions() {
         return RxNodeImpl.logging;
@@ -105,10 +116,10 @@ export class RxTree {
         RxNodeImpl.logging = logging;
     }
 }
-RxTree.shortFrameDuration = 16;
-RxTree.longFrameDuration = 300;
-RxTree.currentUpdatePriority = Priority.Realtime;
-RxTree.frameDuration = RxTree.longFrameDuration;
+RxNode.shortFrameDuration = 16;
+RxNode.longFrameDuration = 300;
+RxNode.currentUpdatePriority = Priority.Realtime;
+RxNode.frameDuration = RxNode.longFrameDuration;
 export class BaseDriver {
     constructor(name, isPartitionSeparator, predefine) {
         this.name = name;
@@ -373,29 +384,29 @@ 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;
+        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, RxNode.shortFrameDuration / 3)) {
+            let outerPriority = RxNode.currentUpdatePriority;
+            RxNode.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));
+                const frameDurationLimit = priority === Priority.Background ? RxNode.shortFrameDuration : Infinity;
+                let frameDuration = Math.min(frameDurationLimit, Math.max(RxNode.frameDuration / 4, RxNode.shortFrameDuration));
                 for (const child of items) {
                     triggerUpdateViaSeat(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
-                        RxTree.currentUpdatePriority = outerPriority;
+                        RxNode.currentUpdatePriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
-                        outerPriority = RxTree.currentUpdatePriority;
-                        RxTree.currentUpdatePriority = priority;
-                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, RxTree.frameDuration));
+                        outerPriority = RxNode.currentUpdatePriority;
+                        RxNode.currentUpdatePriority = priority;
+                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, RxNode.frameDuration));
                     }
-                    if (Transaction.isCanceled && Transaction.isFrameOver(1, RxTree.shortFrameDuration / 3))
+                    if (Transaction.isCanceled && Transaction.isFrameOver(1, RxNode.shortFrameDuration / 3))
                         break;
                 }
             }
             finally {
-                RxTree.currentUpdatePriority = outerPriority;
+                RxNode.currentUpdatePriority = outerPriority;
             }
         }
     });
@@ -438,7 +449,6 @@ function mountOrRemountIfNecessary(node) {
 }
 function updateNow(seat) {
     const node = seat.instance;
-    const el = node.element;
     if (node.stamp >= 0) {
         let result = undefined;
         runInside(seat, () => {
@@ -449,7 +459,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

package/package.json

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

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

@@ -1,55 +0,0 @@
-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,
-    IndependentUpdate = 1,
-    ManualMount = 2
-}
-export declare const enum Priority {
-    Realtime = 0,
-    Normal = 1,
-    Background = 2
-}
-export interface RxNode<E = unknown> {
-    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;
-    priority?: Priority;
-    childrenShuffling: boolean;
-    strictOrder: boolean;
-    has(mode: Mode): boolean;
-    configureReactronic(options: Partial<MemberOptions>): MemberOptions;
-}
-export interface RxNodeDecl<E = unknown> {
-    preset?: RxNodeDecl<E>;
-    key?: string;
-    mode?: Mode;
-    triggers?: unknown;
-    initialize?: Delegate<E>;
-    update?: Delegate<E>;
-    finalize?: Delegate<E>;
-}
-export interface RxNodeDriver<E = unknown> {
-    readonly name: string;
-    readonly isPartitionSeparator: boolean;
-    readonly predefine?: SimpleDelegate<E>;
-    allocate(node: RxNode<E>): E;
-    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/RxNode.js

@@ -1,12 +0,0 @@
-export var Mode;
-(function (Mode) {
-    Mode[Mode["Default"] = 0] = "Default";
-    Mode[Mode["IndependentUpdate"] = 1] = "IndependentUpdate";
-    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 = {}));