@matter/tools 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/esm/testing/mocks/logging.js

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import colors from "ansi-colors";
+const TheMockLogger = {
+  emitAll: false,
+  injectExternalMessage: (source, text) => console.log(formatExternalMessage(source, text))
+};
+function formatExternalMessage(source, text) {
+  return `    ${colors.bgCyan.black.bold(` ${source} `)} ${colors.dim(text)}`;
+}
+const LoggerHooks = {
+  beforeEach: Array(),
+  afterEach: Array()
+};
+function loggerSetup(Logger) {
+  Logger.format = "ansi";
+  let messageBuffer;
+  const defaultLog = Logger.log;
+  function passMessage(args) {
+    defaultLog.apply(Logger, args);
+  }
+  function interceptingLogger(...args) {
+    let emitAll = TheMockLogger.emitAll;
+    if (MatterHooks?.loggerSink) {
+      MatterHooks.loggerSink(...args);
+    } else if (!emitAll) {
+      if (messageBuffer) {
+        messageBuffer.push(args);
+      } else {
+        emitAll = true;
+      }
+    }
+    if (emitAll) {
+      passMessage(args);
+    }
+  }
+  TheMockLogger.injectExternalMessage = (source, text) => interceptingLogger(0, formatExternalMessage(source, text));
+  Logger.log = interceptingLogger;
+  LoggerHooks.beforeEach.push(function() {
+    if (!TheMockLogger.emitAll) {
+      messageBuffer = [];
+    }
+  });
+  LoggerHooks.afterEach.push((mocha) => {
+    if (messageBuffer?.length) {
+      if (mocha.suite.ctx.currentTest?.isFailed()) {
+        for (const args of messageBuffer) {
+          passMessage(args);
+        }
+      }
+      messageBuffer = void 0;
+    }
+  });
+}
+export {
+  LoggerHooks,
+  TheMockLogger,
+  loggerSetup
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/testing/mocks/logging.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/testing/mocks/logging.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,OAAO,YAAY;AAYZ,MAAM,gBAA4B;AAAA,EACrC,SAAS;AAAA,EACT,uBAAuB,CAAC,QAAgB,SAAiB,QAAQ,IAAI,sBAAsB,QAAQ,IAAI,CAAC;AAC5G;AAEA,SAAS,sBAAsB,QAAgB,MAAc;AACzD,SAAO,OAAO,OAAO,OAAO,MAAM,KAAK,IAAI,MAAM,GAAG,CAAC,IAAI,OAAO,IAAI,IAAI,CAAC;AAC7E;AASO,MAAM,cAAc;AAAA,EACvB,YAAY,MAA8B;AAAA,EAC1C,WAAW,MAA8B;AAC7C;AAEO,SAAS,YAAY,QAAoB;AAU5C,SAAO,SAAS;AAEhB,MAAI;AAEJ,QAAM,aAAa,OAAO;AAE1B,WAAS,YAAY,MAAwB;AACzC,eAAW,MAAM,QAAQ,IAAI;AAAA,EACjC;AAEA,WAAS,sBAAsB,MAAwB;AACnD,QAAI,UAAU,cAAc;AAC5B,QAAI,aAAa,YAAY;AACzB,kBAAY,WAAW,GAAG,IAAI;AAAA,IAClC,WAAW,CAAC,SAAS;AACjB,UAAI,eAAe;AACf,sBAAc,KAAK,IAAI;AAAA,MAC3B,OAAO;AACH,kBAAU;AAAA,MACd;AAAA,IACJ;AAEA,QAAI,SAAS;AACT,kBAAY,IAAI;AAAA,IACpB;AAAA,EACJ;AAEA,gBAAc,wBAAwB,CAAC,QAAQ,SAAS,mBAAmB,GAAG,sBAAsB,QAAQ,IAAI,CAAC;AAEjH,SAAO,MAAM;AAGb,cAAY,WAAW,KAAK,WAAY;AACpC,QAAI,CAAC,cAAc,SAAS;AACxB,sBAAgB,CAAC;AAAA,IACrB;AAAA,EACJ,CAAC;AAGD,cAAY,UAAU,KAAK,WAAS;AAChC,QAAI,eAAe,QAAQ;AACvB,UAAI,MAAM,MAAM,IAAI,aAAa,SAAS,GAAG;AACzC,mBAAW,QAAQ,eAAe;AAC9B,sBAAY,IAAI;AAAA,QACpB;AAAA,MACJ;AACA,sBAAgB;AAAA,IACpB;AAAA,EACJ,CAAC;AACL;",
+  "names": []
+}

package/dist/esm/testing/mocks/time.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+type TimerCallback = () => any;
+type MockTimeLike = typeof MockTime;
+export interface MockTime extends MockTimeLike {
+}
+declare class MockTimer {
+    private readonly mockTime;
+    private readonly durationMs;
+    name: string;
+    systemId: number;
+    intervalMs: number;
+    isPeriodic: boolean;
+    isRunning: boolean;
+    private readonly callback;
+    constructor(mockTime: MockTime, durationMs: number, callback: TimerCallback);
+    start(): this;
+    stop(): this;
+}
+type InterceptResult<T> = T extends Promise<T> ? {
+    resolve: Awaited<T>;
+    reject?: undefined;
+} | {
+    resolve?: undefined;
+    reject: {};
+} : {
+    resolve: T;
+    reject?: undefined;
+} | {
+    resolve?: void;
+    reject: {};
+};
+export declare const MockTime: {
+    readonly activeImplementation: unknown;
+    disable(): void;
+    enable(): void;
+    reset(time?: number): void;
+    now(): Date;
+    nowMs(): number;
+    getTimer(_name: string, durationMs: number, callback: TimerCallback): MockTimer;
+    getPeriodicTimer(_name: string, intervalMs: number, callback: TimerCallback): MockTimer;
+    /**
+     * Resolve a promise with time dependency.
+     *
+     * Moves time forward until the promise resolves.
+     */
+    resolve<T>(promise: PromiseLike<T>): Promise<T>;
+    /**
+     * Move time forward.  Runs tasks scheduled during this interval.
+     */
+    advance(ms: number): Promise<void>;
+    /**
+     * Yield to scheduled microtasks.  This means that all code paths waiting
+     * on resolved promises (including await) will proceed before this method
+     * returns.
+     */
+    yield(): Promise<void>;
+    /**
+     * Due to its implementation, an older version of yield() would actually
+     * yield to microtasks three times.  Our tests then depended on this
+     * functionality -- one yield could trigger up to three nested awaits.
+     *
+     * To make this clear, the version of yield() that emulates old behavior
+     * is called "yield3".
+     */
+    yield3(): Promise<void>;
+    /**
+     * Hook a method and invoke a callback just before the method completes.
+     * Unhooks after completion.
+     *
+     * Handles both synchronous and asynchronous methods.  The interceptor
+     * should match the async-ness of the intercepted method.
+     *
+     * The interceptor can optionally access and/or replace the resolve/reject
+     * value.
+     */
+    interceptOnce<NameT extends string, ReturnT, ObjT extends { [N in NameT]: (...args: any) => ReturnT; }>(obj: ObjT, method: NameT, interceptor: (result: InterceptResult<ReturnT>) => void | InterceptResult<ReturnT> | Promise<void> | Promise<InterceptResult<ReturnT>>): void;
+    callbackAtTime(atMs: number, callback: TimerCallback): void;
+    removeCallback(callbackToRemove: TimerCallback): void;
+};
+export declare function timeSetup(Time: {
+    get(): unknown;
+}): void;
+export {};
+//# sourceMappingURL=time.d.ts.map

package/dist/esm/testing/mocks/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../../../src/testing/mocks/time.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,KAAK,aAAa,GAAG,MAAM,GAAG,CAAC;AAE/B,KAAK,YAAY,GAAG,OAAO,QAAQ,CAAC;AACpC,MAAM,WAAW,QAAS,SAAQ,YAAY;CAAG;AAGjD,cAAM,SAAS;IAUP,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAV/B,IAAI,SAAU;IACd,QAAQ,SAAK;IACb,UAAU,SAAK;IACf,UAAU,UAAS;IAEnB,SAAS,UAAS;IAClB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;gBAGpB,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,EACnC,QAAQ,EAAE,aAAa;IAY3B,KAAK;IAML,IAAI;CAKP;AAYD,KAAK,eAAe,CAAC,CAAC,IAClB,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,GACd;IAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,OAAO,CAAC,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,EAAE,CAAA;CAAE,GACjF;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,OAAO,CAAC,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,EAAE,CAAA;CAAE,CAAC;AAY9E,eAAO,MAAM,QAAQ;;;;;WAuBV,IAAI;;oBAQK,MAAM,cAAc,MAAM,YAAY,aAAa,GAAG,SAAS;4BAIvD,MAAM,cAAc,MAAM,YAAY,aAAa,GAAG,SAAS;IAIvF;;;;OAIG;YACW,CAAC,WAAW,WAAW,CAAC,CAAC,CAAC;IAwDxC;;OAEG;gBACe,MAAM;IAexB;;;;OAIG;;IAKH;;;;;;;OAOG;;IAOH;;;;;;;;;OASG;kBACW,KAAK,SAAS,MAAM,EAAE,OAAO,EAAE,IAAI,SAAS,GAAG,CAAU,IAAL,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,OAAO,GAAE,OAC5F,IAAI,UACD,KAAK,eACA,CACT,MAAM,EAAE,eAAe,CAAC,OAAO,CAAC,KAC/B,IAAI,GAAG,eAAe,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;yBA2CvE,MAAM,YAAY,aAAa;qCAKnB,aAAa;CAKjD,CAAC;AAIF,wBAAgB,SAAS,CAAC,IAAI,EAAE;IAAE,GAAG,IAAI,OAAO,CAAA;CAAE,QAIjD"}

package/dist/esm/testing/mocks/time.js

@@ -0,0 +1,230 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class MockTimer {
+  constructor(mockTime, durationMs, callback) {
+    this.mockTime = mockTime;
+    this.durationMs = durationMs;
+    if (this instanceof MockInterval) {
+      this.callback = callback;
+    } else {
+      this.callback = () => {
+        this.isRunning = false;
+        callback();
+      };
+    }
+  }
+  name = "Test";
+  systemId = 0;
+  intervalMs = 0;
+  isPeriodic = false;
+  isRunning = false;
+  callback;
+  start() {
+    this.mockTime.callbackAtTime(this.mockTime.nowMs() + this.durationMs, this.callback);
+    this.isRunning = true;
+    return this;
+  }
+  stop() {
+    this.mockTime.removeCallback(this.callback);
+    this.isRunning = false;
+    return this;
+  }
+}
+class MockInterval extends MockTimer {
+  constructor(mockTime, durationMs, callback) {
+    const intervalCallback = async () => {
+      mockTime.callbackAtTime(mockTime.nowMs() + durationMs, intervalCallback);
+      await callback();
+    };
+    super(mockTime, durationMs, intervalCallback);
+  }
+}
+function isAsync(fn) {
+  return fn.constructor.name === "AsyncFunction";
+}
+let callbacks = new Array();
+let nowMs = 0;
+let real = void 0;
+let enabled = true;
+const MockTime = {
+  get activeImplementation() {
+    return enabled ? this : real ?? this;
+  },
+  disable() {
+    enabled = false;
+    reinstallTime?.();
+  },
+  enable() {
+    enabled = true;
+    reinstallTime?.();
+  },
+  reset(time = 0) {
+    callbacks = [];
+    nowMs = time;
+    reinstallTime?.();
+  },
+  now() {
+    return new Date(nowMs);
+  },
+  nowMs() {
+    return nowMs;
+  },
+  getTimer(_name, durationMs, callback) {
+    return new MockTimer(this, durationMs, callback);
+  },
+  getPeriodicTimer(_name, intervalMs, callback) {
+    return new MockInterval(this, intervalMs, callback);
+  },
+  /**
+   * Resolve a promise with time dependency.
+   *
+   * Moves time forward until the promise resolves.
+   */
+  async resolve(promise) {
+    let resolved = false;
+    let result;
+    let error;
+    promise.then(
+      (r) => {
+        resolved = true;
+        result = r;
+      },
+      (e) => {
+        resolved = true;
+        error = e;
+      }
+    );
+    let timeAdvanced = 0;
+    while (!resolved) {
+      await new Promise((resolve) => setTimeout(() => resolve(), 0));
+      if (resolved) {
+        break;
+      }
+      if (timeAdvanced > 60 * 60 * 1e3) {
+        throw new Error(
+          "Mock timeout: Promise did not resolve within one (virtual) hour, probably not going to happen"
+        );
+      }
+      await this.advance(1e3);
+      timeAdvanced += 1e3;
+      if (resolved) {
+        break;
+      }
+      await this.yield();
+    }
+    if (error !== void 0) {
+      throw error;
+    }
+    return result;
+  },
+  /**
+   * Move time forward.  Runs tasks scheduled during this interval.
+   */
+  async advance(ms) {
+    const newTimeMs = nowMs + ms;
+    while (true) {
+      if (callbacks.length === 0) break;
+      const { atMs, callback } = callbacks[0];
+      if (atMs > newTimeMs) break;
+      callbacks.shift();
+      nowMs = atMs;
+      await callback();
+    }
+    nowMs = newTimeMs;
+  },
+  /**
+   * Yield to scheduled microtasks.  This means that all code paths waiting
+   * on resolved promises (including await) will proceed before this method
+   * returns.
+   */
+  async yield() {
+    await Promise.resolve();
+  },
+  /**
+   * Due to its implementation, an older version of yield() would actually
+   * yield to microtasks three times.  Our tests then depended on this
+   * functionality -- one yield could trigger up to three nested awaits.
+   *
+   * To make this clear, the version of yield() that emulates old behavior
+   * is called "yield3".
+   */
+  async yield3() {
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+  },
+  /**
+   * Hook a method and invoke a callback just before the method completes.
+   * Unhooks after completion.
+   *
+   * Handles both synchronous and asynchronous methods.  The interceptor
+   * should match the async-ness of the intercepted method.
+   *
+   * The interceptor can optionally access and/or replace the resolve/reject
+   * value.
+   */
+  interceptOnce(obj, method, interceptor) {
+    const original = obj[method];
+    if (!original) {
+      throw new Error(`Interception method ${method} is not present`);
+    }
+    let result;
+    if (isAsync(interceptor)) {
+      obj[method] = async function(...args) {
+        try {
+          const resolve = await original.apply(this, args);
+          result = { resolve };
+        } catch (reject) {
+          result = { reject };
+        } finally {
+          obj[method] = original;
+        }
+        result = await interceptor(result) ?? result;
+        if (result.reject) {
+          throw result.reject;
+        }
+        return result.resolve;
+      };
+    } else {
+      obj[method] = function(...args) {
+        try {
+          const resolve = original.apply(this, args);
+          result = { resolve };
+        } catch (reject) {
+          result = { reject };
+        } finally {
+          obj[method] = original;
+        }
+        result = interceptor(result) ?? result;
+        if (result.reject) {
+          throw result.reject;
+        }
+        return result.resolve;
+      };
+    }
+  },
+  callbackAtTime(atMs, callback) {
+    callbacks.push({ atMs, callback });
+    callbacks.sort(({ atMs: atMsA }, { atMs: atMsB }) => atMsA - atMsB);
+  },
+  removeCallback(callbackToRemove) {
+    const index = callbacks.findIndex(({ callback }) => callbackToRemove === callback);
+    if (index === -1) return;
+    callbacks.splice(index, 1);
+  }
+};
+let reinstallTime;
+function timeSetup(Time) {
+  real = Time.get();
+  reinstallTime = () => Time.get = () => MockTime.activeImplementation;
+  reinstallTime();
+}
+Object.assign(globalThis, { MockTime });
+export {
+  MockTime,
+  timeSetup
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/testing/mocks/time.ts"],
  "sourcesContent": ["/**\n * @license\n * Copyright 2022-2024 Matter.js Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\ntype TimerCallback = () => any;\n\ntype MockTimeLike = typeof MockTime;\nexport interface MockTime extends MockTimeLike {}\n\n// Must match matter.js Timer interface\nclass MockTimer {\n    name = \"Test\";\n    systemId = 0;\n    intervalMs = 0;\n    isPeriodic = false;\n\n    isRunning = false;\n    private readonly callback: TimerCallback;\n\n    constructor(\n        private readonly mockTime: MockTime,\n        private readonly durationMs: number,\n        callback: TimerCallback,\n    ) {\n        if (this instanceof MockInterval) {\n            this.callback = callback;\n        } else {\n            this.callback = () => {\n                this.isRunning = false;\n                callback();\n            };\n        }\n    }\n\n    start() {\n        this.mockTime.callbackAtTime(this.mockTime.nowMs() + this.durationMs, this.callback);\n        this.isRunning = true;\n        return this;\n    }\n\n    stop() {\n        this.mockTime.removeCallback(this.callback);\n        this.isRunning = false;\n        return this;\n    }\n}\n\nclass MockInterval extends MockTimer {\n    constructor(mockTime: MockTime, durationMs: number, callback: TimerCallback) {\n        const intervalCallback = async () => {\n            mockTime.callbackAtTime(mockTime.nowMs() + durationMs, intervalCallback);\n            await callback();\n        };\n        super(mockTime, durationMs, intervalCallback);\n    }\n}\n\ntype InterceptResult<T> =\n    T extends Promise<T>\n        ? { resolve: Awaited<T>; reject?: undefined } | { resolve?: undefined; reject: {} }\n        : { resolve: T; reject?: undefined } | { resolve?: void; reject: {} };\n\nfunction isAsync(fn: (...args: any) => any): fn is (...args: any) => Promise<any> {\n    return fn.constructor.name === \"AsyncFunction\";\n}\n\nlet callbacks = new Array<{ atMs: number; callback: TimerCallback }>();\nlet nowMs = 0;\nlet real = undefined as unknown;\nlet enabled = true;\n\n// Must match matter.js Time interface\nexport const MockTime = {\n    get activeImplementation(): unknown {\n        return enabled ? this : (real ?? this);\n    },\n\n    disable() {\n        enabled = false;\n        reinstallTime?.();\n    },\n\n    enable() {\n        enabled = true;\n        reinstallTime?.();\n    },\n\n    reset(time = 0) {\n        callbacks = [];\n        nowMs = time;\n\n        // Ensure time reverts to correct implementation across suites\n        reinstallTime?.();\n    },\n\n    now(): Date {\n        return new Date(nowMs);\n    },\n\n    nowMs() {\n        return nowMs;\n    },\n\n    getTimer(_name: string, durationMs: number, callback: TimerCallback): MockTimer {\n        return new MockTimer(this, durationMs, callback);\n    },\n\n    getPeriodicTimer(_name: string, intervalMs: number, callback: TimerCallback): MockTimer {\n        return new MockInterval(this, intervalMs, callback);\n    },\n\n    /**\n     * Resolve a promise with time dependency.\n     *\n     * Moves time forward until the promise resolves.\n     */\n    async resolve<T>(promise: PromiseLike<T>) {\n        let resolved = false;\n        let result: T | undefined;\n        let error: any;\n\n        promise.then(\n            r => {\n                resolved = true;\n                result = r;\n            },\n            e => {\n                resolved = true;\n                error = e;\n            },\n        );\n\n        let timeAdvanced = 0;\n        while (!resolved) {\n            // Interestingly, a Time.yield() works in almost every case.  However, on Node SubtleCrypto.deriveBits hangs\n            // if you only yield via microtask.  It seems to require yielding via macrotask.  So we use setTimeout here.\n            // Probably related to entropy collection but I think it's safe to classify as a Node bug.  Tested on\n            // version 20.11.0\n            await new Promise<void>(resolve => setTimeout(() => resolve(), 0));\n\n            if (resolved) {\n                break;\n            }\n\n            // If we've advanced more than one hour, assume we've hung\n            if (timeAdvanced > 60 * 60 * 1000) {\n                throw new Error(\n                    \"Mock timeout: Promise did not resolve within one (virtual) hour, probably not going to happen\",\n                );\n            }\n\n            // Advance time exponentially, trying for granularity but also OK performance.  Note that we are not only\n            // advancing time but also yielding event loop.  So it's possible if we run out of time it's just because\n            // there were too few yields in one virtual hour.  As designed currently it's 360 macrotasks and 360\n            // microtasks (360 loops w/ 1 macro- and 1 micro-yield)\n            await this.advance(1000);\n            timeAdvanced += 1000;\n\n            if (resolved) {\n                break;\n            }\n\n            await this.yield();\n        }\n\n        if (error !== undefined) {\n            throw error;\n        }\n\n        return result as T;\n    },\n\n    /**\n     * Move time forward.  Runs tasks scheduled during this interval.\n     */\n    async advance(ms: number) {\n        const newTimeMs = nowMs + ms;\n\n        while (true) {\n            if (callbacks.length === 0) break;\n            const { atMs, callback } = callbacks[0];\n            if (atMs > newTimeMs) break;\n            callbacks.shift();\n            nowMs = atMs;\n            await callback();\n        }\n\n        nowMs = newTimeMs;\n    },\n\n    /**\n     * Yield to scheduled microtasks.  This means that all code paths waiting\n     * on resolved promises (including await) will proceed before this method\n     * returns.\n     */\n    async yield() {\n        await Promise.resolve();\n    },\n\n    /**\n     * Due to its implementation, an older version of yield() would actually\n     * yield to microtasks three times.  Our tests then depended on this\n     * functionality -- one yield could trigger up to three nested awaits.\n     *\n     * To make this clear, the version of yield() that emulates old behavior\n     * is called \"yield3\".\n     */\n    async yield3() {\n        await Promise.resolve();\n        await Promise.resolve();\n        await Promise.resolve();\n    },\n\n    /**\n     * Hook a method and invoke a callback just before the method completes.\n     * Unhooks after completion.\n     *\n     * Handles both synchronous and asynchronous methods.  The interceptor\n     * should match the async-ness of the intercepted method.\n     *\n     * The interceptor can optionally access and/or replace the resolve/reject\n     * value.\n     */\n    interceptOnce<NameT extends string, ReturnT, ObjT extends { [N in NameT]: (...args: any) => ReturnT }>(\n        obj: ObjT,\n        method: NameT,\n        interceptor: (\n            result: InterceptResult<ReturnT>,\n        ) => void | InterceptResult<ReturnT> | Promise<void> | Promise<InterceptResult<ReturnT>>,\n    ) {\n        const original = obj[method];\n        if (!original) {\n            throw new Error(`Interception method ${method} is not present`);\n        }\n        let result: InterceptResult<ReturnT>;\n        if (isAsync(interceptor)) {\n            obj[method] = async function (this: any, ...args: any): Promise<any> {\n                try {\n                    // eslint-disable-next-line @typescript-eslint/await-thenable\n                    const resolve = await original.apply(this, args);\n                    result = { resolve } as any;\n                } catch (reject) {\n                    result = { reject } as any;\n                } finally {\n                    obj[method] = original;\n                }\n                result = (await interceptor(result)) ?? result;\n                if (result.reject) {\n                    throw result.reject;\n                }\n                return result.resolve;\n            } as any;\n        } else {\n            obj[method] = function (this: any, ...args: any): any {\n                try {\n                    const resolve = original.apply(this, args);\n                    result = { resolve } as any;\n                } catch (reject) {\n                    result = { reject } as any;\n                } finally {\n                    obj[method] = original;\n                }\n                result = (interceptor(result) as any) ?? result;\n                if (result.reject) {\n                    throw result.reject;\n                }\n                return result.resolve;\n            } as any;\n        }\n    },\n\n    callbackAtTime(atMs: number, callback: TimerCallback) {\n        callbacks.push({ atMs, callback });\n        callbacks.sort(({ atMs: atMsA }, { atMs: atMsB }) => atMsA - atMsB);\n    },\n\n    removeCallback(callbackToRemove: TimerCallback) {\n        const index = callbacks.findIndex(({ callback }) => callbackToRemove === callback);\n        if (index === -1) return;\n        callbacks.splice(index, 1);\n    },\n};\n\nlet reinstallTime: undefined | (() => void);\n\nexport function timeSetup(Time: { get(): unknown }) {\n    real = Time.get();\n    reinstallTime = () => (Time.get = () => MockTime.activeImplementation);\n    reinstallTime();\n}\n\nObject.assign(globalThis, { MockTime });\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/testing/mocks/time.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/testing/mocks/time.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/testing/node.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { TestRunner } from "./runner.js";
+import "./global-definitions.js";
+export declare function testNode(runner: TestRunner, format: "cjs" | "esm"): Promise<void>;
+export interface Profilerish {
+    setGenerateType(value: number): void;
+    startProfiling(): void;
+    stopProfiling(): {
+        export(callback: (error: any, result: string) => any): void;
+    };
+}
+//# sourceMappingURL=node.d.ts.map

package/dist/esm/testing/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/testing/node.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,OAAO,yBAAyB,CAAC;AAEjC,wBAAsB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,GAAG,KAAK,iBA+CvE;AAMD,MAAM,WAAW,WAAW;IACxB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,cAAc,IAAI,IAAI,CAAC;IACvB,aAAa,IAAI;QACb,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,KAAK,GAAG,GAAG,IAAI,CAAC;KAC/D,CAAC;CACL"}

package/dist/esm/testing/node.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { mkdir, writeFile } from "fs/promises";
+import Mocha from "mocha";
+import { relative } from "path";
+import { adaptReporter, generalSetup } from "./mocha.js";
+import { TestOptions } from "./options.js";
+import { FailureDetail } from "./failure-detail.js";
+import "./global-definitions.js";
+async function testNode(runner, format) {
+  process.on("unhandledRejection", (e) => {
+    if (process.listenerCount("unhandledRejection") === 1) {
+      const error = new Error("Unhandled rejection (ignored by mocha)");
+      error.cause = e;
+      runner.reporter.failRun(FailureDetail(error));
+    }
+  });
+  const mocha = new Mocha({
+    inlineDiffs: true,
+    reporter: adaptReporter(Mocha, format.toUpperCase(), runner.reporter)
+  });
+  generalSetup(mocha);
+  TestOptions.apply(mocha, runner.options);
+  const files = runner.loadFiles(format);
+  files.forEach((path) => {
+    path = relative(process.cwd(), path);
+    if (path[0] !== ".") {
+      path = `./${path}`;
+    }
+    mocha.addFile(path);
+  });
+  await mocha.loadFilesAsync();
+  const profiler = new Profiler();
+  if (runner.options.profile) {
+    await profiler.start();
+  }
+  await new Promise((resolve) => {
+    const runner2 = mocha.run(() => resolve(runner2));
+  });
+  if (runner.options.profile) {
+    await profiler.stop(runner.pkg.resolve("build/profiles"));
+  }
+}
+class Profiler {
+  #profiler;
+  async start() {
+    this.#profiler = (await import("v8-profiler-next")).default;
+    this.#profiler.setGenerateType(1);
+    this.#profiler.startProfiling();
+  }
+  async stop(outputDir) {
+    if (!this.#profiler) {
+      return;
+    }
+    const profile = this.#profiler.stopProfiling();
+    const result = await new Promise(
+      (accept, reject) => profile.export((error, result2) => {
+        if (error) {
+          reject(error);
+        } else if (!result2) {
+          reject(new Error("No profile error or result"));
+        } else {
+          accept(result2);
+        }
+      })
+    );
+    await mkdir(outputDir, { recursive: true });
+    await writeFile(`${outputDir}/test-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19)}.cpuprofile`, result);
+    this.#profiler = void 0;
+  }
+}
+export {
+  testNode
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/testing/node.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/testing/node.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,OAAO,iBAAiB;AACjC,OAAO,WAAW;AAClB,SAAS,gBAAgB;AACzB,SAAS,eAAe,oBAAoB;AAC5C,SAAS,mBAAmB;AAI5B,SAAS,qBAAqB;AAC9B,OAAO;AAEP,eAAsB,SAAS,QAAoB,QAAuB;AAOtE,UAAQ,GAAG,sBAAsB,OAAK;AAClC,QAAI,QAAQ,cAAc,oBAAoB,MAAM,GAAG;AACnD,YAAM,QAAQ,IAAI,MAAM,wCAAwC;AAChE,YAAM,QAAQ;AACd,aAAO,SAAS,QAAQ,cAAc,KAAK,CAAC;AAAA,IAChD;AAAA,EACJ,CAAC;AAED,QAAM,QAAQ,IAAI,MAAM;AAAA,IACpB,aAAa;AAAA,IACb,UAAU,cAAc,OAAO,OAAO,YAAY,GAAG,OAAO,QAAQ;AAAA,EACxE,CAAC;AAED,eAAa,KAAK;AAElB,cAAY,MAAM,OAAO,OAAO,OAAO;AAEvC,QAAM,QAAQ,OAAO,UAAU,MAAM;AACrC,QAAM,QAAQ,UAAQ;AAClB,WAAO,SAAS,QAAQ,IAAI,GAAG,IAAI;AACnC,QAAI,KAAK,CAAC,MAAM,KAAK;AACjB,aAAO,KAAK,IAAI;AAAA,IACpB;AACA,UAAM,QAAQ,IAAI;AAAA,EACtB,CAAC;AAED,QAAM,MAAM,eAAe;AAE3B,QAAM,WAAW,IAAI,SAAS;AAC9B,MAAI,OAAO,QAAQ,SAAS;AACxB,UAAM,SAAS,MAAM;AAAA,EACzB;AAEA,QAAM,IAAI,QAAsB,aAAW;AACvC,UAAMA,UAAS,MAAM,IAAI,MAAM,QAAQA,OAAM,CAAC;AAAA,EAClD,CAAC;AAED,MAAI,OAAO,QAAQ,SAAS;AACxB,UAAM,SAAS,KAAK,OAAO,IAAI,QAAQ,gBAAgB,CAAC;AAAA,EAC5D;AACJ;AAgBA,MAAM,SAAS;AAAA,EACX;AAAA,EAEA,MAAM,QAAQ;AACV,SAAK,aAAa,MAAM,OAAO,kBAAuB,GAAG;AACzD,SAAK,UAAU,gBAAgB,CAAC;AAChC,SAAK,UAAU,eAAe;AAAA,EAClC;AAAA,EAEA,MAAM,KAAK,WAAmB;AAC1B,QAAI,CAAC,KAAK,WAAW;AACjB;AAAA,IACJ;AAEA,UAAM,UAAU,KAAK,UAAU,cAAc;AAE7C,UAAM,SAAS,MAAM,IAAI;AAAA,MAAgB,CAAC,QAAQ,WAC9C,QAAQ,OAAO,CAAC,OAAOC,YAAW;AAC9B,YAAI,OAAO;AACP,iBAAO,KAAK;AAAA,QAChB,WAAW,CAACA,SAAQ;AAChB,iBAAO,IAAI,MAAM,4BAA4B,CAAC;AAAA,QAClD,OAAO;AACH,iBAAOA,OAAM;AAAA,QACjB;AAAA,MACJ,CAAC;AAAA,IACL;AAEA,UAAM,MAAM,WAAW,EAAE,WAAW,KAAK,CAAC;AAC1C,UAAM,UAAU,GAAG,SAAS,UAAS,oBAAI,KAAK,GAAE,YAAY,EAAE,MAAM,GAAG,EAAE,CAAC,eAAe,MAAM;AAE/F,SAAK,YAAY;AAAA,EACrB;AACJ;",
+  "names": ["runner", "result"]
+}

package/dist/esm/testing/options.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export type TestOptions = {
+    spec?: string | string[];
+    profile?: boolean;
+    grep?: string;
+    fgrep?: string;
+    invert?: boolean;
+    allLogs?: boolean;
+    wtf?: boolean;
+    debug?: boolean;
+};
+export declare namespace TestOptions {
+    function apply(mocha: Mocha, options: TestOptions): void;
+}
+//# sourceMappingURL=options.d.ts.map

package/dist/esm/testing/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/testing/options.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,WAAW,GAAG;IACtB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAqBF,yBAAiB,WAAW,CAAC;IACzB,SAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,QAmBvD;CACJ"}

package/dist/esm/testing/options.js

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function option(options, name) {
+  if (options[name] !== void 0 && options[name] !== null) {
+    return options[name];
+  }
+  if (typeof process === "undefined") {
+    return;
+  }
+  return process.env?.["MATTER_" + name.match(/(.[^A-Z]+)/g)?.map((s) => s.toUpperCase()).join("_")];
+}
+var TestOptions;
+((TestOptions2) => {
+  function apply(mocha, options) {
+    const grep = option(options, "grep");
+    if (grep) {
+      mocha.grep(grep);
+    }
+    const fgrep = option(options, "fgrep");
+    if (fgrep) {
+      mocha.fgrep(fgrep);
+    }
+    const invert = option(options, "invert");
+    if (invert) {
+      mocha.invert();
+    }
+    const allLogs = option(options, "allLogs");
+    if (allLogs) {
+      if (typeof MockLogger !== "undefined") {
+        MockLogger.emitAll = true;
+      }
+    }
+  }
+  TestOptions2.apply = apply;
+})(TestOptions || (TestOptions = {}));
+export {
+  TestOptions
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/testing/options.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/testing/options.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,SAAS,OAAoC,SAAsB,MAAS;AACxE,MAAI,QAAQ,IAAI,MAAM,UAAa,QAAQ,IAAI,MAAM,MAAM;AACvD,WAAO,QAAQ,IAAI;AAAA,EACvB;AAGA,MAAI,OAAO,YAAY,aAAa;AAChC;AAAA,EACJ;AAEA,SAAO,QAAQ,MACX,YACI,KACK,MAAM,aAAa,GAClB,IAAI,OAAK,EAAE,YAAY,CAAC,EACzB,KAAK,GAAG,CACrB;AACJ;AAEO,IAAU;AAAA,CAAV,CAAUA,iBAAV;AACI,WAAS,MAAM,OAAc,SAAsB;AACtD,UAAM,OAAO,OAAO,SAAS,MAAM;AACnC,QAAI,MAAM;AACN,YAAM,KAAK,IAAI;AAAA,IACnB;AACA,UAAM,QAAQ,OAAO,SAAS,OAAO;AACrC,QAAI,OAAO;AACP,YAAM,MAAM,KAAK;AAAA,IACrB;AACA,UAAM,SAAS,OAAO,SAAS,QAAQ;AACvC,QAAI,QAAQ;AACR,YAAM,OAAO;AAAA,IACjB;AACA,UAAM,UAAU,OAAO,SAAS,SAAS;AACzC,QAAI,SAAS;AACT,UAAI,OAAO,eAAe,aAAa;AACnC,mBAAW,UAAU;AAAA,MACzB;AAAA,IACJ;AAAA,EACJ;AAnBO,EAAAA,aAAS;AAAA,GADH;",
+  "names": ["TestOptions"]
+}