lookupFiles repeats various operations over and over. We can avoid alot of this overhead and improve the performance of big test suites.

Uzlopak · Uzlopak · commit 918523e31847 · 2025-10-03T08:35:18.000+02:00
To improve the performance, we can normalize the file extensions once at the beginning and dont need to do it again if we have a recursive call. `normalizeFileExtensions` is a new function, which takes care of it once per run.

This means that we can avoid again normalizing the array in `hasMatchingFileExtension` (before: `hasMatchingExtname`). Also we avoid the performance bottleneck of Array.helper functions like `.map` and `.some()`.

`fs.statSync` is called with `throwIfNoEntry`, which exists since node 14.17.0, set to `false`. We can avoid "expensive" errors and the try catch blocks. We just check if stat is undefined, and if so, well, the path has an issue.

Also added fourth parameter for to `lookupFiles` which is the `files` parameter, passed through the recursive calls, avoiding the repetive spreads and and array generationsto to join the paths.

Added `jsdoc` for better type resolution. Also if you would put `// @ts-check` at the beginning of the file, it would pass.
diff --git a/lib/cli/lookup-files.js b/lib/cli/lookup-files.js
@@ -5,14 +5,17 @@
  * @private
  */
 
-var fs = require('node:fs');
-var path = require('node:path');
-var glob = require('glob');
-var errors = require('../errors');
-var createNoFilesMatchPatternError = errors.createNoFilesMatchPatternError;
-var createMissingArgumentError = errors.createMissingArgumentError;
+const fs = require('node:fs');
+const path = require('node:path');
+const glob = require('glob');
+const {
+  createNoFilesMatchPatternError,
+  createMissingArgumentError
+} = require('../errors');
 const debug = require('debug')('mocha:cli:lookup-files');
 
+/** @typedef {`.${string}`} HiddenUnixPathname */
+
 /**
  * Determines if pathname would be a "hidden" file (or directory) on UN*X.
  *
@@ -24,30 +27,59 @@ const debug = require('debug')('mocha:cli:lookup-files');
  *
  * @private
  * @param {string} pathname - Pathname to check for match.
- * @return {boolean} whether pathname would be considered a hidden file.
+ * @returns {value is HiddenUnixPathname} whether pathname would be considered a hidden file.
  * @example
  * isHiddenOnUnix('.profile'); // => true
  */
-const isHiddenOnUnix = pathname => path.basename(pathname).startsWith('.');
+const isHiddenOnUnix = pathname => path.basename(pathname)[0] === '.';
+
+/** @typedef {`.${string}`} FileExtension */
 
 /**
- * Determines if pathname has a matching file extension.
+ * Normalize file extensions to ensure they have a leading period character.
  *
- * Supports multi-part extensions.
+ * @private
+ * @param {FileExtension[]|string[]|undefined|null} exts
+ * @param {boolean} normalized
+ * @returns {FileExtension[]}
+ */
+const normalizeFileExtensions = (exts, normalized) => {
+  if (normalized === true) {
+    return /** @type {FileExtension[]} */ (exts)
+  }
+
+  if (!exts) {
+    return [];
+  }
+
+  for (var i = 0; i < exts.length; i++) {
+    if (exts[i][0] !== '.') {
+      exts[i] = `.${exts[i]}`;
+    }
+  }
+  return /** @type {FileExtension[]} */ (exts);
+}
+
+/**
+ * Determines if pathname has a matching file extension.
  *
  * @private
  * @param {string} pathname - Pathname to check for match.
- * @param {string[]} exts - List of file extensions, w/-or-w/o leading period
- * @return {boolean} `true` if file extension matches.
+ * @param {FileExtension[]} fileExtensions - List of file extensions, w/-or-w/o leading period
+ * @returns {boolean} `true` if file extension matches.
  * @example
- * hasMatchingExtname('foo.html', ['js', 'css']); // false
- * hasMatchingExtname('foo.js', ['.js']); // true
- * hasMatchingExtname('foo.js', ['js']); // ture
+ * hasMatchingFileExtension('foo.html', ['js', 'css']); // false
+ * hasMatchingFileExtension('foo.js', ['.js']); // true
+ * hasMatchingFileExtension('foo.js', ['js']); // ture
  */
-const hasMatchingExtname = (pathname, exts = []) =>
-  exts
-    .map(ext => (ext.startsWith('.') ? ext : `.${ext}`))
-    .some(ext => pathname.endsWith(ext));
+const hasMatchingFileExtension = (pathname, fileExtensions) => {
+  for (var i = 0; i < fileExtensions.length; i++) {
+    if (pathname.endsWith(fileExtensions[i])) {
+      return true;
+    }
+  }
+  return false;
+}
 
 /**
  * Lookup file names at the given `path`.
@@ -59,31 +91,33 @@ const hasMatchingExtname = (pathname, exts = []) =>
  * @public
  * @alias module:lib/cli.lookupFiles
  * @param {string} filepath - Base path to start searching from.
- * @param {string[]} [extensions=[]] - File extensions to look for.
+ * @param {string[]} [fileExtensions=[]] - File extensions to look for.
  * @param {boolean} [recursive=false] - Whether to recurse into subdirectories.
- * @return {string[]} An array of paths.
+ * @param {string[]} [files=[]] - The array of files found (used internally).
+ * @param {boolean} [recursion=false] - Whether function is being called recursively (used internally).
+ * @returns {string[]} An array of paths.
  * @throws {Error} if no files match pattern.
- * @throws {TypeError} if `filepath` is directory and `extensions` not provided.
+ * @throws {TypeError} if `filepath` is directory and `fileExtensions` not 
+ * provided or an empty array.
  */
 module.exports = function lookupFiles(
   filepath,
-  extensions = [],
-  recursive = false
+  fileExtensions,
+  recursive = false,
+  files = [],
+  recursion = false
 ) {
-  const files = [];
-  let stat;
+  fileExtensions = normalizeFileExtensions(fileExtensions, recursion);
 
+  // Detect glob patterns by checking if the path does not exist as-is
   if (!fs.existsSync(filepath)) {
     let pattern;
     if (glob.hasMagic(filepath, {windowsPathsNoEscape: true})) {
       // Handle glob as is without extensions
       pattern = filepath;
     } else {
       // glob pattern e.g. 'filepath+(.js|.ts)'
-      const strExtensions = extensions
-        .map(ext => (ext.startsWith('.') ? ext : `.${ext}`))
-        .join('|');
-      pattern = `${filepath}+(${strExtensions})`;
+      pattern = `${filepath}+(${fileExtensions.join('|')})`;
       debug('looking for files using glob pattern: %s', pattern);
     }
     files.push(
@@ -106,50 +140,50 @@ module.exports = function lookupFiles(
     return files;
   }
 
-  // Handle file
-  try {
-    stat = fs.statSync(filepath);
-    if (stat.isFile()) {
-      return filepath;
-    }
-  } catch (err) {
-    // ignore error
-    return;
-  }
+  const stat = fs.statSync(filepath, {
+    throwIfNoEntry: false
+  });
+
+  if (stat === undefined) {
+    // Unreachable because glob check already checks if path exists, but for
+    // completeness...
+  } else if (stat.isFile()) {
+    files.push(filepath);
+  } else if (stat.isDirectory()) {
+    // Handle directory
+    const dirEnts = fs.readdirSync(filepath);
 
-  // Handle directory
-  fs.readdirSync(filepath).forEach(dirent => {
-    const pathname = path.join(filepath, dirent);
-    let stat;
+    for (var i = 0; i < dirEnts.length; i++) {
+      const pathname = path.join(filepath, dirEnts[i]);
+      const subStat = fs.statSync(pathname, {
+        throwIfNoEntry: false
+      });
 
-    try {
-      stat = fs.statSync(pathname);
-      if (stat.isDirectory()) {
-        if (recursive) {
-          files.push(...lookupFiles(pathname, extensions, recursive));
+      if (subStat === undefined) {
+        continue;
+      } else if (subStat.isDirectory()) {
+        if (recursive === true) {
+          lookupFiles(pathname, fileExtensions, recursive, files, true);
+        }
+      } else if (
+        subStat.isFile()
+      ) {
+         if (fileExtensions.length === 0) {
+          throw createMissingArgumentError(
+            `Argument '${fileExtensions}' required when argument '${filepath}' is a directory`,
+            'extensions',
+            'array'
+          )
+        }
+        if (
+          hasMatchingFileExtension(pathname, /** @type {FileExtension[]} */ (fileExtensions)) &&
+          !isHiddenOnUnix(pathname)
+        ) {
+          files.push(pathname);
         }
-        return;
       }
-    } catch (ignored) {
-      return;
-    }
-    if (!extensions.length) {
-      throw createMissingArgumentError(
-        `Argument '${extensions}' required when argument '${filepath}' is a directory`,
-        'extensions',
-        'array'
-      );
     }
-
-    if (
-      !stat.isFile() ||
-      !hasMatchingExtname(pathname, extensions) ||
-      isHiddenOnUnix(pathname)
-    ) {
-      return;
-    }
-    files.push(pathname);
-  });
+  }
 
   return files;
 };
diff --git a/test/integration/file-utils.spec.js b/test/integration/file-utils.spec.js
@@ -17,7 +17,7 @@ describe('file utils', function () {
     tmpDir = result.dirpath;
     removeTempDir = result.removeTempDir;
 
-    tmpFile = filepath => path.join(tmpDir, filepath);
+    tmpFile = (...args) => path.join(...[tmpDir, ...args]);
 
     touchFile(tmpFile('mocha-utils.js'));
     if (SYMLINK_SUPPORT) {
@@ -64,6 +64,22 @@ describe('file utils', function () {
       ex.and('to have length', expectedLength);
     });
 
+    describe('when containing subdirectories', function () {
+      beforeEach(function () {
+        touchFile(tmpFile('types','mocha-utils.d.ts'));
+      });
+
+      it('should find files in subdirectories', function () {
+        expect(
+          lookupFiles(tmpDir, ['.d.ts'], true).map(foundFilepath =>
+            path.normalize(foundFilepath)
+          ),
+          'to contain',
+          tmpFile('types', 'mocha-utils.d.ts')
+        ).and('to have length', 1);
+      });
+    })
+
     describe('when given `extension` option', function () {
       describe('when provided a directory for the filepath', function () {
         let filepath;
@@ -253,6 +269,15 @@ describe('file utils', function () {
       });
     });
 
+    describe('when provided path to non existing file', function () {
+      it('should throw an exception', function () {
+        expect(() => lookupFiles(tmpFile('mocha-utils-faux')), 'to throw', {
+          name: 'Error',
+          code: 'ERR_MOCHA_NO_FILES_MATCH_PATTERN'
+        });
+      });
+    });
+
     describe('when no files match', function () {
       it('should throw an exception', function () {
         expect(() => lookupFiles(tmpFile('mocha-utils')), 'to throw', {
