reactronic 0.22.205 → 0.22.300

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

@@ -9,10 +9,10 @@ const Snapshot_1 = require("./Snapshot");
 const Transaction_1 = require("./Transaction");
 const Monitor_1 = require("./Monitor");
 const Hooks_1 = require("./Hooks");
-const EditJournal_1 = require("./EditJournal");
+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);
@@ -42,7 +42,7 @@ class OperationController extends Controller_1.Controller {
             const standalone = weak || opts.standalone || opts.kind === Options_1.Kind.Reaction ||
                 (opts.kind === Options_1.Kind.Transaction && outerOpts && (outerOpts.noSideEffects || outerOpts.kind === Options_1.Kind.Cache)) ||
                 (opts.kind === Options_1.Kind.Cache && (oc.revision.snapshot.sealed ||
-                    oc.revision.prev.revision !== Snapshot_1.ROOT_REV));
+                    oc.revision.former.revision !== Snapshot_1.ROOT_REV));
             const token = opts.noSideEffects ? this : undefined;
             const oc2 = this.run(oc, standalone, opts, token, args);
             const ctx2 = oc2.operation.snapshot;
@@ -129,7 +129,7 @@ class OperationController extends Controller_1.Controller {
         if (op.snapshot !== r.snapshot) {
             const op2 = new Operation(this, r.snapshot, op);
             r.data[m] = op2.reenterOver(op);
-            ctx.bumpBy(r.prev.revision.snapshot.timestamp);
+            ctx.bumpBy(r.former.revision.snapshot.timestamp);
             Snapshot_1.Snapshot.markEdited(op, op2, true, r, m, h);
             op = op2;
         }
@@ -141,7 +141,7 @@ class OperationController extends Controller_1.Controller {
         if (op.controller !== this) {
             if (r.snapshot !== Snapshot_1.ROOT_REV.snapshot) {
                 const hint = Dbg_1.Log.isOn ? `${Snapshot_1.Dump.obj(this.ownHolder, m)}/boot` : 'MethodController/init';
-                const standalone = r.snapshot.sealed || r.prev.revision !== Snapshot_1.ROOT_REV;
+                const standalone = r.snapshot.sealed || r.former.revision !== Snapshot_1.ROOT_REV;
                 op = Transaction_1.Transaction.run({ hint, standalone, token: this }, () => {
                     const h = this.ownHolder;
                     let r2 = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
@@ -204,21 +204,21 @@ class OperationController extends Controller_1.Controller {
     }
 }
 exports.OperationController = OperationController;
-class Operation extends Data_1.Observable {
-    constructor(controller, snapshot, prev) {
+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();
-        if (prev instanceof Operation) {
-            this.options = prev.options;
-            this.args = prev.args;
-            this.cause = prev.obsoleteDueTo;
+        this.subscriptions = new Map();
+        if (former instanceof Operation) {
+            this.options = former.options;
+            this.args = former.args;
+            this.cause = former.obsoleteDueTo;
         }
         else {
-            this.options = prev;
+            this.options = former;
             this.args = BOOT_ARGS;
             this.cause = undefined;
         }
@@ -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);
             }
         }
     }
@@ -486,11 +486,11 @@ class Operation extends Data_1.Observable {
             if (!r.changes.has(Data_1.Meta.Disposed))
                 r.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(false, since, r, m, h, reactions));
             else
-                for (const m in r.prev.revision.data)
+                for (const m in r.former.revision.data)
                     Operation.propagateMemberChangeThroughSubscriptions(true, since, r, m, h, reactions);
         });
         reactions.sort(compareReactionsByOrder);
-        (_a = snapshot.options.journal) === null || _a === void 0 ? void 0 : _a.register(EditJournal_1.EditJournalImpl.buildPatch(snapshot.hint, snapshot.changeset));
+        (_a = snapshot.options.journal) === null || _a === void 0 ? void 0 : _a.edited(Journal_1.JournalImpl.buildPatch(snapshot.hint, snapshot.changeset));
     }
     static revokeAllSubscriptions(snapshot) {
         snapshot.changeset.forEach((r, h) => r.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(true, snapshot.timestamp, r, m, h, undefined)));
@@ -499,45 +499,39 @@ class Operation extends Data_1.Observable {
         var _a;
         const curr = r.data[m];
         if (reactions) {
-            const prev = r.prev.revision.data[m];
-            if (prev !== undefined && prev instanceof Data_1.Observable) {
+            const former = r.former.revision.data[m];
+            if (former !== undefined && former instanceof Data_1.Subscription) {
                 const why = `T${r.snapshot.id}[${r.snapshot.hint}]`;
-                if (prev instanceof Operation) {
-                    if ((prev.obsoleteSince === Snapshot_1.MAX_TIMESTAMP || prev.obsoleteSince <= 0)) {
-                        prev.obsoleteDueTo = why;
-                        prev.obsoleteSince = timestamp;
-                        prev.unsubscribeFromAllObservables();
+                if (former instanceof Operation) {
+                    if ((former.obsoleteSince === Snapshot_1.MAX_TIMESTAMP || former.obsoleteSince <= 0)) {
+                        former.obsoleteDueTo = why;
+                        former.obsoleteSince = timestamp;
+                        former.unsubscribeFromAllSubscriptions();
                     }
-                    const prevSuccessor = prev.successor;
-                    if (prevSuccessor !== curr) {
-                        if (prevSuccessor && !prevSuccessor.transaction.isFinished)
-                            prevSuccessor.transaction.cancel(new Error(`T${prevSuccessor.transaction.id}[${prevSuccessor.transaction.hint}] is canceled by T${r.snapshot.id}[${r.snapshot.hint}] and will not run anymore`), null);
+                    const formerSuccessor = former.successor;
+                    if (formerSuccessor !== curr) {
+                        if (formerSuccessor && !formerSuccessor.transaction.isFinished)
+                            formerSuccessor.transaction.cancel(new Error(`T${formerSuccessor.transaction.id}[${formerSuccessor.transaction.hint}] is canceled by T${r.snapshot.id}[${r.snapshot.hint}] and will not run anymore`), null);
                     }
                     else
-                        prev.successor = undefined;
+                        former.successor = undefined;
                 }
-                (_a = prev.observers) === null || _a === void 0 ? void 0 : _a.forEach(c => c.markObsoleteDueTo(prev, 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) {
-            curr.observers.forEach(o => {
-                o.observables.delete(curr);
-                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.read)
-                    Dbg_1.Log.write(Dbg_1.Log.opt.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', '-', `${o.hint()} is unsubscribed from own-changed ${Snapshot_1.Dump.rev(r, m)}`);
-            });
-            curr.observers = undefined;
+        else if (curr instanceof Data_1.Subscription && curr.subscribers) {
         }
     }
     static enqueueReactionsToRun(reactions) {
@@ -558,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)` : ''}`);
             }
@@ -595,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;
         }
@@ -51,7 +51,7 @@ class Snapshot {
         if (!r) {
             r = h.head;
             while (r !== exports.ROOT_REV && r.snapshot.timestamp > this.timestamp)
-                r = r.prev.revision;
+                r = r.former.revision;
         }
         return r;
     }
@@ -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,9 +99,9 @@ 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.prev.revision !== exports.ROOT_REV) {
+            if (r.snapshot !== this || r.former.revision !== exports.ROOT_REV) {
                 if (this.options.token !== undefined && token !== this.options.token)
                     throw (0, Dbg_1.misuse)(`${this.hint} should not have side effects (trying to change ${Dump.rev(r, m)})`);
             }
@@ -129,7 +129,7 @@ class Snapshot {
         let conflicts = undefined;
         if (this.changeset.size > 0) {
             this.changeset.forEach((r, h) => {
-                if (r.prev.revision !== h.head) {
+                if (r.former.revision !== h.head) {
                     const merged = this.merge(h, r);
                     if (r.conflicts.size > 0) {
                         if (!conflicts)
@@ -172,7 +172,7 @@ class Snapshot {
                 }
             }
             else {
-                const conflict = Snapshot.isConflicting(head.data[m], ours.prev.revision.data[m]);
+                const conflict = Snapshot.isConflicting(head.data[m], ours.former.revision.data[m]);
                 if (conflict)
                     ours.conflicts.set(m, head);
                 if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
@@ -180,7 +180,7 @@ class Snapshot {
             }
         });
         Utils_1.Utils.copyAllMembers(merged, ours.data);
-        ours.prev.revision = head;
+        ours.former.revision = head;
         return counter;
     }
     applyOrDiscard(error) {
@@ -193,9 +193,9 @@ class Snapshot {
             if (!error) {
                 h.head = r;
                 if (Snapshot.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
-                    Snapshot.totalObjectRevisionCount++;
-                    if (r.prev.revision === exports.ROOT_REV)
-                        Snapshot.totalObjectHolderCount++;
+                    Snapshot.totalRevisionCount++;
+                    if (r.former.revision === exports.ROOT_REV)
+                        Snapshot.totalHolderCount++;
                 }
             }
         });
@@ -205,7 +205,7 @@ class Snapshot {
                     const members = [];
                     r.changes.forEach((o, m) => members.push(m.toString()));
                     const s = members.join(', ');
-                    Dbg_1.Log.write('║', '√', `${Dump.rev2(h, r.snapshot)} (${s}) is ${r.prev.revision === exports.ROOT_REV ? 'constructed' : `applied on top of ${Dump.rev2(h, r.prev.revision.snapshot)}`}`);
+                    Dbg_1.Log.write('║', '√', `${Dump.rev2(h, r.snapshot)} (${s}) is ${r.former.revision === exports.ROOT_REV ? 'constructed' : `applied on top of ${Dump.rev2(h, r.former.revision.snapshot)}`}`);
                 });
             }
             if (Dbg_1.Log.opt.transaction)
@@ -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.prev.revision.data)
+            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;
                 }
             }
@@ -264,15 +264,15 @@ class Snapshot {
         if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc)
             Dbg_1.Log.write('', '[G]', `Dismiss history below v${this.stamp}t${this.id} (${this.hint})`);
         this.changeset.forEach((r, h) => {
-            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc && r.prev.revision !== exports.ROOT_REV)
-                Dbg_1.Log.write(' ', '  ', `${Dump.rev2(h, r.prev.revision.snapshot)} is ready for GC because overwritten by ${Dump.rev2(h, r.snapshot)}`);
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc && r.former.revision !== exports.ROOT_REV)
+                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.prev.revision !== exports.ROOT_REV)
-                    Snapshot.totalObjectRevisionCount--;
+                if (r.former.revision !== exports.ROOT_REV)
+                    Snapshot.totalRevisionCount--;
                 if (r.changes.has(Data_1.Meta.Disposed))
-                    Snapshot.totalObjectHolderCount--;
+                    Snapshot.totalHolderCount--;
             }
-            r.prev.revision = exports.ROOT_REV;
+            r.former.revision = exports.ROOT_REV;
         });
         this.changeset = EMPTY_MAP;
         this.reactions = EMPTY_ARRAY;
@@ -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.205",
+  "version": "0.22.300",
   "description": "Reactronic - Transactional Reactive State Management",
   "main": "build/dist/source/api.js",
   "types": "build/dist/source/api.d.ts",

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

@@ -1,37 +0,0 @@
-import { ObservableObject } from './Hooks';
-import { ObjectHolder, ObjectRevision, Patch } from './Data';
-export declare abstract class EditJournal extends ObservableObject {
-    abstract capacity: number;
-    abstract readonly isSaving: boolean;
-    abstract readonly edits: ReadonlyArray<Patch>;
-    abstract readonly canUndo: boolean;
-    abstract readonly canRedo: boolean;
-    abstract undo(count?: number): void;
-    abstract redo(count?: number): void;
-    abstract getUnsaved(): Patch | undefined;
-    abstract beginSave(): void;
-    abstract endSave(success: boolean): void;
-    abstract register(patch: Patch): void;
-    static create(): EditJournal;
-}
-export declare class EditJournalImpl extends EditJournal {
-    private _capacity;
-    private _isSaving;
-    private _edits;
-    private _position;
-    private _saved;
-    get capacity(): number;
-    set capacity(value: number);
-    get isSaving(): boolean;
-    get edits(): ReadonlyArray<Patch>;
-    get canUndo(): boolean;
-    get canRedo(): boolean;
-    undo(count?: number): void;
-    redo(count?: number): void;
-    getUnsaved(): Patch | undefined;
-    beginSave(): void;
-    endSave(success: boolean): void;
-    register(p: Patch): void;
-    static buildPatch(hint: string, changeset: Map<ObjectHolder, ObjectRevision>): Patch;
-    static applyPatch(patch: Patch, undo: boolean): void;
-}