qunitx 1.2.6 → 1.2.8

package/dist/shared/index.js

@@ -27,11 +27,8 @@ function objectType(obj) {
       return typeof obj;
   }
 }
-function is(type, obj) {
-  return objectType(obj) === type;
-}
 function objectValues(obj, allowArray = true) {
-  const vals = allowArray && is("array", obj) ? [] : {};
+  const vals = allowArray && objectType(obj) === "array" ? [] : {};
   for (const key in obj) {
     if (hasOwn.call(obj, key)) {
       const val = obj[key];
@@ -63,13 +60,15 @@ function validateExpectedExceptionArgs(expected, message, assertionMethod) {
       expected = void 0;
       return [expected, message];
     } else {
-      throw new Error("assert." + assertionMethod + " does not accept a string value for the expected argument.\nUse a non-string object value (e.g. RegExp or validator function) instead if necessary.");
+      throw new Error(
+        `assert.${assertionMethod} does not accept a string value for the expected argument.
+Use a non-string object value (e.g. RegExp or validator function) instead if necessary.`
+      );
     }
   }
-  const valid = !expected || // TODO: be more explicit here
-  expectedType === "regexp" || expectedType === "function" || expectedType === "object";
+  const valid = !expected || expectedType === "regexp" || expectedType === "function" || expectedType === "object";
   if (!valid) {
-    throw new Error("Invalid expected value type (" + expectedType + ") provided to assert." + assertionMethod + ".");
+    throw new Error(`Invalid expected value type (${expectedType}) provided to assert.${assertionMethod}.`);
   }
   return [expected, message];
 }
@@ -99,14 +98,13 @@ function validateException(actual, expected, message) {
 function errorString(error) {
   const resultErrorString = String(error);
   if (resultErrorString.slice(0, 7) === "[object") {
-    return (error.name || "Error") + (error.message ? ": ".concat(error.message) : "");
-  } else {
-    return resultErrorString;
+    const name = error.name || "Error";
+    const msg = error.message;
+    return msg ? `${name}: ${msg}` : name;
   }
+  return resultErrorString;
 }
-var shared_default = { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException };
 export {
-  shared_default as default,
   objectType,
   objectValues,
   objectValuesSubset,

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

@@ -1,14 +1,14 @@
-import type Assert from './assert.d.ts';
 import type { HookFn } from '../types.d.ts';
+import type Assert from './assert.d.ts';
 import TestContext from './test-context.d.ts';
 export default class ModuleContext {
     static Assert: typeof Assert;
     static currentModuleChain: ModuleContext[];
-    static get lastModule(): ModuleContext;
+    static get lastModule(): ModuleContext | undefined;
     name: string;
     assert: Assert;
     userContext: Record<string, unknown>;
-    context: TestContext;
+    testContext: TestContext;
     moduleChain: ModuleContext[];
     beforeEachHooks: HookFn<Assert>[];
     afterEachHooks: HookFn<Assert>[];

package/dist/shared/module-context.js

@@ -3,21 +3,21 @@ class ModuleContext {
   static Assert;
   static currentModuleChain = [];
   static get lastModule() {
-    return this.currentModuleChain[this.currentModuleChain.length - 1];
+    return this.currentModuleChain.at(-1);
   }
   name;
   assert;
   userContext;
   // Internal fallback assert for modules with no direct tests
-  context = new TestContext();
+  testContext = new TestContext();
   moduleChain = [];
   beforeEachHooks = [];
   afterEachHooks = [];
   tests = [];
   constructor(name) {
-    const parentModule = ModuleContext.currentModuleChain[ModuleContext.currentModuleChain.length - 1];
+    const parentModule = ModuleContext.currentModuleChain.at(-1);
     ModuleContext.currentModuleChain.push(this);
-    this.moduleChain = ModuleContext.currentModuleChain.slice(0);
+    this.moduleChain = [...ModuleContext.currentModuleChain];
     this.name = parentModule ? `${parentModule.name} > ${name}` : name;
     this.assert = new ModuleContext.Assert(this);
     this.userContext = parentModule ? Object.create(parentModule.userContext) : /* @__PURE__ */ Object.create(null);

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

@@ -3,26 +3,18 @@ import type ModuleContext from './module-context.d.ts';
 export default class TestContext {
     #private;
     static Assert: typeof Assert;
-    get name(): string | undefined;
-    set name(value: string | undefined);
-    get module(): ModuleContext | undefined;
-    set module(value: ModuleContext | undefined);
-    get asyncOps(): Promise<void>[];
-    set asyncOps(value: Promise<void>[]);
-    get assert(): Assert | undefined;
-    set assert(value: Assert | undefined);
-    get timeout(): number | undefined;
-    set timeout(value: number | undefined);
+    name: string | undefined;
+    module: ModuleContext | undefined;
+    asyncOps: Promise<void>[];
+    assert: Assert | undefined;
+    timeout: number | undefined;
+    steps: string[];
+    expectedAssertionCount: number | undefined;
+    totalExecutedAssertions: number;
+    userContext: Record<string, unknown>;
     rejectTimeout: ((err: Error) => void) | undefined;
+    constructor(name?: string, moduleContext?: ModuleContext);
     setTimeoutDuration(ms: number): void;
     clearTimeoutHandle(): void;
-    get steps(): string[];
-    set steps(value: string[]);
-    get expectedAssertionCount(): number | undefined;
-    set expectedAssertionCount(value: number | undefined);
-    get totalExecutedAssertions(): number;
-    set totalExecutedAssertions(value: number);
-    userContext: Record<string, unknown>;
-    constructor(name?: string, moduleContext?: ModuleContext);
     finish(): void;
 }

package/dist/shared/test-context.js

@@ -1,43 +1,25 @@
 class TestContext {
   static Assert;
-  #name;
-  get name() {
-    return this.#name;
-  }
-  set name(value) {
-    this.#name = value;
-  }
-  #module;
-  get module() {
-    return this.#module;
-  }
-  set module(value) {
-    this.#module = value;
-  }
-  #asyncOps = [];
-  get asyncOps() {
-    return this.#asyncOps;
-  }
-  set asyncOps(value) {
-    this.#asyncOps = value;
-  }
-  #assert;
-  get assert() {
-    return this.#assert;
-  }
-  set assert(value) {
-    this.#assert = value;
-  }
-  #timeout;
-  get timeout() {
-    return this.#timeout;
-  }
-  set timeout(value) {
-    this.#timeout = value;
-  }
+  name;
+  module;
+  asyncOps = [];
+  assert;
+  timeout;
+  steps = [];
+  expectedAssertionCount;
+  totalExecutedAssertions = 0;
+  userContext = {};
   rejectTimeout;
   #timeoutHandle;
   #timedOut = false;
+  constructor(name, moduleContext) {
+    if (moduleContext) {
+      this.name = `${moduleContext.name} | ${name}`;
+      this.module = moduleContext;
+      this.module.tests.push(this);
+      this.assert = new TestContext.Assert(moduleContext, this);
+    }
+  }
   setTimeoutDuration(ms) {
     if (this.#timeoutHandle !== void 0) {
       clearTimeout(this.#timeoutHandle);
@@ -55,59 +37,29 @@ class TestContext {
       this.#timeoutHandle = void 0;
     }
   }
-  #steps = [];
-  get steps() {
-    return this.#steps;
-  }
-  set steps(value) {
-    this.#steps = value;
-  }
-  #expectedAssertionCount;
-  get expectedAssertionCount() {
-    return this.#expectedAssertionCount;
-  }
-  set expectedAssertionCount(value) {
-    this.#expectedAssertionCount = value;
-  }
-  #totalExecutedAssertions = 0;
-  get totalExecutedAssertions() {
-    return this.#totalExecutedAssertions;
-  }
-  set totalExecutedAssertions(value) {
-    this.#totalExecutedAssertions = value;
-  }
-  userContext = {};
-  constructor(name, moduleContext) {
-    if (moduleContext) {
-      this.name = `${moduleContext.name} | ${name}`;
-      this.module = moduleContext;
-      this.module.tests.push(this);
-      this.assert = new TestContext.Assert(moduleContext, this);
-    }
-  }
   finish() {
     if (this.#timedOut) return;
-    if (this.totalExecutedAssertions === 0) {
-      this.assert.pushResult({
-        result: false,
-        actual: this.totalExecutedAssertions,
-        expected: "> 0",
-        message: `Expected at least one assertion to be run for test: ${this.name}`
-      });
-    } else if (this.steps.length > 0) {
+    if (this.steps.length > 0) {
       this.assert.pushResult({
         result: false,
         actual: this.steps,
         expected: [],
         message: `Expected assert.verifySteps() to be called before end of test after using assert.step(). Unverified steps: ${this.steps.join(", ")}`
       });
-    } else if (this.expectedAssertionCount && this.expectedAssertionCount !== this.totalExecutedAssertions) {
+    } else if (this.expectedAssertionCount !== void 0 && this.expectedAssertionCount !== this.totalExecutedAssertions) {
       this.assert.pushResult({
         result: false,
         actual: this.totalExecutedAssertions,
         expected: this.expectedAssertionCount,
         message: `Expected ${this.expectedAssertionCount} assertions, but ${this.totalExecutedAssertions} were run for test: ${this.name}`
       });
+    } else if (this.expectedAssertionCount === void 0 && this.totalExecutedAssertions === 0) {
+      this.assert.pushResult({
+        result: false,
+        actual: this.totalExecutedAssertions,
+        expected: "> 0",
+        message: `Expected at least one assertion to be run for test: ${this.name}`
+      });
     }
   }
 }

package/dist/types.d.ts

@@ -44,7 +44,7 @@ export interface TestState {
 }
 /** Minimal module shape that Assert needs to resolve a fallback test context. */
 export interface ModuleState {
-    context: TestState;
+    testContext: TestState;
 }
 /** 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: {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.2.6",
-  "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
+  "version": "1.2.8",
+  "description": "Universal test library — run the same test file in Node.js, Deno, and the browser with QUnit's battle-tested assertion API",
   "author": "Izel Nakri",
   "license": "MIT",
   "keywords": [

package/shims/deno/index.ts

@@ -24,12 +24,12 @@
  *
  * @module
  */
-import { AssertionError as DenoAssertionError } from "jsr:@std/assert";
-import type { AssertionErrorOptions } from "../types.ts";
 import '../../vendor/qunit.js';
+import { AssertionError as DenoAssertionError } from 'jsr:@std/assert';
 import Assert from '../shared/assert.ts';
 import ModuleContext from '../shared/module-context.ts';
 import TestContext from '../shared/test-context.ts';
+import type { AssertionErrorOptions } from '../types.ts';
 import Module from './module.ts';
 import Test from './test.ts';
 
@@ -54,6 +54,7 @@ import Test from './test.ts';
 export class AssertionError extends DenoAssertionError {
   constructor(object: AssertionErrorOptions) {
     super(object.message ?? 'Assertion failed');
+    if (object.stackStartFn) Error.captureStackTrace(this, object.stackStartFn);
   }
 }
 
@@ -111,6 +112,25 @@ export { Assert };
  */
 export { default as module } from './module.ts';
 
+/**
+ * Registers a skipped test. Equivalent to `test.skip`. The test body is never
+ * executed and the test is reported as ignored by Deno's runner.
+ *
+ * @param {string} testName - Name of the test to skip.
+ * @param {function} [_testContent] - Optional body (ignored — the test will not run).
+ * @example
+ * ```js
+ * import { module, skip } from "qunitx";
+ *
+ * module("Math", () => {
+ *   skip("addition is not yet implemented", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ * });
+ * ```
+ */
+export const skip = Test.skip;
+
 /**
  * Defines an individual test. Wraps Deno's `it()` and handles the full QUnit
  * lifecycle: `beforeEach`/`afterEach` hooks, async assertion waiting, and step
@@ -142,25 +162,6 @@ export { default as module } from './module.ts';
  * ```
  */
 export { default as test } from './test.ts';
-
-/**
- * Registers a skipped test. Equivalent to `test.skip`. The test body is never
- * executed and the test is reported as ignored by Deno's runner.
- *
- * @param {string} testName - Name of the test to skip.
- * @param {function} [_testContent] - Optional body (ignored — the test will not run).
- * @example
- * ```js
- * import { module, skip } from "qunitx";
- *
- * module("Math", () => {
- *   skip("addition is not yet implemented", (assert) => {
- *     assert.equal(1 + 1, 2);
- *   });
- * });
- * ```
- */
-export const skip = Test.skip;
 export const todo = Test.todo;
 
 /**

package/shims/deno/module.ts

@@ -1,9 +1,7 @@
-import { describe, beforeAll, afterAll } from "jsr:@std/testing/bdd";
+import { afterAll, beforeAll, describe } from 'jsr:@std/testing/bdd';
 import type Assert from '../shared/assert.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';
+import type { HookFn, HooksObject } from '../types.ts';
 
 /**
  * Defines a test module (suite) for Deno's BDD test runner.
@@ -53,14 +51,14 @@ export default function module(
     return;
   }
 
-  const targetModuleContent = (moduleContent ? moduleContent : runtimeOptions) as (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown }) => void;
+  const targetModuleContent = (moduleContent ?? runtimeOptions) as (hooks: HooksObject<Assert>, meta: { moduleName: string; options: unknown }) => void;
   const moduleContext = new ModuleContext(moduleName);
 
   describe(moduleName, { ...targetRuntimeOptions }, function () {
     const beforeHooks: HookFn<Assert>[] = [];
     const afterHooks: HookFn<Assert>[] = [];
 
-    beforeAll(async function () {
+    beforeAll(async () => {
       // 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];
@@ -72,19 +70,18 @@ export default function module(
     });
 
     afterAll(async () => {
-      for (const testContext of moduleContext.tests) {
-        await testContext.assert!.waitForAsyncOps();
-      }
+      const allAsyncOps = moduleContext.tests.flatMap((t) => t.asyncOps);
+      if (allAsyncOps.length > 0) await Promise.all(allAsyncOps);
 
-      const lastTest = moduleContext.tests[moduleContext.tests.length - 1];
+      const lastTest = moduleContext.tests.at(-1);
       if (lastTest) {
-        for (let j = afterHooks.length - 1; j >= 0; j--) {
-          await afterHooks[j]!.call(lastTest.userContext, lastTest.assert!, { context: lastTest.userContext });
+        for (const hook of afterHooks.toReversed()) {
+          await hook.call(lastTest.userContext, lastTest.assert!, { context: lastTest.userContext });
         }
       }
 
-      for (let i = 0, len = moduleContext.tests.length; i < len; i++) {
-        moduleContext.tests[i].finish();
+      for (const testCtx of moduleContext.tests) {
+        testCtx.finish();
       }
     });
 
@@ -101,7 +98,7 @@ export default function module(
       after(afterFn) {
         afterHooks.push(afterFn);
       }
-    }, { moduleName, options: runtimeOptions, context: moduleContext.userContext });
+    }, { moduleName, options: targetRuntimeOptions, context: moduleContext.userContext });
 
     ModuleContext.currentModuleChain.pop();
   });
@@ -149,3 +146,6 @@ module.skip = function skipModule(moduleName: string, _moduleContent?: unknown):
 module.todo = function todoModule(moduleName: string, _moduleContent?: unknown): void {
   describe(moduleName, { ignore: true }, function () {});
 };
+
+export type { Assert };
+export type { HookFn, HooksObject, PushResultInfo } from '../types.ts';

package/shims/deno/test.ts

@@ -1,9 +1,7 @@
-import { it } from "jsr:@std/testing/bdd";
+import { it } from 'jsr:@std/testing/bdd';
 import type Assert from '../shared/assert.ts';
-import TestContext from '../shared/test-context.ts';
 import ModuleContext from '../shared/module-context.ts';
-export type { Assert };
-export type { PushResultInfo } from '../types.ts';
+import TestContext from '../shared/test-context.ts';
 
 /**
  * Defines an individual test within a module for Deno's BDD test runner.
@@ -59,7 +57,7 @@ export default function test(
     return;
   }
 
-  const targetTestContent = (testContent ? testContent : runtimeOptions) as (assert: Assert, meta: { testName: string; options: unknown }) => void | Promise<void>;
+  const targetTestContent = (testContent ?? runtimeOptions) as (assert: Assert, meta: { testName: string; options: unknown }) => void | Promise<void>;
   const context = new TestContext(testName, moduleContext);
 
   // Each test gets a fresh plain object inheriting from the module's user context.
@@ -69,38 +67,38 @@ export default function test(
   context.userContext = userContext;
 
   it(testName, { ...targetRuntimeOptions }, function () {
-    return new Promise((resolve, reject) => {
-      context.rejectTimeout = reject;
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
+    context.rejectTimeout = reject;
 
-      (async () => {
-        const hookMeta = { context: userContext };
+    const hookMeta = { context: userContext };
 
-        try {
-          for (const module of context.module!.moduleChain) {
-            for (const hook of module.beforeEachHooks) {
-              await hook.call(userContext, context.assert!, hookMeta);
-            }
+    (async () => {
+      try {
+        for (const mod of context.module!.moduleChain) {
+          for (const hook of mod.beforeEachHooks) {
+            await hook.call(userContext, context.assert!, hookMeta);
           }
+        }
 
-          const result = await targetTestContent.call(userContext, context.assert!, { testName, options: runtimeOptions, context: userContext });
+        await targetTestContent.call(userContext, context.assert!, { testName, options: targetRuntimeOptions, context: userContext });
 
-          await context.assert!.waitForAsyncOps();
+        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!, hookMeta);
-            }
+        for (const mod of context.module!.moduleChain.toReversed()) {
+          for (const hook of mod.afterEachHooks.toReversed()) {
+            await hook.call(userContext, context.assert!, hookMeta);
           }
-
-          resolve(result);
-        } catch (err) {
-          reject(err);
-        } finally {
-          context.clearTimeoutHandle();
         }
-      })();
-    });
+
+        resolve();
+      } catch (err) {
+        reject(err);
+      } finally {
+        context.clearTimeoutHandle();
+      }
+    })();
+
+    return promise;
   });
 }
 
@@ -146,3 +144,6 @@ test.skip = function skipTest(testName: string, _testContent?: unknown): void {
 test.todo = function todoTest(testName: string, _testContent?: unknown): void {
   it(testName, { ignore: true }, async function () {});
 };
+
+export type { Assert };
+export type { PushResultInfo } from '../types.ts';