reactronic 0.24.401 → 0.24.500

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

@@ -36,9 +36,9 @@ export declare abstract class ReactiveNode<E = unknown> {
     static readonly longFrameDuration = 300;
     static currentUpdatePriority: Priority;
     static frameDuration: number;
-    static declare<E = void>(driver: ReactiveNodeDriver<E>, content?: Script<E>, contentAsync?: 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>, content?: Script<E>, contentAsync?: 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>, contentOrDeclaration?: Script<E> | ReactiveNodeDecl<E>, contentAsync?: 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>, contentOrDeclaration?: Script<E> | ReactiveNodeDecl<E>, contentAsync?: 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 isFirstUpdate(): boolean;
     static get key(): string;
@@ -49,7 +49,7 @@ export declare abstract class ReactiveNode<E = unknown> {
     static get childrenShuffling(): boolean;
     static set childrenShuffling(value: boolean);
     static triggerUpdate(node: ReactiveNode<any>, triggers: unknown): void;
-    static triggerDeactivation(node: ReactiveNode<any>): void;
+    static triggerFinalization(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;
@@ -63,9 +63,9 @@ export type ReactiveNodeDecl<E = unknown> = {
     contentAsync?: ScriptAsync<E>;
     key?: string;
     mode?: Mode;
-    creation?: Script<E>;
-    creationAsync?: ScriptAsync<E>;
-    destruction?: Script<E>;
+    preparation?: Script<E>;
+    preparationAsync?: ScriptAsync<E>;
+    finalization?: Script<E>;
     triggers?: unknown;
     basis?: ReactiveNodeDecl<E>;
 };
@@ -74,12 +74,12 @@ export type ReactiveNodeDriver<E = unknown> = {
     readonly isPartition: boolean;
     readonly initialize?: Handler<E>;
     allocate(node: ReactiveNode<E>): E;
-    create(node: ReactiveNode<E>): void;
-    destroy(node: ReactiveNode<E>, isLeader: boolean): boolean;
+    prepare(node: ReactiveNode<E>): void;
+    finalize(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>;
+    provideHost(node: ReactiveNode<E>): ReactiveNode<E>;
 };
 export type ReactiveNodeContext<T extends Object = Object> = {
     value: T;
@@ -90,12 +90,12 @@ export declare abstract class BaseDriver<E = unknown> implements ReactiveNodeDri
     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;
+    prepare(node: ReactiveNode<E>): void | Promise<void>;
+    finalize(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>;
+    provideHost(node: ReactiveNode<E>): ReactiveNode<E>;
 }
 export declare class ReactiveNodeVariable<T extends Object = Object> {
     readonly defaultValue: T | undefined;

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

@@ -36,13 +36,13 @@ export var Priority;
     Priority[Priority["background"] = 2] = "background";
 })(Priority || (Priority = {}));
 export class ReactiveNode {
-    static declare(driver, contentOrDeclaration, contentAsync, key, mode, creation, creationAsync, destruction, triggers, basis) {
+    static declare(driver, contentOrDeclaration, contentAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
         let result;
         let declaration;
         if (contentOrDeclaration instanceof Function) {
             declaration = {
                 content: contentOrDeclaration, contentAsync, key, mode,
-                creation, creationAsync, destruction, triggers, basis,
+                preparation, preparationAsync, finalization, triggers, basis,
             };
         }
         else
@@ -113,9 +113,9 @@ export class ReactiveNode {
             triggerUpdateViaSlot(impl.slot);
         }
     }
-    static triggerDeactivation(node) {
+    static triggerFinalization(node) {
         const impl = node;
-        triggerDeactivation(impl.slot, true, true);
+        triggerFinalization(impl.slot, true, true);
     }
     static updateNestedNodesThenDo(action) {
         runUpdateNestedNodesThenDo(ReactiveNodeImpl.ownSlot, undefined, action);
@@ -162,13 +162,13 @@ export class BaseDriver {
         this.isPartition = isPartition;
         this.initialize = initialize;
     }
-    create(node) {
+    prepare(node) {
         var _a;
         (_a = this.initialize) === null || _a === void 0 ? void 0 : _a.call(this, node.element);
-        return invokeCreationUsingBasisChain(node.element, node.declaration);
+        return invokePreparationUsingBasisChain(node.element, node.declaration);
     }
-    destroy(node, isLeader) {
-        invokeDestructionUsingBasisChain(node.element, node.declaration);
+    finalize(node, isLeader) {
+        invokeFinalizationUsingBasisChain(node.element, node.declaration);
         return isLeader;
     }
     mount(node) {
@@ -179,7 +179,7 @@ export class BaseDriver {
     child(ownerNode, childDriver, childDeclaration, childBasis) {
         return undefined;
     }
-    getHost(node) {
+    provideHost(node) {
         return node;
     }
 }
@@ -226,28 +226,28 @@ function invokeContentUsingBasisChain(element, declaration) {
         result = invokeContentUsingBasisChain(element, basis);
     return result;
 }
-function invokeCreationUsingBasisChain(element, declaration) {
+function invokePreparationUsingBasisChain(element, declaration) {
     let result = undefined;
     const basis = declaration.basis;
-    const creation = declaration.creation;
-    const creationAsync = declaration.creationAsync;
-    if (creation && creationAsync)
-        throw misuse("'creation' and 'creationAsync' cannot be defined together");
-    if (creation)
-        result = creation(element, basis ? () => invokeCreationUsingBasisChain(element, basis) : NOP);
-    else if (creationAsync)
-        result = creationAsync(element, basis ? () => invokeCreationUsingBasisChain(element, basis) : NOP_ASYNC);
+    const preparation = declaration.preparation;
+    const preparationAsync = declaration.preparationAsync;
+    if (preparation && preparationAsync)
+        throw misuse("'preparation' and 'preparationAsync' cannot be defined together");
+    if (preparation)
+        result = preparation(element, basis ? () => invokePreparationUsingBasisChain(element, basis) : NOP);
+    else if (preparationAsync)
+        result = preparationAsync(element, basis ? () => invokePreparationUsingBasisChain(element, basis) : NOP_ASYNC);
     else if (basis)
-        result = invokeCreationUsingBasisChain(element, basis);
+        result = invokePreparationUsingBasisChain(element, basis);
     return result;
 }
-function invokeDestructionUsingBasisChain(element, declaration) {
+function invokeFinalizationUsingBasisChain(element, declaration) {
     const basis = declaration.basis;
-    const destruction = declaration.destruction;
-    if (destruction)
-        destruction(element, basis ? () => invokeDestructionUsingBasisChain(element, basis) : NOP);
+    const finalization = declaration.finalization;
+    if (finalization)
+        finalization(element, basis ? () => invokeFinalizationUsingBasisChain(element, basis) : NOP);
     else if (basis)
-        invokeDestructionUsingBasisChain(element, basis);
+        invokeFinalizationUsingBasisChain(element, basis);
 }
 class ReactiveNodeContextImpl extends ObservableObject {
     constructor(variable, value) {
@@ -382,7 +382,7 @@ function runUpdateNestedNodesThenDo(ownSlot, error, action) {
             try {
                 children.endMerge(error);
                 for (const child of children.removedItems(true))
-                    triggerDeactivation(child, true, true);
+                    triggerFinalization(child, true, true);
                 if (!error) {
                     const sequential = children.isStrict;
                     let p1 = undefined;
@@ -494,7 +494,7 @@ function mountOrRemountIfNecessary(node) {
     if (node.stamp === Number.MAX_SAFE_INTEGER) {
         unobs(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
-            driver.create(node);
+            driver.prepare(node);
             if (!node.has(Mode.manualMount)) {
                 node.stamp = 0;
                 if (node.host !== node)
@@ -529,14 +529,14 @@ function updateNow(slot) {
         });
     }
 }
-function triggerDeactivation(slot, isLeader, individual) {
+function triggerFinalization(slot, isLeader, individual) {
     const node = slot.instance;
     if (node.stamp >= 0) {
         const driver = node.driver;
         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 = unobs(() => driver.destroy(node, isLeader));
+        const childrenAreLeaders = unobs(() => driver.finalize(node, isLeader));
         if (node.has(Mode.autonomous)) {
             slot.aux = undefined;
             const last = gLastToDispose;
@@ -550,7 +550,7 @@ function triggerDeactivation(slot, isLeader, individual) {
                 });
         }
         for (const child of node.children.items())
-            triggerDeactivation(child, childrenAreLeaders, false);
+            triggerFinalization(child, childrenAreLeaders, false);
         ReactiveNodeImpl.grandNodeCount--;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.24.401",
+  "version": "0.24.500",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -31,13 +31,13 @@
   },
   "homepage": "https://github.com/nezaboodka/reactronic/blob/master/README.md#readme",
   "devDependencies": {
-    "@types/node": "22.8.5",
+    "@types/node": "22.8.6",
     "@types/react": "18.3.12",
     "@typescript-eslint/eslint-plugin": "8.12.2",
     "@typescript-eslint/parser": "8.12.2",
     "ava": "6.2.0",
     "c8": "10.1.2",
-    "eslint": "9.13.0",
+    "eslint": "9.14.0",
     "react": "18.3.1",
     "ts-node": "10.9.2",
     "typescript": "5.5.4"