reactronic 0.22.301 → 0.22.304

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

@@ -1,50 +0,0 @@
-import { F } from '../util/Utils';
-import { MemberOptions, Kind, Reentrance } from '../Options';
-import { LoggingOptions, ProfilingOptions } from '../Logging';
-import { MemberName, DataHolder, StandaloneMode } from './Data';
-import { Journal } from './Journal';
-import { Monitor } from './Monitor';
-export declare abstract class ReactiveObject {
-    constructor();
-    [Symbol.toStringTag](): string;
-}
-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<DataHolder> {
-    static reactionsAutoStartDisabled: boolean;
-    static repetitiveUsageWarningThreshold: number;
-    static mainThreadBlockingWarningThreshold: number;
-    static asyncActionDurationWarningThreshold: number;
-    static sensitivity: boolean;
-    static readonly proxy: Hooks;
-    getPrototypeOf(h: DataHolder): object | null;
-    get(h: DataHolder, m: MemberName, receiver: any): any;
-    set(h: DataHolder, m: MemberName, value: any, receiver: any): boolean;
-    has(h: DataHolder, m: MemberName): boolean;
-    getOwnPropertyDescriptor(h: DataHolder, m: MemberName): PropertyDescriptor | undefined;
-    ownKeys(h: DataHolder): 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 acquireDataHolder(obj: any): DataHolder;
-    static createDataHolderForReactiveObject(proto: any, data: any, blank: any, hint: string): DataHolder;
-    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: DataHolder, 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

@@ -1,241 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hooks = exports.OptionsImpl = exports.ReactiveObject = void 0;
-const Utils_1 = require("../util/Utils");
-const Dbg_1 = require("../util/Dbg");
-const Options_1 = require("../Options");
-const Data_1 = require("./Data");
-const Snapshot_1 = require("./Snapshot");
-class ReactiveObject {
-    constructor() {
-        const proto = new.target.prototype;
-        const initial = Data_1.Meta.getFrom(proto, Data_1.Meta.Initial);
-        const h = Hooks.createDataHolderForReactiveObject(proto, this, initial, new.target.name);
-        return h.proxy;
-    }
-    [Symbol.toStringTag]() {
-        const h = Data_1.Meta.get(this, Data_1.Meta.Holder);
-        return Snapshot_1.Dump.obj(h);
-    }
-}
-exports.ReactiveObject = ReactiveObject;
-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;
-        const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
-        result = r.data[m];
-        if (result instanceof Data_1.Subscription && !result.isOperation) {
-            Snapshot_1.Snapshot.markUsed(result, r, m, h, Options_1.Kind.Plain, false);
-            result = result.content;
-        }
-        else if (m === Data_1.Meta.Holder) {
-        }
-        else
-            result = Reflect.get(h.data, m, receiver);
-        return result;
-    }
-    set(h, m, value, receiver) {
-        const r = Snapshot_1.Snapshot.edit().getEditableRevision(h, m, value);
-        if (r !== Snapshot_1.ROOT_REV) {
-            let curr = r.data[m];
-            if (curr !== undefined || (r.former.revision.snapshot === Snapshot_1.ROOT_REV.snapshot && (m in h.data) === false)) {
-                if (curr === undefined || curr.content !== value || Hooks.sensitivity) {
-                    const existing = curr === null || curr === void 0 ? void 0 : curr.content;
-                    if (r.former.revision.data[m] === curr) {
-                        curr = r.data[m] = new Data_1.Subscription(value);
-                        Snapshot_1.Snapshot.markEdited(existing, value, true, r, m, h);
-                    }
-                    else {
-                        curr.content = value;
-                        Snapshot_1.Snapshot.markEdited(existing, value, true, r, m, h);
-                    }
-                }
-            }
-            else
-                Reflect.set(h.data, m, value, receiver);
-        }
-        else
-            h.data[m] = value;
-        return true;
-    }
-    has(h, m) {
-        const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
-        return m in r.data || m in h.data;
-    }
-    getOwnPropertyDescriptor(h, m) {
-        const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
-        const pd = Reflect.getOwnPropertyDescriptor(r.data, m);
-        if (pd)
-            pd.configurable = pd.writable = true;
-        return pd;
-    }
-    ownKeys(h) {
-        const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, Data_1.Meta.Holder);
-        const result = [];
-        for (const m of Object.getOwnPropertyNames(r.data)) {
-            const value = r.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.acquireDataHolder(this);
-                return Hooks.proxy.get(h, m, this);
-            };
-            const set = function (value) {
-                const h = Hooks.acquireDataHolder(this);
-                return Hooks.proxy.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.acquireDataHolder(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.acquireDataHolder(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 acquireDataHolder(obj) {
-        let h = obj[Data_1.Meta.Holder];
-        if (!h) {
-            if (obj !== Object(obj) || Array.isArray(obj))
-                throw (0, Dbg_1.misuse)('only objects can be reactive');
-            const initial = Data_1.Meta.getFrom(Object.getPrototypeOf(obj), Data_1.Meta.Initial);
-            const rev = new Data_1.DataRevision(Snapshot_1.ROOT_REV.snapshot, Snapshot_1.ROOT_REV, Object.assign({}, initial));
-            Data_1.Meta.set(rev.data, Data_1.Meta.Holder, h);
-            h = new Data_1.DataHolder(obj, obj, Hooks.proxy, rev, obj.constructor.name);
-            Data_1.Meta.set(obj, Data_1.Meta.Holder, h);
-        }
-        return h;
-    }
-    static createDataHolderForReactiveObject(proto, data, blank, hint) {
-        const ctx = Snapshot_1.Snapshot.edit();
-        const h = new Data_1.DataHolder(data, undefined, Hooks.proxy, Snapshot_1.ROOT_REV, hint);
-        ctx.getEditableRevision(h, Data_1.Meta.Holder, blank);
-        if (!Hooks.reactionsAutoStartDisabled)
-            for (const m in Data_1.Meta.getFrom(proto, Data_1.Meta.Reactions))
-                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;
-            Snapshot_1.Snapshot.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;
-            Snapshot_1.Snapshot.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.acquireDataHolder(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.proxy = 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

@@ -1,34 +0,0 @@
-import { ReactiveObject } from './Hooks';
-import { DataHolder, DataRevision, 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, changeset: Map<DataHolder, DataRevision>): PatchSet;
-    static applyPatch(patch: PatchSet, undoing: boolean): void;
-    mergePatchToUnsaved(patch: PatchSet, undoing: boolean): void;
-}

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

@@ -1,138 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JournalImpl = exports.Journal = void 0;
-const Hooks_1 = require("./Hooks");
-const Data_1 = require("./Data");
-const Snapshot_1 = require("./Snapshot");
-const Transaction_1 = require("./Transaction");
-const Sealant_1 = require("../util/Sealant");
-class Journal extends Hooks_1.ReactiveObject {
-    static create() { return new JournalImpl(); }
-}
-exports.Journal = Journal;
-class JournalImpl extends Journal {
-    constructor() {
-        super(...arguments);
-        this._capacity = 5;
-        this._edits = [];
-        this._unsaved = { hint: 'unsaved', objects: new Map() };
-        this._position = 0;
-    }
-    get capacity() { return this._capacity; }
-    set capacity(value) { this._capacity = value; if (value < this._edits.length)
-        this._edits.splice(0, this._edits.length - value); }
-    get edits() { return this._edits; }
-    get unsaved() { return this._unsaved; }
-    get canUndo() { return this._edits.length > 0 && this._position > 0; }
-    get canRedo() { return this._position < this._edits.length; }
-    edited(p) {
-        Transaction_1.Transaction.run({ hint: 'EditJournal.edited', standalone: 'isolated' }, () => {
-            const items = this._edits = this._edits.toMutable();
-            if (items.length >= this._capacity)
-                items.shift();
-            else
-                items.splice(this._position);
-            this.mergePatchToUnsaved(p, false);
-            items.push(p);
-            this._position = items.length;
-        });
-    }
-    saved(patch) {
-        if (this._unsaved === patch)
-            this._unsaved = { hint: 'unsaved', objects: new Map() };
-        else
-            throw new Error('not implemented');
-    }
-    undo(count = 1) {
-        Transaction_1.Transaction.run({ hint: 'Journal.undo', standalone: 'isolated' }, () => {
-            let i = this._position - 1;
-            while (i >= 0 && count > 0) {
-                const patch = this._edits[i];
-                JournalImpl.applyPatch(patch, true);
-                this.mergePatchToUnsaved(patch, true);
-                i--, count--;
-            }
-            this._position = i + 1;
-        });
-    }
-    redo(count = 1) {
-        Transaction_1.Transaction.run({ hint: 'Journal.redo', standalone: 'isolated' }, () => {
-            let i = this._position;
-            while (i < this._edits.length && count > 0) {
-                const patch = this._edits[i];
-                JournalImpl.applyPatch(patch, false);
-                this.mergePatchToUnsaved(patch, false);
-                i++, count--;
-            }
-            this._position = i;
-        });
-    }
-    static buildPatch(hint, changeset) {
-        const patch = { hint, objects: new Map() };
-        changeset.forEach((r, h) => {
-            const op = { data: {}, former: {} };
-            const former = r.former.revision !== Snapshot_1.ROOT_REV ? r.former.revision.data : undefined;
-            r.changes.forEach(m => {
-                op.data[m] = unseal(r.data[m]);
-                if (former)
-                    op.former[m] = unseal(former[m]);
-            });
-            if (!former) {
-                delete op.data[Data_1.Meta.Disposed];
-                op.former[Data_1.Meta.Disposed] = Data_1.Meta.Disposed;
-            }
-            patch.objects.set(h.proxy, op);
-        });
-        return patch;
-    }
-    static applyPatch(patch, undoing) {
-        const ctx = Snapshot_1.Snapshot.edit();
-        patch.objects.forEach((dp, obj) => {
-            const h = Data_1.Meta.get(obj, Data_1.Meta.Holder);
-            const data = undoing ? dp.former : dp.data;
-            if (data[Data_1.Meta.Disposed] === undefined) {
-                for (const m in data) {
-                    const value = data[m];
-                    const r = ctx.getEditableRevision(h, m, value);
-                    if (r.snapshot === ctx) {
-                        r.data[m] = new Data_1.Subscription(value);
-                        const existing = r.former.revision.data[m];
-                        Snapshot_1.Snapshot.markEdited(existing, value, existing !== value, r, m, h);
-                    }
-                }
-            }
-            else
-                Snapshot_1.Snapshot.doDispose(ctx, h);
-        });
-    }
-    mergePatchToUnsaved(patch, undoing) {
-        const unsaved = this._unsaved;
-        patch.objects.forEach((dp, obj) => {
-            let merged = unsaved.objects.get(obj);
-            if (!merged)
-                unsaved.objects.set(obj, merged = { data: {}, former: {} });
-            const data = undoing ? dp.former : dp.data;
-            const former = undoing ? dp.data : dp.former;
-            for (const m in data) {
-                const value = data[m];
-                if (value !== merged.former[m]) {
-                    merged.data[m] = value;
-                    if (m in merged.former === false)
-                        merged.former[m] = former[m];
-                }
-                else {
-                    delete merged.data[m];
-                    delete merged.former[m];
-                    if (Object.keys(merged.data).length === 0)
-                        unsaved.objects.delete(obj);
-                }
-            }
-        });
-    }
-}
-exports.JournalImpl = JournalImpl;
-function unseal(subscription) {
-    const result = subscription.content;
-    const createCopy = result === null || result === void 0 ? void 0 : result[Sealant_1.Sealant.CreateCopy];
-    return createCopy !== undefined ? createCopy.call(result) : result;
-}

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

@@ -1,13 +0,0 @@
-export declare abstract class Meta {
-    static readonly Holder: unique symbol;
-    static readonly Controller: unique symbol;
-    static readonly Disposed: 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

@@ -1,33 +0,0 @@
-"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.Holder = Symbol('rxHolder');
-Meta.Controller = Symbol('rxController');
-Meta.Disposed = Symbol('rxDisposed');
-Meta.Initial = Symbol('rxInitial');
-Meta.Reactions = Symbol('rxReactions');
-Meta.Nonreactive = Symbol('rxNonreactive');
-Meta.Undefined = Symbol('rxUndefined');

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

@@ -1,32 +0,0 @@
-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

@@ -1,97 +0,0 @@
-"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;