reactronic 0.24.113 → 0.24.115

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

@@ -1,4 +1,4 @@
-import { ObservableObject } from './impl/Mvcc.js';
+import { ObservableObject } from './core/Mvcc.js';
 export declare class Clock extends ObservableObject {
     hour: number;
     minute: number;

package/build/dist/source/Clock.js

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

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

@@ -1,9 +1,9 @@
 import { LoggingOptions } from './Logging.js';
-import { SeparationMode } from './impl/Data.js';
+import { SeparationMode } from './core/Data.js';
 export { LoggingLevel } from './Logging.js';
 export type { LoggingOptions, ProfilingOptions } from './Logging.js';
-import { Journal } from './impl/Journal.js';
-import { Monitor } from './impl/Monitor.js';
+import { Journal } from './core/Journal.js';
+import { Monitor } from './core/Monitor.js';
 export interface SnapshotOptions {
     readonly hint?: string;
     readonly separation?: SeparationMode;

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

@@ -1,4 +1,4 @@
-import { ObservableObject } from './impl/Mvcc.js';
+import { ObservableObject } from './core/Mvcc.js';
 export declare abstract class Pipe<T> extends ObservableObject {
     abstract readonly capacity: number;
     abstract readonly count: number;

package/build/dist/source/Pipe.js

@@ -1,4 +1,4 @@
-import { ObservableObject } from './impl/Mvcc.js';
+import { ObservableObject } from './core/Mvcc.js';
 export class Pipe extends ObservableObject {
     static create(hint, capacity) { throw new Error('not implemented'); }
 }

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

@@ -1,5 +1,5 @@
 import { F } from './util/Utils.js';
-import { ObservableObject } from './impl/Mvcc.js';
+import { ObservableObject } from './core/Mvcc.js';
 export declare class Reaction<T> extends ObservableObject {
     protected action: F<T>;
     constructor(action: F<T>);

package/build/dist/source/Reaction.js

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

package/build/dist/source/Ref.js

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

package/build/dist/source/RxSystem.js

@@ -1,10 +1,10 @@
 import { Log } from './util/Dbg.js';
 import { Kind } from './Options.js';
-import { Meta, ObjectHandle } from './impl/Data.js';
-import { Changeset } from './impl/Changeset.js';
-import { Mvcc } from './impl/Mvcc.js';
-import { Transaction } from './impl/Transaction.js';
-import { ReactionImpl } from './impl/Reaction.js';
+import { Meta, ObjectHandle } from './core/Data.js';
+import { Changeset } from './core/Changeset.js';
+import { Mvcc } from './core/Mvcc.js';
+import { Transaction } from './core/Transaction.js';
+import { ReactionImpl } from './core/Reaction.js';
 export class RxSystem {
     static why(brief = false) { return brief ? ReactionImpl.briefWhy() : ReactionImpl.why(); }
     static getReaction(method) { return ReactionImpl.getControllerOf(method); }

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

@@ -9,15 +9,15 @@ export type { AbstractReaction, MemberOptions, SnapshotOptions, LoggingOptions,
 export type { Worker } from './Worker.js';
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from './Ref.js';
 export type { BoolOnly, GivenTypeOnly } from './Ref.js';
-export { TransactionalObject, ObservableObject } from './impl/Mvcc.js';
-export { TransactionalArray, ObservableArray } from './impl/MvccArray.js';
-export { TransactionalMap, ObservableMap } from './impl/MvccMap.js';
-export { Changeset } from './impl/Changeset.js';
-export { Transaction } from './impl/Transaction.js';
-export { Monitor } from './impl/Monitor.js';
-export { Journal } from './impl/Journal.js';
+export { TransactionalObject, ObservableObject } from './core/Mvcc.js';
+export { TransactionalArray, ObservableArray } from './core/MvccArray.js';
+export { TransactionalMap, ObservableMap } from './core/MvccMap.js';
+export { Changeset } from './core/Changeset.js';
+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 './RxNode.js';
-export type { Delegate, SimpleDelegate, RxElement, RxNode, RxNodeDecl, RxNodeDriver, RxNodeContext } from './RxNode.js';
-export { RxTree, BaseDriver, RxNodeVariable } from './RxTree.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 { Clock } from './Clock.js';

package/build/dist/source/api.js

@@ -5,14 +5,14 @@ export { SealedMap } from './util/SealedMap.js';
 export { SealedSet } from './util/SealedSet.js';
 export { Kind, Reentrance, LoggingLevel } from './Options.js';
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from './Ref.js';
-export { TransactionalObject, ObservableObject } from './impl/Mvcc.js';
-export { TransactionalArray, ObservableArray } from './impl/MvccArray.js';
-export { TransactionalMap, ObservableMap } from './impl/MvccMap.js';
-export { Changeset } from './impl/Changeset.js';
-export { Transaction } from './impl/Transaction.js';
-export { Monitor } from './impl/Monitor.js';
-export { Journal } from './impl/Journal.js';
+export { TransactionalObject, ObservableObject } from './core/Mvcc.js';
+export { TransactionalArray, ObservableArray } from './core/MvccArray.js';
+export { TransactionalMap, ObservableMap } from './core/MvccMap.js';
+export { Changeset } from './core/Changeset.js';
+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 './RxNode.js';
-export { RxTree, BaseDriver, RxNodeVariable } from './RxTree.js';
+export { Mode, Priority } from './tree/RxNode.js';
+export { RxTree, BaseDriver, RxNodeVariable } from './tree/RxTree.js';
 export { Clock } from './Clock.js';

package/build/dist/source/{RxNode.d.ts → tree/RxNode.d.ts}

@@ -1,5 +1,5 @@
-import { MergeListReader, MergedItem } from './util/MergeList.js';
-import { MemberOptions } from './Options.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 {
@@ -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,33 +25,30 @@ 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;
     triggers?: unknown;
-    specify?: Delegate<E>;
-    create?: Delegate<E>;
     initialize?: Delegate<E>;
     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

@@ -0,0 +1,36 @@
+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;
+}

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

@@ -16,13 +16,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { MergeList } from './util/MergeList.js';
+import { MergeList } from '../util/MergeList.js';
+import { emitLetters, getCallerInfo } from './RxNodeUtils.js';
+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';
-import { emitLetters, getCallerInfo } from './util/RxNodeUtils.js';
-import { Reentrance } from './Options.js';
-import { ObservableObject } from './impl/Mvcc.js';
-import { Transaction } from './impl/Transaction.js';
-import { RxSystem, options, raw, reactive, unobs } from './RxSystem.js';
 export class RxTree {
     static declare(driver, declaration, preset) {
         var _a;
@@ -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;
-            triggerUpdateGivenSeat(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;
-            triggerUpdateGivenSeat(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); }
@@ -319,20 +323,19 @@ function runUpdateNestedTreesThenDo(error, action) {
                 for (const child of children.items()) {
                     if (Transaction.isCanceled)
                         break;
-                    const node = child.instance;
-                    const el = node.element;
-                    const isPart = node.driver.isPartitionSeparator;
+                    const childNode = child.instance;
+                    const isPart = childNode.driver.isPartitionSeparator;
                     const host = isPart ? owner : partition;
-                    const p = (_a = el.node.priority) !== null && _a !== void 0 ? _a : Priority.Realtime;
+                    const p = (_a = childNode.priority) !== null && _a !== void 0 ? _a : Priority.Realtime;
                     mounting = markToMountIfNecessary(mounting, host, child, children, sequential);
                     if (p === Priority.Realtime)
-                        triggerUpdateGivenSeat(child);
+                        triggerUpdateViaSeat(child);
                     else if (p === Priority.Normal)
                         p1 = push(child, p1);
                     else
                         p2 = push(child, p2);
                     if (isPart)
-                        partition = node;
+                        partition = childNode;
                 }
                 if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
                     promised = startIncrementalUpdate(curr, children, p1, p2).then(() => action(error), e => action(e));
@@ -346,8 +349,7 @@ function runUpdateNestedTreesThenDo(error, action) {
 }
 function markToMountIfNecessary(mounting, host, seat, children, sequential) {
     const node = seat.instance;
-    const el = node.element;
-    if (el.native && !node.has(Mode.ManualMount)) {
+    if (node.element.native && !node.has(Mode.ManualMount)) {
         if (mounting || node.host !== host) {
             children.markAsMoved(seat);
             mounting = false;
@@ -380,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) {
-                    triggerUpdateGivenSeat(child);
+                    triggerUpdateViaSeat(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
                         RxTree.currentUpdatePriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
@@ -398,7 +400,7 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
         }
     });
 }
-function triggerUpdateGivenSeat(seat) {
+function triggerUpdateViaSeat(seat) {
     const node = seat.instance;
     if (node.stamp >= 0) {
         if (node.has(Mode.IndependentUpdate)) {
@@ -418,22 +420,21 @@ function triggerUpdateGivenSeat(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;
@@ -465,15 +466,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));
-        el.native = null;
-        el.controller = null;
+        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.113",
+  "version": "0.24.115",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",

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

@@ -1,34 +0,0 @@
-import { LoggingOptions } from './Logging.js';
-import { Priority, RxNodeDecl, RxNodeDriver, SimpleDelegate, RxNode, RxElement } 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 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 getDefaultLoggingOptions(): LoggingOptions | undefined;
-    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
-}
-export declare abstract class BaseDriver<E extends RxElement> 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;
-}
-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;
-}