dependency-cruiser 17.3.1 → 17.3.3-beta-1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-cruiser",
-  "version": "17.3.1",
+  "version": "17.3.3-beta-1",
   "description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
   "keywords": [
     "static analysis",
@@ -163,14 +163,6 @@
     "tsconfig-paths-webpack-plugin": "4.2.0",
     "watskeburt": "5.0.0"
   },
-  "overrides": {
-    "cross-spawn": ">=6.0.6",
-    "nanoid": "^3.3.8"
-  },
-  "resolutions": {
-    "cross-spawn": ">=6.0.6",
-    "nanoid": "^3.3.8"
-  },
   "engines": {
     "node": "^20.12||^22||>=24"
   },

package/src/cache/content-strategy.mjs

@@ -87,15 +87,15 @@ export default class ContentStrategy {
   revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
     return Boolean(
       pExistingRevisionData &&
-        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,
-        ),
+      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,
+      ),
     );
   }
 

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

@@ -19,6 +19,7 @@ import findAllFiles from "#utl/find-all-files.mjs";
 
 /**
  * @param {Set<string>} pFileSet
+ * @param {string} pBaseDirectory
  * @param {typeof getFileHashSync} pFileHashFunction
  * @returns {(pModule:IModule) => IRevisionChange}
  */

package/src/cli/index.mjs

@@ -20,9 +20,8 @@ async function extractResolveOptions(pCruiseOptions) {
     pCruiseOptions?.ruleSet?.options?.webpackConfig?.fileName ?? null;
 
   if (lWebPackConfigFileName) {
-    const { default: extractWebpackResolveConfig } = await import(
-      "#config-utl/extract-webpack-resolve-config.mjs"
-    );
+    const { default: extractWebpackResolveConfig } =
+      await import("#config-utl/extract-webpack-resolve-config.mjs");
     lResolveOptions = await extractWebpackResolveConfig(
       lWebPackConfigFileName,
       pCruiseOptions?.ruleSet?.options?.webpackConfig?.env ?? null,
@@ -34,9 +33,8 @@ async function extractResolveOptions(pCruiseOptions) {
 
 async function addKnownViolations(pCruiseOptions) {
   if (pCruiseOptions.knownViolationsFile) {
-    const { default: extractKnownViolations } = await import(
-      "#config-utl/extract-known-violations.mjs"
-    );
+    const { default: extractKnownViolations } =
+      await import("#config-utl/extract-known-violations.mjs");
     const lKnownViolations = await extractKnownViolations(
       pCruiseOptions.knownViolationsFile,
     );
@@ -56,9 +54,8 @@ async function extractTSConfigOptions(pCruiseOptions) {
     pCruiseOptions?.ruleSet?.options?.tsConfig?.fileName ?? null;
 
   if (lTSConfigFileName) {
-    const { default: extractTSConfig } = await import(
-      "#config-utl/extract-ts-config.mjs"
-    );
+    const { default: extractTSConfig } =
+      await import("#config-utl/extract-ts-config.mjs");
     lReturnValue = extractTSConfig(lTSConfigFileName);
   }
 
@@ -70,9 +67,8 @@ async function extractBabelConfigOptions(pCruiseOptions) {
   const lBabelConfigFileName =
     pCruiseOptions?.ruleSet?.options?.babelConfig?.fileName ?? null;
   if (lBabelConfigFileName) {
-    const { default: extractBabelConfig } = await import(
-      "#config-utl/extract-babel-config.mjs"
-    );
+    const { default: extractBabelConfig } =
+      await import("#config-utl/extract-babel-config.mjs");
     lReturnValue = extractBabelConfig(lBabelConfigFileName);
   }
 
@@ -177,9 +173,8 @@ export default async function executeCli(
     }
     /* c8 ignore stop */
     if (lCruiseOptions.info === true) {
-      const { default: formatMetaInfo } = await import(
-        "./format-meta-info.mjs"
-      );
+      const { default: formatMetaInfo } =
+        await import("./format-meta-info.mjs");
       lStreams.stdout.write(await formatMetaInfo());
     } else if (lCruiseOptions.init) {
       const { default: initConfig } = await import("./init-config/index.mjs");

package/src/cli/init-config/normalize-init-options.mjs

@@ -19,12 +19,12 @@ import meta from "#meta.cjs";
 function usesTypeScript(pInitOptions, pExtensions) {
   return Boolean(
     pInitOptions.tsConfig ||
-      pInitOptions.tsPreCompilationDeps ||
-      (pExtensions || []).some((pExtension) =>
-        [".ts", ".tsx", ".d.ts", ".mts", ".d.mts", ".cts", ".d.cts"].includes(
-          pExtension,
-        ),
+    pInitOptions.tsPreCompilationDeps ||
+    (pExtensions || []).some((pExtension) =>
+      [".ts", ".tsx", ".d.ts", ".mts", ".d.mts", ".cts", ".d.cts"].includes(
+        pExtension,
       ),
+    ),
   );
 }
 

package/src/enrich/derive/{dependents/index.mjs → dependents.mjs}

@@ -1,6 +1,6 @@
-import getDependents from "./get-dependents.mjs";
+import { isDependent } from "./module-utl.mjs";
 
-/** @import { IFlattenedRuleSet } from "../../../../types/rule-set.mjs" */
+/** @import { IFlattenedRuleSet } from "../../../types/rule-set.mjs" */
 
 function isDependentsRule(pRule) {
   // used in folder rules and when moreUnstable is in the 'to' => governed by
@@ -16,6 +16,13 @@ function isDependentsRule(pRule) {
   );
 }
 
+export function getDependents(pModule, pModules) {
+  // perf between O(n) in an unconnected graph and O(n^2) in a fully connected one
+  return pModules
+    .filter(isDependent(pModule.source))
+    .map((pDependentModule) => pDependentModule.source);
+}
+
 /**
  * @param {IFlattenedRuleSet} pRuleSet
  * @returns {boolean}

package/src/enrich/derive/reachable.mjs

@@ -171,25 +171,29 @@ function addReachabilityToGraph(pGraph, pIndexedGraph, pReachableRule) {
   const lFromModules = pGraph.filter(isModuleInRuleFrom(pReachableRule));
 
   return pGraph.map((pModule) => {
-    let lClonedModule = structuredClone(pModule);
-
-    if (shouldAddReaches(pReachableRule, lClonedModule)) {
-      lClonedModule = addReachesToModule(
-        lClonedModule,
+    // strictly speaking we should clone pModule to prevent mutating it,
+    // but in practice this function is called with a structuredClone'd graph
+    // anyway and the (reference only) copy we use now is faster (observable
+    // even on dependency-cruiser's self scan) and less memory intentsive.
+    let lModule = pModule;
+
+    if (shouldAddReaches(pReachableRule, lModule)) {
+      lModule = addReachesToModule(
+        lModule,
         pGraph,
         pIndexedGraph,
         pReachableRule,
       );
     }
-    if (shouldAddReachable(pReachableRule, lClonedModule, pGraph)) {
-      lClonedModule = addReachableToModule(
-        lClonedModule,
+    if (shouldAddReachable(pReachableRule, lModule, pGraph)) {
+      lModule = addReachableToModule(
+        lModule,
         pIndexedGraph,
         pReachableRule,
         lFromModules,
       );
     }
-    return lClonedModule;
+    return lModule;
   });
 }
 
@@ -199,11 +203,11 @@ export default function deriveReachables(pGraph, pRuleSet) {
   if (lReachableRules.length > 0) {
     const lIndexedGraph = new IndexedModuleGraph(pGraph);
 
-    return lReachableRules.reduce(
-      (pReturnGraph, pRule) =>
-        addReachabilityToGraph(pReturnGraph, lIndexedGraph, pRule),
-      structuredClone(pGraph),
-    );
+    let lResultGraph = structuredClone(pGraph);
+    for (const lRule of lReachableRules) {
+      lResultGraph = addReachabilityToGraph(lResultGraph, lIndexedGraph, lRule);
+    }
+    return lResultGraph;
   }
   return pGraph;
 }

package/src/enrich/enrich-modules.mjs

@@ -1,6 +1,6 @@
 import deriveCycles from "./derive/circular.mjs";
 import deriveOrphans from "./derive/orphan/index.mjs";
-import addDependents from "./derive/dependents/index.mjs";
+import addDependents from "./derive/dependents.mjs";
 import deriveReachable from "./derive/reachable.mjs";
 import addValidations from "./add-validations.mjs";
 import softenKnownViolations from "./soften-known-violations.mjs";

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/tsc/extract-typescript-deps.mjs

@@ -15,6 +15,14 @@ const typescript = await tryImport(
   meta.supportedTranspilers.typescript,
 );
 
+const INTERESTING_NODE_KINDS = new Set([
+  typescript.SyntaxKind.CallExpression,
+  typescript.SyntaxKind.ExportDeclaration,
+  typescript.SyntaxKind.ImportDeclaration,
+  typescript.SyntaxKind.ImportEqualsDeclaration,
+  typescript.SyntaxKind.LastTypeNode,
+]);
+
 function isTypeOnlyImport(pStatement) {
   return (
     pStatement.importClause &&
@@ -60,7 +68,7 @@ function extractImports(pAST) {
   return pAST.statements
     .filter(
       (pStatement) =>
-        typescript.SyntaxKind[pStatement.kind] === "ImportDeclaration" &&
+        pStatement.kind === typescript.SyntaxKind.ImportDeclaration &&
         pStatement.moduleSpecifier,
     )
     .map((pStatement) => ({
@@ -84,7 +92,7 @@ function extractExports(pAST) {
   return pAST.statements
     .filter(
       (pStatement) =>
-        typescript.SyntaxKind[pStatement.kind] === "ExportDeclaration" &&
+        pStatement.kind === typescript.SyntaxKind.ExportDeclaration &&
         pStatement.moduleSpecifier,
     )
     .map((pStatement) => ({
@@ -112,7 +120,7 @@ function extractImportEquals(pAST) {
   return pAST.statements
     .filter(
       (pStatement) =>
-        typescript.SyntaxKind[pStatement.kind] === "ImportEqualsDeclaration" &&
+        pStatement.kind === typescript.SyntaxKind.ImportEqualsDeclaration &&
         pStatement.moduleReference &&
         pStatement.moduleReference.expression &&
         pStatement.moduleReference.expression.text,
@@ -173,15 +181,15 @@ function firstArgumentIsAString(pASTNode) {
   return (
     lFirstArgument &&
     // "thing" or 'thing'
-    (typescript.SyntaxKind[lFirstArgument.kind] === "StringLiteral" ||
+    (lFirstArgument.kind === typescript.SyntaxKind.StringLiteral ||
       // `thing`
-      typescript.SyntaxKind[lFirstArgument.kind] === "FirstTemplateToken")
+      lFirstArgument.kind === typescript.SyntaxKind.FirstTemplateToken)
   );
 }
 
 function isRequireCallExpression(pASTNode) {
   if (
-    typescript.SyntaxKind[pASTNode.kind] === "CallExpression" &&
+    pASTNode.kind === typescript.SyntaxKind.CallExpression &&
     pASTNode.expression
   ) {
     /*
@@ -204,7 +212,7 @@ function isRequireCallExpression(pASTNode) {
 
 function isSingleExoticRequire(pASTNode, pString) {
   return (
-    typescript.SyntaxKind[pASTNode.kind] === "CallExpression" &&
+    pASTNode.kind === typescript.SyntaxKind.CallExpression &&
     pASTNode.expression &&
     pASTNode.expression.text === pString &&
     firstArgumentIsAString(pASTNode)
@@ -214,16 +222,15 @@ function isSingleExoticRequire(pASTNode, pString) {
 /* eslint complexity:0 */
 function isCompositeExoticRequire(pASTNode, pObjectName, pPropertyName) {
   return (
-    typescript.SyntaxKind[pASTNode.kind] === "CallExpression" &&
+    pASTNode.kind === typescript.SyntaxKind.CallExpression &&
     pASTNode.expression &&
-    typescript.SyntaxKind[pASTNode.expression.kind] ===
-      "PropertyAccessExpression" &&
+    pASTNode.expression.kind ===
+      typescript.SyntaxKind.PropertyAccessExpression &&
     pASTNode.expression.expression &&
-    typescript.SyntaxKind[pASTNode.expression.expression.kind] ===
-      "Identifier" &&
+    pASTNode.expression.expression.kind === typescript.SyntaxKind.Identifier &&
     pASTNode.expression.expression.escapedText === pObjectName &&
     pASTNode.expression.name &&
-    typescript.SyntaxKind[pASTNode.expression.name.kind] === "Identifier" &&
+    pASTNode.expression.name.kind === typescript.SyntaxKind.Identifier &&
     pASTNode.expression.name.escapedText === pPropertyName &&
     firstArgumentIsAString(pASTNode)
   );
@@ -236,25 +243,25 @@ function isTripleCursedCompositeExoticRequire(
   pPropertyName,
 ) {
   return (
-    typescript.SyntaxKind[pASTNode.kind] === "CallExpression" &&
+    pASTNode.kind === typescript.SyntaxKind.CallExpression &&
     pASTNode.expression &&
-    typescript.SyntaxKind[pASTNode.expression.kind] ===
-      "PropertyAccessExpression" &&
+    pASTNode.expression.kind ===
+      typescript.SyntaxKind.PropertyAccessExpression &&
     pASTNode.expression.expression &&
-    typescript.SyntaxKind[pASTNode.expression.expression.kind] ===
-      "PropertyAccessExpression" &&
+    pASTNode.expression.expression.kind ===
+      typescript.SyntaxKind.PropertyAccessExpression &&
     // globalThis
     pASTNode.expression.expression.expression &&
-    typescript.SyntaxKind[pASTNode.expression.expression.expression.kind] ===
-      "Identifier" &&
+    pASTNode.expression.expression.expression.kind ===
+      typescript.SyntaxKind.Identifier &&
     pASTNode.expression.expression.expression.escapedText === pObjectName1 &&
     // process
-    typescript.SyntaxKind[pASTNode.expression.expression.name.kind] ===
-      "Identifier" &&
+    pASTNode.expression.expression.name.kind ===
+      typescript.SyntaxKind.Identifier &&
     pASTNode.expression.expression.name.escapedText === pObjectName2 &&
     // getBuiltinModule
     pASTNode.expression.name &&
-    typescript.SyntaxKind[pASTNode.expression.name.kind] === "Identifier" &&
+    pASTNode.expression.name.kind === typescript.SyntaxKind.Identifier &&
     pASTNode.expression.name.escapedText === pPropertyName &&
     firstArgumentIsAString(pASTNode)
   );
@@ -270,23 +277,22 @@ function isExoticRequire(pASTNode, pString) {
 
 function isDynamicImportExpression(pASTNode) {
   return (
-    typescript.SyntaxKind[pASTNode.kind] === "CallExpression" &&
+    pASTNode.kind === typescript.SyntaxKind.CallExpression &&
     pASTNode.expression &&
-    typescript.SyntaxKind[pASTNode.expression.kind] === "ImportKeyword" &&
+    pASTNode.expression.kind === typescript.SyntaxKind.ImportKeyword &&
     firstArgumentIsAString(pASTNode)
   );
 }
 
 function isTypeImport(pASTNode) {
   return (
-    typescript.SyntaxKind[pASTNode.kind] === "LastTypeNode" &&
+    pASTNode.kind === typescript.SyntaxKind.LastTypeNode &&
     pASTNode.argument &&
-    typescript.SyntaxKind[pASTNode.argument.kind] === "LiteralType" &&
+    pASTNode.argument.kind === typescript.SyntaxKind.LiteralType &&
     ((pASTNode.argument.literal &&
-      typescript.SyntaxKind[pASTNode.argument.literal.kind] ===
-        "StringLiteral") ||
-      typescript.SyntaxKind[pASTNode.argument.literal.kind] ===
-        "FirstTemplateToken")
+      pASTNode.argument.literal.kind === typescript.SyntaxKind.StringLiteral) ||
+      pASTNode.argument.literal.kind ===
+        typescript.SyntaxKind.FirstTemplateToken)
   );
 }
 
@@ -296,7 +302,7 @@ function extractJSDocImportTags(pJSDocTags) {
       (pTag) =>
         pTag.tagName.escapedText === "import" &&
         pTag.moduleSpecifier &&
-        typescript.SyntaxKind[pTag.moduleSpecifier.kind] === "StringLiteral" &&
+        pTag.moduleSpecifier.kind === typescript.SyntaxKind.StringLiteral &&
         pTag.moduleSpecifier.text,
     )
     .map((pTag) => ({
@@ -310,10 +316,9 @@ function extractJSDocImportTags(pJSDocTags) {
 function isJSDocImport(pTypeNode) {
   // import('./hello.mjs') within jsdoc
   return (
-    typescript.SyntaxKind[pTypeNode?.kind] === "LastTypeNode" &&
-    typescript.SyntaxKind[pTypeNode.argument?.kind] === "LiteralType" &&
-    typescript.SyntaxKind[pTypeNode.argument?.literal?.kind] ===
-      "StringLiteral" &&
+    pTypeNode?.kind === typescript.SyntaxKind.LastTypeNode &&
+    pTypeNode.argument?.kind === typescript.SyntaxKind.LiteralType &&
+    pTypeNode.argument?.literal?.kind === typescript.SyntaxKind.StringLiteral &&
     pTypeNode.argument.literal.text
   );
 }
@@ -362,7 +367,7 @@ function extractJSDocBracketImports(pJSDocTags) {
     .filter(
       (pTag) =>
         pTag.tagName.escapedText !== "import" &&
-        typescript.SyntaxKind[pTag.typeExpression?.kind] === "FirstJSDocNode",
+        pTag.typeExpression?.kind === typescript.SyntaxKind.FirstJSDocNode,
     )
     .flatMap((pTag) => getJSDocImports(pTag))
     .map((pImportName) => ({
@@ -404,81 +409,87 @@ function walk(
 ) {
   // eslint-disable-next-line max-lines-per-function
   return (pASTNode) => {
-    // require('a-string'), require(`a-template-literal`)
-    if (isRequireCallExpression(pASTNode)) {
-      pResult.push({
-        module: pASTNode.arguments[0].text,
-        moduleSystem: "cjs",
-        exoticallyRequired: false,
-        dependencyTypes: ["require"],
-      });
+    // /** @import thing from './module' */ etc
+    // /** @type {import('module').thing}*/ etc
+    if (pDetectJSDocImports && pASTNode.jsDoc) {
+      const lJSDocImports = extractJSDocImports(pASTNode.jsDoc);
+
+      // pResult = pResult.concat(lJSDocImports) looks like the more obvious
+      // way to do this, but it re-assigns the pResult parameter
+      for (const lImport of lJSDocImports) {
+        pResult.push(lImport);
+      }
     }
 
-    // const want = require; {lalala} = want('yudelyo'), window.require('elektron')
-    for (const lExoticRequireString of pExoticRequireStrings) {
-      if (isExoticRequire(pASTNode, lExoticRequireString)) {
+    if (INTERESTING_NODE_KINDS.has(pASTNode.kind)) {
+      // require('a-string'), require(`a-template-literal`)
+      if (isRequireCallExpression(pASTNode)) {
         pResult.push({
           module: pASTNode.arguments[0].text,
           moduleSystem: "cjs",
-          exoticallyRequired: true,
-          exoticRequire: lExoticRequireString,
-          dependencyTypes: ["exotic-require"],
+          exoticallyRequired: false,
+          dependencyTypes: ["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)) {
-      pResult.push({
-        module: pASTNode.arguments[0].text,
-        moduleSystem: "es6",
-        dynamic: true,
-        exoticallyRequired: false,
-        dependencyTypes: ["dynamic-import"],
-      });
-    }
+      // const want = require; {lalala} = want('yudelyo'), window.require('elektron')
+      if (pASTNode.kind === typescript.SyntaxKind.CallExpression) {
+        for (const lExoticRequireString of pExoticRequireStrings) {
+          // eslint-disable-next-line max-depth
+          if (isExoticRequire(pASTNode, lExoticRequireString)) {
+            pResult.push({
+              module: pASTNode.arguments[0].text,
+              moduleSystem: "cjs",
+              exoticallyRequired: true,
+              exoticRequire: lExoticRequireString,
+              dependencyTypes: ["exotic-require"],
+            });
+          }
+        }
+      }
 
-    // const atype: import('./types').T
-    // const atype: import(`./types`).T
-    if (isTypeImport(pASTNode)) {
-      pResult.push({
-        module: pASTNode.argument.literal.text,
-        moduleSystem: "es6",
-        exoticallyRequired: false,
-        dependencyTypes: ["type-import"],
-      });
-    }
+      // 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 thing from './module' */ etc
-    // /** @type {import('module').thing}*/ etc
-    if (pDetectJSDocImports && pASTNode.jsDoc) {
-      const lJSDocImports = extractJSDocImports(pASTNode.jsDoc);
+      // import('a-string'), import(`a-template-literal`)
+      if (isDynamicImportExpression(pASTNode)) {
+        pResult.push({
+          module: pASTNode.arguments[0].text,
+          moduleSystem: "es6",
+          dynamic: true,
+          exoticallyRequired: false,
+          dependencyTypes: ["dynamic-import"],
+        });
+      }
 
-      // pResult = pResult.concat(lJSDocImports) looks like the more obvious
-      // way to do this, but it re-assigns the pResult parameter
-      for (const lImport of lJSDocImports) {
-        pResult.push(lImport);
+      // const atype: import('./types').T
+      // const atype: import(`./types`).T
+      if (isTypeImport(pASTNode)) {
+        pResult.push({
+          module: pASTNode.argument.literal.text,
+          moduleSystem: "es6",
+          exoticallyRequired: false,
+          dependencyTypes: ["type-import"],
+        });
       }
     }
+
     typescript.forEachChild(
       pASTNode,
       walk(

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

@@ -1,4 +1,3 @@
-// @ts-check
 /* eslint-disable security/detect-object-injection */
 /**
  * @import { IFolderDependency, IDependency, IFolder, IModule } from "../../types/cruise-result.mjs"
@@ -68,7 +67,7 @@ export default class IndexedModuleGraph {
   ) {
     /** @type {string[]} */
     let lReturnValue = [];
-    const lModule = this.findVertexByName(pName);
+    const lModule = this.#indexedGraph.get(pName);
 
     if (lModule && (!pMaxDepth || pDepth <= pMaxDepth)) {
       let lDependents = lModule.dependents || [];
@@ -110,24 +109,26 @@ export default class IndexedModuleGraph {
   ) {
     /** @type {string[]} */
     let lReturnValue = [];
-    const lModule = this.findVertexByName(pName);
+    /** @type {IVertex} */
+    const lModule = this.#indexedGraph.get(pName);
 
     if (lModule && (!pMaxDepth || pDepth <= pMaxDepth)) {
       let lDependencies = lModule.dependencies;
       const lVisited = pVisited.add(pName);
 
       if (lDependencies.length > 0) {
-        lDependencies
-          .map(({ name }) => name)
-          .filter((pDependency) => !lVisited.has(pDependency))
-          .forEach((pDependency) =>
+        // eslint-disable-next-line budapestian/local-variable-pattern
+        for (const { name } of lDependencies) {
+          // eslint-disable-next-line max-depth
+          if (!lVisited.has(name)) {
             this.findTransitiveDependencies(
-              pDependency,
+              name,
               pMaxDepth,
               pDepth + 1,
               lVisited,
-            ),
-          );
+            );
+          }
+        }
       }
       lReturnValue = Array.from(lVisited);
     }
@@ -140,12 +141,10 @@ export default class IndexedModuleGraph {
    * @returns {IMiniDependency}
    */
   #geldEdge(pEdge) {
-    let lReturnValue = {};
-    lReturnValue.name = pEdge.name;
-    lReturnValue.dependencyTypes = pEdge.dependencyTypes
-      ? pEdge.dependencyTypes
-      : [];
-    return lReturnValue;
+    return {
+      name: pEdge.name,
+      dependencyTypes: pEdge.dependencyTypes ?? [],
+    };
   }
 
   /**
@@ -155,7 +154,8 @@ export default class IndexedModuleGraph {
    * @returns {Array<IMiniDependency>}
    */
   getPath(pFrom, pTo, pVisited = new Set()) {
-    const lFromNode = this.findVertexByName(pFrom);
+    /** @type {IVertex} */
+    const lFromNode = this.#indexedGraph.get(pFrom);
 
     pVisited.add(pFrom);
 
@@ -195,7 +195,8 @@ export default class IndexedModuleGraph {
    */
   #getCycle(pInitialSource, pCurrentDependency, pVisited) {
     const lVisited = pVisited || new Set();
-    const lCurrentVertex = this.findVertexByName(pCurrentDependency.name);
+    /** @type {IVertex} */
+    const lCurrentVertex = this.#indexedGraph.get(pCurrentDependency.name);
     const lEdges = lCurrentVertex.dependencies.filter(
       (pDependency) => !lVisited.has(pDependency.name),
     );
@@ -245,7 +246,8 @@ export default class IndexedModuleGraph {
    * @return {Array<IMiniDependency>}   see description above
    */
   getCycle(pInitialSource, pCurrentSource) {
-    const lInitialNode = this.findVertexByName(pInitialSource);
+    /** @type {IVertex} */
+    const lInitialNode = this.#indexedGraph.get(pInitialSource);
     const lCurrentDependency = lInitialNode.dependencies.find(
       (pDependency) => pDependency.name === pCurrentSource,
     );

package/src/main/resolve-options/normalize.mjs

@@ -80,9 +80,8 @@ async function compileResolveOptions(
   // Also: requiring the plugin only when it's necessary will save some
   // startup time (especially on a cold require cache)
   if (pResolveOptions.tsConfig) {
-    const { default: TsConfigPathsPlugin } = await import(
-      "tsconfig-paths-webpack-plugin"
-    );
+    const { default: TsConfigPathsPlugin } =
+      await import("tsconfig-paths-webpack-plugin");
     lResolveOptions.plugins = pushPlugin(
       lResolveOptions.plugins,
       // @ts-expect-error TS2351 "TsConfPathsPlugin is not constructable" - is unjustified

package/src/meta.cjs

@@ -1,7 +1,7 @@
 /* generated - don't edit */
 
 module.exports = {
-  version: "17.3.1",
+  version: "17.3.3-beta-1",
   engines: {
     node: "^20.12||^22||>=24",
   },

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

@@ -28,37 +28,29 @@ function walk(
   pDirectoryName,
   { baseDir, ignoreFilterFn, excludeFilterFn, includeOnlyFilterFn },
 ) {
-  return readdirSync(join(baseDir, pDirectoryName))
+  const lFilesInCurrentDirectory = readdirSync(join(baseDir, pDirectoryName))
     .map((pFileName) => join(pDirectoryName, pFileName))
     .filter(ignoreFilterFn)
     .filter(excludeFilterFn)
-    .filter(includeOnlyFilterFn)
-    .map((pFullPathToFile) => ({
-      fullPathToFile: pFullPathToFile,
-      isDirectory: fileIsDirectory(pFullPathToFile, baseDir),
-    }))
-    .reduce(
-      /**
-       * @param {string[]} pSum
-       * @param {{fullPathToFile: string; isDirectory: boolean}} pCurrentValue
-       * @returns {string[]}
-       */
-      (pSum, { fullPathToFile, isDirectory }) => {
-        if (isDirectory) {
-          return pSum.concat(
-            walk(fullPathToFile, {
-              baseDir,
-              ignoreFilterFn,
-              excludeFilterFn,
-              includeOnlyFilterFn,
-            }),
-          );
-        }
-        return pSum.concat(fullPathToFile);
-      },
-      [],
-    )
-    .map((pFullPathToFile) => pathToPosix(pFullPathToFile));
+    .filter(includeOnlyFilterFn);
+
+  const lFiles = [];
+  for (const lFile of lFilesInCurrentDirectory) {
+    if (fileIsDirectory(lFile, baseDir)) {
+      lFiles.push(
+        ...walk(lFile, {
+          baseDir,
+          ignoreFilterFn,
+          excludeFilterFn,
+          includeOnlyFilterFn,
+        }),
+      );
+    } else {
+      lFiles.push(pathToPosix(lFile));
+    }
+  }
+
+  return lFiles;
 }
 
 function readIgnoreFile(pFileName) {

package/src/validate/match-folder-dependency-rule.mjs

@@ -15,16 +15,14 @@ function fromFolderPathNot(pRule, pFromFolder) {
 function toFolderPath(pRule, pToFolder, pGroups) {
   return Boolean(
     !pRule.to.path ||
-      pToFolder.name.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
+    pToFolder.name.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
   );
 }
 
 function toFolderPathNot(pRule, pToFolder, pGroups) {
   return Boolean(
     !pRule.to.pathNot ||
-      !pToFolder.name.match(
-        replaceGroupPlaceholders(pRule.to.pathNot, pGroups),
-      ),
+    !pToFolder.name.match(replaceGroupPlaceholders(pRule.to.pathNot, pGroups)),
   );
 }
 

package/src/validate/matchers.mjs

@@ -31,8 +31,8 @@ export function propertyEquals(pRule, pDependency, pProperty) {
 export function propertyMatches(pRule, pDependency, pRuleProperty, pProperty) {
   return Boolean(
     !pRule.to[pRuleProperty] ||
-      (pDependency[pProperty] &&
-        pDependency[pProperty].match(pRule.to[pRuleProperty])),
+    (pDependency[pProperty] &&
+      pDependency[pProperty].match(pRule.to[pRuleProperty])),
   );
 }
 
@@ -44,8 +44,8 @@ export function propertyMatchesNot(
 ) {
   return Boolean(
     !pRule.to[pRuleProperty] ||
-      (pDependency[pProperty] &&
-        !pDependency[pProperty].match(pRule.to[pRuleProperty])),
+    (pDependency[pProperty] &&
+      !pDependency[pProperty].match(pRule.to[pRuleProperty])),
   );
 }
 
@@ -72,7 +72,7 @@ export function matchesModulePathNot(pRule, pModule) {
 function _matchesToPath(pRule, pString, pGroups = []) {
   return Boolean(
     !pRule.to.path ||
-      pString.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
+    pString.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
   );
 }
 
@@ -102,14 +102,14 @@ export function matchToModulePathNot(pRule, pModule, pGroups) {
 export function matchesToDependencyTypes(pRule, pDependency) {
   return Boolean(
     !pRule.to.dependencyTypes ||
-      intersects(pDependency.dependencyTypes, pRule.to.dependencyTypes),
+    intersects(pDependency.dependencyTypes, pRule.to.dependencyTypes),
   );
 }
 
 export function matchesToDependencyTypesNot(pRule, pDependency) {
   return Boolean(
     !pRule.to.dependencyTypesNot ||
-      !intersects(pDependency.dependencyTypes, pRule.to.dependencyTypesNot),
+    !intersects(pDependency.dependencyTypes, pRule.to.dependencyTypesNot),
   );
 }
 

package/types/strict-restrictions.d.mts

@@ -18,8 +18,7 @@ export interface IStrictFromRestriction extends IFromRestriction {
   pathNot?: string;
 }
 
-export interface IStrictMiniDependencyRestriction
-  extends IStrictBaseRestrictionType {
+export interface IStrictMiniDependencyRestriction extends IStrictBaseRestrictionType {
   dependencyTypes?: DependencyType[];
   dependencyTypesNot?: DependencyType[];
 }
@@ -35,19 +34,16 @@ interface IStrictToRestriction extends IToRestriction {
   licenseNot?: string;
 }
 
-export interface IStrictReachabilityToRestrictionType
-  extends IReachabilityToRestrictionType {
+export interface IStrictReachabilityToRestrictionType extends IReachabilityToRestrictionType {
   path?: string;
   pathNot?: string;
 }
 
-export interface IStrictRequiredToRestrictionType
-  extends IRequiredToRestrictionType {
+export interface IStrictRequiredToRestrictionType extends IRequiredToRestrictionType {
   path?: string;
 }
 
-export interface IStrictDependentsModuleRestrictionType
-  extends IDependentsModuleRestrictionType {
+export interface IStrictDependentsModuleRestrictionType extends IDependentsModuleRestrictionType {
   path?: string;
   pathNot?: string;
 }

package/types/strict-rule-set.d.mts

@@ -24,14 +24,12 @@ export interface IStrictRegularForbiddenRuleType extends IStrictBaseRuleType {
   scope: RuleScopeType;
 }
 
-export interface IStrictReachabilityForbiddenRuleType
-  extends IStrictBaseRuleType {
+export interface IStrictReachabilityForbiddenRuleType extends IStrictBaseRuleType {
   from: IStrictBaseRestrictionType;
   to: IStrictReachabilityToRestrictionType;
 }
 
-export interface IStrictDependentsForbiddenRuleType
-  extends IStrictBaseRuleType {
+export interface IStrictDependentsForbiddenRuleType extends IStrictBaseRuleType {
   module: IStrictDependentsModuleRestrictionType;
   from: IStrictBaseRestrictionType;
 }

package/src/enrich/derive/dependents/get-dependents.mjs

@@ -1,8 +0,0 @@
-import { isDependent } from "../module-utl.mjs";
-
-export default function getDependents(pModule, pModules) {
-  // perf between O(n) in an unconnected graph and O(n^2) in a fully connected one
-  return pModules
-    .filter(isDependent(pModule.source))
-    .map((pDependentModule) => pDependentModule.source);
-}