reactronic 0.92.25014 → 0.92.25020

package/README.md

@@ -19,19 +19,20 @@ atomically applied, are **consistently propagated** to
 corresponding visual components for (re)rendering. All
 that is done in automatic, seamless, and fine-grained
 way. Reactronic **takes full care of tracking dependencies**
-between visual components (observers) and state
-(observable objects).
+between visual components (reactive functions) and
+application state (triggering objects).
 
 Transactional reactivity is based on four fundamental
 concepts:
 
-  - **Observable Objects** - a set of objects that store
-    data of an application (state);
+  - **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
-    observable objects in atomic way ("all or nothing");
+    triggering objects in atomic way ("all or nothing");
   - **Reactive Function** - a function that is
-    (re-)executed in response to changes made by atomic
-    actions;
+    (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.
@@ -46,7 +47,7 @@ Quick introduction and detailed description is below.
 Here is an example of transactional reactive code:
 
 ``` typescript
-class Demo extends ObservableObject {
+class Demo extends TriggeringObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -66,7 +67,7 @@ class Demo extends ObservableObject {
 }
 ```
 
-In the example above, `Demo` is an observable object,
+In the example above, `Demo` is a triggering object,
 meaning that access to its fields are seamlessly tracked
 to determine dependent reactive and cached functions.
 Reactive function `printContact` reads `name` and `email`
@@ -78,7 +79,7 @@ Here is an example of a cached result that is
 (re-)computed on-demand:
 
 ``` typescript
-class Demo extends ObservableObject {
+class Demo extends TriggeringObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -105,15 +106,15 @@ thus causing execution of depending reactive function
 `printContact` runs it reads `contact` and causes its
 re-computation.
 
-## Observable Objects
+## Triggering Objects
 
-Observable objects are aimed to store data of an
-application. All such objects are transparently hooked
+Triggering objects (triggers) are aimed to store data of
+an application. All such objects are transparently hooked
 to track access to their properties, both on reads and
 writes.
 
 ``` typescript
-class MyModel extends ObservableObject {
+class MyModel extends TriggeringObject {
   url: string = "https://github.com/nezaboodka/reactronic"
   content: string = "transactional reactive state management"
   timestamp: Date = Date.now()
@@ -121,19 +122,19 @@ class MyModel extends ObservableObject {
 ```
 
 In the example above, the class `MyModel` is based on
-Reactronic's `ObservableObject` class and all its
+Reactronic's `TriggeringObject` class and all its
 properties `url`, `content`, and `timestamp` are hooked.
 
 ## Atomic Function
 
-Atomic function makes changes in observable objects
+Atomic function makes changes in triggering objects
 in atomic (transactional) way, thus provoking execution
 of dependent reactive and cached functions. Atomic
 function is instrumented with hooks to provide transparent atomicity
 (by implicit context switching and isolation).
 
 ``` typescript
-class MyModel extends ObservableObject {
+class MyModel extends TriggeringObject {
   // ...
   @atomic
   async load(url: string): Promise<void> {
@@ -180,12 +181,12 @@ chain of asynchronous operations is fully completed.
 ## Reactive & Cached Functions
 
 Reactive function is automatically and immediately called
-in response to changes in observable objects made by
+in response to changes in triggering objects made by
 atomic functions. Cached function is called on-demand to
 renew the result if it was marked as obsolete due to
 changes made by an atomic functions. Reactive and cached
 functions are instrumented with hooks to seamlessly
-subscribe to those observable objects and other cached
+subscribe to those triggering objects and other cached
 functions (dependencies), which are used during their
 execution.
 
@@ -248,14 +249,14 @@ cached value.
 
 In general case, all reactive and cached functions
 are automatically and immediately marked as obsolete
-when changes are made in those observable objects and
+when changes are made in those triggering objects and
 other cached results that were used during their
 execution. And once marked, the functions are
 automatically executed again, either immediately (for
 reactive functions) or on-demand (for cached functions).
 
 Reactronic takes full care of tracking dependencies
-between all the observable objects and reactive/cached
+between all the triggering objects and reactive/cached
 functions. With Reactronic, you no longer need to create
 data change events in one set of objects, subscribe to
 these events in other objects, and manually maintain
@@ -301,7 +302,7 @@ Key Reactronic principles and differentiators:
 
   - No compromises on consistency, clarity, and simplicity;
   - Minimalism and zero boilerplating (it's not a framework bloating your code);
-  - Asynchrony, patches, undo/redo, conflict resolving are provided out of the box;
+  - Async, patches, undo/redo, conflict resolving are provided out of the box;
   - Seamless integration with transactional reactive object-oriented databases like [Nezaboodka](https://nezaboodka.com/#products);
   - Compact dependency-free implementation consisting of less than 2K lines of code.
 
@@ -322,12 +323,12 @@ NPM: `npm install reactronic`
 // Classes
 
 class TransactionalObject { }
-class ObservableObject { }
+class TriggeringObject { }
 
 // Decorators & Operators
 
-function observable(proto, prop) // field only
-function unobservable(proto, prop) // field only
+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

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

@@ -1,5 +1,5 @@
-import { ObservableObject } from "./core/Mvcc.js";
-export declare abstract class Pipe<T> extends ObservableObject {
+import { TriggeringObject } from "./core/Mvcc.js";
+export declare abstract class Pipe<T> extends TriggeringObject {
     abstract readonly capacity: number;
     abstract readonly count: number;
     abstract put(...items: T[]): void;

package/build/dist/source/Pipe.js

@@ -1,4 +1,4 @@
-import { ObservableObject } from "./core/Mvcc.js";
-export class Pipe extends ObservableObject {
+import { TriggeringObject } from "./core/Mvcc.js";
+export class Pipe extends TriggeringObject {
     static create(hint, capacity) { throw new Error("not implemented"); }
 }

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

@@ -1,6 +1,6 @@
 import { F } from "./util/Utils.js";
-import { ObservableObject } from "./core/Mvcc.js";
-export declare class ReactiveLoop<T> extends ObservableObject {
+import { TriggeringObject } from "./core/Mvcc.js";
+export declare class ReactiveLoop<T> extends TriggeringObject {
     protected reactiveFunction: F<T>;
     constructor(reactiveFunction: F<T>);
     protected launch(): T;

package/build/dist/source/ReactiveLoop.js

@@ -7,9 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { ObservableObject } from "./core/Mvcc.js";
+import { TriggeringObject } from "./core/Mvcc.js";
 import { reactive } from "./ReactiveSystem.js";
-export class ReactiveLoop extends ObservableObject {
+export class ReactiveLoop extends TriggeringObject {
     constructor(reactiveFunction) {
         super();
         this.reactiveFunction = reactiveFunction;

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

@@ -22,8 +22,8 @@ export declare function atomicRun<T>(options: SnapshotOptions, func: F<T>, ...ar
 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 unobservable(proto: object, prop: PropertyKey): any;
-export declare function observable(proto: object, prop: PropertyKey): any;
+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;

package/build/dist/source/ReactiveSystem.js

@@ -45,11 +45,14 @@ export function sensitiveRun(sensitivity, func, ...args) {
 export function contextualRun(p) {
     throw new Error("not implemented yet");
 }
-export function unobservable(proto, prop) {
-    return Mvcc.decorateData(false, proto, prop);
-}
-export function observable(proto, prop) {
-    return Mvcc.decorateData(true, proto, prop);
+export function trigger(protoOrEnabled, prop) {
+    if (typeof (protoOrEnabled) === "boolean") {
+        return (proto, prop) => {
+            return Mvcc.decorateData(protoOrEnabled, proto, prop);
+        };
+    }
+    else
+        return Mvcc.decorateData(true, protoOrEnabled, prop);
 }
 export function atomic(proto, prop, pd) {
     const opts = {

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

@@ -9,15 +9,15 @@ export type { Operation, MemberOptions, SnapshotOptions, LoggingOptions, Profili
 export type { Worker } from "./Worker.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from "./Ref.js";
 export type { BoolOnly, GivenTypeOnly } from "./Ref.js";
-export { TransactionalObject, ObservableObject } from "./core/Mvcc.js";
-export { TransactionalArray, ObservableArray } from "./core/MvccArray.js";
-export { TransactionalMap, ObservableMap } from "./core/MvccMap.js";
+export { TransactionalObject, TriggeringObject } from "./core/Mvcc.js";
+export { TransactionalArray, TriggeringArray } from "./core/MvccArray.js";
+export { TransactionalMap, TriggeringMap } from "./core/MvccMap.js";
 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, observable, unobservable, atomic, reactive, cached, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, trigger, atomic, reactive, cached, 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

@@ -5,14 +5,14 @@ export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";
 export { Kind, Reentrance, Isolation, LoggingLevel } from "./Options.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from "./Ref.js";
-export { TransactionalObject, ObservableObject } from "./core/Mvcc.js";
-export { TransactionalArray, ObservableArray } from "./core/MvccArray.js";
-export { TransactionalMap, ObservableMap } from "./core/MvccMap.js";
+export { TransactionalObject, TriggeringObject } from "./core/Mvcc.js";
+export { TransactionalArray, TriggeringArray } from "./core/MvccArray.js";
+export { TransactionalMap, TriggeringMap } from "./core/MvccMap.js";
 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, observable, unobservable, atomic, reactive, cached, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, trigger, atomic, reactive, cached, 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.js

@@ -125,7 +125,7 @@ export class Changeset {
     }
     isNewObjectVersionRequired(h, ov, fk, existing, value, token) {
         if (this.sealed && ov.changeset !== EMPTY_OBJECT_VERSION.changeset)
-            throw misuse(`observable property ${Dump.obj(h, fk)} can only be modified inside transaction`);
+            throw misuse(`triggering property ${Dump.obj(h, fk)} can only be modified inside transaction`);
         if (fk !== Meta.Handle) {
             if (value !== Meta.Handle) {
                 if (ov.changeset !== this || ov.former.objectVersion !== EMPTY_OBJECT_VERSION) {

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

@@ -14,10 +14,10 @@ export declare class FieldVersion<T = any> {
 }
 export type Observer = {
     readonly order: number;
-    readonly observables: Map<FieldVersion, Subscription> | undefined;
+    readonly triggers: Map<FieldVersion, Subscription> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(observable: 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, reactive: Array<Observer>): void;
     relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
 };
 export type FieldKey = PropertyKey;

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

@@ -1,6 +1,6 @@
 import { Worker } from "../Worker.js";
-import { ObservableObject } from "./Mvcc.js";
-export declare abstract class Indicator extends ObservableObject {
+import { TriggeringObject } from "./Mvcc.js";
+export declare abstract class Indicator extends TriggeringObject {
     abstract readonly isBusy: boolean;
     abstract readonly counter: number;
     abstract readonly workers: ReadonlySet<Worker>;

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

@@ -8,9 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Isolation } from "../Options.js";
-import { ObservableObject, Mvcc } from "./Mvcc.js";
+import { TriggeringObject, Mvcc } from "./Mvcc.js";
 import { Transaction } from "./Transaction.js";
-export class Indicator extends ObservableObject {
+export class Indicator extends TriggeringObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return IndicatorImpl.createImpl(hint, activationDelay, deactivationDelay, durationResolution);
     }

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

@@ -1,7 +1,7 @@
-import { ObservableObject } from "./Mvcc.js";
+import { TriggeringObject } from "./Mvcc.js";
 import { ObjectHandle, ObjectVersion, PatchSet } from "./Data.js";
 export type Saver = (patch: PatchSet) => Promise<void>;
-export declare abstract class Journal extends ObservableObject {
+export declare abstract class Journal extends TriggeringObject {
     abstract capacity: number;
     abstract readonly edits: ReadonlyArray<PatchSet>;
     abstract readonly unsaved: PatchSet;

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

@@ -1,10 +1,10 @@
 import { Isolation } from "../Options.js";
-import { ObservableObject } from "./Mvcc.js";
+import { TriggeringObject } from "./Mvcc.js";
 import { Meta, FieldVersion } from "./Data.js";
 import { Changeset, EMPTY_OBJECT_VERSION } from "./Changeset.js";
 import { Transaction } from "./Transaction.js";
 import { Sealant } from "../util/Sealant.js";
-export class Journal extends ObservableObject {
+export class Journal extends TriggeringObject {
     static create() { return new JournalImpl(); }
 }
 export class JournalImpl extends Journal {

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

@@ -5,13 +5,13 @@ import { FieldKey, ObjectHandle } from "./Data.js";
 import { Journal } from "./Journal.js";
 import { Indicator } from "./Indicator.js";
 export declare abstract class MvccObject {
-    protected constructor(observable: boolean);
+    protected constructor(isTriggering: boolean);
     [Symbol.toStringTag](): string;
 }
 export declare abstract class TransactionalObject extends MvccObject {
     constructor();
 }
-export declare abstract class ObservableObject extends MvccObject {
+export declare abstract class TriggeringObject extends MvccObject {
     constructor();
 }
 export declare class OptionsImpl implements MemberOptions {
@@ -38,9 +38,9 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
     static readonly transactional: Mvcc;
-    static readonly observable: Mvcc;
-    readonly isObservable: boolean;
-    constructor(isObservable: boolean);
+    static readonly triggering: Mvcc;
+    readonly isTriggering: boolean;
+    constructor(isTriggering: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;
     get(h: ObjectHandle, fk: FieldKey, receiver: any): any;
     set(h: ObjectHandle, fk: FieldKey, value: any, receiver: any): boolean;
@@ -48,11 +48,11 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     defineProperty?(h: ObjectHandle, name: string | symbol, attributes: PropertyDescriptor): boolean;
     getOwnPropertyDescriptor(h: ObjectHandle, fk: FieldKey): PropertyDescriptor | undefined;
     ownKeys(h: ObjectHandle): Array<string | symbol>;
-    static decorateData(isObservable: boolean, proto: any, fk: FieldKey): any;
+    static decorateData(isTrigger: boolean, proto: any, fk: FieldKey): any;
     static decorateOperation(implicit: boolean, decorator: Function, options: Partial<MemberOptions>, proto: any, member: FieldKey, pd: PropertyDescriptor | undefined): any;
     static decorateOperationParametrized(decorator: Function, options: Partial<MemberOptions>): F<any>;
     static acquireHandle(obj: any): ObjectHandle;
-    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, isObservable: boolean): ObjectHandle;
+    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, isTriggering: boolean): ObjectHandle;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
     static sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
     static setHint<T>(obj: T, hint: string | undefined): T;

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

@@ -4,10 +4,10 @@ import { Kind, Reentrance, Isolation } from "../Options.js";
 import { ObjectVersion, ObjectHandle, FieldVersion, Meta } from "./Data.js";
 import { Changeset, Dump, EMPTY_OBJECT_VERSION } from "./Changeset.js";
 export class MvccObject {
-    constructor(observable) {
+    constructor(isTriggering) {
         const proto = new.target.prototype;
         const initial = Meta.getFrom(proto, Meta.Initial);
-        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, observable);
+        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, isTriggering);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -20,7 +20,7 @@ export class TransactionalObject extends MvccObject {
         super(false);
     }
 }
-export class ObservableObject extends MvccObject {
+export class TriggeringObject extends MvccObject {
     constructor() {
         super(true);
     }
@@ -62,8 +62,8 @@ function merge(def, existing, patch, implicit) {
     return patch !== undefined && (existing === def || !implicit) ? patch : existing;
 }
 export class Mvcc {
-    constructor(isObservable) {
-        this.isObservable = isObservable;
+    constructor(isTriggering) {
+        this.isTriggering = isTriggering;
     }
     getPrototypeOf(h) {
         return Reflect.getPrototypeOf(h.data);
@@ -75,7 +75,7 @@ export class Mvcc {
             const ov = cs.getObjectVersion(h, fk);
             result = ov.data[fk];
             if (result instanceof FieldVersion && !result.isLaunch) {
-                if (this.isObservable)
+                if (this.isTriggering)
                     Changeset.markUsed(result, ov, fk, h, Kind.plain, false);
                 result = result.content;
             }
@@ -122,16 +122,16 @@ export class Mvcc {
         }
         return result;
     }
-    static decorateData(isObservable, proto, fk) {
-        if (isObservable) {
+    static decorateData(isTrigger, proto, fk) {
+        if (isTrigger) {
             Meta.acquire(proto, Meta.Initial)[fk] = new FieldVersion(undefined, 0);
             const get = function () {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.observable.get(h, fk, this);
+                return Mvcc.triggering.get(h, fk, this);
             };
             const set = function (value) {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.observable.set(h, fk, value, this);
+                return Mvcc.triggering.set(h, fk, value, this);
             };
             const enumerable = true;
             const configurable = false;
@@ -177,19 +177,19 @@ export class Mvcc {
         let h = obj[Meta.Handle];
         if (!h) {
             if (obj !== Object(obj) || Array.isArray(obj))
-                throw misuse("only objects can be observable");
+                throw misuse("only objects can be triggering");
             const initial = Meta.getFrom(Object.getPrototypeOf(obj), Meta.Initial);
             const ov = new ObjectVersion(EMPTY_OBJECT_VERSION.changeset, EMPTY_OBJECT_VERSION, Object.assign({}, initial));
-            h = new ObjectHandle(obj, obj, Mvcc.observable, ov, obj.constructor.name);
+            h = new ObjectHandle(obj, obj, Mvcc.triggering, ov, obj.constructor.name);
             Meta.set(ov.data, Meta.Handle, h);
             Meta.set(obj, Meta.Handle, h);
             Meta.set(ov.data, Meta.Revision, new FieldVersion(1, 0));
         }
         return h;
     }
-    static createHandleForMvccObject(proto, data, blank, hint, isObservable) {
+    static createHandleForMvccObject(proto, data, blank, hint, isTriggering) {
         const ctx = Changeset.edit();
-        const mvcc = isObservable ? Mvcc.observable : Mvcc.transactional;
+        const mvcc = isTriggering ? Mvcc.triggering : Mvcc.transactional;
         const h = new ObjectHandle(data, undefined, mvcc, EMPTY_OBJECT_VERSION, hint);
         ctx.getEditableObjectVersion(h, Meta.Handle, blank);
         if (!Mvcc.reactivityAutoStartDisabled)
@@ -239,7 +239,7 @@ Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.sensitivity = false;
 Mvcc.transactional = new Mvcc(false);
-Mvcc.observable = new Mvcc(true);
+Mvcc.triggering = new Mvcc(true);
 Mvcc.createOperation = function (h, fk, options) {
     throw misuse("this implementation of createOperation should never be called");
 };

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

@@ -1,7 +1,7 @@
 import { MvccObject } from "./Mvcc.js";
 export declare class MvccArray<T> extends MvccObject {
     private impl;
-    constructor(isObservable: boolean, array: Array<T>);
+    constructor(isTriggering: boolean, array: Array<T>);
     get length(): number;
     set length(n: number);
     getItem(n: number): T;
@@ -53,7 +53,7 @@ export declare class TransactionalArray<T> extends MvccArray<T> {
     constructor(arrayLength?: number);
     constructor(...items: T[]);
 }
-export declare class ObservableArray<T> extends MvccArray<T> {
+export declare class TriggeringArray<T> extends MvccArray<T> {
     constructor();
     constructor(arrayLength: number);
     constructor(arrayLength?: number);

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

@@ -1,8 +1,8 @@
 import { Sealant } from "../util/Sealant.js";
 import { MvccObject } from "./Mvcc.js";
 export class MvccArray extends MvccObject {
-    constructor(isObservable, array) {
-        super(isObservable);
+    constructor(isTriggering, array) {
+        super(isTriggering);
         this.impl = array;
     }
     get length() { return this.impl.length; }
@@ -51,7 +51,7 @@ export class TransactionalArray extends MvccArray {
         super(false, new Array(...args));
     }
 }
-export class ObservableArray extends MvccArray {
+export class TriggeringArray extends MvccArray {
     constructor(...args) {
         super(true, new Array(...args));
     }

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

@@ -1,7 +1,7 @@
 import { MvccObject } from "./Mvcc.js";
 export declare class MvccMap<K, V> extends MvccObject {
     private impl;
-    constructor(isObservable: boolean, map: Map<K, V>);
+    constructor(isTriggering: boolean, map: Map<K, V>);
     clear(): void;
     delete(key: K): boolean;
     forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
@@ -19,7 +19,7 @@ export declare class TransactionalMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }
-export declare class ObservableMap<K, V> extends MvccMap<K, V> {
+export declare class TriggeringMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }

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

@@ -1,8 +1,8 @@
 import { Sealant } from "../util/Sealant.js";
 import { MvccObject } from "./Mvcc.js";
 export class MvccMap extends MvccObject {
-    constructor(isObservable, map) {
-        super(isObservable);
+    constructor(isTriggering, map) {
+        super(isTriggering);
         this.impl = map;
     }
     clear() { this.mutable.clear(); }
@@ -28,7 +28,7 @@ export class TransactionalMap extends MvccMap {
         super(false, args !== undefined ? new Map(args) : new Map());
     }
 }
-export class ObservableMap extends MvccMap {
+export class TriggeringMap extends MvccMap {
     constructor(args) {
         super(true, args !== undefined ? new Map(args) : new Map());
     }

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

@@ -1,6 +1,6 @@
 import { MergeList, MergedItem, MergeListReader } from "../util/MergeList.js";
-import { ObservableObject } from "./Mvcc.js";
-export declare abstract class ObservableMergeList<T> extends ObservableObject implements MergeListReader<T> {
+import { TriggeringObject } from "./Mvcc.js";
+export declare abstract class TriggeringMergeList<T> extends TriggeringObject implements MergeListReader<T> {
     protected abstract impl: MergeList<T>;
     get isStrict(): boolean;
     get count(): number;

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

@@ -1,5 +1,5 @@
-import { ObservableObject } from "./Mvcc.js";
-export class ObservableMergeList extends ObservableObject {
+import { TriggeringObject } from "./Mvcc.js";
+export class TriggeringMergeList extends TriggeringObject {
     get isStrict() { return this.impl.isStrict; }
     get count() { return this.impl.count; }
     get addedCount() { return this.impl.addedCount; }

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

@@ -39,7 +39,7 @@ declare class Launch extends FieldVersion implements Observer {
     readonly transaction: Transaction;
     readonly operation: OperationImpl;
     readonly changeset: AbstractChangeset;
-    observables: Map<FieldVersion, Subscription> | undefined;
+    triggers: Map<FieldVersion, Subscription> | undefined;
     options: OptionsImpl;
     cause: string | undefined;
     args: any[];
@@ -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(observable: 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, obsolete: Observer[]): void;
     relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
     isNotUpToDate(): boolean;
     reenterOver(head: Launch): this;
@@ -81,7 +81,7 @@ declare class Launch extends FieldVersion implements Observer {
     private static enqueueReactiveFunctionsToRun;
     private static migrateFieldVersion;
     private static processQueuedReactiveOperations;
-    private unsubscribeFromAllObservables;
+    private unsubscribeFromAllTriggers;
     private subscribeTo;
     private static canSubscribeTo;
     private static createOperation;

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

@@ -8,7 +8,7 @@ import { Mvcc, OptionsImpl } from "./Mvcc.js";
 import { JournalImpl } from "./Journal.js";
 const BOOT_ARGS = [];
 const BOOT_CAUSE = "<boot>";
-const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.observable, EMPTY_OBJECT_VERSION, "<boot>");
+const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.triggering, EMPTY_OBJECT_VERSION, "<boot>");
 export class OperationImpl {
     configure(options) { return OperationImpl.configureImpl(this, options); }
     get options() { return this.peek(undefined).launch.options; }
@@ -201,7 +201,7 @@ class Launch extends FieldVersion {
         this.transaction = transaction;
         this.operation = operation;
         this.changeset = changeset;
-        this.observables = new Map();
+        this.triggers = new Map();
         if (former instanceof Launch) {
             this.options = former.options;
             this.cause = former.obsoleteDueTo;
@@ -287,13 +287,13 @@ class Launch extends FieldVersion {
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(observable, fk, changeset, h, outer, since, obsolete) {
+    markObsoleteDueTo(trigger, fk, changeset, h, outer, since, obsolete) {
         var _a, _b, _c;
-        if (this.observables !== undefined) {
-            const skip = !observable.isLaunch &&
+        if (this.triggers !== undefined) {
+            const skip = !trigger.isLaunch &&
                 changeset.id === this.lastEditorChangesetId;
             if (!skip) {
-                const why = `${Dump.snapshot2(h, changeset, fk, observable)}    ◀◀    ${outer}`;
+                const why = `${Dump.snapshot2(h, changeset, fk, trigger)}    ◀◀    ${outer}`;
                 const isReactive = this.options.kind === Kind.reactive;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
@@ -301,7 +301,7 @@ class Launch extends FieldVersion {
                     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.unsubscribeFromAllObservables();
+                this.unsubscribeFromAllTriggers();
                 if (isReactive)
                     obsolete.push(this);
                 else
@@ -309,11 +309,11 @@ class Launch extends FieldVersion {
                 const tran = this.transaction;
                 if (tran.changeset === changeset) {
                 }
-                else if (!tran.isFinished && this !== observable && !this.options.allowObsoleteToFinish)
+                else if (!tran.isFinished && this !== trigger && !this.options.allowObsoleteToFinish)
                     tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Dump.snapshot2(h, changeset, fk)} changed by T${changeset.id}[${changeset.hint}]`), null);
             }
             else if (Log.isOn && (Log.opt.obsolete || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.obsolete)))
-                Log.write(" ", "x", `${this.hint()} is not obsolete due to its own change to ${Dump.snapshot2(h, changeset, fk, observable)}`);
+                Log.write(" ", "x", `${this.hint()} is not obsolete due to its own change to ${Dump.snapshot2(h, changeset, fk, trigger)}`);
         }
     }
     relaunchIfNotUpToDate(now, nothrow) {
@@ -468,7 +468,7 @@ class Launch extends FieldVersion {
         for (const x of deferred)
             x.relaunchIfNotUpToDate(true, true);
     }
-    static markUsed(observable, ov, fk, h, kind, weak) {
+    static markUsed(trigger, ov, fk, h, kind, weak) {
         if (kind !== Kind.atomic) {
             const launch = Launch.current;
             if (launch && launch.options.kind !== Kind.atomic &&
@@ -477,8 +477,8 @@ class Launch extends FieldVersion {
                 if (ctx !== ov.changeset)
                     ctx.bumpBy(ov.changeset.timestamp);
                 const t = weak ? -1 : ctx.timestamp;
-                if (!launch.subscribeTo(observable, ov, fk, h, t))
-                    launch.markObsoleteDueTo(observable, fk, h.applied.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
+                if (!launch.subscribeTo(trigger, ov, fk, h, t))
+                    launch.markObsoleteDueTo(trigger, fk, h.applied.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
             }
         }
     }
@@ -534,7 +534,7 @@ class Launch extends FieldVersion {
                     if ((former.obsoleteSince === MAX_REVISION || former.obsoleteSince <= 0)) {
                         former.obsoleteDueTo = why;
                         former.obsoleteSince = timestamp;
-                        former.unsubscribeFromAllObservables();
+                        former.unsubscribeFromAllTriggers();
                     }
                     const formerSuccessor = former.successor;
                     if (formerSuccessor !== curr) {
@@ -552,15 +552,15 @@ class Launch extends FieldVersion {
             }
         }
         if (curr instanceof Launch) {
-            if (curr.changeset === ov.changeset && curr.observables !== undefined) {
+            if (curr.changeset === ov.changeset && curr.triggers !== undefined) {
                 if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                    curr.observables.forEach((info, v) => {
+                    curr.triggers.forEach((info, v) => {
                         if (info.usageCount > Mvcc.repetitiveUsageWarningThreshold)
                             Log.write("", "[!]", `${curr.hint()} uses ${info.memberHint} ${info.usageCount} times (consider remembering it in a local variable)`, 0, " *** WARNING ***");
                     });
                 }
                 if (unsubscribe)
-                    curr.unsubscribeFromAllObservables();
+                    curr.unsubscribeFromAllTriggers();
             }
         }
         else if (curr instanceof FieldVersion && curr.observers) {
@@ -592,50 +592,50 @@ class Launch extends FieldVersion {
         }
         Launch.queuedReactiveOperations = [];
     }
-    unsubscribeFromAllObservables() {
+    unsubscribeFromAllTriggers() {
         var _a;
-        (_a = this.observables) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
+        (_a = this.triggers) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
             var _a;
             value.observers.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}`);
         });
-        this.observables = undefined;
+        this.triggers = undefined;
     }
-    subscribeTo(observable, ov, fk, h, timestamp) {
+    subscribeTo(trigger, ov, fk, h, timestamp) {
         var _a, _b, _c;
         const parent = this.transaction.changeset.parent;
-        const ok = Launch.canSubscribeTo(observable, ov, parent, fk, h, timestamp);
+        const ok = Launch.canSubscribeTo(trigger, ov, parent, fk, h, timestamp);
         if (ok) {
             let times = 0;
             if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                const existing = this.observables.get(observable);
+                const existing = this.triggers.get(trigger);
                 times = existing ? existing.usageCount + 1 : 1;
             }
-            if (this.observables !== undefined) {
-                if (!observable.observers)
-                    observable.observers = new Set();
+            if (this.triggers !== undefined) {
+                if (!trigger.observers)
+                    trigger.observers = new Set();
                 const subscription = { memberHint: Dump.snapshot2(h, ov.changeset, fk), usageCount: times };
-                observable.observers.add(this);
-                this.observables.set(observable, subscription);
+                trigger.observers.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, observable)}${subscription.usageCount > 1 ? ` (${subscription.usageCount} times)` : ""}`);
+                    Log.write("║", "  ∞", `${this.hint()} is subscribed to ${Dump.snapshot2(h, ov.changeset, fk, trigger)}${subscription.usageCount > 1 ? ` (${subscription.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, observable)}`);
+                Log.write("║", "  x", `${this.hint()} is obsolete and is NOT subscribed to ${Dump.snapshot2(h, ov.changeset, fk, trigger)}`);
         }
         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, observable)}`);
+                Log.write("║", "  x", `${this.hint()} is NOT subscribed to already obsolete ${Dump.snapshot2(h, ov.changeset, fk, trigger)}`);
         }
         return ok;
     }
-    static canSubscribeTo(observable, ov, parent, fk, h, timestamp) {
+    static canSubscribeTo(trigger, ov, parent, fk, h, timestamp) {
         const parentSnapshot = parent ? parent.lookupObjectVersion(h, fk, false) : h.applied;
-        const observableParent = parentSnapshot.data[fk];
-        let result = observable === observableParent || (!ov.changeset.sealed && ov.former.objectVersion.data[fk] === observableParent);
+        const parentTrigger = parentSnapshot.data[fk];
+        let result = trigger === parentTrigger || (!ov.changeset.sealed && ov.former.objectVersion.data[fk] === parentTrigger);
         if (result && timestamp !== -1)
-            result = !(observable instanceof Launch && timestamp >= observable.obsoleteSince);
+            result = !(trigger instanceof Launch && timestamp >= trigger.obsoleteSince);
         return result;
     }
     static createOperation(h, fk, options) {

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

@@ -20,9 +20,9 @@ import { misuse } from "../util/Dbg.js";
 import { MergeList } from "../util/MergeList.js";
 import { emitLetters, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js";
 import { Isolation, Reentrance } from "../Options.js";
-import { ObservableObject } from "../core/Mvcc.js";
+import { TriggeringObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
-import { ReactiveSystem, options, unobservable, reactive, atomicRun, nonReactiveRun } from "../ReactiveSystem.js";
+import { ReactiveSystem, options, trigger, reactive, atomicRun, nonReactiveRun } from "../ReactiveSystem.js";
 export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
@@ -250,7 +250,7 @@ function invokeFinalizationUsingBasisChain(element, declaration) {
     else if (basis)
         invokeFinalizationUsingBasisChain(element, basis);
 }
-class ReactiveNodeContextImpl extends ObservableObject {
+class ReactiveNodeContextImpl extends TriggeringObject {
     constructor(variable, value) {
         super();
         this.next = undefined;
@@ -259,11 +259,11 @@ class ReactiveNodeContextImpl extends ObservableObject {
     }
 }
 __decorate([
-    unobservable,
+    trigger(false),
     __metadata("design:type", Object)
 ], ReactiveNodeContextImpl.prototype, "next", void 0);
 __decorate([
-    unobservable,
+    trigger(false),
     __metadata("design:type", ReactiveNodeVariable)
 ], ReactiveNodeContextImpl.prototype, "variable", void 0);
 class ReactiveNodeImpl extends ReactiveNode {

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

@@ -363,10 +363,10 @@ export class TransactionImpl extends Transaction {
                 if (observers) {
                     const migratedObservers = migrated.observers = new Set();
                     observers.forEach(o => {
-                        var _a, _b;
-                        const sub = o.observables.get(fvParent);
-                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fvParent);
-                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(migrated, sub);
+                        const conformingTriggers = o.triggers;
+                        const sub = conformingTriggers.get(fvParent);
+                        conformingTriggers.delete(fvParent);
+                        conformingTriggers.set(migrated, sub);
                         migratedObservers.add(o);
                     });
                     fvParent.observers = undefined;
@@ -377,24 +377,24 @@ export class TransactionImpl extends Transaction {
                     if (migratedObservers === undefined)
                         migratedObservers = migrated.observers = new Set();
                     observers.forEach(o => {
-                        var _a, _b;
-                        const sub = o.observables.get(fv);
-                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fv);
-                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(migrated, sub);
-                        migratedObservers === null || migratedObservers === void 0 ? void 0 : migratedObservers.add(o);
+                        const conformingTriggers = o.triggers;
+                        const sub = conformingTriggers.get(fv);
+                        conformingTriggers.delete(fv);
+                        conformingTriggers.set(migrated, sub);
+                        migratedObservers.add(o);
                     });
                     fv.observers = undefined;
                 }
-                const observables = fv.observables;
-                const migratedObservables = migrated.observables;
-                if (observables) {
-                    observables.forEach((s, o) => {
-                        var _a, _b;
-                        (_a = o.observers) === null || _a === void 0 ? void 0 : _a.delete(fv);
-                        (_b = o.observers) === null || _b === void 0 ? void 0 : _b.add(migrated);
-                        migratedObservables === null || migratedObservables === void 0 ? void 0 : migratedObservables.set(o, s);
+                const triggers = fv.triggers;
+                const migratedTriggers = migrated.triggers;
+                if (triggers) {
+                    triggers.forEach((s, o) => {
+                        const conformingObservers = o.observers;
+                        conformingObservers.delete(fv);
+                        conformingObservers.add(migrated);
+                        migratedTriggers.set(o, s);
                     });
-                    observables.clear();
+                    triggers.clear();
                 }
                 ovParent.data[fk] = migrated;
             }
@@ -403,24 +403,24 @@ export class TransactionImpl extends Transaction {
                 if (observers) {
                     const migratedObservers = migrated.observers = new Set();
                     observers.forEach(o => {
-                        var _a, _b;
-                        const sub = o.observables.get(fv);
-                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fv);
-                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(migrated, sub);
+                        const conformingTriggers = o.triggers;
+                        const sub = conformingTriggers.get(fv);
+                        conformingTriggers.delete(fv);
+                        conformingTriggers.set(migrated, sub);
                         migratedObservers.add(o);
                     });
                     fv.observers = undefined;
                 }
-                const observables = fv.observables;
-                const migratedObservables = migrated.observables;
-                if (observables) {
-                    observables.forEach((s, o) => {
-                        var _a, _b;
-                        (_a = o.observers) === null || _a === void 0 ? void 0 : _a.delete(fv);
-                        (_b = o.observers) === null || _b === void 0 ? void 0 : _b.add(migrated);
-                        migratedObservables === null || migratedObservables === void 0 ? void 0 : migratedObservables.set(o, s);
+                const triggers = fv.triggers;
+                const migratedTriggers = migrated.triggers;
+                if (triggers) {
+                    triggers.forEach((s, o) => {
+                        const conformingObservers = o.observers;
+                        conformingObservers.delete(fv);
+                        conformingObservers.add(migrated);
+                        migratedTriggers.set(o, s);
                     });
-                    observables.clear();
+                    triggers.clear();
                 }
                 ovParent.data[fk] = migrated;
             }
@@ -436,11 +436,11 @@ export class TransactionImpl extends Transaction {
                     if (fvParent.observers === undefined)
                         fvParent.observers = new Set();
                     observers.forEach(o => {
-                        var _a, _b, _c;
-                        const sub = o.observables.get(fv);
-                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fv);
-                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(fvParent, sub);
-                        (_c = fvParent.observers) === null || _c === void 0 ? void 0 : _c.add(o);
+                        const conformingTriggers = o.triggers;
+                        const sub = conformingTriggers.get(fv);
+                        conformingTriggers.delete(fv);
+                        conformingTriggers.set(fvParent, sub);
+                        fvParent.observers.add(o);
                     });
                 }
             }

package/package.json

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