reactronic 0.22.307 → 0.22.310

package/build/dist/source/Rx.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = exports.cached = exports.reaction = exports.transaction = exports.isnonreactive = exports.sensitive = exports.nonreactive = exports.Rx = void 0;
+const Dbg_1 = require("./util/Dbg");
+const Options_1 = require("./Options");
+const Data_1 = require("./impl/Data");
+const Changeset_1 = require("./impl/Changeset");
+const Hooks_1 = require("./impl/Hooks");
+const Operation_1 = require("./impl/Operation");
+class Rx {
+    static getRevisionOf(obj) { return obj[Data_1.Meta.Revision]; }
+    static why(brief = false) { return brief ? Operation_1.OperationController.briefWhy() : Operation_1.OperationController.why(); }
+    static getController(method) { return Operation_1.OperationController.of(method); }
+    static pullLastResult(method, args) { return Rx.getController(method).pullLastResult(args); }
+    static configureCurrentOperation(options) { return Operation_1.OperationController.configureImpl(undefined, options); }
+    static takeSnapshot(obj) { return Changeset_1.Changeset.takeSnapshot(obj); }
+    static dispose(obj) { Changeset_1.Changeset.dispose(obj); }
+    static get reactionsAutoStartDisabled() { return Hooks_1.Hooks.reactionsAutoStartDisabled; }
+    static set reactionsAutoStartDisabled(value) { Hooks_1.Hooks.reactionsAutoStartDisabled = value; }
+    static get isLogging() { return Dbg_1.Log.isOn; }
+    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.ObjectHandle.getHint(obj, full); }
+    static setProfilingMode(isOn, options) { Hooks_1.Hooks.setProfilingMode(isOn, options); }
+}
+exports.Rx = Rx;
+function nonreactive(func, ...args) {
+    return Operation_1.OperationController.runWithin(undefined, func, ...args);
+}
+exports.nonreactive = nonreactive;
+function sensitive(sensitivity, func, ...args) {
+    return Hooks_1.Hooks.sensitive(sensitivity, func, ...args);
+}
+exports.sensitive = sensitive;
+function isnonreactive(proto, prop) {
+    return Hooks_1.Hooks.decorateData(false, proto, prop);
+}
+exports.isnonreactive = isnonreactive;
+function transaction(proto, prop, pd) {
+    const opts = { kind: Options_1.Kind.Transaction };
+    return Hooks_1.Hooks.decorateOperation(true, transaction, opts, proto, prop, pd);
+}
+exports.transaction = transaction;
+function reaction(proto, prop, pd) {
+    const opts = { kind: Options_1.Kind.Reaction, throttling: -1 };
+    return Hooks_1.Hooks.decorateOperation(true, reaction, opts, proto, prop, pd);
+}
+exports.reaction = reaction;
+function cached(proto, prop, pd) {
+    const opts = { kind: Options_1.Kind.Cache, noSideEffects: true };
+    return Hooks_1.Hooks.decorateOperation(true, cached, opts, proto, prop, pd);
+}
+exports.cached = cached;
+function options(value) {
+    return Hooks_1.Hooks.decorateOperationParametrized(options, value);
+}
+exports.options = options;

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

@@ -0,0 +1,8 @@
+export interface Worker {
+    readonly id: number;
+    readonly hint: string;
+    readonly isCanceled: boolean;
+    readonly isFinished: boolean;
+    cancel(error: Error, restartAfter?: Worker | null): this;
+    whenFinished(): Promise<void>;
+}

package/build/dist/source/Worker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,14 @@
+export { all, pause } from './util/Utils';
+export { SealedArray } from './util/SealedArray';
+export { SealedMap } from './util/SealedMap';
+export { SealedSet } from './util/SealedSet';
+export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, ProfilingOptions, LoggingLevel } from './Options';
+export { Worker } from './Worker';
+export { Controller } from './Controller';
+export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
+export { ReactiveObject, ReactiveArray, ReactiveMap } from './impl/Hooks';
+export { Changeset } from './impl/Changeset';
+export { Transaction } from './impl/Transaction';
+export { Monitor } from './impl/Monitor';
+export { Journal } from './impl/Journal';
+export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';

package/build/dist/source/api.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = exports.cached = exports.reaction = exports.transaction = exports.isnonreactive = exports.sensitive = exports.nonreactive = exports.Rx = exports.Journal = exports.Monitor = exports.Transaction = exports.Changeset = exports.ReactiveMap = exports.ReactiveArray = exports.ReactiveObject = exports.ToggleRef = exports.Ref = exports.Controller = exports.LoggingLevel = exports.Reentrance = exports.Kind = exports.SealedSet = exports.SealedMap = exports.SealedArray = exports.pause = exports.all = void 0;
+var Utils_1 = require("./util/Utils");
+Object.defineProperty(exports, "all", { enumerable: true, get: function () { return Utils_1.all; } });
+Object.defineProperty(exports, "pause", { enumerable: true, get: function () { return Utils_1.pause; } });
+var SealedArray_1 = require("./util/SealedArray");
+Object.defineProperty(exports, "SealedArray", { enumerable: true, get: function () { return SealedArray_1.SealedArray; } });
+var SealedMap_1 = require("./util/SealedMap");
+Object.defineProperty(exports, "SealedMap", { enumerable: true, get: function () { return SealedMap_1.SealedMap; } });
+var SealedSet_1 = require("./util/SealedSet");
+Object.defineProperty(exports, "SealedSet", { enumerable: true, get: function () { return SealedSet_1.SealedSet; } });
+var Options_1 = require("./Options");
+Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return Options_1.Kind; } });
+Object.defineProperty(exports, "Reentrance", { enumerable: true, get: function () { return Options_1.Reentrance; } });
+Object.defineProperty(exports, "LoggingLevel", { enumerable: true, get: function () { return Options_1.LoggingLevel; } });
+var Controller_1 = require("./Controller");
+Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return Controller_1.Controller; } });
+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, "ReactiveObject", { enumerable: true, get: function () { return Hooks_1.ReactiveObject; } });
+Object.defineProperty(exports, "ReactiveArray", { enumerable: true, get: function () { return Hooks_1.ReactiveArray; } });
+Object.defineProperty(exports, "ReactiveMap", { enumerable: true, get: function () { return Hooks_1.ReactiveMap; } });
+var Changeset_1 = require("./impl/Changeset");
+Object.defineProperty(exports, "Changeset", { enumerable: true, get: function () { return Changeset_1.Changeset; } });
+var Transaction_1 = require("./impl/Transaction");
+Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return Transaction_1.Transaction; } });
+var Monitor_1 = require("./impl/Monitor");
+Object.defineProperty(exports, "Monitor", { enumerable: true, get: function () { return Monitor_1.Monitor; } });
+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, "sensitive", { enumerable: true, get: function () { return Rx_1.sensitive; } });
+Object.defineProperty(exports, "isnonreactive", { enumerable: true, get: function () { return Rx_1.isnonreactive; } });
+Object.defineProperty(exports, "transaction", { enumerable: true, get: function () { return Rx_1.transaction; } });
+Object.defineProperty(exports, "reaction", { enumerable: true, get: function () { return Rx_1.reaction; } });
+Object.defineProperty(exports, "cached", { enumerable: true, get: function () { return Rx_1.cached; } });
+Object.defineProperty(exports, "options", { enumerable: true, get: function () { return Rx_1.options; } });

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

@@ -0,0 +1,60 @@
+import { Kind, SnapshotOptions } from '../Options';
+import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, Subscription, Subscriber } from './Data';
+export declare const MAX_REVISION: number;
+export declare const UNDEFINED_REVISION: number;
+export declare class Changeset implements AbstractChangeset {
+    static idGen: number;
+    private static stampGen;
+    private static pending;
+    private static oldest;
+    static garbageCollectionSummaryInterval: number;
+    static lastGarbageCollectionSummaryTimestamp: number;
+    static totalObjectHandleCount: number;
+    static totalObjectSnapshotCount: number;
+    readonly id: number;
+    readonly options: SnapshotOptions;
+    get hint(): string;
+    get timestamp(): number;
+    private revision;
+    private bumper;
+    items: Map<ObjectHandle, ObjectSnapshot>;
+    reactions: Subscriber[];
+    sealed: boolean;
+    constructor(options: SnapshotOptions | null);
+    static current: () => Changeset;
+    static edit: () => Changeset;
+    static markUsed: (subscription: Subscription, os: ObjectSnapshot, m: MemberName, h: ObjectHandle, kind: Kind, weak: boolean) => void;
+    static markEdited: (oldValue: any, newValue: any, edited: boolean, os: ObjectSnapshot, m: MemberName, h: ObjectHandle) => void;
+    static isConflicting: (oldValue: any, newValue: any) => boolean;
+    static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
+    static revokeAllSubscriptions: (changeset: Changeset) => void;
+    static enqueueReactionsToRun: (reactions: Array<Subscriber>) => void;
+    seekSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
+    getRelevantSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
+    getEditableSnapshot(h: ObjectHandle, m: MemberName, value: any, token?: any): ObjectSnapshot;
+    static takeSnapshot<T>(obj: T): T;
+    static dispose(obj: any): void;
+    static doDispose(ctx: Changeset, h: ObjectHandle): ObjectSnapshot;
+    private isNewSnapshotRequired;
+    acquire(outer: Changeset): void;
+    bumpBy(timestamp: number): void;
+    rebase(): ObjectSnapshot[] | undefined;
+    private merge;
+    applyOrDiscard(error?: any): Array<Subscriber>;
+    static sealObjectSnapshot(h: ObjectHandle, os: ObjectSnapshot): void;
+    static sealSubscription(subscription: Subscription | symbol, m: MemberName, typeName: string): void;
+    static freezeObjectSnapshot(os: ObjectSnapshot): ObjectSnapshot;
+    triggerGarbageCollection(): void;
+    private unlinkHistory;
+    static _init(): void;
+}
+export declare class Dump {
+    static valueHint: (value: any, m?: MemberName) => string;
+    static obj(h: ObjectHandle | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
+    static snapshot2(h: ObjectHandle, s: AbstractChangeset, m?: MemberName, o?: Subscription): string;
+    static snapshot(os: ObjectSnapshot, m?: MemberName): string;
+    static conflicts(conflicts: ObjectSnapshot[]): string;
+    static conflictingMemberHint(m: MemberName, ours: ObjectSnapshot, theirs: ObjectSnapshot): string;
+}
+export declare const EMPTY_SNAPSHOT: ObjectSnapshot;
+export declare const DefaultSnapshotOptions: SnapshotOptions;

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

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSnapshotOptions = exports.EMPTY_SNAPSHOT = exports.Dump = exports.Changeset = exports.UNDEFINED_REVISION = exports.MAX_REVISION = void 0;
+const Utils_1 = require("../util/Utils");
+const Dbg_1 = require("../util/Dbg");
+const Sealant_1 = require("../util/Sealant");
+const SealedArray_1 = require("../util/SealedArray");
+const SealedMap_1 = require("../util/SealedMap");
+const SealedSet_1 = require("../util/SealedSet");
+const Data_1 = require("./Data");
+exports.MAX_REVISION = Number.MAX_SAFE_INTEGER;
+exports.UNDEFINED_REVISION = exports.MAX_REVISION - 1;
+Object.defineProperty(Data_1.ObjectHandle.prototype, '#this', {
+    configurable: false, enumerable: false,
+    get() {
+        const result = {};
+        const data = Changeset.current().getRelevantSnapshot(this, '#this').data;
+        for (const m in data) {
+            const v = data[m];
+            if (v instanceof Data_1.Subscription)
+                result[m] = v.content;
+            else if (v === Data_1.Meta.Nonreactive)
+                result[m] = this.data[m];
+            else
+                result[m] = v;
+        }
+        return result;
+    },
+});
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_MAP = Utils_1.Utils.freezeMap(new Map());
+class Changeset {
+    constructor(options) {
+        this.id = ++Changeset.idGen;
+        this.options = options !== null && options !== void 0 ? options : exports.DefaultSnapshotOptions;
+        this.revision = exports.UNDEFINED_REVISION;
+        this.bumper = 100;
+        this.items = new Map();
+        this.reactions = [];
+        this.sealed = false;
+    }
+    get hint() { var _a; return (_a = this.options.hint) !== null && _a !== void 0 ? _a : 'noname'; }
+    get timestamp() { return this.revision; }
+    seekSnapshot(h, m) {
+        let os = h.editing;
+        if (os && os.changeset !== this) {
+            os = this.items.get(h);
+            if (os)
+                h.editing = os;
+        }
+        if (!os) {
+            os = h.head;
+            while (os !== exports.EMPTY_SNAPSHOT && os.changeset.timestamp > this.timestamp)
+                os = os.former.snapshot;
+        }
+        return os;
+    }
+    getRelevantSnapshot(h, m) {
+        const r = this.seekSnapshot(h, m);
+        if (r === exports.EMPTY_SNAPSHOT)
+            throw (0, Dbg_1.misuse)(`object ${Dump.obj(h)} doesn't exist in snapshot v${this.revision} (${this.hint})`);
+        return r;
+    }
+    getEditableSnapshot(h, m, value, token) {
+        let os = this.seekSnapshot(h, m);
+        const existing = os.data[m];
+        if (existing !== Data_1.Meta.Nonreactive) {
+            if (this.isNewSnapshotRequired(h, os, m, existing, value, token)) {
+                this.bumpBy(os.changeset.timestamp);
+                const revision = m === Data_1.Meta.Handle ? 1 : os.revision + 1;
+                const data = Object.assign({}, m === Data_1.Meta.Handle ? value : os.data);
+                Data_1.Meta.set(data, Data_1.Meta.Handle, h);
+                Data_1.Meta.set(data, Data_1.Meta.Revision, new Data_1.Subscription(revision));
+                os = new Data_1.ObjectSnapshot(this, os, data);
+                this.items.set(h, os);
+                h.editing = os;
+                h.editors++;
+                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
+                    Dbg_1.Log.write('║', ' ⎘⎘', `${Dump.obj(h)} - new snapshot is created (revision ${revision})`);
+            }
+        }
+        else
+            os = exports.EMPTY_SNAPSHOT;
+        return os;
+    }
+    static takeSnapshot(obj) {
+        return obj[Data_1.Meta.Handle]['#this'];
+    }
+    static dispose(obj) {
+        const ctx = Changeset.edit();
+        const h = Data_1.Meta.get(obj, Data_1.Meta.Handle);
+        if (h !== undefined)
+            Changeset.doDispose(ctx, h);
+    }
+    static doDispose(ctx, h) {
+        const os = ctx.getEditableSnapshot(h, Data_1.Meta.Revision, Data_1.Meta.Undefined);
+        if (os !== exports.EMPTY_SNAPSHOT)
+            os.disposed = true;
+        return os;
+    }
+    isNewSnapshotRequired(h, os, m, existing, value, token) {
+        if (this.sealed && os.changeset !== exports.EMPTY_SNAPSHOT.changeset)
+            throw (0, Dbg_1.misuse)(`reactive property ${Dump.obj(h, m)} can only be modified inside transaction`);
+        if (m !== Data_1.Meta.Handle && value !== Data_1.Meta.Handle) {
+            if (os.changeset !== this || os.former.snapshot !== exports.EMPTY_SNAPSHOT) {
+                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.snapshot(os, m)})`);
+            }
+            if (os === exports.EMPTY_SNAPSHOT)
+                throw (0, Dbg_1.misuse)(`member ${Dump.snapshot(os, m)} doesn't exist in snapshot v${this.revision} (${this.hint})`);
+        }
+        return os.changeset !== this && !this.sealed;
+    }
+    acquire(outer) {
+        if (!this.sealed && this.revision === exports.UNDEFINED_REVISION) {
+            const ahead = this.options.token === undefined || outer.revision === exports.UNDEFINED_REVISION;
+            this.revision = ahead ? Changeset.stampGen : outer.revision;
+            Changeset.pending.push(this);
+            if (Changeset.oldest === undefined)
+                Changeset.oldest = this;
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
+                Dbg_1.Log.write('╔══', `v${this.revision}`, `${this.hint}`);
+        }
+    }
+    bumpBy(timestamp) {
+        if (timestamp > this.bumper)
+            this.bumper = timestamp;
+    }
+    rebase() {
+        let conflicts = undefined;
+        if (this.items.size > 0) {
+            this.items.forEach((os, h) => {
+                if (os.former.snapshot !== h.head) {
+                    const merged = this.merge(h, os);
+                    if (os.conflicts.size > 0) {
+                        if (!conflicts)
+                            conflicts = [];
+                        conflicts.push(os);
+                    }
+                    if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
+                        Dbg_1.Log.write('╠╝', '', `${Dump.snapshot2(h, os.changeset)} is merged with ${Dump.snapshot2(h, h.head.changeset)} among ${merged} properties with ${os.conflicts.size} conflicts.`);
+                }
+            });
+            if (this.options.token === undefined) {
+                if (this.bumper > 100) {
+                    this.bumper = this.revision;
+                    this.revision = ++Changeset.stampGen;
+                }
+                else
+                    this.revision = this.bumper + 1;
+            }
+            else {
+                this.revision = this.bumper;
+            }
+        }
+        return conflicts;
+    }
+    merge(h, ours) {
+        let counter = 0;
+        const head = h.head;
+        const headDisposed = head.disposed;
+        const oursDisposed = ours.disposed;
+        const merged = Object.assign({}, head.data);
+        ours.changes.forEach((o, m) => {
+            counter++;
+            merged[m] = ours.data[m];
+            if (headDisposed || oursDisposed) {
+                if (headDisposed !== oursDisposed) {
+                    if (headDisposed || this.options.standalone !== 'disposal') {
+                        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
+                            Dbg_1.Log.write('║╠', '', `${Dump.snapshot2(h, ours.changeset, m)} <> ${Dump.snapshot2(h, head.changeset, m)}`, 0, ' *** CONFLICT ***');
+                        ours.conflicts.set(m, head);
+                    }
+                }
+            }
+            else {
+                const conflict = Changeset.isConflicting(head.data[m], ours.former.snapshot.data[m]);
+                if (conflict)
+                    ours.conflicts.set(m, head);
+                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
+                    Dbg_1.Log.write('║╠', '', `${Dump.snapshot2(h, ours.changeset, m)} ${conflict ? '<>' : '=='} ${Dump.snapshot2(h, head.changeset, m)}`, 0, conflict ? ' *** CONFLICT ***' : undefined);
+            }
+        });
+        Utils_1.Utils.copyAllMembers(merged, ours.data);
+        ours.former.snapshot = head;
+        return counter;
+    }
+    applyOrDiscard(error) {
+        this.sealed = true;
+        this.items.forEach((os, h) => {
+            Changeset.sealObjectSnapshot(h, os);
+            h.editors--;
+            if (h.editors === 0)
+                h.editing = undefined;
+            if (!error) {
+                h.head = os;
+                if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
+                    Changeset.totalObjectSnapshotCount++;
+                    if (os.former.snapshot === exports.EMPTY_SNAPSHOT)
+                        Changeset.totalObjectHandleCount++;
+                }
+            }
+        });
+        if (Dbg_1.Log.isOn) {
+            if (Dbg_1.Log.opt.change && !error) {
+                this.items.forEach((os, h) => {
+                    const members = [];
+                    os.changes.forEach((o, m) => members.push(m.toString()));
+                    const s = members.join(', ');
+                    Dbg_1.Log.write('║', '√', `${Dump.snapshot2(h, os.changeset)} (${s}) is ${os.former.snapshot === exports.EMPTY_SNAPSHOT ? 'constructed' : `applied on top of ${Dump.snapshot2(h, os.former.snapshot.changeset)}`}`);
+                });
+            }
+            if (Dbg_1.Log.opt.transaction)
+                Dbg_1.Log.write(this.revision < exports.UNDEFINED_REVISION ? '╚══' : '═══', `v${this.revision}`, `${this.hint} - ${error ? 'CANCEL' : 'APPLY'}(${this.items.size})${error ? ` - ${error}` : ''}`);
+        }
+        if (!error)
+            Changeset.propagateAllChangesThroughSubscriptions(this);
+        return this.reactions;
+    }
+    static sealObjectSnapshot(h, os) {
+        if (!os.disposed)
+            os.changes.forEach((o, m) => Changeset.sealSubscription(os.data[m], m, h.proxy.constructor.name));
+        else
+            for (const m in os.former.snapshot.data)
+                os.data[m] = Data_1.Meta.Undefined;
+        if (Dbg_1.Log.isOn)
+            Changeset.freezeObjectSnapshot(os);
+    }
+    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)
+                    subscription.content = Sealant_1.Sealant.seal(value, sealedType, typeName, m);
+            }
+        }
+    }
+    static freezeObjectSnapshot(os) {
+        Object.freeze(os.data);
+        Utils_1.Utils.freezeSet(os.changes);
+        Utils_1.Utils.freezeMap(os.conflicts);
+        return os;
+    }
+    triggerGarbageCollection() {
+        if (this.revision !== 0) {
+            if (this === Changeset.oldest) {
+                const p = Changeset.pending;
+                p.sort((a, b) => a.revision - b.revision);
+                let i = 0;
+                while (i < p.length && p[i].sealed) {
+                    p[i].unlinkHistory();
+                    i++;
+                }
+                Changeset.pending = p.slice(i);
+                Changeset.oldest = Changeset.pending[0];
+                const now = Date.now();
+                if (now - Changeset.lastGarbageCollectionSummaryTimestamp > Changeset.garbageCollectionSummaryInterval) {
+                    Dbg_1.Log.write('', '[G]', `Total object/snapshot count: ${Changeset.totalObjectHandleCount}/${Changeset.totalObjectSnapshotCount}`);
+                    Changeset.lastGarbageCollectionSummaryTimestamp = now;
+                }
+            }
+        }
+    }
+    unlinkHistory() {
+        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc)
+            Dbg_1.Log.write('', '[G]', `Dismiss history below v${this.revision}t${this.id} (${this.hint})`);
+        this.items.forEach((os, h) => {
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc && os.former.snapshot !== exports.EMPTY_SNAPSHOT)
+                Dbg_1.Log.write(' ', '  ', `${Dump.snapshot2(h, os.former.snapshot.changeset)} is ready for GC because overwritten by ${Dump.snapshot2(h, os.changeset)}`);
+            if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
+                if (os.former.snapshot !== exports.EMPTY_SNAPSHOT)
+                    Changeset.totalObjectSnapshotCount--;
+                if (os.disposed)
+                    Changeset.totalObjectHandleCount--;
+            }
+            os.former.snapshot = exports.EMPTY_SNAPSHOT;
+        });
+        this.items = EMPTY_MAP;
+        this.reactions = EMPTY_ARRAY;
+        if (Dbg_1.Log.isOn)
+            Object.freeze(this);
+    }
+    static _init() {
+        const boot = exports.EMPTY_SNAPSHOT.changeset;
+        boot.acquire(boot);
+        boot.applyOrDiscard();
+        boot.triggerGarbageCollection();
+        Changeset.freezeObjectSnapshot(exports.EMPTY_SNAPSHOT);
+        Changeset.idGen = 100;
+        Changeset.stampGen = 101;
+        Changeset.oldest = undefined;
+        SealedArray_1.SealedArray.prototype;
+        SealedMap_1.SealedMap.prototype;
+        SealedSet_1.SealedSet.prototype;
+    }
+}
+exports.Changeset = Changeset;
+Changeset.idGen = -1;
+Changeset.stampGen = 1;
+Changeset.pending = [];
+Changeset.oldest = undefined;
+Changeset.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
+Changeset.lastGarbageCollectionSummaryTimestamp = Date.now();
+Changeset.totalObjectHandleCount = 0;
+Changeset.totalObjectSnapshotCount = 0;
+Changeset.current = Utils_1.UNDEF;
+Changeset.edit = Utils_1.UNDEF;
+Changeset.markUsed = Utils_1.UNDEF;
+Changeset.markEdited = Utils_1.UNDEF;
+Changeset.isConflicting = Utils_1.UNDEF;
+Changeset.propagateAllChangesThroughSubscriptions = (changeset) => { };
+Changeset.revokeAllSubscriptions = (changeset) => { };
+Changeset.enqueueReactionsToRun = (reactions) => { };
+class Dump {
+    static obj(h, m, stamp, snapshotId, originSnapshotId, value) {
+        const member = m !== undefined ? `.${m.toString()}` : '';
+        let result;
+        if (h !== undefined) {
+            const v = value !== undefined && value !== Data_1.Meta.Undefined ? `[=${Dump.valueHint(value)}]` : '';
+            if (stamp === undefined)
+                result = `${h.hint}${member}${v} #${h.id}`;
+            else
+                result = `${h.hint}${member}${v} #${h.id}t${snapshotId}v${stamp}${originSnapshotId !== undefined && originSnapshotId !== 0 ? `t${originSnapshotId}` : ''}`;
+        }
+        else
+            result = `boot${member}`;
+        return result;
+    }
+    static snapshot2(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.content) !== null && _a !== void 0 ? _a : Data_1.Meta.Undefined);
+    }
+    static snapshot(os, m) {
+        const h = Data_1.Meta.get(os.data, Data_1.Meta.Handle);
+        const value = m !== undefined ? os.data[m] : undefined;
+        return Dump.obj(h, m, os.changeset.timestamp, os.changeset.id, value === null || value === void 0 ? void 0 : value.originSnapshotId);
+    }
+    static conflicts(conflicts) {
+        return conflicts.map(ours => {
+            const items = [];
+            ours.conflicts.forEach((theirs, m) => {
+                items.push(Dump.conflictingMemberHint(m, ours, theirs));
+            });
+            return items.join(', ');
+        }).join(', ');
+    }
+    static conflictingMemberHint(m, ours, theirs) {
+        return `${theirs.changeset.hint} (${Dump.snapshot(theirs, m)})`;
+    }
+}
+exports.Dump = Dump;
+Dump.valueHint = (value, m) => '???';
+exports.EMPTY_SNAPSHOT = new Data_1.ObjectSnapshot(new Changeset({ hint: '<empty>' }), undefined, {});
+exports.DefaultSnapshotOptions = Object.freeze({
+    hint: 'noname',
+    standalone: false,
+    journal: undefined,
+    logging: undefined,
+    token: undefined,
+});

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

@@ -0,0 +1,60 @@
+export { Meta } from './Meta';
+export interface AbstractChangeset {
+    readonly id: number;
+    readonly hint: string;
+    readonly timestamp: number;
+    readonly sealed: boolean;
+}
+export declare class Subscription {
+    content: any;
+    subscribers?: Set<Subscriber>;
+    get isOperation(): boolean;
+    get originSnapshotId(): number | undefined;
+    constructor(content: any);
+}
+export declare type StandaloneMode = boolean | 'isolated' | 'disposal';
+export interface Subscriber {
+    readonly order: number;
+    readonly subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
+    readonly obsoleteSince: number;
+    hint(nop?: boolean): string;
+    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactions: Array<Subscriber>): void;
+    runIfNotUpToDate(now: boolean, nothrow: boolean): void;
+}
+export declare type MemberName = PropertyKey;
+export interface SubscriptionInfo {
+    readonly memberHint: string;
+    readonly usageCount: number;
+}
+export declare class ObjectSnapshot {
+    readonly changeset: AbstractChangeset;
+    readonly former: {
+        snapshot: ObjectSnapshot;
+    };
+    readonly data: any;
+    readonly changes: Set<MemberName>;
+    readonly conflicts: Map<MemberName, ObjectSnapshot>;
+    constructor(changeset: AbstractChangeset, former: ObjectSnapshot | undefined, data: object);
+    get revision(): number;
+    get disposed(): boolean;
+    set disposed(value: boolean);
+}
+export declare class ObjectHandle {
+    private static generator;
+    readonly id: number;
+    readonly data: any;
+    readonly proxy: any;
+    head: ObjectSnapshot;
+    editing?: ObjectSnapshot;
+    editors: number;
+    hint: string;
+    constructor(data: any, proxy: any, handler: ProxyHandler<ObjectHandle>, head: ObjectSnapshot, hint: string);
+    static getHint(obj: object, full: boolean): string | undefined;
+}
+export declare type PatchSet = Map<object, Map<MemberName, ValuePatch>>;
+export interface ValuePatch {
+    memberName: MemberName;
+    patchKind: 'update' | 'add' | 'remove';
+    freshValue: any;
+    formerValue: any;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectHandle = exports.ObjectSnapshot = 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 Subscription {
+    constructor(content) { this.content = content; }
+    get isOperation() { return false; }
+    get originSnapshotId() { return 0; }
+}
+exports.Subscription = Subscription;
+class ObjectSnapshot {
+    constructor(changeset, former, data) {
+        this.changeset = changeset;
+        this.former = { snapshot: former || this };
+        this.data = data;
+        this.changes = new Set();
+        this.conflicts = new Map();
+        if (Dbg_1.Log.isOn)
+            Object.freeze(this);
+    }
+    get revision() {
+        return this.data[Meta_1.Meta.Revision].content;
+    }
+    get disposed() { return this.revision < 0; }
+    set disposed(value) {
+        const rev = this.revision;
+        if (rev < 0 !== value)
+            this.data[Meta_1.Meta.Revision].content = ~rev;
+    }
+}
+exports.ObjectSnapshot = ObjectSnapshot;
+class ObjectHandle {
+    constructor(data, proxy, handler, head, hint) {
+        this.id = ++ObjectHandle.generator;
+        this.data = data;
+        this.proxy = proxy || new Proxy(this, handler);
+        this.head = head;
+        this.editing = undefined;
+        this.editors = 0;
+        this.hint = hint;
+    }
+    static getHint(obj, full) {
+        const h = Meta_1.Meta.get(obj, Meta_1.Meta.Handle);
+        return h !== undefined ? (full ? `${h.hint}#${h.id}` : h.hint) : undefined;
+    }
+}
+exports.ObjectHandle = ObjectHandle;
+ObjectHandle.generator = 19;