reactronic 0.22.210 → 0.22.302

package/README.md

@@ -19,13 +19,13 @@ isolated data snapshot and then, once atomically applied, are
 **consistently propagated** to corresponding visual components for
 (re)rendering. All that is done in automatic, seamless, and fine-grained
 way, because reactronic **takes full care of tracking dependencies**
-between visual components (observers) and state (observable objects).
+between visual components (subscribers) and state (reactive objects).
 
 Transactional reactivity is based on four fundamental concepts:
 
-  - **Observable Objects** - a set of objects that store data of an
-    application (state);
-  - **Transaction** - a function that makes changes in observable
+  - **Reactive Objects** - a set of objects that store data of an
+    application (state) and maintain subscription lists;
+  - **Transaction** - a function that makes changes in reactive
     objects in transactional (atomic) way;
   - **Reaction** - a function that is executed automatically in
     response to changes made by a transaction;
@@ -39,11 +39,11 @@ Quick introduction and detailed description is below.
 
 ## Quick Introduction
 
-Here is an example of transactional reactive code with an observable
-object, transaction and reaction:
+Here is an example of transactional reactive code with
+reactive object, transaction and reaction:
 
 ``` typescript
-class Demo extends ObservableObject {
+class Demo extends ReactiveObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -70,7 +70,7 @@ to changes of these fields made by `saveContact` transaction.
 Here is an example of if cached value computed on-demand:
 
 ``` typescript
-class Demo extends ObservableObject {
+class Demo extends ReactiveObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -95,14 +95,14 @@ invalidated, thus causing execution of depending reaction
 `printContact`. Then `printContact` reaction causes `contact`
 re-computation on the first use.
 
-## Observable Objects
+## Reactive Objects
 
-Observable objects store data of an application. All such objects
+Reactive objects 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 ReactiveObject {
   url: string = "https://github.com/nezaboodka/reactronic"
   content: string = "transactional reactive state management"
   timestamp: Date = Date.now()
@@ -110,18 +110,18 @@ class MyModel extends ObservableObject {
 ```
 
 In the example above, the class `MyModel` is based on Reactronic's
-`ObservableObject` class and all its properties `url`, `content`,
+`ReactiveObject` class and all its properties `url`, `content`,
 and `timestamp` are hooked.
 
 ## Transaction
 
-Transaction is a function that makes changes in observable objects
+Transaction is a function that makes changes in reactive objects
 in transactional (atomic) way. Such a function is instrumented with hooks
 to provide transparent atomicity (by implicit context switching
 and isolation).
 
 ``` typescript
-class MyModel extends ObservableObject {
+class MyModel extends ReactiveObject {
   // ...
   @transaction
   async load(url: string): Promise<void> {
@@ -164,12 +164,12 @@ of asynchronous operations is fully completed.
 ## Reaction & Cache
 
 Reaction is an code block that is immediately called in response to
-changes made by a transaction in observable objects. Cache is a
+changes made by a transaction in reactive objects. Cache is a
 computed value having an associated function that is called
 on-demand to renew the value if it was marked as obsolete due to changes
 made by a transaction. Reactive and cached functions are
 instrumented with hooks to seamlessly subscribe to those
-observable objects and other cached functions (dependencies),
+reactive objects and other cached functions (dependencies),
 which are used during their execution.
 
 ``` tsx
@@ -223,14 +223,14 @@ function enqueues re-rendering request to React, which calls
 `render` function causing it to renew its cached value.
 
 In general case, all reactions and caches are automatically and
-immediately marked as obsolete when changes are made in those observable
+immediately marked as obsolete when changes are made in those reactive
 objects and cached functions 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 reactions/caches (observables and observers).
+all the reactive objects and reactions/caches.
 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 switching from the previous object version
@@ -292,11 +292,11 @@ NPM: `npm install reactronic`
 
 // Classes
 
-class ObservableObject { }
+class ReactiveObject { }
 
 // Decorators & Operators
 
-function unobservable(proto, prop) // field only
+function isnonreactive(proto, prop) // field only
 function transaction(proto, prop, pd) // method only
 function reaction(proto, prop, pd) // method only
 function cached(proto, prop, pd) // method only

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

@@ -1,5 +1,5 @@
-import { ObservableObject } from './impl/Hooks';
-export declare abstract class Buffer<T> extends ObservableObject {
+import { ReactiveObject } from './impl/Hooks';
+export declare abstract class Buffer<T> extends ReactiveObject {
     abstract readonly capacity: number;
     abstract readonly count: number;
     abstract put(...items: T[]): void;

package/build/dist/source/Buffer.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Buffer = void 0;
 const Hooks_1 = require("./impl/Hooks");
-class Buffer extends Hooks_1.ObservableObject {
+class Buffer extends Hooks_1.ReactiveObject {
     static create(hint, capacity) { throw new Error('not implemented'); }
 }
 exports.Buffer = Buffer;

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

@@ -11,7 +11,7 @@ export declare class Ref<T = any> {
     constructor(owner: any, name: string, index?: number);
     get value(): T;
     set value(value: T);
-    nonreactiveValue(): T;
+    nonreactive(): T;
     observe(): T;
     unobserve(): T;
     static to<O extends object = object>(owner: O): {

package/build/dist/source/Ref.js

@@ -21,7 +21,7 @@ class Ref {
         else
             this.owner[this.name][this.index] = value;
     }
-    nonreactiveValue() {
+    nonreactive() {
         return (0, Rx_1.nonreactive)(() => this.value);
     }
     observe() {

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

@@ -19,7 +19,7 @@ export declare class Rx {
 }
 export declare function nonreactive<T>(func: F<T>, ...args: any[]): T;
 export declare function sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
-export declare function unobservable(proto: object, prop: PropertyKey): any;
+export declare function isnonreactive(proto: object, prop: PropertyKey): any;
 export declare function transaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function reaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function cached(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;

package/build/dist/source/Rx.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.options = exports.cached = exports.reaction = exports.transaction = exports.unobservable = exports.sensitive = exports.nonreactive = exports.Rx = void 0;
+exports.options = exports.cached = exports.reaction = exports.transaction = exports.isnonreactive = exports.sensitive = exports.nonreactive = exports.Rx = void 0;
 const Dbg_1 = require("./util/Dbg");
 const Options_1 = require("./Options");
 const Data_1 = require("./impl/Data");
@@ -20,7 +20,7 @@ class Rx {
     static get loggingOptions() { return Dbg_1.Log.opt; }
     static setLoggingMode(isOn, options) { Dbg_1.Log.setMode(isOn, options); }
     static setLoggingHint(obj, name) { Hooks_1.Hooks.setHint(obj, name); }
-    static getLoggingHint(obj, full = false) { return Data_1.ObjectHolder.getHint(obj, full); }
+    static getLoggingHint(obj, full = false) { return Data_1.DataHolder.getHint(obj, full); }
     static setProfilingMode(isOn, options) { Hooks_1.Hooks.setProfilingMode(isOn, options); }
 }
 exports.Rx = Rx;
@@ -32,10 +32,10 @@ function sensitive(sensitivity, func, ...args) {
     return Hooks_1.Hooks.sensitive(sensitivity, func, ...args);
 }
 exports.sensitive = sensitive;
-function unobservable(proto, prop) {
+function isnonreactive(proto, prop) {
     return Hooks_1.Hooks.decorateData(false, proto, prop);
 }
-exports.unobservable = unobservable;
+exports.isnonreactive = isnonreactive;
 function transaction(proto, prop, pd) {
     const opts = { kind: Options_1.Kind.Transaction };
     return Hooks_1.Hooks.decorateOperation(true, transaction, opts, proto, prop, pd);

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

@@ -6,9 +6,9 @@ export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, Profi
 export { Worker } from './Worker';
 export { Controller } from './Controller';
 export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
-export { ObservableObject } from './impl/Hooks';
+export { ReactiveObject } from './impl/Hooks';
 export { Snapshot } from './impl/Snapshot';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, nonreactive, sensitive, unobservable, transaction, reaction, cached, options } from './Rx';
+export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';

package/build/dist/source/api.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.options = exports.cached = exports.reaction = exports.transaction = exports.unobservable = exports.sensitive = exports.nonreactive = exports.Rx = exports.Journal = exports.Monitor = exports.Transaction = exports.Snapshot = exports.ObservableObject = exports.ToggleRef = exports.Ref = exports.Controller = exports.LoggingLevel = exports.Reentrance = exports.Kind = exports.SealedSet = exports.SealedMap = exports.SealedArray = exports.pause = exports.all = void 0;
+exports.options = exports.cached = exports.reaction = exports.transaction = exports.isnonreactive = exports.sensitive = exports.nonreactive = exports.Rx = exports.Journal = exports.Monitor = exports.Transaction = exports.Snapshot = exports.ReactiveObject = exports.ToggleRef = exports.Ref = exports.Controller = exports.LoggingLevel = exports.Reentrance = exports.Kind = exports.SealedSet = exports.SealedMap = exports.SealedArray = exports.pause = exports.all = void 0;
 var Utils_1 = require("./util/Utils");
 Object.defineProperty(exports, "all", { enumerable: true, get: function () { return Utils_1.all; } });
 Object.defineProperty(exports, "pause", { enumerable: true, get: function () { return Utils_1.pause; } });
@@ -20,7 +20,7 @@ var Ref_1 = require("./Ref");
 Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return Ref_1.Ref; } });
 Object.defineProperty(exports, "ToggleRef", { enumerable: true, get: function () { return Ref_1.ToggleRef; } });
 var Hooks_1 = require("./impl/Hooks");
-Object.defineProperty(exports, "ObservableObject", { enumerable: true, get: function () { return Hooks_1.ObservableObject; } });
+Object.defineProperty(exports, "ReactiveObject", { enumerable: true, get: function () { return Hooks_1.ReactiveObject; } });
 var Snapshot_1 = require("./impl/Snapshot");
 Object.defineProperty(exports, "Snapshot", { enumerable: true, get: function () { return Snapshot_1.Snapshot; } });
 var Transaction_1 = require("./impl/Transaction");
@@ -33,7 +33,7 @@ var Rx_1 = require("./Rx");
 Object.defineProperty(exports, "Rx", { enumerable: true, get: function () { return Rx_1.Rx; } });
 Object.defineProperty(exports, "nonreactive", { enumerable: true, get: function () { return Rx_1.nonreactive; } });
 Object.defineProperty(exports, "sensitive", { enumerable: true, get: function () { return Rx_1.sensitive; } });
-Object.defineProperty(exports, "unobservable", { enumerable: true, get: function () { return Rx_1.unobservable; } });
+Object.defineProperty(exports, "isnonreactive", { enumerable: true, get: function () { return Rx_1.isnonreactive; } });
 Object.defineProperty(exports, "transaction", { enumerable: true, get: function () { return Rx_1.transaction; } });
 Object.defineProperty(exports, "reaction", { enumerable: true, get: function () { return Rx_1.reaction; } });
 Object.defineProperty(exports, "cached", { enumerable: true, get: function () { return Rx_1.cached; } });

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

@@ -5,54 +5,54 @@ export interface AbstractSnapshot {
     readonly timestamp: number;
     readonly sealed: boolean;
 }
-export declare class Observable {
-    value: any;
-    observers?: Set<Observer>;
+export declare class Subscription {
+    content: any;
+    subscribers?: Set<Subscriber>;
     get isOperation(): boolean;
     get originSnapshotId(): number | undefined;
-    constructor(value: any);
+    constructor(content: any);
 }
 export declare type StandaloneMode = boolean | 'isolated' | 'disposal';
-export interface Observer {
+export interface Subscriber {
     readonly order: number;
-    readonly observables: Map<Observable, ObservableInfo> | undefined;
+    readonly subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(observable: Observable, memberName: MemberName, snapshot: AbstractSnapshot, holder: ObjectHolder, outer: string, since: number, reactions: Observer[]): void;
+    markObsoleteDueTo(subscription: Subscription, memberName: MemberName, snapshot: AbstractSnapshot, holder: DataHolder, outer: string, since: number, reactions: Array<Subscriber>): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
 }
 export declare type MemberName = PropertyKey;
-export interface ObservableInfo {
+export interface SubscriptionInfo {
     readonly memberHint: string;
     readonly usageCount: number;
 }
-export declare class ObjectRevision {
+export declare class DataRevision {
     readonly snapshot: AbstractSnapshot;
     readonly former: {
-        revision: ObjectRevision;
+        revision: DataRevision;
     };
     readonly data: any;
     readonly changes: Set<MemberName>;
-    readonly conflicts: Map<MemberName, ObjectRevision>;
-    constructor(snapshot: AbstractSnapshot, former: ObjectRevision | undefined, data: object);
+    readonly conflicts: Map<MemberName, DataRevision>;
+    constructor(snapshot: AbstractSnapshot, former: DataRevision | undefined, data: object);
 }
-export declare class ObjectHolder {
+export declare class DataHolder {
     private static generator;
     readonly id: number;
-    readonly unobservable: any;
+    readonly data: any;
     readonly proxy: any;
-    head: ObjectRevision;
-    editing?: ObjectRevision;
+    head: DataRevision;
+    editing?: DataRevision;
     editors: number;
     hint: string;
-    constructor(unobservable: any, proxy: any, handler: ProxyHandler<ObjectHolder>, head: ObjectRevision, hint: string);
+    constructor(data: any, proxy: any, handler: ProxyHandler<DataHolder>, head: DataRevision, hint: string);
     static getHint(obj: object, full: boolean): string | undefined;
 }
-export interface Patch {
+export interface PatchSet {
     hint: string;
-    objects: Map<object, ObjectPatch>;
+    objects: Map<object, DataPatch>;
 }
-export interface ObjectPatch {
+export interface DataPatch {
     data: any;
     former: any;
 }

package/build/dist/source/impl/Data.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectHolder = exports.ObjectRevision = exports.Observable = exports.Meta = void 0;
+exports.DataHolder = exports.DataRevision = exports.Subscription = exports.Meta = void 0;
 const Dbg_1 = require("../util/Dbg");
 const Meta_1 = require("./Meta");
 var Meta_2 = require("./Meta");
 Object.defineProperty(exports, "Meta", { enumerable: true, get: function () { return Meta_2.Meta; } });
-class Observable {
-    constructor(value) { this.value = value; }
+class Subscription {
+    constructor(content) { this.content = content; }
     get isOperation() { return false; }
     get originSnapshotId() { return 0; }
 }
-exports.Observable = Observable;
-class ObjectRevision {
+exports.Subscription = Subscription;
+class DataRevision {
     constructor(snapshot, former, data) {
         this.snapshot = snapshot;
         this.former = { revision: former || this };
@@ -22,11 +22,11 @@ class ObjectRevision {
             Object.freeze(this);
     }
 }
-exports.ObjectRevision = ObjectRevision;
-class ObjectHolder {
-    constructor(unobservable, proxy, handler, head, hint) {
-        this.id = ++ObjectHolder.generator;
-        this.unobservable = unobservable;
+exports.DataRevision = DataRevision;
+class DataHolder {
+    constructor(data, proxy, handler, head, hint) {
+        this.id = ++DataHolder.generator;
+        this.data = data;
         this.proxy = proxy || new Proxy(this, handler);
         this.head = head;
         this.editing = undefined;
@@ -38,5 +38,5 @@ class ObjectHolder {
         return h !== undefined ? (full ? `${h.hint}#${h.id}` : h.hint) : undefined;
     }
 }
-exports.ObjectHolder = ObjectHolder;
-ObjectHolder.generator = 19;
+exports.DataHolder = DataHolder;
+DataHolder.generator = 19;

package/build/dist/source/impl/Hooks.d.ts

@@ -1,10 +1,10 @@
 import { F } from '../util/Utils';
 import { MemberOptions, Kind, Reentrance } from '../Options';
 import { LoggingOptions, ProfilingOptions } from '../Logging';
-import { MemberName, ObjectHolder, StandaloneMode } from './Data';
+import { MemberName, DataHolder, StandaloneMode } from './Data';
 import { Journal } from './Journal';
 import { Monitor } from './Monitor';
-export declare abstract class ObservableObject {
+export declare abstract class ReactiveObject {
     constructor();
     [Symbol.toStringTag](): string;
 }
@@ -24,27 +24,27 @@ export declare class OptionsImpl implements MemberOptions {
     static readonly INITIAL: Readonly<OptionsImpl>;
     constructor(getter: Function | undefined, setter: Function | undefined, existing: OptionsImpl, patch: Partial<OptionsImpl>, implicit: boolean);
 }
-export declare class Hooks implements ProxyHandler<ObjectHolder> {
+export declare class Hooks implements ProxyHandler<DataHolder> {
     static reactionsAutoStartDisabled: boolean;
     static repetitiveUsageWarningThreshold: number;
     static mainThreadBlockingWarningThreshold: number;
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
     static readonly proxy: Hooks;
-    getPrototypeOf(h: ObjectHolder): object | null;
-    get(h: ObjectHolder, m: MemberName, receiver: any): any;
-    set(h: ObjectHolder, m: MemberName, value: any, receiver: any): boolean;
-    has(h: ObjectHolder, m: MemberName): boolean;
-    getOwnPropertyDescriptor(h: ObjectHolder, m: MemberName): PropertyDescriptor | undefined;
-    ownKeys(h: ObjectHolder): Array<string | symbol>;
-    static decorateData(observable: boolean, proto: any, m: MemberName): any;
+    getPrototypeOf(h: DataHolder): object | null;
+    get(h: DataHolder, m: MemberName, receiver: any): any;
+    set(h: DataHolder, m: MemberName, value: any, receiver: any): boolean;
+    has(h: DataHolder, m: MemberName): boolean;
+    getOwnPropertyDescriptor(h: DataHolder, m: MemberName): PropertyDescriptor | undefined;
+    ownKeys(h: DataHolder): Array<string | symbol>;
+    static decorateData(reactive: boolean, proto: any, m: MemberName): any;
     static decorateOperation(implicit: boolean, decorator: Function, options: Partial<MemberOptions>, proto: any, member: MemberName, pd: PropertyDescriptor | undefined): any;
     static decorateOperationParametrized(decorator: Function, options: Partial<MemberOptions>): F<any>;
-    static acquireObjectHolder(obj: any): ObjectHolder;
-    static createObjectHolderForObservableObject(proto: any, unobservable: any, blank: any, hint: string): ObjectHolder;
+    static acquireDataHolder(obj: any): DataHolder;
+    static createDataHolderForReactiveObject(proto: any, data: any, blank: any, hint: string): DataHolder;
     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;
-    static createOperation: (h: ObjectHolder, m: MemberName, options: OptionsImpl) => F<any>;
+    static createOperation: (h: DataHolder, m: MemberName, options: OptionsImpl) => F<any>;
     static rememberOperationOptions: (proto: any, m: MemberName, getter: Function | undefined, setter: Function | undefined, enumerable: boolean, configurable: boolean, options: Partial<MemberOptions>, implicit: boolean) => OptionsImpl;
 }

package/build/dist/source/impl/Hooks.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hooks = exports.OptionsImpl = exports.ObservableObject = void 0;
+exports.Hooks = exports.OptionsImpl = exports.ReactiveObject = void 0;
 const Utils_1 = require("../util/Utils");
 const Dbg_1 = require("../util/Dbg");
 const Options_1 = require("../Options");
 const Data_1 = require("./Data");
 const Snapshot_1 = require("./Snapshot");
-class ObservableObject {
+class ReactiveObject {
     constructor() {
         const proto = new.target.prototype;
         const initial = Data_1.Meta.getFrom(proto, Data_1.Meta.Initial);
-        const h = Hooks.createObjectHolderForObservableObject(proto, this, initial, new.target.name);
+        const h = Hooks.createDataHolderForReactiveObject(proto, this, initial, new.target.name);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -18,7 +18,7 @@ class ObservableObject {
         return Snapshot_1.Dump.obj(h);
     }
 }
-exports.ObservableObject = ObservableObject;
+exports.ReactiveObject = ReactiveObject;
 const DEFAULT_OPTIONS = Object.freeze({
     kind: Options_1.Kind.Plain,
     standalone: false,
@@ -56,49 +56,49 @@ function merge(def, existing, patch, implicit) {
 }
 class Hooks {
     getPrototypeOf(h) {
-        return Reflect.getPrototypeOf(h.unobservable);
+        return Reflect.getPrototypeOf(h.data);
     }
     get(h, m, receiver) {
         let result;
         const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
         result = r.data[m];
-        if (result instanceof Data_1.Observable && !result.isOperation) {
+        if (result instanceof Data_1.Subscription && !result.isOperation) {
             Snapshot_1.Snapshot.markUsed(result, r, m, h, Options_1.Kind.Plain, false);
-            result = result.value;
+            result = result.content;
         }
         else if (m === Data_1.Meta.Holder) {
         }
         else
-            result = Reflect.get(h.unobservable, m, receiver);
+            result = Reflect.get(h.data, m, receiver);
         return result;
     }
     set(h, m, value, receiver) {
         const r = Snapshot_1.Snapshot.edit().getEditableRevision(h, m, value);
         if (r !== Snapshot_1.ROOT_REV) {
             let curr = r.data[m];
-            if (curr !== undefined || (r.former.revision.snapshot === Snapshot_1.ROOT_REV.snapshot && (m in h.unobservable) === false)) {
-                if (curr === undefined || curr.value !== value || Hooks.sensitivity) {
-                    const old = curr === null || curr === void 0 ? void 0 : curr.value;
+            if (curr !== undefined || (r.former.revision.snapshot === Snapshot_1.ROOT_REV.snapshot && (m in h.data) === false)) {
+                if (curr === undefined || curr.content !== value || Hooks.sensitivity) {
+                    const existing = curr === null || curr === void 0 ? void 0 : curr.content;
                     if (r.former.revision.data[m] === curr) {
-                        curr = r.data[m] = new Data_1.Observable(value);
-                        Snapshot_1.Snapshot.markEdited(old, value, true, r, m, h);
+                        curr = r.data[m] = new Data_1.Subscription(value);
+                        Snapshot_1.Snapshot.markEdited(existing, value, true, r, m, h);
                     }
                     else {
-                        curr.value = value;
-                        Snapshot_1.Snapshot.markEdited(old, value, true, r, m, h);
+                        curr.content = value;
+                        Snapshot_1.Snapshot.markEdited(existing, value, true, r, m, h);
                     }
                 }
             }
             else
-                Reflect.set(h.unobservable, m, value, receiver);
+                Reflect.set(h.data, m, value, receiver);
         }
         else
-            h.unobservable[m] = value;
+            h.data[m] = value;
         return true;
     }
     has(h, m) {
         const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
-        return m in r.data || m in h.unobservable;
+        return m in r.data || m in h.data;
     }
     getOwnPropertyDescriptor(h, m) {
         const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
@@ -112,19 +112,19 @@ class Hooks {
         const result = [];
         for (const m of Object.getOwnPropertyNames(r.data)) {
             const value = r.data[m];
-            if (!(value instanceof Data_1.Observable) || !value.isOperation)
+            if (!(value instanceof Data_1.Subscription) || !value.isOperation)
                 result.push(m);
         }
         return result;
     }
-    static decorateData(observable, proto, m) {
-        if (observable) {
+    static decorateData(reactive, proto, m) {
+        if (reactive) {
             const get = function () {
-                const h = Hooks.acquireObjectHolder(this);
+                const h = Hooks.acquireDataHolder(this);
                 return Hooks.proxy.get(h, m, this);
             };
             const set = function (value) {
-                const h = Hooks.acquireObjectHolder(this);
+                const h = Hooks.acquireDataHolder(this);
                 return Hooks.proxy.set(h, m, value, this);
             };
             const enumerable = true;
@@ -132,7 +132,7 @@ class Hooks {
             return Object.defineProperty(proto, m, { get, set, enumerable, configurable });
         }
         else
-            Data_1.Meta.acquire(proto, Data_1.Meta.Initial)[m] = Data_1.Meta.Unobservable;
+            Data_1.Meta.acquire(proto, Data_1.Meta.Initial)[m] = Data_1.Meta.Nonreactive;
     }
     static decorateOperation(implicit, decorator, options, proto, member, pd) {
         var _a, _b, _c, _d;
@@ -143,18 +143,18 @@ class Hooks {
         const opts = Hooks.rememberOperationOptions(proto, member, (_c = pd.value) !== null && _c !== void 0 ? _c : pd.get, (_d = pd.value) !== null && _d !== void 0 ? _d : pd.set, true, configurable, options, implicit);
         if (opts.getter === opts.setter) {
             const bootstrap = function () {
-                const h = Hooks.acquireObjectHolder(this);
+                const h = Hooks.acquireDataHolder(this);
                 const operation = Hooks.createOperation(h, member, opts);
-                Object.defineProperty(h.unobservable, member, { value: operation, enumerable, configurable });
+                Object.defineProperty(h.data, member, { value: operation, enumerable, configurable });
                 return operation;
             };
             return Object.defineProperty(proto, member, { get: bootstrap, enumerable, configurable: true });
         }
         else if (opts.setter === Utils_1.UNDEF) {
             const bootstrap = function () {
-                const h = Hooks.acquireObjectHolder(this);
+                const h = Hooks.acquireDataHolder(this);
                 const operation = Hooks.createOperation(h, member, opts);
-                Object.defineProperty(h.unobservable, member, { get: operation, enumerable, configurable });
+                Object.defineProperty(h.data, member, { get: operation, enumerable, configurable });
                 return operation.call(this);
             };
             return Object.defineProperty(proto, member, { get: bootstrap, enumerable, configurable: true });
@@ -167,22 +167,22 @@ class Hooks {
             return Hooks.decorateOperation(false, decorator, options, proto, prop, pd);
         };
     }
-    static acquireObjectHolder(obj) {
+    static acquireDataHolder(obj) {
         let h = obj[Data_1.Meta.Holder];
         if (!h) {
             if (obj !== Object(obj) || Array.isArray(obj))
                 throw (0, Dbg_1.misuse)('only objects can be reactive');
             const initial = Data_1.Meta.getFrom(Object.getPrototypeOf(obj), Data_1.Meta.Initial);
-            const rev = new Data_1.ObjectRevision(Snapshot_1.ROOT_REV.snapshot, Snapshot_1.ROOT_REV, Object.assign({}, initial));
+            const rev = new Data_1.DataRevision(Snapshot_1.ROOT_REV.snapshot, Snapshot_1.ROOT_REV, Object.assign({}, initial));
             Data_1.Meta.set(rev.data, Data_1.Meta.Holder, h);
-            h = new Data_1.ObjectHolder(obj, obj, Hooks.proxy, rev, obj.constructor.name);
+            h = new Data_1.DataHolder(obj, obj, Hooks.proxy, rev, obj.constructor.name);
             Data_1.Meta.set(obj, Data_1.Meta.Holder, h);
         }
         return h;
     }
-    static createObjectHolderForObservableObject(proto, unobservable, blank, hint) {
+    static createDataHolderForReactiveObject(proto, data, blank, hint) {
         const ctx = Snapshot_1.Snapshot.edit();
-        const h = new Data_1.ObjectHolder(unobservable, undefined, Hooks.proxy, Snapshot_1.ROOT_REV, hint);
+        const h = new Data_1.DataHolder(data, undefined, Hooks.proxy, Snapshot_1.ROOT_REV, hint);
         ctx.getEditableRevision(h, Data_1.Meta.Holder, blank);
         if (!Hooks.reactionsAutoStartDisabled)
             for (const m in Data_1.Meta.getFrom(proto, Data_1.Meta.Reactions))
@@ -215,7 +215,7 @@ class Hooks {
     }
     static setHint(obj, hint) {
         if (hint) {
-            const h = Hooks.acquireObjectHolder(obj);
+            const h = Hooks.acquireDataHolder(obj);
             h.hint = hint;
         }
         return obj;

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

@@ -1,14 +1,14 @@
-import { ObservableObject } from './Hooks';
-import { ObjectHolder, ObjectRevision, Patch } from './Data';
-export declare type Saver = (patch: Patch) => Promise<void>;
-export declare abstract class Journal extends ObservableObject {
+import { ReactiveObject } from './Hooks';
+import { DataHolder, DataRevision, PatchSet } from './Data';
+export declare type Saver = (patch: PatchSet) => Promise<void>;
+export declare abstract class Journal extends ReactiveObject {
     abstract capacity: number;
-    abstract readonly edits: ReadonlyArray<Patch>;
-    abstract readonly unsaved: Patch;
+    abstract readonly edits: ReadonlyArray<PatchSet>;
+    abstract readonly unsaved: PatchSet;
     abstract readonly canUndo: boolean;
     abstract readonly canRedo: boolean;
-    abstract edited(patch: Patch): void;
-    abstract saved(patch: Patch): void;
+    abstract edited(patch: PatchSet): void;
+    abstract saved(patch: PatchSet): void;
     abstract undo(count?: number): void;
     abstract redo(count?: number): void;
     static create(): Journal;
@@ -20,15 +20,15 @@ export declare class JournalImpl extends Journal {
     private _position;
     get capacity(): number;
     set capacity(value: number);
-    get edits(): ReadonlyArray<Patch>;
-    get unsaved(): Patch;
+    get edits(): ReadonlyArray<PatchSet>;
+    get unsaved(): PatchSet;
     get canUndo(): boolean;
     get canRedo(): boolean;
-    edited(p: Patch): void;
-    saved(patch: Patch): void;
+    edited(p: PatchSet): void;
+    saved(patch: PatchSet): void;
     undo(count?: number): void;
     redo(count?: number): void;
-    static buildPatch(hint: string, changeset: Map<ObjectHolder, ObjectRevision>): Patch;
-    static applyPatch(patch: Patch, undoing: boolean): void;
-    mergePatchToUnsaved(patch: Patch, undoing: boolean): void;
+    static buildPatch(hint: string, changeset: Map<DataHolder, DataRevision>): PatchSet;
+    static applyPatch(patch: PatchSet, undoing: boolean): void;
+    mergePatchToUnsaved(patch: PatchSet, undoing: boolean): void;
 }

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

@@ -6,7 +6,7 @@ const Data_1 = require("./Data");
 const Snapshot_1 = require("./Snapshot");
 const Transaction_1 = require("./Transaction");
 const Sealant_1 = require("../util/Sealant");
-class Journal extends Hooks_1.ObservableObject {
+class Journal extends Hooks_1.ReactiveObject {
     static create() { return new JournalImpl(); }
 }
 exports.Journal = Journal;
@@ -87,17 +87,17 @@ class JournalImpl extends Journal {
     }
     static applyPatch(patch, undoing) {
         const ctx = Snapshot_1.Snapshot.edit();
-        patch.objects.forEach((op, obj) => {
+        patch.objects.forEach((dp, obj) => {
             const h = Data_1.Meta.get(obj, Data_1.Meta.Holder);
-            const data = undoing ? op.former : op.data;
+            const data = undoing ? dp.former : dp.data;
             if (data[Data_1.Meta.Disposed] === undefined) {
                 for (const m in data) {
                     const value = data[m];
                     const r = ctx.getEditableRevision(h, m, value);
                     if (r.snapshot === ctx) {
-                        r.data[m] = new Data_1.Observable(value);
-                        const v = r.former.revision.data[m];
-                        Snapshot_1.Snapshot.markEdited(v, value, v !== value, r, m, h);
+                        r.data[m] = new Data_1.Subscription(value);
+                        const existing = r.former.revision.data[m];
+                        Snapshot_1.Snapshot.markEdited(existing, value, existing !== value, r, m, h);
                     }
                 }
             }
@@ -107,12 +107,12 @@ class JournalImpl extends Journal {
     }
     mergePatchToUnsaved(patch, undoing) {
         const unsaved = this._unsaved;
-        patch.objects.forEach((op, obj) => {
+        patch.objects.forEach((dp, obj) => {
             let merged = unsaved.objects.get(obj);
             if (!merged)
                 unsaved.objects.set(obj, merged = { data: {}, former: {} });
-            const data = undoing ? op.former : op.data;
-            const former = undoing ? op.data : op.former;
+            const data = undoing ? dp.former : dp.data;
+            const former = undoing ? dp.data : dp.former;
             for (const m in data) {
                 const value = data[m];
                 if (value !== merged.former[m]) {
@@ -131,8 +131,8 @@ class JournalImpl extends Journal {
     }
 }
 exports.JournalImpl = JournalImpl;
-function unseal(observable) {
-    const result = observable.value;
+function unseal(subscription) {
+    const result = subscription.content;
     const createCopy = result === null || result === void 0 ? void 0 : result[Sealant_1.Sealant.CreateCopy];
     return createCopy !== undefined ? createCopy.call(result) : result;
 }

package/build/dist/source/impl/Meta.d.ts

@@ -4,7 +4,7 @@ export declare abstract class Meta {
     static readonly Disposed: unique symbol;
     static readonly Initial: unique symbol;
     static readonly Reactions: unique symbol;
-    static readonly Unobservable: unique symbol;
+    static readonly Nonreactive: unique symbol;
     static readonly Undefined: unique symbol;
     static get<T>(obj: any, sym: symbol): T;
     static set(obj: any, sym: symbol, value: any): any;

package/build/dist/source/impl/Meta.js

@@ -29,5 +29,5 @@ Meta.Controller = Symbol('rxController');
 Meta.Disposed = Symbol('rxDisposed');
 Meta.Initial = Symbol('rxInitial');
 Meta.Reactions = Symbol('rxReactions');
-Meta.Unobservable = Symbol('rxUnobservable');
+Meta.Nonreactive = Symbol('rxNonreactive');
 Meta.Undefined = Symbol('rxUndefined');

package/build/dist/source/impl/Monitor.d.ts

@@ -1,6 +1,6 @@
 import { Worker } from '../Worker';
-import { ObservableObject } from './Hooks';
-export declare abstract class Monitor extends ObservableObject {
+import { ReactiveObject } from './Hooks';
+export declare abstract class Monitor extends ReactiveObject {
     abstract readonly isActive: boolean;
     abstract readonly counter: number;
     abstract readonly workers: ReadonlySet<Worker>;

package/build/dist/source/impl/Monitor.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MonitorImpl = exports.Monitor = void 0;
 const Hooks_1 = require("./Hooks");
 const Transaction_1 = require("./Transaction");
-class Monitor extends Hooks_1.ObservableObject {
+class Monitor extends Hooks_1.ReactiveObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return MonitorImpl.create(hint, activationDelay, deactivationDelay, durationResolution);
     }

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

@@ -1,11 +1,11 @@
 import { F } from '../util/Utils';
 import { MemberOptions } from '../Options';
 import { Controller } from '../Controller';
-import { MemberName, ObjectHolder, Observable, Observer, ObservableInfo, AbstractSnapshot } from './Data';
+import { MemberName, DataHolder, Subscription, Subscriber, SubscriptionInfo, AbstractSnapshot } from './Data';
 import { Transaction } from './Transaction';
 import { OptionsImpl } from './Hooks';
 export declare class OperationController extends Controller<any> {
-    readonly ownHolder: ObjectHolder;
+    readonly ownHolder: DataHolder;
     readonly memberName: MemberName;
     configure(options: Partial<MemberOptions>): MemberOptions;
     get options(): MemberOptions;
@@ -17,7 +17,7 @@ export declare class OperationController extends Controller<any> {
     get isUpToDate(): boolean;
     markObsolete(): void;
     pullLastResult(args?: any[]): any;
-    constructor(ownHolder: ObjectHolder, memberName: MemberName);
+    constructor(ownHolder: DataHolder, memberName: MemberName);
     useOrRun(weak: boolean, args: any[] | undefined): Operation;
     static of(method: F<any>): Controller<any>;
     static configureImpl(self: OperationController | undefined, options: Partial<MemberOptions>): MemberOptions;
@@ -32,15 +32,15 @@ export declare class OperationController extends Controller<any> {
     private run;
     private static markObsolete;
 }
-declare class Operation extends Observable implements Observer {
+declare class Operation extends Subscription implements Subscriber {
     static current?: Operation;
-    static queuedReactions: Array<Observer>;
+    static queuedReactions: Array<Subscriber>;
     static deferredReactions: Array<Operation>;
     readonly margin: number;
     readonly transaction: Transaction;
     readonly controller: OperationController;
     readonly snapshot: AbstractSnapshot;
-    observables: Map<Observable, ObservableInfo> | undefined;
+    subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
     options: OptionsImpl;
     cause: string | undefined;
     args: any[];
@@ -61,7 +61,7 @@ declare class Operation extends Observable implements Observer {
     dependencies(): string[];
     wrap<T>(func: F<T>): F<T>;
     run(proxy: any, args: any[] | undefined): void;
-    markObsoleteDueTo(observable: Observable, memberName: MemberName, snapshot: AbstractSnapshot, holder: ObjectHolder, outer: string, since: number, reactions: Observer[]): void;
+    markObsoleteDueTo(subscription: Subscription, memberName: MemberName, snapshot: AbstractSnapshot, holder: DataHolder, outer: string, since: number, reactions: Subscriber[]): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
     isNotUpToDate(): boolean;
     reenterOver(head: Operation): this;
@@ -81,7 +81,7 @@ declare class Operation extends Observable implements Observer {
     private static propagateMemberChangeThroughSubscriptions;
     private static enqueueReactionsToRun;
     private static runQueuedReactionsLoop;
-    private unsubscribeFromAllObservables;
+    private unsubscribeFromAllSubscriptions;
     private subscribeTo;
     private static canSubscribe;
     private static createOperation;

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

@@ -12,7 +12,7 @@ const Hooks_1 = require("./Hooks");
 const Journal_1 = require("./Journal");
 const BOOT_ARGS = [];
 const BOOT_CAUSE = '<boot>';
-const ROOT_HOLDER = new Data_1.ObjectHolder(undefined, undefined, Hooks_1.Hooks.proxy, Snapshot_1.ROOT_REV, '<root>');
+const ROOT_HOLDER = new Data_1.DataHolder(undefined, undefined, Hooks_1.Hooks.proxy, Snapshot_1.ROOT_REV, '<root>');
 class OperationController extends Controller_1.Controller {
     constructor(ownHolder, memberName) {
         super();
@@ -21,14 +21,14 @@ class OperationController extends Controller_1.Controller {
     }
     configure(options) { return OperationController.configureImpl(this, options); }
     get options() { return this.peek(undefined).operation.options; }
-    get nonreactive() { return this.peek(undefined).operation.value; }
+    get nonreactive() { return this.peek(undefined).operation.content; }
     get args() { return this.use().operation.args; }
-    get result() { return this.useOrRun(true, undefined).value; }
+    get result() { return this.useOrRun(true, undefined).content; }
     get error() { return this.use().operation.error; }
     get stamp() { return this.use().revision.snapshot.timestamp; }
     get isUpToDate() { return this.use().isUpToDate; }
     markObsolete() { Transaction_1.Transaction.run({ hint: Dbg_1.Log.isOn ? `markObsolete(${Snapshot_1.Dump.obj(this.ownHolder, this.memberName)})` : 'markObsolete()' }, OperationController.markObsolete, this); }
-    pullLastResult(args) { return this.useOrRun(true, args).value; }
+    pullLastResult(args) { return this.useOrRun(true, args).content; }
     useOrRun(weak, args) {
         var _a;
         let oc = this.peek(args);
@@ -204,14 +204,14 @@ class OperationController extends Controller_1.Controller {
     }
 }
 exports.OperationController = OperationController;
-class Operation extends Data_1.Observable {
+class Operation extends Data_1.Subscription {
     constructor(controller, snapshot, former) {
         super(undefined);
         this.margin = Operation.current ? Operation.current.margin + 1 : 1;
         this.transaction = Transaction_1.Transaction.current;
         this.controller = controller;
         this.snapshot = snapshot;
-        this.observables = new Map();
+        this.subscriptions = new Map();
         if (former instanceof Operation) {
             this.options = former.options;
             this.args = former.args;
@@ -274,14 +274,14 @@ class Operation extends Data_1.Observable {
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(observable, memberName, snapshot, holder, outer, since, reactions) {
+    markObsoleteDueTo(subscription, memberName, snapshot, holder, outer, since, reactions) {
         var _a, _b, _c;
-        if (this.observables !== undefined) {
-            const skip = !observable.isOperation &&
+        if (this.subscriptions !== undefined) {
+            const skip = !subscription.isOperation &&
                 snapshot === this.snapshot;
             if (!skip) {
-                const why = `${Snapshot_1.Dump.rev2(holder, snapshot, memberName, observable)}    <<    ${outer}`;
-                this.unsubscribeFromAllObservables();
+                const why = `${Snapshot_1.Dump.rev2(holder, snapshot, memberName, subscription)}    <<    ${outer}`;
+                this.unsubscribeFromAllSubscriptions();
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
                 const isReaction = this.options.kind === Options_1.Kind.Reaction;
@@ -292,11 +292,11 @@ class Operation extends Data_1.Observable {
                 if (isReaction)
                     reactions.push(this);
                 else
-                    (_b = this.observers) === null || _b === void 0 ? void 0 : _b.forEach(c => c.markObsoleteDueTo(this, this.controller.memberName, this.snapshot, this.controller.ownHolder, why, since, reactions));
+                    (_b = this.subscribers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.controller.memberName, this.snapshot, this.controller.ownHolder, why, since, reactions));
                 const tran = this.transaction;
                 if (tran.snapshot === snapshot) {
                 }
-                else if (!tran.isFinished && this !== observable)
+                else if (!tran.isFinished && this !== subscription)
                     tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Snapshot_1.Dump.rev2(holder, snapshot, memberName)} changed by T${snapshot.id}[${snapshot.hint}]`), null);
             }
             else if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.obsolete || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.obsolete)))
@@ -390,7 +390,7 @@ class Operation extends Data_1.Observable {
     leaveOrAsync() {
         if (this.result instanceof Promise) {
             this.result = this.result.then(value => {
-                this.value = value;
+                this.content = value;
                 this.leave(false, '  ⚐', '- finished  ', ' OK ──┘');
                 return value;
             }, error => {
@@ -406,7 +406,7 @@ class Operation extends Data_1.Observable {
             }
         }
         else {
-            this.value = this.result;
+            this.content = this.result;
             this.leave(true, '_/', '- leave');
         }
     }
@@ -453,7 +453,7 @@ class Operation extends Data_1.Observable {
         for (const x of reactions)
             x.runIfNotUpToDate(true, true);
     }
-    static markUsed(observable, r, m, h, kind, weak) {
+    static markUsed(subscription, r, m, h, kind, weak) {
         if (kind !== Options_1.Kind.Transaction) {
             const op = Operation.current;
             if (op && op.options.kind !== Options_1.Kind.Transaction &&
@@ -462,8 +462,8 @@ class Operation extends Data_1.Observable {
                 if (ctx !== r.snapshot)
                     ctx.bumpBy(r.snapshot.timestamp);
                 const t = weak ? -1 : ctx.timestamp;
-                if (!op.subscribeTo(observable, r, m, h, t))
-                    op.markObsoleteDueTo(observable, m, r.snapshot, h, BOOT_CAUSE, ctx.timestamp, ctx.reactions);
+                if (!op.subscribeTo(subscription, r, m, h, t))
+                    op.markObsoleteDueTo(subscription, m, r.snapshot, h, BOOT_CAUSE, ctx.timestamp, ctx.reactions);
             }
         }
     }
@@ -500,13 +500,13 @@ class Operation extends Data_1.Observable {
         const curr = r.data[m];
         if (reactions) {
             const former = r.former.revision.data[m];
-            if (former !== undefined && former instanceof Data_1.Observable) {
+            if (former !== undefined && former instanceof Data_1.Subscription) {
                 const why = `T${r.snapshot.id}[${r.snapshot.hint}]`;
                 if (former instanceof Operation) {
                     if ((former.obsoleteSince === Snapshot_1.MAX_TIMESTAMP || former.obsoleteSince <= 0)) {
                         former.obsoleteDueTo = why;
                         former.obsoleteSince = timestamp;
-                        former.unsubscribeFromAllObservables();
+                        former.unsubscribeFromAllSubscriptions();
                     }
                     const formerSuccessor = former.successor;
                     if (formerSuccessor !== curr) {
@@ -516,22 +516,22 @@ class Operation extends Data_1.Observable {
                     else
                         former.successor = undefined;
                 }
-                (_a = former.observers) === null || _a === void 0 ? void 0 : _a.forEach(c => c.markObsoleteDueTo(former, m, r.snapshot, h, why, timestamp, reactions));
+                (_a = former.subscribers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, r.snapshot, h, why, timestamp, reactions));
             }
         }
         if (curr instanceof Operation) {
-            if (curr.snapshot === r.snapshot && curr.observables !== undefined) {
+            if (curr.snapshot === r.snapshot && curr.subscriptions !== undefined) {
                 if (Hooks_1.Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                    curr.observables.forEach((info, v) => {
+                    curr.subscriptions.forEach((info, v) => {
                         if (info.usageCount > Hooks_1.Hooks.repetitiveUsageWarningThreshold)
                             Dbg_1.Log.write('', '[!]', `${curr.hint()} uses ${info.memberHint} ${info.usageCount} times (consider remembering it in a local variable)`, 0, ' *** WARNING ***');
                     });
                 }
                 if (unsubscribe)
-                    curr.unsubscribeFromAllObservables();
+                    curr.unsubscribeFromAllSubscriptions();
             }
         }
-        else if (curr instanceof Data_1.Observable && curr.observers) {
+        else if (curr instanceof Data_1.Subscription && curr.subscribers) {
         }
     }
     static enqueueReactionsToRun(reactions) {
@@ -552,31 +552,31 @@ class Operation extends Data_1.Observable {
         }
         Operation.queuedReactions = [];
     }
-    unsubscribeFromAllObservables() {
+    unsubscribeFromAllSubscriptions() {
         var _a;
-        (_a = this.observables) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
+        (_a = this.subscriptions) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
             var _a;
-            value.observers.delete(this);
+            value.subscribers.delete(this);
             if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
                 Dbg_1.Log.write(Dbg_1.Log.opt.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', '-', `${this.hint()} is unsubscribed from ${info.memberHint}`);
         });
-        this.observables = undefined;
+        this.subscriptions = undefined;
     }
-    subscribeTo(observable, r, m, h, timestamp) {
+    subscribeTo(subscription, r, m, h, timestamp) {
         var _a, _b, _c;
-        const ok = Operation.canSubscribe(observable, r, m, h, timestamp);
+        const ok = Operation.canSubscribe(subscription, r, m, h, timestamp);
         if (ok) {
             let times = 0;
             if (Hooks_1.Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                const existing = this.observables.get(observable);
+                const existing = this.subscriptions.get(subscription);
                 times = existing ? existing.usageCount + 1 : 1;
             }
-            if (this.observables !== undefined) {
-                if (!observable.observers)
-                    observable.observers = new Set();
+            if (this.subscriptions !== undefined) {
+                if (!subscription.subscribers)
+                    subscription.subscribers = new Set();
                 const info = { memberHint: Snapshot_1.Dump.rev2(h, r.snapshot, m), usageCount: times };
-                observable.observers.add(this);
-                this.observables.set(observable, info);
+                subscription.subscribers.add(this);
+                this.subscriptions.set(subscription, info);
                 if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
                     Dbg_1.Log.write('║', '  ∞ ', `${this.hint()} is subscribed to ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}${info.usageCount > 1 ? ` (${info.usageCount} times)` : ''}`);
             }
@@ -589,10 +589,10 @@ class Operation extends Data_1.Observable {
         }
         return ok;
     }
-    static canSubscribe(observable, r, m, h, timestamp) {
-        let result = !r.snapshot.sealed || observable === h.head.data[m];
+    static canSubscribe(subscription, r, m, h, timestamp) {
+        let result = !r.snapshot.sealed || subscription === h.head.data[m];
         if (result && timestamp !== -1)
-            result = !(observable instanceof Operation && timestamp >= observable.obsoleteSince);
+            result = !(subscription instanceof Operation && timestamp >= subscription.obsoleteSince);
         return result;
     }
     static createOperation(h, m, options) {

package/build/dist/source/impl/Snapshot.d.ts

@@ -1,5 +1,5 @@
 import { Kind, SnapshotOptions } from '../Options';
-import { AbstractSnapshot, ObjectRevision, MemberName, ObjectHolder, Observable, Observer } from './Data';
+import { AbstractSnapshot, DataRevision, MemberName, DataHolder, Subscription, Subscriber } from './Data';
 export declare const MAX_TIMESTAMP: number;
 export declare const UNDEFINED_TIMESTAMP: number;
 export declare class Snapshot implements AbstractSnapshot {
@@ -9,52 +9,52 @@ export declare class Snapshot implements AbstractSnapshot {
     private static oldest;
     static garbageCollectionSummaryInterval: number;
     static lastGarbageCollectionSummaryTimestamp: number;
-    static totalObjectHolderCount: number;
-    static totalObjectRevisionCount: number;
+    static totalHolderCount: number;
+    static totalRevisionCount: number;
     readonly id: number;
     readonly options: SnapshotOptions;
     get hint(): string;
     get timestamp(): number;
     private stamp;
     private bumper;
-    changeset: Map<ObjectHolder, ObjectRevision>;
-    reactions: Observer[];
+    changeset: Map<DataHolder, DataRevision>;
+    reactions: Subscriber[];
     sealed: boolean;
     constructor(options: SnapshotOptions | null);
     static current: () => Snapshot;
     static edit: () => Snapshot;
-    static markUsed: (observable: Observable, r: ObjectRevision, m: MemberName, h: ObjectHolder, kind: Kind, weak: boolean) => void;
-    static markEdited: (oldValue: any, newValue: any, edited: boolean, r: ObjectRevision, m: MemberName, h: ObjectHolder) => void;
+    static markUsed: (subscription: Subscription, r: DataRevision, m: MemberName, h: DataHolder, kind: Kind, weak: boolean) => void;
+    static markEdited: (oldValue: any, newValue: any, edited: boolean, r: DataRevision, m: MemberName, h: DataHolder) => void;
     static isConflicting: (oldValue: any, newValue: any) => boolean;
     static propagateAllChangesThroughSubscriptions: (snapshot: Snapshot) => void;
     static revokeAllSubscriptions: (snapshot: Snapshot) => void;
-    static enqueueReactionsToRun: (reactions: Array<Observer>) => void;
-    seekRevision(h: ObjectHolder, m: MemberName): ObjectRevision;
-    getCurrentRevision(h: ObjectHolder, m: MemberName): ObjectRevision;
-    getEditableRevision(h: ObjectHolder, m: MemberName, value: any, token?: any): ObjectRevision;
+    static enqueueReactionsToRun: (reactions: Array<Subscriber>) => void;
+    seekRevision(h: DataHolder, m: MemberName): DataRevision;
+    getCurrentRevision(h: DataHolder, m: MemberName): DataRevision;
+    getEditableRevision(h: DataHolder, m: MemberName, value: any, token?: any): DataRevision;
     static takeSnapshot<T>(obj: T): T;
     static dispose(obj: any): void;
-    static doDispose(ctx: Snapshot, h: ObjectHolder): ObjectRevision;
+    static doDispose(ctx: Snapshot, h: DataHolder): DataRevision;
     private isNewRevisionRequired;
     acquire(outer: Snapshot): void;
     bumpBy(timestamp: number): void;
-    rebase(): ObjectRevision[] | undefined;
+    rebase(): DataRevision[] | undefined;
     private merge;
-    applyOrDiscard(error?: any): Array<Observer>;
-    static sealObjectRevision(h: ObjectHolder, r: ObjectRevision): void;
-    static sealObservable(observable: Observable | symbol, m: MemberName, typeName: string): void;
-    static freezeObjectRevision(r: ObjectRevision): ObjectRevision;
+    applyOrDiscard(error?: any): Array<Subscriber>;
+    static sealObjectRevision(h: DataHolder, r: DataRevision): void;
+    static sealSubscription(subscription: Subscription | symbol, m: MemberName, typeName: string): void;
+    static freezeObjectRevision(r: DataRevision): DataRevision;
     triggerGarbageCollection(): void;
     private unlinkHistory;
     static _init(): void;
 }
 export declare class Dump {
     static valueHint: (value: any, m?: PropertyKey | undefined) => string;
-    static obj(h: ObjectHolder | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
-    static rev2(h: ObjectHolder, s: AbstractSnapshot, m?: MemberName, o?: Observable): string;
-    static rev(r: ObjectRevision, m?: MemberName): string;
-    static conflicts(conflicts: ObjectRevision[]): string;
-    static conflictingMemberHint(m: MemberName, ours: ObjectRevision, theirs: ObjectRevision): string;
+    static obj(h: DataHolder | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
+    static rev2(h: DataHolder, s: AbstractSnapshot, m?: MemberName, o?: Subscription): string;
+    static rev(r: DataRevision, m?: MemberName): string;
+    static conflicts(conflicts: DataRevision[]): string;
+    static conflictingMemberHint(m: MemberName, ours: DataRevision, theirs: DataRevision): string;
 }
-export declare const ROOT_REV: ObjectRevision;
+export declare const ROOT_REV: DataRevision;
 export declare const DefaultSnapshotOptions: SnapshotOptions;

package/build/dist/source/impl/Snapshot.js

@@ -10,17 +10,17 @@ const SealedSet_1 = require("../util/SealedSet");
 const Data_1 = require("./Data");
 exports.MAX_TIMESTAMP = Number.MAX_SAFE_INTEGER;
 exports.UNDEFINED_TIMESTAMP = exports.MAX_TIMESTAMP - 1;
-Object.defineProperty(Data_1.ObjectHolder.prototype, '#this', {
+Object.defineProperty(Data_1.DataHolder.prototype, '#this', {
     configurable: false, enumerable: false,
     get() {
         const result = {};
         const data = Snapshot.current().getCurrentRevision(this, '#this').data;
         for (const m in data) {
             const v = data[m];
-            if (v instanceof Data_1.Observable)
-                result[m] = v.value;
-            else if (v === Data_1.Meta.Unobservable)
-                result[m] = this.unobservable[m];
+            if (v instanceof Data_1.Subscription)
+                result[m] = v.content;
+            else if (v === Data_1.Meta.Nonreactive)
+                result[m] = this.data[m];
             else
                 result[m] = v;
         }
@@ -64,11 +64,11 @@ class Snapshot {
     getEditableRevision(h, m, value, token) {
         let r = this.seekRevision(h, m);
         const existing = r.data[m];
-        if (existing !== Data_1.Meta.Unobservable) {
+        if (existing !== Data_1.Meta.Nonreactive) {
             if (this.isNewRevisionRequired(h, r, m, existing, value, token)) {
                 const data = Object.assign({}, m === Data_1.Meta.Holder ? value : r.data);
                 Reflect.set(data, Data_1.Meta.Holder, h);
-                r = new Data_1.ObjectRevision(this, r, data);
+                r = new Data_1.DataRevision(this, r, data);
                 this.changeset.set(h, r);
                 h.editing = r;
                 h.editors++;
@@ -99,7 +99,7 @@ class Snapshot {
     }
     isNewRevisionRequired(h, r, m, existing, value, token) {
         if (this.sealed && r.snapshot !== exports.ROOT_REV.snapshot)
-            throw (0, Dbg_1.misuse)(`observable property ${Dump.obj(h, m)} can only be modified inside transaction`);
+            throw (0, Dbg_1.misuse)(`reactive property ${Dump.obj(h, m)} can only be modified inside transaction`);
         if (m !== Data_1.Meta.Holder && value !== Data_1.Meta.Holder) {
             if (r.snapshot !== this || r.former.revision !== exports.ROOT_REV) {
                 if (this.options.token !== undefined && token !== this.options.token)
@@ -193,9 +193,9 @@ class Snapshot {
             if (!error) {
                 h.head = r;
                 if (Snapshot.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
-                    Snapshot.totalObjectRevisionCount++;
+                    Snapshot.totalRevisionCount++;
                     if (r.former.revision === exports.ROOT_REV)
-                        Snapshot.totalObjectHolderCount++;
+                        Snapshot.totalHolderCount++;
                 }
             }
         });
@@ -217,20 +217,20 @@ class Snapshot {
     }
     static sealObjectRevision(h, r) {
         if (!r.changes.has(Data_1.Meta.Disposed))
-            r.changes.forEach((o, m) => Snapshot.sealObservable(r.data[m], m, h.proxy.constructor.name));
+            r.changes.forEach((o, m) => Snapshot.sealSubscription(r.data[m], m, h.proxy.constructor.name));
         else
             for (const m in r.former.revision.data)
                 r.data[m] = Data_1.Meta.Disposed;
         if (Dbg_1.Log.isOn)
             Snapshot.freezeObjectRevision(r);
     }
-    static sealObservable(observable, m, typeName) {
-        if (observable instanceof Data_1.Observable) {
-            const value = observable.value;
+    static sealSubscription(subscription, m, typeName) {
+        if (subscription instanceof Data_1.Subscription) {
+            const value = subscription.content;
             if (value !== undefined && value !== null) {
                 const sealedType = Object.getPrototypeOf(value)[Sealant_1.Sealant.SealedType];
                 if (sealedType)
-                    observable.value = Sealant_1.Sealant.seal(value, sealedType, typeName, m);
+                    subscription.content = Sealant_1.Sealant.seal(value, sealedType, typeName, m);
             }
         }
     }
@@ -254,7 +254,7 @@ class Snapshot {
                 Snapshot.oldest = Snapshot.pending[0];
                 const now = Date.now();
                 if (now - Snapshot.lastGarbageCollectionSummaryTimestamp > Snapshot.garbageCollectionSummaryInterval) {
-                    Dbg_1.Log.write('', '[G]', `Total object/revision count: ${Snapshot.totalObjectHolderCount}/${Snapshot.totalObjectRevisionCount}`);
+                    Dbg_1.Log.write('', '[G]', `Total object/revision count: ${Snapshot.totalHolderCount}/${Snapshot.totalRevisionCount}`);
                     Snapshot.lastGarbageCollectionSummaryTimestamp = now;
                 }
             }
@@ -268,9 +268,9 @@ class Snapshot {
                 Dbg_1.Log.write(' ', '  ', `${Dump.rev2(h, r.former.revision.snapshot)} is ready for GC because overwritten by ${Dump.rev2(h, r.snapshot)}`);
             if (Snapshot.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
                 if (r.former.revision !== exports.ROOT_REV)
-                    Snapshot.totalObjectRevisionCount--;
+                    Snapshot.totalRevisionCount--;
                 if (r.changes.has(Data_1.Meta.Disposed))
-                    Snapshot.totalObjectHolderCount--;
+                    Snapshot.totalHolderCount--;
             }
             r.former.revision = exports.ROOT_REV;
         });
@@ -300,8 +300,8 @@ Snapshot.pending = [];
 Snapshot.oldest = undefined;
 Snapshot.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
 Snapshot.lastGarbageCollectionSummaryTimestamp = Date.now();
-Snapshot.totalObjectHolderCount = 0;
-Snapshot.totalObjectRevisionCount = 0;
+Snapshot.totalHolderCount = 0;
+Snapshot.totalRevisionCount = 0;
 Snapshot.current = Utils_1.UNDEF;
 Snapshot.edit = Utils_1.UNDEF;
 Snapshot.markUsed = Utils_1.UNDEF;
@@ -321,7 +321,7 @@ class Dump {
     }
     static rev2(h, s, m, o) {
         var _a;
-        return Dump.obj(h, m, s.timestamp, s.id, o === null || o === void 0 ? void 0 : o.originSnapshotId, (_a = o === null || o === void 0 ? void 0 : o.value) !== null && _a !== void 0 ? _a : Data_1.Meta.Undefined);
+        return Dump.obj(h, m, s.timestamp, s.id, o === null || o === void 0 ? void 0 : o.originSnapshotId, (_a = o === null || o === void 0 ? void 0 : o.content) !== null && _a !== void 0 ? _a : Data_1.Meta.Undefined);
     }
     static rev(r, m) {
         const h = Data_1.Meta.get(r.data, Data_1.Meta.Holder);
@@ -343,7 +343,7 @@ class Dump {
 }
 exports.Dump = Dump;
 Dump.valueHint = (value, m) => '???';
-exports.ROOT_REV = new Data_1.ObjectRevision(new Snapshot({ hint: '<root>' }), undefined, {});
+exports.ROOT_REV = new Data_1.DataRevision(new Snapshot({ hint: '<root>' }), undefined, {});
 exports.DefaultSnapshotOptions = Object.freeze({
     hint: 'noname',
     standalone: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.22.210",
+  "version": "0.22.302",
   "description": "Reactronic - Transactional Reactive State Management",
   "main": "build/dist/source/api.js",
   "types": "build/dist/source/api.d.ts",