reactronic 0.93.25021 → 0.93.25025

package/build/dist/source/ReactiveLoop.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { TriggeringObject } from "./core/Mvcc.js";
-import { reactive } from "./ReactiveSystem.js";
+import { reaction } from "./ReactiveSystem.js";
 export class ReactiveLoop extends TriggeringObject {
     constructor(reactiveFunction) {
         super();
@@ -19,7 +19,7 @@ export class ReactiveLoop extends TriggeringObject {
     }
 }
 __decorate([
-    reactive,
+    reaction,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)

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

@@ -24,7 +24,7 @@ export declare function sensitiveRun<T>(sensitivity: boolean, func: F<T>, ...arg
 export declare function contextualRun<T>(p: Promise<T>): Promise<T>;
 export declare function trigger(enabled: boolean): (proto: object, prop: PropertyKey) => any;
 export declare function trigger<T>(proto: object, prop: PropertyKey): any;
-export declare function atomic(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
-export declare function reactive(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
-export declare function cached(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function atomicBlock(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function reaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function cache(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function options(value: Partial<MemberOptions>): F<any>;

package/build/dist/source/ReactiveSystem.js

@@ -54,28 +54,28 @@ export function trigger(protoOrEnabled, prop) {
     else
         return Mvcc.decorateData(true, protoOrEnabled, prop);
 }
-export function atomic(proto, prop, pd) {
+export function atomicBlock(proto, prop, pd) {
     const opts = {
         kind: Kind.atomic,
         isolation: Isolation.joinToCurrentTransaction,
     };
-    return Mvcc.decorateOperation(true, atomic, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, atomicBlock, opts, proto, prop, pd);
 }
-export function reactive(proto, prop, pd) {
+export function reaction(proto, prop, pd) {
     const opts = {
         kind: Kind.reactive,
         isolation: Isolation.joinAsNestedTransaction,
         throttling: -1,
     };
-    return Mvcc.decorateOperation(true, reactive, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
 }
-export function cached(proto, prop, pd) {
+export function cache(proto, prop, pd) {
     const opts = {
         kind: Kind.cached,
         isolation: Isolation.joinToCurrentTransaction,
         noSideEffects: true,
     };
-    return Mvcc.decorateOperation(true, cached, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, cache, opts, proto, prop, pd);
 }
 export function options(value) {
     return Mvcc.decorateOperationParametrized(options, value);

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

@@ -17,7 +17,7 @@ export { Transaction } from "./core/Transaction.js";
 export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
 export { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./ReactiveSystem.js";
-export { ReactiveSystem, trigger, atomic, reactive, cached, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, trigger, atomicBlock, reaction, cache, options } from "./ReactiveSystem.js";
 export { ReactiveLoop } from "./ReactiveLoop.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export type { Script, ScriptAsync, Handler, ReactiveNodeDecl, ReactiveNodeDriver, ReactiveNodeContext } from "./core/ReactiveNode.js";

package/build/dist/source/api.js

@@ -13,6 +13,6 @@ export { Transaction } from "./core/Transaction.js";
 export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
 export { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./ReactiveSystem.js";
-export { ReactiveSystem, trigger, atomic, reactive, cached, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, trigger, atomicBlock, reaction, cache, options } from "./ReactiveSystem.js";
 export { ReactiveLoop } from "./ReactiveLoop.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";

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

@@ -1,5 +1,5 @@
 import { Kind, SnapshotOptions } from "../Options.js";
-import { AbstractChangeset, ObjectVersion, FieldKey, ObjectHandle, FieldVersion, Observer } from "./Data.js";
+import { AbstractChangeset, ObjectVersion, FieldKey, ObjectHandle, FieldVersion, Reaction } from "./Data.js";
 export declare const MAX_REVISION: number;
 export declare const UNDEFINED_REVISION: number;
 export declare class Changeset implements AbstractChangeset {
@@ -19,7 +19,7 @@ export declare class Changeset implements AbstractChangeset {
     private revision;
     private bumper;
     items: Map<ObjectHandle, ObjectVersion>;
-    obsolete: Observer[];
+    obsolete: Reaction[];
     sealed: boolean;
     constructor(options: SnapshotOptions | null, parent?: Changeset);
     static current: () => Changeset;
@@ -32,7 +32,7 @@ export declare class Changeset implements AbstractChangeset {
     };
     static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
     static revokeAllSubscriptions: (changeset: Changeset) => void;
-    static enqueueReactiveFunctionsToRun: (reactive: Array<Observer>) => void;
+    static enqueueReactionsToRun: (reactions: Array<Reaction>) => void;
     lookupObjectVersion(h: ObjectHandle, fk: FieldKey, editing: boolean): ObjectVersion;
     getObjectVersion(h: ObjectHandle, fk: FieldKey): ObjectVersion;
     getEditableObjectVersion(h: ObjectHandle, fk: FieldKey, value: any, token?: any): ObjectVersion;

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

@@ -318,7 +318,7 @@ Changeset.markEdited = UNDEF;
 Changeset.tryResolveConflict = UNDEF;
 Changeset.propagateAllChangesThroughSubscriptions = (changeset) => { };
 Changeset.revokeAllSubscriptions = (changeset) => { };
-Changeset.enqueueReactiveFunctionsToRun = (reactive) => { };
+Changeset.enqueueReactionsToRun = (reactions) => { };
 export class Dump {
     static obj(h, fk, stamp, changesetId, lastEditorChangesetId, value) {
         const member = fk !== undefined ? `.${fk.toString()}` : "";

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

@@ -7,17 +7,17 @@ export type AbstractChangeset = {
 };
 export declare class FieldVersion<T = any> {
     content: T;
-    observers?: Set<Observer>;
+    reactions?: Set<Reaction>;
     lastEditorChangesetId: number;
     get isLaunch(): boolean;
     constructor(content: T, lastEditorChangesetId: number);
 }
-export type Observer = {
+export type Reaction = {
     readonly order: number;
     readonly triggers: Map<FieldVersion, Subscription> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(trigger: FieldVersion, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Observer>): void;
+    markObsoleteDueTo(trigger: FieldVersion, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, collector: Array<Reaction>): void;
     relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
 };
 export type FieldKey = PropertyKey;

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

@@ -23,12 +23,12 @@ export declare class MvccArray<T> extends MvccObject {
     includes(searchElement: T, fromIndex?: number): boolean;
     indexOf(searchElement: T, fromIndex?: number): number;
     lastIndexOf(searchElement: T, fromIndex?: number): number;
-    every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    every(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
     every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[];
-    some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    some(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
     forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
     map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
-    filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
+    filter(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
     filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
     reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
     reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
@@ -36,9 +36,9 @@ export declare class MvccArray<T> extends MvccObject {
     reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
     reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
     reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
-    find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
+    find(predicate: (value: T, index: number, obj: T[]) => boolean, thisArg?: any): T | undefined;
     find<S extends T>(predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
-    findIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number;
+    findIndex(predicate: (value: T, index: number, obj: T[]) => boolean, thisArg?: any): number;
     fill(value: T, start?: number, end?: number): this;
     copyWithin(target: number, start: number, end?: number): this;
     [Symbol.iterator](): IterableIterator<T>;

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

@@ -1,6 +1,6 @@
 import { F } from "../util/Utils.js";
 import { Operation, MemberOptions } from "../Options.js";
-import { FieldKey, ObjectHandle, FieldVersion, Observer, Subscription, AbstractChangeset } from "./Data.js";
+import { FieldKey, ObjectHandle, FieldVersion, Reaction, Subscription, AbstractChangeset } from "./Data.js";
 import { Transaction } from "./Transaction.js";
 import { OptionsImpl } from "./Mvcc.js";
 export declare class OperationImpl implements Operation<any> {
@@ -31,9 +31,9 @@ export declare class OperationImpl implements Operation<any> {
     private relaunch;
     private static markObsolete;
 }
-declare class Launch extends FieldVersion implements Observer {
+declare class Launch extends FieldVersion implements Reaction {
     static current?: Launch;
-    static queuedReactiveOperations: Array<Observer>;
+    static queuedReactions: Array<Reaction>;
     static deferredReactiveOperations: Array<Launch>;
     readonly margin: number;
     readonly transaction: Transaction;
@@ -60,7 +60,7 @@ declare class Launch extends FieldVersion implements Observer {
     dependencies(): string[];
     wrap<T>(func: F<T>): F<T>;
     proceed(proxy: any, args: any[] | undefined): void;
-    markObsoleteDueTo(trigger: FieldVersion, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, obsolete: Observer[]): void;
+    markObsoleteDueTo(trigger: FieldVersion, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, collector: Reaction[]): void;
     relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
     isNotUpToDate(): boolean;
     reenterOver(head: Launch): this;
@@ -78,9 +78,9 @@ declare class Launch extends FieldVersion implements Observer {
     private static propagateAllChangesThroughSubscriptions;
     private static revokeAllSubscriptions;
     private static propagateFieldChangeThroughSubscriptions;
-    private static enqueueReactiveFunctionsToRun;
+    private static enqueueReactionsToRun;
     private static migrateFieldVersion;
-    private static processQueuedReactiveOperations;
+    private static processQueuedReactions;
     private unsubscribeFromAllTriggers;
     private subscribeTo;
     private static canSubscribeTo;

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

@@ -287,7 +287,7 @@ class Launch extends FieldVersion {
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(trigger, fk, changeset, h, outer, since, obsolete) {
+    markObsoleteDueTo(trigger, fk, changeset, h, outer, since, collector) {
         var _a, _b, _c;
         if (this.triggers !== undefined) {
             const skip = !trigger.isLaunch &&
@@ -303,9 +303,9 @@ class Launch extends FieldVersion {
                         : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, fk)} since s${since}${isReactive ? ` and will run automatically (order ${this.options.order})` : ""}`);
                 this.unsubscribeFromAllTriggers();
                 if (isReactive)
-                    obsolete.push(this);
+                    collector.push(this);
                 else
-                    (_b = this.observers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.operation.fieldKey, this.changeset, this.operation.ownerHandle, why, since, obsolete));
+                    (_b = this.reactions) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.operation.fieldKey, this.changeset, this.operation.ownerHandle, why, since, collector));
                 const tran = this.transaction;
                 if (tran.changeset === changeset) {
                 }
@@ -514,7 +514,7 @@ class Launch extends FieldVersion {
                 for (const fk in ov.former.objectVersion.data)
                     Launch.propagateFieldChangeThroughSubscriptions(true, since, ov, fk, h, obsolete);
         });
-        obsolete.sort(compareObserversByOrder);
+        obsolete.sort(compareReactionsByOrder);
         (_a = changeset.options.journal) === null || _a === void 0 ? void 0 : _a.edited(JournalImpl.buildPatch(changeset.hint, changeset.items));
     }
     static revokeAllSubscriptions(changeset) {
@@ -523,10 +523,10 @@ class Launch extends FieldVersion {
             ov.changes.forEach((o, fk) => Launch.propagateFieldChangeThroughSubscriptions(true, changeset.timestamp, ov, fk, h, undefined));
         });
     }
-    static propagateFieldChangeThroughSubscriptions(unsubscribe, timestamp, ov, fk, h, obsolete) {
+    static propagateFieldChangeThroughSubscriptions(unsubscribe, timestamp, ov, fk, h, collector) {
         var _a;
         const curr = ov.data[fk];
-        if (obsolete !== undefined) {
+        if (collector !== undefined) {
             const former = ov.former.objectVersion.data[fk];
             if (former !== undefined && former instanceof FieldVersion) {
                 const why = `T${ov.changeset.id}[${ov.changeset.hint}]`;
@@ -544,9 +544,9 @@ class Launch extends FieldVersion {
                     else
                         former.successor = undefined;
                 }
-                (_a = former.observers) === null || _a === void 0 ? void 0 : _a.forEach(s => {
+                (_a = former.reactions) === null || _a === void 0 ? void 0 : _a.forEach(s => {
                     const t = s.transaction;
-                    const o = t.isFinished ? obsolete : t.changeset.obsolete;
+                    const o = t.isFinished ? collector : t.changeset.obsolete;
                     return s.markObsoleteDueTo(former, fk, ov.changeset, h, why, timestamp, o);
                 });
             }
@@ -563,16 +563,16 @@ class Launch extends FieldVersion {
                     curr.unsubscribeFromAllTriggers();
             }
         }
-        else if (curr instanceof FieldVersion && curr.observers) {
+        else if (curr instanceof FieldVersion && curr.reactions) {
         }
     }
-    static enqueueReactiveFunctionsToRun(reactive) {
-        const queue = Launch.queuedReactiveOperations;
+    static enqueueReactionsToRun(reactions) {
+        const queue = Launch.queuedReactions;
         const isKickOff = queue.length === 0;
-        for (const r of reactive)
+        for (const r of reactions)
             queue.push(r);
         if (isKickOff)
-            OperationImpl.proceedWithinGivenLaunch(undefined, Launch.processQueuedReactiveOperations);
+            OperationImpl.proceedWithinGivenLaunch(undefined, Launch.processQueuedReactions);
     }
     static migrateFieldVersion(fv, target) {
         let result;
@@ -582,21 +582,21 @@ class Launch extends FieldVersion {
             result = new FieldVersion(fv.content, fv.lastEditorChangesetId);
         return result;
     }
-    static processQueuedReactiveOperations() {
-        const queue = Launch.queuedReactiveOperations;
+    static processQueuedReactions() {
+        const queue = Launch.queuedReactions;
         let i = 0;
         while (i < queue.length) {
             const reactive = queue[i];
             reactive.relaunchIfNotUpToDate(false, true);
             i++;
         }
-        Launch.queuedReactiveOperations = [];
+        Launch.queuedReactions = [];
     }
     unsubscribeFromAllTriggers() {
         var _a;
         (_a = this.triggers) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
             var _a;
-            value.observers.delete(this);
+            value.reactions.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}`);
         });
@@ -613,10 +613,10 @@ class Launch extends FieldVersion {
                 times = existing ? existing.usageCount + 1 : 1;
             }
             if (this.triggers !== undefined) {
-                if (!trigger.observers)
-                    trigger.observers = new Set();
+                if (!trigger.reactions)
+                    trigger.reactions = new Set();
                 const subscription = { memberHint: Dump.snapshot2(h, ov.changeset, fk), usageCount: times };
-                trigger.observers.add(this);
+                trigger.reactions.add(this);
                 this.triggers.set(trigger, subscription);
                 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, trigger)}${subscription.usageCount > 1 ? ` (${subscription.usageCount} times)` : ""}`);
@@ -671,7 +671,7 @@ class Launch extends FieldVersion {
         Changeset.tryResolveConflict = Launch.tryResolveConflict;
         Changeset.propagateAllChangesThroughSubscriptions = Launch.propagateAllChangesThroughSubscriptions;
         Changeset.revokeAllSubscriptions = Launch.revokeAllSubscriptions;
-        Changeset.enqueueReactiveFunctionsToRun = Launch.enqueueReactiveFunctionsToRun;
+        Changeset.enqueueReactionsToRun = Launch.enqueueReactionsToRun;
         TransactionImpl.migrateFieldVersion = Launch.migrateFieldVersion;
         Mvcc.createOperation = Launch.createOperation;
         Mvcc.rememberOperationOptions = Launch.rememberOperationOptions;
@@ -699,7 +699,7 @@ class Launch extends FieldVersion {
     }
 }
 Launch.current = undefined;
-Launch.queuedReactiveOperations = [];
+Launch.queuedReactions = [];
 Launch.deferredReactiveOperations = [];
 function valueHint(value) {
     let result = "";
@@ -749,8 +749,8 @@ function reactronicHookedThen(resolve, reject) {
     }
     return ORIGINAL_PROMISE_THEN.call(this, resolve, reject);
 }
-function compareObserversByOrder(a, b) {
-    return a.order - b.order;
+function compareReactionsByOrder(r1, r2) {
+    return r1.order - r2.order;
 }
 export function resolveReturn(value) {
     return value;

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

@@ -22,7 +22,7 @@ import { emitLetters, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js
 import { Isolation, Reentrance } from "../Options.js";
 import { TriggeringObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
-import { ReactiveSystem, options, trigger, reactive, atomicRun, nonReactiveRun } from "../ReactiveSystem.js";
+import { ReactiveSystem, options, trigger, reaction, atomicRun, nonReactiveRun } from "../ReactiveSystem.js";
 export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
@@ -359,7 +359,7 @@ ReactiveNodeImpl.logging = undefined;
 ReactiveNodeImpl.grandNodeCount = 0;
 ReactiveNodeImpl.disposableNodeCount = 0;
 __decorate([
-    reactive,
+    reaction,
     options({
         reentrance: Reentrance.cancelAndWaitPrevious,
         allowObsoleteToFinish: true,

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

@@ -1,7 +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 { ObjectHandle, ObjectVersion, Reaction, FieldVersion, FieldKey } from "./Data.js";
 import { Changeset } from "./Changeset.js";
 export declare abstract class Transaction implements Worker {
     static get current(): Transaction;
@@ -78,7 +78,7 @@ export declare class TransactionImpl extends Transaction {
     private checkForConflicts;
     private tryResolveConflicts;
     private applyOrDiscard;
-    applyOrDiscardChangeset(): Array<Observer>;
+    applyOrDiscardChangeset(): Array<Reaction>;
     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;

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

@@ -238,11 +238,11 @@ export class TransactionImpl extends Transaction {
         finally {
             this.pending--;
             if (this.sealed && this.pending === 0) {
-                const reactive = this.applyOrDiscard();
+                const obsolete = this.applyOrDiscard();
                 if (p)
                     p.runImpl(undefined, () => p.pending--);
                 TransactionImpl.gCurr = outer;
-                TransactionImpl.outside(Changeset.enqueueReactiveFunctionsToRun, reactive);
+                TransactionImpl.outside(Changeset.enqueueReactionsToRun, obsolete);
             }
             else
                 TransactionImpl.gCurr = outer;
@@ -271,12 +271,12 @@ export class TransactionImpl extends Transaction {
         throw error(`T${this.id}[${this.hint}] conflicts with: ${Dump.conflicts(conflicts)}`, undefined);
     }
     applyOrDiscard() {
-        let observers;
+        let obsolete;
         try {
             if (Log.isOn && Log.opt.change)
                 Log.write("╠═", "", "", undefined, "changes");
             this.changeset.seal();
-            observers = this.applyOrDiscardChangeset();
+            obsolete = this.applyOrDiscardChangeset();
             this.changeset.triggerGarbageCollection();
             if (this.promise) {
                 if (this.canceled && !this.after)
@@ -291,7 +291,7 @@ export class TransactionImpl extends Transaction {
             fatal(e);
             throw e;
         }
-        return observers;
+        return obsolete;
     }
     applyOrDiscardChangeset() {
         const error = this.canceled;
@@ -359,39 +359,39 @@ export class TransactionImpl extends Transaction {
         if (fv.isLaunch) {
             const migrated = TransactionImpl.migrateFieldVersion(fv, tParent);
             if (ovParent.former.objectVersion.data[fk] !== fvParent) {
-                let observers = fvParent.observers;
-                if (observers) {
-                    const migratedObservers = migrated.observers = new Set();
-                    observers.forEach(o => {
+                let reactions = fvParent.reactions;
+                if (reactions) {
+                    const migratedReactions = migrated.reactions = new Set();
+                    reactions.forEach(o => {
                         const conformingTriggers = o.triggers;
                         const sub = conformingTriggers.get(fvParent);
                         conformingTriggers.delete(fvParent);
                         conformingTriggers.set(migrated, sub);
-                        migratedObservers.add(o);
+                        migratedReactions.add(o);
                     });
-                    fvParent.observers = undefined;
+                    fvParent.reactions = undefined;
                 }
-                observers = fv.observers;
-                if (observers) {
-                    let migratedObservers = migrated.observers;
-                    if (migratedObservers === undefined)
-                        migratedObservers = migrated.observers = new Set();
-                    observers.forEach(o => {
+                reactions = fv.reactions;
+                if (reactions) {
+                    let migratedReactions = migrated.reactions;
+                    if (migratedReactions === undefined)
+                        migratedReactions = migrated.reactions = new Set();
+                    reactions.forEach(o => {
                         const conformingTriggers = o.triggers;
                         const sub = conformingTriggers.get(fv);
                         conformingTriggers.delete(fv);
                         conformingTriggers.set(migrated, sub);
-                        migratedObservers.add(o);
+                        migratedReactions.add(o);
                     });
-                    fv.observers = undefined;
+                    fv.reactions = undefined;
                 }
                 const triggers = fv.triggers;
                 const migratedTriggers = migrated.triggers;
                 if (triggers) {
                     triggers.forEach((s, o) => {
-                        const conformingObservers = o.observers;
-                        conformingObservers.delete(fv);
-                        conformingObservers.add(migrated);
+                        const conformingReactions = o.reactions;
+                        conformingReactions.delete(fv);
+                        conformingReactions.add(migrated);
                         migratedTriggers.set(o, s);
                     });
                     triggers.clear();
@@ -399,25 +399,25 @@ export class TransactionImpl extends Transaction {
                 ovParent.data[fk] = migrated;
             }
             else {
-                const observers = fv.observers;
-                if (observers) {
-                    const migratedObservers = migrated.observers = new Set();
-                    observers.forEach(o => {
+                const reactions = fv.reactions;
+                if (reactions) {
+                    const migratedReactions = migrated.reactions = new Set();
+                    reactions.forEach(o => {
                         const conformingTriggers = o.triggers;
                         const sub = conformingTriggers.get(fv);
                         conformingTriggers.delete(fv);
                         conformingTriggers.set(migrated, sub);
-                        migratedObservers.add(o);
+                        migratedReactions.add(o);
                     });
-                    fv.observers = undefined;
+                    fv.reactions = undefined;
                 }
                 const triggers = fv.triggers;
                 const migratedTriggers = migrated.triggers;
                 if (triggers) {
                     triggers.forEach((s, o) => {
-                        const conformingObservers = o.observers;
-                        conformingObservers.delete(fv);
-                        conformingObservers.add(migrated);
+                        const conformingReactions = o.reactions;
+                        conformingReactions.delete(fv);
+                        conformingReactions.add(migrated);
                         migratedTriggers.set(o, s);
                     });
                     triggers.clear();
@@ -431,16 +431,16 @@ export class TransactionImpl extends Transaction {
             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) {
-                    if (fvParent.observers === undefined)
-                        fvParent.observers = new Set();
-                    observers.forEach(o => {
+                const reactions = fv.reactions;
+                if (reactions) {
+                    if (fvParent.reactions === undefined)
+                        fvParent.reactions = new Set();
+                    reactions.forEach(o => {
                         const conformingTriggers = o.triggers;
                         const sub = conformingTriggers.get(fv);
                         conformingTriggers.delete(fv);
                         conformingTriggers.set(fvParent, sub);
-                        fvParent.observers.add(o);
+                        fvParent.reactions.add(o);
                     });
                 }
             }

package/package.json

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