velocious 1.0.577 → 1.0.579

package/build/src/testing/test-suite-splitter.d.ts

@@ -1,8 +1,32 @@
+export type SplitterFileEntry = {
+    /**
+     * - Absolute file path.
+     */
+    filePath: string;
+    /**
+     * - Computed weight for load balancing.
+     */
+    weight: number;
+};
+export type GroupBucket = {
+    /**
+     * - Accumulated weight.
+     */
+    totalWeight: number;
+    /**
+     * - Files assigned to this group.
+     */
+    files: string[];
+};
 /**
  * Splits a list of test files into balanced groups using a greedy load-balancing algorithm.
  * Modeled after test_suite_splitter for RSpec.
  */
 export default class TestSuiteSplitter {
+    _groups: number;
+    _groupNumber: number;
+    _testFiles: string[];
+    _baseDirectory: string;
     /**
      * Runs constructor.
      * @param {object} args - Options.
@@ -15,12 +39,8 @@ export default class TestSuiteSplitter {
         groups: number;
         groupNumber: number;
         testFiles: string[];
-        baseDirectory?: string | undefined;
+        baseDirectory?: string;
     });
-    _groups: number;
-    _groupNumber: number;
-    _testFiles: string[];
-    _baseDirectory: string;
     /**
      * Returns the test files assigned to this group.
      * @returns {string[]} - File paths for the requested group.
@@ -58,30 +78,4 @@ export default class TestSuiteSplitter {
      */
     findLightestBucket(buckets: GroupBucket[]): GroupBucket;
 }
-/**
- * SplitterFileEntry type.
- */
-export type SplitterFileEntry = {
-    /**
-     * - Absolute file path.
-     */
-    filePath: string;
-    /**
-     * - Computed weight for load balancing.
-     */
-    weight: number;
-};
-/**
- * GroupBucket type.
- */
-export type GroupBucket = {
-    /**
-     * - Accumulated weight.
-     */
-    totalWeight: number;
-    /**
-     * - Files assigned to this group.
-     */
-    files: string[];
-};
 //# sourceMappingURL=test-suite-splitter.d.ts.map

package/build/src/testing/test-suite-splitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-suite-splitter.d.ts","sourceRoot":"","sources":["../../../src/testing/test-suite-splitter.js"],"names":[],"mappings":"AAoCA;;;GAGG;AACH;IACE;;;;;;;OAOG;IACH,4EALG;QAAqB,MAAM,EAAnB,MAAM;QACO,WAAW,EAAxB,MAAM;QACS,SAAS,EAAxB,MAAM,EAAE;QACM,aAAa;KACrC,EAgBA;IAJC,gBAAqB;IACrB,qBAA+B;IAC/B,qBAA2B;IAC3B,uBAAoD;IAGtD;;;OAGG;IACH,iBAFa,MAAM,EAAE,CAQpB;IAED;;;OAGG;IACH,wBAFa,iBAAiB,EAAE,CAO/B;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,MAAM,CAwBlB;IAED;;;;OAIG;IACH,8BAHW,iBAAiB,EAAE,GACjB,iBAAiB,EAAE,CAU/B;IAED;;;;;OAKG;IACH,gCAHW,iBAAiB,EAAE,GACjB,WAAW,EAAE,CAoBzB;IAED;;;;;OAKG;IACH,4BAHW,WAAW,EAAE,GACX,WAAW,CAYvB;CACF;;;;;;;;cAxKa,MAAM;;;;YACN,MAAM;;;;;;;;;iBAMN,MAAM;;;;WACN,MAAM,EAAE"}
+{"version":3,"file":"test-suite-splitter.d.ts","sourceRoot":"","sources":["../../../src/testing/test-suite-splitter.js"],"names":[],"mappings":"AAOG,YAAkB,iBAAiB,GACnC;;;;IAAmB,QAAQ,EAAhB,MAAM,CACjB;;;;IAAmB,MAAM,EAAd,MAAM,CACnB;CAAA,CAAA;AAIE,YAAkB,WAAW,GAC7B;;;;IAAmB,WAAW,EAAnB,MAAM,CACjB;;;;IAAqB,KAAK,EAAf,MAAM,EAAE,CACrB;CAAA,CAAA;AAmBD;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;IAoB7B,OAAO;IACP,YAAY;IACZ,UAAU;IACV,cAAc;IAtBrB;;;;;;;OAOG;IACH,YAAY,EAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,QAAQ,EAAC,EALrE;QAAqB,MAAM,EAAnB,MAAM,CACd;QAAqB,WAAW,EAAxB,MAAM,CACd;QAAuB,SAAS,EAAxB,MAAM,EAAE,CAChB;QAAsB,aAAa,AAAnC,CACF,EADU,MAAM,CAChB;KACuE,EAevE;IAED;;;OAGG;IACH,aAAa,IAFA,MAAM,EAAE,CAQpB;IAED;;;OAGG;IACH,oBAAoB,IAFP,iBAAiB,EAAE,CAO/B;IAED;;;;OAIG;IACH,aAAa,CAAC,QAAQ,EAHX,MAGW,GAFT,MAAM,CAwBlB;IAED;;;;OAIG;IACH,sBAAsB,CAAC,KAAK,EAHjB,iBAAiB,EAGA,GAFf,iBAAiB,EAAE,CAU/B;IAED;;;;;OAKG;IACH,kBAAkB,CAAC,WAAW,EAHnB,iBAAiB,EAGE,GAFjB,WAAW,EAAE,CAoBzB;IAED;;;;;OAKG;IACH,kBAAkB,CAAC,OAAO,EAHf,WAAW,EAGI,GAFb,WAAW,CAYvB;CACF"}

package/build/src/testing/test.d.ts

@@ -1,6 +1,6 @@
-/**
- * VelociousTestConfig type.
- */
+import Expect from "./expect.js";
+import waitForEvent from "./wait-for-event.js";
+import { arrayContaining, objectContaining } from "./expect-utils.js";
 export type VelociousTestConfig = {
     /**
      * - Console output mode.
@@ -20,44 +20,61 @@ export type VelociousTestConfig = {
     failedConsoleOutputMaxLines: number;
 };
 /**
- * Runs after all.
- * @param {import("./test-runner.js").BeforeAfterAllCallbackType} callback - Callback function.
- * @returns {void} - No return value.
+ * VelociousTestConfig type.
+ * @typedef {object} VelociousTestConfig
+ * @property {"failure" | "live"} consoleOutput - Console output mode.
+ * @property {string[]} excludeTags - Tags excluded by default.
+ * @property {number} defaultTimeoutSeconds - Default timeout in seconds.
+ * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.
  */
-export function afterAll(callback: import("./test-runner.js").BeforeAfterAllCallbackType): void;
 /**
- * Runs after each.
+ * Tests.
+ * @type {import("./test-runner.js").TestsArgument} */
+declare const tests: import("./test-runner.js").TestsArgument;
+declare const testEvents: import("eventemitter3").EventEmitter<string | symbol, any>;
+/**
+ * Test config.
+ * @type {VelociousTestConfig} */
+declare const testConfig: VelociousTestConfig;
+/**
+ * Runs configure tests.
+ * @param {object} args - Options.
+ * @param {"failure" | "live"} [args.consoleOutput] - Console output mode.
+ * @param {string[] | string} [args.excludeTags] - Tags to exclude.
+ * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.
+ * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.
+ * @returns {void}
+ */
+declare function configureTests({ consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines }?: {
+    consoleOutput?: "failure" | "live";
+    excludeTags?: string[] | string;
+    defaultTimeoutSeconds?: number;
+    failedConsoleOutputMaxLines?: number;
+}): void;
+/**
+ * Runs before each.
  * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback - Callback function.
  * @returns {void} - No return value.
  */
-export function afterEach(callback: import("./test-runner.js").AfterBeforeEachCallbackType): void;
+declare function beforeEach(callback: import("./test-runner.js").AfterBeforeEachCallbackType): void;
 /**
  * Runs before all.
  * @param {import("./test-runner.js").BeforeAfterAllCallbackType} callback - Callback function.
  * @returns {void} - No return value.
  */
-export function beforeAll(callback: import("./test-runner.js").BeforeAfterAllCallbackType): void;
+declare function beforeAll(callback: import("./test-runner.js").BeforeAfterAllCallbackType): void;
 /**
- * Runs before each.
+ * Runs after each.
  * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback - Callback function.
  * @returns {void} - No return value.
  */
-export function beforeEach(callback: import("./test-runner.js").AfterBeforeEachCallbackType): void;
+declare function afterEach(callback: import("./test-runner.js").AfterBeforeEachCallbackType): void;
 /**
- * Runs configure tests.
- * @param {object} args - Options.
- * @param {"failure" | "live"} [args.consoleOutput] - Console output mode.
- * @param {string[] | string} [args.excludeTags] - Tags to exclude.
- * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.
- * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.
- * @returns {void}
+ * Runs after all.
+ * @param {import("./test-runner.js").BeforeAfterAllCallbackType} callback - Callback function.
+ * @returns {void} - No return value.
  */
-export function configureTests({ consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines }?: {
-    consoleOutput?: "failure" | "live" | undefined;
-    excludeTags?: string | string[] | undefined;
-    defaultTimeoutSeconds?: number | undefined;
-    failedConsoleOutputMaxLines?: number | undefined;
-}): void;
+declare function afterAll(callback: import("./test-runner.js").BeforeAfterAllCallbackType): void;
 /**
  * Runs describe.
  * @param {string} description - Description.
@@ -65,53 +82,32 @@ export function configureTests({ consoleOutput, excludeTags, defaultTimeoutSecon
  * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.
  * @returns {Promise<void>} - Resolves when complete.
  */
-export function describe(description: string, arg1: object | (() => (void | Promise<void>)), arg2?: undefined | (() => (void | Promise<void>))): Promise<void>;
+declare function describe(description: string, arg1: object | (() => (void | Promise<void>)), arg2?: undefined | (() => (void | Promise<void>))): Promise<void>;
 /**
  * Runs expect.
- * @param {?} arg - Arg.
+ * @param {ReturnType<typeof JSON.parse>} arg - Arg.
  * @returns {Expect} - The expect.
  */
-export function expect(arg: unknown): Expect;
-export namespace expect {
+declare function expect(arg: ReturnType<typeof JSON.parse>): Expect;
+declare namespace expect {
     export { objectContaining };
     export { arrayContaining };
 }
 /**
- * Runs fit.
+ * Runs it.
  * @param {string} description - Description.
  * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.
  * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.
  * @returns {void} - No return value.
  */
-export function fit(description: string, arg1: object | (() => (void | Promise<void>)), arg2?: undefined | (() => (void | Promise<void>))): void;
+declare function it(description: string, arg1: object | (() => (void | Promise<void>)), arg2?: undefined | (() => (void | Promise<void>))): void;
 /**
- * Runs it.
+ * Runs fit.
  * @param {string} description - Description.
  * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.
  * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.
  * @returns {void} - No return value.
  */
-export function it(description: string, arg1: object | (() => (void | Promise<void>)), arg2?: undefined | (() => (void | Promise<void>))): void;
-import { arrayContaining } from "./expect-utils.js";
-import { objectContaining } from "./expect-utils.js";
-/**
- * Test config.
- * @type {VelociousTestConfig} */
-export const testConfig: VelociousTestConfig;
-export const testEvents: import("eventemitter3").EventEmitter<string | symbol, any>;
-/**
- * VelociousTestConfig type.
- * @typedef {object} VelociousTestConfig
- * @property {"failure" | "live"} consoleOutput - Console output mode.
- * @property {string[]} excludeTags - Tags excluded by default.
- * @property {number} defaultTimeoutSeconds - Default timeout in seconds.
- * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.
- */
-/**
- * Tests.
- * @type {import("./test-runner.js").TestsArgument} */
-export const tests: import("./test-runner.js").TestsArgument;
-import waitForEvent from "./wait-for-event.js";
-import Expect from "./expect.js";
-export { arrayContaining, objectContaining, waitForEvent };
+declare function fit(description: string, arg1: object | (() => (void | Promise<void>)), arg2?: undefined | (() => (void | Promise<void>))): void;
+export { afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent };
 //# sourceMappingURL=test.d.ts.map

package/build/src/testing/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":";;;;;;;mBAYc,SAAS,GAAG,MAAM;;;;iBAClB,MAAM,EAAE;;;;2BACR,MAAM;;;;iCACN,MAAM;;AA0LpB;;;;GAIG;AACH,mCAHW,OAAO,kBAAkB,EAAE,0BAA0B,GACnD,IAAI,CAMhB;AApBD;;;;GAIG;AACH,oCAHW,OAAO,kBAAkB,EAAE,2BAA2B,GACpD,IAAI,CAMhB;AApBD;;;;GAIG;AACH,oCAHW,OAAO,kBAAkB,EAAE,0BAA0B,GACnD,IAAI,CAMhB;AApBD;;;;GAIG;AACH,qCAHW,OAAO,kBAAkB,EAAE,2BAA2B,GACpD,IAAI,CAMhB;AA3DD;;;;;;;;GAQG;AACH,oHANG;IAAkC,aAAa;IACd,WAAW;IACtB,qBAAqB;IACrB,2BAA2B;CACjD,GAAU,IAAI,CAsBhB;AAiED;;;;;;GAMG;AACH,sCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SACnC,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CA8CzB;AAED;;;;GAIG;AACH,4BAHW,OAAC,GACC,MAAM,CAIlB;;;;;AA8CD;;;;;;GAMG;AACH,iCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SACnC,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GACpC,IAAI,CAwBhB;AAtED;;;;;;GAMG;AACH,gCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SACnC,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GACpC,IAAI,CAkChB;gCArT+C,mBAAmB;iCAAnB,mBAAmB;AAqGnE;;iCAEiC;AACjC,yBADU,mBAAmB,CAM5B;AAvED,oFAAqC;AApCrC;;;;;;;GAOG;AACH;;sDAEsD;AACtD,oBADU,OAAO,kBAAkB,EAAE,aAAa,CAwBjD;yBArCwB,qBAAqB;mBAD3B,aAAa"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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"}

package/build/src/testing/test.js

@@ -128,9 +128,9 @@ function configureTests({ consoleOutput, excludeTags, defaultTimeoutSeconds, fai
 }
 /**
  * Runs merge test args.
- * @param {Record<string, ?>} baseArgs - Base args.
- * @param {Record<string, ?>} extraArgs - Extra args.
- * @returns {Record<string, ?>} - Merged args.
+ * @param {Record<string, ReturnType<typeof JSON.parse>>} baseArgs - Base args.
+ * @param {Record<string, ReturnType<typeof JSON.parse>>} extraArgs - Extra args.
+ * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Merged args.
  */
 function mergeTestArgs(baseArgs, extraArgs) {
     const merged = Object.assign({}, baseArgs, extraArgs);
@@ -189,7 +189,7 @@ function afterAll(callback) {
 async function describe(description, arg1, arg2) {
     /**
      * Defines testArgs.
-     * @type {Record<string, ?>} */
+     * @type {Record<string, ReturnType<typeof JSON.parse>>} */
     let testArgs, testFunction;
     if (typeof arg2 == "function") {
         testFunction = arg2;
@@ -230,7 +230,7 @@ async function describe(description, arg1, arg2) {
 }
 /**
  * Runs expect.
- * @param {?} arg - Arg.
+ * @param {ReturnType<typeof JSON.parse>} arg - Arg.
  * @returns {Expect} - The expect.
  */
 function expect(arg) {
@@ -249,7 +249,7 @@ function it(description, arg1, arg2) {
     const currentTest = currentPath[currentPath.length - 1];
     /**
      * Defines testArgs.
-     * @type {Record<string, ?>} */
+     * @type {Record<string, ReturnType<typeof JSON.parse>>} */
     let testArgs;
     /**
      * Defines testFunction.
@@ -285,7 +285,7 @@ function it(description, arg1, arg2) {
 function fit(description, arg1, arg2) {
     /**
      * Defines testArgs.
-     * @type {Record<string, ?>} */
+     * @type {Record<string, ReturnType<typeof JSON.parse>>} */
     let testArgs;
     /**
      * Defines testFunction.
@@ -305,15 +305,17 @@ function fit(description, arg1, arg2) {
     return it(description, testArgs, testFunction);
 }
 // Make the methods global so they can be used in test files
-globalThis.afterEach = afterEach;
-globalThis.afterAll = afterAll;
-globalThis.beforeEach = beforeEach;
-globalThis.beforeAll = beforeAll;
-globalThis.describe = describe;
-globalThis.expect = expect;
-globalThis.it = it;
-globalThis.fit = fit;
-globalThis.testEvents = testEvents;
-globalThis.configureTests = configureTests;
+Object.assign(globalThis, {
+    afterAll,
+    afterEach,
+    beforeAll,
+    beforeEach,
+    configureTests,
+    describe,
+    expect,
+    fit,
+    it,
+    testEvents
+});
 export { afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport {fileURLToPath} from \"url\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Expect from \"./expect.js\"\nimport waitForEvent from \"./wait-for-event.js\"\nimport {arrayContaining, objectContaining} from \"./expect-utils.js\"\n\n/**\n * VelociousTestConfig type.\n * @typedef {object} VelociousTestConfig\n * @property {\"failure\" | \"live\"} consoleOutput - Console output mode.\n * @property {string[]} excludeTags - Tags excluded by default.\n * @property {number} defaultTimeoutSeconds - Default timeout in seconds.\n * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.\n */\n/**\n * Tests.\n * @type {import(\"./test-runner.js\").TestsArgument} */\nconst tests = {\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  afterEaches: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  afterAlls: [],\n  args: {},\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  beforeAlls: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  beforeEaches: [],\n  filePath: undefined,\n  line: undefined,\n  subs: {},\n  tests: {}\n}\n\nconst testEvents = new EventEmitter()\n\nlet currentPath = [tests]\n\n/**\n * Runs capture location.\n * @returns {{filePath?: string, line?: number}} - Location.\n */\nfunction captureLocation() {\n  const error = new Error()\n  const stack = typeof error.stack === \"string\" ? error.stack.split(\"\\n\") : []\n\n  for (const line of stack) {\n    const trimmed = line.trim()\n\n    if (!trimmed.includes(\"at\")) continue\n    if (trimmed.includes(\"/src/testing/test.js\")) continue\n\n    const match = trimmed.match(/(?:\\(|\\s)(file:\\/\\/.*?|\\/.*?):(\\d+):(\\d+)\\)?$/)\n\n    if (!match) continue\n\n    const rawPath = match[1]\n    const lineNumber = Number(match[2])\n    const filePath = rawPath.startsWith(\"file://\")\n      ? fileURLToPath(rawPath)\n      : rawPath\n\n    return {\n      filePath: path.resolve(filePath),\n      line: Number.isFinite(lineNumber) ? lineNumber : undefined\n    }\n  }\n\n  return {}\n}\n\n/**\n * Runs normalize tags.\n * @param {string[] | string | undefined} tags - Tags.\n * @returns {string[]} - Normalized tags.\n */\nfunction normalizeTags(tags) {\n  if (!tags) return []\n\n  const values = []\n  const rawTags = Array.isArray(tags) ? tags : [tags]\n\n  for (const rawTag of rawTags) {\n    if (rawTag === undefined || rawTag === null) continue\n\n    const parts = String(rawTag).split(\",\")\n\n    for (const part of parts) {\n      const trimmed = part.trim()\n\n      if (trimmed) values.push(trimmed)\n    }\n  }\n\n  return Array.from(new Set(values))\n}\n\n/**\n * Test config.\n * @type {VelociousTestConfig} */\nconst testConfig = {\n  consoleOutput: \"failure\",\n  failedConsoleOutputMaxLines: 200,\n  excludeTags: [],\n  defaultTimeoutSeconds: 60\n}\n\n/**\n * Runs configure tests.\n * @param {object} args - Options.\n * @param {\"failure\" | \"live\"} [args.consoleOutput] - Console output mode.\n * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.\n * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.\n * @returns {void}\n */\nfunction configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines} = {}) {\n  if (excludeTags !== undefined) {\n    testConfig.excludeTags = normalizeTags(excludeTags)\n  }\n\n  if (consoleOutput !== undefined) {\n    if (consoleOutput !== \"failure\" && consoleOutput !== \"live\") {\n      throw new Error(`Invalid consoleOutput config: ${consoleOutput}`)\n    }\n\n    testConfig.consoleOutput = consoleOutput\n  }\n\n  if (typeof defaultTimeoutSeconds === \"number\") {\n    testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds\n  }\n\n  if (typeof failedConsoleOutputMaxLines === \"number\") {\n    testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines\n  }\n}\n\n/**\n * Runs merge test args.\n * @param {Record<string, ?>} baseArgs - Base args.\n * @param {Record<string, ?>} extraArgs - Extra args.\n * @returns {Record<string, ?>} - Merged args.\n */\nfunction mergeTestArgs(baseArgs, extraArgs) {\n  const merged = Object.assign({}, baseArgs, extraArgs)\n  const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)]\n\n  if (mergedTags.length > 0) {\n    merged.tags = Array.from(new Set(mergedTags))\n  } else if (\"tags\" in merged) {\n    delete merged.tags\n  }\n\n  return merged\n}\n\n/**\n * Runs before each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeEaches.push({callback})\n}\n\n/**\n * Runs before all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeAlls.push({callback})\n}\n\n/**\n * Runs after each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterEaches.push({callback})\n}\n\n/**\n * Runs after all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterAlls.push({callback})\n}\n\n/**\n * Runs describe.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {Promise<void>} - Resolves when complete.\n */\nasync function describe(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ?>} */\n  let testArgs, testFunction\n\n  if (typeof arg2 == \"function\") {\n    testFunction = arg2\n    testArgs = arg1\n  } else if (typeof arg1 == \"function\") {\n    testFunction = arg1\n    testArgs = {}\n  } else {\n    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)\n  }\n\n  const currentTest = currentPath[currentPath.length - 1]\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  if (description in currentTest.subs) {\n    throw new Error(`Duplicate test description: ${description}`)\n  }\n\n  const location = captureLocation()\n  const newTestData = {\n    afterEaches: [],\n    afterAlls: [],\n    args: newTestArgs,\n    beforeAlls: [],\n    beforeEaches: [],\n    filePath: location.filePath,\n    line: location.line,\n    subs: {},\n    tests: {}\n  }\n\n  currentTest.subs[description] = newTestData\n  currentPath.push(newTestData)\n\n  try {\n    await testFunction()\n  } finally {\n    currentPath.pop()\n  }\n}\n\n/**\n * Runs expect.\n * @param {?} arg - Arg.\n * @returns {Expect} - The expect.\n */\nfunction expect(arg) {\n  return new Expect(arg)\n}\n\nexpect.objectContaining = objectContaining\nexpect.arrayContaining = arrayContaining\n\n/**\n * Runs it.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction it(description, arg1, arg2) {\n  const currentTest = currentPath[currentPath.length - 1]\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ?>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = arg1\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  const location = captureLocation()\n\n  currentTest.tests[description] = {\n    args: newTestArgs,\n    function: testFunction,\n    filePath: location.filePath,\n    line: location.line\n  }\n}\n\n/**\n * Runs fit.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction fit(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ?>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {focus: true}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = Object.assign({focus: true}, arg1)\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  return it(description, testArgs, testFunction)\n}\n\n// Make the methods global so they can be used in test files\nglobalThis.afterEach = afterEach\nglobalThis.afterAll = afterAll\nglobalThis.beforeEach = beforeEach\nglobalThis.beforeAll = beforeAll\nglobalThis.describe = describe\nglobalThis.expect = expect\nglobalThis.it = it\nglobalThis.fit = fit\nglobalThis.testEvents = testEvents\nglobalThis.configureTests = configureTests\n\nexport {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport {fileURLToPath} from \"url\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Expect from \"./expect.js\"\nimport waitForEvent from \"./wait-for-event.js\"\nimport {arrayContaining, objectContaining} from \"./expect-utils.js\"\n\n/**\n * VelociousTestConfig type.\n * @typedef {object} VelociousTestConfig\n * @property {\"failure\" | \"live\"} consoleOutput - Console output mode.\n * @property {string[]} excludeTags - Tags excluded by default.\n * @property {number} defaultTimeoutSeconds - Default timeout in seconds.\n * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.\n */\n/**\n * Tests.\n * @type {import(\"./test-runner.js\").TestsArgument} */\nconst tests = {\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  afterEaches: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  afterAlls: [],\n  args: {},\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  beforeAlls: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  beforeEaches: [],\n  filePath: undefined,\n  line: undefined,\n  subs: {},\n  tests: {}\n}\n\nconst testEvents = new EventEmitter()\n\nlet currentPath = [tests]\n\n/**\n * Runs capture location.\n * @returns {{filePath?: string, line?: number}} - Location.\n */\nfunction captureLocation() {\n  const error = new Error()\n  const stack = typeof error.stack === \"string\" ? error.stack.split(\"\\n\") : []\n\n  for (const line of stack) {\n    const trimmed = line.trim()\n\n    if (!trimmed.includes(\"at\")) continue\n    if (trimmed.includes(\"/src/testing/test.js\")) continue\n\n    const match = trimmed.match(/(?:\\(|\\s)(file:\\/\\/.*?|\\/.*?):(\\d+):(\\d+)\\)?$/)\n\n    if (!match) continue\n\n    const rawPath = match[1]\n    const lineNumber = Number(match[2])\n    const filePath = rawPath.startsWith(\"file://\")\n      ? fileURLToPath(rawPath)\n      : rawPath\n\n    return {\n      filePath: path.resolve(filePath),\n      line: Number.isFinite(lineNumber) ? lineNumber : undefined\n    }\n  }\n\n  return {}\n}\n\n/**\n * Runs normalize tags.\n * @param {string[] | string | undefined} tags - Tags.\n * @returns {string[]} - Normalized tags.\n */\nfunction normalizeTags(tags) {\n  if (!tags) return []\n\n  const values = []\n  const rawTags = Array.isArray(tags) ? tags : [tags]\n\n  for (const rawTag of rawTags) {\n    if (rawTag === undefined || rawTag === null) continue\n\n    const parts = String(rawTag).split(\",\")\n\n    for (const part of parts) {\n      const trimmed = part.trim()\n\n      if (trimmed) values.push(trimmed)\n    }\n  }\n\n  return Array.from(new Set(values))\n}\n\n/**\n * Test config.\n * @type {VelociousTestConfig} */\nconst testConfig = {\n  consoleOutput: \"failure\",\n  failedConsoleOutputMaxLines: 200,\n  excludeTags: [],\n  defaultTimeoutSeconds: 60\n}\n\n/**\n * Runs configure tests.\n * @param {object} args - Options.\n * @param {\"failure\" | \"live\"} [args.consoleOutput] - Console output mode.\n * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.\n * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.\n * @returns {void}\n */\nfunction configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines} = {}) {\n  if (excludeTags !== undefined) {\n    testConfig.excludeTags = normalizeTags(excludeTags)\n  }\n\n  if (consoleOutput !== undefined) {\n    if (consoleOutput !== \"failure\" && consoleOutput !== \"live\") {\n      throw new Error(`Invalid consoleOutput config: ${consoleOutput}`)\n    }\n\n    testConfig.consoleOutput = consoleOutput\n  }\n\n  if (typeof defaultTimeoutSeconds === \"number\") {\n    testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds\n  }\n\n  if (typeof failedConsoleOutputMaxLines === \"number\") {\n    testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines\n  }\n}\n\n/**\n * Runs merge test args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} baseArgs - Base args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} extraArgs - Extra args.\n * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Merged args.\n */\nfunction mergeTestArgs(baseArgs, extraArgs) {\n  const merged = Object.assign({}, baseArgs, extraArgs)\n  const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)]\n\n  if (mergedTags.length > 0) {\n    merged.tags = Array.from(new Set(mergedTags))\n  } else if (\"tags\" in merged) {\n    delete merged.tags\n  }\n\n  return merged\n}\n\n/**\n * Runs before each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeEaches.push({callback})\n}\n\n/**\n * Runs before all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeAlls.push({callback})\n}\n\n/**\n * Runs after each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterEaches.push({callback})\n}\n\n/**\n * Runs after all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterAlls.push({callback})\n}\n\n/**\n * Runs describe.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {Promise<void>} - Resolves when complete.\n */\nasync function describe(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs, testFunction\n\n  if (typeof arg2 == \"function\") {\n    testFunction = arg2\n    testArgs = arg1\n  } else if (typeof arg1 == \"function\") {\n    testFunction = arg1\n    testArgs = {}\n  } else {\n    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)\n  }\n\n  const currentTest = currentPath[currentPath.length - 1]\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  if (description in currentTest.subs) {\n    throw new Error(`Duplicate test description: ${description}`)\n  }\n\n  const location = captureLocation()\n  const newTestData = {\n    afterEaches: [],\n    afterAlls: [],\n    args: newTestArgs,\n    beforeAlls: [],\n    beforeEaches: [],\n    filePath: location.filePath,\n    line: location.line,\n    subs: {},\n    tests: {}\n  }\n\n  currentTest.subs[description] = newTestData\n  currentPath.push(newTestData)\n\n  try {\n    await testFunction()\n  } finally {\n    currentPath.pop()\n  }\n}\n\n/**\n * Runs expect.\n * @param {ReturnType<typeof JSON.parse>} arg - Arg.\n * @returns {Expect} - The expect.\n */\nfunction expect(arg) {\n  return new Expect(arg)\n}\n\nexpect.objectContaining = objectContaining\nexpect.arrayContaining = arrayContaining\n\n/**\n * Runs it.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction it(description, arg1, arg2) {\n  const currentTest = currentPath[currentPath.length - 1]\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = arg1\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  const location = captureLocation()\n\n  currentTest.tests[description] = {\n    args: newTestArgs,\n    function: testFunction,\n    filePath: location.filePath,\n    line: location.line\n  }\n}\n\n/**\n * Runs fit.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction fit(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {focus: true}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = Object.assign({focus: true}, arg1)\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  return it(description, testArgs, testFunction)\n}\n\n// Make the methods global so they can be used in test files\nObject.assign(globalThis, {\n  afterAll,\n  afterEach,\n  beforeAll,\n  beforeEach,\n  configureTests,\n  describe,\n  expect,\n  fit,\n  it,\n  testEvents\n})\n\nexport {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent}\n"]}

package/build/src/testing/wait-for-event.d.ts

@@ -1,12 +1,32 @@
+export type WaitForEventOptions = {
+    /**
+     * Timeout in milliseconds (default: 5000).
+     */
+    timeoutMs?: number;
+    /**
+     * Only resolve when this predicate returns true for the emitted arguments.
+     */
+    filter?: (...args: Array<ReturnType<typeof JSON.parse>>) => boolean;
+};
+export type EventEmitterLike = {
+    /**
+     * Registers a listener.
+     */
+    on: (event: string, listener: (...args: Array<ReturnType<typeof JSON.parse>>) => void) => void;
+    /**
+     * Removes a listener.
+     */
+    off: (event: string, listener: (...args: Array<ReturnType<typeof JSON.parse>>) => void) => void;
+};
 /**
  * @typedef {object} WaitForEventOptions
  * @property {number} [timeoutMs] Timeout in milliseconds (default: 5000).
- * @property {(...args: Array<?>) => boolean} [filter] Only resolve when this predicate returns true for the emitted arguments.
+ * @property {(...args: Array<ReturnType<typeof JSON.parse>>) => boolean} [filter] Only resolve when this predicate returns true for the emitted arguments.
  */
 /**
  * @typedef {object} EventEmitterLike
- * @property {(event: string, listener: (...args: Array<?>) => void) => void} on Registers a listener.
- * @property {(event: string, listener: (...args: Array<?>) => void) => void} off Removes a listener.
+ * @property {(event: string, listener: (...args: Array<ReturnType<typeof JSON.parse>>) => void) => void} on Registers a listener.
+ * @property {(event: string, listener: (...args: Array<ReturnType<typeof JSON.parse>>) => void) => void} off Removes a listener.
  */
 /**
  * Resolves the moment `eventName` fires on `emitter` — optionally only when `filter`
@@ -20,27 +40,7 @@
  * @param {EventEmitterLike} emitter - Event emitter exposing `on`/`off` (Node EventEmitter, eventemitter3, velocious `testEvents`, ...).
  * @param {string} eventName - The event to wait for.
  * @param {WaitForEventOptions} [options] - Options.
- * @returns {Promise<?>} - Resolves with the single emitted argument, an array when the event emits multiple, or undefined when it emits none.
+ * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the single emitted argument, an array when the event emits multiple, or undefined when it emits none.
  */
-export default function waitForEvent(emitter: EventEmitterLike, eventName: string, options?: WaitForEventOptions): Promise<unknown>;
-export type WaitForEventOptions = {
-    /**
-     * Timeout in milliseconds (default: 5000).
-     */
-    timeoutMs?: number | undefined;
-    /**
-     * Only resolve when this predicate returns true for the emitted arguments.
-     */
-    filter?: ((...args: Array<unknown>) => boolean) | undefined;
-};
-export type EventEmitterLike = {
-    /**
-     * Registers a listener.
-     */
-    on: (event: string, listener: (...args: Array<unknown>) => void) => void;
-    /**
-     * Removes a listener.
-     */
-    off: (event: string, listener: (...args: Array<unknown>) => void) => void;
-};
+export default function waitForEvent(emitter: EventEmitterLike, eventName: string, options?: WaitForEventOptions): Promise<ReturnType<typeof JSON.parse>>;
 //# sourceMappingURL=wait-for-event.d.ts.map

package/build/src/testing/wait-for-event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wait-for-event.d.ts","sourceRoot":"","sources":["../../../src/testing/wait-for-event.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,8CALW,gBAAgB,aAChB,MAAM,YACN,mBAAmB,GACjB,OAAO,CAAC,OAAC,CAAC,CA6CtB;;;;;;;;;wBAlEuB,KAAK,CAAC,OAAC,CAAC,KAAK,OAAO;;;;;;QAK9B,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,OAAC,CAAC,KAAK,IAAI,KAAK,IAAI;;;;SAC9D,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,OAAC,CAAC,KAAK,IAAI,KAAK,IAAI"}
+{"version":3,"file":"wait-for-event.d.ts","sourceRoot":"","sources":["../../../src/testing/wait-for-event.js"],"names":[],"mappings":"AAGG,YAAkB,mBAAmB,GACrC;;;;IAAoB,SAAS,AAA7B,CACA,EADW,MAAM,CACjB;;;;IAAwE,MAAM,AAA9E,CACF,EADa,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,OAAO,CACvE;CAAA,CAAA;AAGE,YAAkB,gBAAgB,GAClC;;;;IAAuG,EAAE,EAA9F,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,KAAK,IAAI,CACrG;;;;IAAuG,GAAG,EAA/F,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,KAAK,IAAI,CACvG;CAAA,CAAA;AAVD;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,OAAO,EALjC,gBAKiC,EAAE,SAAS,EAJ5C,MAI4C,EAAE,OAAO,AAH7D,CACA,EADQ,mBAG0D,GAFxD,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CA6ClD"}

package/build/src/testing/wait-for-event.js

@@ -2,12 +2,12 @@
 /**
  * @typedef {object} WaitForEventOptions
  * @property {number} [timeoutMs] Timeout in milliseconds (default: 5000).
- * @property {(...args: Array<?>) => boolean} [filter] Only resolve when this predicate returns true for the emitted arguments.
+ * @property {(...args: Array<ReturnType<typeof JSON.parse>>) => boolean} [filter] Only resolve when this predicate returns true for the emitted arguments.
  */
 /**
  * @typedef {object} EventEmitterLike
- * @property {(event: string, listener: (...args: Array<?>) => void) => void} on Registers a listener.
- * @property {(event: string, listener: (...args: Array<?>) => void) => void} off Removes a listener.
+ * @property {(event: string, listener: (...args: Array<ReturnType<typeof JSON.parse>>) => void) => void} on Registers a listener.
+ * @property {(event: string, listener: (...args: Array<ReturnType<typeof JSON.parse>>) => void) => void} off Removes a listener.
  */
 /**
  * Resolves the moment `eventName` fires on `emitter` — optionally only when `filter`
@@ -21,7 +21,7 @@
  * @param {EventEmitterLike} emitter - Event emitter exposing `on`/`off` (Node EventEmitter, eventemitter3, velocious `testEvents`, ...).
  * @param {string} eventName - The event to wait for.
  * @param {WaitForEventOptions} [options] - Options.
- * @returns {Promise<?>} - Resolves with the single emitted argument, an array when the event emits multiple, or undefined when it emits none.
+ * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the single emitted argument, an array when the event emits multiple, or undefined when it emits none.
  */
 export default function waitForEvent(emitter, eventName, options = {}) {
     const { timeoutMs = 5000, filter } = options;
@@ -32,7 +32,7 @@ export default function waitForEvent(emitter, eventName, options = {}) {
          * Resolves the wait when a matching event fires, removing itself first. A filter
          * that throws (e.g. it assumes an event shape an intermediate emission doesn't
          * have) rejects immediately rather than leaving the waiter pending until timeout.
-         * @param {...?} args - Emitted arguments.
+         * @param {...ReturnType<typeof JSON.parse>} args - Emitted arguments.
          * @returns {void}
          */
         const listener = (...args) => {
@@ -61,4 +61,4 @@ export default function waitForEvent(emitter, eventName, options = {}) {
         emitter.on(eventName, listener);
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/time-zone.d.ts

@@ -1,16 +1,16 @@
+export declare const REQUEST_TIME_ZONE_HEADER = "X-Velocious-Time-Zone";
 /**
  * Validates a configured or client-provided IANA timezone.
  * @param {string} timeZone - Timezone identifier.
  * @param {string} label - Error label.
  * @returns {string} - Normalized timezone identifier.
  */
-export function validateTimeZone(timeZone: string, label?: string): string;
+export declare function validateTimeZone(timeZone: string, label?: string): string;
 /**
  * Formats a Date as an ISO timestamp in the given timezone.
  * @param {Date} value - Date instant.
  * @param {string} timeZone - IANA timezone identifier.
  * @returns {string} - ISO timestamp carrying the timezone's offset for the instant.
  */
-export function formatDateInTimeZone(value: Date, timeZone: string): string;
-export const REQUEST_TIME_ZONE_HEADER: "X-Velocious-Time-Zone";
+export declare function formatDateInTimeZone(value: Date, timeZone: string): string;
 //# sourceMappingURL=time-zone.d.ts.map

package/build/src/time-zone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-zone.d.ts","sourceRoot":"","sources":["../../src/time-zone.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,2CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAmClB;AAED;;;;;GAKG;AACH,4CAJW,IAAI,YACJ,MAAM,GACJ,MAAM,CAWlB;AA5DD,uCAAwC,uBAAuB,CAAA"}
+{"version":3,"file":"time-zone.d.ts","sourceRoot":"","sources":["../../src/time-zone.js"],"names":[],"mappings":"AAIA,eAAO,MAAM,wBAAwB,0BAA0B,CAAA;AAI/D;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAJ9B,MAI8B,EAAE,KAAK,GAHrC,MAGkD,GAFhD,MAAM,CAmClB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAJ/B,IAI+B,EAAE,QAAQ,EAHzC,MAGyC,GAFvC,MAAM,CAWlB"}