qunitx-cli 0.9.2 → 0.9.4

package/lib/utils/{find-internal-assets-from-html.js → find-internal-assets-from-html.ts}

@@ -6,7 +6,7 @@ const LINK_HREF_REGEX = /<link[^>]+\bhref=['"]([^'"]+)['"]/gi;
  * Parses an HTML string and returns all internal (non-absolute-URL) `<script src>` and `<link href>` paths.
  * @returns {string[]}
  */
-export default function findInternalAssetsFromHTML(htmlContent) {
+export default function findInternalAssetsFromHTML(htmlContent: string): string[] {
   const links = [...htmlContent.matchAll(LINK_HREF_REGEX)]
     .map((m) => m[1])
     .filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));

package/lib/utils/{find-project-root.js → find-project-root.ts}

@@ -1,18 +1,18 @@
 import process from 'node:process';
-import searchInParentDirectories from './search-in-parent-directories.js';
+import searchInParentDirectories from './search-in-parent-directories.ts';
 
 /**
  * Walks up parent directories from `cwd` to find the nearest `package.json` and returns its directory path.
  * @returns {Promise<string>}
  */
-export default async function findProjectRoot() {
+export default async function findProjectRoot(): Promise<string> {
   try {
     const absolutePath = await searchInParentDirectories('.', 'package.json');
-    if (!absolutePath.includes('package.json')) {
+    if (!absolutePath!.includes('package.json')) {
       throw new Error('package.json mising');
     }
 
-    return absolutePath.replace('/package.json', '');
+    return absolutePath!.replace('/package.json', '');
   } catch (_error) {
     console.log('couldnt find projects package.json, did you run $ npm init ??');
     process.exit(1);

package/lib/utils/{indent-string.js → indent-string.ts}

@@ -2,12 +2,16 @@
  * Prepends `count` repetitions of `indent` (default: one space) to each non-empty line of `string`.
  * @example
  * ```js
- * import indentString from './lib/utils/indent-string.js';
+ * import indentString from './lib/utils/indent-string.ts';
  * console.assert(indentString('hello\nworld', 2) === '  hello\n  world');
  * ```
  * @returns {string}
  */
-export default function indentString(string, count = 1, options = {}) {
+export default function indentString(
+  string: string,
+  count: number = 1,
+  options: { indent?: string; includeEmptyLines?: boolean } = {},
+): string {
   const { indent = ' ', includeEmptyLines = false } = options;
 
   if (count <= 0) {

package/lib/utils/{listen-to-keyboard-key.js → listen-to-keyboard-key.ts}

@@ -1,8 +1,9 @@
 import process from 'node:process';
 
 const stdin = process.stdin;
-const targetInputs = {};
-const inputs = [];
+const targetInputs: Record<string, { caseSensitive: boolean; closure: (input: string) => void }> =
+  {};
+const inputs: (string | undefined)[] = [];
 let listenerAdded = false;
 
 /**
@@ -10,10 +11,10 @@ let listenerAdded = false;
  * @returns {void}
  */
 export default function listenToKeyboardKey(
-  inputString,
-  closure,
-  options = { caseSensitive: false },
-) {
+  inputString: string,
+  closure: (input: string) => void,
+  options: { caseSensitive: boolean } = { caseSensitive: false },
+): void {
   if (!stdin.isTTY) return;
   stdin.setRawMode(true);
   stdin.resume();
@@ -44,7 +45,10 @@ export default function listenToKeyboardKey(
   targetInputs[inputString.toUpperCase()] = Object.assign(options, { closure });
 }
 
-function targetListenerConformsToCase(targetListener, inputString) {
+function targetListenerConformsToCase(
+  targetListener: { caseSensitive: boolean },
+  inputString: string,
+): boolean {
   if (targetListener.caseSensitive) {
     return inputString === inputString.toUpperCase();
   }

package/lib/utils/{parse-cli-flags.js → parse-cli-flags.ts}

@@ -1,9 +1,24 @@
 // { inputs: [], debug: true, watch: true, failFast: true, htmlPaths: [], output }
+interface ParsedFlags {
+  inputs: string[];
+  debug?: boolean;
+  watch?: boolean;
+  failFast?: boolean;
+  timeout?: number;
+  output?: string;
+  htmlPaths?: string[];
+  port?: number;
+  extensions?: string[];
+  browser?: 'chromium' | 'firefox' | 'webkit';
+  before?: string | false;
+  after?: string | false;
+}
+
 /**
  * Parses `process.argv` into a qunitx flag object (`inputs`, `debug`, `watch`, `failFast`, `timeout`, `output`, `port`, `before`, `after`).
  * @returns {object}
  */
-export default function parseCliFlags(projectRoot) {
+export default function parseCliFlags(projectRoot: string): ParsedFlags {
   const providedFlags = process.argv.slice(2).reduce(
     (result, arg) => {
       if (arg.startsWith('--debug')) {
@@ -41,7 +56,7 @@ export default function parseCliFlags(projectRoot) {
           );
           process.exit(1);
         }
-        return Object.assign(result, { browser: value });
+        return Object.assign(result, { browser: value as 'chromium' | 'firefox' | 'webkit' });
       } else if (arg.startsWith('--before')) {
         return Object.assign(result, { before: parseModule(arg.split('=')[1]) });
       } else if (arg.startsWith('--after')) {
@@ -55,15 +70,13 @@ export default function parseCliFlags(projectRoot) {
 
       return result;
     },
-    { inputs: new Set([]) },
+    { inputs: new Set<string>([]) } as ParsedFlags & { inputs: Set<string> },
   );
 
-  providedFlags.inputs = Array.from(providedFlags.inputs);
-
-  return providedFlags;
+  return { ...providedFlags, inputs: Array.from(providedFlags.inputs) };
 }
 
-function parseBoolean(result, defaultValue = true) {
+function parseBoolean(result: string, defaultValue = true): boolean {
   if (result === 'true') {
     return true;
   } else if (result === 'false') {
@@ -73,7 +86,7 @@ function parseBoolean(result, defaultValue = true) {
   return defaultValue;
 }
 
-function parseModule(value) {
+function parseModule(value: string): string | false {
   if (['false', "'false'", '"false"', ''].includes(value)) {
     return false;
   }

package/lib/utils/{path-exists.js → path-exists.ts}

@@ -4,13 +4,13 @@ import fs from 'node:fs/promises';
  * Returns `true` if the given filesystem path is accessible, `false` otherwise.
  * @example
  * ```js
- * import pathExists from './lib/utils/path-exists.js';
+ * import pathExists from './lib/utils/path-exists.ts';
  * console.assert(await pathExists('/tmp') === true);
  * console.assert(await pathExists('/tmp/nonexistent-qunitx-file') === false);
  * ```
  * @returns {Promise<boolean>}
  */
-export default async function pathExists(path) {
+export default async function pathExists(path: string): Promise<boolean> {
   try {
     await fs.access(path);
 

package/lib/utils/{perf-logger.js → perf-logger.ts}

@@ -17,7 +17,7 @@ const processStart = isPerfTracing ? Date.now() : 0;
  * @param {string} label
  * @param {...*} details
  */
-export function perfLog(label, ...details) {
+export function perfLog(label: string, ...details: unknown[]): void {
   if (!isPerfTracing) return;
   const elapsed = Date.now() - processStart;
   const suffix = details.length ? ' ' + details.join(' ') : '';

package/lib/utils/{pre-launch-chrome.js → pre-launch-chrome.ts}

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import type { EarlyChrome } from '../types.ts';
 
 const CDP_URL_REGEX = /DevTools listening on (ws:\/\/[^\s]+)/;
 
@@ -8,7 +9,10 @@ const CDP_URL_REGEX = /DevTools listening on (ws:\/\/[^\s]+)/;
  * fails to start, so callers can fall back to playwright's normal launch.
  * @returns {Promise<{proc: ChildProcess, cdpEndpoint: string} | null>}
  */
-export default function preLaunchChrome(chromePath, args) {
+export default function preLaunchChrome(
+  chromePath: string | null | undefined,
+  args: string[],
+): Promise<EarlyChrome | null> {
   if (!chromePath) return Promise.resolve(null);
 
   return new Promise((resolve) => {

package/lib/utils/{read-boilerplate.js → read-boilerplate.ts}

@@ -8,7 +8,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
  * Reads a boilerplate file by relative path, using the SEA asset store when running as a Node.js binary.
  * @returns {Promise<string>}
  */
-export default async function readBoilerplate(relativePath) {
+export default async function readBoilerplate(relativePath: string): Promise<string> {
   const sea = await import('node:sea').catch(() => null);
   if (sea?.isSea()) return sea.getAsset(relativePath, 'utf8');
   return (await fs.readFile(join(__dirname, '../../templates', relativePath))).toString();

package/lib/utils/{resolve-port-number-for.js → resolve-port-number-for.ts}

@@ -2,7 +2,7 @@
  * Returns `portNumber` if it is free, otherwise recursively tries `portNumber + 1` until a free port is found.
  * @returns {Promise<number>}
  */
-export default async function resolvePortNumberFor(portNumber) {
+export default async function resolvePortNumberFor(portNumber: number): Promise<number> {
   if (await portIsAvailable(portNumber)) {
     return portNumber;
   }
@@ -10,7 +10,7 @@ export default async function resolvePortNumberFor(portNumber) {
   return await resolvePortNumberFor(portNumber + 1);
 }
 
-async function portIsAvailable(portNumber) {
+async function portIsAvailable(portNumber: number): Promise<boolean> {
   const net = await import('net');
   return new Promise((resolve) => {
     const server = net.createServer();

package/lib/utils/{run-user-module.js → run-user-module.ts}

@@ -1,10 +1,14 @@
-import { red } from './color.js';
+import { red } from './color.ts';
 
 /**
  * Dynamically imports `modulePath` and calls its default export with `params`; exits with code 1 on error.
  * @returns {Promise<void>}
  */
-export default async function runUserModule(modulePath, params, scriptPosition) {
+export default async function runUserModule(
+  modulePath: string,
+  params: unknown,
+  scriptPosition: string,
+): Promise<void> {
   try {
     const func = await import(modulePath);
     if (func) {

package/lib/utils/{search-in-parent-directories.js → search-in-parent-directories.ts}

@@ -1,10 +1,13 @@
-import pathExists from './path-exists.js';
+import pathExists from './path-exists.ts';
 
 /**
  * Recursively searches `directory` and its ancestors for a file or folder named `targetEntry`; returns the absolute path or `undefined`.
  * @returns {Promise<string|undefined>}
  */
-async function searchInParentDirectories(directory, targetEntry) {
+async function searchInParentDirectories(
+  directory: string,
+  targetEntry: string,
+): Promise<string | undefined> {
   const resolvedDirectory = directory === '.' ? process.cwd() : directory;
 
   if (await pathExists(`${resolvedDirectory}/${targetEntry}`)) {

package/lib/utils/{time-counter.js → time-counter.ts}

@@ -2,14 +2,14 @@
  * Returns a timer object with a `startTime` Date and a `stop()` method that returns elapsed milliseconds.
  * @example
  * ```js
- * import timeCounter from './lib/utils/time-counter.js';
+ * import timeCounter from './lib/utils/time-counter.ts';
  * const t = timeCounter();
  * const ms = t.stop();
  * console.assert(ms >= 0);
  * ```
  * @returns {{ startTime: Date, stop: () => number }}
  */
-export default function timeCounter() {
+export default function timeCounter(): { startTime: Date; stop: () => number } {
   const startTime = new Date();
 
   return {

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "qunitx-cli",
   "type": "module",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
-  "main": "cli.js",
+  "main": "cli.ts",
   "author": "Izel Nakri",
   "license": "MIT",
   "keywords": [
@@ -15,27 +15,27 @@
     "qunitx"
   ],
   "scripts": {
-    "bin": "chmod +x cli.js && ./cli.js",
-    "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",
+    "bin": "chmod +x cli.ts && ./cli.ts",
+    "format": "prettier --check \"lib/**/*.ts\" \"test/**/*.ts\" \"*.ts\" \"package.json\" \".github/**/*.yml\"",
+    "format:fix": "prettier --write \"lib/**/*.ts\" \"test/**/*.ts\" \"*.ts\" \"package.json\" \".github/**/*.yml\"",
+    "lint": "deno lint lib/ cli.ts",
     "lint:docs": "node scripts/lint-docs.js",
-    "docs": "deno doc --html --name=\"qunitx-cli\" --output=docs/lib 'lib/**/*.js' README.md",
+    "docs": "deno doc --html --name=\"qunitx-cli\" --output=docs/lib 'lib/**/*.ts' README.md",
     "changelog:unreleased": "git-cliff --unreleased --strip all",
     "changelog:preview": "git-cliff",
     "changelog:update": "git-cliff --output CHANGELOG.md",
     "postinstall": "deno install --allow-scripts=npm:playwright-core || true",
-    "test": "node test/setup.js && FORCE_COLOR=0 node --test --test-concurrency=$(node -p 'require(\"os\").availableParallelism()') test/**/*-test.js",
-    "test:browser": "node test/setup.js && FORCE_COLOR=0 node --test --test-concurrency=$(node -p 'require(\"os\").availableParallelism()') test/flags/*-test.js test/inputs/*-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"
+    "test": "node --experimental-strip-types test/setup.ts && FORCE_COLOR=0 node --experimental-strip-types --test --test-concurrency=$(node -p 'require(\"os\").availableParallelism()') test/**/*-test.ts",
+    "test:browser": "node --experimental-strip-types test/setup.ts && FORCE_COLOR=0 node --experimental-strip-types --test --test-concurrency=$(node -p 'require(\"os\").availableParallelism()') test/flags/*-test.ts test/inputs/*-test.ts",
+    "test:sanity-first": "./cli.ts test/helpers/failing-tests.js test/helpers/failing-tests.ts",
+    "test:sanity-second": "./cli.ts test/helpers/passing-tests.js test/helpers/passing-tests.ts"
   },
   "engines": {
     "node": ">=24.0.0",
     "deno": ">=2.7.0"
   },
   "bin": {
-    "qunitx": "cli.js"
+    "qunitx": "cli.ts"
   },
   "repository": {
     "type": "git",
@@ -43,7 +43,6 @@
   },
   "dependencies": {
     "esbuild": "^0.27.3",
-    "picomatch": "^4.0.4",
     "playwright-core": "^1.58.2",
     "ws": "^8.20.0"
   },
@@ -52,7 +51,8 @@
     "express": "^5.2.1",
     "js-yaml": "^4.1.1",
     "prettier": "^3.8.1",
-    "qunitx": "^1.0.4"
+    "qunitx": "^1.0.4",
+    "typescript": "^5.0.0"
   },
   "volta": {
     "node": "24.14.0"

package/lib/setup/bind-server-to-port.js

@@ -1,9 +0,0 @@
-/**
- * Binds an HTTPServer to an OS-assigned port and writes the resolved port back to `config.port`.
- * @returns {Promise<object>}
- */
-export default async function bindServerToPort(server, config) {
-  await server.listen(0);
-  config.port = server._server.address().port;
-  return server;
-}

package/lib/setup/config.js

@@ -1,48 +0,0 @@
-import fs from 'node:fs/promises';
-import defaultProjectConfigValues from './default-project-config-values.js';
-import findProjectRoot from '../utils/find-project-root.js';
-import setupFSTree from './fs-tree.js';
-import setupTestFilePaths from './test-file-paths.js';
-import parseCliFlags from '../utils/parse-cli-flags.js';
-
-/**
- * Builds the merged qunitx config from package.json settings and CLI flags.
- * @returns {Promise<object>}
- */
-export default async function setupConfig() {
-  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,
-    ...cliConfigFlags,
-    projectRoot,
-    inputs,
-    testFileLookupPaths: setupTestFilePaths(projectRoot, inputs),
-    lastFailedTestFiles: null,
-    lastRanTestFiles: null,
-  };
-  config.htmlPaths = normalizeHTMLPaths(config.projectRoot, config.htmlPaths);
-  config.fsTree = await setupFSTree(config.testFileLookupPaths, config);
-
-  return config;
-}
-
-async function readConfigFromPackageJSON(projectRoot) {
-  const packageJSON = await fs.readFile(`${projectRoot}/package.json`);
-
-  return JSON.parse(packageJSON.toString());
-}
-
-function normalizeHTMLPaths(projectRoot, htmlPaths) {
-  return Array.from(new Set(htmlPaths.map((htmlPath) => `${projectRoot}/${htmlPath}`)));
-}
-
-function readInputsFromPackageJSON(packageJSON) {
-  const qunitx = packageJSON.qunitx;
-
-  return qunitx && qunitx.inputs ? qunitx.inputs : [];
-}