reactronic 0.22.306 → 0.22.309

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

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hooks = exports.OptionsImpl = exports.ReactiveMap = exports.ReactiveArray = exports.ReactiveObject = void 0;
+const Utils_1 = require("../util/Utils");
+const Sealant_1 = require("../util/Sealant");
+const Dbg_1 = require("../util/Dbg");
+const Options_1 = require("../Options");
+const Data_1 = require("./Data");
+const Changeset_1 = require("./Changeset");
+class ReactiveObject {
+    constructor() {
+        const proto = new.target.prototype;
+        const initial = Data_1.Meta.getFrom(proto, Data_1.Meta.Initial);
+        const h = Hooks.createHandleForReactiveObject(proto, this, initial, new.target.name);
+        return h.proxy;
+    }
+    [Symbol.toStringTag]() {
+        const h = Data_1.Meta.get(this, Data_1.Meta.Handle);
+        return Changeset_1.Dump.obj(h);
+    }
+}
+exports.ReactiveObject = ReactiveObject;
+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_1.Sealant.CreateCopy];
+        if (createCopy)
+            return this.a = createCopy.call(this.a);
+        return this.a;
+    }
+}
+exports.ReactiveArray = ReactiveArray;
+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_1.Sealant.CreateCopy];
+        if (createCopy)
+            return this.m = createCopy.call(this.m);
+        return this.m;
+    }
+}
+exports.ReactiveMap = ReactiveMap;
+const DEFAULT_OPTIONS = Object.freeze({
+    kind: Options_1.Kind.Plain,
+    standalone: false,
+    order: 0,
+    noSideEffects: false,
+    triggeringArgs: false,
+    throttling: Number.MAX_SAFE_INTEGER,
+    reentrance: Options_1.Reentrance.PreventWithError,
+    journal: undefined,
+    monitor: null,
+    logging: undefined,
+});
+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 (Dbg_1.Log.isOn)
+            Object.freeze(this);
+    }
+}
+exports.OptionsImpl = OptionsImpl;
+OptionsImpl.INITIAL = Object.freeze(new OptionsImpl(Utils_1.UNDEF, Utils_1.UNDEF, Object.assign({ getter: Utils_1.UNDEF, setter: Utils_1.UNDEF }, DEFAULT_OPTIONS), {}, false));
+function merge(def, existing, patch, implicit) {
+    return patch !== undefined && (existing === def || !implicit) ? patch : existing;
+}
+class Hooks {
+    getPrototypeOf(h) {
+        return Reflect.getPrototypeOf(h.data);
+    }
+    get(h, m, receiver) {
+        let result;
+        if (m !== Data_1.Meta.Handle) {
+            const cs = Changeset_1.Changeset.current();
+            const os = cs.getRelevantSnapshot(h, m);
+            result = os.data[m];
+            if (result instanceof Data_1.Subscription && !result.isOperation) {
+                Changeset_1.Changeset.markUsed(result, os, m, h, Options_1.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_1.Changeset.edit().getEditableSnapshot(h, m, value);
+        if (os !== Changeset_1.EMPTY_SNAPSHOT) {
+            let curr = os.data[m];
+            if (curr !== undefined || (os.former.snapshot.changeset === Changeset_1.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 Data_1.Subscription(value);
+                        Changeset_1.Changeset.markEdited(existing, value, true, os, m, h);
+                    }
+                    else {
+                        curr.content = value;
+                        Changeset_1.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_1.Changeset.current().getRelevantSnapshot(h, m);
+        return m in os.data || m in h.data;
+    }
+    getOwnPropertyDescriptor(h, m) {
+        const os = Changeset_1.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_1.Changeset.current().getRelevantSnapshot(h, Data_1.Meta.Handle);
+        const result = [];
+        for (const m of Object.getOwnPropertyNames(os.data)) {
+            const value = os.data[m];
+            if (!(value instanceof Data_1.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
+            Data_1.Meta.acquire(proto, Data_1.Meta.Initial)[m] = Data_1.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 === Utils_1.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 (0, Dbg_1.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[Data_1.Meta.Handle];
+        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 os = new Data_1.ObjectSnapshot(Changeset_1.EMPTY_SNAPSHOT.changeset, Changeset_1.EMPTY_SNAPSHOT, Object.assign({}, initial));
+            h = new Data_1.ObjectHandle(obj, obj, Hooks.handler, os, obj.constructor.name);
+            Data_1.Meta.set(os.data, Data_1.Meta.Handle, h);
+            Data_1.Meta.set(obj, Data_1.Meta.Handle, h);
+            Data_1.Meta.set(os.data, Data_1.Meta.Revision, new Data_1.Subscription(1));
+        }
+        return h;
+    }
+    static createHandleForReactiveObject(proto, data, blank, hint) {
+        const ctx = Changeset_1.Changeset.edit();
+        const h = new Data_1.ObjectHandle(data, undefined, Hooks.handler, Changeset_1.EMPTY_SNAPSHOT, hint);
+        ctx.getEditableSnapshot(h, Data_1.Meta.Handle, blank);
+        if (!Hooks.reactionsAutoStartDisabled)
+            for (const m in Data_1.Meta.getFrom(proto, Data_1.Meta.Reactions))
+                h.proxy[m][Data_1.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_1.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_1.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;
+    }
+}
+exports.Hooks = Hooks;
+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 (0, Dbg_1.misuse)('createOperation should never be called');
+};
+Hooks.rememberOperationOptions = function (proto, m, getter, setter, enumerable, configurable, options, implicit) {
+    throw (0, Dbg_1.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,149 @@
+"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 Changeset_1 = require("./Changeset");
+const Transaction_1 = require("./Transaction");
+const Sealant_1 = require("../util/Sealant");
+class Journal extends Hooks_1.ReactiveObject {
+    static create() { return new JournalImpl(); }
+}
+exports.Journal = Journal;
+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_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 = 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, items) {
+        const patch = new Map();
+        items.forEach((os, h) => {
+            const op = new Map();
+            const former = os.former.snapshot !== Changeset_1.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: Data_1.Meta.Revision, patchKind: 'remove',
+                    freshValue: Data_1.Meta.Undefined, formerValue: undefined,
+                };
+                op.set(Data_1.Meta.Revision, vp);
+            }
+            patch.set(h.proxy, op);
+        });
+        return patch;
+    }
+    static applyPatch(patch, undoing) {
+        const ctx = Changeset_1.Changeset.edit();
+        patch.forEach((op, obj) => {
+            const h = Data_1.Meta.get(obj, Data_1.Meta.Handle);
+            const rev = op.get(Data_1.Meta.Revision);
+            const disposed = rev && (undoing ? rev.formerValue : rev.freshValue) === Data_1.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 Data_1.Subscription(value);
+                        const existing = os.former.snapshot.data[m];
+                        Changeset_1.Changeset.markEdited(existing, value, existing !== value, os, m, h);
+                    }
+                });
+            }
+            else
+                Changeset_1.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);
+                }
+            });
+        });
+    }
+}
+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

@@ -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,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Meta = void 0;
+const EMPTY_META = Object.freeze({});
+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;
+    }
+}
+exports.Meta = 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;
+}

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

@@ -0,0 +1,97 @@
+"use strict";
+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.ReactiveObject {
+    static create(hint, activationDelay, deactivationDelay, durationResolution) {
+        return MonitorImpl.create(hint, activationDelay, deactivationDelay, durationResolution);
+    }
+}
+exports.Monitor = Monitor;
+class MonitorImpl extends Monitor {
+    constructor() {
+        super(...arguments);
+        this.isActive = false;
+        this.counter = 0;
+        this.workers = new Set();
+        this.duration = 0;
+        this.internals = {
+            started: 0,
+            activationDelay: -1,
+            activationTimeout: undefined,
+            deactivationDelay: -1,
+            deactivationTimeout: undefined,
+            durationResolution: 1,
+        };
+    }
+    enter(worker) {
+        this.counter++;
+        const workers = this.workers = this.workers.toMutable();
+        workers.add(worker);
+        MonitorImpl.activate(this, this.internals.activationDelay);
+    }
+    leave(worker) {
+        this.counter--;
+        const workers = this.workers = this.workers.toMutable();
+        workers.delete(worker);
+        MonitorImpl.deactivate(this, this.internals.deactivationDelay);
+    }
+    static create(hint, activationDelay, deactivationDelay, durationResolution) {
+        return Transaction_1.Transaction.run({ hint: 'Monitor.create' }, MonitorImpl.doCreate, hint, activationDelay, deactivationDelay, durationResolution);
+    }
+    static enter(mon, worker) {
+        mon.enter(worker);
+    }
+    static leave(mon, worker) {
+        mon.leave(worker);
+    }
+    static doCreate(hint, activationDelay, deactivationDelay, durationResolution) {
+        const m = new MonitorImpl();
+        Hooks_1.Hooks.setHint(m, hint);
+        m.internals.activationDelay = activationDelay;
+        m.internals.deactivationDelay = deactivationDelay;
+        m.internals.durationResolution = durationResolution;
+        return m;
+    }
+    static activate(mon, delay) {
+        if (mon.internals.started === 0) {
+            mon.duration = 0;
+            mon.internals.started = performance.now();
+            MonitorImpl.tick(mon);
+        }
+        if (delay >= 0) {
+            if (mon.internals.activationTimeout === undefined)
+                mon.internals.activationTimeout = setTimeout(() => Transaction_1.Transaction.run({ hint: 'Monitor.activate', standalone: 'isolated' }, MonitorImpl.activate, mon, -1), delay);
+        }
+        else if (mon.counter > 0)
+            mon.isActive = true;
+    }
+    static deactivate(mon, delay) {
+        if (delay >= 0) {
+            clearTimeout(mon.internals.deactivationTimeout);
+            mon.internals.deactivationTimeout = setTimeout(() => Transaction_1.Transaction.run({ hint: 'Monitor.deactivate', standalone: 'isolated' }, MonitorImpl.deactivate, mon, -1), delay);
+        }
+        else if (mon.counter <= 0) {
+            mon.isActive = false;
+            mon.internals.activationTimeout = undefined;
+        }
+        if (mon.counter === 0 && mon.internals.started !== 0) {
+            const resolution = mon.internals.durationResolution;
+            mon.duration = Math.round(resolution * (performance.now() - mon.internals.started)) / resolution;
+            mon.internals.started = 0;
+        }
+    }
+    static tick(mon) {
+        if (mon.internals.started !== 0) {
+            Transaction_1.Transaction.run(null, () => {
+                const resolution = mon.internals.durationResolution;
+                mon.duration = Math.round(resolution * (performance.now() - mon.internals.started)) / resolution;
+            });
+            const t = globalThis !== null && globalThis !== void 0 ? globalThis : global;
+            if (t.requestAnimationFrame)
+                requestAnimationFrame(() => MonitorImpl.tick(mon));
+        }
+    }
+}
+exports.MonitorImpl = MonitorImpl;