reactronic 0.22.210 → 0.22.300

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 { SubscribingObject } from './Hooks';
+import { DataHolder, DataRevision, PatchSet } from './Data';
+export declare type Saver = (patch: PatchSet) => Promise<void>;
+export declare abstract class Journal extends SubscribingObject {
     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.SubscribingObject {
     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 Nonsubscribing: 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.Nonsubscribing = Symbol('rxNonsubscribing');
 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 { SubscribingObject } from './Hooks';
+export declare abstract class Monitor extends SubscribingObject {
     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.SubscribingObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return MonitorImpl.create(hint, activationDelay, deactivationDelay, durationResolution);
     }

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

@@ -1,15 +1,15 @@
 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;
-    get nonreactive(): any;
+    get nonsubscribing(): any;
     get args(): ReadonlyArray<any>;
     get result(): any;
     get error(): boolean;
@@ -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 nonsubscribing() { 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.Nonsubscribing)
+                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.Nonsubscribing) {
             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)(`subscribing 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,