dependency-cruiser 16.2.4 → 16.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-cruiser",
-  "version": "16.2.4",
+  "version": "16.3.1",
   "description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
   "keywords": [
     "static analysis",
@@ -148,7 +148,7 @@
     "json5": "2.2.3",
     "lodash": "4.17.21",
     "memoize": "10.0.0",
-    "picomatch": "4.0.1",
+    "picomatch": "4.0.2",
     "prompts": "2.4.2",
     "rechoir": "^0.8.0",
     "safe-regex": "2.1.1",
@@ -156,7 +156,7 @@
     "semver-try-require": "6.2.3",
     "teamcity-service-messages": "0.1.14",
     "tsconfig-paths-webpack-plugin": "4.1.0",
-    "watskeburt": "4.0.1",
+    "watskeburt": "4.0.2",
     "wrap-ansi": "9.0.0"
   },
   "overrides": {

package/src/cache/options-compatible.mjs

@@ -104,6 +104,7 @@ export function optionsAreCompatible(pOldOptions, pNewOptions) {
     pOldOptions.tsPreCompilationDeps === pNewOptions.tsPreCompilationDeps &&
     pOldOptions.preserveSymlinks === pNewOptions.preserveSymlinks &&
     pOldOptions.combinedDependencies === pNewOptions.combinedDependencies &&
+    pOldOptions.experimentalStats === pNewOptions.experimentalStats &&
     metricsIsCompatible(pOldOptions.metrics, pNewOptions.metrics) &&
     // includeOnly suffers from a backwards compatibility disease
     includeOnlyIsCompatible(pOldOptions.includeOnly, pNewOptions.includeOnly) &&

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

@@ -10,6 +10,7 @@ import {
   object2Array,
 } from "./utl.mjs";
 import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
+import { uniq } from "#utl/array-util.mjs";
 
 function upsertCouplings(pAllDependents, pNewDependents) {
   pNewDependents.forEach((pNewDependent) => {
@@ -20,6 +21,14 @@ function upsertCouplings(pAllDependents, pNewDependents) {
   });
 }
 
+/**
+ *
+ * @param {any} pAllMetrics
+ * @param {import("../../../../types/cruise-result.d.mts").IModule} pModule
+ * @param {string} pDirname
+ * @returns {any}
+ */
+
 function upsertFolderAttributes(pAllMetrics, pModule, pDirname) {
   pAllMetrics[pDirname] = pAllMetrics[pDirname] || {
     dependencies: {},
@@ -38,6 +47,19 @@ function upsertFolderAttributes(pAllMetrics, pModule, pDirname) {
     ),
   );
   pAllMetrics[pDirname].moduleCount += 1;
+
+  if (pModule.experimentalStats) {
+    if (!Object.hasOwn(pAllMetrics[pDirname], "experimentalStats")) {
+      pAllMetrics[pDirname].experimentalStats = {
+        size: 0,
+        topLevelStatementCount: 0,
+      };
+    }
+    pAllMetrics[pDirname].experimentalStats.size +=
+      pModule.experimentalStats.size;
+    pAllMetrics[pDirname].experimentalStats.topLevelStatementCount +=
+      pModule.experimentalStats.topLevelStatementCount;
+  }
   return pAllMetrics;
 }
 
@@ -53,13 +75,11 @@ function sumCounts(pAll, pCurrent) {
 }
 
 function getFolderLevelCouplings(pCouplingArray) {
-  return Array.from(
-    new Set(
-      pCouplingArray.map((pCoupling) =>
-        dirname(pCoupling.name) === "."
-          ? pCoupling.name
-          : dirname(pCoupling.name),
-      ),
+  return uniq(
+    pCouplingArray.map((pCoupling) =>
+      dirname(pCoupling.name) === "."
+        ? pCoupling.name
+        : dirname(pCoupling.name),
     ),
   ).map((pCoupling) => ({ name: pCoupling }));
 }
@@ -95,9 +115,7 @@ function deNormalizeInstability(pFolder, _, pAllFolders) {
     }),
   };
 }
-function uniq(pArray) {
-  return [...new Set(pArray)];
-}
+
 function getSinks(pFolders) {
   const lKnownFolders = new Set(pFolders.map(({ name }) => name));
   const lAllFolders = uniq(

package/src/extract/{ast-extractors → acorn}/estree-helpers.mjs

@@ -10,7 +10,7 @@ function firstArgumentIsAString(pArgumentsNode) {
   );
 }
 
-function isPlaceholderlessTemplateLiteral(pArgument) {
+function isPlaceholderLessTemplateLiteral(pArgument) {
   return (
     pArgument.type === "TemplateLiteral" &&
     pArgument.quasis.length === 1 &&
@@ -22,7 +22,7 @@ function firstArgumentIsATemplateLiteral(pArgumentsNode) {
   return (
     Boolean(pArgumentsNode) &&
     pArgumentsNode[0] &&
-    isPlaceholderlessTemplateLiteral(pArgumentsNode[0])
+    isPlaceholderLessTemplateLiteral(pArgumentsNode[0])
   );
 }
 
@@ -70,7 +70,7 @@ export default {
   firstArgumentIsAString,
   firstArgumentIsATemplateLiteral,
   isStringLiteral,
-  isPlaceholderlessTemplateLiteral,
+  isPlaceholderlessTemplateLiteral: isPlaceholderLessTemplateLiteral,
   isMemberCallExpression,
   isCalleeIdentifier,
   isRequireOfSomeSort,

package/src/extract/acorn/extract-stats.mjs

@@ -0,0 +1,6 @@
+export default function extractStats(pAST) {
+  return {
+    topLevelStatementCount: pAST?.body?.length || 0,
+    size: pAST?.end || 0,
+  };
+}

package/src/extract/acorn/extract.mjs

@@ -0,0 +1,32 @@
+import { join } from "node:path";
+import extractES6Deps from "./extract-es6-deps.mjs";
+import extractCommonJSDeps from "./extract-cjs-deps.mjs";
+import extractAMDDeps from "./extract-amd-deps.mjs";
+import parse from "./parse.mjs";
+import extractStats from "./extract-stats.mjs";
+
+export function extract(
+  { baseDir, moduleSystems, exoticRequireStrings },
+  pFileName,
+  pTranspileOptions,
+) {
+  let lDependencies = [];
+  const lAST = parse.getASTCached(join(baseDir, pFileName), pTranspileOptions);
+
+  if (moduleSystems.includes("cjs")) {
+    extractCommonJSDeps(lAST, lDependencies, "cjs", exoticRequireStrings);
+  }
+  if (moduleSystems.includes("es6")) {
+    extractES6Deps(lAST, lDependencies);
+  }
+  if (moduleSystems.includes("amd")) {
+    extractAMDDeps(lAST, lDependencies, exoticRequireStrings);
+  }
+
+  return lDependencies;
+}
+
+export function getStats({ baseDir }, pFileName, pTranspileOptions) {
+  const lAST = parse.getASTCached(join(baseDir, pFileName), pTranspileOptions);
+  return extractStats(lAST);
+}

package/src/extract/clear-caches.mjs

@@ -1,15 +1,15 @@
-import toTypescriptAST from "./parse/to-typescript-ast.mjs";
-import toJavascriptAST from "./parse/to-javascript-ast.mjs";
-import toSwcAST from "./parse/to-swc-ast.mjs";
+import tscParse from "./tsc/parse.mjs";
+import acornParse from "./acorn/parse.mjs";
+import swcParse from "./swc/parse.mjs";
 import { clearCache as externalModuleHelpers_clearCache } from "./resolve/external-module-helpers.mjs";
 import { clearCache as getManifest_clearCache } from "./resolve/get-manifest.mjs";
 import { clearCache as resolveAMD_clearCache } from "./resolve/resolve-amd.mjs";
 import { clearCache as resolve_clearCache } from "./resolve/resolve.mjs";
 
 export default function clearCaches() {
-  toTypescriptAST.clearCache();
-  toJavascriptAST.clearCache();
-  toSwcAST.clearCache();
+  tscParse.clearCache();
+  acornParse.clearCache();
+  swcParse.clearCache();
   externalModuleHelpers_clearCache();
   getManifest_clearCache();
   resolveAMD_clearCache();

package/src/extract/{get-dependencies.mjs → extract-dependencies.mjs}

@@ -1,117 +1,51 @@
 import { join, extname, dirname } from "node:path";
 import uniqBy from "lodash/uniqBy.js";
+import { extract as acornExtract } from "./acorn/extract.mjs";
+import {
+  extract as tscExtract,
+  shouldUse as tscShouldUse,
+} from "./tsc/extract.mjs";
+import {
+  extract as swcExtract,
+  shouldUse as swcShouldUse,
+} from "./swc/extract.mjs";
 import resolve from "./resolve/index.mjs";
-import extractES6Deps from "./ast-extractors/extract-es6-deps.mjs";
-import extractCommonJSDeps from "./ast-extractors/extract-cjs-deps.mjs";
-import extractAMDDeps from "./ast-extractors/extract-amd-deps.mjs";
-import extractTypeScriptDeps from "./ast-extractors/extract-typescript-deps.mjs";
-import extractSwcDeps from "./ast-extractors/extract-swc-deps.mjs";
-import toJavascriptAST from "./parse/to-javascript-ast.mjs";
-import toTypescriptAST from "./parse/to-typescript-ast.mjs";
-import toSwcAST from "./parse/to-swc-ast.mjs";
 import {
   detectPreCompilationNess,
   extractModuleAttributes,
 } from "./helpers.mjs";
 import { intersects } from "#utl/array-util.mjs";
 
-function extractFromSwcAST({ baseDir, exoticRequireStrings }, pFileName) {
-  return extractSwcDeps(
-    toSwcAST.getASTCached(join(baseDir, pFileName)),
-    exoticRequireStrings,
-  );
-}
-
-function extractFromTypeScriptAST(
-  { baseDir, exoticRequireStrings },
-  pFileName,
-  pTranspileOptions,
-) {
-  return extractTypeScriptDeps(
-    toTypescriptAST.getASTCached(join(baseDir, pFileName), pTranspileOptions),
-    exoticRequireStrings,
-  );
-}
-
-function isTypeScriptCompatible(pFileName) {
-  return [
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".mjs",
-    ".cjs",
-    ".vue",
-  ].includes(extname(pFileName));
-}
-
-function shouldUseTsc({ tsPreCompilationDeps, parser }, pFileName) {
-  return (
-    (tsPreCompilationDeps || parser === "tsc") &&
-    toTypescriptAST.isAvailable() &&
-    isTypeScriptCompatible(pFileName)
-  );
-}
-
-function shouldUseSwc({ parser }, pFileName) {
-  return (
-    parser === "swc" &&
-    toSwcAST.isAvailable() &&
-    isTypeScriptCompatible(pFileName)
-  );
-}
-
-function extractFromJavaScriptAST(
-  { baseDir, moduleSystems, exoticRequireStrings },
-  pFileName,
-  pTranspileOptions,
-) {
-  let lDependencies = [];
-  const lAST = toJavascriptAST.getASTCached(
-    join(baseDir, pFileName),
-    pTranspileOptions,
-  );
-
-  if (moduleSystems.includes("cjs")) {
-    extractCommonJSDeps(lAST, lDependencies, "cjs", exoticRequireStrings);
-  }
-  if (moduleSystems.includes("es6")) {
-    extractES6Deps(lAST, lDependencies);
-  }
-  if (moduleSystems.includes("amd")) {
-    extractAMDDeps(lAST, lDependencies, exoticRequireStrings);
-  }
-
-  return lDependencies;
-}
-
-function extractWithSwc(pCruiseOptions, pFileName) {
-  return extractFromSwcAST(pCruiseOptions, pFileName).filter(
-    ({ moduleSystem }) => pCruiseOptions.moduleSystems.includes(moduleSystem),
-  );
-}
-
 function extractWithTsc(pCruiseOptions, pFileName, pTranspileOptions) {
-  let lDependencies = extractFromTypeScriptAST(
-    pCruiseOptions,
-    pFileName,
-    pTranspileOptions,
-  ).filter(({ moduleSystem }) =>
-    pCruiseOptions.moduleSystems.includes(moduleSystem),
-  );
+  let lDependencies = tscExtract(pCruiseOptions, pFileName, pTranspileOptions);
 
   if (pCruiseOptions.tsPreCompilationDeps === "specify") {
     lDependencies = detectPreCompilationNess(
       lDependencies,
-      extractFromJavaScriptAST(pCruiseOptions, pFileName, pTranspileOptions),
+      acornExtract(pCruiseOptions, pFileName, pTranspileOptions),
     );
   }
   return lDependencies;
 }
 
 /**
- *
+ * @param {IStrictCruiseOptions} pCruiseOptions
+ * @param {string} pFileName
+ * @returns {(IStrictCruiseOptions, string, any) => import("../../types/cruise-result.mjs").IDependency[]}
+ */
+function determineExtractionFunction(pCruiseOptions, pFileName) {
+  let lExtractionFunction = acornExtract;
+
+  if (tscShouldUse(pCruiseOptions, pFileName)) {
+    lExtractionFunction = extractWithTsc;
+  } else if (swcShouldUse(pCruiseOptions, pFileName)) {
+    lExtractionFunction = swcExtract;
+  }
+
+  return lExtractionFunction;
+}
+
+/**
  * @param {import('../../types/dependency-cruiser.js').IStrictCruiseOptions} pCruiseOptions
  * @param {string} pFileName
  * @param {any} pTranspileOptions
@@ -122,21 +56,15 @@ function extractDependencies(pCruiseOptions, pFileName, pTranspileOptions) {
   let lDependencies = [];
 
   if (!pCruiseOptions.extraExtensionsToScan.includes(extname(pFileName))) {
-    if (shouldUseSwc(pCruiseOptions, pFileName)) {
-      lDependencies = extractWithSwc(pCruiseOptions, pFileName);
-    } else if (shouldUseTsc(pCruiseOptions, pFileName)) {
-      lDependencies = extractWithTsc(
-        pCruiseOptions,
-        pFileName,
-        pTranspileOptions,
-      );
-    } else {
-      lDependencies = extractFromJavaScriptAST(
-        pCruiseOptions,
-        pFileName,
-        pTranspileOptions,
-      );
-    }
+    const lExtractionFunction = determineExtractionFunction(
+      pCruiseOptions,
+      pFileName,
+    );
+    lDependencies = lExtractionFunction(
+      pCruiseOptions,
+      pFileName,
+      pTranspileOptions,
+    );
   }
 
   return lDependencies.map((pDependency) => ({

package/src/extract/extract-stats.mjs

@@ -0,0 +1,48 @@
+import {
+  getStats as tscStats,
+  shouldUse as tscShouldUse,
+} from "./tsc/extract.mjs";
+import { getStats as acornStats } from "./acorn/extract.mjs";
+
+/**
+ * @param {IStrictCruiseOptions} pCruiseOptions
+ * @param {string} pFileName
+ * @returns {(IStrictCruiseOptions, string, any) => import("../../types/cruise-result.mjs").IDependency[]}
+ */
+function determineExtractionFunction(pCruiseOptions, pFileName) {
+  let lExtractionFunction = acornStats;
+
+  if (tscShouldUse(pCruiseOptions, pFileName)) {
+    lExtractionFunction = tscStats;
+  }
+
+  return lExtractionFunction;
+}
+
+/**
+ * Returns some stats for the module in pFileName
+ *
+ * @param  {string} pFileName path to the file
+ * @param  {import("../../types/dependency-cruiser.js").IStrictCruiseOptions} pCruiseOptions cruise options
+ * @param  {import("../../types/dependency-cruiser.js").ITranspileOptions} pTranspileOptions       an object with tsconfig ('typescript project') options
+ *                               ('flattened' so there's no need for file access on any
+ *                               'extends' option in there)
+ * @return {import("../../types/dependency-cruiser.js").IDependency[]} an array of dependency objects (see above)
+ */
+export default function extractStats(
+  pFileName,
+  pCruiseOptions,
+  pTranspileOptions,
+) {
+  try {
+    return determineExtractionFunction(pCruiseOptions, pFileName)(
+      pCruiseOptions,
+      pFileName,
+      pTranspileOptions,
+    );
+  } catch (pError) {
+    throw new Error(
+      `Extracting stats ran afoul of...\n\n  ${pError.message}\n... in ${pFileName}\n\n`,
+    );
+  }
+}

package/src/extract/helpers.mjs

@@ -1,3 +1,5 @@
+import { extname } from "node:path";
+
 export function dependenciesEqual(pLeftDependency) {
   // As we're using this to compare (typescript) pre-compilation dependencies
   // with post-compilation dependencies we do not consider the moduleSystem.
@@ -77,6 +79,23 @@ export function extractModuleAttributes(pString) {
  */
 export function stripQueryParameters(pFilenameString) {
   // url.parse(pFilenameString).pathname did this quite admirably, but it's
-  // deprecated, hence this fonky RE replace. And accompanying unit test :-/
+  // deprecated, hence this funky RE replace. And accompanying unit test :-/
   return pFilenameString.replace(/\?.+$/, "");
 }
+/**
+ * Returns true if the file name has a TypeScript compatible extension
+ * @param {string} pFileName
+ * @returns {boolean}
+ */
+export function isTypeScriptCompatible(pFileName) {
+  return [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".mjs",
+    ".cjs",
+    ".vue",
+  ].includes(extname(pFileName));
+}

package/src/extract/index.mjs

@@ -1,9 +1,10 @@
-import getDependencies from "./get-dependencies.mjs";
+import extractDependencies from "./extract-dependencies.mjs";
+import extractStats from "./extract-stats.mjs";
 import gatherInitialSources from "./gather-initial-sources.mjs";
 import clearCaches from "./clear-caches.mjs";
 import { bus } from "#utl/bus.mjs";
 
-/* eslint max-params:0 */
+/* eslint max-params:0 , max-lines-per-function:0*/
 function extractRecursive(
   pFileName,
   pCruiseOptions,
@@ -15,7 +16,7 @@ function extractRecursive(
   pVisited.add(pFileName);
   const lDependencies =
     pCruiseOptions.maxDepth <= 0 || pDepth < pCruiseOptions.maxDepth
-      ? getDependencies(
+      ? extractDependencies(
           pFileName,
           pCruiseOptions,
           pResolveOptions,
@@ -46,6 +47,15 @@ function extractRecursive(
       [
         {
           source: pFileName,
+          ...(pCruiseOptions.experimentalStats
+            ? {
+                experimentalStats: extractStats(
+                  pFileName,
+                  pCruiseOptions,
+                  pTranspileOptions,
+                ),
+              }
+            : {}),
           dependencies: lDependencies,
         },
       ],

package/src/extract/resolve/merge-manifests.mjs

@@ -1,3 +1,5 @@
+import { uniq } from "#utl/array-util.mjs";
+
 /* eslint-disable security/detect-object-injection */
 function normalizeManifestKeys(pManifest) {
   let lReturnValue = pManifest;
@@ -19,9 +21,7 @@ function mergeDependencyKey(pClosestDependencyKey, pFurtherDependencyKey) {
 }
 
 function mergeDependencyArray(pClosestDependencyKey, pFurtherDependencyKey) {
-  return Array.from(
-    new Set(pClosestDependencyKey.concat(pFurtherDependencyKey)),
-  );
+  return uniq(pClosestDependencyKey.concat(pFurtherDependencyKey));
 }
 
 function isInterestingKey(pKey) {
@@ -35,11 +35,9 @@ function getDependencyKeys(pPackage) {
 }
 
 function getJointUniqueDependencyKeys(pClosestPackage, pFurtherPackage) {
-  return Array.from(
-    new Set(
-      getDependencyKeys(pClosestPackage).concat(
-        getDependencyKeys(pFurtherPackage),
-      ),
+  return uniq(
+    getDependencyKeys(pClosestPackage).concat(
+      getDependencyKeys(pFurtherPackage),
     ),
   );
 }

package/src/extract/{ast-extractors → swc}/extract-swc-deps.mjs

@@ -1,4 +1,4 @@
-import SwcDependencyVisitor from "./swc-dependency-visitor.mjs";
+import SwcDependencyVisitor from "./dependency-visitor.mjs";
 
 /**
  * @param {import('@swc/core').ModuleItem[]} pSwcAST

package/src/extract/swc/extract.mjs

@@ -0,0 +1,20 @@
+import { join } from "node:path/posix";
+import { isTypeScriptCompatible } from "../helpers.mjs";
+import extractSwcDeps from "./extract-swc-deps.mjs";
+import parse from "./parse.mjs";
+
+export function shouldUse({ parser }, pFileName) {
+  return (
+    parser === "swc" && parse.isAvailable() && isTypeScriptCompatible(pFileName)
+  );
+}
+
+export function extract(
+  { baseDir, exoticRequireStrings, moduleSystems },
+  pFileName,
+) {
+  return extractSwcDeps(
+    parse.getASTCached(join(baseDir, pFileName)),
+    exoticRequireStrings,
+  ).filter(({ moduleSystem }) => moduleSystems.includes(moduleSystem));
+}

package/src/extract/transpile/index.mjs

@@ -35,7 +35,7 @@ export const EXTENSION2WRAPPER = new Map([
   [".cjsx", coffeeVanillaWrap],
 ]);
 
-const BABELEABLE_EXTENSIONS = [
+const BABEL_ABLE_EXTENSIONS = [
   ".js",
   ".cjs",
   ".mjs",
@@ -47,7 +47,7 @@ const BABELEABLE_EXTENSIONS = [
 
 /**
  * returns the babel wrapper if there's a babelConfig in the transpiler
- * options for babeleable extensions (javascript and typescript - currently
+ * options for babel-  able extensions (javascript and typescript - currently
  * not configurable)
  *
  * returns the wrapper module configured for the extension pExtension if
@@ -63,7 +63,7 @@ const BABELEABLE_EXTENSIONS = [
 export function getWrapper(pExtension, pTranspilerOptions) {
   if (
     Object.keys(pTranspilerOptions?.babelConfig ?? {}).length > 0 &&
-    BABELEABLE_EXTENSIONS.includes(pExtension)
+    BABEL_ABLE_EXTENSIONS.includes(pExtension)
   ) {
     return babelWrap;
   }

package/src/extract/tsc/extract-stats.mjs

@@ -0,0 +1,6 @@
+export default function extractStats(pAST) {
+  return {
+    topLevelStatementCount: pAST?.statements?.length || 0,
+    size: pAST?.end || 0,
+  };
+}

package/src/extract/tsc/extract.mjs

@@ -0,0 +1,29 @@
+import { join } from "node:path";
+import { isTypeScriptCompatible } from "../helpers.mjs";
+import extractTypeScriptDeps from "./extract-typescript-deps.mjs";
+import parse from "./parse.mjs";
+import extractStats from "./extract-stats.mjs";
+
+export function shouldUse({ tsPreCompilationDeps, parser }, pFileName) {
+  return (
+    (tsPreCompilationDeps || parser === "tsc") &&
+    parse.isAvailable() &&
+    isTypeScriptCompatible(pFileName)
+  );
+}
+
+export function extract(
+  { baseDir, exoticRequireStrings, moduleSystems },
+  pFileName,
+  pTranspileOptions,
+) {
+  return extractTypeScriptDeps(
+    parse.getASTCached(join(baseDir, pFileName), pTranspileOptions),
+    exoticRequireStrings,
+  ).filter(({ moduleSystem }) => moduleSystems.includes(moduleSystem));
+}
+
+export function getStats({ baseDir }, pFileName, pTranspileOptions) {
+  const lAST = parse.getASTCached(join(baseDir, pFileName), pTranspileOptions);
+  return extractStats(lAST);
+}

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

@@ -1,16 +1,13 @@
 import reject from "lodash/reject.js";
 import compare from "./compare.mjs";
+import { uniq } from "#utl/array-util.mjs";
 
 function mergeDependency(pLeftDependency, pRightDependency) {
   return {
     ...pLeftDependency,
     ...pRightDependency,
-    dependencyTypes: Array.from(
-      new Set(
-        pLeftDependency.dependencyTypes.concat(
-          pRightDependency.dependencyTypes,
-        ),
-      ),
+    dependencyTypes: uniq(
+      pLeftDependency.dependencyTypes.concat(pRightDependency.dependencyTypes),
     ),
     rules: pLeftDependency.rules
       .concat(pRightDependency?.rules ?? [])

package/src/graph-utl/rule-set.mjs

@@ -10,9 +10,10 @@
  * @return {import("../../types/rule-set").IForbiddenRuleType|undefined} - a rule (or 'undefined' if nothing found)
  */
 export function findRuleByName(pRuleSet, pName) {
-  return (pRuleSet?.forbidden ?? []).find(
-    (pForbiddenRule) => pForbiddenRule.name === pName,
+  const lNamedRules = (pRuleSet?.forbidden ?? []).concat(
+    pRuleSet?.required ?? [],
   );
+  return lNamedRules.find((pRule) => pRule.name === pName);
 }
 
 function ruleHasALicenseLikeAttribute(pRule) {

package/src/main/options/normalize.mjs

@@ -1,14 +1,11 @@
 /* eslint-disable security/detect-object-injection */
 import { normalizeREProperties } from "../helpers.mjs";
 import defaults from "./defaults.mjs";
+import { uniq } from "#utl/array-util.mjs";
 
 const DEFAULT_CACHE_FOLDER = "node_modules/.cache/dependency-cruiser";
 const DEFAULT_CACHE_STRATEGY = "metadata";
 
-function uniq(pArray) {
-  return [...new Set(pArray)];
-}
-
 function normalizeFilterOption(pFilterOption) {
   let lReturnValue = pFilterOption || {};