reactronic 0.24.501 → 0.91.25002

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

@@ -20,6 +20,7 @@ export declare class ReactiveSystem {
 export declare function transaction<T>(action: F<T>, ...args: any[]): T;
 export declare function unobs<T>(func: F<T>, ...args: any[]): T;
 export declare function sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
+export declare function contextually<T>(p: Promise<T>): Promise<T>;
 export declare function raw(proto: object, prop: PropertyKey): any;
 export declare function obs(proto: object, prop: PropertyKey): any;
 export declare function transactional(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;

package/build/dist/source/ReactiveSystem.js

@@ -31,6 +31,9 @@ export function unobs(func, ...args) {
 export function sensitive(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
 }
+export function contextually(p) {
+    throw new Error("not implemented yet");
+}
 export function raw(proto, prop) {
     return Mvcc.decorateData(false, proto, prop);
 }

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

@@ -16,7 +16,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 { ReactiveSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, contextually, options } from "./ReactiveSystem.js";
 export { Reaction } from "./Reaction.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export type { Script, ScriptAsync, Handler, ReactiveNodeDecl, ReactiveNodeDriver, ReactiveNodeContext } from "./core/ReactiveNode.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 { ReactiveSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, contextually, options } from "./ReactiveSystem.js";
 export { Reaction } from "./Reaction.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export { Clock } from "./Clock.js";

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

@@ -7,7 +7,8 @@ export type Handler<E = unknown, R = void> = (el: E) => R;
 export declare enum Mode {
     default = 0,
     autonomous = 1,
-    manualMount = 2
+    manualMount = 2,
+    rootNode = 4
 }
 export declare enum Priority {
     realtime = 0,
@@ -36,9 +37,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, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveNodeDecl<E>): ReactiveNode<E>;
+    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>, 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 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 isFirstUpdate(): boolean;
     static get key(): string;
@@ -59,8 +60,8 @@ export declare abstract class ReactiveNode<E = unknown> {
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
 export type ReactiveNodeDecl<E = unknown> = {
-    content?: Script<E>;
-    contentAsync?: ScriptAsync<E>;
+    script?: Script<E>;
+    scriptAsync?: ScriptAsync<E>;
     key?: string;
     mode?: Mode;
     preparation?: Script<E>;
@@ -74,11 +75,11 @@ export type ReactiveNodeDriver<E = unknown> = {
     readonly isPartition: boolean;
     readonly initialize?: Handler<E>;
     create(node: ReactiveNode<E>): E;
-    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;
+    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> = {
@@ -90,11 +91,11 @@ export declare abstract class BaseDriver<E = unknown> implements ReactiveNodeDri
     readonly initialize?: Handler<E> | undefined;
     constructor(name: string, isPartition: boolean, initialize?: Handler<E> | undefined);
     abstract create(node: ReactiveNode<E>): E;
-    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;
+    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> {

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

@@ -28,6 +28,7 @@ export var 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) {
@@ -36,23 +37,23 @@ export var Priority;
     Priority[Priority["background"] = 2] = "background";
 })(Priority || (Priority = {}));
 export class ReactiveNode {
-    static declare(driver, contentOrDeclaration, contentAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
+    static declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
         let result;
         let declaration;
-        if (contentOrDeclaration instanceof Function) {
+        if (scriptOrDeclaration instanceof Function) {
             declaration = {
-                content: contentOrDeclaration, contentAsync, key, mode,
+                script: scriptOrDeclaration, scriptAsync, key, mode,
                 preparation, preparationAsync, finalization, triggers, basis,
             };
         }
         else
-            declaration = contentOrDeclaration !== null && contentOrDeclaration !== void 0 ? contentOrDeclaration : {};
+            declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
         let effectiveKey = declaration.key;
-        const owner = gOwnSlot === null || gOwnSlot === void 0 ? void 0 : gOwnSlot.instance;
+        const owner = (getModeUsingBasisChain(declaration) & Mode.rootNode) !== Mode.rootNode ? gOwnSlot === null || gOwnSlot === void 0 ? void 0 : gOwnSlot.instance : undefined;
         if (owner) {
-            let existing = owner.driver.child(owner, driver, declaration, declaration.basis);
+            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 content script only"));
+            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)
@@ -162,21 +163,21 @@ export class BaseDriver {
         this.isPartition = isPartition;
         this.initialize = initialize;
     }
-    prepare(node) {
+    runPreparation(node) {
         var _a;
         (_a = this.initialize) === null || _a === void 0 ? void 0 : _a.call(this, node.element);
         return invokePreparationUsingBasisChain(node.element, node.declaration);
     }
-    finalize(node, isLeader) {
+    runFinalization(node, isLeader) {
         invokeFinalizationUsingBasisChain(node.element, node.declaration);
         return isLeader;
     }
-    mount(node) {
+    runMount(node) {
     }
-    update(node) {
-        return invokeContentUsingBasisChain(node.element, node.declaration);
+    runScript(node) {
+        return invokeScriptUsingBasisChain(node.element, node.declaration);
     }
-    child(ownerNode, childDriver, childDeclaration, childBasis) {
+    declareChild(ownerNode, childDriver, childDeclaration, childBasis) {
         return undefined;
     }
     provideHost(node) {
@@ -211,19 +212,19 @@ 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.basis) ? getModeUsingBasisChain(declaration === null || declaration === void 0 ? void 0 : declaration.basis) : Mode.default);
 }
-function invokeContentUsingBasisChain(element, declaration) {
+function invokeScriptUsingBasisChain(element, declaration) {
     let result = undefined;
     const basis = declaration.basis;
-    const content = declaration.content;
-    const contentAsync = declaration.contentAsync;
-    if (content && contentAsync)
-        throw misuse("'content' and 'contentAsync' cannot be defined together");
-    if (content)
-        result = content(element, basis ? () => invokeContentUsingBasisChain(element, basis) : NOP);
-    else if (contentAsync)
-        result = contentAsync(element, basis ? () => invokeContentUsingBasisChain(element, basis) : NOP_ASYNC);
+    const script = declaration.script;
+    const scriptAsync = declaration.scriptAsync;
+    if (script && scriptAsync)
+        throw misuse("'script' and 'scriptAsync' cannot be defined together");
+    if (script)
+        result = script(element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP);
+    else if (scriptAsync)
+        result = scriptAsync(element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP_ASYNC);
     else if (basis)
-        result = invokeContentUsingBasisChain(element, basis);
+        result = invokeScriptUsingBasisChain(element, basis);
     return result;
 }
 function invokePreparationUsingBasisChain(element, declaration) {
@@ -494,16 +495,16 @@ function mountOrRemountIfNecessary(node) {
     if (node.stamp === Number.MAX_SAFE_INTEGER) {
         unobs(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
-            driver.prepare(node);
+            driver.runPreparation(node);
             if (!node.has(Mode.manualMount)) {
                 node.stamp = 0;
                 if (node.host !== node)
-                    driver.mount(node);
+                    driver.runMount(node);
             }
         });
     }
     else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
-        unobs(() => driver.mount(node));
+        unobs(() => driver.runMount(node));
 }
 function updateNow(slot) {
     const node = slot.instance;
@@ -517,7 +518,7 @@ function updateNow(slot) {
                     node.numerator = 0;
                     node.children.beginMerge();
                     const driver = node.driver;
-                    result = driver.update(node);
+                    result = driver.runScript(node);
                     result = proceedSyncOrAsync(result, v => { runUpdateNestedNodesThenDo(slot, undefined, NOP); return v; }, e => { console.log(e); runUpdateNestedNodesThenDo(slot, e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
                 }
                 catch (e) {
@@ -536,7 +537,7 @@ function triggerFinalization(slot, 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 = unobs(() => driver.finalize(node, isLeader));
+        const childrenAreLeaders = unobs(() => driver.runFinalization(node, isLeader));
         if (node.has(Mode.autonomous)) {
             slot.aux = undefined;
             const last = gLastToDispose;

package/package.json

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