reactronic 0.22.205 → 0.22.300

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.prev.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 (r.prev.revision.data[m] === curr) {
-                        curr = r.data[m] = new Data_1.Observable(value);
-                        Snapshot_1.Snapshot.markEdited(old, value, true, r, m, h);
+            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.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;

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

@@ -0,0 +1,34 @@
+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<PatchSet>;
+    abstract readonly unsaved: PatchSet;
+    abstract readonly canUndo: boolean;
+    abstract readonly canRedo: boolean;
+    abstract edited(patch: PatchSet): void;
+    abstract saved(patch: PatchSet): void;
+    abstract undo(count?: number): void;
+    abstract redo(count?: number): void;
+    static create(): Journal;
+}
+export declare class JournalImpl extends Journal {
+    private _capacity;
+    private _edits;
+    private _unsaved;
+    private _position;
+    get capacity(): number;
+    set capacity(value: number);
+    get edits(): ReadonlyArray<PatchSet>;
+    get unsaved(): PatchSet;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    edited(p: PatchSet): void;
+    saved(patch: PatchSet): void;
+    undo(count?: number): void;
+    redo(count?: number): 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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JournalImpl = exports.Journal = void 0;
+const Hooks_1 = require("./Hooks");
+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.SubscribingObject {
+    static create() { return new JournalImpl(); }
+}
+exports.Journal = Journal;
+class JournalImpl extends Journal {
+    constructor() {
+        super(...arguments);
+        this._capacity = 5;
+        this._edits = [];
+        this._unsaved = { hint: 'unsaved', objects: new Map() };
+        this._position = 0;
+    }
+    get capacity() { return this._capacity; }
+    set capacity(value) { this._capacity = value; if (value < this._edits.length)
+        this._edits.splice(0, this._edits.length - value); }
+    get edits() { return this._edits; }
+    get unsaved() { return this._unsaved; }
+    get canUndo() { return this._edits.length > 0 && this._position > 0; }
+    get canRedo() { return this._position < this._edits.length; }
+    edited(p) {
+        Transaction_1.Transaction.run({ hint: 'EditJournal.edited', standalone: 'isolated' }, () => {
+            const items = this._edits = this._edits.toMutable();
+            if (items.length >= this._capacity)
+                items.shift();
+            else
+                items.splice(this._position);
+            this.mergePatchToUnsaved(p, false);
+            items.push(p);
+            this._position = items.length;
+        });
+    }
+    saved(patch) {
+        if (this._unsaved === patch)
+            this._unsaved = { hint: 'unsaved', objects: new Map() };
+        else
+            throw new Error('not implemented');
+    }
+    undo(count = 1) {
+        Transaction_1.Transaction.run({ hint: 'Journal.undo', standalone: 'isolated' }, () => {
+            let i = this._position - 1;
+            while (i >= 0 && count > 0) {
+                const patch = this._edits[i];
+                JournalImpl.applyPatch(patch, true);
+                this.mergePatchToUnsaved(patch, true);
+                i--, count--;
+            }
+            this._position = i + 1;
+        });
+    }
+    redo(count = 1) {
+        Transaction_1.Transaction.run({ hint: 'Journal.redo', standalone: 'isolated' }, () => {
+            let i = this._position;
+            while (i < this._edits.length && count > 0) {
+                const patch = this._edits[i];
+                JournalImpl.applyPatch(patch, false);
+                this.mergePatchToUnsaved(patch, false);
+                i++, count--;
+            }
+            this._position = i;
+        });
+    }
+    static buildPatch(hint, changeset) {
+        const patch = { hint, objects: new Map() };
+        changeset.forEach((r, h) => {
+            const op = { data: {}, former: {} };
+            const former = r.former.revision !== Snapshot_1.ROOT_REV ? r.former.revision.data : undefined;
+            r.changes.forEach(m => {
+                op.data[m] = unseal(r.data[m]);
+                if (former)
+                    op.former[m] = unseal(former[m]);
+            });
+            if (!former) {
+                delete op.data[Data_1.Meta.Disposed];
+                op.former[Data_1.Meta.Disposed] = Data_1.Meta.Disposed;
+            }
+            patch.objects.set(h.proxy, op);
+        });
+        return patch;
+    }
+    static applyPatch(patch, undoing) {
+        const ctx = Snapshot_1.Snapshot.edit();
+        patch.objects.forEach((dp, obj) => {
+            const h = Data_1.Meta.get(obj, Data_1.Meta.Holder);
+            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.Subscription(value);
+                        const existing = r.former.revision.data[m];
+                        Snapshot_1.Snapshot.markEdited(existing, value, existing !== value, r, m, h);
+                    }
+                }
+            }
+            else
+                Snapshot_1.Snapshot.doDispose(ctx, h);
+        });
+    }
+    mergePatchToUnsaved(patch, undoing) {
+        const unsaved = this._unsaved;
+        patch.objects.forEach((dp, obj) => {
+            let merged = unsaved.objects.get(obj);
+            if (!merged)
+                unsaved.objects.set(obj, merged = { data: {}, 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]) {
+                    merged.data[m] = value;
+                    if (m in merged.former === false)
+                        merged.former[m] = former[m];
+                }
+                else {
+                    delete merged.data[m];
+                    delete merged.former[m];
+                    if (Object.keys(merged.data).length === 0)
+                        unsaved.objects.delete(obj);
+                }
+            }
+        });
+    }
+}
+exports.JournalImpl = JournalImpl;
+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[];
@@ -50,7 +50,7 @@ declare class Operation extends Observable implements Observer {
     obsoleteDueTo: string | undefined;
     obsoleteSince: number;
     successor: Operation | undefined;
-    constructor(controller: OperationController, snapshot: AbstractSnapshot, prev: Operation | OptionsImpl);
+    constructor(controller: OperationController, snapshot: AbstractSnapshot, former: Operation | OptionsImpl);
     get isOperation(): boolean;
     get originSnapshotId(): number;
     hint(): string;
@@ -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;