qunitx 1.1.5 → 1.1.6

package/dist/shared/index.js

@@ -1,154 +1,115 @@
 const hasOwn = Object.prototype.hasOwnProperty;
-export function objectType(obj) {
-    if (typeof obj === 'undefined') {
-        return 'undefined';
-    }
-    // Consider: typeof null === object
-    if (obj === null) {
-        return 'null';
-    }
-    // slice(8, -1) extracts the type name from "[object Foo]" without a regex
-    const type = Object.prototype.toString.call(obj).slice(8, -1);
-    switch (type) {
-        case 'Number':
-            if (isNaN(obj)) {
-                return 'nan';
-            }
-            return 'number';
-        case 'String':
-        case 'Boolean':
-        case 'Array':
-        case 'Set':
-        case 'Map':
-        case 'Date':
-        case 'RegExp':
-        case 'Function':
-        case 'Symbol':
-            return type.toLowerCase();
-        default:
-            return typeof obj;
-    }
+function objectType(obj) {
+  if (typeof obj === "undefined") {
+    return "undefined";
+  }
+  if (obj === null) {
+    return "null";
+  }
+  const type = Object.prototype.toString.call(obj).slice(8, -1);
+  switch (type) {
+    case "Number":
+      if (isNaN(obj)) {
+        return "nan";
+      }
+      return "number";
+    case "String":
+    case "Boolean":
+    case "Array":
+    case "Set":
+    case "Map":
+    case "Date":
+    case "RegExp":
+    case "Function":
+    case "Symbol":
+      return type.toLowerCase();
+    default:
+      return typeof obj;
+  }
 }
 function is(type, obj) {
-    return objectType(obj) === type;
+  return objectType(obj) === type;
 }
-export function objectValues(obj, allowArray = true) {
-    const vals = allowArray && is('array', obj) ? [] : {};
-    for (const key in obj) {
-        if (hasOwn.call(obj, key)) {
-            const val = obj[key];
-            vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
-        }
+function objectValues(obj, allowArray = true) {
+  const vals = allowArray && is("array", obj) ? [] : {};
+  for (const key in obj) {
+    if (hasOwn.call(obj, key)) {
+      const val = obj[key];
+      vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
     }
-    return vals;
+  }
+  return vals;
 }
-/**
- *
- * Recursively clone an object into a plain object, taking only the
- * subset of own enumerable properties that exist a given model.
- *
- * @param {any} obj
- * @param {any} model
- * @return {Object}
- */
-export function objectValuesSubset(obj, model) {
-    // Return primitive values unchanged to avoid false positives or confusing
-    // results from assert.propContains().
-    // E.g. an actual null or false wrongly equaling an empty object,
-    // or an actual string being reported as object not matching a partial object.
-    if (obj !== Object(obj)) {
-        return obj;
+function objectValuesSubset(obj, model) {
+  if (obj !== Object(obj)) {
+    return obj;
+  }
+  const subset = {};
+  for (const key in model) {
+    if (hasOwn.call(model, key) && hasOwn.call(obj, key)) {
+      subset[key] = objectValuesSubset(
+        obj[key],
+        model[key]
+      );
     }
-    // Unlike objectValues(), subset arrays to a plain objects as well.
-    // This enables subsetting [20, 30] with {1: 30}.
-    const subset = {};
-    for (const key in model) {
-        if (hasOwn.call(model, key) && hasOwn.call(obj, key)) {
-            subset[key] = objectValuesSubset(obj[key], model[key]);
-        }
-    }
-    return subset;
+  }
+  return subset;
 }
-export function validateExpectedExceptionArgs(expected, message, assertionMethod) {
-    const expectedType = objectType(expected);
-    // 'expected' is optional unless doing string comparison
-    if (expectedType === 'string') {
-        if (message === undefined) {
-            message = expected;
-            expected = undefined;
-            return [expected, message];
-        }
-        else {
-            throw new Error('assert.' + assertionMethod + ' does not accept a string value for the expected argument.\n' + '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';
-    if (!valid) {
-        throw new Error('Invalid expected value type (' + expectedType + ') ' + 'provided to assert.' + assertionMethod + '.');
+function validateExpectedExceptionArgs(expected, message, assertionMethod) {
+  const expectedType = objectType(expected);
+  if (expectedType === "string") {
+    if (message === void 0) {
+      message = expected;
+      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.");
     }
-    return [expected, message];
+  }
+  const valid = !expected || // TODO: be more explicit here
+  expectedType === "regexp" || expectedType === "function" || expectedType === "object";
+  if (!valid) {
+    throw new Error("Invalid expected value type (" + expectedType + ") provided to assert." + assertionMethod + ".");
+  }
+  return [expected, message];
 }
-export function validateException(actual, expected, message) {
-    let result = false;
-    const expectedType = objectType(expected);
-    // These branches should be exhaustive, based on validation done in validateExpectedException
-    // We don't want to validate
-    if (!expected) {
-        result = true;
-        // Expected is a regexp
-    }
-    else if (expectedType === 'regexp') {
-        result = expected.test(errorString(actual));
-        // Log the string form of the regexp
-        expected = String(expected);
-        // Expected is a constructor, maybe an Error constructor.
-        // Note the extra check on its prototype - this is an implicit
-        // requirement of "instanceof", else it will throw a TypeError.
+function validateException(actual, expected, message) {
+  let result = false;
+  const expectedType = objectType(expected);
+  if (!expected) {
+    result = true;
+  } else if (expectedType === "regexp") {
+    result = expected.test(errorString(actual));
+    expected = String(expected);
+  } else if (expectedType === "function" && expected.prototype !== void 0 && actual instanceof expected) {
+    result = true;
+  } else if (expectedType === "object") {
+    result = actual instanceof expected.constructor && actual.name === expected.name && actual.message === expected.message;
+    expected = errorString(expected);
+  } else if (expectedType === "function") {
+    try {
+      result = expected.call({}, actual) === true;
+      expected = null;
+    } catch (e) {
+      expected = errorString(e);
     }
-    else if (expectedType === 'function' &&
-        expected.prototype !== undefined &&
-        actual instanceof expected) {
-        result = true;
-        // Expected is an Error object
-    }
-    else if (expectedType === 'object') {
-        result =
-            actual instanceof expected.constructor &&
-                actual.name === expected.name &&
-                actual.message === expected.message;
-        // Log the string form of the Error object
-        expected = errorString(expected);
-        // Expected is a validation function which returns true if validation passed
-    }
-    else if (expectedType === 'function') {
-        // protect against accidental semantics which could hard error in the test
-        try {
-            result = expected.call({}, actual) === true;
-            expected = null;
-        }
-        catch (e) {
-            // assign the "expected" to a nice error string to communicate the local failure to the user
-            expected = errorString(e);
-        }
-    }
-    return [result, expected, message];
+  }
+  return [result, expected, message];
 }
 function errorString(error) {
-    // Use String() instead of toString() to handle non-object values like undefined or null.
-    const resultErrorString = String(error);
-    // If the error wasn't a subclass of Error but something like
-    // an object literal with name and message properties...
-    if (resultErrorString.slice(0, 7) === '[object') {
-        // Based on https://es5.github.io/#x15.11.4.4
-        return ((error.name || 'Error') +
-            (error.message
-                ? ': '.concat(error.message)
-                : ''));
-    }
-    else {
-        return resultErrorString;
-    }
+  const resultErrorString = String(error);
+  if (resultErrorString.slice(0, 7) === "[object") {
+    return (error.name || "Error") + (error.message ? ": ".concat(error.message) : "");
+  } else {
+    return resultErrorString;
+  }
 }
-export default { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException };
+var shared_default = { objectValues, objectValuesSubset, validateExpectedExceptionArgs, validateException };
+export {
+  shared_default as default,
+  objectType,
+  objectValues,
+  objectValuesSubset,
+  validateException,
+  validateExpectedExceptionArgs
+};

package/dist/shared/module-context.js

@@ -1,28 +1,29 @@
 import TestContext from "./test-context.js";
-export default class ModuleContext {
-    static Assert;
-    static currentModuleChain = [];
-    static get lastModule() {
-        return this.currentModuleChain[this.currentModuleChain.length - 1];
-    }
-    name;
-    assert;
-    userContext;
-    // Internal fallback assert for modules with no direct tests
-    context = new TestContext();
-    moduleChain = [];
-    beforeEachHooks = [];
-    afterEachHooks = [];
-    tests = [];
-    constructor(name) {
-        const parentModule = ModuleContext.currentModuleChain[ModuleContext.currentModuleChain.length - 1];
-        ModuleContext.currentModuleChain.push(this);
-        this.moduleChain = ModuleContext.currentModuleChain.slice(0);
-        this.name = parentModule ? `${parentModule.name} > ${name}` : name;
-        this.assert = new ModuleContext.Assert(this);
-        // User context uses prototype chain from parent module for proper QUnit-style inheritance:
-        // parent before() sets props on parent userContext, child tests inherit via prototype.
-        this.userContext = parentModule ? Object.create(parentModule.userContext) : Object.create(null);
-        return Object.freeze(this);
-    }
+class ModuleContext {
+  static Assert;
+  static currentModuleChain = [];
+  static get lastModule() {
+    return this.currentModuleChain[this.currentModuleChain.length - 1];
+  }
+  name;
+  assert;
+  userContext;
+  // Internal fallback assert for modules with no direct tests
+  context = new TestContext();
+  moduleChain = [];
+  beforeEachHooks = [];
+  afterEachHooks = [];
+  tests = [];
+  constructor(name) {
+    const parentModule = ModuleContext.currentModuleChain[ModuleContext.currentModuleChain.length - 1];
+    ModuleContext.currentModuleChain.push(this);
+    this.moduleChain = ModuleContext.currentModuleChain.slice(0);
+    this.name = parentModule ? `${parentModule.name} > ${name}` : name;
+    this.assert = new ModuleContext.Assert(this);
+    this.userContext = parentModule ? Object.create(parentModule.userContext) : /* @__PURE__ */ Object.create(null);
+    return Object.freeze(this);
+  }
 }
+export {
+  ModuleContext as default
+};

package/dist/shared/test-context.js

@@ -1,94 +1,95 @@
-export default 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;
-    }
-    #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.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) {
-            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) {
-            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}`,
-            });
-        }
-    }
+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;
+  }
+  #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.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) {
+      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) {
+      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}`
+      });
+    }
+  }
 }
+export {
+  TestContext as default
+};

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -93,6 +93,7 @@
     "changelog:update": "git-cliff --output CHANGELOG.md",
     "prepare": "npm run build",
     "test": "npm run test:browser && npm run test:node && npm run test:deno",
+    "test:release": "bash scripts/test-release.sh",
     "test:dev": "npm run test | tee test-output.log",
     "test:browser": "qunitx test/index.ts --debug",
     "test:deno": "deno test --allow-read --allow-run test/index.ts",

package/shims/deno/index.ts

@@ -109,7 +109,7 @@ export { Assert };
  * });
  * ```
  */
-export const module = Module;
+export { default as module } from './module.ts';
 
 /**
  * Defines an individual test. Wraps Deno's `it()` and handles the full QUnit
@@ -139,7 +139,7 @@ export const module = Module;
  * });
  * ```
  */
-export const test = Test;
+export { default as test } from './test.ts';
 
 /**
  * The default export provides the full QUnitX API as a single object.
@@ -166,4 +166,4 @@ export const test = Test;
  * @property {object} config - Runtime configuration object (currently unused; reserved
  *   for future QUnit config compatibility).
  */
-export default { AssertionError: Assert.AssertionError, module, test, config: {} };
+export default { AssertionError: Assert.AssertionError, module: Module, test: Test, config: {} };

package/shims/deno/module.ts

@@ -32,6 +32,9 @@ 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;
+/** 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 | ((hooks: HooksObject<Assert>) => void),

package/shims/deno/test.ts

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

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

@@ -1,7 +1,42 @@
-// Type stub for jsr:@std/assert. Deno resolves the real module at runtime.
+// Auto-generated by build.ts from jsr:@std/assert. Do not edit manually.
+// deno-lint-ignore-file no-explicit-any
 declare module 'jsr:@std/assert' {
+  function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+  type ArrayLikeArg<T> = ArrayLike<T> & object;
+  function assertArrayIncludes<T>(actual: ArrayLikeArg<T>, expected: ArrayLikeArg<T>, msg?: string): void;
+  function assertEquals<T>(actual: T, expected: T, msg?: string): void;
+  function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable;
+  type Falsy = false | 0 | unknown | "" | null | undefined;
+  function assertFalse(expr: unknown, _): asserts expr is Falsy;
+  function assertGreaterOrEqual<T>(actual: T, expected: T, msg?: string): void;
+  function assertGreater<T>(actual: T, expected: T, msg?: string): void;
+  type AnyConstructor = (...args: any[]) => any;
+  type GetConstructorType<T extends AnyConstructor> = InstanceType<T>;
+  function assertInstanceOf<T extends (...args: any[]) => any>(actual: unknown, expectedType: T, _): asserts actual is InstanceType;
+  function assertIsError<E extends Error>(error: unknown, ErrorClass?: (...args: any[]) => E, msgMatches?: string | RegExp, msg?: string): asserts error is E;
+  function assertLessOrEqual<T>(actual: T, expected: T, msg?: string): void;
+  function assertLess<T>(actual: T, expected: T, msg?: string): void;
+  function assertMatch(actual: string, expected: RegExp, msg?: string): void;
+  function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
+  function assertNotInstanceOf<A, T>(actual: A, unexpectedType: (...args: any[]) => T, msg?: string): asserts actual is Exclude;
+  function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
+  function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+  function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;
+  function assertRejects(fn: () => PromiseLike<unknown>, msg?: string): Promise<unknown>;
+  function assertRejects<E extends Error>(fn: () => PromiseLike<unknown>, ErrorClass: (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;
+  function assertRejects<E extends Error>(fn: () => PromiseLike<unknown>, errorClassOrMsg?: ((...args: any[]) => E) | string, msgIncludesOrMsg?: string, msg?: string): Promise<E | Error | unknown>;
+  function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
+  function assertStringIncludes(actual: string, expected: string, msg?: string): void;
+  function assertThrows(fn: () => unknown, msg?: string): unknown;
+  function assertThrows<E extends Error>(fn: () => unknown, ErrorClass: (...args: any[]) => E, msgIncludes?: string, msg?: string): E;
+  function assertThrows<E extends Error>(fn: () => unknown, errorClassOrMsg?: ((...args: any[]) => E) | string, msgIncludesOrMsg?: string, msg?: string): E | Error | unknown;
+  function assert(expr: unknown, _): asserts expr;
   class AssertionError extends Error {
-    constructor(message?: string);
+    constructor(message: string, options?: ErrorOptions);
   }
-  export { AssertionError };
+  function equal(a: unknown, b: unknown): boolean;
+  function fail(msg?: string): never;
+  function unimplemented(msg?: string): never;
+  function unreachable(msg?: string): never;
+  export { assertAlmostEquals, ArrayLikeArg, assertArrayIncludes, assertEquals, assertExists, Falsy, assertFalse, assertGreaterOrEqual, assertGreater, AnyConstructor, GetConstructorType, assertInstanceOf, assertIsError, assertLessOrEqual, assertLess, assertMatch, assertNotEquals, assertNotInstanceOf, assertNotMatch, assertNotStrictEquals, assertObjectMatch, assertRejects, assertStrictEquals, assertStringIncludes, assertThrows, assert, AssertionError, equal, fail, unimplemented, unreachable };
 }