reactronic 0.92.25012 → 0.92.25013

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

@@ -21,4 +21,3 @@ export { ReactiveSystem, observable, unobservable, atomic, reactive, cached, opt
 export { ReactiveLoop } from "./ReactiveLoop.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export type { Script, ScriptAsync, Handler, ReactiveNodeDecl, ReactiveNodeDriver, ReactiveNodeContext } from "./core/ReactiveNode.js";
-export { RealTimeClock } from "./RealTimeClock.js";

package/build/dist/source/api.js

@@ -16,4 +16,3 @@ export { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./Reacti
 export { ReactiveSystem, observable, unobservable, atomic, reactive, cached, options } from "./ReactiveSystem.js";
 export { ReactiveLoop } from "./ReactiveLoop.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
-export { RealTimeClock } from "./RealTimeClock.js";

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

@@ -49,7 +49,7 @@ export class ReactiveNode {
         else
             declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
         let effectiveKey = declaration.key;
-        const owner = (getModeUsingBasisChain(declaration) & Mode.rootNode) !== Mode.rootNode ? gOwnSlot === null || gOwnSlot === void 0 ? void 0 : gOwnSlot.instance : undefined;
+        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;
@@ -83,28 +83,28 @@ export class ReactiveNode {
         return declaration;
     }
     static get isFirstScriptRun() {
-        return ReactiveNodeImpl.ownSlot.instance.stamp === 1;
+        return ReactiveNodeImpl.nodeSlot.instance.stamp === 1;
     }
     static get key() {
-        return ReactiveNodeImpl.ownSlot.instance.key;
+        return ReactiveNodeImpl.nodeSlot.instance.key;
     }
     static get stamp() {
-        return ReactiveNodeImpl.ownSlot.instance.stamp;
+        return ReactiveNodeImpl.nodeSlot.instance.stamp;
     }
     static get triggers() {
-        return ReactiveNodeImpl.ownSlot.instance.declaration.triggers;
+        return ReactiveNodeImpl.nodeSlot.instance.declaration.triggers;
     }
     static get priority() {
-        return ReactiveNodeImpl.ownSlot.instance.priority;
+        return ReactiveNodeImpl.nodeSlot.instance.priority;
     }
     static set priority(value) {
-        ReactiveNodeImpl.ownSlot.instance.priority = value;
+        ReactiveNodeImpl.nodeSlot.instance.priority = value;
     }
     static get childrenShuffling() {
-        return ReactiveNodeImpl.ownSlot.instance.childrenShuffling;
+        return ReactiveNodeImpl.nodeSlot.instance.childrenShuffling;
     }
     static set childrenShuffling(value) {
-        ReactiveNodeImpl.ownSlot.instance.childrenShuffling = value;
+        ReactiveNodeImpl.nodeSlot.instance.childrenShuffling = value;
     }
     static triggerScriptRun(node, triggers) {
         const impl = node;
@@ -119,7 +119,7 @@ export class ReactiveNode {
         triggerFinalization(impl.slot, true, true);
     }
     static runNestedNodeScriptsThenDo(action) {
-        runNestedNodeScriptsThenDoImpl(ReactiveNodeImpl.ownSlot, undefined, action);
+        runNestedNodeScriptsThenDoImpl(ReactiveNodeImpl.nodeSlot, undefined, action);
     }
     static markAsMounted(node, yes) {
         const n = node;
@@ -311,14 +311,14 @@ class ReactiveNodeImpl extends ReactiveNode {
             throw new Error("reactronic can be configured only for elements with autonomous mode and only during activation");
         return ReactiveSystem.getOperation(this.script).configure(options);
     }
-    static get ownSlot() {
-        if (!gOwnSlot)
+    static get nodeSlot() {
+        if (!gNodeSlot)
             throw new Error("current element is undefined");
-        return gOwnSlot;
+        return gNodeSlot;
     }
     static tryUseNodeVariableValue(variable) {
         var _a, _b;
-        let node = ReactiveNodeImpl.ownSlot.instance;
+        let node = ReactiveNodeImpl.nodeSlot.instance;
         while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
             node = node.outer.slot.instance;
         return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
@@ -331,7 +331,7 @@ class ReactiveNodeImpl extends ReactiveNode {
         return result;
     }
     static setNodeVariableValue(variable, value) {
-        const node = ReactiveNodeImpl.ownSlot.instance;
+        const node = ReactiveNodeImpl.nodeSlot.instance;
         const owner = node.owner;
         const hostCtx = nonReactiveRun(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
@@ -373,10 +373,10 @@ __decorate([
 function getNodeKey(node) {
     return node.stamp >= 0 ? node.key : undefined;
 }
-function runNestedNodeScriptsThenDoImpl(ownSlot, error, action) {
-    runInside(ownSlot, () => {
+function runNestedNodeScriptsThenDoImpl(nodeSlot, error, action) {
+    runInsideContextOfNode(nodeSlot, () => {
         var _a;
-        const owner = ownSlot.instance;
+        const owner = nodeSlot.instance;
         const children = owner.children;
         if (children.isMergeInProgress) {
             let promised = undefined;
@@ -408,7 +408,7 @@ function runNestedNodeScriptsThenDoImpl(ownSlot, error, action) {
                             partition = childNode;
                     }
                     if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
-                        promised = startIncrementalNestedScriptsRun(ownSlot, children, p1, p2).then(() => action(error), e => action(e));
+                        promised = startIncrementalNestedScriptsRun(nodeSlot, children, p1, p2).then(() => action(error), e => action(e));
                 }
             }
             finally {
@@ -418,15 +418,15 @@ function runNestedNodeScriptsThenDoImpl(ownSlot, error, action) {
         }
     });
 }
-function markToMountIfNecessary(mounting, host, slot, children, sequential) {
-    const node = slot.instance;
+function markToMountIfNecessary(mounting, host, nodeSlot, children, sequential) {
+    const node = nodeSlot.instance;
     if (node.element.native && !node.has(Mode.manualMount)) {
         if (mounting || node.host !== host) {
-            children.markAsMoved(slot);
+            children.markAsMoved(nodeSlot);
             mounting = false;
         }
     }
-    else if (sequential && children.isMoved(slot))
+    else if (sequential && children.isMoved(nodeSlot))
         mounting = true;
     node.host = host;
     return mounting;
@@ -471,8 +471,8 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
         }
     });
 }
-function triggerScriptRunViaSlot(slot) {
-    const node = slot.instance;
+function triggerScriptRunViaSlot(nodeSlot) {
+    const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         if (node.has(Mode.autonomous)) {
             if (node.stamp === Number.MAX_SAFE_INTEGER) {
@@ -486,8 +486,10 @@ function triggerScriptRunViaSlot(slot) {
             }
             nonReactiveRun(node.script, node.declaration.triggers);
         }
+        else if (node.owner !== node)
+            runScriptNow(nodeSlot);
         else
-            runScriptNow(slot);
+            atomicRun(() => runScriptNow(nodeSlot));
     }
 }
 function mountOrRemountIfNecessary(node) {
@@ -506,11 +508,11 @@ function mountOrRemountIfNecessary(node) {
     else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
         nonReactiveRun(() => driver.runMount(node));
 }
-function runScriptNow(slot) {
-    const node = slot.instance;
+function runScriptNow(nodeSlot) {
+    const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         let result = undefined;
-        runInside(slot, () => {
+        runInsideContextOfNode(nodeSlot, () => {
             mountOrRemountIfNecessary(node);
             if (node.stamp < Number.MAX_SAFE_INTEGER - 1) {
                 try {
@@ -519,10 +521,10 @@ function runScriptNow(slot) {
                     node.children.beginMerge();
                     const driver = node.driver;
                     result = driver.runScript(node);
-                    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); });
+                    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); });
                 }
                 catch (e) {
-                    runNestedNodeScriptsThenDoImpl(slot, e, NOP);
+                    runNestedNodeScriptsThenDoImpl(nodeSlot, e, NOP);
                     console.log(`Reactive node script failed: ${node.key}`);
                     console.log(`${e}`);
                 }
@@ -530,8 +532,8 @@ function runScriptNow(slot) {
         });
     }
 }
-function triggerFinalization(slot, isLeader, individual) {
-    const node = slot.instance;
+function triggerFinalization(nodeSlot, isLeader, individual) {
+    const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         const driver = node.driver;
         if (individual && node.key !== node.declaration.key && !driver.isPartition)
@@ -539,14 +541,14 @@ function triggerFinalization(slot, isLeader, individual) {
         node.stamp = ~node.stamp;
         const childrenAreLeaders = nonReactiveRun(() => driver.runFinalization(node, isLeader));
         if (node.has(Mode.autonomous)) {
-            slot.aux = undefined;
+            nodeSlot.aux = undefined;
             const last = gLastToDispose;
             if (last)
-                gLastToDispose = last.aux = slot;
+                gLastToDispose = last.aux = nodeSlot;
             else
-                gFirstToDispose = gLastToDispose = slot;
-            if (gFirstToDispose === slot)
-                atomicRun({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
+                gFirstToDispose = gLastToDispose = nodeSlot;
+            if (gFirstToDispose === nodeSlot)
+                atomicRun({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }
@@ -571,23 +573,23 @@ function runDisposalLoop() {
 }
 function wrapToRunInside(func) {
     let wrappedToRunInside;
-    const outer = gOwnSlot;
+    const outer = gNodeSlot;
     if (outer)
         wrappedToRunInside = (...args) => {
-            return runInside(outer, func, ...args);
+            return runInsideContextOfNode(outer, func, ...args);
         };
     else
         wrappedToRunInside = func;
     return wrappedToRunInside;
 }
-function runInside(slot, func, ...args) {
-    const outer = gOwnSlot;
+function runInsideContextOfNode(nodeSlot, func, ...args) {
+    const outer = gNodeSlot;
     try {
-        gOwnSlot = slot;
+        gNodeSlot = nodeSlot;
         return func(...args);
     }
     finally {
-        gOwnSlot = outer;
+        gNodeSlot = outer;
     }
 }
 function triggersAreEqual(a1, a2) {
@@ -641,6 +643,6 @@ function defaultReject(error) {
 Promise.prototype.then = reactronicDomHookedThen;
 const NOP = (...args) => { };
 const NOP_ASYNC = (...args) => __awaiter(void 0, void 0, void 0, function* () { });
-let gOwnSlot = undefined;
+let gNodeSlot = undefined;
 let gFirstToDispose = undefined;
 let gLastToDispose = undefined;

package/package.json

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

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

@@ -1,14 +0,0 @@
-import { ObservableObject } from "./core/Mvcc.js";
-export declare class RealTimeClock extends ObservableObject {
-    hour: number;
-    minute: number;
-    second: number;
-    ms: number;
-    interval: number;
-    paused: boolean;
-    constructor(interval?: number);
-    pause(value?: boolean): void;
-    private tick;
-    protected activate(): void;
-    private put;
-}

package/build/dist/source/RealTimeClock.js

@@ -1,65 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { ObservableObject } from "./core/Mvcc.js";
-import { atomic, reactive } from "./ReactiveSystem.js";
-export class RealTimeClock extends ObservableObject {
-    constructor(interval = 1000) {
-        super();
-        this.hour = 0;
-        this.minute = 0;
-        this.second = 0;
-        this.ms = 0;
-        this.interval = 0;
-        this.paused = false;
-        this.interval = interval;
-        this.put(new Date());
-    }
-    pause(value = true) {
-        this.paused = value;
-    }
-    tick() {
-        let calibration = 0;
-        try {
-            const now = new Date();
-            this.put(now);
-            calibration = now.getTime() % this.interval;
-        }
-        finally {
-            setTimeout(() => this.tick(), this.interval - calibration);
-        }
-    }
-    activate() {
-        this.tick();
-    }
-    put(time) {
-        this.hour = time.getHours();
-        this.minute = time.getMinutes();
-        this.second = time.getSeconds();
-        this.ms = time.getMilliseconds();
-    }
-}
-__decorate([
-    atomic,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Boolean]),
-    __metadata("design:returntype", void 0)
-], RealTimeClock.prototype, "pause", null);
-__decorate([
-    atomic,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], RealTimeClock.prototype, "tick", null);
-__decorate([
-    reactive,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], RealTimeClock.prototype, "activate", null);