qunitx 1.1.4 → 1.1.5

package/dist/deno/index.d.ts

@@ -0,0 +1,156 @@
+/**
+ * QUnitX — universal test library that runs the same test file in Node.js, Deno, and browser.
+ *
+ * Wraps QUnit's assertion API over each runtime's native BDD test runner so you only
+ * write your tests once.
+ *
+ * @example
+ * ```js
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", (hooks) => {
+ *   hooks.before((assert) => assert.step("setup"));
+ *
+ *   test("addition", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ *
+ *   test("async", async (assert) => {
+ *     const n = await Promise.resolve(42);
+ *     assert.strictEqual(n, 42);
+ *   });
+ * });
+ * ```
+ *
+ * @module
+ */
+import { AssertionError as DenoAssertionError } from "jsr:@std/assert";
+import type { AssertionErrorOptions } from "../types.d.ts";
+import '../../vendor/qunit.js';
+import Assert from '../shared/assert.d.ts';
+import Module from './module.d.ts';
+import Test from './test.d.ts';
+/**
+ * Thrown when an assertion fails. Extends Deno's built-in `AssertionError`
+ * so it integrates cleanly with Deno's test runner output.
+ *
+ * You rarely construct this directly — assertion methods on {@linkcode Assert}
+ * throw it automatically on failure.
+ *
+ * @example
+ * ```js
+ * import { AssertionError } from "qunitx";
+ *
+ * try {
+ *   throw new AssertionError({ message: "something went wrong" });
+ * } catch (e) {
+ *   console.log(e instanceof AssertionError); // true
+ * }
+ * ```
+ */
+export declare class AssertionError extends DenoAssertionError {
+    constructor(object: AssertionErrorOptions);
+}
+export { Assert };
+/**
+ * Defines a test module (suite). Wraps Deno's `describe()` and sets up the
+ * QUnit lifecycle — `before`, `beforeEach`, `afterEach`, and `after` hooks,
+ * assertion counting, and step tracking.
+ *
+ * Each {@linkcode test} inside the callback receives an {@linkcode Assert} instance.
+ * Modules can be nested by calling `module()` inside another module's callback.
+ *
+ * @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.
+ *   Receives `(hooks, { moduleName, options })` where `hooks` exposes
+ *   `before`, `beforeEach`, `afterEach`, and `after`.
+ * @example
+ * ```js
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", (hooks) => {
+ *   hooks.before((assert) => {
+ *     assert.step("before hook ran");
+ *   });
+ *
+ *   test("addition", (assert) => {
+ *     assert.equal(2 + 2, 4);
+ *   });
+ * });
+ * ```
+ * @example
+ * ```js
+ * // Nested modules
+ * module("Outer", () => {
+ *   module("Inner", () => {
+ *     test("nested test", (assert) => {
+ *       assert.ok(true);
+ *     });
+ *   });
+ * });
+ * ```
+ */
+export declare const module: typeof Module;
+/**
+ * Defines an individual test. Wraps Deno's `it()` and handles the full QUnit
+ * lifecycle: `beforeEach`/`afterEach` hooks, async assertion waiting, and step
+ * verification. Must be called inside a {@linkcode module} callback.
+ *
+ * The test callback receives `(assert, { testName, options })` where `assert`
+ * is an {@linkcode Assert} instance.
+ *
+ * @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 })`.
+ * @example
+ * ```js
+ * 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 declare const test: typeof Test;
+/**
+ * The default export provides the full QUnitX API as a single object.
+ *
+ * @example
+ * ```js
+ * import qunitx from "qunitx";
+ *
+ * qunitx.module("Math", () => {
+ *   qunitx.test("addition", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ * });
+ * ```
+ *
+ * @property {Function} module - Defines a test suite. Wraps Deno's `describe()` with
+ *   QUnit lifecycle hooks (`before`, `beforeEach`, `afterEach`, `after`).
+ *   See the named {@linkcode module} export for full parameter documentation.
+ * @property {Function} test - Defines an individual test inside a `module()` callback.
+ *   Receives an {@linkcode Assert} instance as its first argument.
+ *   See the named {@linkcode test} export for full parameter documentation.
+ * @property {typeof AssertionError} AssertionError - The error class thrown when an
+ *   assertion fails. Extends Deno's built-in `AssertionError`.
+ * @property {object} config - Runtime configuration object (currently unused; reserved
+ *   for future QUnit config compatibility).
+ */
+declare const _default: {
+    AssertionError: import("../types.d.ts").AssertionErrorConstructor;
+    module: typeof Module;
+    test: typeof Test;
+    config: {};
+};
+export default _default;

package/dist/deno/index.js

@@ -0,0 +1,161 @@
+/**
+ * QUnitX — universal test library that runs the same test file in Node.js, Deno, and browser.
+ *
+ * Wraps QUnit's assertion API over each runtime's native BDD test runner so you only
+ * write your tests once.
+ *
+ * @example
+ * ```js
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", (hooks) => {
+ *   hooks.before((assert) => assert.step("setup"));
+ *
+ *   test("addition", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ *
+ *   test("async", async (assert) => {
+ *     const n = await Promise.resolve(42);
+ *     assert.strictEqual(n, 42);
+ *   });
+ * });
+ * ```
+ *
+ * @module
+ */
+import { AssertionError as DenoAssertionError } from "jsr:@std/assert";
+import '../../vendor/qunit.js';
+import Assert from "../shared/assert.js";
+import ModuleContext from "../shared/module-context.js";
+import TestContext from "../shared/test-context.js";
+import Module from "./module.js";
+import Test from "./test.js";
+/**
+ * Thrown when an assertion fails. Extends Deno's built-in `AssertionError`
+ * so it integrates cleanly with Deno's test runner output.
+ *
+ * You rarely construct this directly — assertion methods on {@linkcode Assert}
+ * throw it automatically on failure.
+ *
+ * @example
+ * ```js
+ * import { AssertionError } from "qunitx";
+ *
+ * try {
+ *   throw new AssertionError({ message: "something went wrong" });
+ * } catch (e) {
+ *   console.log(e instanceof AssertionError); // true
+ * }
+ * ```
+ */
+export class AssertionError extends DenoAssertionError {
+    constructor(object) {
+        super(object.message ?? 'Assertion failed');
+    }
+}
+Assert.QUnit = globalThis.QUnit;
+Assert.AssertionError = AssertionError;
+Assert.inspect = Deno.inspect;
+ModuleContext.Assert = Assert;
+TestContext.Assert = Assert;
+Object.freeze(Assert);
+Object.freeze(ModuleContext);
+Object.freeze(TestContext);
+export { Assert };
+/**
+ * Defines a test module (suite). Wraps Deno's `describe()` and sets up the
+ * QUnit lifecycle — `before`, `beforeEach`, `afterEach`, and `after` hooks,
+ * assertion counting, and step tracking.
+ *
+ * Each {@linkcode test} inside the callback receives an {@linkcode Assert} instance.
+ * Modules can be nested by calling `module()` inside another module's callback.
+ *
+ * @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.
+ *   Receives `(hooks, { moduleName, options })` where `hooks` exposes
+ *   `before`, `beforeEach`, `afterEach`, and `after`.
+ * @example
+ * ```js
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", (hooks) => {
+ *   hooks.before((assert) => {
+ *     assert.step("before hook ran");
+ *   });
+ *
+ *   test("addition", (assert) => {
+ *     assert.equal(2 + 2, 4);
+ *   });
+ * });
+ * ```
+ * @example
+ * ```js
+ * // Nested modules
+ * module("Outer", () => {
+ *   module("Inner", () => {
+ *     test("nested test", (assert) => {
+ *       assert.ok(true);
+ *     });
+ *   });
+ * });
+ * ```
+ */
+export const module = Module;
+/**
+ * Defines an individual test. Wraps Deno's `it()` and handles the full QUnit
+ * lifecycle: `beforeEach`/`afterEach` hooks, async assertion waiting, and step
+ * verification. Must be called inside a {@linkcode module} callback.
+ *
+ * The test callback receives `(assert, { testName, options })` where `assert`
+ * is an {@linkcode Assert} instance.
+ *
+ * @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 })`.
+ * @example
+ * ```js
+ * 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 const test = Test;
+/**
+ * The default export provides the full QUnitX API as a single object.
+ *
+ * @example
+ * ```js
+ * import qunitx from "qunitx";
+ *
+ * qunitx.module("Math", () => {
+ *   qunitx.test("addition", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ * });
+ * ```
+ *
+ * @property {Function} module - Defines a test suite. Wraps Deno's `describe()` with
+ *   QUnit lifecycle hooks (`before`, `beforeEach`, `afterEach`, `after`).
+ *   See the named {@linkcode module} export for full parameter documentation.
+ * @property {Function} test - Defines an individual test inside a `module()` callback.
+ *   Receives an {@linkcode Assert} instance as its first argument.
+ *   See the named {@linkcode test} export for full parameter documentation.
+ * @property {typeof AssertionError} AssertionError - The error class thrown when an
+ *   assertion fails. Extends Deno's built-in `AssertionError`.
+ * @property {object} config - Runtime configuration object (currently unused; reserved
+ *   for future QUnit config compatibility).
+ */
+export default { AssertionError: Assert.AssertionError, module, test, config: {} };

package/dist/deno/module.d.ts

@@ -0,0 +1,35 @@
+import type Assert from '../shared/assert.d.ts';
+import type { HooksObject } from '../types.d.ts';
+export type { Assert };
+export type { HookFn, HooksObject, PushResultInfo } from '../types.d.ts';
+/**
+ * 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: string, runtimeOptions: object | ((hooks: HooksObject<Assert>) => void), moduleContent?: (hooks: HooksObject<Assert>, meta: {
+    moduleName: string;
+    options: unknown;
+}) => void): void;

package/dist/deno/module.js

@@ -0,0 +1,76 @@
+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();
+    });
+}

package/dist/deno/test.d.ts

@@ -0,0 +1,39 @@
+import type Assert from '../shared/assert.d.ts';
+export type { Assert };
+export type { PushResultInfo } from '../types.d.ts';
+/**
+ * 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: string, runtimeOptions: object | ((assert: Assert, meta: {
+    testName: string;
+    options: unknown;
+}) => void | Promise<void>), testContent?: (assert: Assert, meta: {
+    testName: string;
+    options: unknown;
+}) => void | Promise<void>): void;

package/dist/deno/test.js

@@ -0,0 +1,62 @@
+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.`);
+    }
+    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;
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -49,7 +49,7 @@
   "imports": {
     "qunitx": {
       "types": "./dist/node/index.d.ts",
-      "deno": "./shims/deno/index.ts",
+      "deno": "./dist/deno/index.js",
       "node": "./dist/node/index.js",
       "default": "./dist/browser/index.js"
     }
@@ -57,7 +57,7 @@
   "exports": {
     ".": {
       "types": "./dist/node/index.d.ts",
-      "deno": "./shims/deno/index.ts",
+      "deno": "./dist/deno/index.js",
       "node": "./dist/node/index.js",
       "default": "./dist/browser/index.js"
     },

package/shims/deno/vendor-types/globals.d.ts

@@ -0,0 +1,8 @@
+// Minimal Deno global declarations needed to compile shims/deno/ with tsc.
+// The actual Deno runtime provides these at runtime.
+declare namespace Deno {
+  function inspect(
+    value: unknown,
+    options?: { depth?: number; colors?: boolean; compact?: number | boolean },
+  ): string;
+}

package/shims/deno/vendor-types/jsr-std-assert.d.ts

@@ -0,0 +1,7 @@
+// Type stub for jsr:@std/assert. Deno resolves the real module at runtime.
+declare module 'jsr:@std/assert' {
+  class AssertionError extends Error {
+    constructor(message?: string);
+  }
+  export { AssertionError };
+}

package/shims/deno/vendor-types/jsr-std-testing-bdd.d.ts

@@ -0,0 +1,9 @@
+// Type stub for jsr:@std/testing/bdd. Deno resolves the real module at runtime.
+declare module 'jsr:@std/testing/bdd' {
+  function describe(name: string, fn: () => void): void;
+  function describe(name: string, options: object, fn: () => void): void;
+  function it(name: string, options: object, fn: () => void | Promise<void>): void;
+  function beforeAll(fn: () => void | Promise<void>): void;
+  function afterAll(fn: () => void | Promise<void>): void;
+  export { describe, it, beforeAll, afterAll };
+}