reactronic 0.24.275 → 0.24.301

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

@@ -18,7 +18,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { MergeList } from "../util/MergeList.js";
 import { emitLetters, getCallerInfo } from "../util/Utils.js";
-import { Reentrance } from "../Options.js";
+import { Isolation, Reentrance } from "../Options.js";
 import { ObservableObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
 import { RxSystem, options, raw, reactive, unobs } from "../RxSystem.js";
@@ -281,7 +281,7 @@ class RxNodeImpl extends RxNode {
     configureReactronic(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.independentUpdate))
             throw new Error("reactronic can be configured only for elements with independent update mode and only during activation");
-        return RxSystem.getReaction(this.update).configure(options);
+        return RxSystem.getOperation(this.update).configure(options);
     }
     static get ownSeat() {
         if (!gOwnSeat)
@@ -311,7 +311,7 @@ class RxNodeImpl extends RxNode {
                 node.outer = owner;
             else
                 node.outer = owner.outer;
-            Transaction.run({ separation: true }, () => {
+            Transaction.run({ isolation: Isolation.joinAsNestedTransaction }, () => {
                 const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
@@ -449,7 +449,7 @@ function triggerUpdateViaSeat(seat) {
                 Transaction.outside(() => {
                     if (RxSystem.isLogging)
                         RxSystem.setLoggingHint(node.element, node.key);
-                    RxSystem.getReaction(node.update).configure({
+                    RxSystem.getOperation(node.update).configure({
                         order: node.level,
                     });
                 });
@@ -519,7 +519,7 @@ function triggerDeactivation(seat, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = seat;
             if (gFirstToDispose === seat)
-                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${seat.instance.key})` }, () => {
+                Transaction.run({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${seat.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }

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

@@ -1,6 +1,7 @@
 import { F } from "../util/Utils.js";
 import { Worker } from "../Worker.js";
 import { SnapshotOptions } from "../Options.js";
+import { ObjectHandle, ObjectVersion, Observer, FieldVersion, FieldKey } from "./Data.js";
 import { Changeset } from "./Changeset.js";
 export declare abstract class Transaction implements Worker {
     static get current(): Transaction;
@@ -20,11 +21,69 @@ export declare abstract class Transaction implements Worker {
     abstract readonly isCanceled: boolean;
     abstract readonly isFinished: boolean;
     whenFinished(): Promise<void>;
-    static create(options: SnapshotOptions | null): Transaction;
+    static create(options: SnapshotOptions | null, parent?: Transaction): Transaction;
     static run<T>(options: SnapshotOptions | null, func: F<T>, ...args: any[]): T;
-    static separate<T>(func: F<T>, ...args: any[]): T;
+    static isolate<T>(func: F<T>, ...args: any[]): T;
     static outside<T>(func: F<T>, ...args: any[]): T;
     static isFrameOver(everyN?: number, timeLimit?: number): boolean;
     static requestNextFrame(sleepTime?: number): Promise<void>;
     static get isCanceled(): boolean;
 }
+export declare class TransactionImpl extends Transaction {
+    private static readonly none;
+    private static curr;
+    private static inspection;
+    private static frameStartTime;
+    private static frameOverCounter;
+    readonly margin: number;
+    readonly parent?: TransactionImpl;
+    readonly changeset: Changeset;
+    private pending;
+    private sealed;
+    private canceled?;
+    private after?;
+    private promise?;
+    private resolve;
+    private reject;
+    constructor(options: SnapshotOptions | null, parent?: TransactionImpl);
+    static get current(): TransactionImpl;
+    get id(): number;
+    get hint(): string;
+    get options(): SnapshotOptions;
+    get timestamp(): number;
+    get error(): Error | undefined;
+    run<T>(func: F<T>, ...args: any[]): T;
+    inspect<T>(func: F<T>, ...args: any[]): T;
+    apply(): void;
+    seal(): this;
+    wrap<T>(func: F<T>, error: boolean): F<T>;
+    private static wrapperEnter;
+    private static wrapperLeave;
+    cancel(error: Error, restartAfter?: Worker | null): this;
+    get isCanceled(): boolean;
+    get isFinished(): boolean;
+    whenFinished(): Promise<void>;
+    static run<T>(options: SnapshotOptions | null, func: F<T>, ...args: any[]): T;
+    static isolate<T>(func: F<T>, ...args: any[]): T;
+    static outside<T>(func: F<T>, ...args: any[]): T;
+    static isFrameOver(everyN?: number, timeLimit?: number): boolean;
+    static requestNextFrame(sleepTime?: number): Promise<void>;
+    private static acquire;
+    private guard;
+    private wrapToRetry;
+    private wrapToWaitUntilFinish;
+    private runImpl;
+    private static seal;
+    private checkForConflicts;
+    private tryResolveConflicts;
+    private applyOrDiscard;
+    applyOrDiscardChangeset(): Array<Observer>;
+    applyObjectChanges(h: ObjectHandle, ov: ObjectVersion): void;
+    static migrateObjectChangesToAnotherTransaction(h: ObjectHandle, ov: ObjectVersion, tParent: Transaction): void;
+    static migrateFieldVersionToAnotherTransaction(h: ObjectHandle, fk: FieldKey, ov: ObjectVersion, ovParent: ObjectVersion, tParent: Transaction): void;
+    private acquirePromise;
+    private static getCurrentChangeset;
+    private static getEditableChangeset;
+    static createFieldVersion: (fv: FieldVersion, target: Transaction) => FieldVersion;
+    static _init(): void;
+}

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

@@ -9,25 +9,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { UNDEF, pause } from "../util/Utils.js";
 import { Log, misuse, error, fatal } from "../util/Dbg.js";
-import { Changeset, Dump } from "./Changeset.js";
+import { Isolation } from "../Options.js";
+import { Meta } from "./Data.js";
+import { Changeset, Dump, EMPTY_OBJECT_VERSION, UNDEFINED_REVISION } from "./Changeset.js";
 export class Transaction {
     static get current() { return TransactionImpl.current; }
     whenFinished() {
         return __awaiter(this, void 0, void 0, function* () { });
     }
-    static create(options) { return new TransactionImpl(options); }
+    static create(options, parent) { return new TransactionImpl(options, parent); }
     static run(options, func, ...args) { return TransactionImpl.run(options, func, ...args); }
-    static separate(func, ...args) { return TransactionImpl.separate(func, ...args); }
+    static isolate(func, ...args) { return TransactionImpl.isolate(func, ...args); }
     static outside(func, ...args) { return TransactionImpl.outside(func, ...args); }
     static isFrameOver(everyN = 1, timeLimit = 10) { return TransactionImpl.isFrameOver(everyN, timeLimit); }
     static requestNextFrame(sleepTime = 0) { return TransactionImpl.requestNextFrame(sleepTime); }
     static get isCanceled() { return TransactionImpl.current.isCanceled; }
 }
-class TransactionImpl extends Transaction {
-    constructor(options) {
+export class TransactionImpl extends Transaction {
+    constructor(options, parent) {
         super();
         this.margin = TransactionImpl.curr !== undefined ? TransactionImpl.curr.margin + 1 : -1;
-        this.changeset = new Changeset(options);
+        this.parent = parent;
+        this.changeset = new Changeset(options, parent === null || parent === void 0 ? void 0 : parent.changeset);
         this.pending = 0;
         this.sealed = false;
         this.canceled = undefined;
@@ -126,8 +129,8 @@ class TransactionImpl extends Transaction {
         }
         return result;
     }
-    static separate(func, ...args) {
-        return TransactionImpl.run({ separation: true }, func, ...args);
+    static isolate(func, ...args) {
+        return TransactionImpl.run({ isolation: Isolation.disjoinFromOuterTransaction }, func, ...args);
     }
     static outside(func, ...args) {
         const outer = TransactionImpl.curr;
@@ -152,11 +155,17 @@ class TransactionImpl extends Transaction {
         return pause(sleepTime);
     }
     static acquire(options) {
-        const curr = TransactionImpl.curr;
-        if ((options === null || options === void 0 ? void 0 : options.separation) || curr.isFinished || curr.options.separation === "isolated")
+        var _a;
+        const outer = TransactionImpl.curr;
+        const isolation = (_a = options === null || options === void 0 ? void 0 : options.isolation) !== null && _a !== void 0 ? _a : Isolation.joinToCurrentTransaction;
+        if (outer.isFinished || outer.options.isolation === Isolation.disjoinFromOuterAndInnerTransactions)
+            return new TransactionImpl(options);
+        else if (isolation === Isolation.joinAsNestedTransaction)
+            return new TransactionImpl(options, outer);
+        else if (isolation !== Isolation.joinToCurrentTransaction)
             return new TransactionImpl(options);
         else
-            return TransactionImpl.curr;
+            return outer;
     }
     guard() {
         if (this.sealed && TransactionImpl.curr !== this)
@@ -176,7 +185,7 @@ class TransactionImpl extends Transaction {
                         yield this.after.whenFinished();
                         const options = {
                             hint: `${this.hint} - restart after T${this.after.id}`,
-                            separation: this.options.separation === "isolated" ? "isolated" : true,
+                            isolation: this.options.isolation === Isolation.joinToCurrentTransaction ? Isolation.disjoinFromOuterTransaction : this.options.isolation,
                             logging: this.changeset.options.logging,
                             token: this.changeset.options.token,
                         };
@@ -255,11 +264,12 @@ class TransactionImpl extends Transaction {
         throw error(`T${this.id}[${this.hint}] conflicts with: ${Dump.conflicts(conflicts)}`, undefined);
     }
     applyOrDiscard() {
-        let reactive;
+        let observers;
         try {
             if (Log.isOn && Log.opt.change)
                 Log.write("╠═", "", "", undefined, "changes");
-            reactive = this.changeset.applyOrDiscard(this.canceled);
+            this.changeset.seal();
+            observers = this.applyOrDiscardChangeset();
             this.changeset.triggerGarbageCollection();
             if (this.promise) {
                 if (this.canceled && !this.after)
@@ -274,7 +284,153 @@ class TransactionImpl extends Transaction {
             fatal(e);
             throw e;
         }
-        return reactive;
+        return observers;
+    }
+    applyOrDiscardChangeset() {
+        const error = this.canceled;
+        const changeset = this.changeset;
+        changeset.items.forEach((ov, h) => {
+            changeset.sealObjectVersion(h, ov);
+            if (!error) {
+                this.applyObjectChanges(h, ov);
+                if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
+                    Changeset.totalObjectSnapshotCount++;
+                    if (ov.former.objectVersion === EMPTY_OBJECT_VERSION)
+                        Changeset.totalObjectHandleCount++;
+                }
+            }
+        });
+        if (Log.isOn) {
+            if (Log.opt.change && !error && !changeset.parent) {
+                changeset.items.forEach((ov, h) => {
+                    const fields = [];
+                    ov.changes.forEach((o, fk) => fields.push(fk.toString()));
+                    const s = fields.join(", ");
+                    Log.write("║", "√", `${Dump.snapshot2(h, ov.changeset)} (${s}) is ${ov.former.objectVersion === EMPTY_OBJECT_VERSION ? "constructed" : `applied over #${h.id}t${ov.former.objectVersion.changeset.id}s${ov.former.objectVersion.changeset.timestamp}`}`);
+                });
+            }
+            if (Log.opt.transaction)
+                Log.write(changeset.timestamp < UNDEFINED_REVISION ? "╚══" : "═══", `s${this.timestamp}`, `${this.hint} - ${error ? "CANCEL" : "APPLY"}(${this.changeset.items.size})${error ? ` - ${error}` : ""}`);
+        }
+        if (!error && !this.parent)
+            Changeset.propagateAllChangesThroughSubscriptions(changeset);
+        return changeset.obsolete;
+    }
+    applyObjectChanges(h, ov) {
+        const parent = this.parent;
+        if (parent)
+            TransactionImpl.migrateObjectChangesToAnotherTransaction(h, ov, parent);
+        else
+            h.applied = ov;
+    }
+    static migrateObjectChangesToAnotherTransaction(h, ov, tParent) {
+        const csParent = tParent.changeset;
+        const ovParent = csParent.getEditableObjectVersion(h, Meta.Undefined, undefined);
+        if (ov.former.objectVersion.changeset === EMPTY_OBJECT_VERSION.changeset) {
+            for (const fk in ov.data) {
+                TransactionImpl.migrateFieldVersionToAnotherTransaction(h, fk, ov, ovParent, tParent);
+            }
+        }
+        else {
+            ov.changes.forEach((o, fk) => {
+                TransactionImpl.migrateFieldVersionToAnotherTransaction(h, fk, ov, ovParent, tParent);
+            });
+        }
+    }
+    static migrateFieldVersionToAnotherTransaction(h, fk, ov, ovParent, tParent) {
+        const csParent = tParent.changeset;
+        const fv = ov.data[fk];
+        const fvParent = ovParent.data[fk];
+        if (fv.isLaunch) {
+            const migrated = TransactionImpl.createFieldVersion(fv, tParent);
+            if (ovParent.former.objectVersion.data[fk] !== fvParent) {
+                let observers = fvParent.observers;
+                if (observers) {
+                    const migratedObservers = migrated.observers = new Set();
+                    observers.forEach(o => {
+                        var _a, _b;
+                        const sub = o.observables.get(fvParent);
+                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fvParent);
+                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(migrated, sub);
+                        migratedObservers.add(o);
+                    });
+                    fvParent.observers = undefined;
+                }
+                observers = fv.observers;
+                if (observers) {
+                    let migratedObservers = migrated.observers;
+                    if (migratedObservers === undefined)
+                        migratedObservers = migrated.observers = new Set();
+                    observers.forEach(o => {
+                        var _a, _b;
+                        const sub = o.observables.get(fv);
+                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(migrated, sub);
+                        migratedObservers === null || migratedObservers === void 0 ? void 0 : migratedObservers.add(o);
+                    });
+                    fv.observers = undefined;
+                }
+                const observables = fv.observables;
+                const migratedObservables = migrated.observables;
+                if (observables) {
+                    observables.forEach((s, o) => {
+                        var _a, _b;
+                        (_a = o.observers) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observers) === null || _b === void 0 ? void 0 : _b.add(migrated);
+                        migratedObservables === null || migratedObservables === void 0 ? void 0 : migratedObservables.set(o, s);
+                    });
+                    observables.clear();
+                }
+                ovParent.data[fk] = migrated;
+            }
+            else {
+                const observers = fv.observers;
+                if (observers) {
+                    const migratedObservers = migrated.observers = new Set();
+                    observers.forEach(o => {
+                        var _a, _b;
+                        const sub = o.observables.get(fv);
+                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(migrated, sub);
+                        migratedObservers.add(o);
+                    });
+                    fv.observers = undefined;
+                }
+                const observables = fv.observables;
+                const migratedObservables = migrated.observables;
+                if (observables) {
+                    observables.forEach((s, o) => {
+                        var _a, _b;
+                        (_a = o.observers) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observers) === null || _b === void 0 ? void 0 : _b.add(migrated);
+                        migratedObservables === null || migratedObservables === void 0 ? void 0 : migratedObservables.set(o, s);
+                    });
+                    observables.clear();
+                }
+                ovParent.data[fk] = migrated;
+            }
+            csParent.bumpBy(ovParent.former.objectVersion.changeset.timestamp);
+            Changeset.markEdited(undefined, migrated, true, ovParent, fk, h);
+        }
+        else {
+            const parentContent = fvParent === null || fvParent === void 0 ? void 0 : fvParent.content;
+            if (ovParent.former.objectVersion.data[fk] !== fvParent) {
+                fvParent.content = fv.content;
+                const observers = fv.observers;
+                if (observers) {
+                    observers.forEach(o => {
+                        var _a, _b, _c;
+                        const sub = o.observables.get(fv);
+                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(fvParent, sub);
+                        (_c = fvParent.observers) === null || _c === void 0 ? void 0 : _c.add(o);
+                    });
+                }
+            }
+            else
+                ovParent.data[fk] = fv;
+            Changeset.markEdited(parentContent, fv.content, true, ovParent, fk, h);
+        }
     }
     acquirePromise() {
         if (!this.promise) {
@@ -297,7 +453,7 @@ class TransactionImpl extends Transaction {
         Changeset.current = TransactionImpl.getCurrentChangeset;
         Changeset.edit = TransactionImpl.getEditableChangeset;
         TransactionImpl.none.sealed = true;
-        TransactionImpl.none.changeset.applyOrDiscard();
+        TransactionImpl.none.changeset.seal();
         Changeset._init();
     }
 }
@@ -306,4 +462,7 @@ TransactionImpl.curr = TransactionImpl.none;
 TransactionImpl.inspection = false;
 TransactionImpl.frameStartTime = 0;
 TransactionImpl.frameOverCounter = 0;
+TransactionImpl.createFieldVersion = function (fv, target) {
+    throw misuse("this implementation of cloneLaunch should never be called");
+};
 TransactionImpl._init();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.24.275",
+  "version": "0.24.301",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -32,13 +32,13 @@
   "homepage": "https://github.com/nezaboodka/reactronic/blob/master/README.md#readme",
   "devDependencies": {
     "@types/node": "20.11.28",
-    "@types/react": "18.2.66",
+    "@types/react": "18.3.4",
     "@typescript-eslint/eslint-plugin": "7.2.0",
     "@typescript-eslint/parser": "7.2.0",
     "ava": "6.1.2",
     "c8": "9.1.0",
     "eslint": "8.57.0",
-    "react": "18.2.0",
+    "react": "18.3.1",
     "ts-node": "10.9.2",
     "typescript": "5.3.2"
   },