reactronic 0.24.273 → 0.24.275

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

@@ -19,5 +19,5 @@ export { Journal } from "./core/Journal.js";
 export { RxSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from "./RxSystem.js";
 export { Reaction } from "./Reaction.js";
 export { RxNode, Mode, Priority, BaseDriver, RxNodeVariable } from "./core/RxNode.js";
-export type { Delegate, SimpleDelegate, RxNodeDecl, RxNodeDriver, RxNodeContext } from "./core/RxNode.js";
+export type { Script, ScriptAsync, Handler, RxNodeDecl, RxNodeDriver, RxNodeContext } from "./core/RxNode.js";
 export { Clock } from "./Clock.js";

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

@@ -1,8 +1,9 @@
 import { LoggingOptions } from "../Logging.js";
 import { MergeListReader, MergedItem } from "../util/MergeList.js";
 import { MemberOptions } from "../Options.js";
-export type Delegate<T> = (el: T, basis: () => void) => void;
-export type SimpleDelegate<T = unknown, R = void> = (el: T) => R;
+export type Script<T> = (el: T, basis: () => void) => void;
+export type ScriptAsync<T> = (el: T, basis: () => Promise<void>) => Promise<void>;
+export type Handler<T = unknown, R = void> = (el: T) => R;
 export declare enum Mode {
     default = 0,
     independentUpdate = 1,
@@ -35,7 +36,7 @@ export declare abstract class RxNode<E = unknown> {
     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 declare<E = void>(driver: RxNodeDriver<E>, declaration?: RxNodeDecl<E>, basis?: RxNodeDecl<E>): RxNode<E>;
     static get isFirstUpdate(): boolean;
     static get key(): string;
     static get stamp(): number;
@@ -48,31 +49,33 @@ export declare abstract class RxNode<E = unknown> {
     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: 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 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?: Delegate<E>;
+    script?: Script<E>;
+    scriptAsync?: ScriptAsync<E>;
     key?: string;
     mode?: Mode;
-    creation?: Delegate<E>;
-    destruction?: Delegate<E>;
+    creation?: Script<E>;
+    destruction?: Script<E>;
     triggers?: unknown;
-    preset?: RxNodeDecl<E>;
+    basis?: RxNodeDecl<E>;
 };
 export type RxNodeDriver<E = unknown> = {
     readonly name: string;
     readonly isPartition: boolean;
-    readonly predefine?: SimpleDelegate<E>;
+    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>, childPreset?: RxNodeDecl<any>): MergedItem<RxNode> | undefined;
+    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;
@@ -80,14 +83,15 @@ export type RxNodeContext<T extends Object = Object> = {
 export declare abstract class BaseDriver<E = unknown> implements RxNodeDriver<E> {
     readonly name: string;
     readonly isPartition: boolean;
-    readonly predefine?: SimpleDelegate<E, void> | undefined;
-    constructor(name: string, isPartition: boolean, predefine?: SimpleDelegate<E, void> | undefined);
+    readonly initialize?: Handler<E, void> | undefined;
+    constructor(name: string, isPartition: boolean, initialize?: Handler<E, void> | undefined);
     abstract 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>, childPreset?: RxNodeDecl<any>): MergedItem<RxNode> | undefined;
+    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;

package/build/dist/source/core/RxNode.js

@@ -35,16 +35,16 @@ export var Priority;
     Priority[Priority["background"] = 2] = "background";
 })(Priority || (Priority = {}));
 export class RxNode {
-    static declare(driver, declaration, preset) {
+    static declare(driver, declaration, basis) {
         let result;
         if (declaration)
-            declaration.preset = preset;
+            declaration.basis = basis;
         else
-            declaration = preset !== null && preset !== void 0 ? preset : {};
+            declaration = basis !== null && basis !== void 0 ? basis : {};
         let key = declaration.key;
         const owner = gOwnSeat === null || gOwnSeat === void 0 ? void 0 : gOwnSeat.instance;
         if (owner) {
-            let existing = owner.driver.child(owner, driver, declaration, preset);
+            let existing = owner.driver.child(owner, driver, declaration, basis);
             const children = owner.children;
             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) {
@@ -144,28 +144,31 @@ RxNode.longFrameDuration = 300;
 RxNode.currentUpdatePriority = Priority.realtime;
 RxNode.frameDuration = RxNode.longFrameDuration;
 export class BaseDriver {
-    constructor(name, isPartition, predefine) {
+    constructor(name, isPartition, initialize) {
         this.name = name;
         this.isPartition = isPartition;
-        this.predefine = predefine;
+        this.initialize = initialize;
     }
     create(node) {
         var _a;
-        (_a = this.predefine) === null || _a === void 0 ? void 0 : _a.call(this, node.element);
-        invokeOnCreateViaPresetChain(node.element, node.declaration);
+        (_a = this.initialize) === null || _a === void 0 ? void 0 : _a.call(this, node.element);
+        invokeCreationUsingBasisChain(node.element, node.declaration);
     }
     destroy(node, isLeader) {
-        invokeOnDestroyViaPresetChain(node.element, node.declaration);
+        invokeDestructionUsingBasisChain(node.element, node.declaration);
         return isLeader;
     }
     mount(node) {
     }
     update(node) {
-        invokeScriptViaPresetChain(node.element, node.declaration);
+        invokeScriptUsingBasisChain(node.element, node.declaration);
     }
-    child(ownerNode, childDriver, childDeclaration, childPreset) {
+    child(ownerNode, childDriver, childDeclaration, childBasis) {
         return undefined;
     }
+    getHost(node) {
+        return node;
+    }
 }
 export class RxNodeVariable {
     constructor(defaultValue) {
@@ -191,33 +194,33 @@ function generateKey(owner) {
         result = `·${lettered}`;
     return result;
 }
-function getModeViaPresetChain(declaration) {
+function getModeUsingBasisChain(declaration) {
     var _a;
-    return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.preset) ? getModeViaPresetChain(declaration === null || declaration === void 0 ? void 0 : declaration.preset) : Mode.default);
-}
-function invokeOnCreateViaPresetChain(element, declaration) {
-    const preset = declaration.preset;
-    const creation = declaration.creation;
-    if (creation)
-        creation(element, preset ? () => invokeOnCreateViaPresetChain(element, preset) : NOP);
-    else if (preset)
-        invokeOnCreateViaPresetChain(element, preset);
+    return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.basis) ? getModeUsingBasisChain(declaration === null || declaration === void 0 ? void 0 : declaration.basis) : Mode.default);
 }
-function invokeScriptViaPresetChain(element, declaration) {
-    const preset = declaration.preset;
+function invokeScriptUsingBasisChain(element, declaration) {
+    const basis = declaration.basis;
     const script = declaration.script;
     if (script)
-        script(element, preset ? () => invokeScriptViaPresetChain(element, preset) : NOP);
-    else if (preset)
-        invokeScriptViaPresetChain(element, preset);
+        script(element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP);
+    else if (basis)
+        invokeScriptUsingBasisChain(element, basis);
+}
+function invokeCreationUsingBasisChain(element, declaration) {
+    const basis = declaration.basis;
+    const creation = declaration.creation;
+    if (creation)
+        creation(element, basis ? () => invokeCreationUsingBasisChain(element, basis) : NOP);
+    else if (basis)
+        invokeCreationUsingBasisChain(element, basis);
 }
-function invokeOnDestroyViaPresetChain(element, declaration) {
-    const preset = declaration.preset;
+function invokeDestructionUsingBasisChain(element, declaration) {
+    const basis = declaration.basis;
     const destruction = declaration.destruction;
     if (destruction)
-        destruction(element, preset ? () => invokeOnDestroyViaPresetChain(element, preset) : NOP);
-    else if (preset)
-        invokeOnDestroyViaPresetChain(element, preset);
+        destruction(element, basis ? () => invokeDestructionUsingBasisChain(element, basis) : NOP);
+    else if (basis)
+        invokeDestructionUsingBasisChain(element, basis);
 }
 class RxNodeContextImpl extends ObservableObject {
     constructor(variable, value) {
@@ -270,7 +273,7 @@ class RxNodeImpl extends RxNode {
     set strictOrder(value) { this.children.isStrict = value; }
     get isMoved() { return this.owner.children.isMoved(this.seat); }
     has(mode) {
-        return (getModeViaPresetChain(this.declaration) & mode) === mode;
+        return (getModeUsingBasisChain(this.declaration) & mode) === mode;
     }
     update(_triggers) {
         updateNow(this.seat);

package/package.json

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