velocious 1.0.431 → 1.0.433

package/build/src/testing/test.js

@@ -1,112 +1,96 @@
 // @ts-check
-
-import path from "path"
-import {fileURLToPath} from "url"
-import EventEmitter from "../utils/event-emitter.js"
-import Expect from "./expect.js"
-import {arrayContaining, objectContaining} from "./expect-utils.js"
-
+import path from "path";
+import { fileURLToPath } from "url";
+import EventEmitter from "../utils/event-emitter.js";
+import Expect from "./expect.js";
+import { arrayContaining, objectContaining } from "./expect-utils.js";
 /**
  * Tests.
   @type {import("./test-runner.js").TestsArgument} */
 const tests = {
-  /**
-   * Narrows the runtime value to the documented type.
-    @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
-  afterEaches: [],
-  /**
-   * Narrows the runtime value to the documented type.
-    @type {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} */
-  afterAlls: [],
-  args: {},
-
-  /**
-   * Narrows the runtime value to the documented type.
-    @type {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} */
-  beforeAlls: [],
-  /**
-   * Narrows the runtime value to the documented type.
-    @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
-  beforeEaches: [],
-  filePath: undefined,
-  line: undefined,
-  subs: {},
-  tests: {}
-}
-
-const testEvents = new EventEmitter()
-
-let currentPath = [tests]
-
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
+    afterEaches: [],
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} */
+    afterAlls: [],
+    args: {},
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} */
+    beforeAlls: [],
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
+    beforeEaches: [],
+    filePath: undefined,
+    line: undefined,
+    subs: {},
+    tests: {}
+};
+const testEvents = new EventEmitter();
+let currentPath = [tests];
 /**
  * Runs capture location.
  * @returns {{filePath?: string, line?: number}} - Location.
  */
 function captureLocation() {
-  const error = new Error()
-  const stack = typeof error.stack === "string" ? error.stack.split("\n") : []
-
-  for (const line of stack) {
-    const trimmed = line.trim()
-
-    if (!trimmed.includes("at")) continue
-    if (trimmed.includes("/src/testing/test.js")) continue
-
-    const match = trimmed.match(/(?:\(|\s)(file:\/\/.*?|\/.*?):(\d+):(\d+)\)?$/)
-
-    if (!match) continue
-
-    const rawPath = match[1]
-    const lineNumber = Number(match[2])
-    const filePath = rawPath.startsWith("file://")
-      ? fileURLToPath(rawPath)
-      : rawPath
-
-    return {
-      filePath: path.resolve(filePath),
-      line: Number.isFinite(lineNumber) ? lineNumber : undefined
+    const error = new Error();
+    const stack = typeof error.stack === "string" ? error.stack.split("\n") : [];
+    for (const line of stack) {
+        const trimmed = line.trim();
+        if (!trimmed.includes("at"))
+            continue;
+        if (trimmed.includes("/src/testing/test.js"))
+            continue;
+        const match = trimmed.match(/(?:\(|\s)(file:\/\/.*?|\/.*?):(\d+):(\d+)\)?$/);
+        if (!match)
+            continue;
+        const rawPath = match[1];
+        const lineNumber = Number(match[2]);
+        const filePath = rawPath.startsWith("file://")
+            ? fileURLToPath(rawPath)
+            : rawPath;
+        return {
+            filePath: path.resolve(filePath),
+            line: Number.isFinite(lineNumber) ? lineNumber : undefined
+        };
     }
-  }
-
-  return {}
+    return {};
 }
-
 /**
  * Runs normalize tags.
  * @param {string[] | string | undefined} tags - Tags.
  * @returns {string[]} - Normalized tags.
  */
 function normalizeTags(tags) {
-  if (!tags) return []
-
-  const values = []
-  const rawTags = Array.isArray(tags) ? tags : [tags]
-
-  for (const rawTag of rawTags) {
-    if (rawTag === undefined || rawTag === null) continue
-
-    const parts = String(rawTag).split(",")
-
-    for (const part of parts) {
-      const trimmed = part.trim()
-
-      if (trimmed) values.push(trimmed)
+    if (!tags)
+        return [];
+    const values = [];
+    const rawTags = Array.isArray(tags) ? tags : [tags];
+    for (const rawTag of rawTags) {
+        if (rawTag === undefined || rawTag === null)
+            continue;
+        const parts = String(rawTag).split(",");
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (trimmed)
+                values.push(trimmed);
+        }
     }
-  }
-
-  return Array.from(new Set(values))
+    return Array.from(new Set(values));
 }
-
 /**
  * Test config.
   @type {VelociousTestConfig} */
 const testConfig = {
-  consoleOutput: "failure",
-  failedConsoleOutputMaxLines: 200,
-  excludeTags: [],
-  defaultTimeoutSeconds: 60
-}
-
+    consoleOutput: "failure",
+    failedConsoleOutputMaxLines: 200,
+    excludeTags: [],
+    defaultTimeoutSeconds: 60
+};
 /**
  * Runs configure tests.
  * @param {object} args - Options.
@@ -116,28 +100,23 @@ const testConfig = {
  * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.
  * @returns {void}
  */
-function configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines} = {}) {
-  if (excludeTags !== undefined) {
-    testConfig.excludeTags = normalizeTags(excludeTags)
-  }
-
-  if (consoleOutput !== undefined) {
-    if (consoleOutput !== "failure" && consoleOutput !== "live") {
-      throw new Error(`Invalid consoleOutput config: ${consoleOutput}`)
+function configureTests({ consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines } = {}) {
+    if (excludeTags !== undefined) {
+        testConfig.excludeTags = normalizeTags(excludeTags);
+    }
+    if (consoleOutput !== undefined) {
+        if (consoleOutput !== "failure" && consoleOutput !== "live") {
+            throw new Error(`Invalid consoleOutput config: ${consoleOutput}`);
+        }
+        testConfig.consoleOutput = consoleOutput;
+    }
+    if (typeof defaultTimeoutSeconds === "number") {
+        testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds;
+    }
+    if (typeof failedConsoleOutputMaxLines === "number") {
+        testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines;
     }
-
-    testConfig.consoleOutput = consoleOutput
-  }
-
-  if (typeof defaultTimeoutSeconds === "number") {
-    testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds
-  }
-
-  if (typeof failedConsoleOutputMaxLines === "number") {
-    testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines
-  }
 }
-
 /**
  * Runs merge test args.
  * @param {Record<string, ?>} baseArgs - Base args.
@@ -145,63 +124,52 @@ function configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, fail
  * @returns {Record<string, ?>} - Merged args.
  */
 function mergeTestArgs(baseArgs, extraArgs) {
-  const merged = Object.assign({}, baseArgs, extraArgs)
-  const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)]
-
-  if (mergedTags.length > 0) {
-    merged.tags = Array.from(new Set(mergedTags))
-  } else if ("tags" in merged) {
-    delete merged.tags
-  }
-
-  return merged
+    const merged = Object.assign({}, baseArgs, extraArgs);
+    const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)];
+    if (mergedTags.length > 0) {
+        merged.tags = Array.from(new Set(mergedTags));
+    }
+    else if ("tags" in merged) {
+        delete merged.tags;
+    }
+    return merged;
 }
-
 /**
  * Runs before each.
  * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback - Callback function.
  * @returns {void} - No return value.
  */
 function beforeEach(callback) {
-  const currentTest = currentPath[currentPath.length - 1]
-
-  currentTest.beforeEaches.push({callback})
+    const currentTest = currentPath[currentPath.length - 1];
+    currentTest.beforeEaches.push({ callback });
 }
-
 /**
  * Runs before all.
  * @param {import("./test-runner.js").BeforeAfterAllCallbackType} callback - Callback function.
  * @returns {void} - No return value.
  */
 function beforeAll(callback) {
-  const currentTest = currentPath[currentPath.length - 1]
-
-  currentTest.beforeAlls.push({callback})
+    const currentTest = currentPath[currentPath.length - 1];
+    currentTest.beforeAlls.push({ callback });
 }
-
 /**
  * Runs after each.
  * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback - Callback function.
  * @returns {void} - No return value.
  */
 function afterEach(callback) {
-  const currentTest = currentPath[currentPath.length - 1]
-
-  currentTest.afterEaches.push({callback})
+    const currentTest = currentPath[currentPath.length - 1];
+    currentTest.afterEaches.push({ callback });
 }
-
 /**
  * Runs after all.
  * @param {import("./test-runner.js").BeforeAfterAllCallbackType} callback - Callback function.
  * @returns {void} - No return value.
  */
 function afterAll(callback) {
-  const currentTest = currentPath[currentPath.length - 1]
-
-  currentTest.afterAlls.push({callback})
+    const currentTest = currentPath[currentPath.length - 1];
+    currentTest.afterAlls.push({ callback });
 }
-
-
 /**
  * Runs describe.
  * @param {string} description - Description.
@@ -210,63 +178,57 @@ function afterAll(callback) {
  * @returns {Promise<void>} - Resolves when complete.
  */
 async function describe(description, arg1, arg2) {
-  /**
-   * Defines testArgs.
-    @type {Record<string, ?>} */
-  let testArgs, testFunction
-
-  if (typeof arg2 == "function") {
-    testFunction = arg2
-    testArgs = arg1
-  } else if (typeof arg1 == "function") {
-    testFunction = arg1
-    testArgs = {}
-  } else {
-    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)
-  }
-
-  const currentTest = currentPath[currentPath.length - 1]
-  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)
-
-  if (description in currentTest.subs) {
-    throw new Error(`Duplicate test description: ${description}`)
-  }
-
-  const location = captureLocation()
-  const newTestData = {
-    afterEaches: [],
-    afterAlls: [],
-    args: newTestArgs,
-    beforeAlls: [],
-    beforeEaches: [],
-    filePath: location.filePath,
-    line: location.line,
-    subs: {},
-    tests: {}
-  }
-
-  currentTest.subs[description] = newTestData
-  currentPath.push(newTestData)
-
-  try {
-    await testFunction()
-  } finally {
-    currentPath.pop()
-  }
+    /**
+     * Defines testArgs.
+      @type {Record<string, ?>} */
+    let testArgs, testFunction;
+    if (typeof arg2 == "function") {
+        testFunction = arg2;
+        testArgs = arg1;
+    }
+    else if (typeof arg1 == "function") {
+        testFunction = arg1;
+        testArgs = {};
+    }
+    else {
+        throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`);
+    }
+    const currentTest = currentPath[currentPath.length - 1];
+    const newTestArgs = mergeTestArgs(currentTest.args, testArgs);
+    if (description in currentTest.subs) {
+        throw new Error(`Duplicate test description: ${description}`);
+    }
+    const location = captureLocation();
+    const newTestData = {
+        afterEaches: [],
+        afterAlls: [],
+        args: newTestArgs,
+        beforeAlls: [],
+        beforeEaches: [],
+        filePath: location.filePath,
+        line: location.line,
+        subs: {},
+        tests: {}
+    };
+    currentTest.subs[description] = newTestData;
+    currentPath.push(newTestData);
+    try {
+        await testFunction();
+    }
+    finally {
+        currentPath.pop();
+    }
 }
-
 /**
  * Runs expect.
  * @param {?} arg - Arg.
  * @returns {Expect} - The expect.
  */
 function expect(arg) {
-  return new Expect(arg)
+    return new Expect(arg);
 }
-
-expect.objectContaining = objectContaining
-expect.arrayContaining = arrayContaining
-
+expect.objectContaining = objectContaining;
+expect.arrayContaining = arrayContaining;
 /**
  * Runs it.
  * @param {string} description - Description.
@@ -275,43 +237,41 @@ expect.arrayContaining = arrayContaining
  * @returns {void} - No return value.
  */
 function it(description, arg1, arg2) {
-  const currentTest = currentPath[currentPath.length - 1]
-  /**
-   * Defines testArgs.
-    @type {Record<string, ?>} */
-  let testArgs
-
-  /**
-   * Defines testFunction.
-    @type {() => (void|Promise<void>)} */
-  let testFunction
-
-  if (typeof arg1 == "function") {
-    testFunction = /**
-                    * Narrows the runtime value to the documented type.
-                     @type {() => (void|Promise<void>)} */ (arg1)
-    testArgs = {}
-  } else if (typeof arg2 == "function") {
-    testFunction = /**
-                    * Narrows the runtime value to the documented type.
-                     @type {() => (void|Promise<void>)} */ (arg2)
-    testArgs = arg1
-  } else {
-    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)
-  }
-
-  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)
-
-  const location = captureLocation()
-
-  currentTest.tests[description] = {
-    args: newTestArgs,
-    function: testFunction,
-    filePath: location.filePath,
-    line: location.line
-  }
+    const currentTest = currentPath[currentPath.length - 1];
+    /**
+     * Defines testArgs.
+      @type {Record<string, ?>} */
+    let testArgs;
+    /**
+     * Defines testFunction.
+      @type {() => (void|Promise<void>)} */
+    let testFunction;
+    if (typeof arg1 == "function") {
+        testFunction = /**
+                        * Narrows the runtime value to the documented type.
+                         @type {() => (void|Promise<void>)} */
+            (arg1);
+        testArgs = {};
+    }
+    else if (typeof arg2 == "function") {
+        testFunction = /**
+                        * Narrows the runtime value to the documented type.
+                         @type {() => (void|Promise<void>)} */
+            (arg2);
+        testArgs = arg1;
+    }
+    else {
+        throw new Error(`Invalid arguments for it: ${description}, ${arg1}`);
+    }
+    const newTestArgs = mergeTestArgs(currentTest.args, testArgs);
+    const location = captureLocation();
+    currentTest.tests[description] = {
+        args: newTestArgs,
+        function: testFunction,
+        filePath: location.filePath,
+        line: location.line
+    };
 }
-
 /**
  * Runs fit.
  * @param {string} description - Description.
@@ -320,46 +280,45 @@ function it(description, arg1, arg2) {
  * @returns {void} - No return value.
  */
 function fit(description, arg1, arg2) {
-  /**
-   * Defines testArgs.
-    @type {Record<string, ?>} */
-  let testArgs
-
-  /**
-   * Defines testFunction.
-    @type {() => (void|Promise<void>)} */
-  let testFunction
-
-  if (typeof arg1 == "function") {
-    testFunction = /**
-                    * Narrows the runtime value to the documented type.
-                     @type {() => (void|Promise<void>)} */ (arg1)
-    testArgs = {focus: true}
-  } else if (typeof arg2 == "function") {
-    testFunction = /**
-                    * Narrows the runtime value to the documented type.
-                     @type {() => (void|Promise<void>)} */ (arg2)
-    testArgs = Object.assign({focus: true}, arg1)
-  } else {
-    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)
-  }
-
-  return it(description, testArgs, testFunction)
+    /**
+     * Defines testArgs.
+      @type {Record<string, ?>} */
+    let testArgs;
+    /**
+     * Defines testFunction.
+      @type {() => (void|Promise<void>)} */
+    let testFunction;
+    if (typeof arg1 == "function") {
+        testFunction = /**
+                        * Narrows the runtime value to the documented type.
+                         @type {() => (void|Promise<void>)} */
+            (arg1);
+        testArgs = { focus: true };
+    }
+    else if (typeof arg2 == "function") {
+        testFunction = /**
+                        * Narrows the runtime value to the documented type.
+                         @type {() => (void|Promise<void>)} */
+            (arg2);
+        testArgs = Object.assign({ focus: true }, arg1);
+    }
+    else {
+        throw new Error(`Invalid arguments for it: ${description}, ${arg1}`);
+    }
+    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
-
-export {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests}
+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;
+export { afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests };
 /**
  * VelociousTestConfig type.
  * @typedef {object} VelociousTestConfig
@@ -368,3 +327,4 @@ export {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, ex
  * @property {number} defaultTimeoutSeconds - Default timeout in seconds.
  * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.
  */
+//# 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 {arrayContaining, objectContaining} from \"./expect-utils.js\"\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/**\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 = /**\n                    * Narrows the runtime value to the documented type.\n                     @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /**\n                    * Narrows the runtime value to the documented type.\n                     @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 = /**\n                    * Narrows the runtime value to the documented type.\n                     @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {focus: true}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /**\n                    * Narrows the runtime value to the documented type.\n                     @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}\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"]}