qunitx 1.2.10 → 1.2.16

package/dist/node/test.js

@@ -26,16 +26,18 @@ function test(testName, runtimeOptions, testContent) {
     const hookMeta = { context: userContext };
     (async () => {
       try {
-        for (const mod of context.module.moduleChain) {
+        const chain = context.module.moduleChain;
+        for (const mod of chain) {
           for (const hook of mod.beforeEachHooks) {
             await hook.call(userContext, context.assert, hookMeta);
           }
         }
         await targetTestContent.call(userContext, context.assert, { testName, options: targetRuntimeOptions, context: userContext });
-        await context.assert.waitForAsyncOps();
-        for (const mod of context.module.moduleChain.toReversed()) {
-          for (const hook of mod.afterEachHooks.toReversed()) {
-            await hook.call(userContext, context.assert, hookMeta);
+        if (context.asyncOps.length > 0) await context.assert.waitForAsyncOps();
+        for (let i = chain.length - 1; i >= 0; i--) {
+          const hooks = chain[i].afterEachHooks;
+          for (let j = hooks.length - 1; j >= 0; j--) {
+            await hooks[j].call(userContext, context.assert, hookMeta);
           }
         }
         resolve();

package/dist/shared/assert.d.ts

@@ -30,8 +30,6 @@ export default class Assert {
     test: TestState;
     /** @internal */
     constructor(module: ModuleState | null, test?: TestState);
-    /** @internal */
-    private _incrementAssertionCount;
     /**
      * Sets the number of milliseconds after which the current test will fail if not yet complete.
      *

package/dist/shared/assert.js

@@ -14,10 +14,6 @@ class Assert {
   constructor(module, test) {
     this.test = test || module.testContext;
   }
-  /** @internal */
-  _incrementAssertionCount() {
-    this.test.totalExecutedAssertions++;
-  }
   /**
    * Sets the number of milliseconds after which the current test will fail if not yet complete.
    *
@@ -145,7 +141,7 @@ class Assert {
    * ```
    */
   pushResult(resultInfo = {}) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (!resultInfo.result) {
       throw new Assert.AssertionError({
         actual: resultInfo.actual,
@@ -169,7 +165,7 @@ class Assert {
    * ```
    */
   ok(state, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (!state) {
       throw new Assert.AssertionError({
         actual: state,
@@ -192,7 +188,7 @@ class Assert {
    * ```
    */
   notOk(state, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (state) {
       throw new Assert.AssertionError({
         actual: state,
@@ -214,7 +210,7 @@ class Assert {
    * ```
    */
   true(state, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (state !== true) {
       throw new Assert.AssertionError({
         actual: state,
@@ -236,7 +232,7 @@ class Assert {
    * ```
    */
   false(state, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (state !== false) {
       throw new Assert.AssertionError({
         actual: state,
@@ -262,7 +258,7 @@ class Assert {
    * ```
    */
   equal(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (actual != expected) {
       throw new Assert.AssertionError({
         actual,
@@ -286,7 +282,7 @@ class Assert {
    * ```
    */
   notEqual(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (actual == expected) {
       throw new Assert.AssertionError({
         actual,
@@ -314,7 +310,7 @@ class Assert {
    * ```
    */
   propEqual(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const targetActual = objectValues(actual);
     const targetExpected = objectValues(expected);
     if (!Assert.QUnit.equiv(targetActual, targetExpected)) {
@@ -340,7 +336,7 @@ class Assert {
    * ```
    */
   notPropEqual(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const targetActual = objectValues(actual);
     const targetExpected = objectValues(expected);
     if (Assert.QUnit.equiv(targetActual, targetExpected)) {
@@ -366,7 +362,7 @@ class Assert {
    * ```
    */
   propContains(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const targetActual = objectValuesSubset(actual, expected);
     const targetExpected = objectValues(expected, false);
     if (!Assert.QUnit.equiv(targetActual, targetExpected)) {
@@ -392,7 +388,7 @@ class Assert {
    * ```
    */
   notPropContains(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const targetActual = objectValuesSubset(actual, expected);
     const targetExpected = objectValues(expected);
     if (Assert.QUnit.equiv(targetActual, targetExpected)) {
@@ -418,7 +414,7 @@ class Assert {
    * ```
    */
   deepEqual(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (!Assert.QUnit.equiv(actual, expected)) {
       throw new Assert.AssertionError({
         actual,
@@ -442,7 +438,7 @@ class Assert {
    * ```
    */
   notDeepEqual(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (Assert.QUnit.equiv(actual, expected)) {
       throw new Assert.AssertionError({
         actual,
@@ -466,7 +462,7 @@ class Assert {
    * ```
    */
   strictEqual(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (actual !== expected) {
       throw new Assert.AssertionError({
         actual,
@@ -490,7 +486,7 @@ class Assert {
    * ```
    */
   notStrictEqual(actual, expected, message) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (actual === expected) {
       throw new Assert.AssertionError({
         actual,
@@ -517,7 +513,7 @@ class Assert {
    * ```
    */
   throws(blockFn, expectedInput, assertionMessage) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, "throws");
     if (typeof blockFn !== "function") {
       throw new Assert.AssertionError({
@@ -575,7 +571,7 @@ class Assert {
    * ```
    */
   async rejects(promise, expectedInput, assertionMessage) {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, "rejects");
     const then = promise && promise.then;
     if (typeof then !== "function") {

package/dist/shared/filter-stack.d.ts

@@ -0,0 +1 @@
+export declare function filterStack(stack: string | undefined): string | undefined;

package/dist/shared/filter-stack.js

@@ -0,0 +1,21 @@
+const FILTER_PATTERNS = [
+  /\bnode:internal\/test_runner\//,
+  /\bnode:async_hooks\b/
+];
+function isDebugEnabled() {
+  try {
+    const proc = globalThis.process;
+    if (proc?.env?.QUNITX_DEBUG === "1") return true;
+    const deno = globalThis.Deno;
+    if (deno?.env?.get?.("QUNITX_DEBUG") === "1") return true;
+  } catch {
+  }
+  return false;
+}
+function filterStack(stack) {
+  if (!stack || isDebugEnabled()) return stack;
+  return stack.split("\n").filter((line) => !FILTER_PATTERNS.some((p) => p.test(line))).join("\n");
+}
+export {
+  filterStack
+};

package/dist/shared/index.js

@@ -1,18 +1,23 @@
 const hasOwn = Object.prototype.hasOwnProperty;
+const objToString = Object.prototype.toString;
 function objectType(obj) {
-  if (typeof obj === "undefined") {
-    return "undefined";
+  if (obj === null) return "null";
+  const t = typeof obj;
+  switch (t) {
+    case "undefined":
+    case "string":
+    case "boolean":
+    case "function":
+    case "symbol":
+    case "bigint":
+      return t;
+    case "number":
+      return obj !== obj ? "nan" : "number";
   }
-  if (obj === null) {
-    return "null";
-  }
-  const type = Object.prototype.toString.call(obj).slice(8, -1);
+  const type = objToString.call(obj).slice(8, -1);
   switch (type) {
     case "Number":
-      if (isNaN(obj)) {
-        return "nan";
-      }
-      return "number";
+      return isNaN(obj) ? "nan" : "number";
     case "String":
     case "Boolean":
     case "Array":
@@ -24,23 +29,25 @@ function objectType(obj) {
     case "Symbol":
       return type.toLowerCase();
     default:
-      return typeof obj;
+      return "object";
   }
 }
 function objectValues(obj, allowArray = true) {
-  const vals = allowArray && objectType(obj) === "array" ? [] : {};
+  const vals = allowArray && Array.isArray(obj) ? [] : {};
   for (const key in obj) {
     if (hasOwn.call(obj, key)) {
       const val = obj[key];
-      vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
+      const t = typeof val;
+      const isObjectish = val !== null && (t === "object" || t === "function");
+      vals[key] = isObjectish ? objectValues(val, allowArray) : val;
     }
   }
   return vals;
 }
 function objectValuesSubset(obj, model) {
-  if (obj !== Object(obj)) {
-    return obj;
-  }
+  if (obj === null) return obj;
+  const objT = typeof obj;
+  if (objT !== "object" && objT !== "function") return obj;
   const subset = {};
   for (const key in model) {
     if (hasOwn.call(model, key) && hasOwn.call(obj, key)) {

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

@@ -4,7 +4,7 @@ import TestContext from './test-context.d.ts';
 export default class ModuleContext {
     static Assert: typeof Assert;
     static currentModuleChain: ModuleContext[];
-    static get lastModule(): ModuleContext | undefined;
+    static get lastModule(): ModuleContext;
     name: string;
     assert: Assert;
     userContext: Record<string, unknown>;

package/dist/shared/module-context.js

@@ -3,7 +3,8 @@ class ModuleContext {
   static Assert;
   static currentModuleChain = [];
   static get lastModule() {
-    return this.currentModuleChain.at(-1);
+    const chain = this.currentModuleChain;
+    return chain[chain.length - 1];
   }
   name;
   assert;
@@ -15,9 +16,10 @@ class ModuleContext {
   afterEachHooks = [];
   tests = [];
   constructor(name) {
-    const parentModule = ModuleContext.currentModuleChain.at(-1);
-    ModuleContext.currentModuleChain.push(this);
-    this.moduleChain = [...ModuleContext.currentModuleChain];
+    const chain = ModuleContext.currentModuleChain;
+    const parentModule = chain[chain.length - 1];
+    chain.push(this);
+    this.moduleChain = chain.slice();
     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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.2.10",
+  "version": "1.2.16",
   "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",

package/shims/deno/index.ts

@@ -27,6 +27,7 @@
 import '../../vendor/qunit.js';
 import { AssertionError as DenoAssertionError } from 'jsr:@std/assert';
 import Assert from '../shared/assert.ts';
+import { filterStack } from '../shared/filter-stack.ts';
 import ModuleContext from '../shared/module-context.ts';
 import TestContext from '../shared/test-context.ts';
 import type { AssertionErrorOptions } from '../types.ts';
@@ -55,6 +56,7 @@ export class AssertionError extends DenoAssertionError {
   constructor(object: AssertionErrorOptions) {
     super(object.message ?? 'Assertion failed');
     if (object.stackStartFn) Error.captureStackTrace(this, object.stackStartFn);
+    this.stack = filterStack(this.stack);
   }
 }
 

package/shims/deno/module.ts

@@ -73,10 +73,12 @@ export default function module(
       const allAsyncOps = moduleContext.tests.flatMap((t) => t.asyncOps);
       if (allAsyncOps.length > 0) await Promise.all(allAsyncOps);
 
-      const lastTest = moduleContext.tests.at(-1);
+      const tests = moduleContext.tests;
+      const lastTest = tests[tests.length - 1];
       if (lastTest) {
-        for (const hook of afterHooks.toReversed()) {
-          await hook.call(lastTest.userContext, lastTest.assert!, { context: lastTest.userContext });
+        // Indexed reverse iteration avoids `afterHooks.toReversed()`'s per-call alloc.
+        for (let i = afterHooks.length - 1; i >= 0; i--) {
+          await afterHooks[i]!.call(lastTest.userContext, lastTest.assert!, { context: lastTest.userContext });
         }
       }
 

package/shims/deno/test.ts

@@ -74,7 +74,8 @@ export default function test(
 
     (async () => {
       try {
-        for (const mod of context.module!.moduleChain) {
+        const chain = context.module!.moduleChain;
+        for (const mod of chain) {
           for (const hook of mod.beforeEachHooks) {
             await hook.call(userContext, context.assert!, hookMeta);
           }
@@ -82,11 +83,15 @@ export default function test(
 
         await targetTestContent.call(userContext, context.assert!, { testName, options: targetRuntimeOptions, context: userContext });
 
-        await context.assert!.waitForAsyncOps();
+        // Skip the microtask hop when no `assert.async()` callbacks were registered.
+        if (context.asyncOps.length > 0) await context.assert!.waitForAsyncOps();
 
-        for (const mod of context.module!.moduleChain.toReversed()) {
-          for (const hook of mod.afterEachHooks.toReversed()) {
-            await hook.call(userContext, context.assert!, hookMeta);
+        // Indexed reverse iteration avoids the per-test allocations from
+        // `chain.toReversed()` + per-module `hooks.toReversed()`.
+        for (let i = chain.length - 1; i >= 0; i--) {
+          const hooks = chain[i]!.afterEachHooks;
+          for (let j = hooks.length - 1; j >= 0; j--) {
+            await hooks[j]!.call(userContext, context.assert!, hookMeta);
           }
         }
 

package/shims/shared/assert.ts

@@ -40,11 +40,6 @@ export default class Assert {
     this.test = test || (module as ModuleState).testContext;
   }
 
-  /** @internal */
-  private _incrementAssertionCount() {
-    this.test.totalExecutedAssertions++;
-  }
-
   /**
    * Sets the number of milliseconds after which the current test will fail if not yet complete.
    *
@@ -186,7 +181,7 @@ export default class Assert {
    * ```
    */
   pushResult(resultInfo: PushResultInfo = {}): this {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (!resultInfo.result) {
       throw new Assert.AssertionError({
         actual: resultInfo.actual,
@@ -212,7 +207,7 @@ export default class Assert {
    * ```
    */
   ok(state: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (!state) {
       throw new Assert.AssertionError({
         actual: state,
@@ -236,7 +231,7 @@ export default class Assert {
    * ```
    */
   notOk(state: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (state) {
       throw new Assert.AssertionError({
         actual: state,
@@ -259,7 +254,7 @@ export default class Assert {
    * ```
    */
   true(state: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (state !== true) {
       throw new Assert.AssertionError({
         actual: state,
@@ -282,7 +277,7 @@ export default class Assert {
    * ```
    */
   false(state: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (state !== false) {
       throw new Assert.AssertionError({
         actual: state,
@@ -309,7 +304,7 @@ export default class Assert {
    * ```
    */
   equal(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (actual != expected) {
       throw new Assert.AssertionError({
         actual,
@@ -334,7 +329,7 @@ export default class Assert {
    * ```
    */
   notEqual(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (actual == expected) {
       throw new Assert.AssertionError({
         actual,
@@ -363,7 +358,7 @@ export default class Assert {
    * ```
    */
   propEqual(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const targetActual = objectValues(actual);
     const targetExpected = objectValues(expected);
     if (!Assert.QUnit.equiv(targetActual, targetExpected)) {
@@ -390,7 +385,7 @@ export default class Assert {
    * ```
    */
   notPropEqual(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const targetActual = objectValues(actual);
     const targetExpected = objectValues(expected);
     if (Assert.QUnit.equiv(targetActual, targetExpected)) {
@@ -417,7 +412,7 @@ export default class Assert {
    * ```
    */
   propContains(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const targetActual = objectValuesSubset(actual, expected);
     const targetExpected = objectValues(expected, false);
     if (!Assert.QUnit.equiv(targetActual, targetExpected)) {
@@ -444,7 +439,7 @@ export default class Assert {
    * ```
    */
   notPropContains(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const targetActual = objectValuesSubset(actual, expected);
     const targetExpected = objectValues(expected);
     if (Assert.QUnit.equiv(targetActual, targetExpected)) {
@@ -471,7 +466,7 @@ export default class Assert {
    * ```
    */
   deepEqual(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (!Assert.QUnit.equiv(actual, expected)) {
       throw new Assert.AssertionError({
         actual,
@@ -496,7 +491,7 @@ export default class Assert {
    * ```
    */
   notDeepEqual(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (Assert.QUnit.equiv(actual, expected)) {
       throw new Assert.AssertionError({
         actual,
@@ -521,7 +516,7 @@ export default class Assert {
    * ```
    */
   strictEqual(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (actual !== expected) {
       throw new Assert.AssertionError({
         actual,
@@ -546,7 +541,7 @@ export default class Assert {
    * ```
    */
   notStrictEqual(actual: unknown, expected: unknown, message?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     if (actual === expected) {
       throw new Assert.AssertionError({
         actual,
@@ -574,7 +569,7 @@ export default class Assert {
    * ```
    */
   throws(blockFn: unknown, expectedInput?: unknown, assertionMessage?: string): void {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'throws');
     if (typeof blockFn !== 'function') {
       throw new Assert.AssertionError({
@@ -637,7 +632,7 @@ export default class Assert {
    * ```
    */
   async rejects(promise: unknown, expectedInput?: unknown, assertionMessage?: string): Promise<void> {
-    this._incrementAssertionCount();
+    this.test.totalExecutedAssertions++;
     const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
     const then = promise && (promise as PromiseLike<unknown>).then;
     if (typeof then !== 'function') {

package/shims/shared/filter-stack.ts

@@ -0,0 +1,35 @@
+// Strips runtime-internal frames from an Error's `.stack` so failing-test output
+// shows the user's code first and qunitx's wrapper frames second, with no trailing
+// pages of `node:internal/test_runner/...` and `node:async_hooks:...` lines.
+//
+// Filtered prefixes are stable Node-internal modules (their paths haven't
+// changed across recent Node versions) and unambiguously not user code. We do
+// NOT filter qunitx's own dist frames — they're exactly two short lines per
+// failure and are useful when a bug actually lands in qunitx itself.
+//
+// QUNITX_DEBUG=1 disables filtering entirely, for the rare case where someone
+// is debugging qunitx and wants the full V8 stack.
+const FILTER_PATTERNS = [
+  /\bnode:internal\/test_runner\//,
+  /\bnode:async_hooks\b/,
+];
+
+function isDebugEnabled(): boolean {
+  try {
+    const proc = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process;
+    if (proc?.env?.QUNITX_DEBUG === '1') return true;
+    const deno = (globalThis as { Deno?: { env?: { get(key: string): string | undefined } } }).Deno;
+    if (deno?.env?.get?.('QUNITX_DEBUG') === '1') return true;
+  } catch {
+    // Deno without --allow-env throws on env access; treat as non-debug.
+  }
+  return false;
+}
+
+export function filterStack(stack: string | undefined): string | undefined {
+  if (!stack || isDebugEnabled()) return stack;
+  return stack
+    .split('\n')
+    .filter((line) => !FILTER_PATTERNS.some((p) => p.test(line)))
+    .join('\n');
+}