dependency-cruiser 12.5.1 → 12.6.0

package/bin/dependency-cruise.js

@@ -111,6 +111,11 @@ try {
       "(experimental) strategy to use for detecting changed files in the cache. " +
         "Possible values: metadata (= use git, the default), content"
     )
+    .option(
+      "--no-cache",
+      "switch off caching. Overrides the 'cache' key in .dependency-cruiser.js " +
+        "and --cache options set earlier on the command line"
+    )
     .option("--preserve-symlinks", `leave symlinks unchanged (off by default)`)
     .option("-v, --validate [file]", `alias for --config`)
     .option(

package/package.json

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

package/src/cli/listeners/performance-log/format-helpers.js

@@ -2,7 +2,7 @@ const chalk = require("chalk");
 
 const MS_PER_SECOND = 1000;
 const MS_PER_MICRO_SECOND = 0.001;
-const MAX_LENGTH_EXPECTED = 12;
+const MAX_EXPECTED_LENGTH = 13;
 const NUMBER_OF_COLUMNS = 8;
 const K = 1024;
 /*
@@ -28,7 +28,11 @@ const gSizeFormat = new Intl.NumberFormat(LOCALE, {
   maximumFractionDigits: 0,
 }).format;
 
-const pad = (pString) => pString.padStart(MAX_LENGTH_EXPECTED).concat(" ");
+const pad = (pString) => pString.padStart(MAX_EXPECTED_LENGTH).concat(" ");
+
+function formatDividerLine() {
+  return `${`${"-".repeat(MAX_EXPECTED_LENGTH)} `.repeat(NUMBER_OF_COLUMNS)}\n`;
+}
 
 function formatHeader() {
   return chalk
@@ -43,19 +47,17 @@ function formatHeader() {
         pad("∆ external")
       }after step...\n`
     )
-    .concat(
-      `${`${"-".repeat(MAX_LENGTH_EXPECTED)} `.repeat(NUMBER_OF_COLUMNS)}\n`
-    );
+    .concat(formatDividerLine());
 }
 
 function formatTime(pNumber, pConversionMultiplier = MS_PER_SECOND) {
   return gTimeFormat(pConversionMultiplier * pNumber)
-    .padStart(MAX_LENGTH_EXPECTED)
+    .padStart(MAX_EXPECTED_LENGTH)
     .concat(" ");
 }
 
 function formatMemory(pBytes) {
-  const lReturnValue = gSizeFormat(pBytes / K).padStart(MAX_LENGTH_EXPECTED);
+  const lReturnValue = gSizeFormat(pBytes / K).padStart(MAX_EXPECTED_LENGTH);
 
   return (pBytes < 0 ? chalk.blue(lReturnValue) : lReturnValue).concat(" ");
 }
@@ -87,4 +89,5 @@ module.exports = {
   formatMemory,
   formatPerfLine,
   formatHeader,
+  formatDividerLine,
 };

package/src/cli/listeners/performance-log/handlers.js

@@ -1,8 +1,7 @@
 const {
-  formatTime,
   formatPerfLine,
   formatHeader,
-  formatMemory,
+  formatDividerLine,
 } = require("./format-helpers");
 
 function getHeader(pLevel, pMaxLevel) {
@@ -47,11 +46,24 @@ function getProgressLine(pMessage, pState, pLevel, pMaxLevel) {
 function getEndText(pState, pLevel, pMaxLevel) {
   if (pLevel <= pMaxLevel) {
     const lTime = process.uptime();
-    const { heapUsed } = process.memoryUsage();
-    pState.previousMessage = `really done (${formatTime(
-      lTime
-    ).trim()}, ${formatMemory(heapUsed).trim()})`;
-    return getProgressLine("", pState, pLevel, pMaxLevel);
+    const { user, system } = process.cpuUsage();
+    const { heapUsed, heapTotal, external, rss } = process.memoryUsage();
+    pState.previousMessage = "really done";
+
+    return (
+      getProgressLine("", pState, pLevel, pMaxLevel) +
+      formatDividerLine() +
+      formatPerfLine({
+        elapsedTime: lTime,
+        elapsedUser: user,
+        elapsedSystem: system,
+        deltaRss: rss,
+        deltaHeapUsed: heapUsed,
+        deltaHeapTotal: heapTotal,
+        deltaExternal: external,
+        message: "",
+      })
+    );
   }
   return "";
 }

package/src/enrich/derive/{circular/index.js → circular.js}

@@ -1,20 +1,20 @@
 /* eslint-disable security/detect-object-injection */
-const getCycle = require("./get-cycle");
 
 function addCircularityCheckToDependency(
-  pGraph,
+  pIndexedGraph,
   pFrom,
   pToDep,
-  { pDependencyName, pFindNodeByName }
+  pDependencyName
 ) {
   let lReturnValue = {
     ...pToDep,
     circular: false,
   };
-  const lCycle = getCycle(pGraph, pFrom, pToDep[pDependencyName], {
-    pDependencyName,
-    pFindNodeByName,
-  });
+  const lCycle = pIndexedGraph.getCycle(
+    pFrom,
+    pToDep[pDependencyName],
+    pDependencyName
+  );
 
   if (lCycle.length > 0) {
     lReturnValue = {
@@ -32,21 +32,20 @@ function addCircularityCheckToDependency(
  * whether it's (part of a) circular (relationship) and returns the
  * dependencies with that added.
  */
-module.exports = (
+module.exports = function detectAndAddCycles(
   pNodes,
-  { pSourceAttribute, pDependencyName, pFindNodeByName }
-) =>
-  pNodes.map((pModule) => ({
+  pIndexedNodes,
+  { pSourceAttribute, pDependencyName }
+) {
+  return pNodes.map((pModule) => ({
     ...pModule,
     dependencies: pModule.dependencies.map((pToDep) =>
       addCircularityCheckToDependency(
-        pNodes,
+        pIndexedNodes,
         pModule[pSourceAttribute],
         pToDep,
-        {
-          pDependencyName,
-          pFindNodeByName,
-        }
+        pDependencyName
       )
     ),
   }));
+};

package/src/enrich/derive/folders/aggregate-to-folders.js

@@ -2,6 +2,7 @@
 const path = require("path").posix;
 const { calculateInstability, metricsAreCalculable } = require("../module-utl");
 const detectCycles = require("../circular");
+const IndexedModuleGraph = require("../../../graph-utl/indexed-module-graph");
 const {
   findFolderByName,
   getAfferentCouplings,
@@ -82,7 +83,7 @@ function calculateFolderMetrics(pFolder) {
   };
 }
 
-function denormalizeInstability(pFolder, _, pAllFolders) {
+function deNormalizeInstability(pFolder, _, pAllFolders) {
   return {
     ...pFolder,
     dependencies: pFolder.dependencies.map((pDependency) => {
@@ -114,15 +115,15 @@ function getSinks(pFolders) {
 }
 
 module.exports = function aggregateToFolders(pModules) {
-  const lFolders = object2Array(
+  let lFolders = object2Array(
     pModules.filter(metricsAreCalculable).reduce(aggregateToFolder, {})
   )
     .map(calculateFolderMetrics)
-    .map(denormalizeInstability);
+    .map(deNormalizeInstability);
+  lFolders = lFolders.concat(getSinks(lFolders));
 
-  return detectCycles(lFolders.concat(getSinks(lFolders)), {
+  return detectCycles(lFolders, new IndexedModuleGraph(lFolders, "name"), {
     pSourceAttribute: "name",
     pDependencyName: "name",
-    pFindNodeByName: findFolderByName,
   });
 };

package/src/enrich/derive/folders/index.js

@@ -2,8 +2,7 @@ const validate = require("../../../validate");
 const aggregateToFolders = require("./aggregate-to-folders");
 
 /**
- *
- * @param {*} pFolder
+ * @param {import("../../../..").IFolder} pFolder
  * @param {import('../../../..').IOptions} pOptions
  * @returns
  */

package/src/enrich/derive/metrics/get-module-metrics.js

@@ -1,4 +1,4 @@
-const { findModuleByName } = require("../module-utl");
+const IndexedModuleGraph = require("../../../graph-utl/indexed-module-graph");
 const { calculateInstability, metricsAreCalculable } = require("../module-utl");
 
 function addInstabilityMetric(pModule) {
@@ -16,11 +16,12 @@ function addInstabilityMetric(pModule) {
 }
 
 function addInstabilityToDependency(pAllModules) {
+  const lIndexedModules = new IndexedModuleGraph(pAllModules);
   return (pDependency) => ({
     ...pDependency,
     instability:
-      (findModuleByName(pAllModules, pDependency.resolved) || {}).instability ||
-      0,
+      (lIndexedModules.findModuleByName(pDependency.resolved) || {})
+        .instability || 0,
   });
 }
 

package/src/enrich/derive/metrics/index.js

@@ -1,4 +1,3 @@
-const { clearCache } = require("../module-utl");
 const {
   addInstabilityMetric,
   deNormalizeInstabilityMetricsToDependencies,
@@ -6,9 +5,9 @@ const {
 
 module.exports = function deriveModulesMetrics(pModules, pOptions) {
   if (pOptions.metrics) {
-    const lModules = pModules.map(addInstabilityMetric);
-    clearCache();
-    return lModules.map(deNormalizeInstabilityMetricsToDependencies);
+    return pModules
+      .map(addInstabilityMetric)
+      .map(deNormalizeInstabilityMetricsToDependencies);
   }
   return pModules;
 };

package/src/enrich/derive/module-utl.js

@@ -1,29 +1,3 @@
-/** @type {Map<string,import('../../../types/cruise-result').IModule>} */
-let gIndexedGraph = null;
-
-/**
- * Returns the module with attribute pSource, when it exists in the pModuleGraph.
- * Returns undefined when it doesn't.
- *
- * This function uses an indexed cache for efficiency reasons. If you need to
- * call this function consecutively for different module graphs, you can clear
- * this cache with the clearCache function from this module.
- *
- * TODO: use IndexedModuleGraph class from src/graph-utl in stead
- *
- * @param {import('../../../types/cruise-result').IModule[]} pModuleGraph
- * @param {string} pSource
- * @returns {import('../../../types/cruise-result').IModule | undefined}
- */
-function findModuleByName(pModuleGraph, pSource) {
-  if (!gIndexedGraph) {
-    gIndexedGraph = new Map(
-      pModuleGraph.map((pModule) => [pModule.source, pModule])
-    );
-  }
-  return gIndexedGraph.get(pSource);
-}
-
 function isDependent(pResolvedName) {
   return (pModule) =>
     pModule.dependencies.some(
@@ -41,7 +15,7 @@ function metricsAreCalculable(pModule) {
 
 /**
  * returns the Instability of a component given the number of incoming (afferent)
- * and outgoign (efferent) connections ('couplings')
+ * and outgoing (efferent) connections ('couplings')
  *
  * @param {number} pEfferentCouplingCount
  * @param {number} pAfferentCouplingCount
@@ -57,13 +31,7 @@ function calculateInstability(pEfferentCouplingCount, pAfferentCouplingCount) {
   );
 }
 
-function clearCache() {
-  gIndexedGraph = null;
-}
-
 module.exports = {
-  findModuleByName,
-  clearCache,
   isDependent,
   metricsAreCalculable,
   calculateInstability,

package/src/enrich/derive/{reachable/index.js → reachable.js}

@@ -1,10 +1,10 @@
 /* eslint-disable security/detect-object-injection, no-inline-comments */
 
-const clone = require("lodash/clone");
+const cloneDeep = require("lodash/cloneDeep");
 const has = require("lodash/has");
-const matchers = require("../../../validate/matchers");
-const { extractGroups } = require("../../../utl/regex-util");
-const getPath = require("./get-path");
+const matchers = require("../../validate/matchers");
+const { extractGroups } = require("../../utl/regex-util");
+const IndexedModuleGraph = require("../../graph-utl/indexed-module-graph");
 
 function getReachableRules(pRuleSet) {
   return (pRuleSet?.forbidden ?? [])
@@ -105,14 +105,14 @@ function shouldAddReachable(pRule, pModuleTo, pGraph) {
   return lReturnValue;
 }
 
-function addReachesToModule(pModule, pGraph, pReachableRule) {
+function addReachesToModule(pModule, pGraph, pIndexedGraph, pReachableRule) {
   const lToModules = pGraph.filter((pToModule) =>
     isModuleInRuleTo(pReachableRule, pToModule, pModule)
   );
 
   for (let lToModule of lToModules) {
     if (pModule.source !== lToModule.source) {
-      const lPath = getPath(pGraph, pModule.source, lToModule.source);
+      const lPath = pIndexedGraph.getPath(pModule.source, lToModule.source);
 
       if (lPath.length > 0) {
         pModule.reaches = mergeReachesProperties(
@@ -127,7 +127,7 @@ function addReachesToModule(pModule, pGraph, pReachableRule) {
   return pModule;
 }
 
-function addReachableToModule(pModule, pGraph, pReachableRule) {
+function addReachableToModule(pModule, pGraph, pIndexedGraph, pReachableRule) {
   const lFromModules = pGraph.filter(isModuleInRuleFrom(pReachableRule));
   let lFound = false;
 
@@ -137,7 +137,7 @@ function addReachableToModule(pModule, pGraph, pReachableRule) {
       pModule.source !== lFromModule.source &&
       isModuleInRuleTo(pReachableRule, pModule, lFromModule)
     ) {
-      const lPath = getPath(pGraph, lFromModule.source, pModule.source);
+      const lPath = pIndexedGraph.getPath(lFromModule.source, pModule.source);
 
       lFound = lPath.length > 0;
       pModule.reachable = mergeReachableProperties(
@@ -151,17 +151,23 @@ function addReachableToModule(pModule, pGraph, pReachableRule) {
   return pModule;
 }
 
-function addReachabilityToGraph(pGraph, pReachableRule) {
+function addReachabilityToGraph(pGraph, pIndexedGraph, pReachableRule) {
   return pGraph.map((pModule) => {
-    let lClonedModule = clone(pModule);
+    let lClonedModule = cloneDeep(pModule);
 
     if (shouldAddReaches(pReachableRule, lClonedModule)) {
-      lClonedModule = addReachesToModule(lClonedModule, pGraph, pReachableRule);
+      lClonedModule = addReachesToModule(
+        lClonedModule,
+        pGraph,
+        pIndexedGraph,
+        pReachableRule
+      );
     }
     if (shouldAddReachable(pReachableRule, lClonedModule, pGraph)) {
       lClonedModule = addReachableToModule(
         lClonedModule,
         pGraph,
+        pIndexedGraph,
         pReachableRule
       );
     }
@@ -171,9 +177,12 @@ function addReachabilityToGraph(pGraph, pReachableRule) {
 
 module.exports = function deriveReachables(pGraph, pRuleSet) {
   const lReachableRules = pRuleSet ? getReachableRules(pRuleSet) : [];
+  const lIndexedGraph =
+    lReachableRules.length > 0 ? new IndexedModuleGraph(pGraph) : {};
 
   return lReachableRules.reduce(
-    (pReturnGraph, pRule) => addReachabilityToGraph(pReturnGraph, pRule),
-    clone(pGraph)
+    (pReturnGraph, pRule) =>
+      addReachabilityToGraph(pReturnGraph, lIndexedGraph, pRule),
+    cloneDeep(pGraph)
   );
 };

package/src/enrich/enrich-modules.js

@@ -1,6 +1,7 @@
 const bus = require("../utl/bus");
 const busLogLevels = require("../utl/bus-log-levels");
 const addFocus = require("../../src/graph-utl/add-focus");
+const IndexedModuleGraph = require("../graph-utl/indexed-module-graph");
 const deriveCycles = require("./derive/circular");
 const deriveOrphans = require("./derive/orphan");
 const addDependents = require("./derive/dependents");
@@ -8,14 +9,13 @@ const deriveReachable = require("./derive/reachable");
 const addValidations = require("./add-validations");
 const softenKnownViolations = require("./soften-known-violations");
 const deriveModuleMetrics = require("./derive/metrics");
-const { findModuleByName } = require("./derive/module-utl");
 
 module.exports = function enrichModules(pModules, pOptions) {
   bus.emit("progress", "analyzing: cycles", { level: busLogLevels.INFO });
-  let lModules = deriveCycles(pModules, {
+  const lIndexedModules = new IndexedModuleGraph(pModules);
+  let lModules = deriveCycles(pModules, lIndexedModules, {
     pSourceAttribute: "source",
     pDependencyName: "resolved",
-    pFindNodeByName: findModuleByName,
   });
   bus.emit("progress", "analyzing: dependents", { level: busLogLevels.INFO });
   lModules = addDependents(lModules, pOptions);

package/src/enrich/index.js

@@ -1,7 +1,6 @@
 const enrichModules = require("./enrich-modules");
 const aggregateToFolders = require("./derive/folders");
 const summarize = require("./summarize");
-const clearCaches = require("./clear-caches");
 
 /**
  * Enriches the passed modules with things like cycle detection, validations,
@@ -17,11 +16,9 @@ const clearCaches = require("./clear-caches");
  * @returns {import("../..").ICruiseResult}
  */
 module.exports = function enrich(pModules, pOptions, pFileAndDirectoryArray) {
-  clearCaches();
   const lModules = enrichModules(pModules, pOptions);
   const lFolders = aggregateToFolders(lModules, pOptions);
 
-  clearCaches();
   const lReturnValue = {
     modules: lModules,
     ...lFolders,

package/src/extract/gather-initial-sources.js

@@ -53,19 +53,19 @@ function gatherScannableFilesFromDirectory(pDirectoryName, pOptions) {
       shouldNotBeExcluded(pathToPosix(pFullPathToFile), pOptions)
     )
     .reduce((pSum, pFullPathToFile) => {
-      let lStat = {};
-      try {
-        lStat = fs.statSync(path.join(pOptions.baseDir, pFullPathToFile));
-      } catch (pError) {
-        return pSum;
-      }
-      if (lStat.isDirectory()) {
-        return pSum.concat(
-          gatherScannableFilesFromDirectory(pFullPathToFile, pOptions)
-        );
-      }
-      if (fileIsScannable(pOptions, pFullPathToFile)) {
-        return pSum.concat(pFullPathToFile);
+      let lStat = fs.statSync(path.join(pOptions.baseDir, pFullPathToFile), {
+        throwIfNoEntry: false,
+      });
+
+      if (lStat) {
+        if (lStat.isDirectory()) {
+          return pSum.concat(
+            gatherScannableFilesFromDirectory(pFullPathToFile, pOptions)
+          );
+        }
+        if (fileIsScannable(pOptions, pFullPathToFile)) {
+          return pSum.concat(pFullPathToFile);
+        }
       }
       return pSum;
     }, [])

package/src/graph-utl/indexed-module-graph.js

@@ -1,18 +1,18 @@
+/* eslint-disable security/detect-object-injection */
 module.exports = class IndexedModuleGraph {
-  init(pModules) {
+  init(pModules, pIndexAttribute) {
     this.indexedGraph = new Map(
-      pModules.map((pModule) => [pModule.source, pModule])
+      pModules.map((pModule) => [pModule[pIndexAttribute], pModule])
     );
   }
 
-  constructor(pModules) {
-    this.init(pModules);
+  constructor(pModules, pIndexAttribute = "source") {
+    this.init(pModules, pIndexAttribute);
   }
 
   /**
-   *
    * @param {string} pName
-   * @return {import("../types/cruise-result").IModule}
+   * @return {import("..").IModule}
    */
   findModuleByName(pName) {
     return this.indexedGraph.get(pName);
@@ -102,4 +102,78 @@ module.exports = class IndexedModuleGraph {
     }
     return lReturnValue;
   }
+
+  /**
+   * @param {string} pFrom
+   * @param {string} pTo
+   * @param {Set<string>} pVisited
+   * @returns {string[]}
+   */
+  getPath(pFrom, pTo, pVisited = new Set()) {
+    let lReturnValue = [];
+    const lFromNode = this.findModuleByName(pFrom);
+
+    pVisited.add(pFrom);
+
+    if (lFromNode) {
+      const lDirectUnvisitedDependencies = lFromNode.dependencies
+        .filter((pDependency) => !pVisited.has(pDependency.resolved))
+        .map((pDependency) => pDependency.resolved);
+      if (lDirectUnvisitedDependencies.includes(pTo)) {
+        lReturnValue = [pFrom, pTo];
+      } else {
+        for (const lFrom of lDirectUnvisitedDependencies) {
+          let lCandidatePath = this.getPath(lFrom, pTo, pVisited);
+          // eslint-disable-next-line max-depth
+          if (lCandidatePath.length > 0) {
+            lReturnValue = [pFrom].concat(lCandidatePath);
+            break;
+          }
+        }
+      }
+    }
+    return lReturnValue;
+  }
+
+  /**
+   * Returns the first non-zero length path from pInitialSource to pInitialSource
+   * Returns the empty array if there is no such path
+   *
+   * @param {string} pInitialSource The 'source' attribute of the node to be tested
+   *                                (source uniquely identifying a node)
+   * @param {string} pCurrentSource The 'source' attribute of the 'to' node to
+   *                                be traversed
+   * @param {string} pDependencyName The attribute name of the dependency to use.
+   *                                defaults to "resolved" (which is in use for
+   *                                modules). For folders pass "name"
+   * @return {string[]}             see description above
+   */
+  getCycle(pInitialSource, pCurrentSource, pDependencyName, pVisited) {
+    let lVisited = pVisited || new Set();
+    const lCurrentNode = this.findModuleByName(pCurrentSource);
+    const lDependencies = lCurrentNode.dependencies.filter(
+      (pDependency) => !lVisited.has(pDependency[pDependencyName])
+    );
+    const lMatch = lDependencies.find(
+      (pDependency) => pDependency[pDependencyName] === pInitialSource
+    );
+    if (lMatch) {
+      return [pCurrentSource, lMatch[pDependencyName]];
+    }
+    return lDependencies.reduce((pAll, pDependency) => {
+      if (!pAll.includes(pCurrentSource)) {
+        const lCycle = this.getCycle(
+          pInitialSource,
+          pDependency[pDependencyName],
+          pDependencyName,
+          lVisited.add(pDependency[pDependencyName])
+        );
+
+        if (lCycle.length > 0 && !lCycle.includes(pCurrentSource)) {
+          return pAll.concat(pCurrentSource).concat(lCycle);
+        }
+      }
+      return pAll;
+    }, []);
+  }
 };

package/src/meta.js

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

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

@@ -13,12 +13,10 @@ const pathToPosix = require("./path-to-posix");
  * @returns {boolean}
  */
 function fileIsDirectory(pFullPathToFile, pBaseDirectory) {
-  try {
-    const lStat = statSync(join(pBaseDirectory, pFullPathToFile));
-    return lStat.isDirectory();
-  } catch (pError) {
-    return false;
-  }
+  const lStat = statSync(join(pBaseDirectory, pFullPathToFile), {
+    throwIfNoEntry: false,
+  });
+  return lStat?.isDirectory() ?? false;
 }
 
 /**

package/src/enrich/clear-caches.js

@@ -1,5 +0,0 @@
-const utl = require("./derive/module-utl");
-
-module.exports = function clearCaches() {
-  utl.clearCache();
-};

package/src/enrich/derive/circular/get-cycle.js

@@ -1,70 +0,0 @@
-/* eslint-disable security/detect-object-injection */
-/* about the absence of checks whether attributes/ objects actually
- * exist:
- * - it saves CPU cycles to the effect of being ~30% faster than with the
- *   checks
- * - .dependencies is a mandatory attribute (as per json schema)
- * - .resolved is a mandatory attribute (as per json schema)
- */
-
-/**
- * Returns the first non-zero length path from pInitialSource to pInitialSource
- * Returns the empty array if there is no such path
- *
- * @param {any} pGraph            The graph in which to test this condition
- * @param {string} pInitialSource The 'source' attribute of the node to be tested
- *                                (source uniquely identifying a node)
- * @param {string} pCurrentSource The 'source' attribute of the 'to' node to
- *                                be traversed
- * @param {string} pDependencyName The attribute name of the dependency to use.
- *                                defaults to "resolved" (which is in use for
- *                                modules). For folders pass "name"
- * @param {function} pFindNodeByName Function taking a Graph and a pCurrentSource string
- *                                that returns the Node in that graph going by
- *                                that name. Defaults to findModuleByName (which
- *                                is in use for modules). For folders pass
- *                                findFolderByName
- * @param {Set} pVisited          The set of nodes visited hithereto (optional
- *                                attribute - there's no need to pass it when
- *                                calling it; it's used by the algorithm to
- *                                determine the stop condition)
- * @return {string[]}             see description above
- */
-// eslint-disable-next-line max-params
-function getCycle(
-  pGraph,
-  pInitialSource,
-  pCurrentSource,
-  { pDependencyName, pFindNodeByName },
-  pVisited
-) {
-  let lVisited = pVisited || new Set();
-  const lCurrentNode = pFindNodeByName(pGraph, pCurrentSource);
-  const lDependencies = lCurrentNode.dependencies.filter(
-    (pDependency) => !lVisited.has(pDependency[pDependencyName])
-  );
-  const lMatch = lDependencies.find(
-    (pDependency) => pDependency[pDependencyName] === pInitialSource
-  );
-  if (lMatch) {
-    return [pCurrentSource, lMatch[pDependencyName]];
-  }
-  return lDependencies.reduce((pAll, pDependency) => {
-    if (!pAll.includes(pCurrentSource)) {
-      const lCycle = getCycle(
-        pGraph,
-        pInitialSource,
-        pDependency[pDependencyName],
-        { pDependencyName, pFindNodeByName },
-        lVisited.add(pDependency[pDependencyName])
-      );
-
-      if (lCycle.length > 0 && !lCycle.includes(pCurrentSource)) {
-        return pAll.concat(pCurrentSource).concat(lCycle);
-      }
-    }
-    return pAll;
-  }, []);
-}
-
-module.exports = getCycle;

package/src/enrich/derive/reachable/get-path.js

@@ -1,29 +0,0 @@
-const { findModuleByName } = require("../module-utl");
-
-function getPath(pGraph, pFrom, pTo, pVisited = new Set()) {
-  let lReturnValue = [];
-  const lFromNode = findModuleByName(pGraph, pFrom);
-
-  pVisited.add(pFrom);
-
-  if (lFromNode) {
-    const lDirectUnvisitedDependencies = lFromNode.dependencies
-      .filter((pDependency) => !pVisited.has(pDependency.resolved))
-      .map((pDependency) => pDependency.resolved);
-    if (lDirectUnvisitedDependencies.includes(pTo)) {
-      lReturnValue = [pFrom, pTo];
-    } else {
-      for (const lFrom of lDirectUnvisitedDependencies) {
-        let lCandidatePath = getPath(pGraph, lFrom, pTo, pVisited);
-        // eslint-disable-next-line max-depth
-        if (lCandidatePath.length > 0) {
-          lReturnValue = [pFrom].concat(lCandidatePath);
-          break;
-        }
-      }
-    }
-  }
-  return lReturnValue;
-}
-
-module.exports = getPath;