dependency-cruiser 17.2.0 → 17.3.2

package/src/extract/acorn/extract-cjs-deps.mjs

@@ -1,12 +1,16 @@
 import { simple as walk_simple, base as walk_base } from "acorn-walk";
-import estreeHelpers from "./estree-helpers.mjs";
+import {
+  firstArgumentIsAString,
+  firstArgumentIsATemplateLiteral,
+  isRequireOfSomeSort,
+} from "./estree-helpers.mjs";
 
 function pryStringsFromArguments(pArguments) {
   let lReturnValue = null;
 
-  if (estreeHelpers.firstArgumentIsAString(pArguments)) {
+  if (firstArgumentIsAString(pArguments)) {
     lReturnValue = pArguments[0].value;
-  } else if (estreeHelpers.firstArgumentIsATemplateLiteral(pArguments)) {
+  } else if (firstArgumentIsATemplateLiteral(pArguments)) {
     lReturnValue = pArguments[0].quasis[0].value.cooked;
   }
 
@@ -20,6 +24,28 @@ function getExoticRequireTypes(pModuleSystem) {
   return pModuleSystem === "amd" ? ["amd-exotic-require"] : ["exotic-require"];
 }
 
+function getDependencyTypeAttributes(pName, pModuleSystem) {
+  switch (pName) {
+    case "require":
+      return {
+        exoticallyRequired: false,
+        dependencyTypes: getRequireTypes(pModuleSystem),
+      };
+    case "process.getBuiltinModule":
+    case "globalThis.process.getBuiltinModule":
+      return {
+        exoticallyRequired: false,
+        dependencyTypes: ["process-get-builtin-module"],
+      };
+    default:
+      return {
+        exoticallyRequired: true,
+        exoticRequire: pName,
+        dependencyTypes: getExoticRequireTypes(pModuleSystem),
+      };
+  }
+}
+
 function pushRequireCallsToDependencies(
   pDependencies,
   pModuleSystem,
@@ -27,23 +53,14 @@ function pushRequireCallsToDependencies(
 ) {
   return (pNode) => {
     for (let lName of pRequireStrings) {
-      if (estreeHelpers.isRequireOfSomeSort(pNode, lName)) {
+      if (isRequireOfSomeSort(pNode, lName)) {
         const lModuleName = pryStringsFromArguments(pNode.arguments);
         if (lModuleName) {
           pDependencies.push({
             module: lModuleName,
             moduleSystem: pModuleSystem,
             dynamic: false,
-            ...(lName === "require"
-              ? {
-                  exoticallyRequired: false,
-                  dependencyTypes: getRequireTypes(pModuleSystem),
-                }
-              : {
-                  exoticallyRequired: true,
-                  exoticRequire: lName,
-                  dependencyTypes: getExoticRequireTypes(pModuleSystem),
-                }),
+            ...getDependencyTypeAttributes(lName, pModuleSystem),
           });
         }
       }
@@ -51,20 +68,31 @@ function pushRequireCallsToDependencies(
   };
 }
 
+// eslint-disable-next-line max-params
 export default function extractCommonJSDependencies(
   pAST,
   pDependencies,
   pModuleSystem,
   pExoticRequireStrings,
+  pDetectProcessBuiltinModuleCalls,
 ) {
   // var/const lalala = require('./lalala');
   // require('./lalala');
   // require('./lalala').doFunkyStuff();
   // require('zoinks!./wappie')
   // require(`./withatemplateliteral`)
+  // when feature switched as such it will also detect
+  //   process.getBuiltinModule('fs')
+  //   globalThis.process.getBuiltinModule('path')
   // as well as renamed requires/ require wrappers
   // as passed in pExoticRequireStrings ("need", "window.require")
-  const lRequireStrings = ["require"].concat(pExoticRequireStrings);
+  const lRequireStrings = ["require"]
+    .concat(
+      pDetectProcessBuiltinModuleCalls
+        ? ["process.getBuiltinModule", "globalThis.process.getBuiltinModule"]
+        : [],
+    )
+    .concat(pExoticRequireStrings);
 
   walk_simple(
     pAST,

package/src/extract/acorn/extract-es6-deps.mjs

@@ -1,12 +1,15 @@
 import { simple as walk_simple, base as walk_base } from "acorn-walk";
 import { extend } from "acorn-jsx-walk";
-import estreeHelpers from "./estree-helpers.mjs";
+import {
+  isStringLiteral,
+  isPlaceholderLessTemplateLiteral,
+} from "./estree-helpers.mjs";
 
 extend(walk_base);
 
 function pushImportNodeValue(pDependencies) {
   return (pNode) => {
-    if (estreeHelpers.isStringLiteral(pNode.source)) {
+    if (isStringLiteral(pNode.source)) {
       pDependencies.push({
         module: pNode.source.value,
         moduleSystem: "es6",
@@ -14,7 +17,7 @@ function pushImportNodeValue(pDependencies) {
         exoticallyRequired: false,
         dependencyTypes: ["dynamic-import"],
       });
-    } else if (estreeHelpers.isPlaceholderlessTemplateLiteral(pNode.source)) {
+    } else if (isPlaceholderLessTemplateLiteral(pNode.source)) {
       pDependencies.push({
         module: pNode.source.quasis[0].value.cooked,
         moduleSystem: "es6",

package/src/extract/acorn/extract.mjs

@@ -6,7 +6,12 @@ import { getASTCached } from "./parse.mjs";
 import extractStats from "./extract-stats.mjs";
 
 export function extract(
-  { baseDir, moduleSystems, exoticRequireStrings },
+  {
+    baseDir,
+    moduleSystems,
+    exoticRequireStrings,
+    detectProcessBuiltinModuleCalls,
+  },
   pFileName,
   pTranspileOptions,
 ) {
@@ -14,7 +19,13 @@ export function extract(
   const lAST = getASTCached(join(baseDir, pFileName), pTranspileOptions);
 
   if (moduleSystems.includes("cjs")) {
-    extractCommonJSDeps(lAST, lDependencies, "cjs", exoticRequireStrings);
+    extractCommonJSDeps(
+      lAST,
+      lDependencies,
+      "cjs",
+      exoticRequireStrings,
+      detectProcessBuiltinModuleCalls,
+    );
   }
   if (moduleSystems.includes("es6")) {
     extractES6Deps(lAST, lDependencies);

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

@@ -31,12 +31,12 @@ function shouldBeIncluded(pFullPathToFile, pOptions) {
   );
 }
 
-function shouldNotBeExcluded(pFullPathToFile, pOptions) {
+function shouldBeExcluded(pFullPathToFile, pOptions) {
   return (
-    (!pOptions?.exclude?.path ||
-      !filenameMatchesPattern(pFullPathToFile, pOptions.exclude.path)) &&
-    (!pOptions?.doNotFollow?.path ||
-      !filenameMatchesPattern(pFullPathToFile, pOptions.doNotFollow.path))
+    (pOptions?.exclude?.path &&
+      filenameMatchesPattern(pFullPathToFile, pOptions.exclude.path)) ||
+    (pOptions?.doNotFollow?.path &&
+      filenameMatchesPattern(pFullPathToFile, pOptions.doNotFollow.path))
   );
 }
 
@@ -48,11 +48,12 @@ function shouldNotBeExcluded(pFullPathToFile, pOptions) {
 function gatherScannableFilesFromDirectory(pDirectoryName, pOptions) {
   return readdirSync(join(pOptions.baseDir, pDirectoryName))
     .map((pFileName) => join(pDirectoryName, pFileName))
-    .filter((pFullPathToFile) =>
-      shouldNotBeExcluded(pathToPosix(pFullPathToFile), pOptions),
-    )
     .flatMap((pFullPathToFile) => {
-      let lStat = statSync(join(pOptions.baseDir, pFullPathToFile), {
+      const lPosixPath = pathToPosix(pFullPathToFile);
+      if (shouldBeExcluded(lPosixPath, pOptions)) {
+        return [];
+      }
+      const lStat = statSync(join(pOptions.baseDir, pFullPathToFile), {
         throwIfNoEntry: false,
       });
 
@@ -60,14 +61,15 @@ function gatherScannableFilesFromDirectory(pDirectoryName, pOptions) {
         if (lStat.isDirectory()) {
           return gatherScannableFilesFromDirectory(pFullPathToFile, pOptions);
         }
-        if (fileIsScannable(pOptions, pFullPathToFile)) {
-          return pFullPathToFile;
+        if (
+          fileIsScannable(pOptions, pFullPathToFile) &&
+          shouldBeIncluded(lPosixPath, pOptions)
+        ) {
+          return lPosixPath;
         }
       }
       return [];
-    })
-    .map((pFullPathToFile) => pathToPosix(pFullPathToFile))
-    .filter((pFullPathToFile) => shouldBeIncluded(pFullPathToFile, pOptions));
+    });
 }
 
 function expandGlob(pBaseDirectory, pScannedGlob) {

package/src/extract/index.mjs

@@ -28,43 +28,38 @@ function extractRecursive(
           pTranspileOptions,
         )
       : [];
-
-  return lDependencies
-    .filter(
-      ({ followable, matchesDoNotFollow }) => followable && !matchesDoNotFollow,
-    )
-    .reduce(
-      (pAll, { resolved }) => {
-        if (!pVisited.has(resolved)) {
-          return pAll.concat(
-            extractRecursive(
-              resolved,
+  const lReturnValue = [
+    {
+      source: pFileName,
+      ...(pCruiseOptions.experimentalStats
+        ? {
+            experimentalStats: extractStats(
+              pFileName,
               pCruiseOptions,
-              pVisited,
-              pDepth + 1,
-              pResolveOptions,
               pTranspileOptions,
             ),
-          );
-        }
-        return pAll;
-      },
-      [
-        {
-          source: pFileName,
-          ...(pCruiseOptions.experimentalStats
-            ? {
-                experimentalStats: extractStats(
-                  pFileName,
-                  pCruiseOptions,
-                  pTranspileOptions,
-                ),
-              }
-            : {}),
-          dependencies: lDependencies,
-        },
-      ],
-    );
+          }
+        : {}),
+      dependencies: lDependencies,
+    },
+  ];
+
+  // eslint-disable-next-line budapestian/local-variable-pattern
+  for (const { resolved, followable, matchesDoNotFollow } of lDependencies) {
+    if (followable && !matchesDoNotFollow && !pVisited.has(resolved)) {
+      lReturnValue.push(
+        ...extractRecursive(
+          resolved,
+          pCruiseOptions,
+          pVisited,
+          pDepth + 1,
+          pResolveOptions,
+          pTranspileOptions,
+        ),
+      );
+    }
+  }
+  return lReturnValue;
 }
 
 function extractFileDirectoryArray(
@@ -82,12 +77,13 @@ function extractFileDirectoryArray(
   );
 
   bus.info("read files: visit dependencies");
-  return lInitialSources.reduce((pDependencies, pFilename) => {
-    if (!lVisited.has(pFilename)) {
-      lVisited.add(pFilename);
-      return pDependencies.concat(
-        extractRecursive(
-          pFilename,
+  const lResult = [];
+  for (const lFilename of lInitialSources) {
+    if (!lVisited.has(lFilename)) {
+      lVisited.add(lFilename);
+      lResult.push(
+        ...extractRecursive(
+          lFilename,
           pCruiseOptions,
           lVisited,
           0,
@@ -96,8 +92,8 @@ function extractFileDirectoryArray(
         ),
       );
     }
-    return pDependencies;
-  }, []);
+  }
+  return lResult;
 }
 
 function isNotFollowable({ followable }) {

package/src/extract/resolve/module-classifiers.mjs

@@ -74,9 +74,9 @@ function determineFollowableExtensions(pResolveOptions) {
     ".less",
   ];
 
-  lKnownUnfollowables.forEach((pUnfollowable) => {
-    lReturnValue.delete(pUnfollowable);
-  });
+  for (const lUnfollowable of lKnownUnfollowables) {
+    lReturnValue.delete(lUnfollowable);
+  }
   return lReturnValue;
 }
 

package/src/extract/tsc/extract-typescript-deps.mjs

@@ -229,6 +229,37 @@ function isCompositeExoticRequire(pASTNode, pObjectName, pPropertyName) {
   );
 }
 
+function isTripleCursedCompositeExoticRequire(
+  pASTNode,
+  pObjectName1,
+  pObjectName2,
+  pPropertyName,
+) {
+  return (
+    typescript.SyntaxKind[pASTNode.kind] === "CallExpression" &&
+    pASTNode.expression &&
+    typescript.SyntaxKind[pASTNode.expression.kind] ===
+      "PropertyAccessExpression" &&
+    pASTNode.expression.expression &&
+    typescript.SyntaxKind[pASTNode.expression.expression.kind] ===
+      "PropertyAccessExpression" &&
+    // globalThis
+    pASTNode.expression.expression.expression &&
+    typescript.SyntaxKind[pASTNode.expression.expression.expression.kind] ===
+      "Identifier" &&
+    pASTNode.expression.expression.expression.escapedText === pObjectName1 &&
+    // process
+    typescript.SyntaxKind[pASTNode.expression.expression.name.kind] ===
+      "Identifier" &&
+    pASTNode.expression.expression.name.escapedText === pObjectName2 &&
+    // getBuiltinModule
+    pASTNode.expression.name &&
+    typescript.SyntaxKind[pASTNode.expression.name.kind] === "Identifier" &&
+    pASTNode.expression.name.escapedText === pPropertyName &&
+    firstArgumentIsAString(pASTNode)
+  );
+}
+
 function isExoticRequire(pASTNode, pString) {
   const lRequireStringElements = pString.split(".");
 
@@ -307,7 +338,9 @@ export function walkJSDoc(pObject, pCollection = new Set()) {
   if (isJSDocImport(pObject)) {
     pCollection.add(pObject.argument.literal.text);
   } else if (Array.isArray(pObject)) {
-    pObject.forEach((pValue) => walkJSDoc(pValue, pCollection));
+    for (const lValue of pObject) {
+      walkJSDoc(lValue, pCollection);
+    }
   } else if (typeof pObject === "object") {
     for (const lKey in pObject) {
       if (!keyInJSDocIsIgnorable(lKey) && pObject[lKey]) {
@@ -363,7 +396,12 @@ function extractJSDocImports(pJSDocNodes) {
  * @returns {(pASTNode: Node) => void} - the walker function
  */
 // eslint-disable-next-line max-lines-per-function
-function walk(pResult, pExoticRequireStrings, pDetectJSDocImports) {
+function walk(
+  pResult,
+  pExoticRequireStrings,
+  pDetectJSDocImports,
+  pDetectProcessBuiltinModuleCalls,
+) {
   // eslint-disable-next-line max-lines-per-function
   return (pASTNode) => {
     // require('a-string'), require(`a-template-literal`)
@@ -377,17 +415,36 @@ function walk(pResult, pExoticRequireStrings, pDetectJSDocImports) {
     }
 
     // const want = require; {lalala} = want('yudelyo'), window.require('elektron')
-    pExoticRequireStrings.forEach((pExoticRequireString) => {
-      if (isExoticRequire(pASTNode, pExoticRequireString)) {
+    for (const lExoticRequireString of pExoticRequireStrings) {
+      if (isExoticRequire(pASTNode, lExoticRequireString)) {
         pResult.push({
           module: pASTNode.arguments[0].text,
           moduleSystem: "cjs",
           exoticallyRequired: true,
-          exoticRequire: pExoticRequireString,
+          exoticRequire: lExoticRequireString,
           dependencyTypes: ["exotic-require"],
         });
       }
-    });
+    }
+
+    // const path = process.getBuiltinModule('node:path'); const fs = globalThis.process.getBuiltinModule(`node:fs`);
+    if (
+      pDetectProcessBuiltinModuleCalls &&
+      (isCompositeExoticRequire(pASTNode, "process", "getBuiltinModule") ||
+        isTripleCursedCompositeExoticRequire(
+          pASTNode,
+          "globalThis",
+          "process",
+          "getBuiltinModule",
+        ))
+    ) {
+      pResult.push({
+        module: pASTNode.arguments[0].text,
+        moduleSystem: "cjs",
+        exoticallyRequired: false,
+        dependencyTypes: ["process-get-builtin-module"],
+      });
+    }
 
     // import('a-string'), import(`a-template-literal`)
     if (isDynamicImportExpression(pASTNode)) {
@@ -418,13 +475,18 @@ function walk(pResult, pExoticRequireStrings, pDetectJSDocImports) {
 
       // pResult = pResult.concat(lJSDocImports) looks like the more obvious
       // way to do this, but it re-assigns the pResult parameter
-      lJSDocImports.forEach((pImport) => {
-        pResult.push(pImport);
-      });
+      for (const lImport of lJSDocImports) {
+        pResult.push(lImport);
+      }
     }
     typescript.forEachChild(
       pASTNode,
-      walk(pResult, pExoticRequireStrings, pDetectJSDocImports),
+      walk(
+        pResult,
+        pExoticRequireStrings,
+        pDetectJSDocImports,
+        pDetectProcessBuiltinModuleCalls,
+      ),
     );
   };
 }
@@ -442,10 +504,16 @@ function extractNestedDependencies(
   pAST,
   pExoticRequireStrings,
   pDetectJSDocImports,
+  pDetectProcessBuiltinModuleCalls,
 ) {
   let lResult = [];
 
-  walk(lResult, pExoticRequireStrings, pDetectJSDocImports)(pAST);
+  walk(
+    lResult,
+    pExoticRequireStrings,
+    pDetectJSDocImports,
+    pDetectProcessBuiltinModuleCalls,
+  )(pAST);
 
   return lResult;
 }
@@ -459,6 +527,7 @@ export default function extractTypeScriptDependencies(
   pTypeScriptAST,
   pExoticRequireStrings,
   pDetectJSDocImports,
+  pDetectProcessBuiltinModuleCalls,
 ) {
   // console.dir(pTypeScriptAST, { depth: 100 });
   return typescript
@@ -471,6 +540,7 @@ export default function extractTypeScriptDependencies(
             pTypeScriptAST,
             pExoticRequireStrings,
             pDetectJSDocImports,
+            pDetectProcessBuiltinModuleCalls,
           ),
         )
         .map((pModule) => ({ dynamic: false, ...pModule }))

package/src/extract/tsc/extract.mjs

@@ -13,7 +13,13 @@ export function shouldUse({ tsPreCompilationDeps, parser }, pFileName) {
 }
 
 export function extract(
-  { baseDir, exoticRequireStrings, moduleSystems, detectJSDocImports },
+  {
+    baseDir,
+    exoticRequireStrings,
+    moduleSystems,
+    detectJSDocImports,
+    detectProcessBuiltinModuleCalls,
+  },
   pFileName,
   pTranspileOptions,
 ) {
@@ -21,6 +27,7 @@ export function extract(
     getASTCached(join(baseDir, pFileName), pTranspileOptions),
     exoticRequireStrings,
     detectJSDocImports,
+    detectProcessBuiltinModuleCalls,
   ).filter(({ moduleSystem }) => moduleSystems.includes(moduleSystem));
 }
 

package/src/graph-utl/consolidate-module-dependencies.mjs

@@ -20,17 +20,17 @@ function mergeDependency(pLeftDependency, pRightDependency) {
 }
 
 function mergeDependencies(pResolvedName, pDependencies) {
-  return pDependencies
-    .filter((pDependency) => pDependency.resolved === pResolvedName)
-    .reduce(
-      (pAllDependencies, pCurrentDependency) =>
-        mergeDependency(pAllDependencies, pCurrentDependency),
-      {
-        dependencyTypes: [],
-        rules: [],
-        valid: true,
-      },
-    );
+  let lReturnValue = {
+    dependencyTypes: [],
+    rules: [],
+    valid: true,
+  };
+  for (const lDependency of pDependencies) {
+    if (lDependency.resolved === pResolvedName) {
+      lReturnValue = mergeDependency(lReturnValue, lDependency);
+    }
+  }
+  return lReturnValue;
 }
 
 /**
@@ -38,17 +38,14 @@ function mergeDependencies(pResolvedName, pDependencies) {
  * @returns {IDependency[]}
  */
 function consolidateDependencies(pDependencies) {
-  let lDependencies = structuredClone(pDependencies);
-  let lReturnValue = [];
+  const lProcessed = new Set();
+  const lReturnValue = [];
 
-  while (lDependencies.length > 0) {
-    lReturnValue.push(
-      mergeDependencies(lDependencies[0].resolved, lDependencies),
-    );
-    lDependencies = lDependencies.filter(
-      // eslint-disable-next-line no-loop-func
-      (pDependency) => pDependency.resolved !== lDependencies[0].resolved,
-    );
+  for (const lDependency of pDependencies) {
+    if (!lProcessed.has(lDependency.resolved)) {
+      lReturnValue.push(mergeDependencies(lDependency.resolved, pDependencies));
+      lProcessed.add(lDependency.resolved);
+    }
   }
 
   return lReturnValue;

package/src/graph-utl/consolidate-modules.mjs

@@ -18,29 +18,29 @@ function mergeModule(pLeftModule, pRightModule) {
 }
 
 function mergeModules(pSourceString, pModules) {
-  return pModules
-    .filter((pModule) => pModule.source === pSourceString)
-    .reduce(
-      (pMergedModule, pCurrentModule) =>
-        mergeModule(pMergedModule, pCurrentModule),
-      {
-        dependencies: [],
-        rules: [],
-        valid: true,
-      },
-    );
+  let lReturnValue = {
+    dependencies: [],
+    rules: [],
+    valid: true,
+  };
+
+  for (const lModule of pModules) {
+    if (lModule.source === pSourceString) {
+      lReturnValue = mergeModule(lReturnValue, lModule);
+    }
+  }
+  return lReturnValue;
 }
 
 export default function consolidateModules(pModules) {
-  let lModules = structuredClone(pModules);
-  let lReturnValue = [];
+  const lProcessed = new Set();
+  const lReturnValue = [];
 
-  while (lModules.length > 0) {
-    lReturnValue.push(mergeModules(lModules[0].source, lModules));
-    lModules = lModules.filter(
-      // eslint-disable-next-line no-loop-func
-      (pModule) => pModule.source !== lModules[0].source,
-    );
+  for (const lModule of pModules) {
+    if (!lProcessed.has(lModule.source)) {
+      lReturnValue.push(mergeModules(lModule.source, pModules));
+      lProcessed.add(lModule.source);
+    }
   }
   return lReturnValue;
 }

package/src/graph-utl/filter-bank.mjs

@@ -47,22 +47,25 @@ function filterReaches(pModules, pReachesFilter) {
     .filter((pModule) => moduleMatchesFilter(pModule, pReachesFilter))
     .map(({ source }) => source);
 
-  /** @type {Array<string>} */
-  let lReachingModules = [];
-  let lIndexedModules = new IndexedModuleGraph(pModules);
+  /** @type {Set<string>} */
+  const lReachingModules = new Set();
+  const lIndexedModules = new IndexedModuleGraph(pModules);
 
   for (let lModuleToReach of lModuleNamesToReach) {
-    lReachingModules = lReachingModules.concat(
-      lIndexedModules.findTransitiveDependents(lModuleToReach),
-    );
+    for (let lDependent of lIndexedModules.findTransitiveDependents(
+      lModuleToReach,
+    )) {
+      lReachingModules.add(lDependent);
+    }
   }
+
   return pModules
-    .filter(({ source }) => lReachingModules.includes(source))
+    .filter(({ source }) => lReachingModules.has(source))
     .map((pModule) => ({
       ...pModule,
       matchesReaches: lModuleNamesToReach.includes(pModule.source),
       dependencies: pModule.dependencies.filter(({ resolved }) =>
-        lReachingModules.includes(resolved),
+        lReachingModules.has(resolved),
       ),
     }));
 }