testem 3.19.0 → 3.20.0

package/lib/utils/file_watch_glob_policy.js

@@ -0,0 +1,119 @@
+const url = require('url');
+
+const expandGlobPattern = require('./expand_glob_pattern');
+const { convertToPosix } = require('./posix');
+const { pathMatchesAny } = require('./path_pattern_match');
+
+/**
+ * Normalize config `src_files`-style values to a list of glob strings.
+ * @param {string|string[]|Array<{src: string}>|undefined|null} value
+ * @returns {string[]}
+ */
+function flattenPatternList(value) {
+  if (value === undefined || value === null) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.map(function(entry) {
+      if (typeof entry === 'string') {
+        return entry;
+      }
+      if (entry && typeof entry.src === 'string') {
+        return entry.src;
+      }
+      return String(entry);
+    });
+  }
+  return [String(value)];
+}
+
+/**
+ * Build the include / ignore pattern lists used by `FileWatcher` with the watch engine
+ * (policy filtering; the engine watches cwd and applies these patterns). Single place for glob +
+ * ignore semantics.
+ *
+ * @param {{ get: function(string): *, isCwdMode: function(): boolean }} config
+ * @returns {{ includePatterns: string[], ignorePatterns: string[] }}
+ */
+function buildWatchGlobPolicy(config) {
+  const includePatterns = [];
+
+  const confFile = config.get('file');
+  if (confFile) {
+    includePatterns.push(String(confFile));
+  }
+  if (config.isCwdMode()) {
+    includePatterns.push('*.js');
+  }
+  const watchFiles = config.get('watch_files');
+  if (watchFiles) {
+    includePatterns.push(...flattenPatternList(watchFiles));
+  }
+  const srcFiles = config.get('src_files');
+  const srcList = srcFiles !== undefined && srcFiles !== null ? srcFiles : '*.js';
+  includePatterns.push(...flattenPatternList(srcList));
+
+  const ignoreRaw = config.get('src_files_ignore');
+  const ignorePatterns = ignoreRaw ? flattenPatternList(ignoreRaw) : [];
+
+  return { includePatterns, ignorePatterns };
+}
+
+/**
+ * Whether a path would be treated as a watched file (matches an include pattern and
+ * no ignore pattern). Paths are normalized with {@link convertToPosix} for matching
+ * on Windows vs POSIX.
+ *
+ * @param {string} filePath - Absolute or relative path as emitted by the filesystem / watcher.
+ * @param {{ includePatterns: string[], ignorePatterns: string[] }} policy
+ * @param {object} [matchOptions] - forwarded to minimatch (via path_pattern_match).
+ * @returns {boolean}
+ */
+function pathMatchesWatchTarget(filePath, policy, matchOptions) {
+  const posix = convertToPosix(filePath);
+  if (pathMatchesAny(posix, policy.ignorePatterns, matchOptions)) {
+    return false;
+  }
+  return pathMatchesAny(posix, policy.includePatterns, matchOptions);
+}
+
+/**
+ * Expand all on-disk files matching the watch policy (same idea as `getFileSet` for
+ * `src_files`, but driven by the watch policy). Skips `http:` / `https:` URLs; keeps
+ * them as literal entries. Uses {@link expandGlobPattern} with `config.resolvePath`.
+ *
+ * @param {{ get: function(string): *, cwd: function(): string, resolvePath: function(string): string }} config
+ * @returns {Promise<string[]>} Sorted unique absolute paths (and any literal URLs).
+ */
+async function expandWatchableFilePaths(config) {
+  const policy = buildWatchGlobPolicy(config);
+  const ignorePosix = policy.ignorePatterns.map(function(p) {
+    return convertToPosix(config.resolvePath(p));
+  });
+  const out = [];
+
+  for (let i = 0; i < policy.includePatterns.length; i++) {
+    const pattern = policy.includePatterns[i];
+    const parsed = url.parse(pattern);
+    if (parsed.protocol && parsed.protocol !== 'file:' && parsed.protocol !== '') {
+      out.push(pattern);
+      continue;
+    }
+    let fsPattern = pattern;
+    if (parsed.protocol === 'file:') {
+      fsPattern = parsed.hostname + parsed.path;
+    }
+    const resolved = convertToPosix(config.resolvePath(fsPattern));
+    const files = await expandGlobPattern(resolved, ignorePosix);
+    out.push(...files);
+  }
+
+  return [...new Set(out)].sort();
+}
+
+module.exports = {
+  buildWatchGlobPolicy,
+  flattenPatternList,
+  pathMatchesWatchTarget,
+  expandWatchableFilePaths,
+};

package/lib/utils/fileutils.js

@@ -2,15 +2,15 @@
 
 const fs = require('fs');
 const execa = require('execa').execa;
-const Bluebird = require('bluebird');
-const log = require('npmlog');
+const { promisify } = require('util');
+const log = require('../log');
 
-const fsStatAsync = Bluebird.promisify(fs.stat);
+const fsStatAsync = promisify(fs.stat);
 
 const isWin = require('./is-win')();
 
 exports.fileExists = function fileExists(path) {
-  return fsStatAsync(path).then(stat => stat.isFile()).catchReturn(false);
+  return fsStatAsync(path).then(stat => stat.isFile()).catch(() => false);
 };
 
 exports.executableExists = function executableExists(exe, options) {

package/lib/utils/is_emfile_error.js

@@ -0,0 +1,16 @@
+/**
+ * Detects EMFILE errors from `fs.watch` / watcher backends (e.g. chokidar `error`).
+ * Fireworm uses a dedicated `emfile` event; other engines surface this via `error`.
+ *
+ * @param {unknown} err
+ * @returns {boolean}
+ */
+function isEmfileError(err) {
+  return (
+    err !== null &&
+    typeof err === 'object' &&
+    /** @type {{ code?: string }} */ (err).code === 'EMFILE'
+  );
+}
+
+module.exports = isEmfileError;

package/lib/utils/known-browsers.js

@@ -1,5 +1,3 @@
-
-
 const browserArgs = require('./browser-args');
 const path = require('path');
 const fs = require('fs');
@@ -8,17 +6,20 @@ const os = require('os');
 
 function chromeWinPaths(homeDir, name) {
   return [
-    homeDir + '\\Local Settings\\Application Data\\Google\\' + name + '\\Application\\chrome.exe',
+    homeDir +
+      '\\Local Settings\\Application Data\\Google\\' +
+      name +
+      '\\Application\\chrome.exe',
     homeDir + '\\AppData\\Local\\Google\\' + name + '\\Application\\chrome.exe',
     'C:\\Program Files\\Google\\' + name + '\\Application\\Chrome.exe',
-    'C:\\Program Files (x86)\\Google\\' + name + '\\Application\\Chrome.exe'
+    'C:\\Program Files (x86)\\Google\\' + name + '\\Application\\Chrome.exe',
   ];
 }
 
 function chromeOSXPaths(name) {
   return [
     process.env.HOME + '/Applications/' + name + '.app/Contents/MacOS/' + name,
-    '/Applications/' + name + '.app/Contents/MacOS/' + name
+    '/Applications/' + name + '.app/Contents/MacOS/' + name,
   ];
 }
 
@@ -31,7 +32,9 @@ function chromeArgs(browserTmpDir, url) {
     '--test-type',
     '--disable-renderer-backgrounding',
     '--disable-background-timer-throttling',
-    url
+    '--disable-infobars',
+    '--disable-session-crashed-bubble',
+    url,
   ];
 }
 
@@ -42,15 +45,24 @@ function headlessChromeArgs(browserTmpDir, url) {
     '--disable-software-rasterizer',
     '--mute-audio',
     '--remote-debugging-port=0',
-    '--window-size=1440,900'].concat(chromeArgs(browserTmpDir, url));
+    '--window-size=1440,900',
+  ].concat(chromeArgs(browserTmpDir, url));
 }
 
 function braveWinPaths(homeDir, name) {
   return [
-    homeDir + '\\Local Settings\\Application Data\\BraveSoftware\\' + name + '\\Application\\brave.exe',
-    homeDir + '\\AppData\\Local\\BraveSoftware\\' + name + '\\Application\\brave.exe',
+    homeDir +
+      '\\Local Settings\\Application Data\\BraveSoftware\\' +
+      name +
+      '\\Application\\brave.exe',
+    homeDir +
+      '\\AppData\\Local\\BraveSoftware\\' +
+      name +
+      '\\Application\\brave.exe',
     'C:\\Program Files\\BraveSoftware\\' + name + '\\Application\\brave.exe',
-    'C:\\Program Files (x86)\\BraveSoftware\\' + name + '\\Application\\brave.exe'
+    'C:\\Program Files (x86)\\BraveSoftware\\' +
+      name +
+      '\\Application\\brave.exe',
   ];
 }
 
@@ -68,15 +80,17 @@ function headlessBraveArgs(browserTmpDir, url) {
     '--disable-gpu',
     '--mute-audio',
     '--remote-debugging-port=0',
-    '--window-size=1440,900'].concat(braveArgs(browserTmpDir, url));
+    '--window-size=1440,900',
+  ].concat(braveArgs(browserTmpDir, url));
 }
 
 function edgePaths() {
   return [
     'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
     'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
-    process.env.HOME + '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
-    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'
+    process.env.HOME +
+      '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
   ];
 }
 
@@ -84,9 +98,11 @@ function firefoxPaths() {
   return [
     'C:\\Program Files\\Mozilla Firefox\\firefox.exe',
     'C:\\Program Files (x86)\\Mozilla Firefox\\firefox.exe',
-    'C:\\Users\\' + process.env.USERNAME + '\\AppData\\Local\\Mozilla Firefox\\firefox.exe',
+    'C:\\Users\\' +
+      process.env.USERNAME +
+      '\\AppData\\Local\\Mozilla Firefox\\firefox.exe',
     process.env.HOME + '/Applications/Firefox.app/Contents/MacOS/firefox',
-    '/Applications/Firefox.app/Contents/MacOS/firefox'
+    '/Applications/Firefox.app/Contents/MacOS/firefox',
   ];
 }
 
@@ -95,24 +111,51 @@ function firefoxSetup(browserTmpDir, config, done) {
   let perfJS = path.join(browserTmpDir, 'user.js');
 
   if (config.get('firefox_user_js')) {
-    return fs.readFile(config.get('firefox_user_js'), (err, content) => {
-      if (err) {
-        return done(err);
-      }
-
-      fs.writeFile(perfJS, content, done);
-    });
+    return fs.promises
+      .readFile(config.get('firefox_user_js'))
+      .then((content) => fs.promises.writeFile(perfJS, content))
+      .then(() => done(null), done);
   }
 
-  // using user.js to suppress the check default browser popup
-  // and the welcome start page
+  // user.js: legacy Testem defaults plus prefs aligned with common Firefox --pref automation
+  // sets (welcome, onboarding, messaging, telemetry) and fewer prompts / background noise.
   let prefs = [
     'user_pref("browser.shell.checkDefaultBrowser", false);',
     'user_pref("browser.cache.disk.smart_size.first_run", false);',
     'user_pref("datareporting.policy.dataSubmissionEnabled", false);',
-    'user_pref("datareporting.policy.dataSubmissionPolicyNotifiedTime", "1481830156314");'
+    'user_pref("datareporting.policy.dataSubmissionPolicyNotifiedTime", "1481830156314");',
+    'user_pref("app.update.auto", false);',
+    'user_pref("app.update.enabled", false);',
+    'user_pref("browser.EULA.override", true);',
+    'user_pref("toolkit.telemetry.reportingpolicy.firstRun", false);',
+    'user_pref("browser.aboutwelcome.enabled", false);',
+    'user_pref("browser.startup.homepage", "about:blank");',
+    'user_pref("browser.startup.page", 0);',
+    'user_pref("browser.startup.firstrunSkipsHomepage", true);',
+    'user_pref("browser.startup.homepage_override.mstone", "ignore");',
+    'user_pref("browser.startup.homepage_welcome_url", "");',
+    'user_pref("browser.startup.homepage_welcome_url.additional", "");',
+    'user_pref("browser.startup.cohort", "ignore");',
+    'user_pref("browser.messaging-system.prompts.enabled", false);',
+    'user_pref("browser.onboarding.enabled", false);',
+    'user_pref("browser.tour.enabled", false);',
+    'user_pref("browser.startup.upgradeDialog.enabled", false);',
+    'user_pref("browser.uiCustomization.skipDefaultState", true);',
+    'user_pref("toolkit.telemetry.enabled", false);',
+    'user_pref("toolkit.telemetry.unified", false);',
+    'user_pref("browser.ping-centre.telemetry", false);',
+    'user_pref("browser.sessionstore.resume_from_crash", false);',
+    'user_pref("browser.tabs.warnOnClose", false);',
+    'user_pref("browser.tabs.warnOnCloseOtherTabs", false);',
+    'user_pref("browser.tabs.warnOnOpen", false);',
+    'user_pref("browser.download.manager.showWhenStarting", false);',
+    'user_pref("extensions.update.enabled", false);',
+    'user_pref("dom.webnotifications.enabled", false);',
+    'user_pref("gfx.direct2d.disabled", true);',
   ];
-  fs.writeFile(perfJS, prefs.join(os.EOL), done);
+  fs.promises
+    .writeFile(perfJS, prefs.join(os.EOL))
+    .then(() => done(null), done);
 }
 
 // Return the catalogue of the browsers that Testem supports for the platform. Each 'browser object'
@@ -137,7 +180,7 @@ module.exports = function knownBrowsers(platform, config) {
       },
       setup(config, done) {
         firefoxSetup(this.browserTmpDir(), config, done);
-      }
+      },
     },
     {
       name: 'Headless Firefox',
@@ -149,156 +192,156 @@ module.exports = function knownBrowsers(platform, config) {
       },
       setup(config, done) {
         firefoxSetup(this.browserTmpDir(), config, done);
-      }
+      },
     },
     {
       name: 'Brave',
-      possiblePath: braveWinPaths(userHomeDir, 'Brave-Browser').concat(braveOSXPaths('Brave Browser')),
-      possibleExe: [
-        'brave'
-      ],
+      possiblePath: braveWinPaths(userHomeDir, 'Brave-Browser').concat(
+        braveOSXPaths('Brave Browser'),
+      ),
+      possibleExe: ['brave'],
       args(config, url) {
         return braveArgs(this.browserTmpDir(), url);
-      }
+      },
     },
     {
       name: 'Headless Brave',
-      possiblePath: braveWinPaths(userHomeDir, 'Brave-Browser').concat(braveOSXPaths('Brave Browser')),
-      possibleExe: [
-        'brave'
-      ],
+      possiblePath: braveWinPaths(userHomeDir, 'Brave-Browser').concat(
+        braveOSXPaths('Brave Browser'),
+      ),
+      possibleExe: ['brave'],
       args(config, url) {
         return headlessBraveArgs(this.browserTmpDir(), url);
-      }
+      },
     },
     {
       name: 'Chrome',
-      possiblePath: chromeWinPaths(userHomeDir, 'Chrome').concat(chromeOSXPaths('Google Chrome')),
-      possibleExe: [
-        'google-chrome',
-        'google-chrome-stable',
-        'chrome'
-      ],
+      possiblePath: chromeWinPaths(userHomeDir, 'Chrome').concat(
+        chromeOSXPaths('Google Chrome'),
+      ),
+      possibleExe: ['google-chrome', 'google-chrome-stable', 'chrome'],
       args(config, url) {
         return chromeArgs(this.browserTmpDir(), url);
-      }
+      },
     },
     {
       name: 'Headless Chrome',
-      possiblePath: chromeWinPaths(userHomeDir, 'Chrome').concat(chromeOSXPaths('Google Chrome')),
-      possibleExe: [
-        'google-chrome',
-        'google-chrome-stable',
-        'chrome'
-      ],
+      possiblePath: chromeWinPaths(userHomeDir, 'Chrome').concat(
+        chromeOSXPaths('Google Chrome'),
+      ),
+      possibleExe: ['google-chrome', 'google-chrome-stable', 'chrome'],
       args(config, url) {
         return headlessChromeArgs(this.browserTmpDir(), url);
-      }
+      },
     },
 
     // On Windows, Chrome Stable/Beta/Dev are installed on the same path
     {
       name: 'Chrome Beta',
       possiblePath: chromeOSXPaths('Google Chrome Beta'),
-      possibleExe: [
-        'google-chrome-beta'
-      ],
+      possibleExe: ['google-chrome-beta'],
       args(config, url) {
         return chromeArgs(this.browserTmpDir(), url);
-      }
+      },
     },
     {
       name: 'Headless Chrome Beta',
       possiblePath: chromeOSXPaths('Google Chrome Beta'),
-      possibleExe: [
-        'google-chrome-beta'
-      ],
+      possibleExe: ['google-chrome-beta'],
       args(config, url) {
         return headlessChromeArgs(this.browserTmpDir(), url);
-      }
+      },
     },
     {
       name: 'Chrome Dev',
       possiblePath: chromeOSXPaths('Google Chrome Dev'),
-      possibleExe: [
-        'google-chrome-unstable'
-      ],
+      possibleExe: ['google-chrome-unstable'],
       args(config, url) {
         return chromeArgs(this.browserTmpDir(), url);
-      }
+      },
     },
 
     // Chrome Canary is not available on Linux
     {
       name: 'Chrome Canary',
-      possiblePath: chromeWinPaths(userHomeDir, 'Chrome SxS').concat(chromeOSXPaths('Google Chrome Canary')),
+      possiblePath: chromeWinPaths(userHomeDir, 'Chrome SxS').concat(
+        chromeOSXPaths('Google Chrome Canary'),
+      ),
       args(config, url) {
         return chromeArgs(this.browserTmpDir(), url);
-      }
+      },
     },
     {
       name: 'Chromium',
-      possiblePath: chromeWinPaths(userHomeDir, 'Chromium').concat(chromeOSXPaths('Chromium')),
-      possibleExe: [
-        'chromium-browser',
-        'chromium'
-      ],
+      possiblePath: chromeWinPaths(userHomeDir, 'Chromium').concat(
+        chromeOSXPaths('Chromium'),
+      ),
+      possibleExe: ['chromium-browser', 'chromium'],
       args(config, url) {
         return chromeArgs(this.browserTmpDir(), url);
-      }
+      },
     },
     {
       name: 'Edge',
       possiblePath: edgePaths(),
-      possibleExe: [
-        'microsoft-edge'
-      ],
+      possibleExe: ['microsoft-edge'],
       args(config, url) {
         return chromeArgs(this.browserTmpDir(), url);
-      }
+      },
     },
     {
       name: 'Headless Edge',
       possiblePath: edgePaths(),
-      possibleExe: [
-        'microsoft-edge'
-      ],
+      possibleExe: ['microsoft-edge'],
       args(config, url) {
         return headlessChromeArgs(this.browserTmpDir(), url);
-      }
-    },
-    {
-      name: 'Safari',
-      possiblePath: [
-        'C:\\Program Files\\Safari\\safari.exe',
-        'C:\\Program Files (x86)\\Safari\\safari.exe',
-        process.env.HOME + '/Applications/Safari.app/Contents/MacOS/Safari',
-        '/Applications/Safari.app/Contents/MacOS/Safari'
-      ],
-      setup(config, done) {
-        let url = this.getUrl();
-        fs.writeFile(
-          path.join(this.browserTmpDir(), 'start.html'),
-          '<script>window.location = \'' + url + '\'</script>',
-          done
-        );
       },
-      args() {
-        return [path.join(this.browserTmpDir(), 'start.html')];
-      }
     },
+    platform === 'darwin'
+      ? {
+          // Use Launch Services so Safari opens the http(s) URL directly. Passing a local
+          // start.html file makes Safari 13+ prompt for confirmation (#1387) and breaks CI.
+          name: 'Safari',
+          possiblePath: '/usr/bin/open',
+          // `open` exits right after handing off to Safari; Testem must not treat that as the
+          // browser process dying (browser_test_runner ignoreProcessExit).
+          ignoreProcessExit: true,
+          args(config, url) {
+            return ['-a', 'Safari', url];
+          },
+        }
+      : {
+          name: 'Safari',
+          possiblePath: [
+            'C:\\Program Files\\Safari\\safari.exe',
+            'C:\\Program Files (x86)\\Safari\\safari.exe',
+            process.env.HOME + '/Applications/Safari.app/Contents/MacOS/Safari',
+            '/Applications/Safari.app/Contents/MacOS/Safari',
+          ],
+          setup(config, done) {
+            let url = this.getUrl();
+            fs.writeFile(
+              path.join(this.browserTmpDir(), 'start.html'),
+              "<script>window.location = '" + url + "'</script>",
+              done,
+            );
+          },
+          args() {
+            return [path.join(this.browserTmpDir(), 'start.html')];
+          },
+        },
     {
       name: 'Opera',
       possiblePath: [
         'C:\\Program Files\\Opera\\opera.exe',
         'C:\\Program Files (x86)\\Opera\\opera.exe',
         process.env.HOME + '/Applications/Opera.app/Contents/MacOS/Opera',
-        '/Applications/Opera.app/Contents/MacOS/Opera'
+        '/Applications/Opera.app/Contents/MacOS/Opera',
       ],
       args(config, url) {
         let operaDataDir = this.browserTmpDir();
         return ['--user-data-dir=' + operaDataDir, '-pd', operaDataDir, url];
-      }
+      },
     },
     {
       name: 'PhantomJS',
@@ -319,43 +362,38 @@ module.exports = function knownBrowsers(platform, config) {
           options = phantom_args.concat(options);
         }
         return options;
-      }
-    }
+      },
+    },
   ];
 
   if (isWin(platform)) {
     browsers.push({
       name: 'IE',
-      possiblePath: 'C:\\Program Files\\Internet Explorer\\iexplore.exe'
+      possiblePath: 'C:\\Program Files\\Internet Explorer\\iexplore.exe',
     });
-  } else {
+  } else if (platform === 'darwin') {
     browsers.push({
+      // Same Launch Services approach as Safari on macOS (#1387).
       name: 'Safari Technology Preview',
-      possiblePath: [
-        process.env.HOME + '/Applications/Safari Technology Preview.app/Contents/MacOS/Safari Technology Preview',
-        '/Applications/Safari Technology Preview.app/Contents/MacOS/Safari Technology Preview'
-      ],
-      setup(config, done) {
-        let url = this.getUrl();
-        fs.writeFile(
-          path.join(this.browserTmpDir(), 'start.html'),
-          '<script>window.location = \'' + url + '\'</script>',
-          done
-        );
+      possiblePath: '/usr/bin/open',
+      ignoreProcessExit: true,
+      args(config, url) {
+        return ['-a', 'Safari Technology Preview', url];
       },
-      args() {
-        return [path.join(this.browserTmpDir(), 'start.html')];
-      }
     });
   }
 
   // Add user-defined configs to browser objects
   let browserPaths = config.get('browser_paths'); // Add config defined 'path' for binary
-  let browserExes = config.get('browser_exes');  // Add config defined 'exe' for binary
+  let browserExes = config.get('browser_exes'); // Add config defined 'exe' for binary
   if (browserPaths || browserExes) {
-    browsers.forEach(browserObject => {
-      let browserPath = browserPaths ? browserPaths[browserObject.name] : undefined;
-      let browserExe = browserExes ? browserExes[browserObject.name] : undefined;
+    browsers.forEach((browserObject) => {
+      let browserPath = browserPaths
+        ? browserPaths[browserObject.name]
+        : undefined;
+      let browserExe = browserExes
+        ? browserExes[browserObject.name]
+        : undefined;
       if (browserPath) {
         browserObject.possiblePath = browserPath;
       }

package/lib/utils/path_pattern_match.js

@@ -0,0 +1,39 @@
+const { minimatch } = require('minimatch');
+
+/**
+ * Match a path against a single glob pattern. Thin wrapper so the matcher
+ * implementation (minimatch today, possibly picomatch later) lives in one place.
+ *
+ * @param {string} filePath - Path to test (forward slashes recommended; callers often use `convertToPosix`).
+ * @param {string} pattern - A single glob pattern.
+ * @param {import('minimatch').MinimatchOptions} [options] - Passed through to the matcher.
+ * @returns {boolean}
+ */
+function pathMatchesPattern(filePath, pattern, options) {
+  if (pattern === null || pattern === undefined || pattern === '') {
+    return false;
+  }
+  return minimatch(filePath, pattern, options);
+}
+
+/**
+ * True if `filePath` matches **any** non-empty pattern in the list.
+ *
+ * @param {string} filePath
+ * @param {string[]} patterns
+ * @param {import('minimatch').MinimatchOptions} [options]
+ * @returns {boolean}
+ */
+function pathMatchesAny(filePath, patterns, options) {
+  if (!patterns || patterns.length === 0) {
+    return false;
+  }
+  return patterns.some(function(p) {
+    return p && pathMatchesPattern(filePath, p, options);
+  });
+}
+
+module.exports = {
+  pathMatchesPattern,
+  pathMatchesAny,
+};