reactronic 0.24.305 → 0.24.307

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

@@ -50,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/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()}`);
@@ -486,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;
@@ -658,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.d.ts

@@ -36,7 +36,9 @@ export declare abstract class RxNode<E = unknown> {
     static readonly longFrameDuration = 300;
     static currentUpdatePriority: Priority;
     static frameDuration: number;
-    static declare<E = void>(driver: RxNodeDriver<E>, declaration?: RxNodeDecl<E>, basis?: RxNodeDecl<E>): RxNode<E>;
+    static declare<E = void>(driver: RxNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, creation?: Script<E>, creationAsync?: ScriptAsync<E>, destruction?: Script<E>, triggers?: unknown, basis?: RxNodeDecl<E>): RxNode<E>;
+    static declare<E = void>(driver: RxNodeDriver<E>, declaration?: RxNodeDecl<E>): RxNode<E>;
+    static rebased<E = void>(declaration?: RxNodeDecl<E>, basis?: RxNodeDecl<E>): RxNodeDecl<E>;
     static get isFirstUpdate(): boolean;
     static get key(): string;
     static get stamp(): number;

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

@@ -36,18 +36,23 @@ export var Priority;
     Priority[Priority["background"] = 2] = "background";
 })(Priority || (Priority = {}));
 export class RxNode {
-    static declare(driver, declaration, basis) {
+    static declare(driver, scriptOrDeclaration, scriptAsync, key, mode, creation, creationAsync, destruction, triggers, basis) {
         let result;
-        if (declaration)
-            declaration.basis = basis;
+        let declaration;
+        if (scriptOrDeclaration instanceof Function) {
+            declaration = {
+                script: scriptOrDeclaration, scriptAsync, key, mode,
+                creation, creationAsync, destruction, triggers, basis,
+            };
+        }
         else
-            declaration = basis !== null && basis !== void 0 ? basis : {};
-        let key = declaration.key;
+            declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
+        let effectiveKey = declaration.key;
         const owner = gOwnSeat === null || gOwnSeat === void 0 ? void 0 : gOwnSeat.instance;
         if (owner) {
-            let existing = owner.driver.child(owner, driver, declaration, basis);
+            let existing = owner.driver.child(owner, driver, declaration, declaration.basis);
             const children = owner.children;
-            existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(key = key || generateKey(owner), undefined, "nested elements can be declared inside update function only"));
+            existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside update function only"));
             if (existing) {
                 result = existing.instance;
                 if (result.driver !== driver && driver !== undefined)
@@ -58,17 +63,24 @@ export class RxNode {
                 result.declaration = declaration;
             }
             else {
-                result = new RxNodeImpl(key || generateKey(owner), driver, declaration, owner);
+                result = new RxNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
                 result.seat = children.mergeAsAdded(result);
             }
         }
         else {
-            result = new RxNodeImpl(key || "", driver, declaration, owner);
+            result = new RxNodeImpl(effectiveKey || "", driver, declaration, owner);
             result.seat = MergeList.createItem(result);
             triggerUpdateViaSeat(result.seat);
         }
         return result;
     }
+    static rebased(declaration, basis) {
+        if (declaration)
+            declaration.basis = basis;
+        else
+            declaration = basis !== null && basis !== void 0 ? basis : {};
+        return declaration;
+    }
     static get isFirstUpdate() {
         return RxNodeImpl.ownSeat.instance.stamp === 1;
     }
@@ -354,7 +366,7 @@ 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.305",
+  "version": "0.24.307",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",