reactronic 0.24.270 → 0.24.272

package/README.md

@@ -259,8 +259,8 @@ and reactive functions:
   - `cancelAndWaitPrevious` - cancel previous call in favor of recent one (but wait until canceling is completed)
   - `runSideBySide` - multiple simultaneous calls are allowed.
 
-**Monitor** is an object that maintains status of running functions,
-which it is attached to. A single monitor object can be shared between
+**Indicator** is an object that maintains status of running functions,
+which it is attached to. A single indicator object can be shared between
 multiple transactional, reactive, and cached functions, thus maintaining
 consolidated status for all of them (busy, workers, etc).
 
@@ -306,7 +306,7 @@ function options(value: Partial<MemberOptions>): F<any>
 function unobs<T>(func: F<T>, ...args: any[]): T
 function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
-// SnapshotOptions, MemberOptions, Kind, Reentrance, Monitor, LoggingOptions, ProfilingOptions
+// SnapshotOptions, MemberOptions, Kind, Reentrance, Indicator, LoggingOptions, ProfilingOptions
 
 export type SnapshotOptions = {
   readonly hint?: string
@@ -325,7 +325,7 @@ type MemberOptions = {
   readonly throttling: number // milliseconds, -1 is immediately, Number.MAX_SAFE_INTEGER is never
   readonly reentrance: Reentrance
   readonly journal: Journal | undefined
-  readonly monitor: Monitor | null
+  readonly indicator: Indicator | null
   readonly logging?: Partial<LoggingOptions>
 }
 
@@ -345,11 +345,14 @@ enum Reentrance {
   runSideBySide = -3 // multiple simultaneous calls are allowed
 }
 
-class Monitor {
-  readonly isActive: boolean
+class Indicator {
+  readonly isBusy: boolean
   readonly counter: number
   readonly workers: ReadonlySet<Worker>
-  static create(hint: string, activationDelay: number, deactivationDelay: number): Monitor
+  readonly busyDuration: number
+  abstract whenBusy(): Promise<void>
+  abstract whenIdle(): Promise<void>
+  static create(hint: string, activationDelay: number, deactivationDelay: number): Indicator
 }
 
 type Worker = {
@@ -366,7 +369,7 @@ type LoggingOptions = {
   readonly transaction: boolean
   readonly operation: boolean
   readonly step: boolean
-  readonly monitor: boolean
+  readonly indicator: boolean
   readonly read: boolean
   readonly write: boolean
   readonly change: boolean

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

@@ -3,7 +3,7 @@ export type LoggingOptions = {
     readonly transaction: boolean;
     readonly operation: boolean;
     readonly step: boolean;
-    readonly monitor: boolean;
+    readonly indicator: boolean;
     readonly read: boolean;
     readonly write: boolean;
     readonly change: boolean;

package/build/dist/source/Logging.js

@@ -4,7 +4,7 @@ export const LoggingLevel = {
         transaction: false,
         operation: false,
         step: false,
-        monitor: false,
+        indicator: false,
         read: false,
         write: false,
         change: false,
@@ -22,7 +22,7 @@ export const LoggingLevel = {
         transaction: false,
         operation: false,
         step: false,
-        monitor: false,
+        indicator: false,
         read: false,
         write: false,
         change: false,
@@ -40,7 +40,7 @@ export const LoggingLevel = {
         transaction: false,
         operation: false,
         step: false,
-        monitor: false,
+        indicator: false,
         read: false,
         write: false,
         change: false,
@@ -58,7 +58,7 @@ export const LoggingLevel = {
         transaction: true,
         operation: false,
         step: false,
-        monitor: false,
+        indicator: false,
         read: false,
         write: false,
         change: false,
@@ -76,7 +76,7 @@ export const LoggingLevel = {
         transaction: true,
         operation: true,
         step: false,
-        monitor: true,
+        indicator: true,
         read: false,
         write: false,
         change: true,
@@ -94,7 +94,7 @@ export const LoggingLevel = {
         transaction: true,
         operation: true,
         step: true,
-        monitor: true,
+        indicator: true,
         read: true,
         write: true,
         change: true,

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

@@ -3,7 +3,7 @@ import { SeparationMode } from "./core/Data.js";
 export { LoggingLevel } from "./Logging.js";
 export type { LoggingOptions, ProfilingOptions } from "./Logging.js";
 import { Journal } from "./core/Journal.js";
-import { Monitor } from "./core/Monitor.js";
+import { Indicator } from "./core/Indicator.js";
 export type SnapshotOptions = {
     readonly hint?: string;
     readonly separation?: SeparationMode;
@@ -20,7 +20,7 @@ export type MemberOptions = {
     readonly throttling: number;
     readonly reentrance: Reentrance;
     readonly journal: Journal | undefined;
-    readonly monitor: Monitor | null;
+    readonly indicator: Indicator | null;
     readonly logging?: Partial<LoggingOptions>;
 };
 export declare enum Kind {

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

@@ -14,7 +14,7 @@ export { TransactionalArray, ObservableArray } from "./core/MvccArray.js";
 export { TransactionalMap, ObservableMap } from "./core/MvccMap.js";
 export { Changeset } from "./core/Changeset.js";
 export { Transaction } from "./core/Transaction.js";
-export { Monitor } from "./core/Monitor.js";
+export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
 export { RxSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from "./RxSystem.js";
 export { Reaction } from "./Reaction.js";

package/build/dist/source/api.js

@@ -10,7 +10,7 @@ export { TransactionalArray, ObservableArray } from "./core/MvccArray.js";
 export { TransactionalMap, ObservableMap } from "./core/MvccMap.js";
 export { Changeset } from "./core/Changeset.js";
 export { Transaction } from "./core/Transaction.js";
-export { Monitor } from "./core/Monitor.js";
+export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
 export { RxSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, options } from "./RxSystem.js";
 export { Reaction } from "./Reaction.js";

package/build/dist/source/core/Indicator.d.ts

@@ -0,0 +1,40 @@
+import { Worker } from "../Worker.js";
+import { ObservableObject } from "./Mvcc.js";
+export declare abstract class Indicator extends ObservableObject {
+    abstract readonly isBusy: boolean;
+    abstract readonly counter: number;
+    abstract readonly workers: ReadonlySet<Worker>;
+    abstract readonly busyDuration: number;
+    abstract whenBusy(): Promise<void>;
+    abstract whenIdle(): Promise<void>;
+    static create(hint: string, activationDelay: number, deactivationDelay: number, durationResolution: number): Indicator;
+}
+export declare class IndicatorImpl extends Indicator {
+    isBusy: boolean;
+    counter: number;
+    workers: Set<Worker>;
+    busyDuration: number;
+    readonly internals: {
+        whenBusy: Promise<void> | undefined;
+        resolveWhenBusy: ((value?: void | undefined) => void) | undefined;
+        whenIdle: Promise<void> | undefined;
+        resolveWhenIdle: ((value?: void | undefined) => void) | undefined;
+        started: number;
+        activationDelay: number;
+        activationTimeout: undefined;
+        deactivationDelay: number;
+        deactivationTimeout: undefined;
+        durationResolution: number;
+    };
+    whenBusy(): Promise<void>;
+    whenIdle(): Promise<void>;
+    enter(worker: Worker): void;
+    leave(worker: Worker): void;
+    static create(hint: string, activationDelay: number, deactivationDelay: number, durationResolution: number): IndicatorImpl;
+    static enter(mon: IndicatorImpl, worker: Worker): void;
+    static leave(mon: IndicatorImpl, worker: Worker): void;
+    private static doCreate;
+    private static activate;
+    private static deactivate;
+    private static tick;
+}

package/build/dist/source/core/Indicator.js

@@ -0,0 +1,145 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ObservableObject, Mvcc } from "./Mvcc.js";
+import { Transaction } from "./Transaction.js";
+export class Indicator extends ObservableObject {
+    static create(hint, activationDelay, deactivationDelay, durationResolution) {
+        return IndicatorImpl.create(hint, activationDelay, deactivationDelay, durationResolution);
+    }
+}
+export class IndicatorImpl extends Indicator {
+    constructor() {
+        super(...arguments);
+        this.isBusy = false;
+        this.counter = 0;
+        this.workers = new Set();
+        this.busyDuration = 0;
+        this.internals = {
+            whenBusy: undefined,
+            resolveWhenBusy: undefined,
+            whenIdle: undefined,
+            resolveWhenIdle: undefined,
+            started: 0,
+            activationDelay: -1,
+            activationTimeout: undefined,
+            deactivationDelay: -1,
+            deactivationTimeout: undefined,
+            durationResolution: 1,
+        };
+    }
+    whenBusy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.internals.started === 0) {
+                if (!this.internals.whenBusy) {
+                    this.internals.whenBusy = new Promise((resolve, reject) => {
+                        this.internals.resolveWhenBusy = resolve;
+                    });
+                }
+                yield this.internals.whenBusy;
+            }
+        });
+    }
+    whenIdle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.internals.started !== 0) {
+                if (!this.internals.whenIdle) {
+                    this.internals.whenIdle = new Promise((resolve, reject) => {
+                        this.internals.resolveWhenIdle = resolve;
+                    });
+                }
+                yield this.internals.whenIdle;
+            }
+        });
+    }
+    enter(worker) {
+        this.counter++;
+        const workers = this.workers = this.workers.toMutable();
+        workers.add(worker);
+        IndicatorImpl.activate(this, this.internals.activationDelay);
+    }
+    leave(worker) {
+        this.counter--;
+        const workers = this.workers = this.workers.toMutable();
+        workers.delete(worker);
+        IndicatorImpl.deactivate(this, this.internals.deactivationDelay);
+    }
+    static create(hint, activationDelay, deactivationDelay, durationResolution) {
+        return Transaction.run({ hint: "Indicator.create" }, IndicatorImpl.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 IndicatorImpl();
+        Mvcc.setHint(m, hint);
+        m.internals.activationDelay = activationDelay;
+        m.internals.deactivationDelay = deactivationDelay;
+        m.internals.durationResolution = durationResolution;
+        return m;
+    }
+    static activate(mon, delay) {
+        const active = mon.counter > 0;
+        if (mon.internals.started === 0 && active) {
+            mon.busyDuration = 0;
+            mon.internals.started = performance.now();
+            if (mon.internals.whenBusy) {
+                const resolve = mon.internals.resolveWhenBusy;
+                mon.internals.whenBusy = undefined;
+                mon.internals.resolveWhenBusy = undefined;
+                resolve();
+            }
+            IndicatorImpl.tick(mon);
+        }
+        if (delay >= 0) {
+            if (mon.internals.activationTimeout === undefined)
+                mon.internals.activationTimeout = setTimeout(() => Transaction.run({ hint: "Indicator.activate", separation: "isolated" }, IndicatorImpl.activate, mon, -1), delay);
+        }
+        else if (active)
+            mon.isBusy = true;
+    }
+    static deactivate(mon, delay) {
+        if (delay >= 0) {
+            clearTimeout(mon.internals.deactivationTimeout);
+            mon.internals.deactivationTimeout = setTimeout(() => Transaction.run({ hint: "Indicator.deactivate", separation: "isolated" }, IndicatorImpl.deactivate, mon, -1), delay);
+        }
+        else if (mon.counter <= 0) {
+            mon.isBusy = false;
+            mon.internals.activationTimeout = undefined;
+        }
+        if (mon.counter === 0 && mon.internals.started !== 0) {
+            const resolution = mon.internals.durationResolution;
+            mon.busyDuration = Math.round(resolution * (performance.now() - mon.internals.started)) / resolution;
+            mon.internals.started = 0;
+            if (mon.internals.whenIdle) {
+                const resolve = mon.internals.resolveWhenIdle;
+                mon.internals.whenIdle = undefined;
+                mon.internals.resolveWhenIdle = undefined;
+                resolve();
+            }
+        }
+    }
+    static tick(mon) {
+        if (mon.internals.started !== 0) {
+            Transaction.run(INDICATOR_TICK_OPTIONS, () => {
+                const resolution = mon.internals.durationResolution;
+                mon.busyDuration = Math.round(resolution * (performance.now() - mon.internals.started)) / resolution;
+            });
+            const t = globalThis !== null && globalThis !== void 0 ? globalThis : global;
+            if (t.requestAnimationFrame)
+                requestAnimationFrame(() => IndicatorImpl.tick(mon));
+        }
+    }
+}
+const INDICATOR_TICK_OPTIONS = Object.freeze({
+    hint: "Indicator.tick",
+});

package/build/dist/source/core/Mvcc.d.ts

@@ -3,7 +3,7 @@ import { MemberOptions, Kind, Reentrance } from "../Options.js";
 import { LoggingOptions, ProfilingOptions } from "../Logging.js";
 import { MemberName, ObjectHandle, SeparationMode } from "./Data.js";
 import { Journal } from "./Journal.js";
-import { Monitor } from "./Monitor.js";
+import { Indicator } from "./Indicator.js";
 export declare abstract class MvccObject {
     protected constructor(observable: boolean);
     [Symbol.toStringTag](): string;
@@ -25,7 +25,7 @@ export declare class OptionsImpl implements MemberOptions {
     readonly throttling: number;
     readonly reentrance: Reentrance;
     readonly journal: Journal | undefined;
-    readonly monitor: Monitor | null;
+    readonly indicator: Indicator | null;
     readonly logging?: Partial<LoggingOptions>;
     static readonly INITIAL: Readonly<OptionsImpl>;
     constructor(getter: Function | undefined, setter: Function | undefined, existing: OptionsImpl, patch: Partial<OptionsImpl>, implicit: boolean);

package/build/dist/source/core/Mvcc.js

@@ -34,7 +34,7 @@ const DEFAULT_OPTIONS = Object.freeze({
     throttling: Number.MAX_SAFE_INTEGER,
     reentrance: Reentrance.preventWithError,
     journal: undefined,
-    monitor: null,
+    indicator: null,
     logging: undefined,
 });
 export class OptionsImpl {
@@ -49,7 +49,7 @@ export class OptionsImpl {
         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.indicator = merge(DEFAULT_OPTIONS.indicator, existing.indicator, patch.indicator, implicit);
         this.logging = merge(DEFAULT_OPTIONS.logging, existing.logging, patch.logging, implicit);
         if (Log.isOn)
             Object.freeze(this);

package/build/dist/source/core/Reaction.d.ts

@@ -68,8 +68,8 @@ declare class Launch extends ValueSnapshot implements Observer {
     private enter;
     private leaveOrAsync;
     private leave;
-    private monitorEnter;
-    private monitorLeave;
+    private indicatorEnter;
+    private indicatorLeave;
     private addToDeferredReactiveFunctions;
     private static processDeferredReactiveFunctions;
     private static markUsed;

package/build/dist/source/core/Reaction.js

@@ -3,7 +3,7 @@ import { Kind, Reentrance } from "../Options.js";
 import { ObjectHandle, ValueSnapshot, Meta } from "./Data.js";
 import { Changeset, Dump, EMPTY_SNAPSHOT, MAX_REVISION } from "./Changeset.js";
 import { Transaction } from "./Transaction.js";
-import { MonitorImpl } from "./Monitor.js";
+import { IndicatorImpl } from "./Indicator.js";
 import { Mvcc, OptionsImpl } from "./Mvcc.js";
 import { JournalImpl } from "./Journal.js";
 const BOOT_ARGS = [];
@@ -374,8 +374,8 @@ class Launch extends ValueSnapshot {
         }
     }
     enter() {
-        if (this.options.monitor)
-            this.monitorEnter(this.options.monitor);
+        if (this.options.indicator)
+            this.indicatorEnter(this.options.indicator);
         if (Log.isOn && Log.opt.operation)
             Log.write("║", "‾\\", `${this.hint()} - enter`, undefined, `    [ ${Dump.obj(this.reaction.objectHandle, this.reaction.memberName)} ]`);
         this.started = Date.now();
@@ -411,26 +411,26 @@ class Launch extends ValueSnapshot {
         if (ms > (main ? Mvcc.mainThreadBlockingWarningThreshold : Mvcc.asyncActionDurationWarningThreshold))
             Log.write("", "[!]", this.why(), ms, main ? "    *** main thread is too busy ***" : "    *** async is too long ***");
         this.cause = undefined;
-        if (this.options.monitor)
-            this.monitorLeave(this.options.monitor);
+        if (this.options.indicator)
+            this.indicatorLeave(this.options.indicator);
     }
-    monitorEnter(mon) {
+    indicatorEnter(mon) {
         const options = {
-            hint: "Monitor.enter",
+            hint: "Indicator.enter",
             separation: "isolated",
-            logging: Log.isOn && Log.opt.monitor ? undefined : Log.global
+            logging: Log.isOn && Log.opt.indicator ? undefined : Log.global
         };
-        ReactionImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, MonitorImpl.enter, mon, this.transaction);
+        ReactionImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.enter, mon, this.transaction);
     }
-    monitorLeave(mon) {
+    indicatorLeave(mon) {
         Transaction.outside(() => {
             const leave = () => {
                 const options = {
-                    hint: "Monitor.leave",
+                    hint: "Indicator.leave",
                     separation: "isolated",
-                    logging: Log.isOn && Log.opt.monitor ? undefined : Log.DefaultLevel
+                    logging: Log.isOn && Log.opt.indicator ? undefined : Log.DefaultLevel
                 };
-                ReactionImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, MonitorImpl.leave, mon, this.transaction);
+                ReactionImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.leave, mon, this.transaction);
             };
             this.transaction.whenFinished().then(leave, leave);
         });

package/build/dist/source/util/Dbg.js

@@ -46,7 +46,7 @@ export class Log {
             transaction: t.transaction !== undefined ? t.transaction : existing.transaction,
             operation: t.operation !== undefined ? t.operation : existing.operation,
             step: t.step !== undefined ? t.step : existing.step,
-            monitor: t.monitor !== undefined ? t.monitor : existing.monitor,
+            indicator: t.indicator !== undefined ? t.indicator : existing.indicator,
             read: t.read !== undefined ? t.read : existing.read,
             write: t.write !== undefined ? t.write : existing.write,
             change: t.change !== undefined ? t.change : existing.change,
@@ -73,7 +73,7 @@ Log.DefaultLevel = {
     transaction: false,
     operation: false,
     step: false,
-    monitor: false,
+    indicator: false,
     read: false,
     write: false,
     change: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.24.270",
+  "version": "0.24.272",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -31,13 +31,13 @@
   },
   "homepage": "https://github.com/nezaboodka/reactronic/blob/master/README.md#readme",
   "devDependencies": {
-    "@types/node": "20.11.17",
-    "@types/react": "18.2.55",
-    "@typescript-eslint/eslint-plugin": "6.21.0",
-    "@typescript-eslint/parser": "6.21.0",
-    "ava": "6.1.1",
+    "@types/node": "20.11.28",
+    "@types/react": "18.2.66",
+    "@typescript-eslint/eslint-plugin": "7.2.0",
+    "@typescript-eslint/parser": "7.2.0",
+    "ava": "6.1.2",
     "c8": "9.1.0",
-    "eslint": "8.56.0",
+    "eslint": "8.57.0",
     "react": "18.2.0",
     "ts-node": "10.9.2",
     "typescript": "5.3.2"

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

@@ -1,32 +0,0 @@
-import { Worker } from "../Worker.js";
-import { ObservableObject } from "./Mvcc.js";
-export declare abstract class Monitor extends ObservableObject {
-    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;
-    readonly 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/core/Monitor.js

@@ -1,96 +0,0 @@
-import { ObservableObject, Mvcc } from "./Mvcc.js";
-import { Transaction } from "./Transaction.js";
-export class Monitor extends ObservableObject {
-    static create(hint, activationDelay, deactivationDelay, durationResolution) {
-        return MonitorImpl.create(hint, activationDelay, deactivationDelay, durationResolution);
-    }
-}
-export 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.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();
-        Mvcc.setHint(m, hint);
-        m.internals.activationDelay = activationDelay;
-        m.internals.deactivationDelay = deactivationDelay;
-        m.internals.durationResolution = durationResolution;
-        return m;
-    }
-    static activate(mon, delay) {
-        const active = mon.counter > 0;
-        if (mon.internals.started === 0 && active) {
-            mon.duration = 0;
-            mon.internals.started = performance.now();
-            MonitorImpl.tick(mon);
-        }
-        if (delay >= 0) {
-            if (mon.internals.activationTimeout === undefined)
-                mon.internals.activationTimeout = setTimeout(() => Transaction.run({ hint: "Monitor.activate", separation: "isolated" }, MonitorImpl.activate, mon, -1), delay);
-        }
-        else if (active)
-            mon.isActive = true;
-    }
-    static deactivate(mon, delay) {
-        if (delay >= 0) {
-            clearTimeout(mon.internals.deactivationTimeout);
-            mon.internals.deactivationTimeout = setTimeout(() => Transaction.run({ hint: "Monitor.deactivate", separation: "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.run(MONITOR_TICK_OPTIONS, () => {
-                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));
-        }
-    }
-}
-const MONITOR_TICK_OPTIONS = Object.freeze({
-    hint: "Monitor.tick",
-});