qunitx-cli 0.5.1 → 0.5.2

package/README.md

@@ -1,6 +1,7 @@
 # qunitx-cli
 
 [![CI](https://github.com/izelnakri/qunitx-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/izelnakri/qunitx-cli/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/izelnakri/qunitx-cli/branch/main/graph/badge.svg)](https://codecov.io/gh/izelnakri/qunitx-cli)
 [![npm](https://img.shields.io/npm/v/qunitx-cli)](https://www.npmjs.com/package/qunitx-cli)
 [![npm downloads](https://img.shields.io/npm/dm/qunitx-cli)](https://www.npmjs.com/package/qunitx-cli)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
@@ -8,7 +9,7 @@
 Browser-based test runner for [QUnitX](https://github.com/izelnakri/qunitx) — bundles your JS/TS tests
 with esbuild, runs them in headless Chrome, and streams TAP output to the terminal.
 
-![qunitx-cli demo](demo/demo.gif)
+![qunitx-cli demo](docs/demo.gif)
 
 ## Features
 
@@ -154,7 +155,7 @@ Options:
 npm install
 make check                 # lint + test (run before every commit)
 make test                  # run tests only
-make demo                  # regenerate demo output
+make demo                  # regenerate docs/demo.gif
 make release LEVEL=patch   # bump version, update changelog, tag, push
 ```
 

package/cli.js

@@ -19,7 +19,7 @@ process.title = 'qunitx';
     return await initializeProject();
   }
 
-  let config = await setupConfig();
+  const config = await setupConfig();
 
   return await run(config);
 })();

package/deno.json

@@ -0,0 +1,7 @@
+{
+  "lint": {
+    "rules": {
+      "exclude": ["no-process-global", "no-node-globals", "no-window"]
+    }
+  }
+}

package/docs/demo-math-test.failing.js

@@ -0,0 +1,59 @@
+import { module, test } from 'qunitx';
+
+module('Math', (hooks) => {
+  hooks.beforeEach(function () {
+    this.numbers = [1, 2, 3];
+  });
+
+  test('equal and notEqual', (assert) => {
+    assert.equal(1 + 1, 2, 'addition');
+    assert.notEqual(1 + 1, 3);
+  });
+
+  test('strictEqual', (assert) => {
+    assert.strictEqual('hello', 'hello');
+    assert.notStrictEqual(1, '1', '1 !== "1" (type-strict)');
+  });
+
+  test('deepEqual — user profile sync', (assert) => {
+    const response = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    const expected = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    assert.deepEqual(response, expected, 'API response matches expected shape');
+  });
+
+  test('hooks: beforeEach resets state per test', function (assert) {
+    assert.deepEqual(this.numbers, [1, 2, 3]);
+    this.numbers.push(4);
+    assert.equal(this.numbers.length, 4);
+  });
+
+  module('Async', () => {
+    test('async/await', async (assert) => {
+      const data = await Promise.resolve({ id: 1, name: 'Alice' });
+      console.log(data.name, 'resolved in Chrome');
+      assert.propContains(data, { name: 'Alice' });
+    });
+
+    test('assert.rejects', async (assert) => {
+      await assert.rejects(Promise.reject(new TypeError('invalid')), TypeError);
+    });
+  });
+});
+
+module('Assertions', () => {
+  test('throws — match by constructor', (assert) => {
+    assert.throws(() => { throw new RangeError('out of bounds'); }, RangeError);
+  });
+
+  test('step/verifySteps — execution order', (assert) => {
+    assert.step('init');
+    assert.step('process');
+    assert.step('done');
+    assert.verifySteps(['init', 'process', 'done']);
+  });
+
+  test('propContains — partial object match', (assert) => {
+    const user = { id: 1, name: 'Alice', role: 'admin', active: true };
+    assert.propContains(user, { role: 'admin', active: true });
+  });
+});

package/docs/demo-math-test.js

@@ -0,0 +1,59 @@
+import { module, test } from 'qunitx';
+
+module('Math', (hooks) => {
+  hooks.beforeEach(function () {
+    this.numbers = [1, 2, 3];
+  });
+
+  test('equal and notEqual', (assert) => {
+    assert.equal(1 + 1, 2, 'addition');
+    assert.notEqual(1 + 1, 3);
+  });
+
+  test('strictEqual', (assert) => {
+    assert.strictEqual('hello', 'hello');
+    assert.notStrictEqual(1, '1', '1 !== "1" (type-strict)');
+  });
+
+  test('deepEqual — user profile sync', (assert) => {
+    const response = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    const expected = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    assert.deepEqual(response, expected, 'API response matches expected shape');
+  });
+
+  test('hooks: beforeEach resets state per test', function (assert) {
+    assert.deepEqual(this.numbers, [1, 2, 3]);
+    this.numbers.push(4);
+    assert.equal(this.numbers.length, 4);
+  });
+
+  module('Async', () => {
+    test('async/await', async (assert) => {
+      const data = await Promise.resolve({ id: 1, name: 'Alice' });
+      console.log(data.name, 'resolved in Chrome');
+      assert.propContains(data, { name: 'Alice' });
+    });
+
+    test('assert.rejects', async (assert) => {
+      await assert.rejects(Promise.reject(new TypeError('invalid')), TypeError);
+    });
+  });
+});
+
+module('Assertions', () => {
+  test('throws — match by constructor', (assert) => {
+    assert.throws(() => { throw new RangeError('out of bounds'); }, RangeError);
+  });
+
+  test('step/verifySteps — execution order', (assert) => {
+    assert.step('init');
+    assert.step('process');
+    assert.step('done');
+    assert.verifySteps(['init', 'process', 'done']);
+  });
+
+  test('propContains — partial object match', (assert) => {
+    const user = { id: 1, name: 'Alice', role: 'admin', active: true };
+    assert.propContains(user, { role: 'admin', active: true });
+  });
+});

package/docs/demo.tape

@@ -0,0 +1,92 @@
+# QUnitX demo — terminal portion of the composite GIF
+# Run: nix run nixpkgs#vhs -- docs/demo.tape
+# Output: docs/terminal.gif  (composited into docs/demo.gif by make-demo-gif.sh)
+
+Output docs/terminal.gif
+
+Set Shell "zsh"
+Set FontSize 14
+Set Width 700
+Set Height 680
+Set Theme "Dracula"
+Set Padding 20
+Set TypingSpeed 55ms
+Set PlaybackSpeed 0.85
+
+Hide
+Type "setopt interactive_comments"
+Enter
+Type "alias qunitx=$(pwd)/cli.js"
+Enter
+Sleep 200ms
+# Create failing version: copy demo-math-test.js with the score bug (88 → 87)
+Type "cp docs/demo-math-test.js docs/demo-math-test.failing.js && sed -i '/const response/s/88/87/' docs/demo-math-test.failing.js"
+Enter
+Sleep 400ms
+Show
+
+# ── 1. Show the test file ─────────────────────────────────────────────────────
+Type "bat --paging=never docs/demo-math-test.js"
+Enter
+Sleep 4000ms
+
+Hide
+Type "clear"
+Enter
+Show
+
+# ── 2. qunitx --debug: headless Chrome, TAP output, browser console ───────────
+Type "# qunitx: headless Chrome, streams TAP, pipes browser console"
+Enter
+Sleep 400ms
+Type "qunitx docs/demo-math-test.failing.js --debug"
+Enter
+Sleep 9500ms
+
+Hide
+Type "clear"
+Enter
+Show
+
+# ── 3. --failFast: stop immediately on the first failure ──────────────────────
+Type "# --failFast: stop on the first failure"
+Enter
+Sleep 400ms
+Type "qunitx docs/demo-math-test.failing.js --failFast"
+Enter
+Sleep 6000ms
+
+Hide
+Type "clear"
+Enter
+# Background: 'fix' the file 9 seconds from now — fires during the watch run
+Type "(sleep 9 && cp docs/demo-math-test.js docs/demo-math-test.failing.js) &"
+Enter
+Sleep 200ms
+Show
+
+# ── 4. --watch: live fail → fix → pass cycle ──────────────────────────────────
+Type "# --watch: re-runs on every file save"
+Enter
+Sleep 400ms
+Type "qunitx docs/demo-math-test.failing.js --watch"
+Enter
+Sleep 4500ms
+# Background fires ~9s after the hidden job was queued, ~5.2s after qunitx started.
+# Initial failing run is done; file is replaced; watch detects change and re-runs.
+Sleep 5500ms
+Ctrl+C
+Sleep 800ms
+
+Hide
+Type "clear"
+Enter
+Show
+
+# ── 5. node --test: same file, same results ───────────────────────────────────
+Type "# Same file in Node.js — zero extra config"
+Enter
+Sleep 400ms
+Type "node --test docs/demo-math-test.js"
+Enter
+Sleep 5500ms

package/docs/make-demo-gif.sh

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# Regenerates docs/demo.gif — the combined terminal + browser demo GIF.
+#
+# Prerequisites (available in the nix devShell):
+#   nix run nixpkgs#vhs        — terminal recorder
+#   CHROME_BIN                 — path to Chromium binary
+#   ffmpeg, gifsicle           — compositing and optimisation
+#
+# Usage:
+#   export CHROME_BIN=/nix/store/<hash>-chromium-<ver>/bin/chromium
+#   bash docs/make-demo-gif.sh
+#
+# Outputs:
+#   docs/terminal.gif           — terminal-only animation (VHS)
+#   docs/browser-*.png          — browser screenshots (puppeteer)
+#   docs/demo.gif               — final composite (1000×500, ~500 KB)
+
+set -euo pipefail
+cd "$(dirname "$0")/.."
+DOCS=docs
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+
+# ── 1. Terminal GIF via VHS ────────────────────────────────────────────────────
+echo "==> Recording terminal animation (VHS)..."
+nix run nixpkgs#vhs -- "$DOCS/demo.tape"
+echo "    terminal.gif: $(du -h "$DOCS/terminal.gif" | cut -f1)"
+
+# ── 2. Browser screenshots via puppeteer ──────────────────────────────────────
+echo "==> Taking browser screenshots..."
+if [[ -z "${CHROME_BIN:-}" ]]; then
+  CHROME_BIN=$(nix eval --raw nixpkgs#chromium.outPath)/bin/chromium
+fi
+CHROME_BIN="$CHROME_BIN" node "$DOCS/take-browser-screenshots.js"
+
+# ── 3. Get terminal duration ───────────────────────────────────────────────────
+DURATION=$(ffprobe -v error -show_entries format=duration \
+  -of default=noprint_wrappers=1:nokey=1 "$DOCS/terminal.gif")
+DURATION=${DURATION%.*}
+
+# ── 4. Terminal: scale to 500×500, per-module palette, optimise ───────────────
+echo "==> Scaling terminal to 500×500..."
+ffmpeg -y -i "$DOCS/terminal.gif" \
+  -vf "fps=8,scale=500:500:flags=lanczos,pad=500:500:(ow-iw)/2:(oh-ih)/2,split[a][b];[a]palettegen=max_colors=200[p];[b][p]paletteuse" \
+  -t "$DURATION" -loop 0 "$TMP/terminal_small.gif" 2>/dev/null
+nix run nixpkgs#gifsicle -- -O3 --lossy=80 "$TMP/terminal_small.gif" -o "$TMP/terminal_opt.gif" 2>/dev/null
+
+# ── 5. Browser slideshow: scale to 500×500, 2fps ──────────────────────────────
+# Frame timing:
+#   1. Failing tests + deepEqual diff  — 14s (give viewers time to read the diff)
+#   2. All passing (simulated refresh) —  8s (quick "it's fixed!")
+#   3. Filtered to Async module        —  8s (shareable URL demo)
+#   4. deepEqual test expanded         — remainder
+D1=14
+D2=8
+D3=8
+D4=$(( DURATION - D1 - D2 - D3 ))
+echo "==> Building browser slideshow (${D1}s / ${D2}s / ${D3}s / ${D4}s)..."
+cat > "$TMP/browser_list.txt" << EOF
+file '$(realpath $DOCS/browser-1-failing.png)'
+duration $D1
+file '$(realpath $DOCS/browser-2-all-passed.png)'
+duration $D2
+file '$(realpath $DOCS/browser-3-filtered.png)'
+duration $D3
+file '$(realpath $DOCS/browser-4-expanded.png)'
+duration $D4
+file '$(realpath $DOCS/browser-4-expanded.png)'
+EOF
+
+ffmpeg -y -f concat -safe 0 -i "$TMP/browser_list.txt" \
+  -vf "fps=2,scale=500:500:flags=lanczos,pad=500:500:(ow-iw)/2:(oh-ih)/2,split[a][b];[a]palettegen=max_colors=200[p];[b][p]paletteuse" \
+  -t "$DURATION" -loop 0 "$TMP/browser_small.gif" 2>/dev/null
+nix run nixpkgs#gifsicle -- -O3 --lossy=80 "$TMP/browser_small.gif" -o "$TMP/browser_opt.gif" 2>/dev/null
+
+# ── 6. Composite: hstack with shared palette ──────────────────────────────────
+echo "==> Compositing side-by-side..."
+ffmpeg -y -i "$TMP/terminal_opt.gif" -i "$TMP/browser_opt.gif" \
+  -filter_complex \
+  "[0:v][1:v]hstack=inputs=2,split[a][b]; \
+   [a]palettegen=max_colors=128[p];[b][p]paletteuse=dither=bayer:bayer_scale=5" \
+  -t "$DURATION" -loop 0 "$TMP/combined.gif" 2>/dev/null
+
+# ── 7. Final optimise ─────────────────────────────────────────────────────────
+echo "==> Optimising with gifsicle..."
+nix run nixpkgs#gifsicle -- -O3 --lossy=100 "$TMP/combined.gif" -o "$DOCS/demo.gif" 2>/dev/null
+
+echo "==> Done: $DOCS/demo.gif ($(du -h "$DOCS/demo.gif" | cut -f1))"

package/docs/take-browser-screenshots.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+// Serves QUnit test pages and captures screenshots for the demo GIF.
+// Usage: CHROME_BIN=... node docs/take-browser-screenshots.js
+// Output: docs/browser-{1-failing,2-all-passed,3-filtered,4-expanded}.png
+
+import http from 'node:http';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import puppeteer from 'puppeteer';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const CHROME =
+  process.env.CHROME_BIN ||
+  `${process.env.HOME}/.cache/puppeteer/chrome/linux-146.0.7680.66/chrome-linux64/chrome`;
+
+const qunitJS = await fs.readFile(path.join(ROOT, 'vendor/qunit.js'), 'utf8');
+const qunitCSS = await fs.readFile(path.join(ROOT, 'vendor/qunit.css'), 'utf8');
+
+// ── Shared test suite ────────────────────────────────────────────────────────
+// Bug is in deepEqual: scores[1] is 87 in "actual" but 88 in "expected".
+// Swap BUGGY_VALUE → FIXED_VALUE to simulate saving the fix.
+const BUGGY_VALUE = '87';
+const FIXED_VALUE = '88';
+
+const makeSuite = (scoreValue) => `
+QUnit.module('Assertions', (hooks) => {
+  QUnit.test('ok / notOk', (assert) => {
+    assert.ok(1, 'truthy value passes');
+    assert.notOk(0, 'falsy value passes');
+  });
+
+  QUnit.test('equal / strictEqual', (assert) => {
+    assert.equal(2 + 2, 4, 'addition');
+    assert.strictEqual('hello', 'hello');
+  });
+
+  QUnit.test('deepEqual – user profile sync', (assert) => {
+    const response = { user: { name: 'Alice', scores: [95, ${scoreValue}, 92] }, active: true };
+    const expected = { user: { name: 'Alice', scores: [95, 88, 92] }, active: true };
+    assert.deepEqual(response, expected, 'API response matches expected shape');
+  });
+
+  QUnit.test('throws – match by constructor', (assert) => {
+    assert.throws(() => { throw new TypeError('bad input'); }, TypeError);
+  });
+
+  QUnit.test('propContains – partial object match', (assert) => {
+    assert.propContains({ id: 1, name: 'Alice', role: 'admin' }, { role: 'admin' });
+  });
+});
+
+QUnit.module('Async', (hooks) => {
+  QUnit.test('async/await', async (assert) => {
+    const result = await Promise.resolve(42);
+    assert.strictEqual(result, 42, 'resolved to 42');
+  });
+
+  QUnit.test('assert.async() – callback style', (assert) => {
+    const done = assert.async();
+    setTimeout(() => {
+      assert.ok(true, 'callback fired');
+      done();
+    }, 10);
+  });
+
+  QUnit.test('rejects – async error handling', async (assert) => {
+    await assert.rejects(Promise.reject(new RangeError('out of bounds')), RangeError);
+  });
+});
+
+QUnit.module('Hooks', (hooks) => {
+  hooks.beforeEach(function () {
+    this.user = { name: 'Alice', loggedIn: false };
+  });
+
+  QUnit.test('beforeEach sets up fresh state', function (assert) {
+    assert.strictEqual(this.user.name, 'Alice');
+    assert.false(this.user.loggedIn, 'starts logged out');
+  });
+
+  QUnit.test('mutations do not leak between tests', function (assert) {
+    this.user.loggedIn = true;
+    assert.true(this.user.loggedIn, 'mutated in this test only');
+  });
+
+  QUnit.module('Nested Hooks', (innerHooks) => {
+    innerHooks.beforeEach(function () {
+      this.role = 'admin';
+    });
+
+    QUnit.test('inner beforeEach stacks on outer', function (assert) {
+      assert.strictEqual(this.user.name, 'Alice', 'outer beforeEach ran');
+      assert.strictEqual(this.role, 'admin', 'inner beforeEach also ran');
+    });
+  });
+});
+`;
+
+const makeHTML = (tests) => `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>QUnitX Demo Tests</title>
+    <style>${qunitCSS}</style>
+    <style>
+      body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
+      #qunit-header { background: #1c1c1e; }
+    </style>
+  </head>
+  <body>
+    <div id="qunit"></div>
+    <div id="qunit-fixture"></div>
+    <script>${qunitJS}</script>
+    <script>${tests}</script>
+  </body>
+</html>`;
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function createServer(html) {
+  const server = http.createServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+    res.end(html);
+  });
+  return new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve(server)));
+}
+
+async function waitForResults(page, timeout = 15000) {
+  await page.waitForFunction(
+    () => {
+      const banner = document.getElementById('qunit-banner');
+      return (
+        banner &&
+        (banner.classList.contains('qunit-pass') || banner.classList.contains('qunit-fail'))
+      );
+    },
+    { timeout },
+  );
+}
+
+// ── Puppeteer ────────────────────────────────────────────────────────────────
+const browser = await puppeteer.launch({
+  executablePath: CHROME,
+  headless: true,
+  args: ['--no-sandbox', '--disable-gpu', '--window-size=1200,860'],
+});
+
+const page = await browser.newPage();
+await page.setViewport({ width: 700, height: 680, deviceScaleFactor: 1 });
+
+// ── Screenshot 1: Failing tests — deepEqual diff visible ─────────────────────
+const failingServer = await createServer(makeHTML(makeSuite(BUGGY_VALUE)));
+const failingURL = `http://127.0.0.1:${failingServer.address().port}/`;
+console.log(`Serving failing tests at ${failingURL}`);
+
+await page.goto(failingURL, { waitUntil: 'networkidle0' });
+await waitForResults(page);
+
+// Expand the failing test so the deepEqual diff is in view
+const failingItem = await page.$('#qunit-tests > li.fail');
+if (failingItem) {
+  const toggle = await failingItem.$('strong');
+  if (toggle) {
+    await toggle.click();
+    await new Promise((r) => setTimeout(r, 600));
+  }
+  // Scroll the failing test to the top so diff is fully visible
+  await page.evaluate((el) => el.scrollIntoView({ block: 'start' }), failingItem);
+  await new Promise((r) => setTimeout(r, 300));
+}
+
+await page.screenshot({ path: path.join(__dirname, 'browser-1-failing.png') });
+console.log('Screenshot 1: failing (deepEqual diff) ✓');
+failingServer.close();
+
+// ── Screenshot 2: All passing — simulates browser refresh after fixing the bug ──
+const passingServer = await createServer(makeHTML(makeSuite(FIXED_VALUE)));
+const passingURL = `http://127.0.0.1:${passingServer.address().port}/`;
+console.log(`Serving passing tests at ${passingURL}`);
+
+await page.goto(passingURL, { waitUntil: 'networkidle0' });
+await waitForResults(page);
+await page.evaluate(() => window.scrollTo(0, 0));
+await page.screenshot({ path: path.join(__dirname, 'browser-2-all-passed.png') });
+console.log('Screenshot 2: all passed ✓');
+
+// ── Screenshot 3: Filtered to "Async" module — shareable URL demo ────────────
+const asyncModuleId = await page.evaluate(() => {
+  if (typeof QUnit !== 'undefined' && QUnit.config && QUnit.config.modules) {
+    const m = QUnit.config.modules.find((m) => m.name === 'Async');
+    return m ? m.moduleId : null;
+  }
+  return null;
+});
+
+if (asyncModuleId) {
+  await page.goto(`${passingURL}?moduleId=${asyncModuleId}`, { waitUntil: 'networkidle0' });
+  await waitForResults(page);
+}
+await page.evaluate(() => window.scrollTo(0, 0));
+await page.screenshot({ path: path.join(__dirname, 'browser-3-filtered.png') });
+console.log('Screenshot 3: filtered (Async module) ✓');
+
+// ── Screenshot 4: Back to all tests, deepEqual test expanded ─────────────────
+await page.goto(passingURL, { waitUntil: 'networkidle0' });
+await waitForResults(page);
+
+// Expand the deepEqual test (3rd test in Assertions) to show passing assertion detail
+const deepEqualItem = await page.$('#qunit-tests > li:nth-child(3)');
+if (deepEqualItem) {
+  const toggle = await deepEqualItem.$('strong');
+  if (toggle) {
+    await toggle.click();
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  await page.evaluate((el) => el.scrollIntoView({ block: 'start' }), deepEqualItem);
+  await new Promise((r) => setTimeout(r, 200));
+}
+await page.screenshot({ path: path.join(__dirname, 'browser-4-expanded.png') });
+console.log('Screenshot 4: deepEqual expanded (passing) ✓');
+
+passingServer.close();
+await browser.close();
+console.log('Done. Screenshots saved to docs/');

package/lib/boilerplates/test.js

@@ -1,6 +1,6 @@
 import { module, test } from 'qunitx';
 
-module('{{moduleName}}', function (hooks) {
+module('{{moduleName}}', function (_hooks) {
   test('assert true works', function (assert) {
     assert.expect(3);
     assert.ok(true);
@@ -11,11 +11,11 @@ module('{{moduleName}}', function (hooks) {
   test('async test finishes', async function (assert) {
     assert.expect(3);
 
-    let wait = () =>
-      new Promise((resolve, reject) => {
+    const wait = () =>
+      new Promise((resolve) => {
         setTimeout(() => resolve(true), 50);
       });
-    let result = await wait();
+    const result = await wait();
 
     assert.ok(true);
     assert.equal(true, result);

package/lib/commands/generate.js

@@ -8,9 +8,9 @@ import pathExists from '../utils/path-exists.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 export default async function () {
-  let projectRoot = await findProjectRoot();
-  let moduleName = process.argv[3]; // TODO: classify this maybe in future
-  let path =
+  const projectRoot = await findProjectRoot();
+  const moduleName = process.argv[3]; // TODO: classify this maybe in future
+  const path =
     process.argv[3].endsWith('.js') || process.argv[3].endsWith('.ts')
       ? `${projectRoot}/${process.argv[3]}`
       : `${projectRoot}/${process.argv[3]}.js`;
@@ -19,8 +19,8 @@ export default async function () {
     return console.log(`${path} already exists!`);
   }
 
-  let testJSContent = await fs.readFile(`${__dirname}/../boilerplates/test.js`);
-  let targetFolderPaths = path.split('/');
+  const testJSContent = await fs.readFile(`${__dirname}/../boilerplates/test.js`);
+  const targetFolderPaths = path.split('/');
 
   targetFolderPaths.pop();
 

package/lib/commands/init.js

@@ -8,9 +8,9 @@ import defaultProjectConfigValues from '../boilerplates/default-project-config-v
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 export default async function () {
-  let projectRoot = await findProjectRoot();
-  let oldPackageJSON = JSON.parse(await fs.readFile(`${projectRoot}/package.json`));
-  let htmlPaths = process.argv.slice(2).reduce(
+  const projectRoot = await findProjectRoot();
+  const oldPackageJSON = JSON.parse(await fs.readFile(`${projectRoot}/package.json`));
+  const htmlPaths = process.argv.slice(2).reduce(
     (result, arg) => {
       if (arg.endsWith('.html')) {
         result.push(arg);
@@ -20,7 +20,7 @@ export default async function () {
     },
     oldPackageJSON.qunitx && oldPackageJSON.qunitx.htmlPaths ? oldPackageJSON.qunitx.htmlPaths : [],
   );
-  let newQunitxConfig = Object.assign(
+  const newQunitxConfig = Object.assign(
     defaultProjectConfigValues,
     htmlPaths.length > 0 ? { htmlPaths } : { htmlPaths: ['test/tests.html'] },
     oldPackageJSON.qunitx,
@@ -34,20 +34,20 @@ export default async function () {
 }
 
 async function writeTestsHTML(projectRoot, newQunitxConfig, oldPackageJSON) {
-  let testHTMLTemplateBuffer = await fs.readFile(`${__dirname}/../boilerplates/setup/tests.hbs`);
+  const testHTMLTemplateBuffer = await fs.readFile(`${__dirname}/../boilerplates/setup/tests.hbs`);
 
   return await Promise.all(
     newQunitxConfig.htmlPaths.map(async (htmlPath) => {
-      let targetPath = `${projectRoot}/${htmlPath}`;
+      const targetPath = `${projectRoot}/${htmlPath}`;
       if (await pathExists(targetPath)) {
         return console.log(`${htmlPath} already exists`);
       } else {
-        let targetDirectory = path.dirname(targetPath);
-        let targetOutputPath = path.relative(
+        const targetDirectory = path.dirname(targetPath);
+        const _targetOutputPath = path.relative(
           targetDirectory,
           `${projectRoot}/${newQunitxConfig.output}/tests.js`,
         );
-        let testHTMLTemplate = testHTMLTemplateBuffer
+        const testHTMLTemplate = testHTMLTemplateBuffer
           .toString()
           .replace('{{applicationName}}', oldPackageJSON.name);
 
@@ -61,15 +61,15 @@ async function writeTestsHTML(projectRoot, newQunitxConfig, oldPackageJSON) {
 }
 
 async function rewritePackageJSON(projectRoot, newQunitxConfig, oldPackageJSON) {
-  let newPackageJSON = Object.assign(oldPackageJSON, { qunitx: newQunitxConfig });
+  const newPackageJSON = Object.assign(oldPackageJSON, { qunitx: newQunitxConfig });
 
   await fs.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
 }
 
 async function writeTSConfigIfNeeded(projectRoot) {
-  let targetPath = `${projectRoot}/tsconfig.json`;
+  const targetPath = `${projectRoot}/tsconfig.json`;
   if (!(await pathExists(targetPath))) {
-    let tsConfigTemplateBuffer = await fs.readFile(
+    const tsConfigTemplateBuffer = await fs.readFile(
       `${__dirname}/../boilerplates/setup/tsconfig.json`,
     );
 

package/lib/commands/run.js

@@ -146,7 +146,7 @@ export default async function (config) {
 async function buildCachedContent(config, htmlPaths) {
   const htmlBuffers = await Promise.all(config.htmlPaths.map((htmlPath) => fs.readFile(htmlPath)));
   const cachedContent = htmlPaths.reduce(
-    (result, htmlPath, index) => {
+    (result, _htmlPath, index) => {
       const filePath = config.htmlPaths[index];
       const html = htmlBuffers[index].toString();
 
@@ -208,7 +208,7 @@ function splitIntoGroups(files, groupCount) {
   return groups.filter((g) => g.length > 0);
 }
 
-function logWatcherAndKeyboardShortcutInfo(config, server) {
+function logWatcherAndKeyboardShortcutInfo(config, _server) {
   console.log(
     '#',
     kleur.blue(`Watching files... You can browse the tests on http://localhost:${config.port} ...`),

package/lib/servers/http.js

@@ -15,14 +15,13 @@ export const MIME_TYPES = {
 
 export default class HTTPServer {
   static serve(config = { port: 1234 }, handler) {
-    let onListen = config.onListen || ((server) => {});
-    let onError = config.onError || ((error) => {});
+    const onListen = config.onListen || ((_server) => {});
+    const onError = config.onError || ((_error) => {});
 
     return new Promise((resolve, reject) => {
-      let server = http.createServer((req, res) => {
+      const server = http.createServer((req, res) => {
         return handler(req, res);
       });
-      server = server;
       server
         .on('error', (error) => {
           onError(error);
@@ -221,7 +220,7 @@ export default class HTTPServer {
     return true;
   }
 
-  buildRegexPattern(path, paramNames) {
+  buildRegexPattern(path, _paramNames) {
     let regexPattern = path.replace(/:[^/]+/g, '([^/]+)');
     regexPattern = regexPattern.replace(/\//g, '\\/');
 
@@ -235,7 +234,7 @@ export default class HTTPServer {
     return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
   }
 
-  extractParams(route, url) {
+  extractParams(route, _url) {
     const { paramNames, paramValues } = route;
     const params = {};
 

package/lib/setup/browser.js

@@ -13,7 +13,7 @@ export default async function setupBrowser(
   cachedContent,
   existingBrowser = null,
 ) {
-  let [server, browser] = await Promise.all([
+  const [server, browser] = await Promise.all([
     setupWebServer(config, cachedContent),
     existingBrowser
       ? Promise.resolve(existingBrowser)
@@ -29,7 +29,7 @@ export default async function setupBrowser(
           headless: true,
         }),
   ]);
-  let [page, _] = await Promise.all([browser.newPage(), bindServerToPort(server, config)]);
+  const [page] = await Promise.all([browser.newPage(), bindServerToPort(server, config)]);
 
   page.on('console', async (msg) => {
     if (config.debug) {
@@ -39,20 +39,12 @@ export default async function setupBrowser(
     }
   });
   page.on('error', (msg) => {
-    try {
-      throw msg;
-    } catch (e) {
-      console.error(e, e.stack);
-      console.log(e, e.stack);
-    }
+    console.error(msg, msg.stack);
+    console.log(msg, msg.stack);
   });
-  page.on('pageerror', async (error) => {
-    try {
-      throw error;
-    } catch (e) {
-      console.log(e.toString());
-      console.error(e.toString());
-    }
+  page.on('pageerror', (error) => {
+    console.log(error.toString());
+    console.error(error.toString());
   });
 
   return { server, browser, page };

package/lib/setup/config.js

@@ -6,11 +6,11 @@ import setupTestFilePaths from './test-file-paths.js';
 import parseCliFlags from '../utils/parse-cli-flags.js';
 
 export default async function setupConfig() {
-  let projectRoot = await findProjectRoot();
-  let cliConfigFlags = parseCliFlags(projectRoot);
-  let projectPackageJSON = await readConfigFromPackageJSON(projectRoot);
-  let inputs = cliConfigFlags.inputs.concat(readInputsFromPackageJSON(projectPackageJSON));
-  let config = {
+  const projectRoot = await findProjectRoot();
+  const cliConfigFlags = parseCliFlags(projectRoot);
+  const projectPackageJSON = await readConfigFromPackageJSON(projectRoot);
+  const inputs = cliConfigFlags.inputs.concat(readInputsFromPackageJSON(projectPackageJSON));
+  const config = {
     ...defaultProjectConfigValues,
     htmlPaths: [],
     ...projectPackageJSON.qunitx,
@@ -28,7 +28,7 @@ export default async function setupConfig() {
 }
 
 async function readConfigFromPackageJSON(projectRoot) {
-  let packageJSON = await fs.readFile(`${projectRoot}/package.json`);
+  const packageJSON = await fs.readFile(`${projectRoot}/package.json`);
 
   return JSON.parse(packageJSON.toString());
 }
@@ -38,7 +38,7 @@ function normalizeHTMLPaths(projectRoot, htmlPaths) {
 }
 
 function readInputsFromPackageJSON(packageJSON) {
-  let qunitx = packageJSON.qunitx;
+  const qunitx = packageJSON.qunitx;
 
   return qunitx && qunitx.inputs ? qunitx.inputs : [];
 }

package/lib/setup/file-watcher.js

@@ -1,14 +1,9 @@
 import chokidar from 'chokidar';
 import kleur from 'kleur';
 
-export default async function setupFileWatchers(
-  testFileLookupPaths,
-  config,
-  onEventFunc,
-  onFinishFunc,
-) {
-  let extensions = ['js', 'ts'];
-  let fileWatchers = testFileLookupPaths.reduce((watcher, watchPath) => {
+export default function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
+  const extensions = ['js', 'ts'];
+  const fileWatchers = testFileLookupPaths.reduce((watcher, watchPath) => {
     return Object.assign(watcher, {
       [watchPath]: chokidar.watch(watchPath, { ignoreInitial: true }).on('all', (event, path) => {
         if (extensions.some((extension) => path.endsWith(extension))) {
@@ -31,7 +26,7 @@ export default async function setupFileWatchers(
           if (!global.chokidarBuild) {
             global.chokidarBuild = true;
 
-            let result = extensions.some((extension) => path.endsWith(extension))
+            const result = extensions.some((extension) => path.endsWith(extension))
               ? onEventFunc(event, path)
               : null;
 
@@ -72,7 +67,7 @@ function mutateFSTree(fsTree, event, path) {
   } else if (event === 'unlink') {
     delete fsTree[path];
   } else if (event === 'unlinkDir') {
-    let targetPaths = Object.keys(config.fsTree).filter((treePath) => treePath.startsWith(path));
+    const targetPaths = Object.keys(config.fsTree).filter((treePath) => treePath.startsWith(path));
 
     targetPaths.forEach((path) => delete config.fsTree[path]);
   }

package/lib/setup/fs-tree.js

@@ -2,19 +2,19 @@ import fs from 'node:fs/promises';
 import picomatch from 'picomatch';
 import recursiveLookup from 'recursive-lookup';
 
-export default async function buildFSTree(fileAbsolutePaths, config = {}) {
-  let targetExtensions = ['js', 'ts'];
-  let fsTree = {};
+export default async function buildFSTree(fileAbsolutePaths, _config = {}) {
+  const targetExtensions = ['js', 'ts'];
+  const fsTree = {};
 
   await Promise.all(
     fileAbsolutePaths.map(async (fileAbsolutePath) => {
-      let glob = picomatch.scan(fileAbsolutePath);
+      const glob = picomatch.scan(fileAbsolutePath);
 
       // TODO: maybe allow absolute path references
 
       try {
         if (glob.isGlob) {
-          let fileNames = await recursiveLookup(glob.base, (path) => {
+          const fileNames = await recursiveLookup(glob.base, (path) => {
             return targetExtensions.some((extension) => path.endsWith(extension));
           });
 
@@ -24,12 +24,12 @@ export default async function buildFSTree(fileAbsolutePaths, config = {}) {
             }
           });
         } else {
-          let entry = await fs.stat(fileAbsolutePath);
+          const entry = await fs.stat(fileAbsolutePath);
 
           if (entry.isFile()) {
             fsTree[fileAbsolutePath] = null;
           } else if (entry.isDirectory()) {
-            let fileNames = await recursiveLookup(glob.base, (path) => {
+            const fileNames = await recursiveLookup(glob.base, (path) => {
               return targetExtensions.some((extension) => path.endsWith(extension));
             });
 

package/lib/setup/keyboard-events.js

@@ -27,11 +27,6 @@ export default function setupKeyboardEvents(config, cachedContent, connections)
   });
 }
 
-function abortBrowserQUnit(config, connections) {
+function abortBrowserQUnit(_config, connections) {
   connections.server.publish('abort', 'abort');
 }
-
-function abortNodejsQUnit(config) {
-  window.QUnit.config.queue.length = 0;
-  config.aborted = true;
-}

package/lib/setup/test-file-paths.js

@@ -1,10 +1,10 @@
 import picomatch from 'picomatch';
 
-export default function setupTestFilePaths(projectRoot, inputs) {
+export default function setupTestFilePaths(_projectRoot, inputs) {
   // NOTE: very complex algorithm, order is very important
-  let [folders, filesWithGlob, filesWithoutGlob] = inputs.reduce(
+  const [folders, filesWithGlob, filesWithoutGlob] = inputs.reduce(
     (result, input) => {
-      let isGlob = picomatch.scan(input).isGlob;
+      const isGlob = picomatch.scan(input).isGlob;
 
       if (!pathIsFile(input)) {
         result[0].push({
@@ -25,7 +25,7 @@ export default function setupTestFilePaths(projectRoot, inputs) {
     [[], [], []],
   );
 
-  let result = folders.reduce((folderResult, folder) => {
+  const result = folders.reduce((folderResult, folder) => {
     if (!pathIsIncludedInPaths(folders, folder)) {
       folderResult.push(folder);
     }
@@ -48,7 +48,7 @@ export default function setupTestFilePaths(projectRoot, inputs) {
 }
 
 function pathIsFile(path) {
-  let inputs = path.split('/');
+  const inputs = path.split('/');
 
   return inputs[inputs.length - 1].includes('.');
 }
@@ -59,7 +59,7 @@ function pathIsIncludedInPaths(paths, targetPath) {
       return false;
     }
 
-    let globFormat = buildGlobFormat(path);
+    const globFormat = buildGlobFormat(path);
 
     return picomatch.isMatch(targetPath.input, globFormat, { bash: true });
   });

package/lib/setup/web-server.js

@@ -7,7 +7,7 @@ import HTTPServer, { MIME_TYPES } from '../servers/http.js';
 
 const fsPromise = fs.promises;
 
-export default async function setupWebServer(
+export default function setupWebServer(
   config = {
     port: 1234,
     debug: false,
@@ -16,8 +16,8 @@ export default async function setupWebServer(
   },
   cachedContent,
 ) {
-  let STATIC_FILES_PATH = path.join(config.projectRoot, config.output);
-  let server = new HTTPServer();
+  const STATIC_FILES_PATH = path.join(config.projectRoot, config.output);
+  const server = new HTTPServer();
 
   server.wss.on('connection', function connection(socket) {
     socket.on('message', function message(data) {
@@ -42,9 +42,9 @@ export default async function setupWebServer(
     });
   });
 
-  server.get('/', async (req, res) => {
-    let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
-    let htmlContent = escapeAndInjectTestsToHTML(
+  server.get('/', async (_req, res) => {
+    const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+    const htmlContent = escapeAndInjectTestsToHTML(
       replaceAssetPaths(
         cachedContent.mainHTML.html,
         cachedContent.mainHTML.filePath,
@@ -63,9 +63,9 @@ export default async function setupWebServer(
     );
   });
 
-  server.get('/qunitx.html', async (req, res) => {
-    let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
-    let htmlContent = escapeAndInjectTestsToHTML(
+  server.get('/qunitx.html', async (_req, res) => {
+    const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+    const htmlContent = escapeAndInjectTestsToHTML(
       replaceAssetPaths(
         cachedContent.mainHTML.html,
         cachedContent.mainHTML.filePath,
@@ -85,10 +85,11 @@ export default async function setupWebServer(
   });
 
   server.get('/*', async (req, res) => {
-    let possibleDynamicHTML = cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
+    const possibleDynamicHTML =
+      cachedContent.dynamicContentHTMLs[`${config.projectRoot}${req.path}`];
     if (possibleDynamicHTML) {
-      let TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
-      let htmlContent = escapeAndInjectTestsToHTML(
+      const TEST_RUNTIME_TO_INJECT = testRuntimeToInject(config.port, config);
+      const htmlContent = escapeAndInjectTestsToHTML(
         possibleDynamicHTML,
         TEST_RUNTIME_TO_INJECT,
         cachedContent.allTestCode,
@@ -103,12 +104,12 @@ export default async function setupWebServer(
       );
     }
 
-    let url = req.url;
-    let requestStartedAt = new Date();
-    let filePath = (
+    const url = req.url;
+    const requestStartedAt = new Date();
+    const filePath = (
       url.endsWith('/') ? [STATIC_FILES_PATH, url, 'index.html'] : [STATIC_FILES_PATH, url]
     ).join('');
-    let statusCode = (await pathExists(filePath)) ? 200 : 404;
+    const statusCode = (await pathExists(filePath)) ? 200 : 404;
 
     res.writeHead(statusCode, {
       'Content-Type': req.headers.accept?.includes('text/html')
@@ -129,11 +130,11 @@ export default async function setupWebServer(
 }
 
 function replaceAssetPaths(html, htmlPath, projectRoot) {
-  let assetPaths = findInternalAssetsFromHTML(html);
-  let htmlDirectory = htmlPath.split('/').slice(0, -1).join('/');
+  const assetPaths = findInternalAssetsFromHTML(html);
+  const htmlDirectory = htmlPath.split('/').slice(0, -1).join('/');
 
   return assetPaths.reduce((result, assetPath) => {
-    let normalizedFullAbsolutePath = path.normalize(`${htmlDirectory}/${assetPath}`);
+    const normalizedFullAbsolutePath = path.normalize(`${htmlDirectory}/${assetPath}`);
 
     return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, '.'));
   }, html);

package/lib/setup/write-output-static-files.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs/promises';
 
 export default async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
-  let staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
-    let htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, '');
+  const staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
+    const htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, '');
 
     await ensureFolderExists(`${projectRoot}/${output}/${htmlRelativePath}`);
     await fs.writeFile(
@@ -10,8 +10,8 @@ export default async function writeOutputStaticFiles({ projectRoot, output }, ca
       cachedContent.staticHTMLs[staticHTMLKey],
     );
   });
-  let assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
-    let assetRelativePath = assetAbsolutePath.replace(`${projectRoot}/`, '');
+  const assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
+    const assetRelativePath = assetAbsolutePath.replace(`${projectRoot}/`, '');
 
     await ensureFolderExists(`${projectRoot}/${output}/${assetRelativePath}`);
     await fs.copyFile(assetAbsolutePath, `${projectRoot}/${output}/${assetRelativePath}`);

package/lib/tap/display-test-result.js

@@ -22,7 +22,7 @@ export default function (COUNTER, details) {
     details.assertions.reduce((errorCount, assertion, index) => {
       if (!assertion.passed && assertion.todo === false) {
         COUNTER.errorCount++;
-        let stack = assertion.stack?.match(/\(.+\)/g);
+        const stack = assertion.stack?.match(/\(.+\)/g);
 
         console.log('  ---');
         console.log(
@@ -59,7 +59,7 @@ export default function (COUNTER, details) {
 
 function getCircularReplacer() {
   const ancestors = [];
-  return function (key, value) {
+  return function (_key, value) {
     if (typeof value !== 'object' || value === null) {
       return value;
     }

package/lib/utils/find-chrome.js

@@ -2,8 +2,8 @@ import { exec } from 'node:child_process';
 
 const CANDIDATES = ['google-chrome-stable', 'google-chrome', 'chromium', 'chromium-browser'];
 
-export default async function findChrome() {
-  if (process.env.CHROME_BIN) return process.env.CHROME_BIN;
+export default function findChrome() {
+  if (process.env.CHROME_BIN) return Promise.resolve(process.env.CHROME_BIN);
 
   return Promise.any(
     CANDIDATES.map(

package/lib/utils/find-project-root.js

@@ -3,13 +3,13 @@ import searchInParentDirectories from './search-in-parent-directories.js';
 
 export default async function () {
   try {
-    let absolutePath = await searchInParentDirectories('.', 'package.json');
+    const absolutePath = await searchInParentDirectories('.', 'package.json');
     if (!absolutePath.includes('package.json')) {
       throw new Error('package.json mising');
     }
 
     return absolutePath.replace('/package.json', '');
-  } catch (error) {
+  } catch (_error) {
     console.log('couldnt find projects package.json, did you run $ npm init ??');
     process.exit(1);
   }

package/lib/utils/listen-to-keyboard-key.js

@@ -1,8 +1,8 @@
 import process from 'node:process';
 
-let stdin = process.stdin;
-let targetInputs = {};
-let inputs = [];
+const stdin = process.stdin;
+const targetInputs = {};
+const inputs = [];
 let listenerAdded = false;
 
 export default function listenToKeyboardKey(
@@ -22,10 +22,10 @@ export default function listenToKeyboardKey(
       inputs.shift();
       inputs.push(key);
 
-      let inputString = inputs.join('');
-      let targetListener = targetInputs[inputString.toUpperCase()];
-      if (targetListener && targetListenerConformsToCase(targetListener, inputString)) {
-        targetListener.closure(inputString);
+      const currentInput = inputs.join('');
+      const targetListener = targetInputs[currentInput.toUpperCase()];
+      if (targetListener && targetListenerConformsToCase(targetListener, currentInput)) {
+        targetListener.closure(currentInput);
         inputs.fill(undefined);
       }
     });

package/lib/utils/resolve-port-number-for.js

@@ -6,15 +6,13 @@ export default async function resolvePortNumberFor(portNumber) {
   return await resolvePortNumberFor(portNumber + 1);
 }
 
-function portIsAvailable(portNumber) {
-  return new Promise(async (resolve) => {
-    const net = await import('net');
+async function portIsAvailable(portNumber) {
+  const net = await import('net');
+  return new Promise((resolve) => {
     const server = net.createServer();
 
-    server.once('error', function (err) {
-      if (err.code === 'EADDRINUSE') {
-        resolve(false);
-      }
+    server.once('error', function (_err) {
+      resolve(false);
     });
 
     server.once('listening', function () {

package/lib/utils/run-user-module.js

@@ -2,7 +2,7 @@ import kleur from 'kleur';
 
 export default async function runUserModule(modulePath, params, scriptPosition) {
   try {
-    let func = await import(modulePath);
+    const func = await import(modulePath);
     if (func) {
       func.default
         ? await func.default(params)

package/lib/utils/search-in-parent-directories.js

@@ -1,16 +1,16 @@
 import pathExists from './path-exists.js';
 
 async function searchInParentDirectories(directory, targetEntry) {
-  directory = directory === '.' ? process.cwd() : directory;
+  const resolvedDirectory = directory === '.' ? process.cwd() : directory;
 
-  if (await pathExists(`${directory}/${targetEntry}`)) {
-    return `${directory}/${targetEntry}`;
-  } else if (directory === '') {
+  if (await pathExists(`${resolvedDirectory}/${targetEntry}`)) {
+    return `${resolvedDirectory}/${targetEntry}`;
+  } else if (resolvedDirectory === '') {
     return;
   }
 
   return await searchInParentDirectories(
-    directory.slice(0, directory.lastIndexOf('/')),
+    resolvedDirectory.slice(0, resolvedDirectory.lastIndexOf('/')),
     targetEntry,
   );
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx-cli",
   "type": "module",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "main": "cli.js",
   "author": "Izel Nakri",
@@ -16,14 +16,15 @@
   ],
   "scripts": {
     "bin": "chmod +x cli.js && ./cli.js",
-    "lint": "prettier --check \"lib/**/*.js\" \"test/**/*.js\" \"*.js\" \"package.json\" \".github/**/*.yml\"",
-    "lint:fix": "prettier --write \"lib/**/*.js\" \"test/**/*.js\" \"*.js\" \"package.json\" \".github/**/*.yml\"",
+    "format": "prettier --check \"lib/**/*.js\" \"test/**/*.js\" \"*.js\" \"package.json\" \".github/**/*.yml\"",
+    "format:fix": "prettier --write \"lib/**/*.js\" \"test/**/*.js\" \"*.js\" \"package.json\" \".github/**/*.yml\"",
+    "lint": "deno lint lib/ cli.js",
     "build": "node build.js",
     "changelog:unreleased": "git-cliff --unreleased --strip all",
     "changelog:preview": "git-cliff",
     "changelog:update": "git-cliff --output CHANGELOG.md",
     "prepack": "npm run build",
-    "test": "node test/setup.js && node --test test/**/*-test.js",
+    "test": "node test/setup.js && FORCE_COLOR=0 node --test test/**/*-test.js",
     "test:sanity-first": "./cli.js test/helpers/failing-tests.js test/helpers/failing-tests.ts",
     "test:sanity-second": "./cli.js test/helpers/passing-tests.js test/helpers/passing-tests.ts"
   },
@@ -53,7 +54,7 @@
     "express": "^5.2.1",
     "prettier": "^3.8.1",
     "qunit": "^2.25.0",
-    "qunitx": "^0.9.3"
+    "qunitx": "^1.0.0"
   },
   "volta": {
     "node": "24.14.0"