reactronic 0.24.116 → 0.24.118

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 './core/RxNode.js';
+export type { Delegate, SimpleDelegate, RxNodeDecl, RxNodeDriver, RxNodeContext } from './core/RxNode.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 './core/RxNode.js';
 export { Clock } from './Clock.js';

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

@@ -0,0 +1,88 @@
+import { LoggingOptions } from '../Logging.js';
+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;
+    static frameDuration: number;
+    static acquire<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 = 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 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, 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;
+    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;
+    constructor(defaultValue?: T);
+    set value(value: T);
+    get value(): T;
+    get valueOrUndefined(): T | undefined;
+}

package/build/dist/source/{tree/RxTree.js → core/RxNode.js}

@@ -22,9 +22,20 @@ 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 {
-    static declare(driver, declaration, preset) {
+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 acquire(driver, declaration, preset) {
         var _a;
         let result;
         if (declaration)
@@ -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;
             }
         }
     });

package/build/dist/source/{tree → core}/RxNodeUtils.js

@@ -18,7 +18,7 @@ export function getCallerInfo(prefix) {
     const stack = error.stack || '';
     Error.stackTraceLimit = restore;
     const lines = stack.split('\n');
-    let i = lines.findIndex(x => x.indexOf('.declare') >= 0);
+    let i = lines.findIndex(x => x.indexOf('.acquire') >= 0);
     i = i >= 0 ? i + 2 : 5;
     let caller = extractFunctionAndLocation(lines[i]);
     let location = caller;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.24.116",
+  "version": "0.24.118",
   "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 = {}));

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

@@ -1,36 +0,0 @@
-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<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 = 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 = 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(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;
-    constructor(defaultValue?: T);
-    set value(value: T);
-    get value(): T;
-    get valueOrUndefined(): T | undefined;
-}