reactronic 0.94.25031 → 0.94.25033

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

@@ -1,8 +1,7 @@
 export declare enum Mode {
     default = 0,
     autonomous = 1,
-    manualMount = 2,
-    rootNode = 4
+    external = 2
 }
 export declare enum Priority {
     realtime = 0,

package/build/dist/source/Enums.js

@@ -2,8 +2,7 @@ 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["external"] = 2] = "external";
 })(Mode || (Mode = {}));
 export var Priority;
 (function (Priority) {

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

@@ -21,5 +21,5 @@ export { Journal } from "./core/Journal.js";
 export { runAtomically, runNonReactively, runSensitively, runContextually, manageReactiveOperation, configureCurrentReactiveOperation, disposeObservableObject } from "./System.js";
 export { ReactiveSystem, observable, atomic, reactive, cached, options } from "./System.js";
 export { ReactiveOperationEx } from "./OperationEx.js";
-export { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
+export { declare, derived, launch, ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
 export type { Script, ScriptAsync, Handler, ReactiveTreeNodeDecl, ReactiveTreeNodeDriver, ReactiveTreeNodeContext } from "./core/TreeNode.js";

package/build/dist/source/api.js

@@ -17,4 +17,4 @@ export { Journal } from "./core/Journal.js";
 export { runAtomically, runNonReactively, runSensitively, runContextually, manageReactiveOperation, configureCurrentReactiveOperation, disposeObservableObject } from "./System.js";
 export { ReactiveSystem, observable, atomic, reactive, cached, options } from "./System.js";
 export { ReactiveOperationEx } from "./OperationEx.js";
-export { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
+export { declare, derived, launch, ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";

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

@@ -6,6 +6,11 @@ import { ObservableObject } from "../core/Mvcc.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 function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+export declare function derived<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
+export declare function launch<T>(node: ReactiveTreeNode<T>, triggers?: unknown): ReactiveTreeNode<T>;
 export declare abstract class ReactiveTreeNode<E = unknown> {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
@@ -31,13 +36,9 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     abstract configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
     static get current(): ReactiveTreeNode;
     static get isFirstScriptRun(): boolean;
-    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-    static withBasis<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
-    static triggerScriptRun(node: ReactiveTreeNode<any>, triggers: unknown): void;
-    static triggerFinalization(node: ReactiveTreeNode<any>): void;
-    static runNestedNodeScriptsThenDo(action: (error: unknown) => void): void;
+    static launchScript(node: ReactiveTreeNode<any>, triggers: unknown): void;
+    static launchFinalization(node: ReactiveTreeNode<any>): void;
+    static launchNestedNodesThenDo(action: (error: unknown) => void): void;
     static markAsMounted(node: ReactiveTreeNode<any>, yes: boolean): void;
     lookupTreeNodeByUri<E = unknown>(uri: string): ReactiveTreeNode<E> | undefined;
     static findMatchingHost<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;

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

@@ -19,77 +19,80 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { misuse } from "../util/Dbg.js";
 import { Uri } from "../util/Uri.js";
 import { MergeList } from "../util/MergeList.js";
-import { emitLetters, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js";
+import { emitLetters, flags, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js";
 import { Priority, Mode, Isolation, Reentrance } from "../Enums.js";
 import { ObservableObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
 import { ReactiveSystem, options, observable, reactive, runAtomically, runNonReactively, manageReactiveOperation, disposeObservableObject } from "../System.js";
-export class ReactiveTreeNode {
-    static get current() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance;
-    }
-    static get isFirstScriptRun() {
-        return ReactiveTreeNode.current.stamp === 1;
+export function 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,
+        };
     }
-    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 misuse(`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 (observablesAreEqual(declaration.triggers, exTriggers))
-                    declaration.triggers = exTriggers;
-                result.declaration = declaration;
-            }
-            else {
-                result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
-                result.slot = children.mergeAsAdded(result);
-            }
+    else
+        declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
+    let effectiveKey = declaration.key;
+    const owner = gNodeSlot === null || gNodeSlot === void 0 ? void 0 : gNodeSlot.instance;
+    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 misuse(`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 (observablesAreEqual(declaration.triggers, exTriggers))
+                declaration.triggers = exTriggers;
+            result.declaration = declaration;
         }
         else {
             result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
-            result.slot = MergeList.createItem(result);
-            triggerScriptRunViaSlot(result.slot);
+            result.slot = children.mergeAsAdded(result);
         }
-        return result;
     }
-    static withBasis(declaration, basis) {
-        if (declaration)
-            declaration.basis = basis;
-        else
-            declaration = basis !== null && basis !== void 0 ? basis : {};
-        return declaration;
+    else {
+        result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
+        result.slot = MergeList.createItem(result);
+    }
+    return result;
+}
+export function derived(declaration, basis) {
+    if (declaration)
+        declaration.basis = basis;
+    else
+        declaration = basis !== null && basis !== void 0 ? basis : {};
+    return declaration;
+}
+export function launch(node, triggers) {
+    ReactiveTreeNode.launchScript(node, triggers);
+    return node;
+}
+export class ReactiveTreeNode {
+    static get current() {
+        return ReactiveTreeNodeImpl.nodeSlot.instance;
+    }
+    static get isFirstScriptRun() {
+        return ReactiveTreeNode.current.stamp === 1;
     }
-    static triggerScriptRun(node, triggers) {
+    static launchScript(node, triggers) {
         const impl = node;
         const declaration = impl.declaration;
-        if (!observablesAreEqual(triggers, declaration.triggers)) {
+        if (node.stamp >= Number.MAX_SAFE_INTEGER || !observablesAreEqual(triggers, declaration.triggers)) {
             declaration.triggers = triggers;
-            triggerScriptRunViaSlot(impl.slot);
+            launchScriptViaSlot(impl.slot);
         }
     }
-    static triggerFinalization(node) {
+    static launchFinalization(node) {
         const impl = node;
-        triggerFinalization(impl.slot, true, true);
+        launchFinalization(impl.slot, true, true);
     }
-    static runNestedNodeScriptsThenDo(action) {
-        runNestedNodeScriptsThenDoImpl(ReactiveTreeNodeImpl.nodeSlot, undefined, action);
+    static launchNestedNodesThenDo(action) {
+        launchNestedNodesThenDoImpl(ReactiveTreeNodeImpl.nodeSlot, undefined, action);
     }
     static markAsMounted(node, yes) {
         const n = node;
@@ -298,7 +301,7 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
         return this.owner.children.isMoved(this.slot);
     }
     has(mode) {
-        return (getModeUsingBasisChain(this.declaration) & mode) === mode;
+        return flags(getModeUsingBasisChain(this.declaration), mode);
     }
     script(_triggers) {
         runScriptNow(this.slot);
@@ -380,7 +383,7 @@ function gatherAuthorityAndPath(node, path, relativeTo) {
 function getNodeKey(node) {
     return node.stamp >= 0 ? node.key : undefined;
 }
-function runNestedNodeScriptsThenDoImpl(nodeSlot, error, action) {
+function launchNestedNodesThenDoImpl(nodeSlot, error, action) {
     runInsideContextOfNode(nodeSlot, () => {
         var _a;
         const owner = nodeSlot.instance;
@@ -390,7 +393,7 @@ function runNestedNodeScriptsThenDoImpl(nodeSlot, error, action) {
             try {
                 children.endMerge(error);
                 for (const child of children.removedItems(true))
-                    triggerFinalization(child, true, true);
+                    launchFinalization(child, true, true);
                 if (!error) {
                     const sequential = children.isStrict;
                     let p1 = undefined;
@@ -406,7 +409,7 @@ function runNestedNodeScriptsThenDoImpl(nodeSlot, error, action) {
                         mounting = markToMountIfNecessary(mounting, host, child, children, sequential);
                         const p = (_a = childNode.priority) !== null && _a !== void 0 ? _a : Priority.realtime;
                         if (p === Priority.realtime)
-                            triggerScriptRunViaSlot(child);
+                            launchScriptViaSlot(child);
                         else if (p === Priority.normal)
                             p1 = push(child, p1);
                         else
@@ -427,7 +430,7 @@ function runNestedNodeScriptsThenDoImpl(nodeSlot, error, action) {
 }
 function markToMountIfNecessary(mounting, host, nodeSlot, children, sequential) {
     const node = nodeSlot.instance;
-    if (node.element.native && !node.has(Mode.manualMount)) {
+    if (node.element.native && !node.has(Mode.external)) {
         if (mounting || node.host !== host) {
             children.markAsMoved(nodeSlot);
             mounting = false;
@@ -460,7 +463,7 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
                 const frameDurationLimit = priority === Priority.background ? ReactiveTreeNode.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveTreeNode.frameDuration / 4, ReactiveTreeNode.shortFrameDuration));
                 for (const child of items) {
-                    triggerScriptRunViaSlot(child);
+                    launchScriptViaSlot(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
                         ReactiveTreeNodeImpl.currentScriptPriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
@@ -478,7 +481,7 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
         }
     });
 }
-function triggerScriptRunViaSlot(nodeSlot) {
+function launchScriptViaSlot(nodeSlot) {
     const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         if (node.has(Mode.autonomous)) {
@@ -505,14 +508,14 @@ function mountOrRemountIfNecessary(node) {
         runNonReactively(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
             driver.runPreparation(node);
-            if (!node.has(Mode.manualMount)) {
+            if (!node.has(Mode.external)) {
                 node.stamp = 0;
                 if (node.host !== node)
                     driver.runMount(node);
             }
         });
     }
-    else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
+    else if (node.isMoved && !node.has(Mode.external) && node.host !== node)
         runNonReactively(() => driver.runMount(node));
 }
 function runScriptNow(nodeSlot) {
@@ -528,10 +531,10 @@ function runScriptNow(nodeSlot) {
                     node.children.beginMerge();
                     const driver = node.driver;
                     result = driver.runScript(node);
-                    result = proceedSyncOrAsync(result, v => { runNestedNodeScriptsThenDoImpl(nodeSlot, undefined, NOP); return v; }, e => { console.log(e); runNestedNodeScriptsThenDoImpl(nodeSlot, e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
+                    result = proceedSyncOrAsync(result, v => { launchNestedNodesThenDoImpl(nodeSlot, undefined, NOP); return v; }, e => { console.log(e); launchNestedNodesThenDoImpl(nodeSlot, e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
                 }
                 catch (e) {
-                    runNestedNodeScriptsThenDoImpl(nodeSlot, e, NOP);
+                    launchNestedNodesThenDoImpl(nodeSlot, e, NOP);
                     console.log(`Reactive node script failed: ${node.key}`);
                     console.log(`${e}`);
                 }
@@ -539,7 +542,7 @@ function runScriptNow(nodeSlot) {
         });
     }
 }
-function triggerFinalization(nodeSlot, isLeader, individual) {
+function launchFinalization(nodeSlot, isLeader, individual) {
     const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         const driver = node.driver;
@@ -560,7 +563,7 @@ function triggerFinalization(nodeSlot, isLeader, individual) {
                 });
         }
         for (const child of node.children.items())
-            triggerFinalization(child, childrenAreLeaders, false);
+            launchFinalization(child, childrenAreLeaders, false);
         ReactiveTreeNodeImpl.grandNodeCount--;
     }
 }

package/build/dist/source/util/Utils.d.ts

@@ -4,6 +4,7 @@ export declare class Utils {
     static freezeMap<K, V>(obj?: Map<K, V>): Map<K, V> | undefined;
     static copyAllMembers(source: any, target: any): any;
 }
+export declare function flags(value: number, flags: number): boolean;
 export declare function UNDEF(...args: any[]): never;
 export declare function all(promises: Array<Promise<any>>): Promise<any[]>;
 export declare function pause<T>(timeout: number): Promise<T>;

package/build/dist/source/util/Utils.js

@@ -37,6 +37,9 @@ export class Utils {
         return target;
     }
 }
+export function flags(value, flags) {
+    return (value & flags) === flags;
+}
 export function UNDEF(...args) {
     throw fatal(new Error("this method should never be called"));
 }

package/package.json

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