qunitx-cli 0.9.4 → 0.9.8

package/lib/types.ts

@@ -1,61 +0,0 @@
-import type HTTPServer from './servers/http.ts';
-import type { Browser, Page } from 'playwright-core';
-import type { ChildProcess } from 'node:child_process';
-import type { Buffer } from 'node:buffer';
-
-export interface Counter {
-  testCount: number;
-  failCount: number;
-  skipCount: number;
-  passCount: number;
-  errorCount: number;
-}
-
-export type FSTree = Record<string, null>;
-
-export interface CachedContent {
-  allTestCode: Buffer | string | null;
-  filteredTestCode?: string;
-  assets: Set<string>;
-  htmlPathsToRunTests: string[];
-  mainHTML: { filePath: string | null; html: string | null };
-  staticHTMLs: Record<string, string>;
-  dynamicContentHTMLs: Record<string, string>;
-}
-
-export interface Config {
-  output: string;
-  timeout: number;
-  failFast: boolean;
-  port: number;
-  extensions: string[];
-  browser: 'chromium' | 'firefox' | 'webkit';
-  projectRoot: string;
-  inputs: string[];
-  htmlPaths: string[];
-  testFileLookupPaths: string[];
-  fsTree: FSTree;
-  before?: string | false;
-  after?: string | false;
-  watch?: boolean;
-  debug?: boolean;
-  COUNTER: Counter;
-  lastFailedTestFiles: string[] | null;
-  lastRanTestFiles: string[] | null;
-  _testRunDone: (() => void) | null;
-  _resetTestTimeout: (() => void) | null;
-  _groupMode?: boolean;
-  _building?: boolean;
-  expressApp?: unknown;
-}
-
-export interface Connections {
-  server: HTTPServer;
-  browser: Browser;
-  page: Page;
-}
-
-export interface EarlyChrome {
-  proc: ChildProcess;
-  cdpEndpoint: string;
-}

package/lib/utils/chromium-args.ts

@@ -1,18 +0,0 @@
-/** Launch args passed to Chromium for both the CDP pre-launch spawn and the playwright fallback launch. */
-export default [
-  '--no-sandbox',
-  '--disable-gpu',
-  '--window-size=1440,900',
-  '--disable-extensions',
-  '--disable-sync',
-  '--no-first-run',
-  '--disable-default-apps',
-  '--mute-audio',
-  '--disable-background-networking',
-  '--disable-background-timer-throttling',
-  '--disable-renderer-backgrounding',
-  '--disable-dev-shm-usage',
-  '--disable-translate',
-  '--metrics-recording-only',
-  '--disable-hang-monitor',
-] as string[];

package/lib/utils/color.ts

@@ -1,66 +0,0 @@
-/**
- * Minimal ANSI color helpers. Respects NO_COLOR, NODE_DISABLE_COLORS, FORCE_COLOR, and TTY
- * detection — same logic as kleur.
- *
- * Use `createColors(enabled)` in tests to exercise both enabled and disabled branches directly.
- */
-
-interface MagentaReturn {
-  bold: (t: string) => string;
-}
-
-interface MagentaFn {
-  (text: string): string;
-  (): MagentaReturn;
-}
-
-/** Creates a set of ANSI color helpers with coloring enabled or disabled. */
-export function createColors(enabled: boolean) {
-  const c = (open: number, close: number) => (text: string) =>
-    enabled ? `\x1b[${open}m${text}\x1b[${close}m` : String(text);
-
-  const red = c(31, 39);
-  const green = c(32, 39);
-  const yellow = c(33, 39);
-  const blue = c(34, 39);
-
-  /** `magenta(text)` — colored text. `magenta()` — chainable: `.bold(text)`. */
-  const magenta = ((text?: string): string | MagentaReturn => {
-    if (text !== undefined) return enabled ? `\x1b[35m${text}\x1b[39m` : String(text);
-    return { bold: (t: string) => (enabled ? `\x1b[35m\x1b[1m${t}\x1b[22m\x1b[39m` : String(t)) };
-  }) as MagentaFn;
-
-  return { red, green, yellow, blue, magenta };
-}
-
-const enabled =
-  !process.env.NODE_DISABLE_COLORS &&
-  process.env.NO_COLOR == null &&
-  process.env.TERM !== 'dumb' &&
-  ((process.env.FORCE_COLOR != null && process.env.FORCE_COLOR !== '0') || !!process.stdout?.isTTY);
-
-const _c = createColors(enabled);
-
-/** ANSI red text. */
-export function red(text: string): string {
-  return _c.red(text);
-}
-/** ANSI green text. */
-export function green(text: string): string {
-  return _c.green(text);
-}
-/** ANSI yellow text. */
-export function yellow(text: string): string {
-  return _c.yellow(text);
-}
-/** ANSI blue text. */
-export function blue(text: string): string {
-  return _c.blue(text);
-}
-/** ANSI magenta text. Call without arguments to chain: `magenta().bold(text)`. */
-export function magenta(text: string): string;
-/** ANSI magenta text. Call without arguments to chain: `magenta().bold(text)`. */
-export function magenta(): MagentaReturn;
-export function magenta(text?: string): string | MagentaReturn {
-  return _c.magenta(text as string);
-}

package/lib/utils/early-chrome.ts

@@ -1,39 +0,0 @@
-import findChrome from './find-chrome.ts';
-import preLaunchChrome from './pre-launch-chrome.ts';
-import CHROMIUM_ARGS from './chromium-args.ts';
-import { perfLog } from './perf-logger.ts';
-
-// This module is statically imported by cli.ts so its module-level code runs
-// at the very start of the process — before the IIFE, before playwright-core loads.
-// For run commands only, Chrome is spawned immediately via CDP so it is ready
-// (or nearly ready) by the time playwright-core finishes loading (~500ms later).
-// For help/init/generate, nothing is spawned and this module costs ~0ms.
-
-const NON_RUN_COMMANDS = new Set(['help', 'h', 'p', 'print', 'new', 'n', 'g', 'generate', 'init']);
-const isRunCommand = Boolean(process.argv[2]) && !NON_RUN_COMMANDS.has(process.argv[2]);
-const browserFromArgv =
-  process.argv.find((arg) => arg.startsWith('--browser='))?.split('=')[1] || 'chromium';
-
-let earlyChromeProcRef = null;
-process.on('exit', () => earlyChromeProcRef?.kill());
-
-perfLog('early-chrome.js: module evaluated');
-
-/**
- * Resolves to `{ proc, cdpEndpoint }` when Chrome is pre-launched and ready,
- * or `null` if pre-launch was skipped (non-run command or non-chromium browser).
- * @type {Promise<{proc: import('node:child_process').ChildProcess, cdpEndpoint: string} | null>}
- */
-export const earlyBrowserPromise =
-  isRunCommand && browserFromArgv === 'chromium'
-    ? findChrome()
-        .then((chromePath) => {
-          perfLog('early-chrome.js: findChrome resolved', chromePath);
-          return preLaunchChrome(chromePath, CHROMIUM_ARGS);
-        })
-        .then((info) => {
-          perfLog('early-chrome.js: Chrome CDP ready', info?.cdpEndpoint ?? null);
-          if (info) earlyChromeProcRef = info.proc;
-          return info;
-        })
-    : Promise.resolve(null);

package/lib/utils/find-chrome.ts

@@ -1,38 +0,0 @@
-import { accessSync, constants } from 'node:fs';
-import { join } from 'node:path';
-
-const CANDIDATES = ['google-chrome-stable', 'google-chrome', 'chromium', 'chromium-browser'];
-const PATH_DIRS = (process.env.PATH || '').split(':').filter(Boolean);
-
-/**
- * Synchronously resolves the Chrome/Chromium executable path from `CHROME_BIN` or by probing
- * common binary names in PATH directories using accessSync.
- * Synchronous to avoid I/O saturation during the module-loading phase, which would cause async
- * fs.access/exec-based approaches to be delayed by hundreds of milliseconds.
- * @returns {string|null}
- */
-function findChromeSync(): string | null {
-  if (process.env.CHROME_BIN) return process.env.CHROME_BIN;
-
-  for (const dir of PATH_DIRS) {
-    for (const name of CANDIDATES) {
-      const fullPath = join(dir, name);
-      try {
-        accessSync(fullPath, constants.X_OK);
-        return fullPath;
-      } catch {
-        // not found or not executable, try next
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Resolves the Chrome/Chromium executable path. Returns a Promise for API compatibility
- * with callers, but the resolution is synchronous.
- * @returns {Promise<string|null>}
- */
-export default function findChrome(): Promise<string | null> {
-  return Promise.resolve(findChromeSync());
-}

package/lib/utils/find-internal-assets-from-html.ts

@@ -1,18 +0,0 @@
-const ABSOLUTE_URL_REGEX = /^(?:[a-z]+:)?\/\//i;
-const SCRIPT_SRC_REGEX = /<script[^>]+\bsrc=['"]([^'"]+)['"]/gi;
-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: string): string[] {
-  const links = [...htmlContent.matchAll(LINK_HREF_REGEX)]
-    .map((m) => m[1])
-    .filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
-  const scripts = [...htmlContent.matchAll(SCRIPT_SRC_REGEX)]
-    .map((m) => m[1])
-    .filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
-
-  return links.concat(scripts);
-}

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

@@ -1,20 +0,0 @@
-import process from 'node:process';
-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(): Promise<string> {
-  try {
-    const absolutePath = await searchInParentDirectories('.', 'package.json');
-    if (!absolutePath!.includes('package.json')) {
-      throw new Error('package.json mising');
-    }
-
-    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.ts

@@ -1,24 +0,0 @@
-/**
- * Prepends `count` repetitions of `indent` (default: one space) to each non-empty line of `string`.
- * @example
- * ```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: string,
-  count: number = 1,
-  options: { indent?: string; includeEmptyLines?: boolean } = {},
-): string {
-  const { indent = ' ', includeEmptyLines = false } = options;
-
-  if (count <= 0) {
-    return string;
-  }
-
-  const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
-
-  return string.replace(regex, indent.repeat(count));
-}

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

@@ -1,57 +0,0 @@
-import process from 'node:process';
-
-const stdin = process.stdin;
-const targetInputs: Record<string, { caseSensitive: boolean; closure: (input: string) => void }> =
-  {};
-const inputs: (string | undefined)[] = [];
-let listenerAdded = false;
-
-/**
- * Registers a stdin listener that fires `closure` when the user types `inputString` (case-insensitive by default).
- * @returns {void}
- */
-export default function listenToKeyboardKey(
-  inputString: string,
-  closure: (input: string) => void,
-  options: { caseSensitive: boolean } = { caseSensitive: false },
-): void {
-  if (!stdin.isTTY) return;
-  stdin.setRawMode(true);
-  stdin.resume();
-  stdin.setEncoding('utf8');
-  if (!listenerAdded) {
-    stdin.on('data', function (key) {
-      if (key === '\u0003') {
-        process.exit(); // so node process doesnt trap Control-C
-      }
-
-      inputs.shift();
-      inputs.push(key);
-
-      const currentInput = inputs.join('');
-      const targetListener = targetInputs[currentInput.toUpperCase()];
-      if (targetListener && targetListenerConformsToCase(targetListener, currentInput)) {
-        targetListener.closure(currentInput);
-        inputs.fill(undefined);
-      }
-    });
-    listenerAdded = true;
-  }
-
-  if (inputString.length > inputs.length) {
-    inputs.length = inputString.length;
-  }
-
-  targetInputs[inputString.toUpperCase()] = Object.assign(options, { closure });
-}
-
-function targetListenerConformsToCase(
-  targetListener: { caseSensitive: boolean },
-  inputString: string,
-): boolean {
-  if (targetListener.caseSensitive) {
-    return inputString === inputString.toUpperCase();
-  }
-
-  return true;
-}

package/lib/utils/parse-cli-flags.ts

@@ -1,95 +0,0 @@
-// { 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: string): ParsedFlags {
-  const providedFlags = process.argv.slice(2).reduce(
-    (result, arg) => {
-      if (arg.startsWith('--debug')) {
-        return Object.assign(result, { debug: parseBoolean(arg.split('=')[1]) });
-      } else if (arg.startsWith('--watch')) {
-        return Object.assign(result, { watch: parseBoolean(arg.split('=')[1]) });
-      } else if (arg.startsWith('--failfast') || arg.startsWith('--failFast')) {
-        return Object.assign(result, { failFast: parseBoolean(arg.split('=')[1]) });
-      } else if (arg.startsWith('--timeout')) {
-        return Object.assign(result, { timeout: Number(arg.split('=')[1]) || 10000 });
-      } else if (arg.startsWith('--output')) {
-        return Object.assign(result, { output: arg.split('=')[1] });
-      } else if (arg.endsWith('.html')) {
-        if (result.htmlPaths) {
-          result.htmlPaths.push(arg);
-        } else {
-          result.htmlPaths = [arg];
-        }
-
-        return result;
-      } else if (arg.startsWith('--port')) {
-        return Object.assign(result, { port: Number(arg.split('=')[1]) });
-      } else if (arg.startsWith('--extensions')) {
-        return Object.assign(result, {
-          extensions: arg
-            .split('=')[1]
-            .split(',')
-            .map((e) => e.trim()),
-        });
-      } else if (arg.startsWith('--browser')) {
-        const value = arg.split('=')[1];
-        if (!['chromium', 'firefox', 'webkit'].includes(value)) {
-          console.error(
-            `Invalid --browser value: "${value}". Must be one of: chromium, firefox, webkit`,
-          );
-          process.exit(1);
-        }
-        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')) {
-        return Object.assign(result, { after: parseModule(arg.split('=')[1]) });
-      } else if (arg === '--trace-perf') {
-        return result; // consumed by perf-logger.js at module load time, not stored in config
-      }
-
-      // maybe set watch depth via micromatch(so incl metadata)
-      result.inputs.add(arg.startsWith(projectRoot) ? arg : `${process.cwd()}/${arg}`);
-
-      return result;
-    },
-    { inputs: new Set<string>([]) } as ParsedFlags & { inputs: Set<string> },
-  );
-
-  return { ...providedFlags, inputs: Array.from(providedFlags.inputs) };
-}
-
-function parseBoolean(result: string, defaultValue = true): boolean {
-  if (result === 'true') {
-    return true;
-  } else if (result === 'false') {
-    return false;
-  }
-
-  return defaultValue;
-}
-
-function parseModule(value: string): string | false {
-  if (['false', "'false'", '"false"', ''].includes(value)) {
-    return false;
-  }
-
-  return value;
-}

package/lib/utils/path-exists.ts

@@ -1,21 +0,0 @@
-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.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: string): Promise<boolean> {
-  try {
-    await fs.access(path);
-
-    return true;
-  } catch {
-    return false;
-  }
-}

package/lib/utils/perf-logger.ts

@@ -1,25 +0,0 @@
-/**
- * Performance tracing logger for qunitx internals.
- *
- * Enable by passing `--trace-perf` to any run command:
- *   qunitx test/foo.js --trace-perf
- *
- * All perfLog() calls are zero-overhead no-ops when tracing is disabled —
- * the flag is read once at module load time, no per-call argument evaluation.
- */
-
-const isPerfTracing = process.argv.includes('--trace-perf');
-
-const processStart = isPerfTracing ? Date.now() : 0;
-
-/**
- * Writes a timestamped perf trace line to stderr when --trace-perf is active.
- * @param {string} label
- * @param {...*} details
- */
-export function perfLog(label: string, ...details: unknown[]): void {
-  if (!isPerfTracing) return;
-  const elapsed = Date.now() - processStart;
-  const suffix = details.length ? ' ' + details.join(' ') : '';
-  process.stderr.write(`[perf +${elapsed}ms] ${label}${suffix}\n`);
-}

package/lib/utils/pre-launch-chrome.ts

@@ -1,45 +0,0 @@
-import { spawn } from 'node:child_process';
-import type { EarlyChrome } from '../types.ts';
-
-const CDP_URL_REGEX = /DevTools listening on (ws:\/\/[^\s]+)/;
-
-/**
- * Spawns a headless Chrome process with remote-debugging-port=0 and resolves once the
- * CDP WebSocket endpoint is printed to stderr. Returns null if Chrome is unavailable or
- * 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: string | null | undefined,
-  args: string[],
-): Promise<EarlyChrome | null> {
-  if (!chromePath) return Promise.resolve(null);
-
-  return new Promise((resolve) => {
-    const proc = spawn(chromePath, ['--remote-debugging-port=0', '--headless=new', ...args], {
-      stdio: ['ignore', 'ignore', 'pipe'],
-    });
-
-    let buffer = '';
-    proc.stderr.on('data', (chunk) => {
-      buffer += chunk.toString();
-      const match = buffer.match(CDP_URL_REGEX);
-      if (match) {
-        // Unref so Chrome's process + stderr pipe don't keep the Node.js event loop alive
-        // after all test work is done. Chrome is still killed via process.on('exit').
-        proc.unref();
-        proc.stderr.unref();
-        resolve({ proc, cdpEndpoint: match[1] });
-      }
-    });
-
-    // Resolve null on any startup failure so launchBrowser falls back to chromium.launch().
-    // The close handler resolves unconditionally: if Chrome exits before printing its CDP URL
-    // (code=0 for a clean exit, code=null for a signal-killed process such as OOM on CI),
-    // the original condition `code !== null && code !== 0` would leave the promise pending
-    // forever, causing launchBrowser to hang and the event loop to drain silently (exit 0).
-    // If Chrome already printed its URL and the promise is resolved, this is a no-op.
-    proc.on('error', () => resolve(null));
-    proc.on('close', () => resolve(null));
-  });
-}

package/lib/utils/read-boilerplate.ts

@@ -1,15 +0,0 @@
-import fs from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-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: 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.ts

@@ -1,29 +0,0 @@
-/**
- * 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: number): Promise<number> {
-  if (await portIsAvailable(portNumber)) {
-    return portNumber;
-  }
-
-  return await resolvePortNumberFor(portNumber + 1);
-}
-
-async function portIsAvailable(portNumber: number): Promise<boolean> {
-  const net = await import('net');
-  return new Promise((resolve) => {
-    const server = net.createServer();
-
-    server.once('error', function (_err) {
-      resolve(false);
-    });
-
-    server.once('listening', function () {
-      server.close();
-      resolve(true);
-    });
-
-    server.listen(portNumber);
-  });
-}

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

@@ -1,28 +0,0 @@
-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: string,
-  params: unknown,
-  scriptPosition: string,
-): Promise<void> {
-  try {
-    const func = await import(modulePath);
-    if (func) {
-      func.default
-        ? await func.default(params)
-        : typeof func === 'function'
-          ? await func(params)
-          : null;
-    }
-  } catch (error) {
-    console.log('#', red(`QUnitX ${scriptPosition} script failed:`));
-    console.trace(error);
-    console.error(error);
-
-    return process.exit(1);
-  }
-}

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

@@ -1,25 +0,0 @@
-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: string,
-  targetEntry: string,
-): Promise<string | undefined> {
-  const resolvedDirectory = directory === '.' ? process.cwd() : directory;
-
-  if (await pathExists(`${resolvedDirectory}/${targetEntry}`)) {
-    return `${resolvedDirectory}/${targetEntry}`;
-  } else if (resolvedDirectory === '') {
-    return;
-  }
-
-  return await searchInParentDirectories(
-    resolvedDirectory.slice(0, resolvedDirectory.lastIndexOf('/')),
-    targetEntry,
-  );
-}
-
-export default searchInParentDirectories;

package/lib/utils/time-counter.ts

@@ -1,19 +0,0 @@
-/**
- * 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.ts';
- * const t = timeCounter();
- * const ms = t.stop();
- * console.assert(ms >= 0);
- * ```
- * @returns {{ startTime: Date, stop: () => number }}
- */
-export default function timeCounter(): { startTime: Date; stop: () => number } {
-  const startTime = new Date();
-
-  return {
-    startTime: startTime,
-    stop: () => +new Date() - +startTime,
-  };
-}