reactronic 0.24.304 → 0.24.306

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

@@ -18,6 +18,7 @@ export type MemberOptions = {
     readonly triggeringArgs: boolean;
     readonly throttling: number;
     readonly reentrance: Reentrance;
+    readonly allowObsoleteToFinish: boolean;
     readonly journal: Journal | undefined;
     readonly indicator: Indicator | null;
     readonly logging?: Partial<LoggingOptions>;
@@ -49,7 +50,7 @@ export type Operation<T> = {
     readonly result: T;
     readonly error: any;
     readonly stamp: number;
-    readonly isUpToDate: boolean;
+    readonly isReusable: boolean;
     configure(options: Partial<MemberOptions>): MemberOptions;
     markObsolete(): void;
     pullLastResult(args?: any[]): T | undefined;

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

@@ -26,7 +26,10 @@ export declare class Changeset implements AbstractChangeset {
     static edit: () => Changeset;
     static markUsed: (fv: FieldVersion, ov: ObjectVersion, fk: FieldKey, h: ObjectHandle, kind: Kind, weak: boolean) => void;
     static markEdited: (oldValue: any, newValue: any, edited: boolean, ov: ObjectVersion, fk: FieldKey, h: ObjectHandle) => void;
-    static isConflicting: (oldValue: any, newValue: any) => boolean;
+    static tryResolveConflict: (theirValue: any, ourFormerValue: any, ourValue: any) => {
+        isResolved: boolean;
+        resolvedValue: any;
+    };
     static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
     static revokeAllSubscriptions: (changeset: Changeset) => void;
     static enqueueReactiveFunctionsToRun: (reactive: Array<Observer>) => void;

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

@@ -157,7 +157,7 @@ export class Changeset {
         let conflicts = undefined;
         if (this.items.size > 0) {
             this.items.forEach((ov, h) => {
-                const theirs = this.parent ? this.parent.lookupObjectVersion(h, Meta.Handle, false) : h.applied;
+                const theirs = this.parent ? this.parent.lookupObjectVersion(h, Meta.Handle, true) : h.applied;
                 if (ov.former.objectVersion !== theirs) {
                     const merged = this.merge(h, ov, theirs);
                     if (ov.conflicts.size > 0) {
@@ -202,11 +202,15 @@ export class Changeset {
                 }
             }
             else {
-                const conflict = Changeset.isConflicting(theirs.data[fk], ours.former.objectVersion.data[fk]);
-                if (conflict)
+                const theirValue = theirs.data[fk];
+                const ourFormerValue = ours.former.objectVersion.data[fk];
+                const { isResolved, resolvedValue } = Changeset.tryResolveConflict(theirValue, ourFormerValue, ourFieldVersion);
+                if (!isResolved)
                     ours.conflicts.set(fk, theirs);
+                else if (resolvedValue.isLaunch)
+                    merged[fk] = resolvedValue;
                 if (Log.isOn && Log.opt.change)
-                    Log.write("║╠", "", `${Dump.snapshot2(h, ours.changeset, fk)} ${conflict ? "<>" : "=="} ${Dump.snapshot2(h, theirs.changeset, fk)}`, 0, conflict ? " *** CONFLICT ***" : undefined);
+                    Log.write("║╠", "", `${Dump.snapshot2(h, ours.changeset, fk)} ${!isResolved ? "<>" : "=="} ${Dump.snapshot2(h, theirs.changeset, fk)}`, 0, !isResolved ? " *** CONFLICT ***" : undefined);
             }
         });
         Utils.copyAllMembers(merged, ours.data);
@@ -311,7 +315,7 @@ Changeset.current = UNDEF;
 Changeset.edit = UNDEF;
 Changeset.markUsed = UNDEF;
 Changeset.markEdited = UNDEF;
-Changeset.isConflicting = UNDEF;
+Changeset.tryResolveConflict = UNDEF;
 Changeset.propagateAllChangesThroughSubscriptions = (changeset) => { };
 Changeset.revokeAllSubscriptions = (changeset) => { };
 Changeset.enqueueReactiveFunctionsToRun = (reactive) => { };

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

@@ -131,13 +131,13 @@ export class IndicatorImpl extends Indicator {
     }
     static tick(mon) {
         if (mon.internals.started !== 0) {
-            Transaction.run(INDICATOR_TICK_OPTIONS, () => {
-                const resolution = mon.internals.durationResolution;
-                mon.busyDuration = Math.round(resolution * (performance.now() - mon.internals.started)) / resolution;
-            });
+            const resolution = mon.internals.durationResolution;
+            mon.busyDuration = Math.round(resolution * (performance.now() - mon.internals.started)) / resolution;
             const t = globalThis !== null && globalThis !== void 0 ? globalThis : global;
             if (t.requestAnimationFrame)
-                requestAnimationFrame(() => IndicatorImpl.tick(mon));
+                requestAnimationFrame(() => {
+                    Transaction.run(INDICATOR_TICK_OPTIONS, () => IndicatorImpl.tick(mon));
+                });
         }
     }
 }

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

@@ -24,6 +24,7 @@ export declare class OptionsImpl implements MemberOptions {
     readonly triggeringArgs: boolean;
     readonly throttling: number;
     readonly reentrance: Reentrance;
+    readonly allowObsoleteToFinish: boolean;
     readonly journal: Journal | undefined;
     readonly indicator: Indicator | null;
     readonly logging?: Partial<LoggingOptions>;

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

@@ -33,6 +33,7 @@ const DEFAULT_OPTIONS = Object.freeze({
     triggeringArgs: false,
     throttling: Number.MAX_SAFE_INTEGER,
     reentrance: Reentrance.preventWithError,
+    allowObsoleteToFinish: false,
     journal: undefined,
     indicator: null,
     logging: undefined,
@@ -48,6 +49,7 @@ export class OptionsImpl {
         this.triggeringArgs = merge(DEFAULT_OPTIONS.triggeringArgs, existing.triggeringArgs, patch.triggeringArgs, implicit);
         this.throttling = merge(DEFAULT_OPTIONS.throttling, existing.throttling, patch.throttling, implicit);
         this.reentrance = merge(DEFAULT_OPTIONS.reentrance, existing.reentrance, patch.reentrance, implicit);
+        this.allowObsoleteToFinish = merge(DEFAULT_OPTIONS.allowObsoleteToFinish, existing.allowObsoleteToFinish, patch.allowObsoleteToFinish, implicit);
         this.journal = merge(DEFAULT_OPTIONS.journal, existing.journal, patch.journal, implicit);
         this.indicator = merge(DEFAULT_OPTIONS.indicator, existing.indicator, patch.indicator, implicit);
         this.logging = merge(DEFAULT_OPTIONS.logging, existing.logging, patch.logging, implicit);

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

@@ -13,7 +13,7 @@ export declare class OperationImpl implements Operation<any> {
     get result(): any;
     get error(): boolean;
     get stamp(): number;
-    get isUpToDate(): boolean;
+    get isReusable(): boolean;
     markObsolete(): void;
     pullLastResult(args?: any[]): any;
     constructor(h: ObjectHandle, fk: FieldKey);
@@ -74,7 +74,7 @@ declare class Launch extends FieldVersion implements Observer {
     private static processDeferredReactiveFunctions;
     private static markUsed;
     private static markEdited;
-    private static isConflicting;
+    private static tryResolveConflict;
     private static propagateAllChangesThroughSubscriptions;
     private static revokeAllSubscriptions;
     private static propagateFieldChangeThroughSubscriptions;

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

@@ -17,7 +17,7 @@ export class OperationImpl {
     get result() { return this.reuseOrRelaunch(true, undefined).content; }
     get error() { return this.use().launch.error; }
     get stamp() { return this.use().objectVersion.changeset.timestamp; }
-    get isUpToDate() { return this.use().isUpToDate; }
+    get isReusable() { return this.use().isReusable; }
     markObsolete() { Transaction.run({ hint: Log.isOn ? `markObsolete(${Dump.obj(this.ownerHandle, this.fieldKey)})` : "markObsolete()" }, OperationImpl.markObsolete, this); }
     pullLastResult(args) { return this.reuseOrRelaunch(true, args).content; }
     constructor(h, fk) {
@@ -29,7 +29,7 @@ export class OperationImpl {
         const ctx = ror.changeset;
         const launch = ror.launch;
         const opts = launch.options;
-        if (!ror.isUpToDate && !ror.objectVersion.disposed
+        if (!ror.isReusable && !ror.objectVersion.disposed
             && (!weak || launch.cause === BOOT_CAUSE || !launch.successor ||
                 launch.successor.transaction.isFinished)) {
             const isolation = !weak ? opts.isolation : Isolation.disjoinFromOuterTransaction;
@@ -98,11 +98,12 @@ export class OperationImpl {
         const ctx = Changeset.current();
         const ov = ctx.lookupObjectVersion(this.ownerHandle, this.fieldKey, false);
         const launch = this.acquireFromObjectVersion(ov, args);
-        const isValid = launch.options.kind !== Kind.transactional && launch.cause !== BOOT_CAUSE &&
-            (ctx === launch.changeset || ctx.timestamp < launch.obsoleteSince) &&
+        const applied = this.ownerHandle.applied.data[this.fieldKey];
+        const isReusable = launch.options.kind !== Kind.transactional && launch.cause !== BOOT_CAUSE &&
+            (ctx === launch.changeset || ctx.timestamp < launch.obsoleteSince || applied.obsoleteDueTo === undefined) &&
             (!launch.options.triggeringArgs || args === undefined ||
                 launch.args.length === args.length && launch.args.every((t, i) => t === args[i])) || ov.disposed;
-        return { launch, isUpToDate: isValid, changeset: ctx, objectVersion: ov };
+        return { launch, isReusable, changeset: ctx, objectVersion: ov };
     }
     use() {
         const ror = this.peek(undefined);
@@ -122,7 +123,7 @@ export class OperationImpl {
             Changeset.markEdited(launch, relaunch, true, ov, fk, h);
             launch = relaunch;
         }
-        return { launch, isUpToDate: true, changeset: ctx, objectVersion: ov };
+        return { launch, isReusable: true, changeset: ctx, objectVersion: ov };
     }
     acquireFromObjectVersion(ov, args) {
         const fk = this.fieldKey;
@@ -174,7 +175,7 @@ export class OperationImpl {
             }
             else {
                 ror = this.peek(argsx);
-                if (ror.launch.options.kind === Kind.transactional || !ror.isUpToDate) {
+                if (ror.launch.options.kind === Kind.transactional || !ror.isReusable) {
                     ror = this.edit();
                     if (Log.isOn && Log.opt.operation)
                         Log.write("║", "  o", `${ror.launch.why()}`);
@@ -189,7 +190,8 @@ export class OperationImpl {
     static markObsolete(self) {
         const ror = self.peek(undefined);
         const ctx = ror.changeset;
-        ror.launch.markObsoleteDueTo(ror.launch, self.fieldKey, EMPTY_OBJECT_VERSION.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
+        const obsolete = ror.launch.transaction.isFinished ? ctx.obsolete : ror.launch.transaction.changeset.obsolete;
+        ror.launch.markObsoleteDueTo(ror.launch, self.fieldKey, EMPTY_OBJECT_VERSION.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, obsolete);
     }
 }
 class Launch extends FieldVersion {
@@ -307,7 +309,7 @@ class Launch extends FieldVersion {
                 const tran = this.transaction;
                 if (tran.changeset === changeset) {
                 }
-                else if (!tran.isFinished && this !== observable)
+                else if (!tran.isFinished && this !== observable && !this.options.allowObsoleteToFinish)
                     tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Dump.snapshot2(h, changeset, fk)} changed by T${changeset.id}[${changeset.hint}]`), null);
             }
             else if (Log.isOn && (Log.opt.obsolete || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.obsolete)))
@@ -485,11 +487,20 @@ class Launch extends FieldVersion {
         if (Log.isOn && Log.opt.write)
             edited ? Log.write("║", "  =", `${Dump.snapshot2(h, ov.changeset, fk)} is changed: ${valueHint(oldValue)} ▸▸ ${valueHint(newValue)}`) : Log.write("║", "  =", `${Dump.snapshot2(h, ov.changeset, fk)} is changed: ${valueHint(oldValue)} ▸▸ ${valueHint(newValue)}`, undefined, " (same as previous)");
     }
-    static isConflicting(oldValue, newValue) {
-        let result = oldValue !== newValue;
-        if (result)
-            result = oldValue instanceof Launch && oldValue.cause !== BOOT_CAUSE;
-        return result;
+    static tryResolveConflict(theirValue, ourFormerValue, ourValue) {
+        let isResolved = theirValue === ourFormerValue;
+        let resolvedValue = ourValue;
+        if (!isResolved) {
+            if (ourValue instanceof Launch && ourValue.obsoleteDueTo === undefined) {
+                isResolved = true;
+                resolvedValue = ourValue;
+            }
+            else if (theirValue instanceof Launch && (theirValue.obsoleteDueTo === undefined || theirValue.cause === BOOT_CAUSE)) {
+                isResolved = true;
+                resolvedValue = theirValue;
+            }
+        }
+        return { isResolved, resolvedValue };
     }
     static propagateAllChangesThroughSubscriptions(changeset) {
         var _a;
@@ -533,7 +544,11 @@ class Launch extends FieldVersion {
                     else
                         former.successor = undefined;
                 }
-                (_a = former.observers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, fk, ov.changeset, h, why, timestamp, obsolete));
+                (_a = former.observers) === null || _a === void 0 ? void 0 : _a.forEach(s => {
+                    const t = s.transaction;
+                    const o = t.isFinished ? obsolete : t.changeset.obsolete;
+                    return s.markObsoleteDueTo(former, fk, ov.changeset, h, why, timestamp, o);
+                });
             }
         }
         if (curr instanceof Launch) {
@@ -653,7 +668,7 @@ class Launch extends FieldVersion {
         Dump.valueHint = valueHint;
         Changeset.markUsed = Launch.markUsed;
         Changeset.markEdited = Launch.markEdited;
-        Changeset.isConflicting = Launch.isConflicting;
+        Changeset.tryResolveConflict = Launch.tryResolveConflict;
         Changeset.propagateAllChangesThroughSubscriptions = Launch.propagateAllChangesThroughSubscriptions;
         Changeset.revokeAllSubscriptions = Launch.revokeAllSubscriptions;
         Changeset.enqueueReactiveFunctionsToRun = Launch.enqueueReactiveFunctionsToRun;

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

@@ -354,7 +354,8 @@ RxNodeImpl.disposableNodeCount = 0;
 __decorate([
     reactive,
     options({
-        reentrance: Reentrance.cancelPrevious,
+        reentrance: Reentrance.cancelAndWaitPrevious,
+        allowObsoleteToFinish: true,
         triggeringArgs: true,
         noSideEffects: false,
     }),

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

@@ -12,6 +12,7 @@ export declare abstract class Transaction implements Worker {
     abstract readonly error: Error | undefined;
     abstract readonly changeset: Changeset;
     abstract readonly margin: number;
+    abstract readonly parent?: Transaction;
     abstract run<T>(func: F<T>, ...args: any[]): T;
     abstract inspect<T>(func: F<T>, ...args: any[]): T;
     abstract apply(): void;

package/package.json

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