reactronic 0.92.25011 → 0.92.25012

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

@@ -35,13 +35,13 @@ export declare abstract class ReactiveNode<E = unknown> {
     abstract configureReactronic(options: Partial<MemberOptions>): MemberOptions;
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
-    static currentUpdatePriority: Priority;
+    static currentScriptPriority: Priority;
     static frameDuration: number;
     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>, 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 isFirstScriptRun(): boolean;
     static get key(): string;
     static get stamp(): number;
     static get triggers(): unknown;
@@ -49,9 +49,9 @@ export declare abstract class ReactiveNode<E = unknown> {
     static set priority(value: Priority);
     static get childrenShuffling(): boolean;
     static set childrenShuffling(value: boolean);
-    static triggerUpdate(node: ReactiveNode<any>, triggers: unknown): void;
+    static triggerScriptRun(node: ReactiveNode<any>, triggers: unknown): void;
     static triggerFinalization(node: ReactiveNode<any>): void;
-    static updateNestedNodesThenDo(action: (error: unknown) => void): void;
+    static runNestedNodeScriptsThenDo(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;
     static findMatchingPrevSibling<E = unknown, R = unknown>(node: ReactiveNode<E>, match: Handler<ReactiveNode<E>, boolean>): ReactiveNode<R> | undefined;

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

@@ -71,7 +71,7 @@ export class ReactiveNode {
         else {
             result = new ReactiveNodeImpl(effectiveKey || "", driver, declaration, owner);
             result.slot = MergeList.createItem(result);
-            triggerUpdateViaSlot(result.slot);
+            triggerScriptRunViaSlot(result.slot);
         }
         return result;
     }
@@ -82,7 +82,7 @@ export class ReactiveNode {
             declaration = basis !== null && basis !== void 0 ? basis : {};
         return declaration;
     }
-    static get isFirstUpdate() {
+    static get isFirstScriptRun() {
         return ReactiveNodeImpl.ownSlot.instance.stamp === 1;
     }
     static get key() {
@@ -106,20 +106,20 @@ export class ReactiveNode {
     static set childrenShuffling(value) {
         ReactiveNodeImpl.ownSlot.instance.childrenShuffling = value;
     }
-    static triggerUpdate(node, triggers) {
+    static triggerScriptRun(node, triggers) {
         const impl = node;
         const declaration = impl.declaration;
         if (!triggersAreEqual(triggers, declaration.triggers)) {
             declaration.triggers = triggers;
-            triggerUpdateViaSlot(impl.slot);
+            triggerScriptRunViaSlot(impl.slot);
         }
     }
     static triggerFinalization(node) {
         const impl = node;
         triggerFinalization(impl.slot, true, true);
     }
-    static updateNestedNodesThenDo(action) {
-        runUpdateNestedNodesThenDo(ReactiveNodeImpl.ownSlot, undefined, action);
+    static runNestedNodeScriptsThenDo(action) {
+        runNestedNodeScriptsThenDoImpl(ReactiveNodeImpl.ownSlot, undefined, action);
     }
     static markAsMounted(node, yes) {
         const n = node;
@@ -155,7 +155,7 @@ export class ReactiveNode {
 }
 ReactiveNode.shortFrameDuration = 16;
 ReactiveNode.longFrameDuration = 300;
-ReactiveNode.currentUpdatePriority = Priority.realtime;
+ReactiveNode.currentScriptPriority = Priority.realtime;
 ReactiveNode.frameDuration = ReactiveNode.longFrameDuration;
 export class BaseDriver {
     constructor(name, isPartition, initialize) {
@@ -303,13 +303,13 @@ class ReactiveNodeImpl extends ReactiveNode {
     has(mode) {
         return (getModeUsingBasisChain(this.declaration) & mode) === mode;
     }
-    update(_triggers) {
-        updateNow(this.slot);
+    script(_triggers) {
+        runScriptNow(this.slot);
     }
     configureReactronic(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.autonomous))
             throw new Error("reactronic can be configured only for elements with autonomous mode and only during activation");
-        return ReactiveSystem.getOperation(this.update).configure(options);
+        return ReactiveSystem.getOperation(this.script).configure(options);
     }
     static get ownSlot() {
         if (!gOwnSlot)
@@ -369,11 +369,11 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], ReactiveNodeImpl.prototype, "update", null);
+], ReactiveNodeImpl.prototype, "script", null);
 function getNodeKey(node) {
     return node.stamp >= 0 ? node.key : undefined;
 }
-function runUpdateNestedNodesThenDo(ownSlot, error, action) {
+function runNestedNodeScriptsThenDoImpl(ownSlot, error, action) {
     runInside(ownSlot, () => {
         var _a;
         const owner = ownSlot.instance;
@@ -399,7 +399,7 @@ function runUpdateNestedNodesThenDo(ownSlot, 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)
-                            triggerUpdateViaSlot(child);
+                            triggerScriptRunViaSlot(child);
                         else if (p === Priority.normal)
                             p1 = push(child, p1);
                         else
@@ -408,7 +408,7 @@ function runUpdateNestedNodesThenDo(ownSlot, error, action) {
                             partition = childNode;
                     }
                     if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
-                        promised = startIncrementalUpdate(ownSlot, children, p1, p2).then(() => action(error), e => action(e));
+                        promised = startIncrementalNestedScriptsRun(ownSlot, children, p1, p2).then(() => action(error), e => action(e));
                 }
             }
             finally {
@@ -431,34 +431,34 @@ function markToMountIfNecessary(mounting, host, slot, children, sequential) {
     node.host = host;
     return mounting;
 }
-function startIncrementalUpdate(ownerSlot, allChildren, priority1, priority2) {
+function startIncrementalNestedScriptsRun(ownerSlot, allChildren, priority1, priority2) {
     return __awaiter(this, void 0, void 0, function* () {
         const stamp = ownerSlot.instance.stamp;
         if (priority1)
-            yield updateIncrementally(ownerSlot, stamp, allChildren, priority1, Priority.normal);
+            yield runNestedScriptsIncrementally(ownerSlot, stamp, allChildren, priority1, Priority.normal);
         if (priority2)
-            yield updateIncrementally(ownerSlot, stamp, allChildren, priority2, Priority.background);
+            yield runNestedScriptsIncrementally(ownerSlot, stamp, allChildren, priority2, Priority.background);
     });
 }
-function updateIncrementally(owner, stamp, allChildren, items, priority) {
+function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priority) {
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
         const node = owner.instance;
         if (!Transaction.isCanceled || !Transaction.isFrameOver(1, ReactiveNode.shortFrameDuration / 3)) {
-            let outerPriority = ReactiveNode.currentUpdatePriority;
-            ReactiveNode.currentUpdatePriority = priority;
+            let outerPriority = ReactiveNode.currentScriptPriority;
+            ReactiveNode.currentScriptPriority = priority;
             try {
                 if (node.childrenShuffling)
                     shuffle(items);
                 const frameDurationLimit = priority === Priority.background ? ReactiveNode.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveNode.frameDuration / 4, ReactiveNode.shortFrameDuration));
                 for (const child of items) {
-                    triggerUpdateViaSlot(child);
+                    triggerScriptRunViaSlot(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
-                        ReactiveNode.currentUpdatePriority = outerPriority;
+                        ReactiveNode.currentScriptPriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
-                        outerPriority = ReactiveNode.currentUpdatePriority;
-                        ReactiveNode.currentUpdatePriority = priority;
+                        outerPriority = ReactiveNode.currentScriptPriority;
+                        ReactiveNode.currentScriptPriority = priority;
                         frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveNode.frameDuration));
                     }
                     if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveNode.shortFrameDuration / 3))
@@ -466,12 +466,12 @@ function updateIncrementally(owner, stamp, allChildren, items, priority) {
                 }
             }
             finally {
-                ReactiveNode.currentUpdatePriority = outerPriority;
+                ReactiveNode.currentScriptPriority = outerPriority;
             }
         }
     });
 }
-function triggerUpdateViaSlot(slot) {
+function triggerScriptRunViaSlot(slot) {
     const node = slot.instance;
     if (node.stamp >= 0) {
         if (node.has(Mode.autonomous)) {
@@ -479,15 +479,15 @@ function triggerUpdateViaSlot(slot) {
                 Transaction.outside(() => {
                     if (ReactiveSystem.isLogging)
                         ReactiveSystem.setLoggingHint(node.element, node.key);
-                    ReactiveSystem.getOperation(node.update).configure({
+                    ReactiveSystem.getOperation(node.script).configure({
                         order: node.level,
                     });
                 });
             }
-            nonReactiveRun(node.update, node.declaration.triggers);
+            nonReactiveRun(node.script, node.declaration.triggers);
         }
         else
-            updateNow(slot);
+            runScriptNow(slot);
     }
 }
 function mountOrRemountIfNecessary(node) {
@@ -506,7 +506,7 @@ function mountOrRemountIfNecessary(node) {
     else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
         nonReactiveRun(() => driver.runMount(node));
 }
-function updateNow(slot) {
+function runScriptNow(slot) {
     const node = slot.instance;
     if (node.stamp >= 0) {
         let result = undefined;
@@ -519,11 +519,11 @@ function updateNow(slot) {
                     node.children.beginMerge();
                     const driver = node.driver;
                     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); });
+                    result = proceedSyncOrAsync(result, v => { runNestedNodeScriptsThenDoImpl(slot, undefined, NOP); return v; }, e => { console.log(e); runNestedNodeScriptsThenDoImpl(slot, e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
                 }
                 catch (e) {
-                    runUpdateNestedNodesThenDo(slot, e, NOP);
-                    console.log(`Update failed: ${node.key}`);
+                    runNestedNodeScriptsThenDoImpl(slot, e, NOP);
+                    console.log(`Reactive node script failed: ${node.key}`);
                     console.log(`${e}`);
                 }
             }

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

@@ -85,7 +85,7 @@ export function getCallerInfo(prefix) {
     i = i >= 0 ? i + 2 : 5;
     let caller = extractFunctionAndLocation(lines[i]);
     let location = caller;
-    if (caller.func.endsWith(".update")) {
+    if (caller.func.endsWith(".script")) {
         i = i - 1;
         caller = extractFunctionAndLocation(lines[i]);
         location = extractFunctionAndLocation(lines[i + 1]);

package/package.json

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