qunitx 1.2.2 → 1.2.5

package/dist/deno/index.js

@@ -1049,13 +1049,13 @@ var require_qunit = __commonJS({
         }, {
           key: "getStatus",
           value: function getStatus() {
-            var _this$getTestCounts = this.getTestCounts(), total = _this$getTestCounts.total, failed = _this$getTestCounts.failed, skipped = _this$getTestCounts.skipped, todo = _this$getTestCounts.todo;
+            var _this$getTestCounts = this.getTestCounts(), total = _this$getTestCounts.total, failed = _this$getTestCounts.failed, skipped = _this$getTestCounts.skipped, todo2 = _this$getTestCounts.todo;
             if (failed) {
               return "failed";
             } else {
               if (skipped === total) {
                 return "skipped";
-              } else if (todo === total) {
+              } else if (todo2 === total) {
                 return "todo";
               } else {
                 return "passed";
@@ -1081,7 +1081,7 @@ var require_qunit = __commonJS({
         var moduleName = parentModule !== null ? [parentModule.name, name].join(" > ") : name;
         var parentSuite = parentModule ? parentModule.suiteReport : runSuite;
         var skip2 = parentModule !== null && parentModule.skip || modifiers.skip;
-        var todo = parentModule !== null && parentModule.todo || modifiers.todo;
+        var todo2 = parentModule !== null && parentModule.todo || modifiers.todo;
         var env = {};
         if (parentModule) {
           extend(env, parentModule.testEnvironment);
@@ -1111,7 +1111,7 @@ var require_qunit = __commonJS({
           // This property will be used to mark own tests and tests of child suites
           // as either `skipped` or `todo`.
           skip: skip2,
-          todo: skip2 ? false : todo,
+          todo: skip2 ? false : todo2,
           ignored: modifiers.ignored || false
         };
         if (parentModule) {
@@ -2373,7 +2373,7 @@ var require_qunit = __commonJS({
           var moduleName = module3.name;
           var testName = this.testName;
           var skipped = !!this.skip;
-          var todo = !!this.todo;
+          var todo2 = !!this.todo;
           var bad = 0;
           var storage = config.storage;
           this.runtime = Math.round(performance.now() - this.started);
@@ -2406,7 +2406,7 @@ var require_qunit = __commonJS({
             name: testName,
             module: moduleName,
             skipped,
-            todo,
+            todo: todo2,
             failed: bad,
             passed: this.assertions.length - bad,
             total: this.assertions.length,
@@ -2866,7 +2866,7 @@ var require_qunit = __commonJS({
         }
       }
       extend(test3, {
-        todo: function todo(testName, callback) {
+        todo: function todo2(testName, callback) {
           addTest({
             testName,
             callback,
@@ -7686,7 +7686,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       const firstTest = moduleContext.tests[0];
       const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.userContext, beforeAssert);
+        await hook.call(moduleContext.userContext, beforeAssert, { context: moduleContext.userContext });
       }
     });
     afterAll(async () => {
@@ -7696,7 +7696,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       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);
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert, { context: lastTest.userContext });
         }
       }
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -7716,7 +7716,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions });
+    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
     ModuleContext.currentModuleChain.pop();
   });
 }
@@ -7732,8 +7732,8 @@ function test2(testName, runtimeOptions, testContent) {
     throw new Error(`Test '${testName}' called outside of module context.`);
   }
   const targetRuntimeOptions = testContent ? runtimeOptions : {};
-  const { skip: skip2 } = targetRuntimeOptions;
-  if (skip2) {
+  const { skip: skip2, todo: todo2 } = targetRuntimeOptions;
+  if (skip2 || todo2) {
     it(testName, { ignore: true }, async function() {
     });
     return;
@@ -7743,17 +7743,18 @@ function test2(testName, runtimeOptions, testContent) {
   const userContext = Object.create(moduleContext.userContext);
   context.userContext = userContext;
   it(testName, { ...targetRuntimeOptions }, async function() {
+    const hookMeta = { context: userContext };
     for (const module2 of context.module.moduleChain) {
       for (const hook of module2.beforeEachHooks) {
-        await hook.call(userContext, context.assert);
+        await hook.call(userContext, context.assert, hookMeta);
       }
     }
-    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions, context: userContext });
     await context.assert.waitForAsyncOps();
     for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
       const module2 = context.module.moduleChain[i];
       for (let j = module2.afterEachHooks.length - 1; j >= 0; j--) {
-        await module2.afterEachHooks[j].call(userContext, context.assert);
+        await module2.afterEachHooks[j].call(userContext, context.assert, hookMeta);
       }
     }
     return result;
@@ -7763,6 +7764,10 @@ test2.skip = function skipTest(testName, _testContent) {
   it(testName, { ignore: true }, async function() {
   });
 };
+test2.todo = function todoTest(testName, _testContent) {
+  it(testName, { ignore: true }, async function() {
+  });
+};
 
 // shims/deno/index.ts
 var AssertionError2 = class extends AssertionError {
@@ -7779,6 +7784,7 @@ Object.freeze(Assert);
 Object.freeze(ModuleContext);
 Object.freeze(TestContext);
 var skip = test2.skip;
+var todo = test2.todo;
 var index_default = { AssertionError: Assert.AssertionError, module, test: test2, config: {} };
 export {
   Assert,
@@ -7786,7 +7792,8 @@ export {
   index_default as default,
   module,
   skip,
-  test2 as test
+  test2 as test,
+  todo
 };
 /*!
  * QUnit 2.25.0

package/dist/deno/module.d.ts

@@ -32,11 +32,13 @@ export type { HookFn, HooksObject, PushResultInfo } from '../types.d.ts';
 export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void): void;
 /** Defines a test module (suite) with optional Deno BDD runtime options forwarded to `describe()`. */
 declare function module(moduleName: string, runtimeOptions: object, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void): void;
 declare namespace module {
     var skip: (moduleName: string, _moduleContent?: unknown) => void;

package/dist/deno/module.js

@@ -17,7 +17,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       const firstTest = moduleContext.tests[0];
       const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.userContext, beforeAssert);
+        await hook.call(moduleContext.userContext, beforeAssert, { context: moduleContext.userContext });
       }
     });
     afterAll(async () => {
@@ -27,7 +27,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       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);
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert, { context: lastTest.userContext });
         }
       }
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -47,7 +47,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions });
+    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
     ModuleContext.currentModuleChain.pop();
   });
 }

package/dist/deno/test.d.ts

@@ -10,8 +10,10 @@ export type { PushResultInfo } from '../types.d.ts';
  * 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 {object} [runtimeOptions] - Optional options forwarded to `it()`.
+ *   Use `{ skip: true | string }` to skip the test, `{ todo: true | string }` to mark it as todo
+ *   (both map to Deno's `{ ignore: true }`). Other Deno BDD options like
+ *   `{ concurrency: false }` or `{ sanitizeExit: false }` are forwarded as-is.
  * @param {function} testContent - Test callback receiving `(assert, { testName, options })`
  * @returns {void}
  * @example
@@ -33,13 +35,16 @@ export type { PushResultInfo } from '../types.d.ts';
 export default function test(testName: string, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<void>): void;
 /** Defines an individual test with optional Deno BDD runtime options forwarded to `it()`. */
 declare function test(testName: string, runtimeOptions: object, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<void>): void;
 declare namespace test {
     var skip: (testName: string, _testContent?: unknown) => void;
+    var todo: (testName: string, _testContent?: unknown) => void;
 }
 export default test;

package/dist/deno/test.js

@@ -7,8 +7,8 @@ function test(testName, runtimeOptions, testContent) {
     throw new Error(`Test '${testName}' called outside of module context.`);
   }
   const targetRuntimeOptions = testContent ? runtimeOptions : {};
-  const { skip } = targetRuntimeOptions;
-  if (skip) {
+  const { skip, todo } = targetRuntimeOptions;
+  if (skip || todo) {
     it(testName, { ignore: true }, async function() {
     });
     return;
@@ -18,17 +18,18 @@ function test(testName, runtimeOptions, testContent) {
   const userContext = Object.create(moduleContext.userContext);
   context.userContext = userContext;
   it(testName, { ...targetRuntimeOptions }, async function() {
+    const hookMeta = { context: userContext };
     for (const module of context.module.moduleChain) {
       for (const hook of module.beforeEachHooks) {
-        await hook.call(userContext, context.assert);
+        await hook.call(userContext, context.assert, hookMeta);
       }
     }
-    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions, context: userContext });
     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);
+        await module.afterEachHooks[j].call(userContext, context.assert, hookMeta);
       }
     }
     return result;
@@ -38,6 +39,10 @@ test.skip = function skipTest(testName, _testContent) {
   it(testName, { ignore: true }, async function() {
   });
 };
+test.todo = function todoTest(testName, _testContent) {
+  it(testName, { ignore: true }, async function() {
+  });
+};
 export {
   test as default
 };

package/dist/node/index.d.ts

@@ -5,6 +5,10 @@ export { default as module } from './module.d.ts';
 export { default as test } from './test.d.ts';
 export { Assert };
 export declare const skip: (testName: string, _testContent?: unknown) => void;
+export declare const todo: (testName: string, testContent?: (assert: Assert, meta: {
+    testName: string;
+    options: unknown;
+}) => void | Promise<void>) => void;
 declare const _default: {
     AssertionError: import("../types.d.ts").AssertionErrorConstructor;
     module: typeof Module;

package/dist/node/index.js

@@ -17,11 +17,13 @@ Object.freeze(TestContext);
 import { default as default2 } from "./module.js";
 import { default as default3 } from "./test.js";
 const skip = Test.skip;
+const todo = Test.todo;
 var node_default = { AssertionError: Assert.AssertionError, module: Module, test: Test, config: {} };
 export {
   Assert,
   node_default as default,
   default2 as module,
   skip,
-  default3 as test
+  default3 as test,
+  todo
 };

package/dist/node/module.d.ts

@@ -1,12 +1,48 @@
 import type Assert from '../shared/assert.d.ts';
 import type { HooksObject } from '../types.d.ts';
+/**
+ * Defines a test module (suite) for Node's built-in test runner.
+ *
+ * Wraps `describe()` from `node:test` 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 Node test runner options forwarded to `describe()`
+ *   (e.g. `{ concurrency: true }`, `{ timeout: 5000 }`). Use `{ skip: true | string }` to skip
+ *   the entire module.
+ * @param {function} moduleContent - Callback that defines tests and hooks via `hooks.before`,
+ *   `hooks.beforeEach`, `hooks.afterEach`, `hooks.after`.
+ *   Receives `(hooks, { moduleName, options, context })`.
+ *   `context` is the shared module environment — the same object as `this` in
+ *   regular-function callbacks, useful when using arrow functions.
+ * @returns {void}
+ * @example
+ * ```js
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", (hooks, { context }) => {
+ *   context.multiplier = 2;
+ *
+ *   hooks.beforeEach((assert, { context }) => {
+ *     context.value = 21;
+ *   });
+ *
+ *   test("multiplication", (assert, { context }) => {
+ *     assert.equal(context.value * context.multiplier, 42);
+ *   });
+ * });
+ * ```
+ */
 export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void): void;
+/** Defines a test module (suite) with optional Node test runner options forwarded to `describe()`. */
 declare function module(moduleName: string, runtimeOptions: object, moduleContent: (hooks: HooksObject<Assert>, meta: {
     moduleName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void): void;
 declare namespace module {
     var skip: (moduleName: string, _moduleContent?: unknown) => void;

package/dist/node/module.js

@@ -17,7 +17,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       const firstTest = moduleContext.tests[0];
       const beforeAssert = firstTest ? firstTest.assert : moduleContext.assert;
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.userContext, beforeAssert);
+        await hook.call(moduleContext.userContext, beforeAssert, { context: moduleContext.userContext });
       }
     });
     afterAll(async () => {
@@ -27,7 +27,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       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);
+          await afterHooks[j].call(lastTest.userContext, lastTest.assert, { context: lastTest.userContext });
         }
       }
       for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
@@ -47,7 +47,7 @@ function module(moduleName, runtimeOptions, moduleContent) {
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions });
+    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
     ModuleContext.currentModuleChain.pop();
   });
 }

package/dist/node/test.d.ts

@@ -1,13 +1,52 @@
 import type Assert from '../shared/assert.d.ts';
+/**
+ * Defines an individual test within a module for Node's built-in test runner.
+ *
+ * Wraps `it()` from `node:test` 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 Node test runner options forwarded to `it()`.
+ *   Use `{ skip: true | string }` to skip the test, `{ todo: true | string }` to mark it as todo.
+ *   Other Node options like `{ concurrency: true }` or `{ timeout: 5000 }` are forwarded as-is.
+ * @param {function} testContent - Test callback receiving `(assert, { testName, options, context })`.
+ *   `context` is the per-test environment — inherits properties set by `before`/`beforeEach` hooks,
+ *   and is the same object as `this` in regular-function callbacks. Useful when using arrow functions.
+ * @returns {void}
+ * @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 default function test(testName: string, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<void>): void;
+/** Defines an individual test with optional Node test runner options forwarded to `it()`. */
 declare function test(testName: string, runtimeOptions: object, testContent: (assert: Assert, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<void>): void;
 declare namespace test {
     var skip: (testName: string, _testContent?: unknown) => void;
+    var todo: (testName: string, testContent?: (assert: Assert, meta: {
+        testName: string;
+        options: unknown;
+    }) => void | Promise<void>) => void;
 }
 export default test;

package/dist/node/test.js

@@ -7,28 +7,30 @@ function test(testName, runtimeOptions, testContent) {
     throw new Error(`Test '${testName}' called outside of module context.`);
   }
   const targetRuntimeOptions = testContent ? runtimeOptions : {};
-  const { skip } = targetRuntimeOptions;
+  const { skip, todo } = targetRuntimeOptions;
   if (skip) {
     it(testName, { skip }, async function() {
     });
     return;
   }
-  const targetTestContent = testContent ? testContent : runtimeOptions;
+  const targetTestContent = testContent ?? runtimeOptions;
   const context = new TestContext(testName, moduleContext);
   const userContext = Object.create(moduleContext.userContext);
   context.userContext = userContext;
+  if (todo) moduleContext.tests.pop();
   it(testName, { ...targetRuntimeOptions }, async function() {
+    const hookMeta = { context: userContext };
     for (const module of context.module.moduleChain) {
       for (const hook of module.beforeEachHooks) {
-        await hook.call(userContext, context.assert);
+        await hook.call(userContext, context.assert, hookMeta);
       }
     }
-    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(userContext, context.assert, { testName, options: runtimeOptions, context: userContext });
     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);
+        await module.afterEachHooks[j].call(userContext, context.assert, hookMeta);
       }
     }
     return result;
@@ -38,6 +40,14 @@ test.skip = function skipTest(testName, _testContent) {
   it(testName, { skip: true }, async function() {
   });
 };
+test.todo = function todoTest(testName, testContent) {
+  if (!testContent) {
+    it(testName, { todo: true }, async function() {
+    });
+    return;
+  }
+  test(testName, { todo: true }, testContent);
+};
 export {
   test as default
 };

package/dist/shared/module-context.d.ts

@@ -7,7 +7,7 @@ export default class ModuleContext {
     static get lastModule(): ModuleContext;
     name: string;
     assert: Assert;
-    userContext: object;
+    userContext: Record<string, unknown>;
     context: TestContext;
     moduleChain: ModuleContext[];
     beforeEachHooks: HookFn<Assert>[];

package/dist/shared/test-context.d.ts

@@ -19,7 +19,7 @@ export default class TestContext {
     set expectedAssertionCount(value: number | undefined);
     get totalExecutedAssertions(): number;
     set totalExecutedAssertions(value: number);
-    userContext: object;
+    userContext: Record<string, unknown>;
     constructor(name?: string, moduleContext?: ModuleContext);
     finish(): void;
 }

package/dist/types.d.ts

@@ -36,7 +36,7 @@ export interface TestState {
     asyncOps: Promise<void>[];
     timeout?: number;
     expectedAssertionCount?: number;
-    userContext?: object;
+    userContext?: Record<string, unknown>;
     module?: {
         name: string;
     };
@@ -45,11 +45,14 @@ export interface TestState {
 export interface ModuleState {
     context: TestState;
 }
-/** A lifecycle hook callback that receives an {@linkcode Assert} instance. */
-export type HookFn<A = unknown> = (assert: A) => void | Promise<void>;
+/** A lifecycle hook callback that receives an {@linkcode Assert} instance and a meta object with the shared context. */
+export type HookFn<A = unknown> = (assert: A, meta: {
+    context: Record<string, unknown>;
+}) => void | Promise<void>;
 export type TestFn<A = unknown> = (assert: A, meta: {
     testName: string;
     options: unknown;
+    context: Record<string, unknown>;
 }) => void | Promise<unknown>;
 /** Lifecycle hooks available inside a `module()` callback. */
 export interface HooksObject<A = unknown> {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.2.2",
+  "version": "1.2.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",
@@ -83,11 +83,11 @@
     "format:fix": "prettier --write \"test/**/*.ts\" \"*.ts\" \"package.json\"",
     "lint": "deno lint shims/",
     "lint:docs": "deno doc --lint shims/deno/module.ts shims/deno/test.ts",
-    "build": "node --experimental-strip-types build.ts",
-    "build:cold": "rm -rf dist && node --experimental-strip-types build.ts",
-    "pretest": "node --experimental-strip-types build.ts && node --input-type=module -e \"import{symlinkSync}from'fs';try{symlinkSync('..','node_modules/qunitx','junction')}catch(_){}\"",
+    "build": "node build.ts",
+    "build:cold": "rm -rf dist && node build.ts",
+    "pretest": "node build.ts && node --input-type=module -e \"import{symlinkSync}from'fs';try{symlinkSync('..','node_modules/qunitx','junction')}catch(_){}\"",
     "run:all": "npm run run:node && npm run run:deno",
-    "run:node": "node --experimental-strip-types --test test/helpers/passing-tests.ts && node --experimental-strip-types --test test/helpers/failing-tests.ts",
+    "run:node": "node --test test/helpers/passing-tests.ts && node --test test/helpers/failing-tests.ts",
     "run:deno": "deno test test/helpers/passing-tests.ts && deno test test/helpers/failing-tests.ts",
     "changelog:unreleased": "git-cliff --unreleased --strip all",
     "changelog:preview": "git-cliff",
@@ -99,8 +99,8 @@
     "test:browser": "qunitx test/index.ts --debug",
     "test:deno": "deno test --allow-read --allow-run test/index.ts",
     "test:doctests": "deno test --doc --allow-read shims/deno/module.ts shims/deno/test.ts",
-    "test:node": "node --experimental-strip-types --test test/index.ts",
-    "coverage": "deno test --coverage=tmp/coverage --allow-read --allow-env --allow-run test/index.ts && deno coverage --lcov --output=tmp/coverage/lcov.info --include='shims/' tmp/coverage && node --experimental-strip-types scripts/check-coverage.ts",
+    "test:node": "node --test test/index.ts",
+    "coverage": "deno test --coverage=tmp/coverage --allow-read --allow-env --allow-run test/index.ts && deno coverage --lcov --output=tmp/coverage/lcov.info --include='shims/' tmp/coverage && node scripts/check-coverage.ts",
     "coverage:report": "npm run coverage && deno coverage --html --include='shims/' tmp/coverage",
     "bench": "deno task bench",
     "bench:check": "deno task bench:check",
@@ -109,6 +109,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "playwright-core": "^1.59.1",
     "prettier": "^3.8.1",
     "qunit": "^2.25.0",
     "qunitx-cli": "^0.9.10",

package/shims/deno/index.ts

@@ -120,8 +120,10 @@ export { default as module } from './module.ts';
  * 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 {object} [runtimeOptions] - Optional options forwarded to `it()`.
+ *   Use `{ skip: true | string }` to skip the test, `{ todo: true | string }` to mark it as todo
+ *   (both map to Deno's `{ ignore: true }`). Other Deno BDD options like
+ *   `{ concurrency: false }` or `{ sanitizeExit: false }` are forwarded as-is.
  * @param {function} testContent - Test callback receiving `(assert, { testName, options })`.
  * @example
  * ```js
@@ -159,6 +161,7 @@ export { default as test } from './test.ts';
  * ```
  */
 export const skip = Test.skip;
+export const todo = Test.todo;
 
 /**
  * The default export provides the full QUnitX API as a single object.

package/shims/deno/module.ts

@@ -1,6 +1,6 @@
 import { describe, beforeAll, afterAll } from "jsr:@std/testing/bdd";
 import type Assert from '../shared/assert.ts';
-import type { HooksObject } from '../types.ts';
+import type { HookFn, HooksObject } from '../types.ts';
 import ModuleContext from '../shared/module-context.ts';
 export type { Assert };
 export type { HookFn, HooksObject, PushResultInfo } from '../types.ts';
@@ -32,13 +32,13 @@ export type { HookFn, HooksObject, PushResultInfo } from '../types.ts';
  * });
  * ```
  */
-export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown }) => void): void;
+export default function module(moduleName: string, moduleContent: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown; context: Record<string, 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;
+export default function module(moduleName: string, runtimeOptions: object, moduleContent: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown; context: Record<string, unknown> }) => void): void;
 export default function module(
   moduleName: string,
   runtimeOptions: object | ((hooks: HooksObject<Assert>) => void),
-  moduleContent?: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown }) => void,
+  moduleContent?: (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown; context: Record<string, unknown> }) => void,
 ): void {
   const targetRuntimeOptions = moduleContent ? runtimeOptions as object : {};
   const { skip } = targetRuntimeOptions as { skip?: boolean | string };
@@ -57,8 +57,8 @@ export default function module(
   const moduleContext = new ModuleContext(moduleName);
 
   describe(moduleName, { ...targetRuntimeOptions }, function () {
-    const beforeHooks: ((assert: Assert) => void | Promise<void>)[] = [];
-    const afterHooks: ((assert: Assert) => void | Promise<void>)[] = [];
+    const beforeHooks: HookFn<Assert>[] = [];
+    const afterHooks: HookFn<Assert>[] = [];
 
     beforeAll(async function () {
       // before() assertions are attributed to the first direct test only (matching QUnit's model).
@@ -67,7 +67,7 @@ export default function module(
       const beforeAssert = firstTest ? firstTest.assert! : moduleContext.assert!;
 
       for (const hook of beforeHooks) {
-        await hook.call(moduleContext.userContext, beforeAssert);
+        await hook.call(moduleContext.userContext, beforeAssert, { context: moduleContext.userContext });
       }
     });
 
@@ -79,7 +79,7 @@ export default function module(
       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!);
+          await afterHooks[j]!.call(lastTest.userContext, lastTest.assert!, { context: lastTest.userContext });
         }
       }
 
@@ -101,7 +101,7 @@ export default function module(
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions });
+    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
 
     ModuleContext.currentModuleChain.pop();
   });