dependency-cruiser 12.5.0-beta-2 → 12.5.0-beta-4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-cruiser",
-  "version": "12.5.0-beta-2",
+  "version": "12.5.0-beta-4",
   "description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
   "keywords": [
     "static analysis",

package/src/cache/cache.js

@@ -2,8 +2,8 @@ const { readFileSync, mkdirSync, writeFileSync } = require("fs");
 const { join } = require("path");
 const meta = require("../extract/transpile/meta");
 const { optionsAreCompatible } = require("./options-compatible");
-const metadataStrategy = require("./metadata-strategy");
-const contentStrategy = require("./content-strategy");
+const MetadataStrategy = require("./metadata-strategy");
+const ContentStrategy = require("./content-strategy");
 
 const CACHE_FILE_NAME = "cache.json";
 
@@ -14,7 +14,9 @@ module.exports = class Cache {
   constructor(pCacheStrategy) {
     this.revisionData = null;
     this.cacheStrategy =
-      pCacheStrategy === "content" ? contentStrategy : metadataStrategy;
+      pCacheStrategy === "content"
+        ? new ContentStrategy()
+        : new MetadataStrategy();
   }
 
   /**

package/src/cache/content-strategy.js

@@ -1,176 +1,29 @@
+const { join } = require("path").posix;
 const { isDeepStrictEqual } = require("util");
-const bus = require("../utl/bus");
-const { DEBUG } = require("../utl/bus-log-levels");
-const findAllFiles = require("../utl/find-all-files");
+const findContentChanges = require("./find-content-changes");
 const {
   getFileHash,
-  excludeFilter,
-  includeOnlyFilter,
   isInterestingChangeType,
-  hasInterestingExtension,
   addCheckSumToChange,
+  moduleIsInterestingForDiff,
 } = require("./utl");
 
 /**
- * @param {Set<string>} pFileSet
- * @param {typeof getFileHash} pFileHashFunction
- * @returns {import('../..').IRevisionChange}
+ * @param {string} pBaseDirectory
+ * @returns {(pModule: import("../..").IModule) => import("../..").IModule}
  */
-function diffCachedModuleAgainstFileSet(
-  pFileSet,
-  pFileHashFunction = getFileHash
-) {
-  // eslint-disable-next-line complexity
+function addCheckSumToModule(pBaseDirectory) {
   return (pModule) => {
-    if (
-      !pModule.consolidated &&
-      !pModule.coreModule &&
-      !pModule.couldNotResolve &&
-      !pModule.matchesDoNotFollow
-    ) {
-      if (!pFileSet.has(pModule.source)) {
-        return { name: pModule.source, changeType: "deleted" };
-      }
-      const lNewCheckSum = pFileHashFunction(pModule.source);
-      if (lNewCheckSum !== pModule.checksum) {
-        return {
-          name: pModule.source,
-          changeType: "modified",
-          checksum: lNewCheckSum,
-        };
-      }
+    if (moduleIsInterestingForDiff(pModule)) {
+      return {
+        ...pModule,
+        checksum: getFileHash(join(pBaseDirectory, pModule.source)),
+      };
     }
-    return {
-      name: pModule.source,
-      changeType: "unmodified",
-      checksum: pModule.checksum,
-    };
+    return pModule;
   };
 }
 
-/**
-  We can run into these scenarios:
-  - there is no cache yet:
-    modules will === []; all files will be marked as 'added'
-  - there is a cache and it contains checksums:
-    - existing files that are not in the cache => added
-    - modules that are in the cache:
-      - don't exist anymore => deleted TODO: 
-        we might wrongly bump into this for files that are gitignored and that don't have an interesting extension
-      - cached checksum === current checksum => not a change; left out
-      - cached checksum !== current checksum => modified
-  - there is a cache, but it doesn't contain checksums => same as before, except
-    all files will be marked as 'modified'
- * @param {string} pDirectory
- * @param {import("../..").ICruiseResult} pCachedCruiseResult
- * @param {Object} pOptions
- * @param {Set<string>} pOptions.extensions
- * @param {string} pOptions.baseDir
- * @returns {{source: string; changeType: import("watskeburt").changeTypeType; checksum: string}[]}
- */
-function findChanges(pDirectory, pCachedCruiseResult, pOptions) {
-  bus.emit("progress", "cache: - hauling revision data", { level: DEBUG });
-  const lFileSet = new Set(
-    findAllFiles(pDirectory, {
-      baseDir: pOptions.baseDir,
-    })
-      .filter(excludeFilter(pOptions.exclude))
-      .filter(includeOnlyFilter(pOptions.includeOnly))
-  );
-
-  bus.emit("progress", "cache: - determining cached vs new", { level: DEBUG });
-  const lDiffCachedVsNew = pCachedCruiseResult.modules.map(
-    diffCachedModuleAgainstFileSet(lFileSet)
-  );
-
-  bus.emit("progress", "cache: - determining new vs cached", { level: DEBUG });
-  lDiffCachedVsNew.forEach(({ name }) => lFileSet.delete(name));
-
-  const lDiffNewVsCached = [];
-  for (let lFileName of lFileSet) {
-    lDiffNewVsCached.push({
-      name: lFileName,
-      changeType: "added",
-      checksum: getFileHash(lFileName),
-    });
-  }
-
-  bus.emit("progress", "cache: - returning revision data", { level: DEBUG });
-  return lDiffCachedVsNew
-    .concat(lDiffNewVsCached)
-    .filter(hasInterestingExtension(pOptions.extensions));
-}
-
-/**
- *
- * @param {string} pDirectory
- * @param {import("../..").ICruiseResult} pCachedCruiseResult
- * @param {import("../../types/strict-options").IStrictCruiseOptions} pCruiseOptions
- * @param {Object} pOptions
- * @param {Set<string>} pOptions.extensions
- * @param {Set<import("watskeburt").changeTypeType>} pOptions.interestingChangeTypes
- * @param {string} pOptions.baseDir
- * @param {(pString:string) => Array<import("watskeburt").IChange>} pOptions.diffListFn
- * @param {(import("watskeburt").IChange) => import("../..").IRevisionChange} pOptions.checksumFn
- * @returns {import("../..").IRevisionData}
- */
-function getRevisionData(
-  pDirectory,
-  pCachedCruiseResult,
-  pCruiseOptions,
-  pOptions
-) {
-  const lOptions = {
-    diffListFn: findChanges,
-    checksumFn: addCheckSumToChange,
-    baseDir: process.cwd(),
-    ...pOptions,
-  };
-  return {
-    SHA1: "unknown-in-content-cache-strategy",
-    changes: lOptions
-      .diffListFn(pDirectory, pCachedCruiseResult, {
-        baseDir: lOptions.baseDir,
-        extensions: lOptions.extensions,
-        includeOnly: pCruiseOptions.includeOnly,
-        exclude: pCruiseOptions.exclude,
-      })
-      .filter(isInterestingChangeType(lOptions.interestingChangeTypes)),
-  };
-}
-
-/**
- * @param {import("../..").IRevisionData} pExistingRevisionData
- * @param {import("../..").IRevisionData} pNewRevisionData
- * @returns {boolean}
- */
-function revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
-  return (
-    Boolean(pExistingRevisionData) &&
-    Boolean(pNewRevisionData) &&
-    isDeepStrictEqual(pExistingRevisionData.changes, pNewRevisionData.changes)
-  );
-}
-
-/**
- * @param {import("../..").IModule} pModule
- * @param {import("../..").IRevisionChange}
- */
-function addCheckSumToModule(pModule) {
-  if (
-    !pModule.consolidated &&
-    !pModule.coreModule &&
-    !pModule.couldNotResolve &&
-    !pModule.matchesDoNotFollow
-  ) {
-    return {
-      ...pModule,
-      checksum: getFileHash(pModule.source),
-    };
-  }
-  return pModule;
-}
-
 /**
  * @param {import("../..").IRevisionChange[]} pChanges
  * @param {import("../..").IModule[]} pModules
@@ -187,29 +40,74 @@ function refreshChanges(pChanges, pModules) {
   );
 }
 
-/**
- * @param {import("../..").ICruiseResult} pCruiseResult
- * @param {import("../..").IRevisionData} pRevisionData
- * @returns {import("../..").ICruiseResult}
- */
-function prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
-  const lModulesWithCheckSum = pCruiseResult.modules.map(addCheckSumToModule);
-  const lRevisionData = {
-    ...pRevisionData,
-    changes: refreshChanges(pRevisionData.changes, lModulesWithCheckSum),
-  };
+module.exports = class ContentStrategy {
+  /**
+   * @param {string} pDirectory
+   * @param {import("../..").ICruiseResult} pCachedCruiseResult
+   * @param {import("../../types/strict-options").IStrictCruiseOptions} pCruiseOptions
+   * @param {Object} pOptions
+   * @param {Set<string>} pOptions.extensions
+   * @param {Set<import("watskeburt").changeTypeType>} pOptions.interestingChangeTypes
+   * @param {string} pOptions.baseDir
+   * @param {(pString:string) => Array<import("watskeburt").IChange>} pOptions.diffListFn
+   * @param {(import("watskeburt").IChange) => import("../..").IRevisionChange} pOptions.checksumFn
+   * @returns {import("../..").IRevisionData}
+   */
+  getRevisionData(pDirectory, pCachedCruiseResult, pCruiseOptions, pOptions) {
+    const lOptions = {
+      diffListFn: findContentChanges,
+      checksumFn: addCheckSumToChange,
+      baseDir: process.cwd(),
+      ...pOptions,
+    };
+    return {
+      SHA1: "unknown-in-content-cache-strategy",
+      changes: lOptions
+        .diffListFn(pDirectory, pCachedCruiseResult, {
+          baseDir: lOptions.baseDir,
+          extensions: lOptions.extensions,
+          includeOnly: pCruiseOptions.includeOnly,
+          exclude: pCruiseOptions.exclude,
+        })
+        .filter(isInterestingChangeType(lOptions.interestingChangeTypes)),
+    };
+  }
 
-  return pRevisionData
-    ? {
-        ...pCruiseResult,
-        modules: lModulesWithCheckSum,
-        revisionData: lRevisionData,
-      }
-    : pCruiseResult;
-}
+  /**
+   * @param {import("../..").IRevisionData} pExistingRevisionData
+   * @param {import("../..").IRevisionData} pNewRevisionData
+   * @returns {boolean}
+   */
+  revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
+    return (
+      Boolean(pExistingRevisionData) &&
+      Boolean(pNewRevisionData) &&
+      // Even though we don't really have a SHA1, it might be the previous version
+      // of the cache did, e.g. because it was rendered with the metadata cache
+      // strategy. In that case the SHA1 comparison is a reliable, fast bailout.
+      pExistingRevisionData.SHA1 === pNewRevisionData.SHA1 &&
+      isDeepStrictEqual(pExistingRevisionData.changes, pNewRevisionData.changes)
+    );
+  }
 
-module.exports = {
-  getRevisionData,
-  revisionDataEqual,
-  prepareRevisionDataForSaving,
+  /**
+   * @param {import("../..").ICruiseResult} pCruiseResult
+   * @param {import("../..").IRevisionData} pRevisionData
+   * @returns {import("../..").ICruiseResult}
+   */
+  prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
+    const lModulesWithCheckSum = pCruiseResult.modules.map(
+      addCheckSumToModule(pCruiseResult.summary.optionsUsed.baseDir)
+    );
+    const lRevisionData = {
+      ...pRevisionData,
+      changes: refreshChanges(pRevisionData.changes, lModulesWithCheckSum),
+    };
+
+    return {
+      ...pCruiseResult,
+      modules: lModulesWithCheckSum,
+      revisionData: lRevisionData,
+    };
+  }
 };

package/src/cache/find-content-changes.js

@@ -0,0 +1,104 @@
+const { join } = require("path").posix;
+const bus = require("../utl/bus");
+const { DEBUG } = require("../utl/bus-log-levels");
+const findAllFiles = require("../utl/find-all-files");
+const {
+  getFileHash,
+  excludeFilter,
+  includeOnlyFilter,
+  hasInterestingExtension,
+  moduleIsInterestingForDiff,
+} = require("./utl");
+
+/**
+ * @param {Set<string>} pFileSet
+ * @param {typeof getFileHash} pFileHashFunction
+ * @returns {(pModule:import("../..").IModule) => import('../..').IRevisionChange}
+ */
+function diffCachedModuleAgainstFileSet(
+  pFileSet,
+  pBaseDirectory,
+  pFileHashFunction = getFileHash
+) {
+  return (pModule) => {
+    if (!moduleIsInterestingForDiff(pModule)) {
+      return { name: pModule.source, changeType: "ignored" };
+    }
+
+    if (!pFileSet.has(pModule.source)) {
+      return { name: pModule.source, changeType: "deleted" };
+    }
+
+    const lNewCheckSum = pFileHashFunction(
+      join(pBaseDirectory, pModule.source)
+    );
+    if (lNewCheckSum !== pModule.checksum) {
+      return {
+        name: pModule.source,
+        changeType: "modified",
+        checksum: lNewCheckSum,
+      };
+    }
+
+    return {
+      name: pModule.source,
+      changeType: "unmodified",
+      checksum: pModule.checksum,
+    };
+  };
+}
+
+/**
+  We can run into these scenarios:
+  - there is no cache yet:
+    modules will === []; all files will be marked as 'added'
+  - there is a cache and it contains checksums:
+    - existing files that are not in the cache => added
+    - modules that are in the cache:
+      - don't exist anymore => deleted TODO: 
+        we might wrongly bump into this for files that are gitignored and that don't have an interesting extension
+      - cached checksum === current checksum => not a change; left out
+      - cached checksum !== current checksum => modified
+  - there is a cache, but it doesn't contain checksums => same as before, except
+    all files will be marked as 'modified'
+ * @param {string} pDirectory
+ * @param {import("../..").ICruiseResult} pCachedCruiseResult
+ * @param {Object} pOptions
+ * @param {Set<string>} pOptions.extensions
+ * @param {string} pOptions.baseDir
+ * @returns {{source: string; changeType: import("watskeburt").changeTypeType; checksum: string}[]}
+ */
+module.exports = function findContentChanges(
+  pDirectory,
+  pCachedCruiseResult,
+  pOptions
+) {
+  bus.emit("progress", "cache: - hauling revision data", { level: DEBUG });
+  const lFileSet = new Set(
+    findAllFiles(pDirectory, {
+      baseDir: pOptions.baseDir,
+      excludeFilterFn: excludeFilter(pOptions.exclude),
+      includeOnlyFilterFn: includeOnlyFilter(pOptions.includeOnly),
+    }).filter(hasInterestingExtension(pOptions.extensions))
+  );
+
+  bus.emit("progress", "cache: - determining cached vs new", { level: DEBUG });
+  const lDiffCachedVsNew = pCachedCruiseResult.modules.map(
+    diffCachedModuleAgainstFileSet(lFileSet, pOptions.baseDir)
+  );
+
+  bus.emit("progress", "cache: - determining new vs cached", { level: DEBUG });
+  lDiffCachedVsNew.forEach(({ name }) => lFileSet.delete(name));
+
+  const lDiffNewVsCached = [];
+  for (let lFileName of lFileSet) {
+    lDiffNewVsCached.push({
+      name: lFileName,
+      changeType: "added",
+      checksum: getFileHash(join(pOptions.baseDir, lFileName)),
+    });
+  }
+
+  bus.emit("progress", "cache: - returning revision data", { level: DEBUG });
+  return lDiffCachedVsNew.concat(lDiffNewVsCached);
+};

package/src/cache/metadata-strategy.js

@@ -5,86 +5,77 @@ const {
   addCheckSumToChange,
   excludeFilter,
   includeOnlyFilter,
-  hasInterestingExtension,
+  changeHasInterestingExtension,
 } = require("./utl");
 
-/**
- * @param {Set<string>} pExtensions
- * @param {Set<import("watskeburt").changeTypeType>} pInterestingChangeTypes
- * @param {import("../../types/strict-options").IStrictCruiseOptions} pCruiseOptions
- * @param {Object} pOptions
- * @param {Set<string>} pOptions.extensions
- * @param {Set<import("watskeburt").changeTypeType>} pOptions.interestingChangeTypes
- * @param {() => string} pOptions.shaRetrievalFn
- * @param {(pString:string) => Array<import("watskeburt").IChange>} pOptions.diffListFn
- * @param {(import("watskeburt").IChange) => import("../..").IRevisionChange} pOptions.checksumFn
- * @returns {import("../..").IRevisionData}
- */
-function getRevisionData(
-  pDirectory,
-  pCachedCruiseResult,
-  pCruiseOptions,
-  pOptions
-) {
-  const lOptions = {
-    shaRetrievalFn: getSHASync,
-    diffListFn: listSync,
-    checksumFn: addCheckSumToChange,
-    ...pOptions,
-  };
-  try {
-    const lSHA = lOptions.shaRetrievalFn();
-    return {
-      SHA1: lSHA,
-      changes: lOptions
-        .diffListFn(lSHA)
-        .filter(({ name }) => excludeFilter(pCruiseOptions.exclude)(name))
-        .filter(({ name }) =>
-          includeOnlyFilter(pCruiseOptions.includeOnly)(name)
-        )
-        .filter(hasInterestingExtension(lOptions.extensions))
-        .filter(isInterestingChangeType(lOptions.interestingChangeTypes))
-        .map(lOptions.checksumFn),
+module.exports = class MetaDataStrategy {
+  /**
+   * @param {Set<string>} pExtensions
+   * @param {Set<import("watskeburt").changeTypeType>} pInterestingChangeTypes
+   * @param {import("../../types/strict-options").IStrictCruiseOptions} pCruiseOptions
+   * @param {Object} pOptions
+   * @param {Set<string>} pOptions.extensions
+   * @param {Set<import("watskeburt").changeTypeType>} pOptions.interestingChangeTypes
+   * @param {() => string} pOptions.shaRetrievalFn
+   * @param {(pString:string) => Array<import("watskeburt").IChange>} pOptions.diffListFn
+   * @param {(import("watskeburt").IChange) => import("../..").IRevisionChange} pOptions.checksumFn
+   * @returns {import("../..").IRevisionData}
+   */
+  getRevisionData(pDirectory, pCachedCruiseResult, pCruiseOptions, pOptions) {
+    const lOptions = {
+      shaRetrievalFn: getSHASync,
+      diffListFn: listSync,
+      checksumFn: addCheckSumToChange,
+      ...pOptions,
     };
-  } catch (pError) {
-    throw new Error(
-      "The --cache option works in concert with git - and it seems either the " +
-        "current folder isn't version managed or git isn't installed. Error:" +
-        `\n\n          ${pError}\n`
-    );
+    try {
+      const lSHA = lOptions.shaRetrievalFn();
+      return {
+        SHA1: lSHA,
+        changes: lOptions
+          .diffListFn(lSHA)
+          .filter(({ name }) => excludeFilter(pCruiseOptions.exclude)(name))
+          .filter(({ name }) =>
+            includeOnlyFilter(pCruiseOptions.includeOnly)(name)
+          )
+          .filter(changeHasInterestingExtension(lOptions.extensions))
+          .filter(isInterestingChangeType(lOptions.interestingChangeTypes))
+          .map(lOptions.checksumFn),
+      };
+    } catch (pError) {
+      throw new Error(
+        "The --cache option works in concert with git - and it seems either the " +
+          "current folder isn't version managed or git isn't installed. Error:" +
+          `\n\n          ${pError}\n`
+      );
+    }
   }
-}
-
-/**
- * @param {import("../..").IRevisionData} pExistingRevisionData
- * @param {import("../..").IRevisionData} pNewRevisionData
- * @returns {boolean}
- */
-function revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
-  return (
-    Boolean(pExistingRevisionData) &&
-    Boolean(pNewRevisionData) &&
-    pExistingRevisionData.SHA1 === pNewRevisionData.SHA1 &&
-    isDeepStrictEqual(pExistingRevisionData.changes, pNewRevisionData.changes)
-  );
-}
 
-/**
- * @param {import("../..").ICruiseResult} pCruiseResult
- * @param {import("../..").IRevisionData} pRevisionData
- * @returns {import("../..").ICruiseResult}
- */
-function prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
-  return pRevisionData
-    ? {
-        ...pCruiseResult,
-        revisionData: pRevisionData,
-      }
-    : pCruiseResult;
-}
+  /**
+   * @param {import("../..").IRevisionData} pExistingRevisionData
+   * @param {import("../..").IRevisionData} pNewRevisionData
+   * @returns {boolean}
+   */
+  revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
+    return (
+      Boolean(pExistingRevisionData) &&
+      Boolean(pNewRevisionData) &&
+      pExistingRevisionData.SHA1 === pNewRevisionData.SHA1 &&
+      isDeepStrictEqual(pExistingRevisionData.changes, pNewRevisionData.changes)
+    );
+  }
 
-module.exports = {
-  getRevisionData,
-  revisionDataEqual,
-  prepareRevisionDataForSaving,
+  /**
+   * @param {import("../..").ICruiseResult} pCruiseResult
+   * @param {import("../..").IRevisionData} pRevisionData
+   * @returns {import("../..").ICruiseResult}
+   */
+  prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
+    return pRevisionData
+      ? {
+          ...pCruiseResult,
+          revisionData: pRevisionData,
+        }
+      : pCruiseResult;
+  }
 };

package/src/cache/utl.js

@@ -63,23 +63,29 @@ function includeOnlyFilter(pIncludeOnlyFilter) {
     return true;
   };
 }
+/**
+ * @param {Set<string>} pExtensions
+ * @returns {(pFileName: string) => boolean}
+ */
+function hasInterestingExtension(pExtensions) {
+  return (pFileName) => pExtensions.has(path.extname(pFileName));
+}
 
 /**
  * @param {Set<string>} pExtensions
  * @returns {(pChange: import("watskeburt").IChange) => boolean}
  */
-function hasInterestingExtension(pExtensions) {
+function changeHasInterestingExtension(pExtensions) {
   return (pChange) =>
-    pExtensions.has(path.extname(pChange.name)) ||
-    (pChange.oldName && pExtensions.has(path.extname(pChange.oldName)));
+    hasInterestingExtension(pExtensions)(pChange.name) ||
+    (pChange.oldName && hasInterestingExtension(pExtensions)(pChange.oldName));
 }
 
-// skipping: "pairing broken", "unmodified", "unmerged", "type changed"
+// skipping: "pairing broken", "unmodified", "type changed", "ignored"
 const DEFAULT_INTERESTING_CHANGE_TYPES = new Set([
   "added",
   "copied",
   "deleted",
-  "ignored",
   "modified",
   "renamed",
   "unmerged",
@@ -97,11 +103,25 @@ function isInterestingChangeType(pInterestingChangeTypes) {
     );
 }
 
+/**
+ * @param {pModule:import("../..").IModule} pModule
+ */
+function moduleIsInterestingForDiff(pModule) {
+  return (
+    !pModule.consolidated &&
+    !pModule.coreModule &&
+    !pModule.couldNotResolve &&
+    !pModule.matchesDoNotFollow
+  );
+}
+
 module.exports = {
   getFileHash,
   excludeFilter,
   includeOnlyFilter,
   hasInterestingExtension,
+  changeHasInterestingExtension,
   isInterestingChangeType,
   addCheckSumToChange,
+  moduleIsInterestingForDiff,
 };

package/src/main/index.js

@@ -63,9 +63,13 @@ function futureCruise(
   let lCache = null;
 
   if (lCruiseOptions.cache) {
-    bus.emit("progress", "cache: checking freshness", c(2));
+    bus.emit(
+      "progress",
+      `cache: check freshness with ${lCruiseOptions.cache.strategy}`,
+      c(2)
+    );
 
-    lCache = new Cache(lCruiseOptions?.cache.strategy);
+    lCache = new Cache(lCruiseOptions.cache.strategy);
     const lCachedResults = lCache.read(lCruiseOptions.cache.folder);
 
     if (lCache.canServeFromCache(lCruiseOptions, lCachedResults)) {
@@ -108,7 +112,7 @@ function futureCruise(
   );
 
   if (lCruiseOptions.cache) {
-    bus.emit("progress", "cache: saving", c(7));
+    bus.emit("progress", "cache: save", c(7));
     lCache.write(lCruiseOptions.cache.folder, lCruiseResult);
   }
 

package/src/meta.js

@@ -1,7 +1,7 @@
 /* generated - don't edit */
 
 module.exports = {
-  version: "12.5.0-beta-2",
+  version: "12.5.0-beta-4",
   engines: {
     node: "^14||^16||>=18",
   },

package/src/utl/find-all-files.js

@@ -3,6 +3,10 @@ const { join } = require("path");
 const ignore = require("ignore");
 const pathToPosix = require("./path-to-posix");
 
+/**
+ * @typedef {(pString:string, pIndex: number, pArray: string[]) => boolean} FilterFunctionType
+ */
+
 /**
  * @param {string} pFullPathToFile
  * @param {string} pBaseDirectory
@@ -19,13 +23,18 @@ function fileIsDirectory(pFullPathToFile, pBaseDirectory) {
 
 /**
  * @param {string} pDirectoryName
- * @param {{baseDir: string; ignoreFilterFn: (pString:string, pIndex: number, pArray: string[]) => boolean)}} pOptions
+ * @param {{baseDir: string; ignoreFilterFn: FilterFunctionType; excludeFilterFn: FilterFunctionType; includeOnlyFilterFn: FilterFunctionType}} pOptions
  * @returns {string[]}
  */
-function walk(pDirectoryName, { baseDir, ignoreFilterFn }) {
+function walk(
+  pDirectoryName,
+  { baseDir, ignoreFilterFn, excludeFilterFn, includeOnlyFilterFn }
+) {
   return readdirSync(join(baseDir, pDirectoryName))
     .map((pFileName) => join(pDirectoryName, pFileName))
     .filter(ignoreFilterFn)
+    .filter(excludeFilterFn)
+    .filter(includeOnlyFilterFn)
     .map((pFullPathToFile) => ({
       fullPathToFile: pFullPathToFile,
       isDirectory: fileIsDirectory(pFullPathToFile, baseDir),
@@ -38,7 +47,14 @@ function walk(pDirectoryName, { baseDir, ignoreFilterFn }) {
        */
       (pSum, { fullPathToFile, isDirectory }) => {
         if (isDirectory) {
-          return pSum.concat(walk(fullPathToFile, { baseDir, ignoreFilterFn }));
+          return pSum.concat(
+            walk(fullPathToFile, {
+              baseDir,
+              ignoreFilterFn,
+              excludeFilterFn,
+              includeOnlyFilterFn,
+            })
+          );
         }
         return pSum.concat(fullPathToFile);
       },
@@ -55,14 +71,28 @@ function readIgnoreFile(pFileName) {
   }
 }
 
+/**
+ * @type FilterFunctionType
+ */
+// eslint-disable-next-line no-unused-vars
+function identityFilter(_pString, _pIndex, _pArray) {
+  return true;
+}
+
 /**
  * @param {string} pDirectoryName
- * @param {{baseDir: string; ignoreFileContents?: string; additionalIgnorePatterns?: string[]}} pOptions
+ * @param {{baseDir: string; ignoreFileContents?: string; additionalIgnorePatterns?: string[]; excludeFilterFn: FilterFunctionType; includeOnlyFilterFn: FilterFunctionType}} pOptions
  * @returns {string[]}
  */
 module.exports = function findAllFiles(
   pDirectoryName,
-  { baseDir, ignoreFileContents, additionalIgnorePatterns }
+  {
+    baseDir,
+    ignoreFileContents,
+    additionalIgnorePatterns,
+    excludeFilterFn,
+    includeOnlyFilterFn,
+  }
 ) {
   const lIgnoreFileContents =
     ignoreFileContents ?? readIgnoreFile(join(baseDir, ".gitignore"));
@@ -75,5 +105,7 @@ module.exports = function findAllFiles(
   return walk(pDirectoryName, {
     baseDir,
     ignoreFilterFn: lIgnoreFilterFunction,
+    excludeFilterFn: excludeFilterFn ?? identityFilter,
+    includeOnlyFilterFn: includeOnlyFilterFn ?? identityFilter,
   });
 };