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

package/dist/cjs/testing/mocks/crypto.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var crypto_exports = {};
+__export(crypto_exports, {
+  cryptoSetup: () => cryptoSetup
+});
+module.exports = __toCommonJS(crypto_exports);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const subtle = globalThis.crypto.subtle;
+const TheCrypto = {
+  getRandomData: (length) => {
+    const bytes = new Uint8Array(length);
+    return bytes;
+  },
+  async pbkdf2(secret, salt, iteration, keyLength) {
+    const key = await subtle.importKey("raw", secret, "PBKDF2", false, ["deriveBits"]);
+    const bits = await subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        hash: "SHA-256",
+        salt,
+        iterations: iteration
+      },
+      key,
+      keyLength * 8
+    );
+    return new Uint8Array(bits);
+  },
+  async hkdf(secret, salt, info, length = 16) {
+    const key = await subtle.importKey("raw", secret, "HKDF", false, ["deriveBits"]);
+    return new Uint8Array(
+      await subtle.deriveBits(
+        {
+          name: "HKDF",
+          hash: "SHA-256",
+          salt,
+          info
+        },
+        key,
+        length
+      )
+    );
+  },
+  verify() {
+    return;
+  },
+  mock: true
+};
+function cryptoSetup(Crypto) {
+  try {
+    Crypto.get();
+  } catch (e) {
+    if (e.constructor.name !== "NoProviderError") {
+      throw e;
+    }
+    Crypto.get = () => TheCrypto;
+  }
+}
+//# sourceMappingURL=crypto.js.map

package/dist/cjs/testing/mocks/crypto.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/testing/mocks/crypto.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,MAAM,SAAS,WAAW,OAAO;AAOjC,MAAM,YAAY;AAAA,EACd,eAAe,CAAC,WAAmB;AAE/B,UAAM,QAAQ,IAAI,WAAW,MAAM;AAEnC,WAAO;AAAA,EACX;AAAA,EAEA,MAAM,OAAO,QAAoB,MAAkB,WAAmB,WAAmB;AACrF,UAAM,MAAM,MAAM,OAAO,UAAU,OAAO,QAAQ,UAAU,OAAO,CAAC,YAAY,CAAC;AACjF,UAAM,OAAO,MAAM,OAAO;AAAA,MACtB;AAAA,QACI,MAAM;AAAA,QACN,MAAM;AAAA,QACN;AAAA,QACA,YAAY;AAAA,MAChB;AAAA,MACA;AAAA,MACA,YAAY;AAAA,IAChB;AACA,WAAO,IAAI,WAAW,IAAI;AAAA,EAC9B;AAAA,EAEA,MAAM,KAAK,QAAoB,MAAkB,MAAkB,SAAiB,IAAI;AACpF,UAAM,MAAM,MAAM,OAAO,UAAU,OAAO,QAAQ,QAAQ,OAAO,CAAC,YAAY,CAAC;AAC/E,WAAO,IAAI;AAAA,MACP,MAAM,OAAO;AAAA,QACT;AAAA,UACI,MAAM;AAAA,UACN,MAAM;AAAA,UACN;AAAA,UACA;AAAA,QACJ;AAAA,QACA;AAAA,QACA;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAAA,EAEA,SAAS;AAEL;AAAA,EACJ;AAAA,EAEA,MAAM;AACV;AAEO,SAAS,YAAY,QAAa;AACrC,MAAI;AACA,WAAO,IAAI;AAAA,EACf,SAAS,GAAG;AACR,QAAK,EAAY,YAAY,SAAS,mBAAmB;AACrD,YAAM;AAAA,IACV;AACA,WAAO,MAAM,MAAM;AAAA,EACvB;AACJ;",
+  "names": []
+}

package/dist/cjs/testing/mocks/environment.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=environment.d.ts.map

package/dist/cjs/testing/mocks/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../../src/testing/mocks/environment.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/cjs/testing/mocks/environment.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=environment.js.map

package/dist/cjs/testing/mocks/environment.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/testing/mocks/environment.ts"],
+  "mappings": ";AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/testing/mocks/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import "./environment.js";
+import "./logging.js";
+export * from "./crypto.js";
+export * from "./time.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/testing/mocks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/mocks/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,cAAc,CAAC;AACtB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}

package/dist/cjs/testing/mocks/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mocks_exports = {};
+module.exports = __toCommonJS(mocks_exports);
+var import_environment = require("./environment.js");
+var import_logging = require("./logging.js");
+__reExport(mocks_exports, require("./crypto.js"), module.exports);
+__reExport(mocks_exports, require("./time.js"), module.exports);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=index.js.map

package/dist/cjs/testing/mocks/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/testing/mocks/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAMA,yBAAO;AACP,qBAAO;AACP,0BAAc,wBARd;AASA,0BAAc,sBATd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/testing/mocks/logging.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+interface LoggerLike {
+    format: string;
+    log(level: number, message: string): void;
+}
+export interface MockLogger {
+    emitAll: boolean;
+    injectExternalMessage: (source: string, text: string) => void;
+}
+export declare const TheMockLogger: MockLogger;
+/**
+ * These functions are invoked by beforeEach/afterEach handlers in generalSetup for Mocha.
+ *
+ * We place them in an array here rather than calling the global hook functions so that load order doesn't matter.  We
+ * use an array so that if multiple Logger classes are created (e.g. one for CJS and one for ESM) we don't have to worry
+ * about which logger is doing the logging.
+ */
+export declare const LoggerHooks: {
+    beforeEach: ((mocha: Mocha) => void)[];
+    afterEach: ((mocha: Mocha) => void)[];
+};
+export declare function loggerSetup(Logger: LoggerLike): void;
+export {};
+//# sourceMappingURL=logging.d.ts.map

package/dist/cjs/testing/mocks/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../../src/testing/mocks/logging.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,UAAU,UAAU;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7C;AAED,MAAM,WAAW,UAAU;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,qBAAqB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjE;AAED,eAAO,MAAM,aAAa,EAAE,UAG3B,CAAC;AAMF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW;yBACM,KAAK,KAAK,IAAI;wBACf,KAAK,KAAK,IAAI;CAC1C,CAAC;AAEF,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,QA2D7C"}

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

@@ -0,0 +1,93 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logging_exports = {};
+__export(logging_exports, {
+  LoggerHooks: () => LoggerHooks,
+  TheMockLogger: () => TheMockLogger,
+  loggerSetup: () => loggerSetup
+});
+module.exports = __toCommonJS(logging_exports);
+var import_ansi_colors = __toESM(require("ansi-colors"), 1);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const TheMockLogger = {
+  emitAll: false,
+  injectExternalMessage: (source, text) => console.log(formatExternalMessage(source, text))
+};
+function formatExternalMessage(source, text) {
+  return `    ${import_ansi_colors.default.bgCyan.black.bold(` ${source} `)} ${import_ansi_colors.default.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;
+    }
+  });
+}
+//# sourceMappingURL=logging.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/testing/mocks/logging.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,yBAAmB;AANnB;AAAA;AAAA;AAAA;AAAA;AAkBO,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,mBAAAA,QAAO,OAAO,MAAM,KAAK,IAAI,MAAM,GAAG,CAAC,IAAI,mBAAAA,QAAO,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": ["colors"]
+}

package/dist/cjs/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/cjs/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/cjs/testing/mocks/time.js

@@ -0,0 +1,250 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var time_exports = {};
+__export(time_exports, {
+  MockTime: () => MockTime,
+  timeSetup: () => timeSetup
+});
+module.exports = __toCommonJS(time_exports);
+/**
+ * @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 });
+//# sourceMappingURL=time.js.map

package/dist/cjs/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/cjs/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