reactronic 0.22.210 → 0.22.300

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 (subscribing 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
+  - **Subscribing Objects** - a set of objects that store data of an
+    application (state) and maintain subscription lists;
+  - **Transaction** - a function that makes changes in subscribing
     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
+subscribing object, transaction and reaction:
 
 ``` typescript
-class Demo extends ObservableObject {
+class Demo extends SubscribingObject {
   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 SubscribingObject {
   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
+## Subscribing Objects
 
-Observable objects store data of an application. All such objects
+Subscribing 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 SubscribingObject {
   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`,
+`SubscribingObject` 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 subscribing 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 SubscribingObject {
   // ...
   @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 subscribing 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),
+subscribing objects and other cached functions (dependencies),
 which are used during their execution.
 
 ``` tsx
@@ -223,15 +223,15 @@ 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 subscribing
 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).
-With Reactronic, you no longer need to create data change events
+all the subscribing objects and reactions/caches (subscribing objects
+and subscribers). 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
 to a new one.
@@ -292,17 +292,17 @@ NPM: `npm install reactronic`
 
 // Classes
 
-class ObservableObject { }
+class SubscribingObject { }
 
 // Decorators & Operators
 
-function unobservable(proto, prop) // field only
+function subscribeless(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
 function options(value: Partial<MemberOptions>): F<any>
 
-function nonreactive<T>(func: F<T>, ...args: any[]): T
+function nonsubscribing<T>(func: F<T>, ...args: any[]): T
 function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 // SnapshotOptions, MemberOptions, Kind, Reentrance, Monitor, LoggingOptions, ProfilingOptions

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 { SubscribingObject } from './impl/Hooks';
+export declare abstract class Buffer<T> extends SubscribingObject {
     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.SubscribingObject {
     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;
+    nonsubscribing(): T;
     observe(): T;
     unobserve(): T;
     static to<O extends object = object>(owner: O): {

package/build/dist/source/Ref.js

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

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

@@ -17,9 +17,9 @@ export declare class Rx {
     static getLoggingHint<T extends object>(obj: T, full?: boolean): string | undefined;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
 }
-export declare function nonreactive<T>(func: F<T>, ...args: any[]): T;
+export declare function nonsubscribing<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 subscribeless(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.subscribeless = exports.sensitive = exports.nonsubscribing = exports.Rx = void 0;
 const Dbg_1 = require("./util/Dbg");
 const Options_1 = require("./Options");
 const Data_1 = require("./impl/Data");
@@ -20,22 +20,22 @@ 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;
-function nonreactive(func, ...args) {
+function nonsubscribing(func, ...args) {
     return Operation_1.OperationController.runWithin(undefined, func, ...args);
 }
-exports.nonreactive = nonreactive;
+exports.nonsubscribing = nonsubscribing;
 function sensitive(sensitivity, func, ...args) {
     return Hooks_1.Hooks.sensitive(sensitivity, func, ...args);
 }
 exports.sensitive = sensitive;
-function unobservable(proto, prop) {
+function subscribeless(proto, prop) {
     return Hooks_1.Hooks.decorateData(false, proto, prop);
 }
-exports.unobservable = unobservable;
+exports.subscribeless = subscribeless;
 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 { SubscribingObject } 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, nonsubscribing, sensitive, subscribeless, 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.subscribeless = exports.sensitive = exports.nonsubscribing = exports.Rx = exports.Journal = exports.Monitor = exports.Transaction = exports.Snapshot = exports.SubscribingObject = 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, "SubscribingObject", { enumerable: true, get: function () { return Hooks_1.SubscribingObject; } });
 var Snapshot_1 = require("./impl/Snapshot");
 Object.defineProperty(exports, "Snapshot", { enumerable: true, get: function () { return Snapshot_1.Snapshot; } });
 var Transaction_1 = require("./impl/Transaction");
@@ -31,9 +31,9 @@ var Journal_1 = require("./impl/Journal");
 Object.defineProperty(exports, "Journal", { enumerable: true, get: function () { return Journal_1.Journal; } });
 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, "nonsubscribing", { enumerable: true, get: function () { return Rx_1.nonsubscribing; } });
 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, "subscribeless", { enumerable: true, get: function () { return Rx_1.subscribeless; } });
 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 SubscribingObject {
     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(subscribing: 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 createDataHolderForSubscribingObject(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.SubscribingObject = 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 SubscribingObject {
     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.createDataHolderForSubscribingObject(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.SubscribingObject = SubscribingObject;
 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(subscribing, proto, m) {
+        if (subscribing) {
             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.Nonsubscribing;
     }
     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 createDataHolderForSubscribingObject(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;