reactronic 0.21.524 → 0.21.528

package/build/dist/source/impl/Operation.d.ts

@@ -34,7 +34,8 @@ export declare class OperationController extends Controller<any> {
 }
 declare class Operation extends Observable implements Observer {
     static current?: Operation;
-    static deferredReactions: Operation[];
+    static queuedReactions: Array<Observer>;
+    static deferredReactions: Array<Operation>;
     readonly margin: number;
     readonly transaction: Transaction;
     readonly controller: OperationController;
@@ -62,6 +63,7 @@ declare class Operation extends Observable implements Observer {
     run(proxy: any, args: any[] | undefined): void;
     markObsoleteDueTo(observable: Observable, cause: MemberInfo, since: number, reactions: Observer[]): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
+    isNotUpToDate(): boolean;
     reenterOver(head: Operation): this;
     private static run;
     private enter;
@@ -77,6 +79,7 @@ declare class Operation extends Observable implements Observer {
     private static propagateAllChangesThroughSubscriptions;
     private static revokeAllSubscriptions;
     private static propagateMemberChangeThroughSubscriptions;
+    private static enqueueDetectedReactions;
     private unsubscribeFromAllObservables;
     private subscribeTo;
     private static canSubscribe;

package/build/dist/source/impl/Operation.js

@@ -107,7 +107,7 @@ class OperationController extends Controller_1.Controller {
     peek(args) {
         const ctx = Snapshot_1.Snapshot.current();
         const r = ctx.seekRevision(this.ownHolder, this.memberName);
-        const op = this.peekFromRevision(r);
+        const op = this.peekFromRevision(r, args);
         const isValid = op.options.kind !== Options_1.Kind.Transaction && op.cause !== ROOT_TRIGGER &&
             (ctx === op.revision.snapshot || ctx.timestamp < op.obsoleteSince) &&
             (!op.options.sensitiveArgs || args === undefined ||
@@ -125,7 +125,7 @@ class OperationController extends Controller_1.Controller {
         const m = this.memberName;
         const ctx = Snapshot_1.Snapshot.edit();
         const r = ctx.getEditableRevision(h, m, Data_1.Meta.Holder, this);
-        let op = this.peekFromRevision(r);
+        let op = this.peekFromRevision(r, undefined);
         if (op.revision !== r) {
             const op2 = new Operation(this, r, op);
             r.data[m] = op2.reenterOver(op);
@@ -135,7 +135,7 @@ class OperationController extends Controller_1.Controller {
         }
         return { operation: op, isUpToDate: true, snapshot: ctx, revision: r };
     }
-    peekFromRevision(r) {
+    peekFromRevision(r, args) {
         const m = this.memberName;
         let op = r.data[m];
         if (op.controller !== this) {
@@ -148,6 +148,8 @@ class OperationController extends Controller_1.Controller {
                 if (op2.controller !== this) {
                     r2 = Snapshot_1.Snapshot.edit().getEditableRevision(h, m, Data_1.Meta.Holder, this);
                     const t = new Operation(this, r2, op2);
+                    if (args)
+                        t.args = args;
                     t.cause = ROOT_TRIGGER;
                     r2.data[m] = t;
                     Snapshot_1.Snapshot.markEdited(op2, t, true, r2, m, h);
@@ -296,8 +298,7 @@ class Operation extends Data_1.Observable {
         const interval = Date.now() + this.started;
         const hold = t ? t - interval : 0;
         if (now || hold < 0) {
-            if (!this.error && (this.options.kind === Options_1.Kind.Transaction ||
-                !this.successor || this.successor.transaction.isCanceled)) {
+            if (this.isNotUpToDate()) {
                 try {
                     const op = this.controller.useOrRun(false, undefined);
                     if (op.result instanceof Promise)
@@ -321,6 +322,10 @@ class Operation extends Data_1.Observable {
                 this.addToDeferredReactions();
         }
     }
+    isNotUpToDate() {
+        return !this.error && (this.options.kind === Options_1.Kind.Transaction ||
+            !this.successor || this.successor.transaction.isCanceled);
+    }
     reenterOver(head) {
         let error = undefined;
         const opponent = head.successor;
@@ -514,6 +519,21 @@ class Operation extends Data_1.Observable {
             curr.observers = undefined;
         }
     }
+    static enqueueDetectedReactions(snapshot) {
+        const queue = Operation.queuedReactions;
+        const isRoot = queue.length === 0;
+        for (const r of snapshot.reactions)
+            queue.push(r);
+        if (isRoot) {
+            let i = 0;
+            while (i < queue.length) {
+                const reaction = queue[i];
+                reaction.runIfNotUpToDate(false, true);
+                i++;
+            }
+            Operation.queuedReactions = [];
+        }
+    }
     unsubscribeFromAllObservables() {
         var _a;
         (_a = this.observables) === null || _a === void 0 ? void 0 : _a.forEach((hint, value) => {
@@ -590,6 +610,7 @@ class Operation extends Data_1.Observable {
         Snapshot_1.Snapshot.isConflicting = Operation.isConflicting;
         Snapshot_1.Snapshot.propagateAllChangesThroughSubscriptions = Operation.propagateAllChangesThroughSubscriptions;
         Snapshot_1.Snapshot.revokeAllSubscriptions = Operation.revokeAllSubscriptions;
+        Snapshot_1.Snapshot.enqueueDetectedReactions = Operation.enqueueDetectedReactions;
         Hooks_1.Hooks.createControllerAndGetHook = Operation.createControllerAndGetHook;
         Hooks_1.Hooks.rememberOperationOptions = Operation.rememberOperationOptions;
         Promise.prototype.then = reactronicHookedThen;
@@ -616,6 +637,7 @@ class Operation extends Data_1.Observable {
     }
 }
 Operation.current = undefined;
+Operation.queuedReactions = [];
 Operation.deferredReactions = [];
 function propagationHint(cause, full) {
     const result = [];

package/build/dist/source/impl/Snapshot.d.ts

@@ -28,6 +28,7 @@ export declare class Snapshot implements AbstractSnapshot {
     static isConflicting: (oldValue: any, newValue: any) => boolean;
     static propagateAllChangesThroughSubscriptions: (snapshot: Snapshot) => void;
     static revokeAllSubscriptions: (snapshot: Snapshot) => void;
+    static enqueueDetectedReactions: (snapshot: Snapshot) => void;
     seekRevision(h: ObjectHolder, m: MemberName): ObjectRevision;
     getCurrentRevision(h: ObjectHolder, m: MemberName): ObjectRevision;
     getEditableRevision(h: ObjectHolder, m: MemberName, value: any, token?: any): ObjectRevision;

package/build/dist/source/impl/Snapshot.js

@@ -309,6 +309,7 @@ Snapshot.markEdited = Utils_1.UNDEF;
 Snapshot.isConflicting = Utils_1.UNDEF;
 Snapshot.propagateAllChangesThroughSubscriptions = (snapshot) => { };
 Snapshot.revokeAllSubscriptions = (snapshot) => { };
+Snapshot.enqueueDetectedReactions = (snapshot) => { };
 class Dump {
     static obj(h, m, stamp, op, xop, typeless) {
         const member = m !== undefined ? `.${m.toString()}` : '';

package/build/dist/source/impl/Transaction.d.ts

@@ -24,7 +24,7 @@ export declare abstract class Transaction implements Worker {
     static run<T>(func: F<T>, ...args: any[]): T;
     static runAs<T>(options: SnapshotOptions | null, func: F<T>, ...args: any[]): T;
     static standalone<T>(func: F<T>, ...args: any[]): T;
-    static isTimeOver(everyN?: number): boolean;
-    static requestMoreTime(): Promise<void>;
+    static isFrameOver(everyN?: number, timeLimit?: number): boolean;
+    static requestNextFrame(sleepTime?: number): Promise<void>;
     static get isCanceled(): boolean;
 }

package/build/dist/source/impl/Transaction.js

@@ -22,8 +22,8 @@ class Transaction {
     static run(func, ...args) { return TransactionImpl.run(func, ...args); }
     static runAs(options, func, ...args) { return TransactionImpl.runAs(options, func, ...args); }
     static standalone(func, ...args) { return TransactionImpl.standalone(func, ...args); }
-    static isTimeOver(everyN = 1) { return TransactionImpl.isTimeOver(everyN); }
-    static requestMoreTime() { return TransactionImpl.requestMoreTime(); }
+    static isFrameOver(everyN = 1, timeLimit = 14) { return TransactionImpl.isFrameOver(everyN, timeLimit); }
+    static requestNextFrame(sleepTime = 0) { return TransactionImpl.requestNextFrame(sleepTime); }
     static get isCanceled() { return TransactionImpl.current.isCanceled; }
 }
 exports.Transaction = Transaction;
@@ -124,10 +124,11 @@ class TransactionImpl extends Transaction {
         t.guard();
         let result = t.runImpl(options === null || options === void 0 ? void 0 : options.trace, func, ...args);
         if (root) {
-            if (result instanceof Promise)
+            if (result instanceof Promise) {
                 result = TransactionImpl.standalone(() => {
                     return t.wrapToRetry(t.wrapToWaitUntilFinish(result), func, ...args);
                 });
+            }
             t.seal();
         }
         return result;
@@ -142,16 +143,16 @@ class TransactionImpl extends Transaction {
             TransactionImpl.curr = outer;
         }
     }
-    static isTimeOver(everyN = 1) {
-        TransactionImpl.checkCount++;
-        let result = TransactionImpl.checkCount % everyN === 0;
+    static isFrameOver(everyN = 1, timeLimit = 14) {
+        TransactionImpl.frameOverCounter++;
+        let result = TransactionImpl.frameOverCounter % everyN === 0;
         if (result) {
-            const ms = performance.now() - TransactionImpl.startTime;
-            result = ms > TransactionImpl.timeLimit;
+            const ms = performance.now() - TransactionImpl.frameStartTime;
+            result = ms > timeLimit;
         }
         return result;
     }
-    static requestMoreTime(sleepTime = 0) {
+    static requestNextFrame(sleepTime = 0) {
         return (0, Utils_1.pause)(sleepTime);
     }
     static acquire(options) {
@@ -205,8 +206,8 @@ class TransactionImpl extends Transaction {
         const outer = TransactionImpl.curr;
         try {
             if (outer === TransactionImpl.none) {
-                TransactionImpl.startTime = performance.now();
-                TransactionImpl.checkCount = 0;
+                TransactionImpl.frameStartTime = performance.now();
+                TransactionImpl.frameOverCounter = 0;
             }
             TransactionImpl.curr = this;
             this.pending++;
@@ -229,16 +230,13 @@ class TransactionImpl extends Transaction {
             if (this.sealed && this.pending === 0) {
                 this.applyOrDiscard();
                 TransactionImpl.curr = outer;
-                TransactionImpl.standalone(TransactionImpl.runReactions, this);
+                TransactionImpl.standalone(Snapshot_1.Snapshot.enqueueDetectedReactions, this.snapshot);
             }
             else
                 TransactionImpl.curr = outer;
         }
         return result;
     }
-    static runReactions(t) {
-        t.snapshot.reactions.forEach(x => x.runIfNotUpToDate(false, true));
-    }
     static seal(t, error, after) {
         if (!t.canceled && error) {
             t.canceled = error;
@@ -308,7 +306,6 @@ class TransactionImpl extends Transaction {
 TransactionImpl.none = new TransactionImpl({ hint: '<none>' });
 TransactionImpl.curr = TransactionImpl.none;
 TransactionImpl.inspection = false;
-TransactionImpl.startTime = 0;
-TransactionImpl.timeLimit = 14;
-TransactionImpl.checkCount = 0;
+TransactionImpl.frameStartTime = 0;
+TransactionImpl.frameOverCounter = 0;
 TransactionImpl._init();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.21.524",
+  "version": "0.21.528",
   "description": "Reactronic - Transactional Reactive State Management",
   "main": "build/dist/source/api.js",
   "types": "build/dist/source/api.d.ts",