reactronic 0.24.119 → 0.24.121

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

@@ -17,6 +17,7 @@ export { Transaction } from './core/Transaction.js';
 export { Monitor } from './core/Monitor.js';
 export { Journal } from './core/Journal.js';
 export { RxSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from './RxSystem.js';
+export { Reaction } from './Reaction.js';
 export { RxNode, Mode, Priority, BaseDriver, RxNodeVariable } from './core/RxNode.js';
 export type { Delegate, SimpleDelegate, RxNodeDecl, RxNodeDriver, RxNodeContext } from './core/RxNode.js';
 export { Clock } from './Clock.js';

package/build/dist/source/api.js

@@ -13,5 +13,6 @@ export { Transaction } from './core/Transaction.js';
 export { Monitor } from './core/Monitor.js';
 export { Journal } from './core/Journal.js';
 export { RxSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from './RxSystem.js';
+export { Reaction } from './Reaction.js';
 export { RxNode, Mode, Priority, BaseDriver, RxNodeVariable } from './core/RxNode.js';
 export { Clock } from './Clock.js';

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

@@ -37,7 +37,13 @@ export declare abstract class RxNode<E = unknown> {
     static frameDuration: number;
     static acquire<E = void>(driver: RxNodeDriver<E>, declaration?: RxNodeDecl<E>, preset?: RxNodeDecl<E>): RxNode<E>;
     static get isFirstUpdate(): boolean;
-    static get nodeStamp(): number;
+    static get key(): string;
+    static get stamp(): number;
+    static get triggers(): unknown;
+    static get priority(): Priority;
+    static set priority(value: Priority);
+    static get childrenShuffling(): boolean;
+    static set childrenShuffling(value: boolean);
     static triggerUpdate(node: RxNode<any>, triggers: unknown): void;
     static updateNestedNodesThenDo(action: (error: unknown) => void): void;
     static findMatchingHost<E = unknown, R = unknown>(node: RxNode<E>, match: SimpleDelegate<RxNode<E>, boolean>): RxNode<R> | undefined;

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

@@ -43,7 +43,7 @@ export class RxNode {
         else
             declaration = preset !== null && preset !== void 0 ? preset : {};
         let key = declaration.key;
-        const owner = gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance;
+        const owner = gOwnSeat === null || gOwnSeat === void 0 ? void 0 : gOwnSeat.instance;
         if (owner) {
             let existing = undefined;
             const children = owner.children;
@@ -75,11 +75,28 @@ export class RxNode {
         return result;
     }
     static get isFirstUpdate() {
-        return (gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance.stamp) === 1;
+        return RxNodeImpl.ownSeat.instance.stamp === 1;
     }
-    static get nodeStamp() {
-        var _a;
-        return (_a = gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance.stamp) !== null && _a !== void 0 ? _a : -1;
+    static get key() {
+        return RxNodeImpl.ownSeat.instance.key;
+    }
+    static get stamp() {
+        return RxNodeImpl.ownSeat.instance.stamp;
+    }
+    static get triggers() {
+        return RxNodeImpl.ownSeat.instance.declaration.triggers;
+    }
+    static get priority() {
+        return RxNodeImpl.ownSeat.instance.priority;
+    }
+    static set priority(value) {
+        RxNodeImpl.ownSeat.instance.priority = value;
+    }
+    static get childrenShuffling() {
+        return RxNodeImpl.ownSeat.instance.childrenShuffling;
+    }
+    static set childrenShuffling(value) {
+        RxNodeImpl.ownSeat.instance.childrenShuffling = value;
     }
     static triggerUpdate(node, triggers) {
         const impl = node;
@@ -254,14 +271,14 @@ class RxNodeImpl extends RxNode {
             throw new Error('reactronic can be configured only for elements with independent update mode and only inside initialize');
         return RxSystem.getReaction(this.update).configure(options);
     }
-    static get current() {
-        if (!gCurrent)
+    static get ownSeat() {
+        if (!gOwnSeat)
             throw new Error('current element is undefined');
-        return gCurrent;
+        return gOwnSeat;
     }
     static tryUseNodeVariableValue(variable) {
         var _a, _b;
-        let node = RxNodeImpl.current.instance;
+        let node = RxNodeImpl.ownSeat.instance;
         while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
             node = node.outer.seat.instance;
         return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
@@ -274,7 +291,7 @@ class RxNodeImpl extends RxNode {
         return result;
     }
     static setNodeVariableValue(variable, value) {
-        const node = RxNodeImpl.current.instance;
+        const node = RxNodeImpl.ownSeat.instance;
         const owner = node.owner;
         const hostCtx = unobs(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
@@ -317,8 +334,8 @@ function getNodeKey(node) {
 }
 function runUpdateNestedNodesThenDo(error, action) {
     var _a;
-    const curr = RxNodeImpl.current;
-    const owner = curr.instance;
+    const ownSeat = RxNodeImpl.ownSeat;
+    const owner = ownSeat.instance;
     const children = owner.children;
     if (children.isMergeInProgress) {
         let promised = undefined;
@@ -350,7 +367,7 @@ function runUpdateNestedNodesThenDo(error, action) {
                         partition = childNode;
                 }
                 if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
-                    promised = startIncrementalUpdate(curr, children, p1, p2).then(() => action(error), e => action(e));
+                    promised = startIncrementalUpdate(ownSeat, children, p1, p2).then(() => action(error), e => action(e));
             }
         }
         finally {
@@ -516,23 +533,23 @@ function runDisposalLoop() {
 }
 function wrapToRunInside(func) {
     let wrappedToRunInside;
-    const current = gCurrent;
-    if (current)
+    const outer = gOwnSeat;
+    if (outer)
         wrappedToRunInside = (...args) => {
-            return runInside(current, func, ...args);
+            return runInside(outer, func, ...args);
         };
     else
         wrappedToRunInside = func;
     return wrappedToRunInside;
 }
 function runInside(seat, func, ...args) {
-    const outer = gCurrent;
+    const outer = gOwnSeat;
     try {
-        gCurrent = seat;
+        gOwnSeat = seat;
         return func(...args);
     }
     finally {
-        gCurrent = outer;
+        gOwnSeat = outer;
     }
 }
 function triggersAreEqual(a1, a2) {
@@ -585,6 +602,6 @@ function defaultReject(error) {
 }
 Promise.prototype.then = reactronicDomHookedThen;
 const NOP = (...args) => { };
-let gCurrent = undefined;
+let gOwnSeat = undefined;
 let gFirstToDispose = undefined;
 let gLastToDispose = undefined;

package/package.json

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