qunitx-cli 0.9.4 → 0.9.7

package/lib/servers/http.ts

@@ -1,321 +0,0 @@
-import http from 'node:http';
-// @deno-types="npm:@types/ws"
-import WebSocket, { WebSocketServer } from 'ws';
-import bindServerToPort from '../setup/bind-server-to-port.ts';
-
-declare module 'node:http' {
-  interface IncomingMessage {
-    send: (data: string) => void;
-    path: string;
-    query: Record<string, string>;
-    params: Record<string, string>;
-  }
-  interface ServerResponse {
-    json: (data: unknown) => void;
-  }
-}
-
-type NodeServerWithWSS = http.Server & { wss: WebSocketServer };
-
-/** Route handler function signature for registered GET/POST/etc. routes. */
-export type RouteHandler = (
-  req: http.IncomingMessage,
-  res: http.ServerResponse,
-) => void | Promise<void>;
-/** Middleware function signature — call `next()` to continue the chain. */
-export type Middleware = (
-  req: http.IncomingMessage,
-  res: http.ServerResponse,
-  next: () => void,
-) => void;
-
-interface Route {
-  path: string;
-  handler: RouteHandler;
-  paramNames: string[];
-  isWildcard: boolean;
-  paramValues?: string[];
-}
-
-/** Map of file extensions to their corresponding MIME type strings. */
-export const MIME_TYPES: Record<string, string> = {
-  html: 'text/html; charset=UTF-8',
-  js: 'application/javascript',
-  css: 'text/css',
-  png: 'image/png',
-  jpg: 'image/jpg',
-  gif: 'image/gif',
-  ico: 'image/x-icon',
-  svg: 'image/svg+xml',
-};
-
-/** Minimal HTTP + WebSocket server used to serve test bundles and push reload events. */
-export default class HTTPServer {
-  /** Registered routes keyed by HTTP method then path. */
-  routes: Record<string, Record<string, Route>>;
-  /** Registered middleware functions, applied in order before each route handler. */
-  middleware: Middleware[];
-  /** Underlying Node.js HTTP server instance. */
-  _server: http.Server;
-  /** WebSocket server attached to the HTTP server for live-reload broadcasts. */
-  wss: WebSocketServer;
-
-  /**
-   * Creates and starts a plain `http.createServer` instance on the given port.
-   * @returns {Promise<object>}
-   */
-  static serve(
-    config: { port: number; onListen?: (s: object) => void; onError?: (e: Error) => void } = {
-      port: 1234,
-    },
-    handler: (req: http.IncomingMessage, res: http.ServerResponse) => void,
-  ): Promise<http.Server> {
-    const onListen = config.onListen || ((_server: object) => {});
-    const onError = config.onError || ((_error: Error) => {});
-
-    return new Promise((resolve, reject) => {
-      const server = http.createServer((req, res) => {
-        return handler(req, res);
-      });
-      server
-        .on('error', (error) => {
-          onError(error);
-          reject(error);
-        })
-        .once('listening', () => {
-          onListen(Object.assign({ hostname: '127.0.0.1', server }, config));
-          resolve(server);
-        });
-      (server as NodeServerWithWSS).wss = new WebSocketServer({ server });
-      (server as NodeServerWithWSS).wss.on('error', (error: Error) => {
-        console.log('# [WebSocketServer] Error:');
-        console.trace(error);
-      });
-
-      bindServerToPort(server as unknown as HTTPServer, config as { port: number });
-    });
-  }
-
-  constructor() {
-    this.routes = {
-      GET: {},
-      POST: {},
-      DELETE: {},
-      PUT: {},
-    };
-    this.middleware = [];
-    this._server = http.createServer((req, res) => {
-      req.send = (data: string) => {
-        res.setHeader('Content-Type', 'text/plain');
-        res.end(data);
-      };
-      res.json = (data: unknown) => {
-        res.setHeader('Content-Type', 'application/json');
-        res.end(JSON.stringify(data));
-      };
-
-      return this.#handleRequest(req, res);
-    });
-    this.wss = new WebSocketServer({ server: this._server });
-    this.wss.on('error', (error) => {
-      console.log('# [WebSocketServer] Error:');
-      console.log(error);
-    });
-  }
-
-  /**
-   * Closes the underlying HTTP server and all active connections, returning a
-   * Promise that resolves once the server is fully closed.
-   * @returns {Promise<void>}
-   */
-  close(): Promise<void> {
-    this._server.closeAllConnections?.();
-    return new Promise((resolve) => this._server.close(resolve as () => void));
-  }
-
-  /** Registers a GET route handler. */
-  get(path: string, handler: RouteHandler): void {
-    this.#registerRouteHandler('GET', path, handler);
-  }
-
-  /**
-   * Starts listening on the given port (0 = OS-assigned).
-   * @returns {Promise<void>}
-   */
-  listen(port = 0, callback: () => void = () => {}): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const onError = (err: Error) => {
-        this._server.off('listening', onListening);
-        reject(err);
-      };
-      const onListening = () => {
-        this._server.off('error', onError);
-        resolve(callback());
-      };
-      this._server.once('error', onError);
-      this._server.once('listening', onListening);
-      this._server.listen(port);
-    });
-  }
-
-  /** Broadcasts a message to all connected WebSocket clients. */
-  publish(data: string): void {
-    this.wss.clients.forEach((client) => {
-      if (client.readyState === WebSocket.OPEN) {
-        client.send(data);
-      }
-    });
-  }
-
-  /** Registers a POST route handler. */
-  post(path: string, handler: RouteHandler): void {
-    this.#registerRouteHandler('POST', path, handler);
-  }
-
-  /** Registers a DELETE route handler. */
-  delete(path: string, handler: RouteHandler): void {
-    this.#registerRouteHandler('DELETE', path, handler);
-  }
-
-  /** Registers a PUT route handler. */
-  put(path: string, handler: RouteHandler): void {
-    this.#registerRouteHandler('PUT', path, handler);
-  }
-
-  /** Adds a middleware function to the chain. */
-  use(middleware: Middleware): void {
-    this.middleware.push(middleware);
-  }
-
-  #registerRouteHandler(method: string, path: string, handler: RouteHandler): void {
-    if (!this.routes[method]) {
-      this.routes[method] = {};
-    }
-
-    this.routes[method][path] = {
-      path,
-      handler,
-      paramNames: this.#extractParamNames(path),
-      isWildcard: path === '/*',
-    };
-  }
-
-  #handleRequest(req: http.IncomingMessage, res: http.ServerResponse): void {
-    const { method, url } = req;
-    const urlObj = new URL(url!, 'http://localhost');
-    const pathname = urlObj.pathname;
-    req.path = pathname;
-    req.query = Object.fromEntries(urlObj.searchParams);
-    const matchingRoute = this.#findRouteHandler(method!, pathname);
-
-    if (matchingRoute) {
-      req.params = this.#extractParams(matchingRoute, pathname);
-      this.#runMiddleware(req, res, matchingRoute.handler);
-    } else {
-      res.statusCode = 404;
-      res.setHeader('Content-Type', 'text/plain');
-      res.end('Not found');
-    }
-  }
-
-  #runMiddleware(
-    req: http.IncomingMessage,
-    res: http.ServerResponse,
-    callback: RouteHandler,
-  ): void {
-    let index = 0;
-    const next = () => {
-      if (index >= this.middleware.length) {
-        callback(req, res);
-      } else {
-        const middleware = this.middleware[index];
-        index++;
-        middleware(req, res, next);
-      }
-    };
-    next();
-  }
-
-  #findRouteHandler(method: string, url: string): Route | null {
-    const routes = this.routes[method];
-    if (!routes) {
-      return null;
-    }
-
-    return (
-      routes[url] ||
-      Object.values(routes).find((route) => {
-        const { path, isWildcard } = route;
-
-        if (!isWildcard && !path.includes(':')) {
-          return false;
-        }
-
-        if (isWildcard || this.#matchPathSegments(path, url)) {
-          if (route.paramNames.length > 0) {
-            const regexPattern = this.#buildRegexPattern(path, route.paramNames);
-            const regex = new RegExp(`^${regexPattern}$`);
-            const regexMatches = regex.exec(url);
-            if (regexMatches) {
-              route.paramValues = regexMatches.slice(1);
-            }
-          }
-          return true;
-        }
-
-        return false;
-      }) ||
-      routes['/*'] ||
-      null
-    );
-  }
-
-  #matchPathSegments(path: string, url: string): boolean {
-    const pathSegments = path.split('/');
-    const urlSegments = url.split('/');
-
-    if (pathSegments.length !== urlSegments.length) {
-      return false;
-    }
-
-    for (let i = 0; i < pathSegments.length; i++) {
-      const pathSegment = pathSegments[i];
-      const urlSegment = urlSegments[i];
-
-      if (pathSegment.startsWith(':')) {
-        continue;
-      }
-
-      if (pathSegment !== urlSegment) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  #buildRegexPattern(path: string, _paramNames: string[]): string {
-    let regexPattern = path.replace(/:[^/]+/g, '([^/]+)');
-    regexPattern = regexPattern.replace(/\//g, '\\/');
-
-    return regexPattern;
-  }
-
-  #extractParamNames(path: string): string[] {
-    const paramRegex = /:(\w+)/g;
-    const paramMatches = path.match(paramRegex);
-
-    return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
-  }
-
-  #extractParams(route: Route, _url: string): Record<string, string> {
-    const { paramNames, paramValues } = route;
-    const params: Record<string, string> = {};
-
-    for (let i = 0; i < paramNames.length; i++) {
-      params[paramNames[i]] = paramValues![i];
-    }
-
-    return params;
-  }
-}

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

@@ -1,14 +0,0 @@
-import type HTTPServer from '../servers/http.ts';
-
-/**
- * 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: HTTPServer,
-  config: { port: number },
-): Promise<HTTPServer> {
-  await server.listen(0);
-  config.port = (server._server.address() as import('node:net').AddressInfo).port;
-  return server;
-}

package/lib/setup/browser.ts

@@ -1,101 +0,0 @@
-import setupWebServer from './web-server.ts';
-import bindServerToPort from './bind-server-to-port.ts';
-import findChrome from '../utils/find-chrome.ts';
-import CHROMIUM_ARGS from '../utils/chromium-args.ts';
-import { earlyBrowserPromise } from '../utils/early-chrome.ts';
-import { perfLog } from '../utils/perf-logger.ts';
-import type { Browser } from 'playwright-core';
-import type { Config, CachedContent, Connections } from '../types.ts';
-
-// Playwright-core starts loading the moment run.js imports this module.
-// browser.js is intentionally the first import in run.js so playwright-core
-// starts loading before heavier deps (esbuild, chokidar) queue up I/O reads
-// and saturate libuv's thread pool, which would delay the dynamic import resolution.
-// early-chrome.ts (statically imported by cli.ts) already started Chrome pre-launch,
-// so both race in parallel — Chrome is typically ready when playwright-core finishes.
-const playwrightCorePromise = import('playwright-core');
-perfLog('browser.js: playwright-core import started');
-
-/**
- * Launches a browser for the given config.browser type.
- * For chromium: connects via CDP to the pre-launched Chrome (fast path) or falls
- * back to chromium.launch() if pre-launch failed.
- * For firefox/webkit: uses playwright's standard launch (requires `npx playwright install [browser]`).
- * @returns {Promise<object>}
- */
-export async function launchBrowser(config: Config): Promise<Browser> {
-  const browserName = config.browser || 'chromium';
-
-  if (browserName === 'chromium') {
-    const waitStart = Date.now();
-    const [playwrightCore, earlyChrome] = await Promise.all([
-      playwrightCorePromise,
-      earlyBrowserPromise,
-    ]);
-    perfLog(
-      `browser.js: playwright-core + earlyChrome resolved in ${Date.now() - waitStart}ms, earlyChrome:`,
-      earlyChrome?.cdpEndpoint ?? null,
-    );
-
-    if (earlyChrome) {
-      const connectStart = Date.now();
-      const browser = await playwrightCore.chromium.connectOverCDP({
-        endpointURL: earlyChrome.cdpEndpoint,
-      });
-      perfLog(`browser.js: connectOverCDP took ${Date.now() - connectStart}ms`);
-      return browser;
-    }
-
-    // Pre-launch failed (Chrome not found, wrong version, etc.) — fall back to normal launch.
-    const executablePath = await findChrome();
-    const launchOptions = { args: CHROMIUM_ARGS, headless: true };
-    if (executablePath) launchOptions.executablePath = executablePath;
-    return playwrightCore.chromium.launch(launchOptions);
-  }
-
-  const playwrightCore = await playwrightCorePromise;
-  return playwrightCore[browserName].launch({ headless: true });
-}
-
-/**
- * Launches a Playwright browser (or reuses an existing one), starts the web server, and returns the page/server/browser connection object.
- * @returns {Promise<{server: object, browser: object, page: object}>}
- */
-export default async function setupBrowser(
-  config: Config,
-  cachedContent: CachedContent,
-  existingBrowser: Browser | null = null,
-): Promise<Connections> {
-  const setupStart = Date.now();
-  const [server, resolvedExistingBrowser] = await Promise.all([
-    setupWebServer(config, cachedContent),
-    Promise.resolve(existingBrowser),
-  ]);
-  perfLog(`browser.js: setupWebServer took ${Date.now() - setupStart}ms`);
-
-  const browser = resolvedExistingBrowser || (await launchBrowser(config));
-
-  const pageStart = Date.now();
-  const [page] = await Promise.all([browser.newPage(), bindServerToPort(server, config)]);
-  perfLog(`browser.js: newPage + bindServerToPort took ${Date.now() - pageStart}ms`);
-
-  await page.addInitScript(() => {
-    window.IS_PLAYWRIGHT = true;
-  });
-
-  page.on('console', async (msg) => {
-    if (!config.debug) return;
-    try {
-      const values = await Promise.all(msg.args().map((arg) => arg.jsonValue()));
-      console.log(...values);
-    } catch {
-      console.log(msg.text());
-    }
-  });
-  page.on('pageerror', (error) => {
-    console.log(error.toString());
-    console.error(error.toString());
-  });
-
-  return { server, browser, page };
-}

package/lib/setup/config.ts

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

package/lib/setup/default-project-config-values.ts

@@ -1,9 +0,0 @@
-/** Default qunitx config values: build output directory, test timeout (ms), fail-fast flag, HTTP server port, and tracked file extensions. */
-export default {
-  output: 'tmp',
-  timeout: 20000,
-  failFast: false,
-  port: 1234,
-  extensions: ['js', 'ts'],
-  browser: 'chromium',
-};

package/lib/setup/file-watcher.ts

@@ -1,134 +0,0 @@
-import fs from 'node:fs';
-import { stat } from 'node:fs/promises';
-import path from 'node:path';
-import { green, magenta, red, yellow } from '../utils/color.ts';
-import type { FSWatcher } from 'node:fs';
-import type { Config, FSTree } from '../types.ts';
-
-/**
- * Starts `fs.watch` watchers for each lookup path and calls `onEventFunc` on JS/TS file changes, debounced via a flag.
- * Uses `config.fsTree` to distinguish `unlink` (tracked file) from `unlinkDir` (directory) on deletion.
- * @returns {object}
- */
-export default function setupFileWatchers(
-  testFileLookupPaths: string[],
-  config: Config,
-  onEventFunc: (event: string, file: string) => unknown,
-  onFinishFunc: ((path: string, event: string) => void) | null | undefined,
-): { fileWatchers: Record<string, FSWatcher>; killFileWatchers: () => Record<string, FSWatcher> } {
-  const extensions = config.extensions || ['js', 'ts'];
-  const fileWatchers = testFileLookupPaths.reduce((watchers, watchPath) => {
-    let ready = false;
-    const watcher = fs.watch(watchPath, { recursive: true }, async (eventType, filename) => {
-      if (!ready || !filename) return;
-      const fullPath = path.join(watchPath, filename);
-      if (eventType === 'change') {
-        return handleWatchEvent(config, extensions, 'change', fullPath, onEventFunc, onFinishFunc);
-      }
-      try {
-        const s = await stat(fullPath);
-        handleWatchEvent(
-          config,
-          extensions,
-          s.isDirectory() ? 'addDir' : 'add',
-          fullPath,
-          onEventFunc,
-          onFinishFunc,
-        );
-      } catch {
-        const event = config.fsTree && fullPath in config.fsTree ? 'unlink' : 'unlinkDir';
-        handleWatchEvent(config, extensions, event, fullPath, onEventFunc, onFinishFunc);
-      }
-    });
-    setImmediate(() => {
-      ready = true;
-    });
-    return Object.assign(watchers, { [watchPath]: watcher });
-  }, {});
-
-  return {
-    fileWatchers,
-    killFileWatchers() {
-      Object.keys(fileWatchers).forEach((watcherKey) => fileWatchers[watcherKey].close());
-
-      return fileWatchers;
-    },
-  };
-}
-
-/**
- * Routes a file-system event to fsTree mutation and optional rebuild trigger.
- * `unlinkDir` bypasses the extension filter so deleted directories always clean up fsTree.
- * @returns {void}
- */
-export function handleWatchEvent(
-  config: Config,
-  extensions: string[],
-  event: string,
-  filePath: string,
-  onEventFunc: (event: string, file: string) => unknown,
-  onFinishFunc: ((path: string, event: string) => void) | null | undefined,
-): void {
-  const isFileEvent = extensions.some((ext) => filePath.endsWith(`.${ext}`));
-
-  if (!isFileEvent && event !== 'unlinkDir') return;
-
-  mutateFSTree(config.fsTree, event, filePath);
-
-  console.log(
-    '#',
-    magenta().bold('=================================================================='),
-  );
-  console.log('#', getEventColor(event), filePath.split(config.projectRoot)[1]);
-  console.log(
-    '#',
-    magenta().bold('=================================================================='),
-  );
-
-  if (!config._building) {
-    config._building = true;
-
-    const result = onEventFunc(event, filePath);
-
-    if (!(result instanceof Promise)) {
-      config._building = false;
-
-      return result;
-    }
-
-    result
-      .then(() => {
-        onFinishFunc ? onFinishFunc(event, filePath) : null;
-      })
-      .catch((error) => {
-        console.error('#', red('Build error:'), error.message || error);
-      })
-      .finally(() => (config._building = false));
-  }
-}
-
-/**
- * Mutates `fsTree` in place based on a chokidar file-system event.
- * @returns {void}
- */
-export function mutateFSTree(fsTree: FSTree, event: string, path: string): void {
-  if (event === 'add') {
-    fsTree[path] = null;
-  } else if (event === 'unlink') {
-    delete fsTree[path];
-  } else if (event === 'unlinkDir') {
-    for (const treePath of Object.keys(fsTree)) {
-      if (treePath.startsWith(path)) delete fsTree[treePath];
-    }
-  }
-}
-
-function getEventColor(event: string): unknown {
-  if (event === 'change') {
-    return yellow('CHANGED:');
-  } else if (event === 'add' || event === 'addDir') {
-    return green('ADDED:');
-  } else if (event === 'unlink' || event === 'unlinkDir') {
-    return red('REMOVED:');
-  }
-}

package/lib/setup/fs-tree.ts

@@ -1,60 +0,0 @@
-import fs, { glob as fsGlob } from 'node:fs/promises';
-import path from 'node:path';
-import type { FSTree } from '../types.ts';
-
-function isGlob(str: string): boolean {
-  return /[*?{[]/.test(str);
-}
-
-async function readDirRecursive(dir: string, filter: (name: string) => boolean): Promise<string[]> {
-  const entries = await fs.readdir(dir, { recursive: true, withFileTypes: true });
-  return entries
-    .filter((e) => e.isFile() && filter(e.name))
-    .map((e) => path.join(e.parentPath, e.name));
-}
-
-/**
- * Resolves an array of file paths, directories, or glob patterns into a flat `{ absolutePath: null }` map.
- * @returns {Promise<object>}
- */
-export default async function buildFSTree(
-  fileAbsolutePaths: string[],
-  config: { extensions?: string[] } = {},
-): Promise<FSTree> {
-  const targetExtensions = config.extensions || ['js', 'ts'];
-  const fsTree = {};
-
-  await Promise.all(
-    fileAbsolutePaths.map(async (fileAbsolutePath) => {
-      try {
-        if (isGlob(fileAbsolutePath)) {
-          for await (const fileName of fsGlob(fileAbsolutePath)) {
-            if (targetExtensions.some((ext) => fileName.endsWith(`.${ext}`))) {
-              fsTree[fileName] = null;
-            }
-          }
-        } else {
-          const entry = await fs.stat(fileAbsolutePath);
-
-          if (entry.isFile()) {
-            fsTree[fileAbsolutePath] = null;
-          } else if (entry.isDirectory()) {
-            const fileNames = await readDirRecursive(fileAbsolutePath, (name) => {
-              return targetExtensions.some((extension) => name.endsWith(`.${extension}`));
-            });
-
-            fileNames.forEach((fileName) => {
-              fsTree[fileName] = null;
-            });
-          }
-        }
-      } catch (error) {
-        console.error(error);
-
-        return process.exit(1);
-      }
-    }),
-  );
-
-  return fsTree;
-}