velocious 1.0.666 → 1.0.668

package/build/testing/test-files-finder.js

@@ -1,364 +1,53 @@
 // @ts-check
 
-import fs from "fs/promises"
-import path from "path"
+import {
+  discoverTestFiles,
+  lineFiltersFromCandidates
+} from "@velocious/testing/node"
 
-import fileExists from "../utils/file-exists.js"
-import Logger from "../logger.js"
 import restArgsError from "../utils/rest-args-error.js"
 
-// Incredibly complex class to find files in multiple simultanious running promises to do it as fast as possible.
-export default class TestFilesFinder {
-  static IGNORED_NAMES = [".git", "node_modules"]
+const VELOCIOUS_NODE_TEST_PATTERN = /(?<!\.browser)-(?:spec|test)\.(?:m)?js$/u
 
+/** Compatibility facade for Velocious's published test-file finder path. */
+export default class TestFilesFinder {
   /**
-   * Runs constructor.
-   * @param {object} args - Options object.
-   * @param {string} args.directory - Directory path.
-   * @param {string[]} [args.directories] - Directories.
-   * @param {string[]} args.processArgs - Process args.
+   * Creates a Velocious-compatible package discovery adapter.
+   * @param {object} args - Discovery options.
+   * @param {string} args.directory - Discovery base directory.
+   * @param {string[]} [args.directories] - Default directories.
+   * @param {RegExp} [args.filePattern] - Test-file pattern override.
+   * @param {string[]} args.processArgs - Process arguments including the command name.
    */
-  constructor({directory, directories, processArgs, ...restArgs}) {
+  constructor({directory, directories, filePattern, processArgs, ...restArgs}) {
     restArgsError(restArgs)
-
-    this.directory = path.resolve(directory)
-    this.logger = new Logger(this)
-
-    if (directories) {
-      this.directories = directories.map((entry) => path.resolve(entry))
-    } else {
-      this.directories = [
-        `${this.directory}/__tests__`,
-        `${this.directory}/tests`,
-        `${this.directory}/spec`
-      ]
-    }
-
-    this.findingCount = 0
-    this.processArgs = processArgs
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.foundFiles = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Record<number, Promise<void>>} */
-    this.findingPromises = {}
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.testArgs = this.processArgs.filter((processArg, index) => index != 0)
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.directoryArgs = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.directoryFullPaths = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.fileArgs = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {string[]} */
-    this.explicitFiles = []
-
-    /**
-     * Narrows the runtime value to the documented type.
-     * @type {Record<string, number[]>} */
-    this.lineFiltersByFile = {}
-
-    this._argsPrepared = false
+    this.directory = directory
+    this.directories = directories
+    this.filePattern = filePattern
+    this.candidates = processArgs.slice(1).filter((argument) => argument !== "--")
+    /** @type {Record<string, number[]>} */
+    this.lineFiltersByFile = lineFiltersFromCandidates({
+      cwd: directory,
+      candidates: this.candidates
+    })
   }
 
   /**
-   * Runs find test files.
-   * @returns {Promise<string[]>} - Resolves with the test files.
+   * Discovers test files through the package implementation.
+   * @returns {Promise<string[]>} - Discovered absolute file paths.
    */
   async findTestFiles() {
-    await this.prepareArgs()
-
-    if (this.explicitFiles.length > 0 && this.directoryArgs.length === 0) {
-      return Array.from(new Set(this.explicitFiles))
-    }
-
-    await this.withFindingCount(async () => {
-      const hasExplicitArgs = this.directoryFullPaths.length > 0 || this.fileArgs.length > 0
-      const directoriesToScan = hasExplicitArgs ? this.directoryFullPaths : this.directories
-
-      for (const directory of directoriesToScan) {
-        if (await fileExists(directory)) {
-          await this.findTestFilesInDir(directory)
-        }
-      }
+    return await discoverTestFiles({
+      cwd: this.directory,
+      candidates: this.candidates,
+      directories: this.directories,
+      filePattern: this.filePattern || VELOCIOUS_NODE_TEST_PATTERN
     })
-
-    await this.waitForFindingPromises()
-
-    if (this.explicitFiles.length > 0) {
-      this.foundFiles.push(...this.explicitFiles)
-    }
-
-    return Array.from(new Set(this.foundFiles))
   }
 
   /**
-   * Runs get line filters by file.
-   * @returns {Record<string, number[]>} - Line filters by file.
+   * Gets candidate-derived line filters.
+   * @returns {Record<string, number[]>} - Line filters keyed by absolute file path.
    */
   getLineFiltersByFile() { return this.lineFiltersByFile }
-
-  /**
-   * Runs finding promises length.
-   * @returns {number} - The ing promises length.
-   */
-  findingPromisesLength() { return Object.keys(this.findingPromises).length }
-
-  async waitForFindingPromises() {
-    while (this.findingPromisesLength() > 0) {
-      await this.waitForFindingPromisesIteration()
-    }
-  }
-
-  /**
-   * Runs wait for finding promises iteration.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async waitForFindingPromisesIteration() {
-    const unfinishedPromises = []
-
-    for (const findingPromiseId in this.findingPromises) {
-      const findingPromise = this.findingPromises[findingPromiseId]
-
-      unfinishedPromises.push(findingPromise)
-    }
-
-    await Promise.all(unfinishedPromises)
-  }
-
-  /**
-   * Runs with finding count.
-   * @param {() => Promise<void>} callback - Callback function.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  withFindingCount(callback) {
-    return new Promise((resolve) => {
-      const findingPromise = callback()
-      const findingCount = this.findingCount
-
-      this.findingCount += 1
-      this.findingPromises[findingCount] = findingPromise
-
-      findingPromise.finally(() => {
-        delete this.findingPromises[findingCount]
-
-        resolve(undefined)
-      })
-    })
-  }
-
-  /**
-   * Runs find test files in dir.
-   * @param {string} dir - Dir.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async findTestFilesInDir(dir) {
-    await this.withFindingCount(async () => {
-      const files = await fs.readdir(dir)
-
-      for (const file of files) {
-        if (TestFilesFinder.IGNORED_NAMES.includes(file)) {
-          continue
-        }
-
-        const fullPath = `${dir}/${file}`
-        const localPath = fullPath.replace(`${this.directory}/`, "")
-        const isDir = (await fs.stat(fullPath)).isDirectory()
-
-        if (isDir) {
-          this.findTestFilesInDir(fullPath)
-        } else {
-          if (this.isFileMatchingRequirements(file, localPath)) {
-            this.foundFiles.push(fullPath)
-          }
-        }
-      }
-    })
-  }
-
-  /**
-   * Runs is file matching requirements.
-   * @param {string} file - File.
-   * @param {string} localPath - Local path.
-   * @returns {boolean} - Whether file matching requirements.
-   */
-  isFileMatchingRequirements(file, localPath) {
-    if (this.directoryArgs.length > 0) {
-      for (const directoryArg of this.directoryArgs) {
-        if (localPath.startsWith(directoryArg) && this.looksLikeTestFile(file)) {
-          this.logger.debug("Found test file because matching dir and looks like this file:", file)
-          return true
-        }
-      }
-    }
-
-    if (this.fileArgs.length > 0) {
-      for (const fileArg of this.fileArgs) {
-        if (fileArg == localPath) {
-          this.logger.debug("Found test file because matching file arg:", file)
-          return true
-        }
-      }
-    }
-
-    if (this.fileArgs.length == 0 && this.directoryArgs.length == 0 && this.looksLikeTestFile(file)) {
-      this.logger.debug("Found test file because looks like this file:", file)
-      return true
-    }
-
-    return false
-  }
-
-  /**
-   * Runs looks like test file.
-   * @param {string} file - File.
-   * @returns {boolean} - Whether looks like test file.
-   */
-  looksLikeTestFile(file) {
-    return Boolean(file.match(/-(spec|test)\.(m|)js$/))
-  }
-
-  /**
-   * Runs prepare args.
-   * @returns {Promise<void>} - Resolves when test args are prepared.
-   */
-  async prepareArgs() {
-    if (this._argsPrepared) return
-
-    for (const testArg of this.testArgs) {
-      if (testArg === "--") continue
-
-      const {cleanArg, line} = this.splitLineArg(testArg)
-      const forceDirectory = testArg.endsWith("/") || testArg.endsWith(path.sep)
-      const fullPath = path.isAbsolute(cleanArg) ? cleanArg : path.resolve(this.directory, cleanArg)
-      const baseName = path.basename(this.directory)
-      const hasBasePrefix = cleanArg === baseName || cleanArg.startsWith(`${baseName}/`) || cleanArg.startsWith(`${baseName}${path.sep}`)
-      const basePrefixedFullPath = (!path.isAbsolute(cleanArg) && hasBasePrefix) ? path.resolve(path.dirname(this.directory), cleanArg) : null
-      const fullPathCandidates = basePrefixedFullPath ? [basePrefixedFullPath] : [fullPath]
-
-      if (forceDirectory) {
-        const preferredLocalPath = this.toLocalPath(basePrefixedFullPath || fullPath)
-        this.directoryArgs.push(this.ensureTrailingSlash(preferredLocalPath))
-        this.directoryFullPaths.push(path.resolve(basePrefixedFullPath || fullPath))
-        continue
-      }
-
-      try {
-        let stats
-        let resolvedFullPath
-
-        for (const candidatePath of fullPathCandidates) {
-          try {
-            stats = await fs.stat(candidatePath)
-            resolvedFullPath = candidatePath
-            break
-          } catch {
-            // Keep searching
-          }
-        }
-
-        if (!stats || !resolvedFullPath) throw new Error("Path not found")
-        const localPath = this.toLocalPath(resolvedFullPath)
-
-        if (stats.isDirectory()) {
-          this.directoryArgs.push(this.ensureTrailingSlash(localPath))
-          this.directoryFullPaths.push(resolvedFullPath)
-        } else if (stats.isFile()) {
-          this.fileArgs.push(localPath)
-          this.explicitFiles.push(resolvedFullPath)
-
-          if (line) {
-            this.addLineFilter(resolvedFullPath, line)
-          }
-        }
-      } catch {
-        const fallbackLocalPath = this.toLocalPath(basePrefixedFullPath || fullPath)
-        this.fileArgs.push(fallbackLocalPath)
-
-        if (line) {
-          this.addLineFilter(basePrefixedFullPath || fullPath, line)
-        }
-      }
-    }
-
-    this._argsPrepared = true
-  }
-
-  /**
-   * Runs add line filter.
-   * @param {string} filePath - File path.
-   * @param {number} line - Line number.
-   * @returns {void} - No return value.
-   */
-  addLineFilter(filePath, line) {
-    const fullPath = path.resolve(filePath)
-
-    if (!this.lineFiltersByFile[fullPath]) {
-      this.lineFiltersByFile[fullPath] = []
-    }
-
-    if (!this.lineFiltersByFile[fullPath].includes(line)) {
-      this.lineFiltersByFile[fullPath].push(line)
-    }
-  }
-
-  /**
-   * Runs split line arg.
-   * @param {string} testArg - Test arg.
-   * @returns {{cleanArg: string, line?: number}} - Cleaned arg and line.
-   */
-  splitLineArg(testArg) {
-    const match = testArg.match(/^(.*):(\d+)$/)
-
-    if (!match) {
-      return {cleanArg: testArg}
-    }
-
-    const line = Number(match[2])
-
-    if (!Number.isFinite(line)) {
-      return {cleanArg: testArg}
-    }
-
-    return {cleanArg: match[1], line}
-  }
-
-  /**
-   * Runs ensure trailing slash.
-   * @param {string} localPath - Local path.
-   * @returns {string} - Normalized local path with trailing slash.
-   */
-  ensureTrailingSlash(localPath) {
-    if (localPath === "") return localPath
-    return localPath.endsWith("/") ? localPath : `${localPath}/`
-  }
-
-  /**
-   * Runs to local path.
-   * @param {string} fullPath - Full path.
-   * @returns {string} - Local path relative to the base directory.
-   */
-  toLocalPath(fullPath) {
-    const relativePath = path.relative(this.directory, fullPath)
-    return relativePath.split(path.sep).join("/")
-  }
 }

package/build/testing/test-filter-parser.js

@@ -1,269 +1,50 @@
+// @ts-check
+
+import {
+  extractTestCliArguments,
+  normalizeExamplePatterns
+} from "@velocious/testing/node"
+
 /**
- * ParseFiltersResult type.
  * @typedef {object} ParseFiltersResult
  * @property {string[]} includeTags - Tags to include.
  * @property {string[]} excludeTags - Tags to exclude.
  * @property {string[]} examplePatterns - Example name patterns.
- * @property {string[]} filteredProcessArgs - Remaining process args with filter flags removed.
+ * @property {string[]} filteredProcessArgs - Remaining process args with package-owned flags removed.
  * @property {number | undefined} groups - Total number of groups for test splitting.
  * @property {number | undefined} groupNumber - Which group to run (1-indexed).
  * @property {boolean} profile - Whether test profiling is enabled.
  * @property {string | undefined} profileJsonPath - Rich profile output path.
  * @property {string | undefined} timingManifestPath - JSON timing manifest path.
  * @property {string | undefined} timingManifestOutputPath - Timing manifest output path.
+ * @property {number | undefined} retries - Default retry count.
+ * @property {string[]} setupFiles - Setup files imported before test files.
+ * @property {number | undefined} timeoutMs - Default lifecycle timeout.
  */
-// @ts-check
-
-const INCLUDE_TAG_FLAGS = new Set(["--tag", "--include-tag", "-t"])
-const EXCLUDE_TAG_FLAGS = new Set(["--exclude-tag", "--skip-tag", "-x"])
-const EXAMPLE_FLAGS = new Set(["--example", "--name", "-e"])
-const GROUPS_FLAGS = new Set(["--groups"])
-const GROUP_NUMBER_FLAGS = new Set(["--group-number"])
-const TIMING_MANIFEST_FLAGS = new Set(["--timing-manifest"])
-const PROFILE_JSON_FLAGS = new Set(["--profile-json"])
-const TIMING_MANIFEST_OUTPUT_FLAGS = new Set(["--timing-manifest-output"])
-
-/**
- * Runs split tags.
- * @param {string | undefined} value - Tag argument value.
- * @returns {string[]} - Tags list.
- */
-function splitTags(value) {
-  if (!value) return []
-
-  return value
-    .split(",")
-    .map((tag) => tag.trim())
-    .filter(Boolean)
-}
-
-/**
- * Runs escape reg exp.
- * @param {string} value - Value.
- * @returns {string} - Escaped value for regex.
- */
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-}
-
-/**
- * Runs the normalizeExamplePatterns helper.
- * @param {string[]} patterns - Patterns.
- * @returns {RegExp[]} - Normalized patterns.
- */
-export function normalizeExamplePatterns(patterns) {
-  const normalized = []
-
-  for (const pattern of patterns) {
-    const regexMatch = pattern.match(/^\/(.+)\/([gimsuy]*)$/)
 
-    if (regexMatch) {
-      normalized.push(new RegExp(regexMatch[1], regexMatch[2]))
-    } else {
-      normalized.push(new RegExp(escapeRegExp(pattern)))
-    }
-  }
-
-  return normalized
-}
+export { normalizeExamplePatterns }
 
 /**
- * Runs the parseFilters helper.
- * @param {string[]} processArgs - Process args.
- * @returns {ParseFiltersResult} - Parsed tags, group options, and process args.
+ * Preserves the Velocious parser result while delegating package-owned option parsing.
+ * @param {string[]} processArgs - Raw process arguments including the command name.
+ * @returns {ParseFiltersResult} - Package options and downstream process arguments.
  */
 export function parseFilters(processArgs) {
-  const includeTags = []
-  const excludeTags = []
-  const filteredProcessArgs = processArgs.length > 0 ? [processArgs[0]] : []
-  const examplePatterns = []
-
-  /**
-   * Defines groups.
-   * @type {number | undefined} */
-  let groups
-  /**
-   * Defines groupNumber.
-   * @type {number | undefined} */
-  let groupNumber
-  let profile = false
-  /** @type {string | undefined} */
-  let profileJsonPath
-  /** @type {string | undefined} */
-  let timingManifestPath
-  /** @type {string | undefined} */
-  let timingManifestOutputPath
-
-  let inRestArgs = false
-
-  for (let i = 1; i < processArgs.length; i++) {
-    const arg = processArgs[i]
-
-    if (arg === "--") {
-      inRestArgs = true
-      filteredProcessArgs.push(arg)
-      continue
-    }
-
-    if (!inRestArgs) {
-      if (INCLUDE_TAG_FLAGS.has(arg)) {
-        const nextValue = processArgs[i + 1]
-
-        if (nextValue && !nextValue.startsWith("-")) {
-          includeTags.push(...splitTags(nextValue))
-          i++
-        }
-        continue
-      }
-
-      if (EXCLUDE_TAG_FLAGS.has(arg)) {
-        const nextValue = processArgs[i + 1]
-
-        if (nextValue && !nextValue.startsWith("-")) {
-          excludeTags.push(...splitTags(nextValue))
-          i++
-        }
-        continue
-      }
-
-      if (arg.startsWith("--tag=")) {
-        includeTags.push(...splitTags(arg.slice("--tag=".length)))
-        continue
-      }
-
-      if (arg.startsWith("--include-tag=")) {
-        includeTags.push(...splitTags(arg.slice("--include-tag=".length)))
-        continue
-      }
-
-      if (arg.startsWith("--exclude-tag=")) {
-        excludeTags.push(...splitTags(arg.slice("--exclude-tag=".length)))
-        continue
-      }
-
-      if (arg.startsWith("--skip-tag=")) {
-        excludeTags.push(...splitTags(arg.slice("--skip-tag=".length)))
-        continue
-      }
-
-      if (EXAMPLE_FLAGS.has(arg)) {
-        const nextValue = processArgs[i + 1]
-
-        if (nextValue && !nextValue.startsWith("-")) {
-          examplePatterns.push(nextValue)
-          i++
-        }
-        continue
-      }
-
-      if (arg.startsWith("--example=")) {
-        examplePatterns.push(arg.slice("--example=".length))
-        continue
-      }
-
-      if (arg.startsWith("--name=")) {
-        examplePatterns.push(arg.slice("--name=".length))
-        continue
-      }
-
-      if (GROUPS_FLAGS.has(arg)) {
-        const nextValue = processArgs[i + 1]
-
-        if (nextValue && !nextValue.startsWith("-")) {
-          groups = parseInt(nextValue, 10)
-          i++
-        }
-        continue
-      }
-
-      if (arg.startsWith("--groups=")) {
-        groups = parseInt(arg.slice("--groups=".length), 10)
-        continue
-      }
-
-      if (GROUP_NUMBER_FLAGS.has(arg)) {
-        const nextValue = processArgs[i + 1]
-
-        if (nextValue && !nextValue.startsWith("-")) {
-          groupNumber = parseInt(nextValue, 10)
-          i++
-        }
-        continue
-      }
-
-      if (arg.startsWith("--group-number=")) {
-        groupNumber = parseInt(arg.slice("--group-number=".length), 10)
-        continue
-      }
-
-      if (TIMING_MANIFEST_FLAGS.has(arg)) {
-        const nextValue = processArgs[i + 1]
-
-        if (!nextValue || nextValue.startsWith("-")) throw new Error("--timing-manifest requires a path")
-        timingManifestPath = nextValue
-        i++
-        continue
-      }
-
-      if (arg.startsWith("--timing-manifest=")) {
-        timingManifestPath = arg.slice("--timing-manifest=".length)
-        if (!timingManifestPath) throw new Error("--timing-manifest requires a path")
-        continue
-      }
-
-      if (arg === "--profile") {
-        profile = true
-        continue
-      }
-
-      if (PROFILE_JSON_FLAGS.has(arg)) {
-        const nextValue = processArgs[i + 1]
-
-        if (!nextValue || nextValue.startsWith("-")) throw new Error("--profile-json requires a path")
-        profileJsonPath = nextValue
-        profile = true
-        i++
-        continue
-      }
-
-      if (arg.startsWith("--profile-json=")) {
-        profileJsonPath = arg.slice("--profile-json=".length)
-        if (!profileJsonPath) throw new Error("--profile-json requires a path")
-        profile = true
-        continue
-      }
-
-      if (TIMING_MANIFEST_OUTPUT_FLAGS.has(arg)) {
-        const nextValue = processArgs[i + 1]
-
-        if (!nextValue || nextValue.startsWith("-")) throw new Error("--timing-manifest-output requires a path")
-        timingManifestOutputPath = nextValue
-        profile = true
-        i++
-        continue
-      }
-
-      if (arg.startsWith("--timing-manifest-output=")) {
-        timingManifestOutputPath = arg.slice("--timing-manifest-output=".length)
-        if (!timingManifestOutputPath) throw new Error("--timing-manifest-output requires a path")
-        profile = true
-        continue
-      }
-    }
-
-    filteredProcessArgs.push(arg)
-  }
+  const {options, remainingArguments} = extractTestCliArguments(processArgs)
 
   return {
-    includeTags: Array.from(new Set(includeTags)),
-    excludeTags: Array.from(new Set(excludeTags)),
-    examplePatterns,
-    filteredProcessArgs,
-    groups,
-    groupNumber,
-    profile,
-    profileJsonPath,
-    timingManifestPath,
-    timingManifestOutputPath
+    includeTags: options.includeTags,
+    excludeTags: options.excludeTags,
+    examplePatterns: options.examples,
+    filteredProcessArgs: remainingArguments,
+    groups: options.groups,
+    groupNumber: options.groupNumber,
+    profile: options.profile === true,
+    profileJsonPath: options.profileJsonPath,
+    timingManifestPath: options.timingManifestPath,
+    timingManifestOutputPath: options.timingManifestOutputPath,
+    retries: options.retries,
+    setupFiles: options.setupFiles,
+    timeoutMs: options.timeoutMs
   }
 }