reactronic 0.22.308 → 0.22.311

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

@@ -0,0 +1,96 @@
+import { F } from '../util/Utils';
+import { MemberOptions, Kind, Reentrance } from '../Options';
+import { LoggingOptions, ProfilingOptions } from '../Logging';
+import { MemberName, ObjectHandle, StandaloneMode } from './Data';
+import { Journal } from './Journal';
+import { Monitor } from './Monitor';
+export declare abstract class ReactiveObject {
+    constructor();
+    [Symbol.toStringTag](): string;
+}
+export declare class ReactiveArray<T> extends ReactiveObject {
+    private a;
+    get length(): number;
+    set length(n: number);
+    get(n: number): T;
+    set(n: number, item: T): void;
+    toString(): string;
+    toLocaleString(): string;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    concat(...items: (T | ConcatArray<T>)[]): T[];
+    join(separator?: string): string;
+    reverse(): T[];
+    shift(): T | undefined;
+    slice(start?: number, end?: number): T[];
+    sort(compareFn?: (a: T, b: T) => number): this;
+    splice(start: number, deleteCount?: number): T[];
+    unshift(...items: T[]): number;
+    indexOf(searchElement: T, fromIndex?: number): number;
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
+    filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+    entries(): IterableIterator<[number, T]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<T>;
+    private get mutable();
+}
+export declare class ReactiveMap<K, V> extends ReactiveObject {
+    private m;
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    get size(): number;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    private get mutable();
+}
+export declare class OptionsImpl implements MemberOptions {
+    readonly getter: Function;
+    readonly setter: Function;
+    readonly kind: Kind;
+    readonly standalone: StandaloneMode;
+    readonly order: number;
+    readonly noSideEffects: boolean;
+    readonly triggeringArgs: boolean;
+    readonly throttling: number;
+    readonly reentrance: Reentrance;
+    readonly journal: Journal | undefined;
+    readonly monitor: Monitor | null;
+    readonly logging?: Partial<LoggingOptions>;
+    static readonly INITIAL: Readonly<OptionsImpl>;
+    constructor(getter: Function | undefined, setter: Function | undefined, existing: OptionsImpl, patch: Partial<OptionsImpl>, implicit: boolean);
+}
+export declare class Hooks implements ProxyHandler<ObjectHandle> {
+    static reactionsAutoStartDisabled: boolean;
+    static repetitiveUsageWarningThreshold: number;
+    static mainThreadBlockingWarningThreshold: number;
+    static asyncActionDurationWarningThreshold: number;
+    static sensitivity: boolean;
+    static readonly handler: Hooks;
+    getPrototypeOf(h: ObjectHandle): object | null;
+    get(h: ObjectHandle, m: MemberName, receiver: any): any;
+    set(h: ObjectHandle, m: MemberName, value: any, receiver: any): boolean;
+    has(h: ObjectHandle, m: MemberName): boolean;
+    getOwnPropertyDescriptor(h: ObjectHandle, m: MemberName): PropertyDescriptor | undefined;
+    ownKeys(h: ObjectHandle): Array<string | symbol>;
+    static decorateData(reactive: boolean, proto: any, m: MemberName): any;
+    static decorateOperation(implicit: boolean, decorator: Function, options: Partial<MemberOptions>, proto: any, member: MemberName, pd: PropertyDescriptor | undefined): any;
+    static decorateOperationParametrized(decorator: Function, options: Partial<MemberOptions>): F<any>;
+    static acquireHandle(obj: any): ObjectHandle;
+    static createHandleForReactiveObject(proto: any, data: any, blank: any, hint: string): ObjectHandle;
+    static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
+    static sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
+    static setHint<T>(obj: T, hint: string | undefined): T;
+    static createOperation: (h: ObjectHandle, m: MemberName, options: OptionsImpl) => F<any>;
+    static rememberOperationOptions: (proto: any, m: MemberName, getter: Function | undefined, setter: Function | undefined, enumerable: boolean, configurable: boolean, options: Partial<MemberOptions>, implicit: boolean) => OptionsImpl;
+}

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

@@ -0,0 +1,302 @@
+import { UNDEF } from '../util/Utils';
+import { Sealant } from '../util/Sealant';
+import { Log, misuse } from '../util/Dbg';
+import { Kind, Reentrance } from '../Options';
+import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
+import { Changeset, Dump, EMPTY_SNAPSHOT } from './Changeset';
+export class ReactiveObject {
+    constructor() {
+        const proto = new.target.prototype;
+        const initial = Meta.getFrom(proto, Meta.Initial);
+        const h = Hooks.createHandleForReactiveObject(proto, this, initial, new.target.name);
+        return h.proxy;
+    }
+    [Symbol.toStringTag]() {
+        const h = Meta.get(this, Meta.Handle);
+        return Dump.obj(h);
+    }
+}
+export class ReactiveArray extends ReactiveObject {
+    constructor() {
+        super(...arguments);
+        this.a = new Array();
+    }
+    get length() { return this.a.length; }
+    set length(n) { this.a.length = n; }
+    get(n) { return this.a[n]; }
+    set(n, item) { this.mutable[n] = item; }
+    toString() { return this.a.toString(); }
+    toLocaleString() { return this.a.toLocaleString(); }
+    pop() { return this.mutable.pop(); }
+    push(...items) { return this.mutable.push(...items); }
+    concat(...items) { return this.a.concat(...items); }
+    join(separator) { return this.a.join(separator); }
+    reverse() { return this.mutable.reverse(); }
+    shift() { return this.mutable.shift(); }
+    slice(start, end) { return this.a.slice(start, end); }
+    sort(compareFn) { this.mutable.sort(compareFn); return this; }
+    splice(start, deleteCount, ...items) { return this.mutable.splice(start, deleteCount, ...items); }
+    unshift(...items) { return this.mutable.unshift(...items); }
+    indexOf(searchElement, fromIndex) { return this.a.indexOf(searchElement, fromIndex); }
+    lastIndexOf(searchElement, fromIndex) { return this.a.lastIndexOf(searchElement, fromIndex); }
+    every(predicate, thisArg) { return this.a.every(predicate, thisArg); }
+    some(predicate, thisArg) { return this.a.some(predicate, thisArg); }
+    forEach(callbackfn, thisArg) { return this.a.forEach(callbackfn, thisArg); }
+    map(callbackfn, thisArg) { return this.a.map(callbackfn, thisArg); }
+    filter(predicate, thisArg) { return this.a.filter(predicate, thisArg); }
+    reduce(callbackfn, initialValue) { return this.a.reduce(callbackfn, initialValue); }
+    reduceRight(callbackfn, initialValue) { return this.a.reduceRight(callbackfn, initialValue); }
+    entries() { return this.a.entries(); }
+    keys() { return this.a.keys(); }
+    values() { return this.a.values(); }
+    get mutable() {
+        const createCopy = this.a[Sealant.CreateCopy];
+        if (createCopy)
+            return this.a = createCopy.call(this.a);
+        return this.a;
+    }
+}
+export class ReactiveMap extends ReactiveObject {
+    constructor() {
+        super(...arguments);
+        this.m = new Map();
+    }
+    clear() { this.mutable.clear(); }
+    delete(key) { return this.mutable.delete(key); }
+    forEach(callbackfn, thisArg) { this.m.forEach(callbackfn, thisArg); }
+    get(key) { return this.m.get(key); }
+    has(key) { return this.m.has(key); }
+    set(key, value) { this.mutable.set(key, value); return this; }
+    get size() { return this.m.size; }
+    entries() { return this.m.entries(); }
+    keys() { return this.m.keys(); }
+    values() { return this.m.values(); }
+    get mutable() {
+        const createCopy = this.m[Sealant.CreateCopy];
+        if (createCopy)
+            return this.m = createCopy.call(this.m);
+        return this.m;
+    }
+}
+const DEFAULT_OPTIONS = Object.freeze({
+    kind: Kind.Plain,
+    standalone: false,
+    order: 0,
+    noSideEffects: false,
+    triggeringArgs: false,
+    throttling: Number.MAX_SAFE_INTEGER,
+    reentrance: Reentrance.PreventWithError,
+    journal: undefined,
+    monitor: null,
+    logging: undefined,
+});
+export class OptionsImpl {
+    constructor(getter, setter, existing, patch, implicit) {
+        this.getter = getter !== undefined ? getter : existing.getter;
+        this.setter = setter !== undefined ? setter : existing.setter;
+        this.kind = merge(DEFAULT_OPTIONS.kind, existing.kind, patch.kind, implicit);
+        this.standalone = merge(DEFAULT_OPTIONS.standalone, existing.standalone, patch.standalone, implicit);
+        this.order = merge(DEFAULT_OPTIONS.order, existing.order, patch.order, implicit);
+        this.noSideEffects = merge(DEFAULT_OPTIONS.noSideEffects, existing.noSideEffects, patch.noSideEffects, implicit);
+        this.triggeringArgs = merge(DEFAULT_OPTIONS.triggeringArgs, existing.triggeringArgs, patch.triggeringArgs, implicit);
+        this.throttling = merge(DEFAULT_OPTIONS.throttling, existing.throttling, patch.throttling, implicit);
+        this.reentrance = merge(DEFAULT_OPTIONS.reentrance, existing.reentrance, patch.reentrance, implicit);
+        this.journal = merge(DEFAULT_OPTIONS.journal, existing.journal, patch.journal, implicit);
+        this.monitor = merge(DEFAULT_OPTIONS.monitor, existing.monitor, patch.monitor, implicit);
+        this.logging = merge(DEFAULT_OPTIONS.logging, existing.logging, patch.logging, implicit);
+        if (Log.isOn)
+            Object.freeze(this);
+    }
+}
+OptionsImpl.INITIAL = Object.freeze(new OptionsImpl(UNDEF, UNDEF, Object.assign({ getter: UNDEF, setter: UNDEF }, DEFAULT_OPTIONS), {}, false));
+function merge(def, existing, patch, implicit) {
+    return patch !== undefined && (existing === def || !implicit) ? patch : existing;
+}
+export class Hooks {
+    getPrototypeOf(h) {
+        return Reflect.getPrototypeOf(h.data);
+    }
+    get(h, m, receiver) {
+        let result;
+        if (m !== Meta.Handle) {
+            const cs = Changeset.current();
+            const os = cs.getRelevantSnapshot(h, m);
+            result = os.data[m];
+            if (result instanceof Subscription && !result.isOperation) {
+                Changeset.markUsed(result, os, m, h, Kind.Plain, false);
+                result = result.content;
+            }
+            else
+                result = Reflect.get(h.data, m, receiver);
+        }
+        else
+            result = h;
+        return result;
+    }
+    set(h, m, value, receiver) {
+        const os = Changeset.edit().getEditableSnapshot(h, m, value);
+        if (os !== EMPTY_SNAPSHOT) {
+            let curr = os.data[m];
+            if (curr !== undefined || (os.former.snapshot.changeset === EMPTY_SNAPSHOT.changeset && (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 (os.former.snapshot.data[m] === curr) {
+                        curr = os.data[m] = new Subscription(value);
+                        Changeset.markEdited(existing, value, true, os, m, h);
+                    }
+                    else {
+                        curr.content = value;
+                        Changeset.markEdited(existing, value, true, os, m, h);
+                    }
+                }
+            }
+            else
+                Reflect.set(h.data, m, value, receiver);
+        }
+        else
+            h.data[m] = value;
+        return true;
+    }
+    has(h, m) {
+        const os = Changeset.current().getRelevantSnapshot(h, m);
+        return m in os.data || m in h.data;
+    }
+    getOwnPropertyDescriptor(h, m) {
+        const os = Changeset.current().getRelevantSnapshot(h, m);
+        const pd = Reflect.getOwnPropertyDescriptor(os.data, m);
+        if (pd)
+            pd.configurable = pd.writable = true;
+        return pd;
+    }
+    ownKeys(h) {
+        const os = Changeset.current().getRelevantSnapshot(h, Meta.Handle);
+        const result = [];
+        for (const m of Object.getOwnPropertyNames(os.data)) {
+            const value = os.data[m];
+            if (!(value instanceof Subscription) || !value.isOperation)
+                result.push(m);
+        }
+        return result;
+    }
+    static decorateData(reactive, proto, m) {
+        if (reactive) {
+            const get = function () {
+                const h = Hooks.acquireHandle(this);
+                return Hooks.handler.get(h, m, this);
+            };
+            const set = function (value) {
+                const h = Hooks.acquireHandle(this);
+                return Hooks.handler.set(h, m, value, this);
+            };
+            const enumerable = true;
+            const configurable = false;
+            return Object.defineProperty(proto, m, { get, set, enumerable, configurable });
+        }
+        else
+            Meta.acquire(proto, Meta.Initial)[m] = Meta.Nonreactive;
+    }
+    static decorateOperation(implicit, decorator, options, proto, member, pd) {
+        var _a, _b, _c, _d;
+        if (pd === undefined || pd === proto)
+            pd = EMPTY_PROP_DESCRIPTOR;
+        const enumerable = (_a = pd.enumerable) !== null && _a !== void 0 ? _a : true;
+        const configurable = (_b = pd.configurable) !== null && _b !== void 0 ? _b : true;
+        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.acquireHandle(this);
+                const operation = Hooks.createOperation(h, member, opts);
+                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 === UNDEF) {
+            const bootstrap = function () {
+                const h = Hooks.acquireHandle(this);
+                const operation = Hooks.createOperation(h, member, opts);
+                Object.defineProperty(h.data, member, { get: operation, enumerable, configurable });
+                return operation.call(this);
+            };
+            return Object.defineProperty(proto, member, { get: bootstrap, enumerable, configurable: true });
+        }
+        else
+            throw misuse(`${proto.constructor.name}.${member.toString()} has setter and cannot be decorated with @${decorator.name}`);
+    }
+    static decorateOperationParametrized(decorator, options) {
+        return function (proto, prop, pd) {
+            return Hooks.decorateOperation(false, decorator, options, proto, prop, pd);
+        };
+    }
+    static acquireHandle(obj) {
+        let h = obj[Meta.Handle];
+        if (!h) {
+            if (obj !== Object(obj) || Array.isArray(obj))
+                throw misuse('only objects can be reactive');
+            const initial = Meta.getFrom(Object.getPrototypeOf(obj), Meta.Initial);
+            const os = new ObjectSnapshot(EMPTY_SNAPSHOT.changeset, EMPTY_SNAPSHOT, Object.assign({}, initial));
+            h = new ObjectHandle(obj, obj, Hooks.handler, os, obj.constructor.name);
+            Meta.set(os.data, Meta.Handle, h);
+            Meta.set(obj, Meta.Handle, h);
+            Meta.set(os.data, Meta.Revision, new Subscription(1));
+        }
+        return h;
+    }
+    static createHandleForReactiveObject(proto, data, blank, hint) {
+        const ctx = Changeset.edit();
+        const h = new ObjectHandle(data, undefined, Hooks.handler, EMPTY_SNAPSHOT, hint);
+        ctx.getEditableSnapshot(h, Meta.Handle, blank);
+        if (!Hooks.reactionsAutoStartDisabled)
+            for (const m in Meta.getFrom(proto, Meta.Reactions))
+                h.proxy[m][Meta.Controller].markObsolete();
+        return h;
+    }
+    static setProfilingMode(isOn, options) {
+        if (isOn) {
+            Hooks.repetitiveUsageWarningThreshold = options && options.repetitiveUsageWarningThreshold !== undefined ? options.repetitiveUsageWarningThreshold : 10;
+            Hooks.mainThreadBlockingWarningThreshold = options && options.mainThreadBlockingWarningThreshold !== undefined ? options.mainThreadBlockingWarningThreshold : 14;
+            Hooks.asyncActionDurationWarningThreshold = options && options.asyncActionDurationWarningThreshold !== undefined ? options.asyncActionDurationWarningThreshold : 300;
+            Changeset.garbageCollectionSummaryInterval = options && options.garbageCollectionSummaryInterval !== undefined ? options.garbageCollectionSummaryInterval : 100;
+        }
+        else {
+            Hooks.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
+            Hooks.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
+            Hooks.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
+            Changeset.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
+        }
+    }
+    static sensitive(sensitivity, func, ...args) {
+        const restore = Hooks.sensitivity;
+        Hooks.sensitivity = sensitivity;
+        try {
+            return func(...args);
+        }
+        finally {
+            Hooks.sensitivity = restore;
+        }
+    }
+    static setHint(obj, hint) {
+        if (hint) {
+            const h = Hooks.acquireHandle(obj);
+            h.hint = hint;
+        }
+        return obj;
+    }
+}
+Hooks.reactionsAutoStartDisabled = false;
+Hooks.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
+Hooks.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
+Hooks.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
+Hooks.sensitivity = false;
+Hooks.handler = new Hooks();
+Hooks.createOperation = function (h, m, options) {
+    throw misuse('createOperation should never be called');
+};
+Hooks.rememberOperationOptions = function (proto, m, getter, setter, enumerable, configurable, options, implicit) {
+    throw misuse('rememberOperationOptions should never be called');
+};
+const EMPTY_PROP_DESCRIPTOR = {
+    configurable: true,
+    enumerable: true,
+    value: undefined,
+};

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

@@ -0,0 +1,34 @@
+import { ReactiveObject } from './Hooks';
+import { ObjectHandle, ObjectSnapshot, PatchSet } from './Data';
+export declare type Saver = (patch: PatchSet) => Promise<void>;
+export declare abstract class Journal extends ReactiveObject {
+    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, items: Map<ObjectHandle, ObjectSnapshot>): PatchSet;
+    static applyPatch(patch: PatchSet, undoing: boolean): void;
+    mergePatchToUnsaved(patch: PatchSet, undoing: boolean): void;
+}

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

@@ -0,0 +1,144 @@
+import { ReactiveObject } from './Hooks';
+import { Meta, Subscription } from './Data';
+import { Changeset, EMPTY_SNAPSHOT } from './Changeset';
+import { Transaction } from './Transaction';
+import { Sealant } from '../util/Sealant';
+export class Journal extends ReactiveObject {
+    static create() { return new JournalImpl(); }
+}
+export class JournalImpl extends Journal {
+    constructor() {
+        super(...arguments);
+        this._capacity = 5;
+        this._edits = [];
+        this._unsaved = 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.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 = new Map();
+        else
+            throw new Error('not implemented');
+    }
+    undo(count = 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.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, items) {
+        const patch = new Map();
+        items.forEach((os, h) => {
+            const op = new Map();
+            const former = os.former.snapshot !== EMPTY_SNAPSHOT ? os.former.snapshot.data : undefined;
+            os.changes.forEach(m => {
+                const vp = {
+                    memberName: m, patchKind: 'update',
+                    freshValue: unseal(os.data[m]), formerValue: undefined,
+                };
+                if (former)
+                    vp.formerValue = unseal(former[m]);
+                op.set(m, vp);
+            });
+            if (!former) {
+                const vp = {
+                    memberName: Meta.Revision, patchKind: 'remove',
+                    freshValue: Meta.Undefined, formerValue: undefined,
+                };
+                op.set(Meta.Revision, vp);
+            }
+            patch.set(h.proxy, op);
+        });
+        return patch;
+    }
+    static applyPatch(patch, undoing) {
+        const ctx = Changeset.edit();
+        patch.forEach((op, obj) => {
+            const h = Meta.get(obj, Meta.Handle);
+            const rev = op.get(Meta.Revision);
+            const disposed = rev && (undoing ? rev.formerValue : rev.freshValue) === Meta.Undefined;
+            if (!disposed) {
+                op.forEach((vp, m) => {
+                    const value = undoing ? vp.formerValue : vp.freshValue;
+                    const os = ctx.getEditableSnapshot(h, m, value);
+                    if (os.changeset === ctx) {
+                        os.data[m] = new Subscription(value);
+                        const existing = os.former.snapshot.data[m];
+                        Changeset.markEdited(existing, value, existing !== value, os, m, h);
+                    }
+                });
+            }
+            else
+                Changeset.doDispose(ctx, h);
+        });
+    }
+    mergePatchToUnsaved(patch, undoing) {
+        const unsaved = this._unsaved = this._unsaved.toMutable();
+        patch.forEach((op, obj) => {
+            let result = unsaved.get(obj);
+            if (!result)
+                unsaved.set(obj, result = new Map());
+            op.forEach((vp, m) => {
+                let merged = result.get(m);
+                if (!merged)
+                    result.set(m, merged = {
+                        memberName: m, patchKind: 'update',
+                        freshValue: undefined, formerValue: undefined,
+                    });
+                const value = undoing ? vp.formerValue : vp.freshValue;
+                const former = undoing ? vp.freshValue : vp.formerValue;
+                if (value !== merged.formerValue) {
+                    merged.freshValue = value;
+                    merged.formerValue = former;
+                }
+                else {
+                    result.delete(m);
+                    if (result.size === 0)
+                        unsaved.delete(obj);
+                }
+            });
+        });
+    }
+}
+function unseal(subscription) {
+    const result = subscription.content;
+    const createCopy = result === null || result === void 0 ? void 0 : result[Sealant.CreateCopy];
+    return createCopy !== undefined ? createCopy.call(result) : result;
+}

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

@@ -0,0 +1,13 @@
+export declare abstract class Meta {
+    static readonly Handle: unique symbol;
+    static readonly Revision: unique symbol;
+    static readonly Controller: unique symbol;
+    static readonly Initial: unique symbol;
+    static readonly Reactions: unique symbol;
+    static readonly Nonreactive: unique symbol;
+    static readonly Undefined: unique symbol;
+    static get<T>(obj: any, sym: symbol): T;
+    static set(obj: any, sym: symbol, value: any): any;
+    static acquire(proto: any, sym: symbol): any;
+    static getFrom<T = any>(proto: any, sym: symbol): T;
+}

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

@@ -0,0 +1,29 @@
+const EMPTY_META = Object.freeze({});
+export class Meta {
+    static get(obj, sym) {
+        return obj[sym];
+    }
+    static set(obj, sym, value) {
+        Object.defineProperty(obj, sym, { value, configurable: false, enumerable: false });
+        return obj;
+    }
+    static acquire(proto, sym) {
+        let meta = proto[sym];
+        if (!proto.hasOwnProperty(sym)) {
+            meta = Object.assign({}, meta);
+            Meta.set(proto, sym, meta);
+        }
+        return meta;
+    }
+    static getFrom(proto, sym) {
+        var _a;
+        return (_a = proto[sym]) !== null && _a !== void 0 ? _a : EMPTY_META;
+    }
+}
+Meta.Handle = Symbol('rx-handle');
+Meta.Revision = Symbol('rx-revision');
+Meta.Controller = Symbol('rx-controller');
+Meta.Initial = Symbol('rx-initial');
+Meta.Reactions = Symbol('rx-reactions');
+Meta.Nonreactive = Symbol('rx-nonreactive');
+Meta.Undefined = Symbol('rx-undefined');

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

@@ -0,0 +1,32 @@
+import { Worker } from '../Worker';
+import { ReactiveObject } from './Hooks';
+export declare abstract class Monitor extends ReactiveObject {
+    abstract readonly isActive: boolean;
+    abstract readonly counter: number;
+    abstract readonly workers: ReadonlySet<Worker>;
+    abstract readonly duration: number;
+    static create(hint: string, activationDelay: number, deactivationDelay: number, durationResolution: number): Monitor;
+}
+export declare class MonitorImpl extends Monitor {
+    isActive: boolean;
+    counter: number;
+    workers: Set<Worker>;
+    duration: number;
+    internals: {
+        started: number;
+        activationDelay: number;
+        activationTimeout: undefined;
+        deactivationDelay: number;
+        deactivationTimeout: undefined;
+        durationResolution: number;
+    };
+    enter(worker: Worker): void;
+    leave(worker: Worker): void;
+    static create(hint: string, activationDelay: number, deactivationDelay: number, durationResolution: number): MonitorImpl;
+    static enter(mon: MonitorImpl, worker: Worker): void;
+    static leave(mon: MonitorImpl, worker: Worker): void;
+    private static doCreate;
+    private static activate;
+    private static deactivate;
+    private static tick;
+}