reactronic 0.93.25021 → 0.93.25026

package/README.md

@@ -28,14 +28,15 @@ concepts:
   - **Triggering Objects** - a set of objects that store
     data of an application (state) and cause reactions
     upon their changes;
-  - **Atomic Function** - a function that makes changes in
-    triggering objects in atomic way ("all or nothing");
-  - **Reactive Function** - a function that is
+  - **Atomic Block** - a code block that makes changes
+    in triggering objects in atomic way ("all or
+    nothing");
+  - **Reaction** - a function that is
     (re-)executed in response to changes made in
     triggering objects by atomic actions;
-  - **Cached Function** -  a function which result is
-    remembered and, if becomes obsolete, causes function
-    to re-execute on-demand.
+  - **Cache** -  a function which result is remembered
+    and, if becomes obsolete, causes function to
+    re-execute on-demand.
 
 Demo application built with Reactronic: https://nevod.io/#/playground.
 Source code of the demo: https://gitlab.com/nezaboodka/nevod.web.public/-/blob/master/README.md.
@@ -57,7 +58,7 @@ class Demo extends TriggeringObject {
     this.email = email
   }
 
-  @reactive
+  @reaction
   printContact(): void {
     // depends on `name` and `email` and reacts to their changes
     if (this.email.indexOf('@') >= 0)
@@ -83,12 +84,12 @@ class Demo extends TriggeringObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @cachedResult
+  @cache
   get contact(): string {
     return this.name + ' <' + this.email + '>'
   }
 
-  @reactive
+  @reaction
   printContact(): void {
     if (this.contact !== '')
       Console.log(this.contact)
@@ -192,7 +193,7 @@ execution.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
-  @cachedResult
+  @cache
   render(): React.JSX.Element {
     return (
       <div>
@@ -206,12 +207,12 @@ class MyView extends Component<{model: MyModel}> {
 
 ``` tsx
 class Component<P> extends React.Component<P> {
-  @cachedResult
+  @cache
   render(): React.JSX.Element {
     throw new Error('render method is undefined')
   }
 
-  @reactive // called in response to changes
+  @reaction // called in response to changes
   ensureUpToDate(): void {
     if (this.shouldComponentUpdate()) {
       // Ask React to re-render
@@ -330,12 +331,12 @@ class TriggeringObject { }
 function trigger(boolean) // field only
 function trigger(proto, prop) // field only
 function atomic(proto, prop, pd) // method only
-function reactive(proto, prop, pd) // method only
-function cached(proto, prop, pd) // method only
+function reaction(proto, prop, pd) // method only
+function cache(proto, prop, pd) // method only
 function options(value: Partial<MemberOptions>): F<any>
 
-function nonReactiveRun<T>(func: F<T>, ...args: any[]): T
-function sensitiveRun<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
+function runNonReactively<T>(func: F<T>, ...args: any[]): T
+function runSensitively<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 // SnapshotOptions, MemberOptions, Kind, Reentrance, Indicator, LoggingOptions, ProfilingOptions
 
@@ -363,8 +364,8 @@ type MemberOptions = {
 enum Kind {
   plain = 0,
   atomic = 1,
-  reactive = 2,
-  cached = 3
+  reaction = 2,
+  cache = 3
 }
 
 enum Reentrance {

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

@@ -26,8 +26,8 @@ export type MemberOptions = {
 export declare enum Kind {
     plain = 0,
     atomic = 1,
-    reactive = 2,
-    cached = 3
+    reaction = 2,
+    cache = 3
 }
 export declare enum Reentrance {
     preventWithError = 1,

package/build/dist/source/Options.js

@@ -3,8 +3,8 @@ export var Kind;
 (function (Kind) {
     Kind[Kind["plain"] = 0] = "plain";
     Kind[Kind["atomic"] = 1] = "atomic";
-    Kind[Kind["reactive"] = 2] = "reactive";
-    Kind[Kind["cached"] = 3] = "cached";
+    Kind[Kind["reaction"] = 2] = "reaction";
+    Kind[Kind["cache"] = 3] = "cache";
 })(Kind || (Kind = {}));
 export var Reentrance;
 (function (Reentrance) {

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

@@ -17,14 +17,14 @@ export declare class ReactiveSystem {
     static getLoggingHint<T extends object>(obj: T, full?: boolean): string | undefined;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
 }
-export declare function atomicRun<T>(func: F<T>, ...args: any[]): T;
-export declare function atomicRun<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
-export declare function nonReactiveRun<T>(func: F<T>, ...args: any[]): T;
-export declare function sensitiveRun<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
-export declare function contextualRun<T>(p: Promise<T>): Promise<T>;
+export declare function runAtomically<T>(func: F<T>, ...args: any[]): T;
+export declare function runAtomically<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
+export declare function runNonReactively<T>(func: F<T>, ...args: any[]): T;
+export declare function runSensitively<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
+export declare function runContextually<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 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

@@ -22,7 +22,7 @@ export class ReactiveSystem {
     static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
     static setProfilingMode(isOn, options) { Mvcc.setProfilingMode(isOn, options); }
 }
-export function atomicRun(p1, p2, p3) {
+export function runAtomically(p1, p2, p3) {
     if (p1 instanceof Function) {
         if (p2 !== undefined)
             return Transaction.run(null, p1, ...p2);
@@ -36,13 +36,13 @@ export function atomicRun(p1, p2, p3) {
             return Transaction.run(p1, p2);
     }
 }
-export function nonReactiveRun(func, ...args) {
+export function runNonReactively(func, ...args) {
     return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
-export function sensitiveRun(sensitivity, func, ...args) {
+export function runSensitively(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
 }
-export function contextualRun(p) {
+export function runContextually(p) {
     throw new Error("not implemented yet");
 }
 export function trigger(protoOrEnabled, prop) {
@@ -61,21 +61,21 @@ export function atomic(proto, prop, pd) {
     };
     return Mvcc.decorateOperation(true, atomic, opts, proto, prop, pd);
 }
-export function reactive(proto, prop, pd) {
+export function reaction(proto, prop, pd) {
     const opts = {
-        kind: Kind.reactive,
+        kind: Kind.reaction,
         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,
+        kind: Kind.cache,
         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/Ref.d.ts

@@ -27,7 +27,7 @@ export declare class Ref<T = any> {
     constructor(owner: any, name: string, index?: number);
     get variable(): T;
     set variable(value: T);
-    unobs(): T;
+    nonReactively(): T;
     observe(): T;
     unobserve(): T;
     static sameRefs(v1: Ref, v2: Ref): boolean;

package/build/dist/source/Ref.js

@@ -1,4 +1,4 @@
-import { atomicRun, nonReactiveRun } from "./ReactiveSystem.js";
+import { runAtomically, runNonReactively } from "./ReactiveSystem.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }
@@ -27,8 +27,8 @@ export class Ref {
         else
             this.owner[this.name][this.index] = value;
     }
-    unobs() {
-        return nonReactiveRun(() => this.variable);
+    nonReactively() {
+        return runNonReactively(() => this.variable);
     }
     observe() {
         return this.variable;
@@ -52,7 +52,7 @@ export class ToggleRef extends Ref {
     toggle() {
         const o = this.owner;
         const p = this.name;
-        atomicRun({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
+        runAtomically({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
             const v = o[p];
             const isOn = v === this.valueOn || (v instanceof Ref && this.valueOn instanceof Ref &&
                 Ref.sameRefs(v, this.valueOn));

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

@@ -16,8 +16,8 @@ export { Changeset } from "./core/Changeset.js";
 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 { runAtomically, runNonReactively, runSensitively, runContextually } from "./ReactiveSystem.js";
+export { ReactiveSystem, trigger, atomic, 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

@@ -12,7 +12,7 @@ export { Changeset } from "./core/Changeset.js";
 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 { runAtomically, runNonReactively, runSensitively, runContextually } from "./ReactiveSystem.js";
+export { ReactiveSystem, trigger, atomic, 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,25 +287,25 @@ 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 &&
                 changeset.id === this.lastEditorChangesetId;
             if (!skip) {
                 const why = `${Dump.snapshot2(h, changeset, fk, trigger)}    ◀◀    ${outer}`;
-                const isReactive = this.options.kind === Kind.reactive;
+                const isReaction = this.options.kind === Kind.reaction;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
                 if (Log.isOn && (Log.opt.obsolete || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.obsolete)))
-                    Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", isReactive ? "█" : "▒", isReactive && changeset === EMPTY_OBJECT_VERSION.changeset
+                    Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", isReaction ? "█" : "▒", isReaction && 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.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, fk)} since s${since}${isReaction ? ` and will run automatically (order ${this.options.order})` : ""}`);
                 this.unsubscribeFromAllTriggers();
-                if (isReactive)
-                    obsolete.push(this);
+                if (isReaction)
+                    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) {
                 }
@@ -326,14 +326,14 @@ class Launch extends FieldVersion {
                     const launch = this.operation.reuseOrRelaunch(false, undefined);
                     if (launch.result instanceof Promise)
                         launch.result.catch(error => {
-                            if (launch.options.kind === Kind.reactive)
+                            if (launch.options.kind === Kind.reaction)
                                 misuse(`reactive function ${launch.hint()} failed and will not run anymore: ${error}`, error);
                         });
                 }
                 catch (e) {
                     if (!nothrow)
                         throw e;
-                    else if (this.options.kind === Kind.reactive)
+                    else if (this.options.kind === Kind.reaction)
                         misuse(`reactive ${this.hint()} failed and will not run anymore: ${e}`, e);
                 }
             }
@@ -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)` : ""}`);
@@ -652,11 +652,11 @@ class Launch extends FieldVersion {
         const rx = launch ? launch.operation : new OperationImpl(EMPTY_HANDLE, fk);
         const opts = launch ? launch.options : OptionsImpl.INITIAL;
         initial[fk] = launch = new Launch(Transaction.current, rx, EMPTY_OBJECT_VERSION.changeset, new OptionsImpl(getter, setter, opts, options, implicit), false);
-        if (launch.options.kind === Kind.reactive && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
+        if (launch.options.kind === Kind.reaction && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
             reactive[fk] = launch;
         }
-        else if (launch.options.kind === Kind.reactive && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
+        else if (launch.options.kind === Kind.reaction && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.getFrom(proto, Meta.Reactive);
             delete reactive[fk];
         }
@@ -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, runAtomically, runNonReactively } from "../ReactiveSystem.js";
 export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
@@ -333,13 +333,13 @@ class ReactiveNodeImpl extends ReactiveNode {
     static setNodeVariableValue(variable, value) {
         const node = ReactiveNodeImpl.nodeSlot.instance;
         const owner = node.owner;
-        const hostCtx = nonReactiveRun(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
+        const hostCtx = runNonReactively(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
             if (hostCtx)
                 node.outer = owner;
             else
                 node.outer = owner.outer;
-            atomicRun({ isolation: Isolation.joinAsNestedTransaction }, () => {
+            runAtomically({ isolation: Isolation.joinAsNestedTransaction }, () => {
                 const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
@@ -359,7 +359,7 @@ ReactiveNodeImpl.logging = undefined;
 ReactiveNodeImpl.grandNodeCount = 0;
 ReactiveNodeImpl.disposableNodeCount = 0;
 __decorate([
-    reactive,
+    reaction,
     options({
         reentrance: Reentrance.cancelAndWaitPrevious,
         allowObsoleteToFinish: true,
@@ -484,18 +484,18 @@ function triggerScriptRunViaSlot(nodeSlot) {
                     });
                 });
             }
-            nonReactiveRun(node.script, node.declaration.triggers);
+            runNonReactively(node.script, node.declaration.triggers);
         }
         else if (node.owner !== node)
             runScriptNow(nodeSlot);
         else
-            atomicRun(() => runScriptNow(nodeSlot));
+            runAtomically(() => runScriptNow(nodeSlot));
     }
 }
 function mountOrRemountIfNecessary(node) {
     const driver = node.driver;
     if (node.stamp === Number.MAX_SAFE_INTEGER) {
-        nonReactiveRun(() => {
+        runNonReactively(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
             driver.runPreparation(node);
             if (!node.has(Mode.manualMount)) {
@@ -506,7 +506,7 @@ function mountOrRemountIfNecessary(node) {
         });
     }
     else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
-        nonReactiveRun(() => driver.runMount(node));
+        runNonReactively(() => driver.runMount(node));
 }
 function runScriptNow(nodeSlot) {
     const node = nodeSlot.instance;
@@ -539,7 +539,7 @@ function triggerFinalization(nodeSlot, isLeader, individual) {
         if (individual && node.key !== node.declaration.key && !driver.isPartition)
             console.log(`WARNING: it is recommended to assign explicit key for conditional element in order to avoid unexpected side effects: ${node.key}`);
         node.stamp = ~node.stamp;
-        const childrenAreLeaders = nonReactiveRun(() => driver.runFinalization(node, isLeader));
+        const childrenAreLeaders = runNonReactively(() => driver.runFinalization(node, isLeader));
         if (node.has(Mode.autonomous)) {
             nodeSlot.aux = undefined;
             const last = gLastToDispose;
@@ -548,7 +548,7 @@ function triggerFinalization(nodeSlot, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = nodeSlot;
             if (gFirstToDispose === nodeSlot)
-                atomicRun({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
+                runAtomically({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }

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.25026",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",