reactronic 0.93.25025 → 0.94.25027

package/build/dist/source/core/{ReactiveNode.js → TreeNode.js}

@@ -19,144 +19,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { misuse } from "../util/Dbg.js";
 import { MergeList } from "../util/MergeList.js";
 import { emitLetters, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js";
-import { Isolation, Reentrance } from "../Options.js";
-import { TriggeringObject } from "../core/Mvcc.js";
+import { Priority, Mode, Isolation, Reentrance } from "../Enums.js";
+import { ObservableObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
-import { ReactiveSystem, options, trigger, reaction, atomicRun, nonReactiveRun } from "../ReactiveSystem.js";
-export var Mode;
-(function (Mode) {
-    Mode[Mode["default"] = 0] = "default";
-    Mode[Mode["autonomous"] = 1] = "autonomous";
-    Mode[Mode["manualMount"] = 2] = "manualMount";
-    Mode[Mode["rootNode"] = 4] = "rootNode";
-})(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 ReactiveNode {
-    static declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
-        let result;
-        let declaration;
-        if (scriptOrDeclaration instanceof Function) {
-            declaration = {
-                script: scriptOrDeclaration, scriptAsync, key, mode,
-                preparation, preparationAsync, finalization, triggers, basis,
-            };
-        }
-        else
-            declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
-        let effectiveKey = declaration.key;
-        const owner = (getModeUsingBasisChain(declaration) & Mode.rootNode) !== Mode.rootNode ? gNodeSlot === null || gNodeSlot === void 0 ? void 0 : gNodeSlot.instance : undefined;
-        if (owner) {
-            let existing = owner.driver.declareChild(owner, driver, declaration, declaration.basis);
-            const children = owner.children;
-            existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside 'script' only"));
-            if (existing) {
-                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;
-                result.declaration = declaration;
-            }
-            else {
-                result = new ReactiveNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
-                result.slot = children.mergeAsAdded(result);
-            }
-        }
-        else {
-            result = new ReactiveNodeImpl(effectiveKey || "", driver, declaration, owner);
-            result.slot = MergeList.createItem(result);
-            triggerScriptRunViaSlot(result.slot);
-        }
-        return result;
-    }
-    static withBasis(declaration, basis) {
-        if (declaration)
-            declaration.basis = basis;
-        else
-            declaration = basis !== null && basis !== void 0 ? basis : {};
-        return declaration;
-    }
-    static get isFirstScriptRun() {
-        return ReactiveNodeImpl.nodeSlot.instance.stamp === 1;
-    }
-    static get key() {
-        return ReactiveNodeImpl.nodeSlot.instance.key;
-    }
-    static get stamp() {
-        return ReactiveNodeImpl.nodeSlot.instance.stamp;
-    }
-    static get triggers() {
-        return ReactiveNodeImpl.nodeSlot.instance.declaration.triggers;
-    }
-    static get priority() {
-        return ReactiveNodeImpl.nodeSlot.instance.priority;
-    }
-    static set priority(value) {
-        ReactiveNodeImpl.nodeSlot.instance.priority = value;
-    }
-    static get childrenShuffling() {
-        return ReactiveNodeImpl.nodeSlot.instance.childrenShuffling;
-    }
-    static set childrenShuffling(value) {
-        ReactiveNodeImpl.nodeSlot.instance.childrenShuffling = value;
-    }
-    static triggerScriptRun(node, triggers) {
-        const impl = node;
-        const declaration = impl.declaration;
-        if (!triggersAreEqual(triggers, declaration.triggers)) {
-            declaration.triggers = triggers;
-            triggerScriptRunViaSlot(impl.slot);
-        }
-    }
-    static triggerFinalization(node) {
-        const impl = node;
-        triggerFinalization(impl.slot, true, true);
-    }
-    static runNestedNodeScriptsThenDo(action) {
-        runNestedNodeScriptsThenDoImpl(ReactiveNodeImpl.nodeSlot, undefined, action);
-    }
-    static markAsMounted(node, yes) {
-        const n = node;
-        if (n.stamp < 0)
-            throw new Error("deactivated node cannot be mounted or unmounted");
-        if (n.stamp >= Number.MAX_SAFE_INTEGER)
-            throw new Error("node must be activated before mounting");
-        n.stamp = yes ? 0 : Number.MAX_SAFE_INTEGER - 1;
-    }
-    static findMatchingHost(node, match) {
-        let p = node.host;
-        while (p !== p.host && !match(p))
-            p = p.host;
-        return p;
-    }
-    static findMatchingPrevSibling(node, match) {
-        let p = node.slot.prev;
-        while (p && !match(p.instance))
-            p = p.prev;
-        return p === null || p === void 0 ? void 0 : p.instance;
-    }
-    static forEachChildRecursively(node, action) {
-        action(node);
-        for (const child of node.children.items())
-            ReactiveNode.forEachChildRecursively(child.instance, action);
-    }
-    static getDefaultLoggingOptions() {
-        return ReactiveNodeImpl.logging;
-    }
-    static setDefaultLoggingOptions(logging) {
-        ReactiveNodeImpl.logging = logging;
-    }
+import { ReactiveSystem, options, observable, reactive, runAtomically, runNonReactively, manageReactiveOperation, disposeObservableObject } from "../System.js";
+export class ReactiveTreeNode {
 }
-ReactiveNode.shortFrameDuration = 16;
-ReactiveNode.longFrameDuration = 300;
-ReactiveNode.currentScriptPriority = Priority.realtime;
-ReactiveNode.frameDuration = ReactiveNode.longFrameDuration;
 export class BaseDriver {
     constructor(name, isPartition, initialize) {
         this.name = name;
@@ -184,21 +52,21 @@ export class BaseDriver {
         return node;
     }
 }
-export class ReactiveNodeVariable {
+export class ReactiveTreeVariable {
     constructor(defaultValue) {
         this.defaultValue = defaultValue;
     }
     set value(value) {
-        ReactiveNodeImpl.setNodeVariableValue(this, value);
+        ReactiveTreeNodeImpl.setNodeVariableValue(this, value);
     }
     get value() {
-        return ReactiveNodeImpl.useNodeVariableValue(this);
+        return ReactiveTreeNodeImpl.useNodeVariableValue(this);
     }
     get valueOrUndefined() {
-        return ReactiveNodeImpl.tryUseNodeVariableValue(this);
+        return ReactiveTreeNodeImpl.tryUseNodeVariableValue(this);
     }
 }
-function generateKey(owner) {
+export function generateKey(owner) {
     const n = owner.numerator++;
     const lettered = emitLetters(n);
     let result;
@@ -250,7 +118,7 @@ function invokeFinalizationUsingBasisChain(element, declaration) {
     else if (basis)
         invokeFinalizationUsingBasisChain(element, basis);
 }
-class ReactiveNodeContextImpl extends TriggeringObject {
+class ReactiveTreeNodeContextImpl extends ObservableObject {
     constructor(variable, value) {
         super();
         this.next = undefined;
@@ -259,14 +127,14 @@ class ReactiveNodeContextImpl extends TriggeringObject {
     }
 }
 __decorate([
-    trigger(false),
+    observable(false),
     __metadata("design:type", Object)
-], ReactiveNodeContextImpl.prototype, "next", void 0);
+], ReactiveTreeNodeContextImpl.prototype, "next", void 0);
 __decorate([
-    trigger(false),
-    __metadata("design:type", ReactiveNodeVariable)
-], ReactiveNodeContextImpl.prototype, "variable", void 0);
-class ReactiveNodeImpl extends ReactiveNode {
+    observable(false),
+    __metadata("design:type", ReactiveTreeVariable)
+], ReactiveTreeNodeContextImpl.prototype, "variable", void 0);
+class ReactiveTreeNodeImpl extends ReactiveTreeNode {
     constructor(key, driver, declaration, owner) {
         super();
         const thisAsUnknown = this;
@@ -293,9 +161,9 @@ class ReactiveNodeImpl extends ReactiveNode {
         this.numerator = 0;
         this.priority = Priority.realtime;
         this.childrenShuffling = false;
-        ReactiveNodeImpl.grandNodeCount++;
+        ReactiveTreeNodeImpl.grandNodeCount++;
         if (this.has(Mode.autonomous))
-            ReactiveNodeImpl.disposableNodeCount++;
+            ReactiveTreeNodeImpl.disposableNodeCount++;
     }
     get strictOrder() { return this.children.isStrict; }
     set strictOrder(value) { this.children.isStrict = value; }
@@ -309,7 +177,7 @@ class ReactiveNodeImpl extends ReactiveNode {
     configureReactronic(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.autonomous))
             throw new Error("reactronic can be configured only for elements with autonomous mode and only during activation");
-        return ReactiveSystem.getOperation(this.script).configure(options);
+        return manageReactiveOperation(this.script).configure(options);
     }
     static get nodeSlot() {
         if (!gNodeSlot)
@@ -318,35 +186,35 @@ class ReactiveNodeImpl extends ReactiveNode {
     }
     static tryUseNodeVariableValue(variable) {
         var _a, _b;
-        let node = ReactiveNodeImpl.nodeSlot.instance;
+        let node = ReactiveTreeNodeImpl.nodeSlot.instance;
         while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
             node = node.outer.slot.instance;
         return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
     static useNodeVariableValue(variable) {
         var _a;
-        const result = (_a = ReactiveNodeImpl.tryUseNodeVariableValue(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
+        const result = (_a = ReactiveTreeNodeImpl.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 = ReactiveNodeImpl.nodeSlot.instance;
+        const node = ReactiveTreeNodeImpl.nodeSlot.instance;
         const owner = node.owner;
-        const hostCtx = nonReactiveRun(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
+        const hostCtx = runNonReactively(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
             if (hostCtx)
                 node.outer = owner;
             else
                 node.outer = owner.outer;
-            atomicRun({ isolation: Isolation.joinAsNestedTransaction }, () => {
+            runAtomically({ isolation: Isolation.joinAsNestedTransaction }, () => {
                 const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
                     ctx.value = value;
                 }
                 else
-                    node.context = new ReactiveNodeContextImpl(variable, value);
+                    node.context = new ReactiveTreeNodeContextImpl(variable, value);
             });
         }
         else if (hostCtx)
@@ -355,21 +223,25 @@ class ReactiveNodeImpl extends ReactiveNode {
             node.outer = owner.outer;
     }
 }
-ReactiveNodeImpl.logging = undefined;
-ReactiveNodeImpl.grandNodeCount = 0;
-ReactiveNodeImpl.disposableNodeCount = 0;
+ReactiveTreeNodeImpl.logging = undefined;
+ReactiveTreeNodeImpl.grandNodeCount = 0;
+ReactiveTreeNodeImpl.disposableNodeCount = 0;
+ReactiveTreeNodeImpl.shortFrameDuration = 16;
+ReactiveTreeNodeImpl.longFrameDuration = 300;
+ReactiveTreeNodeImpl.currentScriptPriority = Priority.realtime;
+ReactiveTreeNodeImpl.frameDuration = ReactiveTreeNodeImpl.longFrameDuration;
 __decorate([
-    reaction,
+    reactive,
     options({
         reentrance: Reentrance.cancelAndWaitPrevious,
         allowObsoleteToFinish: true,
-        triggeringArgs: true,
+        observableArgs: true,
         noSideEffects: false,
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], ReactiveNodeImpl.prototype, "script", null);
+], ReactiveTreeNodeImpl.prototype, "script", null);
 function getNodeKey(node) {
     return node.stamp >= 0 ? node.key : undefined;
 }
@@ -444,29 +316,29 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
         const node = owner.instance;
-        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, ReactiveNode.shortFrameDuration / 3)) {
-            let outerPriority = ReactiveNode.currentScriptPriority;
-            ReactiveNode.currentScriptPriority = priority;
+        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, ReactiveTreeNodeImpl.shortFrameDuration / 3)) {
+            let outerPriority = ReactiveTreeNodeImpl.currentScriptPriority;
+            ReactiveTreeNodeImpl.currentScriptPriority = priority;
             try {
                 if (node.childrenShuffling)
                     shuffle(items);
-                const frameDurationLimit = priority === Priority.background ? ReactiveNode.shortFrameDuration : Infinity;
-                let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveNode.frameDuration / 4, ReactiveNode.shortFrameDuration));
+                const frameDurationLimit = priority === Priority.background ? ReactiveTreeNodeImpl.shortFrameDuration : Infinity;
+                let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveTreeNodeImpl.frameDuration / 4, ReactiveTreeNodeImpl.shortFrameDuration));
                 for (const child of items) {
                     triggerScriptRunViaSlot(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
-                        ReactiveNode.currentScriptPriority = outerPriority;
+                        ReactiveTreeNodeImpl.currentScriptPriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
-                        outerPriority = ReactiveNode.currentScriptPriority;
-                        ReactiveNode.currentScriptPriority = priority;
-                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveNode.frameDuration));
+                        outerPriority = ReactiveTreeNodeImpl.currentScriptPriority;
+                        ReactiveTreeNodeImpl.currentScriptPriority = priority;
+                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveTreeNodeImpl.frameDuration));
                     }
-                    if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveNode.shortFrameDuration / 3))
+                    if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveTreeNodeImpl.shortFrameDuration / 3))
                         break;
                 }
             }
             finally {
-                ReactiveNode.currentScriptPriority = outerPriority;
+                ReactiveTreeNodeImpl.currentScriptPriority = outerPriority;
             }
         }
     });
@@ -479,23 +351,23 @@ function triggerScriptRunViaSlot(nodeSlot) {
                 Transaction.outside(() => {
                     if (ReactiveSystem.isLogging)
                         ReactiveSystem.setLoggingHint(node.element, node.key);
-                    ReactiveSystem.getOperation(node.script).configure({
+                    manageReactiveOperation(node.script).configure({
                         order: node.level,
                     });
                 });
             }
-            nonReactiveRun(node.script, node.declaration.triggers);
+            runNonReactively(node.script, node.declaration.triggers);
         }
         else if (node.owner !== node)
             runScriptNow(nodeSlot);
         else
-            atomicRun(() => runScriptNow(nodeSlot));
+            runAtomically(() => runScriptNow(nodeSlot));
     }
 }
 function mountOrRemountIfNecessary(node) {
     const driver = node.driver;
     if (node.stamp === Number.MAX_SAFE_INTEGER) {
-        nonReactiveRun(() => {
+        runNonReactively(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
             driver.runPreparation(node);
             if (!node.has(Mode.manualMount)) {
@@ -506,7 +378,7 @@ function mountOrRemountIfNecessary(node) {
         });
     }
     else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
-        nonReactiveRun(() => driver.runMount(node));
+        runNonReactively(() => driver.runMount(node));
 }
 function runScriptNow(nodeSlot) {
     const node = nodeSlot.instance;
@@ -539,7 +411,7 @@ function triggerFinalization(nodeSlot, isLeader, individual) {
         if (individual && node.key !== node.declaration.key && !driver.isPartition)
             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 = nonReactiveRun(() => driver.runFinalization(node, isLeader));
+        const childrenAreLeaders = runNonReactively(() => driver.runFinalization(node, isLeader));
         if (node.has(Mode.autonomous)) {
             nodeSlot.aux = undefined;
             const last = gLastToDispose;
@@ -548,13 +420,13 @@ function triggerFinalization(nodeSlot, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = nodeSlot;
             if (gFirstToDispose === nodeSlot)
-                atomicRun({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
+                runAtomically({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }
         for (const child of node.children.items())
             triggerFinalization(child, childrenAreLeaders, false);
-        ReactiveNodeImpl.grandNodeCount--;
+        ReactiveTreeNodeImpl.grandNodeCount--;
     }
 }
 function runDisposalLoop() {
@@ -564,9 +436,9 @@ function runDisposalLoop() {
         while (slot !== undefined) {
             if (Transaction.isFrameOver(500, 5))
                 yield Transaction.requestNextFrame();
-            ReactiveSystem.dispose(slot.instance);
+            disposeObservableObject(slot.instance);
             slot = slot.aux;
-            ReactiveNodeImpl.disposableNodeCount--;
+            ReactiveTreeNodeImpl.disposableNodeCount--;
         }
         gFirstToDispose = gLastToDispose = undefined;
     });
@@ -592,7 +464,7 @@ function runInsideContextOfNode(nodeSlot, func, ...args) {
         gNodeSlot = outer;
     }
 }
-function triggersAreEqual(a1, a2) {
+export function observablesAreEqual(a1, a2) {
     let result = a1 === a2;
     if (!result) {
         if (Array.isArray(a1)) {

package/package.json

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

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

@@ -1,7 +0,0 @@
-import { F } from "./util/Utils.js";
-import { TriggeringObject } from "./core/Mvcc.js";
-export declare class ReactiveLoop<T> extends TriggeringObject {
-    protected reactiveFunction: F<T>;
-    constructor(reactiveFunction: F<T>);
-    protected launch(): T;
-}

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

@@ -1,30 +0,0 @@
-import { F } from "./util/Utils.js";
-import { Operation, MemberOptions, LoggingOptions, ProfilingOptions, SnapshotOptions } from "./Options.js";
-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;
-    static configureCurrentOperation(options: Partial<MemberOptions>): MemberOptions;
-    static getRevisionOf(obj: any): number;
-    static takeSnapshot<T>(obj: T): T;
-    static dispose(obj: any): void;
-    static get reactivityAutoStartDisabled(): boolean;
-    static set reactivityAutoStartDisabled(value: boolean);
-    static get isLogging(): boolean;
-    static get loggingOptions(): LoggingOptions;
-    static setLoggingMode(isOn: boolean, options?: LoggingOptions): void;
-    static setLoggingHint<T extends object>(obj: T, name: string | undefined): void;
-    static getLoggingHint<T extends object>(obj: T, full?: boolean): string | undefined;
-    static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
-}
-export declare function atomicRun<T>(func: F<T>, ...args: any[]): T;
-export declare function atomicRun<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
-export declare function nonReactiveRun<T>(func: F<T>, ...args: any[]): T;
-export declare function sensitiveRun<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
-export declare function contextualRun<T>(p: Promise<T>): Promise<T>;
-export declare function trigger(enabled: boolean): (proto: object, prop: PropertyKey) => any;
-export declare function trigger<T>(proto: object, prop: PropertyKey): any;
-export declare function atomicBlock(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
-export declare function reaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
-export declare function cache(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
-export declare function options(value: Partial<MemberOptions>): F<any>;

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

@@ -1,107 +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,
-    autonomous = 1,
-    manualMount = 2,
-    rootNode = 4
-}
-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 slot: 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 currentScriptPriority: Priority;
-    static frameDuration: number;
-    static declare<E = void>(driver: ReactiveNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: 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, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveNodeDecl<E>): ReactiveNode<E>;
-    static withBasis<E = void>(declaration?: ReactiveNodeDecl<E>, basis?: ReactiveNodeDecl<E>): ReactiveNodeDecl<E>;
-    static get isFirstScriptRun(): 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 triggerScriptRun(node: ReactiveNode<any>, triggers: unknown): void;
-    static triggerFinalization(node: ReactiveNode<any>): void;
-    static runNestedNodeScriptsThenDo(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;
-    preparation?: Script<E>;
-    preparationAsync?: ScriptAsync<E>;
-    finalization?: Script<E>;
-    triggers?: unknown;
-    basis?: ReactiveNodeDecl<E>;
-};
-export type ReactiveNodeDriver<E = unknown> = {
-    readonly name: string;
-    readonly isPartition: boolean;
-    readonly initialize?: Handler<E>;
-    create(node: ReactiveNode<E>): E;
-    runPreparation(node: ReactiveNode<E>): void;
-    runFinalization(node: ReactiveNode<E>, isLeader: boolean): boolean;
-    runMount(node: ReactiveNode<E>): void;
-    runScript(node: ReactiveNode<E>): void | Promise<void>;
-    declareChild(ownerNode: ReactiveNode<E>, childDriver: ReactiveNodeDriver<any>, childDeclaration?: ReactiveNodeDecl<any>, childBasis?: ReactiveNodeDecl<any>): MergedItem<ReactiveNode> | undefined;
-    provideHost(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 create(node: ReactiveNode<E>): E;
-    runPreparation(node: ReactiveNode<E>): void | Promise<void>;
-    runFinalization(node: ReactiveNode<E>, isLeader: boolean): boolean;
-    runMount(node: ReactiveNode<E>): void;
-    runScript(node: ReactiveNode<E>): void | Promise<void>;
-    declareChild(ownerNode: ReactiveNode<E>, childDriver: ReactiveNodeDriver<any>, childDeclaration?: ReactiveNodeDecl<any>, childBasis?: ReactiveNodeDecl<any>): MergedItem<ReactiveNode> | undefined;
-    provideHost(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;
-}