qunitx 1.1.5 → 1.2.0

package/dist/deno/module.d.ts

@@ -29,7 +29,12 @@ export type { HookFn, HooksObject, PushResultInfo } from '../types.d.ts';
  * });
  * ```
  */
-export default function module(moduleName: string, runtimeOptions: object | ((hooks: HooksObject<Assert>) => void), moduleContent?: (hooks: HooksObject<Assert>, meta: {
+export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: {
+    moduleName: string;
+    options: unknown;
+}) => void): void;
+/** Defines a test module (suite) with optional Deno BDD runtime options forwarded to `describe()`. */
+export default function module(moduleName: string, runtimeOptions: object, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
 }) => void): void;

package/dist/deno/module.js

@@ -1,76 +1,50 @@
 import { describe, beforeAll, afterAll } from "jsr:@std/testing/bdd";
 import ModuleContext from "../shared/module-context.js";
-/**
- * Defines a test module (suite) for Deno's BDD test runner.
- *
- * Wraps `describe()` from `@std/testing/bdd` and sets up the QUnit lifecycle
- * (before/beforeEach/afterEach/after hooks, assertion counting, steps tracking).
- *
- * @param {string} moduleName - Name of the test suite
- * @param {object} [runtimeOptions] - Optional Deno BDD options forwarded to `describe()`
- *   (e.g. `{ concurrency: false }`, `{ permissions: { read: true } }`)
- * @param {function} moduleContent - Callback that defines tests and hooks via `hooks.before`,
- *   `hooks.beforeEach`, `hooks.afterEach`, `hooks.after`
- * @returns {void}
- * @example
- * ```js ignore
- * import { module, test } from "qunitx";
- *
- * module("Math", (hooks) => {
- *   hooks.before((assert) => {
- *     assert.step("before hook ran");
- *   });
- *
- *   test("addition", (assert) => {
- *     assert.equal(2 + 2, 4);
- *   });
- * });
- * ```
- */
-export default function module(moduleName, runtimeOptions, moduleContent) {
-    const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
-    const targetModuleContent = (moduleContent ? moduleContent : runtimeOptions);
-    const moduleContext = new ModuleContext(moduleName);
-    describe(moduleName, { ...targetRuntimeOptions }, function () {
-        const beforeHooks = [];
-        const afterHooks = [];
-        beforeAll(async function () {
-            // before() assertions are attributed to the first direct test only (matching QUnit's model).
-            // Tests inherit parent context via prototype chain, so no Object.assign needed.
-            const firstTest = moduleContext.tests[0];
-            const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
-            for (const hook of beforeHooks) {
-                await hook.call(moduleContext.userContext, beforeAssert);
-            }
-        });
-        afterAll(async () => {
-            for (const testContext of moduleContext.tests) {
-                await testContext.assert.waitForAsyncOps();
-            }
-            const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
-            if (lastTest) {
-                for (let j = afterHooks.length - 1; j >= 0; j--) {
-                    await afterHooks[j].call(lastTest.userContext, lastTest.assert);
-                }
-            }
-            for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
-                moduleContext.tests[i].finish();
-            }
-        });
-        targetModuleContent.call(moduleContext.userContext, {
-            before(beforeFn) {
-                beforeHooks.push(beforeFn);
-            },
-            beforeEach(beforeEachFn) {
-                moduleContext.beforeEachHooks.push(beforeEachFn);
-            },
-            afterEach(afterEachFn) {
-                moduleContext.afterEachHooks.push(afterEachFn);
-            },
-            after(afterFn) {
-                afterHooks.push(afterFn);
-            }
-        }, { moduleName, options: runtimeOptions });
-        ModuleContext.currentModuleChain.pop();
+function module(moduleName, runtimeOptions, moduleContent) {
+  const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
+  const targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
+  const moduleContext = new ModuleContext(moduleName);
+  describe(moduleName, { ...targetRuntimeOptions }, function() {
+    const beforeHooks = [];
+    const afterHooks = [];
+    beforeAll(async function() {
+      const firstTest = moduleContext.tests[0];
+      const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
+      for (const hook of beforeHooks) {
+        await hook.call(moduleContext.userContext, beforeAssert);
+      }
     });
+    afterAll(async () => {
+      for (const testContext of moduleContext.tests) {
+        await testContext.assert.waitForAsyncOps();
+      }
+      const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
+      if (lastTest) {
+        for (let j = afterHooks.length - 1; j >= 0; j--) {
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert);
+        }
+      }
+      for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
+        moduleContext.tests[i].finish();
+      }
+    });
+    targetModuleContent.call(moduleContext.userContext, {
+      before(beforeFn) {
+        beforeHooks.push(beforeFn);
+      },
+      beforeEach(beforeEachFn) {
+        moduleContext.beforeEachHooks.push(beforeEachFn);
+      },
+      afterEach(afterEachFn) {
+        moduleContext.afterEachHooks.push(afterEachFn);
+      },
+      after(afterFn) {
+        afterHooks.push(afterFn);
+      }
+    }, { moduleName, options: runtimeOptions });
+    ModuleContext.currentModuleChain.pop();
+  });
 }
+export {
+  module as default
+};

package/dist/deno/test.d.ts

@@ -30,10 +30,12 @@ export type { PushResultInfo } from '../types.d.ts';
  * });
  * ```
  */
-export default function test(testName: string, runtimeOptions: object | ((assert: Assert, meta: {
+export default function test(testName: string, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
-}) => void | Promise<void>), testContent?: (assert: Assert, meta: {
+}) => void | Promise<void>): void;
+/** Defines an individual test with optional Deno BDD runtime options forwarded to `it()`. */
+export default function test(testName: string, runtimeOptions: object, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
 }) => void | Promise<void>): void;

package/dist/deno/test.js

@@ -1,62 +1,33 @@
 import { it } from "jsr:@std/testing/bdd";
 import TestContext from "../shared/test-context.js";
 import ModuleContext from "../shared/module-context.js";
-/**
- * Defines an individual test within a module for Deno's BDD test runner.
- *
- * Wraps `it()` from `@std/testing/bdd` and handles the full QUnit lifecycle:
- * beforeEach/afterEach hooks, async assertion waiting, and step verification.
- *
- * Must be called inside a `module()` callback.
- *
- * @param {string} testName - Name of the test
- * @param {object} [runtimeOptions] - Optional Deno BDD options forwarded to `it()`
- *   (e.g. `{ concurrency: false }`, `{ sanitizeExit: false }`)
- * @param {function} testContent - Test callback receiving `(assert, { testName, options })`
- * @returns {void}
- * @example
- * ```js ignore
- * import { module, test } from "qunitx";
- *
- * module("Math", () => {
- *   test("addition", (assert) => {
- *     assert.equal(1 + 1, 2);
- *   });
- *
- *   test("async resolves correctly", async (assert) => {
- *     const result = await Promise.resolve(42);
- *     assert.strictEqual(result, 42);
- *   });
- * });
- * ```
- */
-export default function test(testName, runtimeOptions, testContent) {
-    const moduleContext = ModuleContext.lastModule;
-    if (!moduleContext) {
-        throw new Error(`Test '${testName}' called outside of module context.`);
+function test(testName, runtimeOptions, testContent) {
+  const moduleContext = ModuleContext.lastModule;
+  if (!moduleContext) {
+    throw new Error(`Test '${testName}' called outside of module context.`);
+  }
+  const targetRuntimeOptions = testContent ? runtimeOptions : {};
+  const targetTestContent = testContent ? testContent : runtimeOptions;
+  const context = new TestContext(testName, moduleContext);
+  const userContext = Object.create(moduleContext.userContext);
+  context.userContext = userContext;
+  it(testName, { ...targetRuntimeOptions }, async function() {
+    for (const module of context.module.moduleChain) {
+      for (const hook of module.beforeEachHooks) {
+        await hook.call(userContext, context.assert);
+      }
     }
-    const targetRuntimeOptions = testContent ? runtimeOptions : {};
-    const targetTestContent = (testContent ? testContent : runtimeOptions);
-    const context = new TestContext(testName, moduleContext);
-    // Each test gets a fresh plain object inheriting from the module's user context.
-    // This matches QUnit's prototype-chain model: before() sets props on the module context,
-    // tests inherit them, and each test's own writes don't pollute sibling tests.
-    const userContext = Object.create(moduleContext.userContext);
-    context.userContext = userContext;
-    it(testName, { ...targetRuntimeOptions }, async function () {
-        for (const module of context.module.moduleChain) {
-            for (const hook of module.beforeEachHooks) {
-                await hook.call(userContext, context.assert);
-            }
-        }
-        const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
-        await context.assert.waitForAsyncOps();
-        for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
-            const module = context.module.moduleChain[i];
-            for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-                await module.afterEachHooks[j].call(userContext, context.assert);
-            }
-        }
-        return result;
-    });
+    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
+    await context.assert.waitForAsyncOps();
+    for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
+      const module = context.module.moduleChain[i];
+      for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
+        await module.afterEachHooks[j].call(userContext, context.assert);
+      }
+    }
+    return result;
+  });
 }
+export {
+  test as default
+};

package/dist/node/index.d.ts

@@ -1,8 +1,8 @@
 import Assert from '../shared/assert.d.ts';
 import Module from './module.d.ts';
 import Test from './test.d.ts';
-export declare const module: typeof Module;
-export declare const test: typeof Test;
+export { default as module } from './module.d.ts';
+export { default as test } from './test.d.ts';
 export { Assert };
 declare const _default: {
     AssertionError: import("../types.d.ts").AssertionErrorConstructor;

package/dist/node/index.js

@@ -1,6 +1,6 @@
-import { AssertionError } from 'node:assert';
-import { inspect } from 'node:util';
-import QUnit from '../../vendor/qunit.js';
+import { AssertionError } from "node:assert";
+import { inspect } from "node:util";
+import QUnit from "../../vendor/qunit.js";
 import Assert from "../shared/assert.js";
 import ModuleContext from "../shared/module-context.js";
 import TestContext from "../shared/test-context.js";
@@ -14,7 +14,12 @@ TestContext.Assert = Assert;
 Object.freeze(Assert);
 Object.freeze(ModuleContext);
 Object.freeze(TestContext);
-export const module = Module;
-export const test = Test;
-export { Assert };
-export default { AssertionError: Assert.AssertionError, module, test, config: {} };
+import { default as default2 } from "./module.js";
+import { default as default3 } from "./test.js";
+var node_default = { AssertionError: Assert.AssertionError, module: Module, test: Test, config: {} };
+export {
+  Assert,
+  node_default as default,
+  default2 as module,
+  default3 as test
+};

package/dist/node/module.d.ts

@@ -1,6 +1,10 @@
 import type Assert from '../shared/assert.d.ts';
 import type { HooksObject } from '../types.d.ts';
-export default function module(moduleName: string, runtimeOptions: object | ((hooks: HooksObject<Assert>) => void), moduleContent?: (hooks: HooksObject<Assert>, meta: {
+export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: {
+    moduleName: string;
+    options: unknown;
+}) => void): void;
+export default function module(moduleName: string, runtimeOptions: object, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
 }) => void): void;

package/dist/node/module.js

@@ -1,49 +1,50 @@
-import { describe, before as beforeAll, after as afterAll } from 'node:test';
+import { describe, before as beforeAll, after as afterAll } from "node:test";
 import ModuleContext from "../shared/module-context.js";
-export default function module(moduleName, runtimeOptions, moduleContent) {
-    const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
-    const targetModuleContent = (moduleContent ? moduleContent : runtimeOptions);
-    const moduleContext = new ModuleContext(moduleName);
-    describe(moduleName, { ...targetRuntimeOptions }, function () {
-        const beforeHooks = [];
-        const afterHooks = [];
-        beforeAll(async function () {
-            // before() assertions are attributed to the first direct test only (matching QUnit's model).
-            // Tests inherit parent context via prototype chain, so no Object.assign needed.
-            const firstTest = moduleContext.tests[0];
-            const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
-            for (const hook of beforeHooks) {
-                await hook.call(moduleContext.userContext, beforeAssert);
-            }
-        });
-        afterAll(async () => {
-            for (const testContext of moduleContext.tests) {
-                await testContext.assert.waitForAsyncOps();
-            }
-            const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
-            if (lastTest) {
-                for (let j = afterHooks.length - 1; j >= 0; j--) {
-                    await afterHooks[j].call(lastTest.userContext, lastTest.assert);
-                }
-            }
-            for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
-                moduleContext.tests[i].finish();
-            }
-        });
-        targetModuleContent.call(moduleContext.userContext, {
-            before(beforeFn) {
-                beforeHooks.push(beforeFn);
-            },
-            beforeEach(beforeEachFn) {
-                moduleContext.beforeEachHooks.push(beforeEachFn);
-            },
-            afterEach(afterEachFn) {
-                moduleContext.afterEachHooks.push(afterEachFn);
-            },
-            after(afterFn) {
-                afterHooks.push(afterFn);
-            }
-        }, { moduleName, options: runtimeOptions });
-        ModuleContext.currentModuleChain.pop();
+function module(moduleName, runtimeOptions, moduleContent) {
+  const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
+  const targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
+  const moduleContext = new ModuleContext(moduleName);
+  describe(moduleName, { ...targetRuntimeOptions }, function() {
+    const beforeHooks = [];
+    const afterHooks = [];
+    beforeAll(async function() {
+      const firstTest = moduleContext.tests[0];
+      const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
+      for (const hook of beforeHooks) {
+        await hook.call(moduleContext.userContext, beforeAssert);
+      }
     });
+    afterAll(async () => {
+      for (const testContext of moduleContext.tests) {
+        await testContext.assert.waitForAsyncOps();
+      }
+      const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
+      if (lastTest) {
+        for (let j = afterHooks.length - 1; j >= 0; j--) {
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert);
+        }
+      }
+      for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
+        moduleContext.tests[i].finish();
+      }
+    });
+    targetModuleContent.call(moduleContext.userContext, {
+      before(beforeFn) {
+        beforeHooks.push(beforeFn);
+      },
+      beforeEach(beforeEachFn) {
+        moduleContext.beforeEachHooks.push(beforeEachFn);
+      },
+      afterEach(afterEachFn) {
+        moduleContext.afterEachHooks.push(afterEachFn);
+      },
+      after(afterFn) {
+        afterHooks.push(afterFn);
+      }
+    }, { moduleName, options: runtimeOptions });
+    ModuleContext.currentModuleChain.pop();
+  });
 }
+export {
+  module as default
+};

package/dist/node/test.d.ts

@@ -1,8 +1,9 @@
 import type Assert from '../shared/assert.d.ts';
-export default function test(testName: string, runtimeOptions: object | ((assert: Assert, meta: {
+export default function test(testName: string, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
-}) => void | Promise<void>), testContent?: (assert: Assert, meta: {
+}) => void | Promise<void>): void;
+export default function test(testName: string, runtimeOptions: object, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
 }) => void | Promise<void>): void;

package/dist/node/test.js

@@ -1,33 +1,33 @@
-import { it } from 'node:test';
+import { it } from "node:test";
 import TestContext from "../shared/test-context.js";
 import ModuleContext from "../shared/module-context.js";
-export default function test(testName, runtimeOptions, testContent) {
-    const moduleContext = ModuleContext.lastModule;
-    if (!moduleContext) {
-        throw new Error(`Test '${testName}' called outside of module context.`);
+function test(testName, runtimeOptions, testContent) {
+  const moduleContext = ModuleContext.lastModule;
+  if (!moduleContext) {
+    throw new Error(`Test '${testName}' called outside of module context.`);
+  }
+  const targetRuntimeOptions = testContent ? runtimeOptions : {};
+  const targetTestContent = testContent ? testContent : runtimeOptions;
+  const context = new TestContext(testName, moduleContext);
+  const userContext = Object.create(moduleContext.userContext);
+  context.userContext = userContext;
+  it(testName, { ...targetRuntimeOptions }, async function() {
+    for (const module of context.module.moduleChain) {
+      for (const hook of module.beforeEachHooks) {
+        await hook.call(userContext, context.assert);
+      }
     }
-    const targetRuntimeOptions = testContent ? runtimeOptions : {};
-    const targetTestContent = (testContent ? testContent : runtimeOptions);
-    const context = new TestContext(testName, moduleContext);
-    // Each test gets a fresh plain object inheriting from the module's user context.
-    // This matches QUnit's prototype-chain model: before() sets props on the module context,
-    // tests inherit them, and each test's own writes don't pollute sibling tests.
-    const userContext = Object.create(moduleContext.userContext);
-    context.userContext = userContext;
-    it(testName, { ...targetRuntimeOptions }, async function () {
-        for (const module of context.module.moduleChain) {
-            for (const hook of module.beforeEachHooks) {
-                await hook.call(userContext, context.assert);
-            }
-        }
-        const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
-        await context.assert.waitForAsyncOps();
-        for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
-            const module = context.module.moduleChain[i];
-            for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
-                await module.afterEachHooks[j].call(userContext, context.assert);
-            }
-        }
-        return result;
-    });
+    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
+    await context.assert.waitForAsyncOps();
+    for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
+      const module = context.module.moduleChain[i];
+      for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
+        await module.afterEachHooks[j].call(userContext, context.assert);
+      }
+    }
+    return result;
+  });
 }
+export {
+  test as default
+};