qunitx 0.12.0 → 0.12.4

package/README.md

@@ -1,156 +1,235 @@
-![docker-based-ci](https://github.com/izelnakri/qunitx/workflows/docker-based-ci/badge.svg)
-[![npm version](https://badge.fury.io/js/qunitx.svg)](https://badge.fury.io/js/qunitx)
-[![Ask me anything](https://img.shields.io/badge/ask%20me-anything-1abc9c.svg)](https://github.com/izelnakri/qunitx/issues)
+<div align="center">
 
 # QUnitX
 
-Mature, fast, 0 dependency & flexible test API for JavaScript/TypeScript.
+[![CI](https://github.com/izelnakri/qunitx/actions/workflows/ci.yml/badge.svg)](https://github.com/izelnakri/qunitx/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/izelnakri/qunitx/branch/main/graph/badge.svg)](https://codecov.io/gh/izelnakri/qunitx)
+[![npm](https://img.shields.io/npm/v/qunitx)](https://www.npmjs.com/package/qunitx)
+[![npm downloads](https://img.shields.io/npm/dm/qunitx)](https://www.npmjs.com/package/qunitx)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+[![Ask me anything](https://img.shields.io/badge/ask%20me-anything-1abc9c.svg)](https://github.com/izelnakri/qunitx/issues)
+[![Sponsor](https://img.shields.io/badge/sponsor-%E2%99%A5-pink)](https://github.com/sponsors/izelnakri)
 
-***Universal testing for JavaScript with the oldest, most mature & flexible
-testing API in the JavaScript ecosystem. Run the same test file in node.js, deno or in the browser***
+</div>
 
-Your test JS/TS file(s) can now run interchangably in different runtimes with
-the default test runner of node.js or deno, or with a browser runner of your
-choice!
+**The oldest, most battle-tested JavaScript test API — now universal.**
 
-[![asciicast](https://asciinema.org/a/597066.svg)](https://asciinema.org/a/597066?autoplay=1)
+Run the **same test file** in Node.js, Deno, and the browser without changes.
+Zero dependencies. No config needed for Node. TypeScript works out of the box.
 
-In the browser you can use the same browser test/filter UI of
-[QUnit](https://github.com/qunitjs/qunit) and share the web links with your
-colleagues thanks to the test filters through query params feature of QUnit:
+---
 
-[QUnit Test Suite Example](https://objectmodel.js.org/test/?moduleId=6e15ed5f&moduleId=950ec9c5)
+## Why QUnit?
 
-**UI visual automated tests also possible with QUnit!**
+QUnit was created in 2008 by the jQuery team. While newer frameworks come and go,
+QUnit has quietly accumulated 16+ years of real-world edge-case handling that younger
+tools are still catching up to. Its assertion API is the most mature in the JavaScript
+ecosystem:
 
-![QunitX terminal output](https://raw.githubusercontent.com/izelnakri/qunitx/main/docs/qunitx-help-stdout.png)
+- **`assert.deepEqual`** — handles circular references, prototype chains, Sets, Maps,
+  typed arrays, Dates, RegExps, and getters correctly
+- **`assert.throws` / `assert.rejects`** — match errors by constructor, regex, or custom validator
+- **`assert.step` / `assert.verifySteps`** — declarative execution-order verification;
+  catches missing async callbacks that other frameworks silently swallow
+- **`assert.expect(n)`** — fails the test if exactly _n_ assertions didn't run;
+  invaluable for async code where missing assertions would otherwise pass silently
+- **Hooks** — `before`, `beforeEach`, `afterEach`, `after` with correct FIFO/LIFO ordering,
+  properly scoped across nested modules
+- **Shareable browser URLs** — the QUnit browser UI filters tests via query params, so you can
+  share `https://yourapp.test/?moduleId=abc123` with a colleague and they see exactly the same view
 
-### Installation: Node & Deno
+QUnitX wraps this API to work with **Node.js's built-in `node:test` runner** and
+**Deno's native test runner** — no Jest, Vitest, or other framework needed.
 
-This is a 0-dependency test library that runs code in your target runtime(node,
-deno or browser) test runner. Since a default test runner is a new feature of node.js, please use node.js v20.3+.
+QUnit includes the fastest assertion and test runtime in JS world. I've previously contributed to some [speed optimizations](https://qunitjs.com/blog/2022/02/15/qunit-2-18-0/) to QUnit, we benchmark every possible thing to make it the fastest test
+runtime, faster than node.js and deno default assertions in most cases. Therefore I consider myself very objective
+when I say QUnit(X) is the best JS/TS testing tool out there.
 
-In order to use qunitx to convert qunit tests files please change:
+---
 
-```js
-import { module, test } from 'qunit';
+## Demo
 
-// to:
-import { module, test } from 'qunitx';
+> Left window: `node --test` and `deno test` running the same file.
+> Right window: QUnit browser UI with filterable, shareable test results.
+
+<!-- Demo GIF: see docs/demo.tape (VHS script) for terminal portion.
+     For the combined terminal + browser recording, see "Recording the demo" below. -->
+![QUnitX demo](https://raw.githubusercontent.com/izelnakri/qunitx/main/docs/demo.gif)
+
+Live browser UI example (click to see filterable QUnit test suite):
+
+[objectmodel.js.org/test/?moduleId=6e15ed5f](https://objectmodel.js.org/test/?moduleId=6e15ed5f&moduleId=950ec9c5)
+
+---
+
+## Installation
+
+```sh
+npm install qunitx --save-dev
 ```
 
-Example:
+Requires **Node.js >= 22** (LTS) or **Deno >= 2**.
+
+---
+
+## Quick start
 
 ```js
-// in some-test.js: (typescript also works)
+// math-test.js  (works in Node, Deno, and browser unchanged)
 import { module, test } from 'qunitx';
-import $ from 'jquery';
 
-module('Basic sanity check', function (hooks) {
-  test('it works', function (assert) {
-    assert.equal(true, true);
+module('Math utilities', (hooks) => {
+  hooks.before((assert) => {
+    assert.step('setup complete');
   });
 
-  module('More advanced cases', function (hooks) {
-    test('deepEqual works', function (assert) {
-      assert.deepEqual({ username: 'izelnakri' }, { username: 'izelnakri' });
-    });
-    test('can import ES & npm modules', function (assert) {
-      assert.ok(Object.keys($));
+  test('addition', (assert) => {
+    assert.equal(2 + 2, 4);
+    assert.notEqual(2 + 2, 5);
+  });
+
+  test('deepEqual', (assert) => {
+    assert.deepEqual({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] });
+  });
+
+  module('Async', () => {
+    test('resolves correctly', async (assert) => {
+      const result = await Promise.resolve(42);
+      assert.strictEqual(result, 42);
     });
   });
 });
 ```
 
-```zsh
-# you can run the test in node with ES modules package.json{ "type": "module" }
-$ node --test some-test.js
+### Node.js
+
+```sh
+# No extra dependencies — uses the Node built-in test runner
+node --test math-test.js
+
+# Watch mode (re-runs on save)
+node --test --watch math-test.js
+
+# Glob pattern
+node --test --watch 'test/**/*.js'
+
+# TypeScript (tsconfig.json with moduleResolution: NodeNext required)
+node --import=tsx/esm --test math-test.ts
+
+# Code coverage
+npx c8 node --test math-test.js
+```
 
-# TypeScript also works, make sure on node.js mode, tsconfig.json exists with compilerOptions.module & compilerOptions.moduleResolution set to "NodeNext":
-$ node --loader=ts-node/esm/transpile-only --test some-test.ts
+### Deno
 
-# You can use the new watch mode of node.js to watch for files or folder patterns
-$ node --test --watch some-test.js some-folder/*.js
+```sh
+# One-time: create a deno.json import map
+echo '{"imports": {"qunitx": "https://esm.sh/qunitx/shims/deno/index.js"}}' > deno.json
 
-# You can also run this test on deno. Unfortunately today deno requires one extra step to create a deno.json file:
-$ echo '{"imports": { "qunitx": "https://esm.sh/qunitx/shims/deno/index.js" } }' > deno.json
+# Run
+deno test math-test.js
 
-# then run the tests in default deno test runner:
-$ deno test some-test.js
+# With explicit permissions
+deno test --allow-read --allow-env math-test.js
 ```
 
-### Installation: Browser
+### Browser
 
-QUnitX mainly proxies to [QUnit
-API](https://api.qunitjs.com/QUnit/module/#hooks-on-nested-modules) in browser.
-You can use [QUnitX CLI](https://github.com/izelnakri/qunitx-cli) to get your
-browser tests to stdout/CI or use the watch mode during the development.
+Use [qunitx-cli](https://github.com/izelnakri/qunitx-cli) to get browser test output
+in your terminal / CI, or to open the live QUnit UI during development:
 
-```zsh
-# Install QUnitX browser runner/cli:
-$ npm install -g qunitx-cli
-$ qunitx
-$ qunitx some-test.js
+```sh
+npm install -g qunitx-cli
 
-# with browser output enabled:
-$ qunitx some-test.js --debug
+# Headless (CI-friendly — outputs TAP to stdout)
+qunitx math-test.js
 
+# Open QUnit browser UI alongside terminal output
+qunitx math-test.js --debug
 ```
 
-### Concurrency options
+The browser UI lets you:
+- Filter by module or test name (filter state is preserved in the URL)
+- Share a link that reproduces the exact filtered view with a colleague
+- Re-run individual tests by clicking them
+- See full assertion diffs inline
 
-QUnitX API accepts an optional options object as 2nd argument to:
-- `QUnit.module(testName, optionsOrHandler?, handler?)`
-- `QUnit.test(testName, optionsOrHandler?, handler?)`
+---
 
-So you can run tests in parallel(default) or in series. You can even run them
-through the [node.js test runner run()
-api](https://nodejs.org/api/test.html#runoptions):
+## Migrating from QUnit
+
+One import line is all that changes:
 
 ```js
-// in some-test.js: (typescript also works)
+// Before:
+import { module, test } from 'qunit';
+
+// After:
 import { module, test } from 'qunitx';
-import $ from 'jquery';
+```
 
-module('Basic sanity check', function (hooks) {
-  test('it works', { concurrency: false }, function (assert) {
-    assert.equal(true, true);
-  });
+---
 
-  module('More advanced cases', { concurrency: false, permissions: { read: true }, sanitizeExit: false }, function (hooks) {
-    test('deepEqual works', function (assert) {
-      assert.deepEqual({ username: 'izelnakri' }, { username: 'izelnakri' });
-    });
-    test('can import ES & npm modules', function (assert) {
-      assert.ok(Object.keys($));
-    });
+## Concurrency options
+
+`module()` and `test()` accept an optional options object forwarded directly to the underlying
+Node / Deno test runner:
+
+```js
+import { module, test } from 'qunitx';
+
+// Run tests in this module serially
+module('Serial suite', { concurrency: false }, (hooks) => {
+  test('first', (assert) => { assert.ok(true); });
+  test('second', (assert) => { assert.ok(true); });
+});
+
+// Deno-specific: permissions, sanitizeExit, etc.
+module('Deno file access', { permissions: { read: true }, sanitizeExit: false }, (hooks) => {
+  test('reads a file', async (assert) => {
+    const text = await Deno.readTextFile('./README.md');
+    assert.ok(text.length > 0);
   });
 });
 ```
 
-### Code coverage
+---
+
+## How it works
+
+| Runtime | Adapter |
+|---------|---------|
+| Node.js | Wraps `node:test` `describe` / `it` with QUnit lifecycle |
+| Deno | Wraps Deno BDD helpers with the same QUnit lifecycle |
+| Browser | Thin re-export of QUnit's native browser API |
+
+The browser path is literally QUnit itself, so you get full QUnit compatibility:
+plugins, custom reporters, the event API (`QUnit.on`, `QUnit.done`, etc.), and the
+familiar browser UI with zero extra layers.
+
+---
 
-Since QUnitX proxies to default node.js test runner in when executed with node,
-you can use any code coverage tool you like. When running the tests in
-`qunit`(the browser mode) code coverage support is limited.
+## Code coverage
 
-```zsh
-$ c8 node --test test/attachments test/user
+Probably c8 isn't even needed since qunitx runs as a dependency(rather than runtime) on node.js and deno.
+
+```sh
+# Node (any c8-compatible reporter)
+npx c8 node --test test/
+
+# View HTML report
+npx c8 --reporter=html node --test test/ && open coverage/index.html
 ```
 
-You can browse [c8 documentation](https://github.com/bcoe/c8) for all
-configuration options.
-
-Implementing code coverage for the browser mode is currently not possible
-because we use esbuild --bundle feature to create a JS bundles for testing in
-the browser, this could be instrumented with `puppeteer-to-istanbul` however
-instrumentation includes transpiled npm imports of `qunitx` and other potential
-npm imports developer includes in the code, this cannot be filtered since
-potential filtering can only occur after the `esbuild` bundling. When chrome
-browser and puppeteer fully supports ES asset maps we can remove esbuild from
-the browser mode, run everything in deno and make instrumentation for code
-coverage possible with the default v8 instrumentation.
-
-Esbuild plugin interface is an ongoing development, we might be able to figure
-out a way to generate this instrumentation with esbuild in the future, which
-could allow code coverage for --browser mode.
+Browser-mode coverage is limited because qunitx-cli bundles test files with esbuild.
+Native ES import maps support in Puppeteer/Chrome would eliminate the bundling step
+and unlock v8 instrumentation for browser coverage.
+
+---
+
+## Links
+
+- [QUnit API reference](https://api.qunitjs.com)
+- [qunitx-cli](https://github.com/izelnakri/qunitx-cli) — browser runner / CI reporter
+- [Node.js test runner docs](https://nodejs.org/api/test.html)
+- [Deno testing docs](https://docs.deno.com/runtime/fundamentals/testing/)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx",
   "type": "module",
-  "version": "0.12.0",
+  "version": "0.12.4",
   "description": "A universal test framework for testing any js file on node.js, browser or deno with QUnit API",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -44,7 +44,7 @@
     "browser"
   ],
   "engines": {
-    "node": ">=24.0.0"
+    "node": ">=22.0.0"
   },
   "imports": {
     "qunitx": {
@@ -60,11 +60,13 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/izelnakri/qunitx.git"
+    "url": "git+https://github.com/izelnakri/qunitx.git"
   },
   "scripts": {
-    "lint": "prettier --check \"test/**/*.js\" \"*.js\" \"package.json\"",
-    "lint:fix": "prettier --write \"test/**/*.js\" \"*.js\" \"package.json\"",
+    "format": "prettier --check \"test/**/*.js\" \"*.js\" \"package.json\"",
+    "format:fix": "prettier --write \"test/**/*.js\" \"*.js\" \"package.json\"",
+    "lint": "deno lint shims/",
+    "lint:docs": "deno doc --lint shims/deno/module.js shims/deno/test.js",
     "build": "node build.js",
     "run:all": "npm run run:node && npm run run:deno",
     "run:node": "node --test test/helpers/passing-tests.js && node --test test/helpers/failing-tests.js",
@@ -75,9 +77,13 @@
     "prepack": "npm run build",
     "test": "npm run test:browser && npm run test:node && npm run test:deno",
     "test:dev": "npm run test | tee test-output.log",
-    "test:browser": "node_modules/.bin/qunitx test/index.js --debug",
+    "test:browser": "qunitx test/index.js --debug",
     "test:deno": "deno test --allow-read --allow-env --allow-run test/index.js",
-    "test:node": "node --test test/index.js"
+    "test:doctests": "deno test --doc --allow-env --allow-read shims/deno/module.js shims/deno/test.js",
+    "test:node": "node --test test/index.js",
+    "coverage": "deno test --coverage=tmp/coverage --allow-read --allow-env --allow-run test/index.js && deno coverage --lcov --output=tmp/coverage/lcov.info --include='shims/' tmp/coverage && node scripts/check-coverage.js",
+    "coverage:report": "npm run coverage && deno coverage --html --include='shims/' tmp/coverage",
+    "docs": "deno doc --html --name=\"QUnitX\" --output=docs/src shims/deno/index.js"
   },
   "devDependencies": {
     "prettier": "^3.8.1",

package/scripts/check-coverage.js

@@ -0,0 +1,15 @@
+import { readFile } from 'node:fs/promises';
+
+const THRESHOLD = 85;
+const lcov = await readFile('tmp/coverage/lcov.info', 'utf8');
+
+const lh = [...lcov.matchAll(/^LH:(\d+)/gm)].reduce((s, m) => s + parseInt(m[1]), 0);
+const lf = [...lcov.matchAll(/^LF:(\d+)/gm)].reduce((s, m) => s + parseInt(m[1]), 0);
+const pct = lf > 0 ? (lh / lf) * 100 : 0;
+
+console.log(`Coverage: ${pct.toFixed(1)}% (${lh}/${lf} lines)`);
+
+if (pct < THRESHOLD) {
+  console.error(`Error: coverage ${pct.toFixed(1)}% is below the ${THRESHOLD}% threshold.`);
+  process.exit(1);
+}

package/shims/deno/index.js

@@ -1,4 +1,4 @@
-import { AssertionError as DenoAssertionError } from "https://deno.land/std@0.192.0/testing/asserts.ts";
+import { AssertionError as DenoAssertionError } from "jsr:@std/assert";
 import '../../vendor/qunit.js';
 import Assert from '../shared/assert.js';
 import ModuleContext from '../shared/module-context.js';

package/shims/deno/module.js

@@ -1,18 +1,45 @@
-import { describe, beforeAll, afterAll } from "https://deno.land/std@0.192.0/testing/bdd.ts";
+import { describe, beforeAll, afterAll } from "jsr:@std/testing/bdd";
 import ModuleContext from '../shared/module-context.js';
 
 // NOTE: node.js beforeEach & afterEach is buggy because the TestContext it has is NOT correct reference when called, it gets the last context
 // NOTE: QUnit expect() logic is buggy in nested modules
 // NOTE: after gets the last direct children test of the module, not last defined context of a module(last defined context is a module)
 
+/**
+ * Defines a test module (suite) for Deno's BDD test runner.
+ *
+ * Wraps `describe()` from `@std/testing/bdd` and sets up the QUnit lifecycle
+ * (before/beforeEach/afterEach/after hooks, assertion counting, steps tracking).
+ *
+ * @param {string} moduleName - Name of the test suite
+ * @param {object} [runtimeOptions] - Optional Deno BDD options forwarded to `describe()`
+ *   (e.g. `{ concurrency: false }`, `{ permissions: { read: true } }`)
+ * @param {function} moduleContent - Callback that defines tests and hooks via `hooks.before`,
+ *   `hooks.beforeEach`, `hooks.afterEach`, `hooks.after`
+ * @returns {void}
+ * @example
+ * ```js ignore
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", (hooks) => {
+ *   hooks.before((assert) => {
+ *     assert.step("before hook ran");
+ *   });
+ *
+ *   test("addition", (assert) => {
+ *     assert.equal(2 + 2, 4);
+ *   });
+ * });
+ * ```
+ */
 export default function module(moduleName, runtimeOptions, moduleContent) {
-  let targetRuntimeOptions = moduleContent ? runtimeOptions : {};
-  let targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
-  let moduleContext = new ModuleContext(moduleName);
+  const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
+  const targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
+  const moduleContext = new ModuleContext(moduleName);
 
-  return describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, async function () {
-    let beforeHooks = [];
-    let afterHooks = [];
+  describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, function () {
+    const beforeHooks = [];
+    const afterHooks = [];
 
     beforeAll(async function () {
       Object.assign(moduleContext.context, moduleContext.moduleChain.reduce((result, module) => {
@@ -24,7 +51,7 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
         });
       }, { steps: [], expectedAssertionCount: undefined }));
 
-      for (let hook of beforeHooks) {
+      for (const hook of beforeHooks) {
         await hook.call(moduleContext.context, moduleContext.assert);
       }
 
@@ -41,7 +68,7 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
         await assert.waitForAsyncOps();
       }
 
-      let targetContext = moduleContext.tests[moduleContext.tests.length - 1];
+      const targetContext = moduleContext.tests[moduleContext.tests.length - 1];
       for (let j = afterHooks.length - 1; j >= 0; j--) {
         await afterHooks[j].call(targetContext, targetContext.assert);
       }

package/shims/deno/test.js

@@ -1,30 +1,59 @@
-import { it } from "https://deno.land/std@0.192.0/testing/bdd.ts";
+import { it } from "jsr:@std/testing/bdd";
 import TestContext from '../shared/test-context.js';
 import ModuleContext from '../shared/module-context.js';
 
+/**
+ * Defines an individual test within a module for Deno's BDD test runner.
+ *
+ * Wraps `it()` from `@std/testing/bdd` and handles the full QUnit lifecycle:
+ * beforeEach/afterEach hooks, async assertion waiting, and step verification.
+ *
+ * Must be called inside a `module()` callback.
+ *
+ * @param {string} testName - Name of the test
+ * @param {object} [runtimeOptions] - Optional Deno BDD options forwarded to `it()`
+ *   (e.g. `{ concurrency: false }`, `{ sanitizeExit: false }`)
+ * @param {function} testContent - Test callback receiving `(assert, { testName, options })`
+ * @returns {void}
+ * @example
+ * ```js ignore
+ * import { module, test } from "qunitx";
+ *
+ * module("Math", () => {
+ *   test("addition", (assert) => {
+ *     assert.equal(1 + 1, 2);
+ *   });
+ *
+ *   test("async resolves correctly", async (assert) => {
+ *     const result = await Promise.resolve(42);
+ *     assert.strictEqual(result, 42);
+ *   });
+ * });
+ * ```
+ */
 export default function test(testName, runtimeOptions, testContent) {
-  let moduleContext = ModuleContext.lastModule;
+  const moduleContext = ModuleContext.lastModule;
   if (!moduleContext) {
     throw new Error(`Test '${testName}' called outside of module context.`);
   }
 
-  let targetRuntimeOptions = testContent ? runtimeOptions : {};
-  let targetTestContent = testContent ? testContent : runtimeOptions;
-  let context = new TestContext(testName, moduleContext);
+  const targetRuntimeOptions = testContent ? runtimeOptions : {};
+  const targetTestContent = testContent ? testContent : runtimeOptions;
+  const context = new TestContext(testName, moduleContext);
 
-  return it(testName, { concurrency: true, ...targetRuntimeOptions }, async function () {
-    for (let module of context.module.moduleChain) {
-      for (let hook of module.beforeEachHooks) {
+  it(testName, { concurrency: true, ...targetRuntimeOptions }, async function () {
+    for (const module of context.module.moduleChain) {
+      for (const hook of module.beforeEachHooks) {
         await hook.call(context, context.assert);
       }
     }
 
-    let result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
 
     await context.assert.waitForAsyncOps();
 
     for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
-      let module = context.module.moduleChain[i];
+      const module = context.module.moduleChain[i];
       for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
         await module.afterEachHooks[j].call(context, context.assert);
       }

package/shims/node/module.js

@@ -6,13 +6,13 @@ import ModuleContext from '../shared/module-context.js';
 // NOTE: after gets the last direct children test of the module, not last defined context of a module(last defined context is a module)
 
 export default function module(moduleName, runtimeOptions, moduleContent) {
-  let targetRuntimeOptions = moduleContent ? runtimeOptions : {};
-  let targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
-  let moduleContext = new ModuleContext(moduleName);
+  const targetRuntimeOptions = moduleContent ? runtimeOptions : {};
+  const targetModuleContent = moduleContent ? moduleContent : runtimeOptions;
+  const moduleContext = new ModuleContext(moduleName);
 
-  return describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, async function () {
-    let beforeHooks = [];
-    let afterHooks = [];
+  return describe(moduleName, { concurrency: true, ...targetRuntimeOptions }, function () {
+    const beforeHooks = [];
+    const afterHooks = [];
 
     beforeAll(async function () {
       Object.assign(moduleContext.context, moduleContext.moduleChain.reduce((result, module) => {
@@ -24,7 +24,7 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
         });
       }, { steps: [], expectedAssertionCount: undefined }));
 
-      for (let hook of beforeHooks) {
+      for (const hook of beforeHooks) {
         await hook.call(moduleContext.context, moduleContext.assert);
       }
 
@@ -41,7 +41,7 @@ export default function module(moduleName, runtimeOptions, moduleContent) {
         await assert.waitForAsyncOps();
       }
 
-      let targetContext = moduleContext.tests[moduleContext.tests.length - 1];
+      const targetContext = moduleContext.tests[moduleContext.tests.length - 1];
       for (let j = afterHooks.length - 1; j >= 0; j--) {
         await afterHooks[j].call(targetContext, targetContext.assert);
       }

package/shims/node/test.js

@@ -3,28 +3,28 @@ import TestContext from '../shared/test-context.js';
 import ModuleContext from '../shared/module-context.js';
 
 export default function test(testName, runtimeOptions, testContent) {
-  let moduleContext = ModuleContext.lastModule;
+  const moduleContext = ModuleContext.lastModule;
   if (!moduleContext) {
     throw new Error(`Test '${testName}' called outside of module context.`);
   }
 
-  let targetRuntimeOptions = testContent ? runtimeOptions : {};
-  let targetTestContent = testContent ? testContent : runtimeOptions;
-  let context = new TestContext(testName, moduleContext);
+  const targetRuntimeOptions = testContent ? runtimeOptions : {};
+  const targetTestContent = testContent ? testContent : runtimeOptions;
+  const context = new TestContext(testName, moduleContext);
 
   return it(testName, { concurrency: true, ...targetRuntimeOptions }, async function () {
-    for (let module of context.module.moduleChain) {
-      for (let hook of module.beforeEachHooks) {
+    for (const module of context.module.moduleChain) {
+      for (const hook of module.beforeEachHooks) {
         await hook.call(context, context.assert);
       }
     }
 
-    let result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
+    const result = await targetTestContent.call(context, context.assert, { testName, options: runtimeOptions });
 
     await context.assert.waitForAsyncOps();
 
     for (let i = context.module.moduleChain.length - 1; i >= 0; i--) {
-      let module = context.module.moduleChain[i];
+      const module = context.module.moduleChain[i];
       for (let j = module.afterEachHooks.length - 1; j >= 0; j--) {
         await module.afterEachHooks[j].call(context, context.assert);
       }

package/shims/shared/assert.js

@@ -55,13 +55,13 @@ export default class Assert {
   }
   async() {
     let resolveFn;
-    let done = new Promise(resolve => { resolveFn = resolve; });
+    const done = new Promise(resolve => { resolveFn = resolve; });
 
     this.test.asyncOps.push(done);
 
     return () => { resolveFn(); };
   }
-  async waitForAsyncOps() {
+  waitForAsyncOps() {
     return Promise.all(this.test.asyncOps);
   }
   pushResult(resultInfo = {}) {
@@ -147,8 +147,8 @@ export default class Assert {
   }
   propEqual(actual, expected, message) {
     this._incrementAssertionCount();
-    let targetActual = objectValues(actual);
-    let targetExpected = objectValues(expected);
+    const targetActual = objectValues(actual);
+    const targetExpected = objectValues(expected);
     if (!Assert.QUnit.equiv(targetActual, targetExpected)) {
       throw new Assert.AssertionError({
         actual: targetActual,
@@ -160,8 +160,8 @@ export default class Assert {
   }
   notPropEqual(actual, expected, message) {
     this._incrementAssertionCount();
-    let targetActual = objectValues(actual);
-    let targetExpected = objectValues(expected);
+    const targetActual = objectValues(actual);
+    const targetExpected = objectValues(expected);
     if (Assert.QUnit.equiv(targetActual, targetExpected)) {
       throw new Assert.AssertionError({
         actual: targetActual,
@@ -173,8 +173,8 @@ export default class Assert {
   }
   propContains(actual, expected, message) {
     this._incrementAssertionCount();
-    let targetActual = objectValuesSubset(actual, expected);
-    let targetExpected = objectValues(expected, false);
+    const targetActual = objectValuesSubset(actual, expected);
+    const targetExpected = objectValues(expected, false);
     if (!Assert.QUnit.equiv(targetActual, targetExpected)) {
       throw new Assert.AssertionError({
         actual: targetActual,
@@ -186,8 +186,8 @@ export default class Assert {
   }
   notPropContains(actual, expected, message) {
     this._incrementAssertionCount();
-    let targetActual = objectValuesSubset(actual, expected);
-    let targetExpected = objectValues(expected);
+    const targetActual = objectValuesSubset(actual, expected);
+    const targetExpected = objectValues(expected);
     if (Assert.QUnit.equiv(targetActual, targetExpected)) {
       throw new Assert.AssertionError({
         actual: targetActual,
@@ -247,7 +247,7 @@ export default class Assert {
   }
   throws(blockFn, expectedInput, assertionMessage) {
     this?._incrementAssertionCount();
-    let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
+    const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
     if (typeof blockFn !== 'function') {
       throw new Assert.AssertionError({
         actual: blockFn,
@@ -260,7 +260,7 @@ export default class Assert {
     try {
       blockFn();
     } catch (error) {
-      let validation = validateException(error, expected, message);
+      const validation = validateException(error, expected, message);
       if (validation.result === false) {
         throw new Assert.AssertionError({
           actual: validation.result,
@@ -282,8 +282,8 @@ export default class Assert {
   }
   async rejects(promise, expectedInput, assertionMessage) {
     this._incrementAssertionCount();
-    let [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
-    let then = promise && promise.then;
+    const [expected, message] = validateExpectedExceptionArgs(expectedInput, assertionMessage, 'rejects');
+    const then = promise && promise.then;
     if (typeof then !== 'function') {
       throw new Assert.AssertionError({
         actual: promise,
@@ -302,7 +302,7 @@ export default class Assert {
         stackStartFn: this.rejects,
       });
     } catch (error) {
-      let validation = validateException(error, expected, message);
+      const validation = validateException(error, expected, message);
       if (validation.result === false) {
         throw new Assert.AssertionError({
           actual: validation.result,

package/shims/shared/index.js

@@ -1,14 +1,8 @@
 const hasOwn = Object.prototype.hasOwnProperty
 
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  }, _typeof(obj);
-}
+const _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'
+  ? (obj) => typeof obj
+  : (obj) => obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj;
 
 export function objectType(obj) {
   if (typeof obj === 'undefined') {
@@ -19,8 +13,8 @@ export function objectType(obj) {
   if (obj === null) {
     return 'null';
   }
-  var match = toString.call(obj).match(/^\[object\s(.*)\]$/);
-  var type = match && match[1];
+  const match = toString.call(obj).match(/^\[object\s(.*)\]$/);
+  const type = match && match[1];
   switch (type) {
     case 'Number':
       if (isNaN(obj)) {
@@ -47,12 +41,12 @@ function is(type, obj) {
 }
 
 export function objectValues(obj) {
-  let allowArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  let vals = allowArray && is('array', obj) ? [] : {};
+  const allowArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  const vals = allowArray && is('array', obj) ? [] : {};
 
-  for (var key in obj) {
+  for (const key in obj) {
     if (hasOwn.call(obj, key)) {
-      let val = obj[key];
+      const val = obj[key];
       vals[key] = val === Object(val) ? objectValues(val, allowArray) : val;
     }
   }
@@ -80,8 +74,8 @@ export function objectValuesSubset(obj, model) {
 
   // Unlike objectValues(), subset arrays to a plain objects as well.
   // This enables subsetting [20, 30] with {1: 30}.
-  var subset = {};
-  for (var key in model) {
+  const subset = {};
+  for (const key in model) {
     if (hasOwn.call(model, key) && hasOwn.call(obj, key)) {
       subset[key] = objectValuesSubset(obj[key], model[key]);
     }
@@ -90,7 +84,7 @@ export function objectValuesSubset(obj, model) {
 }
 
 export function validateExpectedExceptionArgs(expected, message, assertionMethod) {
-  var expectedType = objectType(expected);
+  const expectedType = objectType(expected);
 
   // 'expected' is optional unless doing string comparison
   if (expectedType === 'string') {
@@ -102,7 +96,7 @@ export function validateExpectedExceptionArgs(expected, message, assertionMethod
       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.');
     }
   }
-  var valid = !expected ||
+  const valid = !expected ||
   // TODO: be more explicit here
   expectedType === 'regexp' || expectedType === 'function' || expectedType === 'object';
   if (!valid) {
@@ -112,8 +106,8 @@ export function validateExpectedExceptionArgs(expected, message, assertionMethod
 }
 
 export function validateException(actual, expected, message) {
-  var result = false;
-  var expectedType = objectType(expected);
+  let result = false;
+  const expectedType = objectType(expected);
 
   // These branches should be exhaustive, based on validation done in validateExpectedException
 
@@ -157,7 +151,7 @@ export function validateException(actual, expected, message) {
 
 function errorString(error) {
   // Use String() instead of toString() to handle non-object values like undefined or null.
-  var resultErrorString = String(error);
+  const resultErrorString = String(error);
 
   // If the error wasn't a subclass of Error but something like
   // an object literal with name and message properties...

package/shims/shared/module-context.js

@@ -16,7 +16,7 @@ export default class ModuleContext {
   tests = [];
 
   constructor(name) {
-    let parentModule = ModuleContext.currentModuleChain[ModuleContext.currentModuleChain.length - 1];
+    const parentModule = ModuleContext.currentModuleChain[ModuleContext.currentModuleChain.length - 1];
 
     ModuleContext.currentModuleChain.push(this);
 

package/Makefile

@@ -1,26 +0,0 @@
-.PHONY: check test lint build release
-
-check: lint test
-
-lint:
-	npm run lint
-
-test:
-	npm test
-
-build:
-	npm run build
-
-# Lint, bump version, update changelog, commit, tag, push, publish to npm.
-# CI then creates the GitHub release.
-# Usage: make release LEVEL=patch|minor|major
-release:
-	@test -n "$(LEVEL)" || (echo "Usage: make release LEVEL=patch|minor|major" && exit 1)
-	npm run lint
-	npm version $(LEVEL) --no-git-tag-version
-	npm run changelog:update
-	git add package.json package-lock.json CHANGELOG.md
-	git commit -m "Release $$(node -p 'require("./package.json").version')"
-	git tag "v$$(node -p 'require("./package.json").version')"
-	git push && git push --tags
-	npm publish --access public