reactronic 0.24.308 → 0.24.309

package/build/dist/source/Clock.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { ObservableObject } from "./core/Mvcc.js";
-import { transactional } from "./RxSystem.js";
+import { transactional } from "./ReactiveSystem.js";
 export class Clock extends ObservableObject {
     constructor(interval = 1000) {
         super();

package/build/dist/source/Reaction.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { ObservableObject } from "./core/Mvcc.js";
-import { reactive } from "./RxSystem.js";
+import { reactive } from "./ReactiveSystem.js";
 export class Reaction extends ObservableObject {
     constructor(action) {
         super();

package/build/dist/source/{RxSystem.d.ts → ReactiveSystem.d.ts}

@@ -1,6 +1,6 @@
 import { F } from "./util/Utils.js";
 import { Operation, MemberOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
-export declare class RxSystem {
+export declare class ReactiveSystem {
     static why(brief?: boolean): string;
     static getOperation<T>(method: F<T>): Operation<T>;
     static pullLastResult<T>(method: F<Promise<T>>, args?: any[]): T | undefined;

package/build/dist/source/{RxSystem.js → ReactiveSystem.js}

@@ -5,10 +5,10 @@ import { Changeset } from "./core/Changeset.js";
 import { Mvcc } from "./core/Mvcc.js";
 import { Transaction } from "./core/Transaction.js";
 import { OperationImpl } from "./core/Operation.js";
-export class RxSystem {
+export class ReactiveSystem {
     static why(brief = false) { return brief ? OperationImpl.briefWhy() : OperationImpl.why(); }
     static getOperation(method) { return OperationImpl.getControllerOf(method); }
-    static pullLastResult(method, args) { return RxSystem.getOperation(method).pullLastResult(args); }
+    static pullLastResult(method, args) { return ReactiveSystem.getOperation(method).pullLastResult(args); }
     static configureCurrentOperation(options) { return OperationImpl.configureImpl(undefined, options); }
     static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }

package/build/dist/source/Ref.js

@@ -1,5 +1,5 @@
 import { Transaction } from "./core/Transaction.js";
-import { unobs } from "./RxSystem.js";
+import { unobs } from "./ReactiveSystem.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }

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

@@ -16,8 +16,8 @@ export { Changeset } from "./core/Changeset.js";
 export { Transaction } from "./core/Transaction.js";
 export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
-export { RxSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from "./RxSystem.js";
+export { ReactiveSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from "./ReactiveSystem.js";
 export { Reaction } from "./Reaction.js";
-export { RxNode, Mode, Priority, BaseDriver, RxNodeVariable } from "./core/RxNode.js";
-export type { Script, ScriptAsync, Handler, RxNodeDecl, RxNodeDriver, RxNodeContext } from "./core/RxNode.js";
+export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
+export type { Script, ScriptAsync, Handler, ReactiveNodeDecl, ReactiveNodeDriver, ReactiveNodeContext } from "./core/ReactiveNode.js";
 export { Clock } from "./Clock.js";

package/build/dist/source/api.js

@@ -12,7 +12,7 @@ export { Changeset } from "./core/Changeset.js";
 export { Transaction } from "./core/Transaction.js";
 export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
-export { RxSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from "./RxSystem.js";
+export { ReactiveSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from "./ReactiveSystem.js";
 export { Reaction } from "./Reaction.js";
-export { RxNode, Mode, Priority, BaseDriver, RxNodeVariable } from "./core/RxNode.js";
+export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export { Clock } from "./Clock.js";

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

@@ -0,0 +1,106 @@
+import { LoggingOptions } from "../Logging.js";
+import { MergeListReader, MergedItem } from "../util/MergeList.js";
+import { MemberOptions } from "../Options.js";
+export type Script<E> = (e: E, basis: () => void) => void;
+export type ScriptAsync<E> = (e: E, basis: () => Promise<void>) => Promise<void>;
+export type Handler<E = unknown, R = void> = (e: E) => R;
+export declare enum Mode {
+    default = 0,
+    independentUpdate = 1,
+    manualMount = 2
+}
+export declare enum Priority {
+    realtime = 0,
+    normal = 1,
+    background = 2
+}
+export declare abstract class ReactiveNode<E = unknown> {
+    abstract readonly key: string;
+    abstract readonly driver: ReactiveNodeDriver<E>;
+    abstract readonly declaration: Readonly<ReactiveNodeDecl<E>>;
+    abstract readonly level: number;
+    abstract readonly owner: ReactiveNode;
+    abstract element: E;
+    abstract readonly host: ReactiveNode;
+    abstract readonly children: MergeListReader<ReactiveNode>;
+    abstract readonly seat: MergedItem<ReactiveNode<E>> | undefined;
+    abstract readonly stamp: number;
+    abstract readonly outer: ReactiveNode;
+    abstract readonly context: ReactiveNodeContext | 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 declare<E = void>(driver: ReactiveNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, creation?: Script<E>, creationAsync?: ScriptAsync<E>, destruction?: Script<E>, triggers?: unknown, basis?: ReactiveNodeDecl<E>): ReactiveNode<E>;
+    static declare<E = void>(driver: ReactiveNodeDriver<E>, declaration?: ReactiveNodeDecl<E>): ReactiveNode<E>;
+    static declare<E = void>(driver: ReactiveNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, creation?: Script<E>, creationAsync?: ScriptAsync<E>, destruction?: Script<E>, triggers?: unknown, basis?: ReactiveNodeDecl<E>): ReactiveNode<E>;
+    static withBasis<E = void>(declaration?: ReactiveNodeDecl<E>, basis?: ReactiveNodeDecl<E>): ReactiveNodeDecl<E>;
+    static get isFirstUpdate(): boolean;
+    static get key(): string;
+    static get stamp(): number;
+    static get triggers(): unknown;
+    static get priority(): Priority;
+    static set priority(value: Priority);
+    static get childrenShuffling(): boolean;
+    static set childrenShuffling(value: boolean);
+    static triggerUpdate(node: ReactiveNode<any>, triggers: unknown): void;
+    static triggerDeactivation(node: ReactiveNode<any>): void;
+    static updateNestedNodesThenDo(action: (error: unknown) => void): void;
+    static markAsMounted(node: ReactiveNode<any>, yes: boolean): void;
+    static findMatchingHost<E = unknown, R = unknown>(node: ReactiveNode<E>, match: Handler<ReactiveNode<E>, boolean>): ReactiveNode<R> | undefined;
+    static findMatchingPrevSibling<E = unknown, R = unknown>(node: ReactiveNode<E>, match: Handler<ReactiveNode<E>, boolean>): ReactiveNode<R> | undefined;
+    static forEachChildRecursively<E = unknown>(node: ReactiveNode<E>, action: Handler<ReactiveNode<E>>): void;
+    static getDefaultLoggingOptions(): LoggingOptions | undefined;
+    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
+}
+export type ReactiveNodeDecl<E = unknown> = {
+    script?: Script<E>;
+    scriptAsync?: ScriptAsync<E>;
+    key?: string;
+    mode?: Mode;
+    creation?: Script<E>;
+    creationAsync?: ScriptAsync<E>;
+    destruction?: Script<E>;
+    triggers?: unknown;
+    basis?: ReactiveNodeDecl<E>;
+};
+export type ReactiveNodeDriver<E = unknown> = {
+    readonly name: string;
+    readonly isPartition: boolean;
+    readonly initialize?: Handler<E>;
+    allocate(node: ReactiveNode<E>): E;
+    create(node: ReactiveNode<E>): void;
+    destroy(node: ReactiveNode<E>, isLeader: boolean): boolean;
+    mount(node: ReactiveNode<E>): void;
+    update(node: ReactiveNode<E>): void | Promise<void>;
+    child(ownerNode: ReactiveNode<E>, childDriver: ReactiveNodeDriver<any>, childDeclaration?: ReactiveNodeDecl<any>, childBasis?: ReactiveNodeDecl<any>): MergedItem<ReactiveNode> | undefined;
+    getHost(node: ReactiveNode<E>): ReactiveNode<E>;
+};
+export type ReactiveNodeContext<T extends Object = Object> = {
+    value: T;
+};
+export declare abstract class BaseDriver<E = unknown> implements ReactiveNodeDriver<E> {
+    readonly name: string;
+    readonly isPartition: boolean;
+    readonly initialize?: Handler<E> | undefined;
+    constructor(name: string, isPartition: boolean, initialize?: Handler<E> | undefined);
+    abstract allocate(node: ReactiveNode<E>): E;
+    create(node: ReactiveNode<E>): void | Promise<void>;
+    destroy(node: ReactiveNode<E>, isLeader: boolean): boolean;
+    mount(node: ReactiveNode<E>): void;
+    update(node: ReactiveNode<E>): void | Promise<void>;
+    child(ownerNode: ReactiveNode<E>, childDriver: ReactiveNodeDriver<any>, childDeclaration?: ReactiveNodeDecl<any>, childBasis?: ReactiveNodeDecl<any>): MergedItem<ReactiveNode> | undefined;
+    getHost(node: ReactiveNode<E>): ReactiveNode<E>;
+}
+export declare class ReactiveNodeVariable<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/core/{RxNode.js → ReactiveNode.js}

@@ -22,7 +22,7 @@ import { emitLetters, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js
 import { Isolation, 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 { ReactiveSystem, options, raw, reactive, unobs } from "../ReactiveSystem.js";
 export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
@@ -35,7 +35,7 @@ export var Priority;
     Priority[Priority["normal"] = 1] = "normal";
     Priority[Priority["background"] = 2] = "background";
 })(Priority || (Priority = {}));
-export class RxNode {
+export class ReactiveNode {
     static declare(driver, scriptOrDeclaration, scriptAsync, key, mode, creation, creationAsync, destruction, triggers, basis) {
         let result;
         let declaration;
@@ -63,18 +63,18 @@ export class RxNode {
                 result.declaration = declaration;
             }
             else {
-                result = new RxNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
+                result = new ReactiveNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
                 result.seat = children.mergeAsAdded(result);
             }
         }
         else {
-            result = new RxNodeImpl(effectiveKey || "", driver, declaration, owner);
+            result = new ReactiveNodeImpl(effectiveKey || "", driver, declaration, owner);
             result.seat = MergeList.createItem(result);
             triggerUpdateViaSeat(result.seat);
         }
         return result;
     }
-    static rebased(declaration, basis) {
+    static withBasis(declaration, basis) {
         if (declaration)
             declaration.basis = basis;
         else
@@ -82,28 +82,28 @@ export class RxNode {
         return declaration;
     }
     static get isFirstUpdate() {
-        return RxNodeImpl.ownSeat.instance.stamp === 1;
+        return ReactiveNodeImpl.ownSeat.instance.stamp === 1;
     }
     static get key() {
-        return RxNodeImpl.ownSeat.instance.key;
+        return ReactiveNodeImpl.ownSeat.instance.key;
     }
     static get stamp() {
-        return RxNodeImpl.ownSeat.instance.stamp;
+        return ReactiveNodeImpl.ownSeat.instance.stamp;
     }
     static get triggers() {
-        return RxNodeImpl.ownSeat.instance.declaration.triggers;
+        return ReactiveNodeImpl.ownSeat.instance.declaration.triggers;
     }
     static get priority() {
-        return RxNodeImpl.ownSeat.instance.priority;
+        return ReactiveNodeImpl.ownSeat.instance.priority;
     }
     static set priority(value) {
-        RxNodeImpl.ownSeat.instance.priority = value;
+        ReactiveNodeImpl.ownSeat.instance.priority = value;
     }
     static get childrenShuffling() {
-        return RxNodeImpl.ownSeat.instance.childrenShuffling;
+        return ReactiveNodeImpl.ownSeat.instance.childrenShuffling;
     }
     static set childrenShuffling(value) {
-        RxNodeImpl.ownSeat.instance.childrenShuffling = value;
+        ReactiveNodeImpl.ownSeat.instance.childrenShuffling = value;
     }
     static triggerUpdate(node, triggers) {
         const impl = node;
@@ -118,7 +118,7 @@ export class RxNode {
         triggerDeactivation(impl.seat, true, true);
     }
     static updateNestedNodesThenDo(action) {
-        runUpdateNestedNodesThenDo(RxNodeImpl.ownSeat, undefined, action);
+        runUpdateNestedNodesThenDo(ReactiveNodeImpl.ownSeat, undefined, action);
     }
     static markAsMounted(node, yes) {
         const n = node;
@@ -143,19 +143,19 @@ export class RxNode {
     static forEachChildRecursively(node, action) {
         action(node);
         for (const child of node.children.items())
-            RxNode.forEachChildRecursively(child.instance, action);
+            ReactiveNode.forEachChildRecursively(child.instance, action);
     }
     static getDefaultLoggingOptions() {
-        return RxNodeImpl.logging;
+        return ReactiveNodeImpl.logging;
     }
     static setDefaultLoggingOptions(logging) {
-        RxNodeImpl.logging = logging;
+        ReactiveNodeImpl.logging = logging;
     }
 }
-RxNode.shortFrameDuration = 16;
-RxNode.longFrameDuration = 300;
-RxNode.currentUpdatePriority = Priority.realtime;
-RxNode.frameDuration = RxNode.longFrameDuration;
+ReactiveNode.shortFrameDuration = 16;
+ReactiveNode.longFrameDuration = 300;
+ReactiveNode.currentUpdatePriority = Priority.realtime;
+ReactiveNode.frameDuration = ReactiveNode.longFrameDuration;
 export class BaseDriver {
     constructor(name, isPartition, initialize) {
         this.name = name;
@@ -183,25 +183,25 @@ export class BaseDriver {
         return node;
     }
 }
-export class RxNodeVariable {
+export class ReactiveNodeVariable {
     constructor(defaultValue) {
         this.defaultValue = defaultValue;
     }
     set value(value) {
-        RxNodeImpl.setNodeVariableValue(this, value);
+        ReactiveNodeImpl.setNodeVariableValue(this, value);
     }
     get value() {
-        return RxNodeImpl.useNodeVariableValue(this);
+        return ReactiveNodeImpl.useNodeVariableValue(this);
     }
     get valueOrUndefined() {
-        return RxNodeImpl.tryUseNodeVariableValue(this);
+        return ReactiveNodeImpl.tryUseNodeVariableValue(this);
     }
 }
 function generateKey(owner) {
     const n = owner.numerator++;
     const lettered = emitLetters(n);
     let result;
-    if (RxSystem.isLogging)
+    if (ReactiveSystem.isLogging)
         result = `·${getCallerInfo(lettered)}`;
     else
         result = `·${lettered}`;
@@ -255,7 +255,7 @@ function invokeDestructionUsingBasisChain(element, declaration) {
     else if (basis)
         invokeDestructionUsingBasisChain(element, basis);
 }
-class RxNodeContextImpl extends ObservableObject {
+class ReactiveNodeContextImpl extends ObservableObject {
     constructor(variable, value) {
         super();
         this.next = undefined;
@@ -266,12 +266,12 @@ class RxNodeContextImpl extends ObservableObject {
 __decorate([
     raw,
     __metadata("design:type", Object)
-], RxNodeContextImpl.prototype, "next", void 0);
+], ReactiveNodeContextImpl.prototype, "next", void 0);
 __decorate([
     raw,
-    __metadata("design:type", RxNodeVariable)
-], RxNodeContextImpl.prototype, "variable", void 0);
-class RxNodeImpl extends RxNode {
+    __metadata("design:type", ReactiveNodeVariable)
+], ReactiveNodeContextImpl.prototype, "variable", void 0);
+class ReactiveNodeImpl extends ReactiveNode {
     constructor(key, driver, declaration, owner) {
         super();
         const thisAsUnknown = this;
@@ -298,9 +298,9 @@ class RxNodeImpl extends RxNode {
         this.numerator = 0;
         this.priority = Priority.realtime;
         this.childrenShuffling = false;
-        RxNodeImpl.grandNodeCount++;
+        ReactiveNodeImpl.grandNodeCount++;
         if (this.has(Mode.independentUpdate))
-            RxNodeImpl.disposableNodeCount++;
+            ReactiveNodeImpl.disposableNodeCount++;
     }
     get strictOrder() { return this.children.isStrict; }
     set strictOrder(value) { this.children.isStrict = value; }
@@ -314,7 +314,7 @@ class RxNodeImpl extends RxNode {
     configureReactronic(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.independentUpdate))
             throw new Error("reactronic can be configured only for elements with independent update mode and only during activation");
-        return RxSystem.getOperation(this.update).configure(options);
+        return ReactiveSystem.getOperation(this.update).configure(options);
     }
     static get ownSeat() {
         if (!gOwnSeat)
@@ -323,20 +323,20 @@ class RxNodeImpl extends RxNode {
     }
     static tryUseNodeVariableValue(variable) {
         var _a, _b;
-        let node = RxNodeImpl.ownSeat.instance;
+        let node = ReactiveNodeImpl.ownSeat.instance;
         while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
             node = node.outer.seat.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;
+        const result = (_a = ReactiveNodeImpl.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.ownSeat.instance;
+        const node = ReactiveNodeImpl.ownSeat.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) {
@@ -351,7 +351,7 @@ class RxNodeImpl extends RxNode {
                     ctx.value = value;
                 }
                 else
-                    node.context = new RxNodeContextImpl(variable, value);
+                    node.context = new ReactiveNodeContextImpl(variable, value);
             });
         }
         else if (hostCtx)
@@ -360,9 +360,9 @@ class RxNodeImpl extends RxNode {
             node.outer = owner.outer;
     }
 }
-RxNodeImpl.logging = undefined;
-RxNodeImpl.grandNodeCount = 0;
-RxNodeImpl.disposableNodeCount = 0;
+ReactiveNodeImpl.logging = undefined;
+ReactiveNodeImpl.grandNodeCount = 0;
+ReactiveNodeImpl.disposableNodeCount = 0;
 __decorate([
     reactive,
     options({
@@ -374,7 +374,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], RxNodeImpl.prototype, "update", null);
+], ReactiveNodeImpl.prototype, "update", null);
 function getNodeKey(node) {
     return node.stamp >= 0 ? node.key : undefined;
 }
@@ -449,29 +449,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, RxNode.shortFrameDuration / 3)) {
-            let outerPriority = RxNode.currentUpdatePriority;
-            RxNode.currentUpdatePriority = priority;
+        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, ReactiveNode.shortFrameDuration / 3)) {
+            let outerPriority = ReactiveNode.currentUpdatePriority;
+            ReactiveNode.currentUpdatePriority = priority;
             try {
                 if (node.childrenShuffling)
                     shuffle(items);
-                const frameDurationLimit = priority === Priority.background ? RxNode.shortFrameDuration : Infinity;
-                let frameDuration = Math.min(frameDurationLimit, Math.max(RxNode.frameDuration / 4, RxNode.shortFrameDuration));
+                const frameDurationLimit = priority === Priority.background ? ReactiveNode.shortFrameDuration : Infinity;
+                let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveNode.frameDuration / 4, ReactiveNode.shortFrameDuration));
                 for (const child of items) {
                     triggerUpdateViaSeat(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
-                        RxNode.currentUpdatePriority = outerPriority;
+                        ReactiveNode.currentUpdatePriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
-                        outerPriority = RxNode.currentUpdatePriority;
-                        RxNode.currentUpdatePriority = priority;
-                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, RxNode.frameDuration));
+                        outerPriority = ReactiveNode.currentUpdatePriority;
+                        ReactiveNode.currentUpdatePriority = priority;
+                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveNode.frameDuration));
                     }
-                    if (Transaction.isCanceled && Transaction.isFrameOver(1, RxNode.shortFrameDuration / 3))
+                    if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveNode.shortFrameDuration / 3))
                         break;
                 }
             }
             finally {
-                RxNode.currentUpdatePriority = outerPriority;
+                ReactiveNode.currentUpdatePriority = outerPriority;
             }
         }
     });
@@ -482,9 +482,9 @@ function triggerUpdateViaSeat(seat) {
         if (node.has(Mode.independentUpdate)) {
             if (node.stamp === Number.MAX_SAFE_INTEGER) {
                 Transaction.outside(() => {
-                    if (RxSystem.isLogging)
-                        RxSystem.setLoggingHint(node.element, node.key);
-                    RxSystem.getOperation(node.update).configure({
+                    if (ReactiveSystem.isLogging)
+                        ReactiveSystem.setLoggingHint(node.element, node.key);
+                    ReactiveSystem.getOperation(node.update).configure({
                         order: node.level,
                     });
                 });
@@ -557,7 +557,7 @@ function triggerDeactivation(seat, isLeader, individual) {
         }
         for (const child of node.children.items())
             triggerDeactivation(child, childrenAreLeaders, false);
-        RxNodeImpl.grandNodeCount--;
+        ReactiveNodeImpl.grandNodeCount--;
     }
 }
 function runDisposalLoop() {
@@ -567,9 +567,9 @@ function runDisposalLoop() {
         while (seat !== undefined) {
             if (Transaction.isFrameOver(500, 5))
                 yield Transaction.requestNextFrame();
-            RxSystem.dispose(seat.instance);
+            ReactiveSystem.dispose(seat.instance);
             seat = seat.aux;
-            RxNodeImpl.disposableNodeCount--;
+            ReactiveNodeImpl.disposableNodeCount--;
         }
         gFirstToDispose = gLastToDispose = undefined;
     });

package/package.json

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

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

@@ -1,106 +0,0 @@
-import { LoggingOptions } from "../Logging.js";
-import { MergeListReader, MergedItem } from "../util/MergeList.js";
-import { MemberOptions } from "../Options.js";
-export type Script<E> = (el: E, basis: () => void) => void;
-export type ScriptAsync<E> = (el: E, basis: () => Promise<void>) => Promise<void>;
-export type Handler<E = unknown, R = void> = (el: E) => R;
-export declare enum Mode {
-    default = 0,
-    independentUpdate = 1,
-    manualMount = 2
-}
-export declare 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 declare<E = void>(driver: RxNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, creation?: Script<E>, creationAsync?: ScriptAsync<E>, destruction?: Script<E>, triggers?: unknown, basis?: RxNodeDecl<E>): RxNode<E>;
-    static declare<E = void>(driver: RxNodeDriver<E>, declaration?: RxNodeDecl<E>): RxNode<E>;
-    static declare<E = void>(driver: RxNodeDriver<E>, scriptOrDeclaration?: Script<E> | RxNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, creation?: Script<E>, creationAsync?: ScriptAsync<E>, destruction?: Script<E>, triggers?: unknown, basis?: RxNodeDecl<E>): RxNode<E>;
-    static rebased<E = void>(declaration?: RxNodeDecl<E>, basis?: RxNodeDecl<E>): RxNodeDecl<E>;
-    static get isFirstUpdate(): boolean;
-    static get key(): string;
-    static get stamp(): number;
-    static get triggers(): unknown;
-    static get priority(): Priority;
-    static set priority(value: Priority);
-    static get childrenShuffling(): boolean;
-    static set childrenShuffling(value: boolean);
-    static triggerUpdate(node: RxNode<any>, triggers: unknown): void;
-    static triggerDeactivation(node: RxNode<any>): void;
-    static updateNestedNodesThenDo(action: (error: unknown) => void): void;
-    static markAsMounted(node: RxNode<any>, yes: boolean): void;
-    static findMatchingHost<E = unknown, R = unknown>(node: RxNode<E>, match: Handler<RxNode<E>, boolean>): RxNode<R> | undefined;
-    static findMatchingPrevSibling<E = unknown, R = unknown>(node: RxNode<E>, match: Handler<RxNode<E>, boolean>): RxNode<R> | undefined;
-    static forEachChildRecursively<E = unknown>(node: RxNode<E>, action: Handler<RxNode<E>>): void;
-    static getDefaultLoggingOptions(): LoggingOptions | undefined;
-    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
-}
-export type RxNodeDecl<E = unknown> = {
-    script?: Script<E>;
-    scriptAsync?: ScriptAsync<E>;
-    key?: string;
-    mode?: Mode;
-    creation?: Script<E>;
-    creationAsync?: ScriptAsync<E>;
-    destruction?: Script<E>;
-    triggers?: unknown;
-    basis?: RxNodeDecl<E>;
-};
-export type RxNodeDriver<E = unknown> = {
-    readonly name: string;
-    readonly isPartition: boolean;
-    readonly initialize?: Handler<E>;
-    allocate(node: RxNode<E>): E;
-    create(node: RxNode<E>): void;
-    destroy(node: RxNode<E>, isLeader: boolean): boolean;
-    mount(node: RxNode<E>): void;
-    update(node: RxNode<E>): void | Promise<void>;
-    child(ownerNode: RxNode<E>, childDriver: RxNodeDriver<any>, childDeclaration?: RxNodeDecl<any>, childBasis?: RxNodeDecl<any>): MergedItem<RxNode> | undefined;
-    getHost(node: RxNode<E>): RxNode<E>;
-};
-export type RxNodeContext<T extends Object = Object> = {
-    value: T;
-};
-export declare abstract class BaseDriver<E = unknown> implements RxNodeDriver<E> {
-    readonly name: string;
-    readonly isPartition: boolean;
-    readonly initialize?: Handler<E> | undefined;
-    constructor(name: string, isPartition: boolean, initialize?: Handler<E> | undefined);
-    abstract allocate(node: RxNode<E>): E;
-    create(node: RxNode<E>): void | Promise<void>;
-    destroy(node: RxNode<E>, isLeader: boolean): boolean;
-    mount(node: RxNode<E>): void;
-    update(node: RxNode<E>): void | Promise<void>;
-    child(ownerNode: RxNode<E>, childDriver: RxNodeDriver<any>, childDeclaration?: RxNodeDecl<any>, childBasis?: RxNodeDecl<any>): MergedItem<RxNode> | undefined;
-    getHost(node: RxNode<E>): RxNode<E>;
-}
-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;
-}