reactronic 0.95.25040 → 0.95.25045

package/README.md

@@ -187,8 +187,8 @@ in response to changes in signalling objects made by
 transactional functions. Cached function is called on-demand
 to renew the result if it was marked as obsolete due to
 changes made by an transactional functions. Reactive and cached
-functions are instrumented with hooks to seamlessly
-subscribe to those signalling objects and other cached
+functions are instrumented with hooks to seamless
+listening of those signalling objects and other cached
 functions (dependencies), which are used during their
 execution.
 
@@ -202,7 +202,7 @@ class MyView extends Component<{model: MyModel}> {
         <div>{this.props.model.content}</div>
       </div>
     )
-  } // render is subscribed to "url" and "content"
+  } // render is listening to "url" and "content"
 }
 ```
 
@@ -219,15 +219,15 @@ class Component<P> extends React.Component<P> {
       // Ask React to re-render
       Transaction.outside(() => this.setState({}))
     }
-  } // EnsureUpToDate is subscribed to render
+  } // EnsureUpToDate is listening to render
 
   shouldComponentUpdate(): boolean {
-    const r = ReactiveSystem.getDescriptor(this.render)
+    const r = manageReaction(this.render)
     return !r.isUpToDate
   }
 
   componentDidMount(): void {
-    // Run to subscribe for the first time
+    // Run for the first time to start listening
     this.ensureUpToDate()
   }
 
@@ -237,9 +237,9 @@ class Component<P> extends React.Component<P> {
 }
 ```
 
-In the example above, reactive function `refresh` is
-transparently subscribed to the cached function `render`.
-In turn, cached function `render` is subscribed to the
+In the example above, reactive function `refresh`
+transparently listens to the cached function `render`.
+In turn, cached function `render` listens to the
 properties `url` and `content` of a corresponding `MyModel`
 object. Once `url` or `content` values are changed, the
 cached function `render` becomes obsolete and causes the
@@ -260,7 +260,7 @@ reactive functions) or on-demand (for cached functions).
 Reactronic takes full care of tracking dependencies
 between all the signalling objects and reactive/cached
 functions. With Reactronic, you no longer need to create
-data change events in one set of objects, subscribe to
+data change events in one set of objects, listen to
 these events in other objects, and manually maintain
 switching from the previous object version to a new one.
 
@@ -324,8 +324,8 @@ NPM: `npm install reactronic`
 
 // Classes
 
-class TransactionalObject { }
-class SignallingObject { }
+class TxObject { } // transactional object
+class SxObject { } // signalling object
 
 // Decorators & Operators
 
@@ -447,9 +447,9 @@ class Transaction implements Worker {
   static isCanceled: boolean
 }
 
-// Operation
+// Reaction
 
-abstract class Operation<T> {
+abstract class Reaction<T> {
   readonly options: Options
   readonly args: ReadonlyArray<any>
   readonly value: T
@@ -467,7 +467,7 @@ abstract class Operation<T> {
 class ReactiveSystem {
   static why(short: boolean = false): string
   static getMethodCache<T>(method: F<T>): Cache<T>
-  static configureCurrentOperation(options: Partial<Options>): Options
+  static configureCurrentReaction(options: Partial<Options>): Options
   static getRevisionOf(obj: any): number
   static takeSnapshot<T>(obj: T): T
   static dispose(obj: any): void

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

@@ -31,8 +31,8 @@ export declare class Changeset implements AbstractChangeset {
         isResolved: boolean;
         resolvedValue: any;
     };
-    static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
-    static revokeAllSubscriptions: (changeset: Changeset) => void;
+    static propagateAllChangesToListeners: (changeset: Changeset) => void;
+    static discardAllListeners: (changeset: Changeset) => void;
     static enqueueReactionsToRun: (reactions: Array<OperationFootprint>) => void;
     lookupObjectVersion(h: ObjectHandle, fk: FieldKey, editing: boolean): ObjectVersion;
     getObjectVersion(h: ObjectHandle, fk: FieldKey): ObjectVersion;

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

@@ -316,8 +316,8 @@ Changeset.edit = UNDEF;
 Changeset.markUsed = UNDEF;
 Changeset.markEdited = UNDEF;
 Changeset.tryResolveConflict = UNDEF;
-Changeset.propagateAllChangesThroughSubscriptions = (changeset) => { };
-Changeset.revokeAllSubscriptions = (changeset) => { };
+Changeset.propagateAllChangesToListeners = (changeset) => { };
+Changeset.discardAllListeners = (changeset) => { };
 Changeset.enqueueReactionsToRun = (reactions) => { };
 export class Dump {
     static obj(h, fk, stamp, changesetId, lastEditorChangesetId, value) {

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

@@ -7,21 +7,21 @@ export type AbstractChangeset = {
 };
 export declare class ContentFootprint<T = any> {
     content: T;
-    subscribers?: Set<OperationFootprint>;
+    listeners?: Set<OperationFootprint>;
     lastEditorChangesetId: number;
     get isComputed(): boolean;
     constructor(content: T, lastEditorChangesetId: number);
 }
 export type OperationFootprint = {
     readonly order: number;
-    readonly signals: Map<ContentFootprint, Subscription> | undefined;
+    readonly signals: Map<ContentFootprint, ListeningInfo> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
     markObsoleteDueTo(footprint: ContentFootprint, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, collector: Array<OperationFootprint>): void;
     relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
 };
 export type FieldKey = PropertyKey;
-export type Subscription = {
+export type ListeningInfo = {
     readonly memberHint: string;
     readonly usageCount: number;
 };

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

@@ -100,10 +100,8 @@ export class Mvcc {
         return fk in ov.data || fk in h.data;
     }
     defineProperty(h, name, attributes) {
-        const result = attributes.get !== undefined && attributes.set !== undefined;
-        if (result)
-            Object.defineProperty(h.data, name, attributes);
-        return result;
+        Object.defineProperty(h.data, name, attributes);
+        return true;
     }
     getOwnPropertyDescriptor(h, fk) {
         const ov = Changeset.current().getObjectVersion(h, fk);

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

@@ -1,6 +1,6 @@
 import { F } from "../util/Utils.js";
 import { Reaction, ReactivityOptions } from "../Options.js";
-import { FieldKey, ObjectHandle, ContentFootprint, OperationFootprint, Subscription, AbstractChangeset } from "./Data.js";
+import { FieldKey, ObjectHandle, ContentFootprint, OperationFootprint, ListeningInfo, AbstractChangeset } from "./Data.js";
 import { Transaction } from "./Transaction.js";
 import { OptionsImpl } from "./Mvcc.js";
 export declare class ReactionImpl implements Reaction<any> {
@@ -39,7 +39,7 @@ declare class OperationFootprintImpl extends ContentFootprint implements Operati
     readonly transaction: Transaction;
     readonly descriptor: ReactionImpl;
     readonly changeset: AbstractChangeset;
-    signals: Map<ContentFootprint, Subscription> | undefined;
+    signals: Map<ContentFootprint, ListeningInfo> | undefined;
     options: OptionsImpl;
     cause: string | undefined;
     args: any[];
@@ -75,15 +75,15 @@ declare class OperationFootprintImpl extends ContentFootprint implements Operati
     private static markUsed;
     private static markEdited;
     private static tryResolveConflict;
-    private static propagateAllChangesThroughSubscriptions;
-    private static revokeAllSubscriptions;
-    private static propagateFieldChangeThroughSubscriptions;
+    private static propagateAllChangesToListeners;
+    private static discardAllListeners;
+    private static propagateFieldChangeToListeners;
     private static enqueueReactionsToRun;
     private static migrateContentFootprint;
     private static processQueuedReactions;
-    private unsubscribeFromAllSignals;
-    private subscribeTo;
-    private static canSubscribeTo;
+    private stopListeningAllSignals;
+    private listenTo;
+    private static canListenTo;
     private static createOperationDescriptor;
     private static rememberOperationOptions;
     static init(): void;

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

@@ -301,11 +301,11 @@ class OperationFootprintImpl extends ContentFootprint {
                     Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", isReactive ? "█" : "▒", isReactive && changeset === EMPTY_OBJECT_VERSION.changeset
                         ? `${this.hint()} is reactive and will run automatically (order ${this.options.order})`
                         : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, fk)} since s${since}${isReactive ? ` and will run automatically (order ${this.options.order})` : ""}`);
-                this.unsubscribeFromAllSignals();
+                this.stopListeningAllSignals();
                 if (isReactive)
                     collector.push(this);
                 else
-                    (_b = this.subscribers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.descriptor.fieldKey, this.changeset, this.descriptor.ownerHandle, why, since, collector));
+                    (_b = this.listeners) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.descriptor.fieldKey, this.changeset, this.descriptor.ownerHandle, why, since, collector));
                 const tran = this.transaction;
                 if (tran.changeset === changeset) {
                 }
@@ -470,15 +470,15 @@ class OperationFootprintImpl extends ContentFootprint {
     }
     static markUsed(footprint, ov, fk, h, kind, weak) {
         if (kind !== Kind.transaction) {
-            const subscriber = OperationFootprintImpl.current;
-            if (subscriber && subscriber.options.kind !== Kind.transaction &&
-                subscriber.transaction === Transaction.current && fk !== Meta.Handle) {
+            const listener = OperationFootprintImpl.current;
+            if (listener && listener.options.kind !== Kind.transaction &&
+                listener.transaction === Transaction.current && fk !== Meta.Handle) {
                 const ctx = Changeset.current();
                 if (ctx !== ov.changeset)
                     ctx.bumpBy(ov.changeset.timestamp);
                 const t = weak ? -1 : ctx.timestamp;
-                if (!subscriber.subscribeTo(footprint, ov, fk, h, t))
-                    subscriber.markObsoleteDueTo(footprint, fk, h.applied.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
+                if (!listener.listenTo(footprint, ov, fk, h, t))
+                    listener.markObsoleteDueTo(footprint, fk, h.applied.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
             }
         }
     }
@@ -502,28 +502,28 @@ class OperationFootprintImpl extends ContentFootprint {
         }
         return { isResolved, resolvedValue };
     }
-    static propagateAllChangesThroughSubscriptions(changeset) {
+    static propagateAllChangesToListeners(changeset) {
         var _a;
         const since = changeset.timestamp;
         const obsolete = changeset.obsolete;
         changeset.items.forEach((ov, h) => {
-            OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(false, since, ov, Meta.Revision, h, obsolete);
+            OperationFootprintImpl.propagateFieldChangeToListeners(false, since, ov, Meta.Revision, h, obsolete);
             if (!ov.disposed)
-                ov.changes.forEach((o, fk) => OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(false, since, ov, fk, h, obsolete));
+                ov.changes.forEach((o, fk) => OperationFootprintImpl.propagateFieldChangeToListeners(false, since, ov, fk, h, obsolete));
             else
                 for (const fk in ov.former.objectVersion.data)
-                    OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(true, since, ov, fk, h, obsolete);
+                    OperationFootprintImpl.propagateFieldChangeToListeners(true, since, ov, fk, h, obsolete);
         });
         obsolete.sort(compareReactionsByOrder);
         (_a = changeset.options.journal) === null || _a === void 0 ? void 0 : _a.edited(JournalImpl.buildPatch(changeset.hint, changeset.items));
     }
-    static revokeAllSubscriptions(changeset) {
+    static discardAllListeners(changeset) {
         changeset.items.forEach((ov, h) => {
-            OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(true, changeset.timestamp, ov, Meta.Revision, h, undefined);
-            ov.changes.forEach((o, fk) => OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(true, changeset.timestamp, ov, fk, h, undefined));
+            OperationFootprintImpl.propagateFieldChangeToListeners(true, changeset.timestamp, ov, Meta.Revision, h, undefined);
+            ov.changes.forEach((o, fk) => OperationFootprintImpl.propagateFieldChangeToListeners(true, changeset.timestamp, ov, fk, h, undefined));
         });
     }
-    static propagateFieldChangeThroughSubscriptions(unsubscribe, timestamp, ov, fk, h, collector) {
+    static propagateFieldChangeToListeners(stopListening, timestamp, ov, fk, h, collector) {
         var _a;
         const curr = ov.data[fk];
         if (collector !== undefined) {
@@ -534,7 +534,7 @@ class OperationFootprintImpl extends ContentFootprint {
                     if ((former.obsoleteSince === MAX_REVISION || former.obsoleteSince <= 0)) {
                         former.obsoleteDueTo = why;
                         former.obsoleteSince = timestamp;
-                        former.unsubscribeFromAllSignals();
+                        former.stopListeningAllSignals();
                     }
                     const formerSuccessor = former.successor;
                     if (formerSuccessor !== curr) {
@@ -544,7 +544,7 @@ class OperationFootprintImpl extends ContentFootprint {
                     else
                         former.successor = undefined;
                 }
-                (_a = former.subscribers) === null || _a === void 0 ? void 0 : _a.forEach(s => {
+                (_a = former.listeners) === null || _a === void 0 ? void 0 : _a.forEach(s => {
                     const t = s.transaction;
                     const o = t.isFinished ? collector : t.changeset.obsolete;
                     return s.markObsoleteDueTo(former, fk, ov.changeset, h, why, timestamp, o);
@@ -559,11 +559,11 @@ class OperationFootprintImpl extends ContentFootprint {
                             Log.write("", "[!]", `${curr.hint()} uses ${info.memberHint} ${info.usageCount} times (consider remembering it in a local variable)`, 0, " *** WARNING ***");
                     });
                 }
-                if (unsubscribe)
-                    curr.unsubscribeFromAllSignals();
+                if (stopListening)
+                    curr.stopListeningAllSignals();
             }
         }
-        else if (curr instanceof ContentFootprint && curr.subscribers) {
+        else if (curr instanceof ContentFootprint && curr.listeners) {
         }
     }
     static enqueueReactionsToRun(reactions) {
@@ -592,20 +592,20 @@ class OperationFootprintImpl extends ContentFootprint {
         }
         OperationFootprintImpl.queuedReactions = [];
     }
-    unsubscribeFromAllSignals() {
+    stopListeningAllSignals() {
         var _a;
         (_a = this.signals) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
             var _a;
-            value.subscribers.delete(this);
+            value.listeners.delete(this);
             if (Log.isOn && (Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
-                Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", "-", `${this.hint()} is unsubscribed from ${info.memberHint}`);
+                Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", "-", `${this.hint()} is no longer listening to ${info.memberHint}`);
         });
         this.signals = undefined;
     }
-    subscribeTo(footprint, ov, fk, h, timestamp) {
+    listenTo(footprint, ov, fk, h, timestamp) {
         var _a, _b, _c;
         const parent = this.transaction.changeset.parent;
-        const ok = OperationFootprintImpl.canSubscribeTo(footprint, ov, parent, fk, h, timestamp);
+        const ok = OperationFootprintImpl.canListenTo(footprint, ov, parent, fk, h, timestamp);
         if (ok) {
             let times = 0;
             if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
@@ -613,24 +613,24 @@ class OperationFootprintImpl extends ContentFootprint {
                 times = existing ? existing.usageCount + 1 : 1;
             }
             if (this.signals !== undefined) {
-                if (!footprint.subscribers)
-                    footprint.subscribers = new Set();
-                const subscription = { memberHint: Dump.snapshot2(h, ov.changeset, fk), usageCount: times };
-                footprint.subscribers.add(this);
-                this.signals.set(footprint, subscription);
+                if (!footprint.listeners)
+                    footprint.listeners = new Set();
+                const listening = { memberHint: Dump.snapshot2(h, ov.changeset, fk), usageCount: times };
+                footprint.listeners.add(this);
+                this.signals.set(footprint, listening);
                 if (Log.isOn && (Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
-                    Log.write("║", "  ∞", `${this.hint()} is subscribed to ${Dump.snapshot2(h, ov.changeset, fk, footprint)}${subscription.usageCount > 1 ? ` (${subscription.usageCount} times)` : ""}`);
+                    Log.write("║", "  ∞", `${this.hint()} now listens to ${Dump.snapshot2(h, ov.changeset, fk, footprint)}${listening.usageCount > 1 ? ` (${listening.usageCount} times)` : ""}`);
             }
             else if (Log.isOn && (Log.opt.read || ((_b = this.options.logging) === null || _b === void 0 ? void 0 : _b.read)))
-                Log.write("║", "  x", `${this.hint()} is obsolete and is NOT subscribed to ${Dump.snapshot2(h, ov.changeset, fk, footprint)}`);
+                Log.write("║", "  x", `${this.hint()} is obsolete and is not listening to ${Dump.snapshot2(h, ov.changeset, fk, footprint)}`);
         }
         else {
             if (Log.isOn && (Log.opt.read || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.read)))
-                Log.write("║", "  x", `${this.hint()} is NOT subscribed to already obsolete ${Dump.snapshot2(h, ov.changeset, fk, footprint)}`);
+                Log.write("║", "  x", `${this.hint()} is not listening to already obsolete ${Dump.snapshot2(h, ov.changeset, fk, footprint)}`);
         }
         return ok;
     }
-    static canSubscribeTo(footprint, ov, parent, fk, h, timestamp) {
+    static canListenTo(footprint, ov, parent, fk, h, timestamp) {
         const parentSnapshot = parent ? parent.lookupObjectVersion(h, fk, false) : h.applied;
         const parentFootprint = parentSnapshot.data[fk];
         let result = footprint === parentFootprint || (!ov.changeset.sealed && ov.former.objectVersion.data[fk] === parentFootprint);
@@ -669,8 +669,8 @@ class OperationFootprintImpl extends ContentFootprint {
         Changeset.markUsed = OperationFootprintImpl.markUsed;
         Changeset.markEdited = OperationFootprintImpl.markEdited;
         Changeset.tryResolveConflict = OperationFootprintImpl.tryResolveConflict;
-        Changeset.propagateAllChangesThroughSubscriptions = OperationFootprintImpl.propagateAllChangesThroughSubscriptions;
-        Changeset.revokeAllSubscriptions = OperationFootprintImpl.revokeAllSubscriptions;
+        Changeset.propagateAllChangesToListeners = OperationFootprintImpl.propagateAllChangesToListeners;
+        Changeset.discardAllListeners = OperationFootprintImpl.discardAllListeners;
         Changeset.enqueueReactionsToRun = OperationFootprintImpl.enqueueReactionsToRun;
         TransactionImpl.migrateContentFootprint = OperationFootprintImpl.migrateContentFootprint;
         Mvcc.createOperationDescriptor = OperationFootprintImpl.createOperationDescriptor;

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

@@ -258,7 +258,7 @@ export class TransactionImpl extends Transaction {
                 if (after && after !== TransactionImpl.none)
                     Log.write("║", " [!]", `T${t.id}[${t.hint}] will be restarted${t !== after ? ` after T${after.id}[${after.hint}]` : ""}`);
             }
-            Changeset.revokeAllSubscriptions(t.changeset);
+            Changeset.discardAllListeners(t.changeset);
         }
         t.sealed = true;
     }
@@ -328,7 +328,7 @@ export class TransactionImpl extends Transaction {
             }
         }
         else if (!error)
-            Changeset.propagateAllChangesThroughSubscriptions(changeset);
+            Changeset.propagateAllChangesToListeners(changeset);
         return obsolete;
     }
     applyObjectChanges(h, ov) {
@@ -359,39 +359,39 @@ export class TransactionImpl extends Transaction {
         if (cf.isComputed) {
             const migrated = TransactionImpl.migrateContentFootprint(cf, tParent);
             if (ovParent.former.objectVersion.data[fk] !== cfParent) {
-                let subscribers = cfParent.subscribers;
-                if (subscribers) {
-                    const migratedSubscribers = migrated.subscribers = new Set();
-                    subscribers.forEach(o => {
+                let listeners = cfParent.listeners;
+                if (listeners) {
+                    const migratedListeners = migrated.listeners = new Set();
+                    listeners.forEach(o => {
                         const conformingSignals = o.signals;
                         const sub = conformingSignals.get(cfParent);
                         conformingSignals.delete(cfParent);
                         conformingSignals.set(migrated, sub);
-                        migratedSubscribers.add(o);
+                        migratedListeners.add(o);
                     });
-                    cfParent.subscribers = undefined;
+                    cfParent.listeners = undefined;
                 }
-                subscribers = cf.subscribers;
-                if (subscribers) {
-                    let migratedSubscribers = migrated.subscribers;
-                    if (migratedSubscribers === undefined)
-                        migratedSubscribers = migrated.subscribers = new Set();
-                    subscribers.forEach(o => {
+                listeners = cf.listeners;
+                if (listeners) {
+                    let migratedListeners = migrated.listeners;
+                    if (migratedListeners === undefined)
+                        migratedListeners = migrated.listeners = new Set();
+                    listeners.forEach(o => {
                         const conformingSignals = o.signals;
                         const sub = conformingSignals.get(cf);
                         conformingSignals.delete(cf);
                         conformingSignals.set(migrated, sub);
-                        migratedSubscribers.add(o);
+                        migratedListeners.add(o);
                     });
-                    cf.subscribers = undefined;
+                    cf.listeners = undefined;
                 }
                 const signals = cf.signals;
                 const migratedSignals = migrated.signals;
                 if (signals) {
                     signals.forEach((s, o) => {
-                        const conformingSubscribers = o.subscribers;
-                        conformingSubscribers.delete(cf);
-                        conformingSubscribers.add(migrated);
+                        const conformingListeners = o.listeners;
+                        conformingListeners.delete(cf);
+                        conformingListeners.add(migrated);
                         migratedSignals.set(o, s);
                     });
                     signals.clear();
@@ -399,25 +399,25 @@ export class TransactionImpl extends Transaction {
                 ovParent.data[fk] = migrated;
             }
             else {
-                const subscribers = cf.subscribers;
-                if (subscribers) {
-                    const migratedReactions = migrated.subscribers = new Set();
-                    subscribers.forEach(o => {
+                const listeners = cf.listeners;
+                if (listeners) {
+                    const migratedReactions = migrated.listeners = new Set();
+                    listeners.forEach(o => {
                         const conformingSignals = o.signals;
                         const sub = conformingSignals.get(cf);
                         conformingSignals.delete(cf);
                         conformingSignals.set(migrated, sub);
                         migratedReactions.add(o);
                     });
-                    cf.subscribers = undefined;
+                    cf.listeners = undefined;
                 }
                 const signals = cf.signals;
                 const migratedSignals = migrated.signals;
                 if (signals) {
                     signals.forEach((s, o) => {
-                        const conformingSubscribers = o.subscribers;
-                        conformingSubscribers.delete(cf);
-                        conformingSubscribers.add(migrated);
+                        const conformingListeners = o.listeners;
+                        conformingListeners.delete(cf);
+                        conformingListeners.add(migrated);
                         migratedSignals.set(o, s);
                     });
                     signals.clear();
@@ -431,16 +431,16 @@ export class TransactionImpl extends Transaction {
             const parentContent = cfParent === null || cfParent === void 0 ? void 0 : cfParent.content;
             if (ovParent.former.objectVersion.data[fk] !== cfParent) {
                 cfParent.content = cf.content;
-                const subscribers = cf.subscribers;
-                if (subscribers) {
-                    if (cfParent.subscribers === undefined)
-                        cfParent.subscribers = new Set();
-                    subscribers.forEach(o => {
+                const listeners = cf.listeners;
+                if (listeners) {
+                    if (cfParent.listeners === undefined)
+                        cfParent.listeners = new Set();
+                    listeners.forEach(o => {
                         const conformingSignals = o.signals;
                         const sub = conformingSignals.get(cf);
                         conformingSignals.delete(cf);
                         conformingSignals.set(cfParent, sub);
-                        cfParent.subscribers.add(o);
+                        cfParent.listeners.add(o);
                     });
                 }
             }

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

@@ -23,7 +23,7 @@ import { emitLetters, flags, getCallerInfo, proceedSyncOrAsync } from "../util/U
 import { Priority, Mode, Isolation, Reentrance } from "../Enums.js";
 import { SxObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
-import { ReactiveSystem, options, signal, reaction, runTransactional, runNonReactive, manageReaction, disposeSignallingObject as disposeSignallingObject } from "../System.js";
+import { ReactiveSystem, options, signal, reaction, runTransactional, runNonReactive, manageReaction, disposeSignallingObject } from "../System.js";
 export function declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
     let result;
     let declaration;

package/build/dist/source/util/LinkedList.d.ts

@@ -5,7 +5,7 @@ export declare class LinkedList<T extends LinkedItem<T>> {
     private isStrictOrder$;
     private map;
     items$: LinkedSubList<T>;
-    former$: LinkedSubList<T> | undefined;
+    private renovation;
     constructor(keyExtractor: KeyExtractor<T>, isStrictOrder?: boolean);
     get isStrictOrder(): boolean;
     set isStrictOrder(value: boolean);
@@ -16,6 +16,8 @@ export declare class LinkedList<T extends LinkedItem<T>> {
     add(item: T, before?: T): void;
     move(item: T, before: T | undefined): void;
     remove(item: T): void;
+    beginRenovation(diff?: Array<T>): LinkedListRenovation<T>;
+    endRenovation(error?: unknown): void;
     static move$<T extends LinkedItem<T>>(list: LinkedList<T>, item: T, before: T | undefined): void;
     static remove$<T extends LinkedItem<T>>(list: LinkedList<T>, item: T): void;
     static removeKey$<T extends LinkedItem<T>>(list: LinkedList<T>, key: string | undefined): void;
@@ -50,3 +52,21 @@ export declare class LinkedSubList<T extends LinkedItem<T>> {
     clear(): void;
     grab(from: LinkedSubList<T>, join: boolean): void;
 }
+export declare class LinkedListRenovation<T extends LinkedItem<T>> {
+    readonly list: LinkedList<T>;
+    readonly diff: Array<T> | undefined;
+    private former;
+    private expected;
+    private absent;
+    constructor(list: LinkedList<T>, former: LinkedSubList<T>, diff?: Array<T>);
+    lookup(key: string | undefined): T | undefined;
+    tryToProlong(key: string, resolution?: {
+        isDuplicate: boolean;
+    }, error?: string): T | undefined;
+    thisIsAdded(item: T, before?: T): T;
+    thisIsModified(item: T): void;
+    thisIsMoved(item: T, before: T | undefined): void;
+    thisIsRemoved(item: T): void;
+    get lostItemCount(): number;
+    lostItems(): Generator<T>;
+}

package/build/dist/source/util/LinkedList.js

@@ -5,20 +5,20 @@ export class LinkedList {
         this.isStrictOrder$ = isStrictOrder;
         this.map = new Map();
         this.items$ = new LinkedSubList();
-        this.former$ = undefined;
+        this.renovation = undefined;
     }
     get isStrictOrder() { return this.isStrictOrder$; }
     set isStrictOrder(value) {
-        if (this.former$ !== undefined)
+        if (this.renovation !== undefined)
             throw misuse("cannot change strict mode in the middle of renovation");
         this.isStrictOrder$ = value;
     }
     get isRenovationInProgress() {
-        return this.former$ !== undefined;
+        return this.renovation !== undefined;
     }
     get count() {
         var _a, _b;
-        return this.items$.count + ((_b = (_a = this.former$) === null || _a === void 0 ? void 0 : _a.count) !== null && _b !== void 0 ? _b : 0);
+        return this.items$.count + ((_b = (_a = this.renovation) === null || _a === void 0 ? void 0 : _a.lostItemCount) !== null && _b !== void 0 ? _b : 0);
     }
     items() {
         return this.items$.items();
@@ -47,6 +47,38 @@ export class LinkedList {
             throw misuse("cannot remove given item outside of renovation cycle");
         LinkedList.remove$(this, item);
     }
+    beginRenovation(diff) {
+        if (this.renovation !== undefined)
+            throw misuse("renovation is in progress already");
+        const former = this.items$;
+        const renovation = new LinkedListRenovation(this, former, diff);
+        this.items$ = new LinkedSubList();
+        this.renovation = renovation;
+        return renovation;
+    }
+    endRenovation(error) {
+        const renovation = this.renovation;
+        if (renovation === undefined)
+            throw misuse("renovation is ended already");
+        const items = this.items$;
+        if (error === undefined) {
+            for (const x of renovation.lostItems()) {
+                if (!x.isManagedExternally) {
+                    LinkedList.removeKey$(this, this.keyOf(x));
+                    LinkedItem.setStatus$(x, Mark.removed, 0);
+                }
+                else
+                    LinkedItem.link$(items, x, undefined);
+            }
+        }
+        else {
+            for (const x of renovation.lostItems()) {
+                LinkedItem.link$(items, x, undefined);
+                LinkedItem.setStatus$(x, Mark.prolonged, items.count);
+            }
+        }
+        this.renovation = undefined;
+    }
     static move$(list, item, before) {
         LinkedItem.link$(list.items$, item, before);
     }
@@ -175,3 +207,106 @@ export class LinkedSubList {
         from.clear();
     }
 }
+export class LinkedListRenovation {
+    constructor(list, former, diff) {
+        this.list = list;
+        this.diff = diff;
+        this.former = former;
+        this.expected = former.first;
+        this.absent = undefined;
+    }
+    lookup(key) {
+        let result = undefined;
+        if (key !== undefined && key !== this.absent) {
+            result = this.list.lookup(key);
+            if (result !== undefined) {
+                if (this.list.keyOf(result) !== key) {
+                    this.absent = key;
+                    result = undefined;
+                }
+            }
+            else
+                this.absent = key;
+        }
+        return result;
+    }
+    tryToProlong(key, resolution, error) {
+        var _a, _b;
+        const list = this.list;
+        if (!list.isRenovationInProgress)
+            throw misuse(error !== null && error !== void 0 ? error : "renovation is no longer in progress");
+        let x = this.expected;
+        if (key !== (x ? list.keyOf(x) : undefined))
+            x = this.lookup(key);
+        if (x !== undefined) {
+            const result = this.list.items$;
+            if (x.list !== result) {
+                const next = x.next;
+                const expected = (_a = grabExternalIfAny(result, x)) !== null && _a !== void 0 ? _a : x;
+                LinkedItem.link$(result, x, undefined);
+                if (list.isStrictOrder && expected !== this.expected) {
+                    LinkedItem.setStatus$(x, Mark.modified, result.count);
+                    (_b = this.diff) === null || _b === void 0 ? void 0 : _b.push(x);
+                }
+                else
+                    LinkedItem.setStatus$(x, Mark.prolonged, result.count);
+                this.expected = next;
+                if (resolution)
+                    resolution.isDuplicate = false;
+            }
+            else if (resolution)
+                resolution.isDuplicate = true;
+            else
+                throw misuse(`duplicate linked item key: ${key}`);
+        }
+        else if (resolution)
+            resolution.isDuplicate = false;
+        return x;
+    }
+    thisIsAdded(item, before) {
+        var _a;
+        this.list.add(item, before);
+        LinkedItem.setStatus$(item, Mark.added, this.list.items$.count);
+        this.absent = undefined;
+        this.expected = undefined;
+        (_a = this.diff) === null || _a === void 0 ? void 0 : _a.push(item);
+        return item;
+    }
+    thisIsModified(item) {
+        if (item.list !== this.list.items$)
+            throw misuse("only prolonged items can be marked as modified");
+        const m = item.mark;
+        if (m === Mark.prolonged)
+            LinkedItem.setStatus$(item, Mark.modified, item.rank);
+        else if (m !== Mark.modified)
+            throw misuse("item is renovated already and cannot be marked as modified");
+    }
+    thisIsMoved(item, before) {
+        var _a;
+        if (item.list !== this.former)
+            throw misuse("cannot move item which doesn't belong to former list");
+        LinkedList.move$(this.list, item, before);
+        LinkedItem.setStatus$(item, Mark.modified, 0);
+        (_a = this.diff) === null || _a === void 0 ? void 0 : _a.push(item);
+    }
+    thisIsRemoved(item) {
+        var _a;
+        if (item.list !== this.former)
+            throw misuse("cannot remove item which doesn't belong to former list");
+        LinkedList.remove$(this.list, item);
+        LinkedItem.setStatus$(item, Mark.removed, 0);
+        (_a = this.diff) === null || _a === void 0 ? void 0 : _a.push(item);
+    }
+    get lostItemCount() { return this.former.count; }
+    lostItems() { return this.former.items(); }
+}
+function grabExternalIfAny(list, item) {
+    let x = item.prev;
+    let before = undefined;
+    while (x !== undefined && x.isManagedExternally) {
+        LinkedItem.link$(list, x, before);
+        before = x;
+        x = x.prev;
+    }
+    return before;
+}

package/package.json

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

package/build/dist/source/util/LinkedListRenovation.d.ts

@@ -1,20 +0,0 @@
-import { LinkedList, LinkedItem } from "./LinkedList.js";
-export declare class LinkedListRenovation<T extends LinkedItem<T>> {
-    readonly list: LinkedList<T>;
-    readonly diff: Array<T> | undefined;
-    private lost$;
-    private expected;
-    private absent;
-    constructor(list: LinkedList<T>, diff?: Array<T>);
-    lookup(key: string | undefined): T | undefined;
-    tryToProlonge(key: string, resolution?: {
-        isDuplicate: boolean;
-    }, error?: string): T | undefined;
-    thisIsAdded(item: T, before?: T): T;
-    thisIsModified(item: T): void;
-    thisIsMoved(item: T, before: T | undefined): void;
-    thisIsRemoved(item: T): void;
-    get lostItemCount(): number;
-    lostItems(): Generator<T>;
-    done(error?: unknown): void;
-}

package/build/dist/source/util/LinkedListRenovation.js

@@ -1,134 +0,0 @@
-import { misuse } from "./Dbg.js";
-import { LinkedList, LinkedItem, LinkedSubList, Mark } from "./LinkedList.js";
-export class LinkedListRenovation {
-    constructor(list, diff) {
-        if (list.former$ !== undefined)
-            throw misuse("renovation is in progress already");
-        const former = list.items$;
-        this.list = list;
-        this.diff = diff;
-        this.lost$ = former;
-        this.expected = former.first;
-        this.absent = undefined;
-        list.former$ = former;
-        list.items$ = new LinkedSubList();
-    }
-    lookup(key) {
-        let result = undefined;
-        if (key !== undefined && key !== this.absent) {
-            result = this.list.lookup(key);
-            if (result !== undefined) {
-                if (this.list.keyOf(result) !== key) {
-                    this.absent = key;
-                    result = undefined;
-                }
-            }
-            else
-                this.absent = key;
-        }
-        return result;
-    }
-    tryToProlonge(key, resolution, error) {
-        var _a, _b;
-        const list = this.list;
-        if (!list.isRenovationInProgress)
-            throw misuse(error !== null && error !== void 0 ? error : "renovation is no longer in progress");
-        let x = this.expected;
-        if (key !== (x ? list.keyOf(x) : undefined))
-            x = this.lookup(key);
-        if (x !== undefined) {
-            const result = this.list.items$;
-            if (x.list !== result) {
-                const next = x.next;
-                const expected = (_a = grabExternalIfAny(result, x)) !== null && _a !== void 0 ? _a : x;
-                LinkedItem.link$(result, x, undefined);
-                if (list.isStrictOrder && expected !== this.expected) {
-                    LinkedItem.setStatus$(x, Mark.modified, result.count);
-                    (_b = this.diff) === null || _b === void 0 ? void 0 : _b.push(x);
-                }
-                else
-                    LinkedItem.setStatus$(x, Mark.prolonged, result.count);
-                this.expected = next;
-                if (resolution)
-                    resolution.isDuplicate = false;
-            }
-            else if (resolution)
-                resolution.isDuplicate = true;
-            else
-                throw misuse(`duplicate linked item key: ${key}`);
-        }
-        else if (resolution)
-            resolution.isDuplicate = false;
-        return x;
-    }
-    thisIsAdded(item, before) {
-        var _a;
-        this.list.add(item, before);
-        LinkedItem.setStatus$(item, Mark.added, this.list.items$.count);
-        this.absent = undefined;
-        this.expected = undefined;
-        (_a = this.diff) === null || _a === void 0 ? void 0 : _a.push(item);
-        return item;
-    }
-    thisIsModified(item) {
-        if (item.list !== this.list.items$)
-            throw misuse("only prolonged items can be marked as modified");
-        const m = item.mark;
-        if (m === Mark.prolonged)
-            LinkedItem.setStatus$(item, Mark.modified, item.rank);
-        else if (m !== Mark.modified)
-            throw misuse("item is renovated already and cannot be marked as modified");
-    }
-    thisIsMoved(item, before) {
-        var _a;
-        if (item.list !== this.list.former$)
-            throw misuse("cannot move item which doesn't belong to former list");
-        LinkedList.move$(this.list, item, before);
-        LinkedItem.setStatus$(item, Mark.modified, 0);
-        (_a = this.diff) === null || _a === void 0 ? void 0 : _a.push(item);
-    }
-    thisIsRemoved(item) {
-        var _a;
-        if (item.list !== this.list.former$)
-            throw misuse("cannot remove item which doesn't belong to former list");
-        LinkedList.remove$(this.list, item);
-        LinkedItem.setStatus$(item, Mark.removed, 0);
-        (_a = this.diff) === null || _a === void 0 ? void 0 : _a.push(item);
-    }
-    get lostItemCount() { return this.lost$.count; }
-    lostItems() { return this.lost$.items(); }
-    done(error) {
-        const list = this.list;
-        if (!list.isRenovationInProgress)
-            throw misuse("renovation is ended already");
-        const items = this.list.items$;
-        const lost = this.lost$;
-        if (error === undefined) {
-            for (const x of lost.items()) {
-                if (!x.isManagedExternally) {
-                    LinkedList.removeKey$(list, list.keyOf(x));
-                    LinkedItem.setStatus$(x, Mark.removed, 0);
-                }
-                else
-                    LinkedItem.link$(items, x, undefined);
-            }
-        }
-        else {
-            for (const x of lost.items()) {
-                LinkedItem.link$(items, x, undefined);
-                LinkedItem.setStatus$(x, Mark.prolonged, items.count);
-            }
-        }
-        list.former$ = undefined;
-    }
-}
-function grabExternalIfAny(list, item) {
-    let x = item.prev;
-    let before = undefined;
-    while (x !== undefined && x.isManagedExternally) {
-        LinkedItem.link$(list, x, before);
-        before = x;
-        x = x.prev;
-    }
-    return before;
-}