dependency-cruiser 16.4.1 → 16.4.2

package/src/report/dot/prepare-folder-level.mjs

@@ -1,14 +1,16 @@
-import moduleUtl from "./module-utl.mjs";
+import { folderify, extractFirstTransgression, addURL } from "./module-utl.mjs";
+import { applyTheme } from "./theming.mjs";
 import consolidateToFolder from "#graph-utl/consolidate-to-folder.mjs";
-import compare from "#graph-utl/compare.mjs";
+import { compareModules } from "#graph-utl/compare.mjs";
 import stripSelfTransitions from "#graph-utl/strip-self-transitions.mjs";
+// fuk eslint
 
 export default function prepareFolderLevel(pResults, pTheme, _, pShowMetrics) {
   return consolidateToFolder(pResults.modules)
-    .sort(compare.modules)
-    .map(moduleUtl.extractFirstTransgression)
-    .map(moduleUtl.folderify(pShowMetrics))
+    .sort(compareModules)
+    .map(extractFirstTransgression)
+    .map(folderify(pShowMetrics))
     .map(stripSelfTransitions)
-    .map(moduleUtl.applyTheme(pTheme))
-    .map(moduleUtl.addURL(pResults.summary.optionsUsed?.prefix ?? ""));
+    .map(applyTheme(pTheme))
+    .map(addURL(pResults.summary.optionsUsed?.prefix ?? ""));
 }

package/src/report/dot/theming.mjs

@@ -1,4 +1,5 @@
 import DEFAULT_THEME from "./default-theme.mjs";
+import { attributizeObject } from "./module-utl.mjs";
 import { has, get } from "#utl/object-util.mjs";
 
 function matchesRE(pValue, pRE) {
@@ -48,7 +49,7 @@ function moduleOrDependencyMatchesCriteria(pSchemeEntry, pModule) {
   });
 }
 
-function determineAttributes(pModuleOrDependency, pAttributeCriteria) {
+export function getThemeAttributes(pModuleOrDependency, pAttributeCriteria) {
   return (pAttributeCriteria || [])
     .filter((pSchemeEntry) =>
       moduleOrDependencyMatchesCriteria(pSchemeEntry, pModuleOrDependency),
@@ -57,7 +58,7 @@ function determineAttributes(pModuleOrDependency, pAttributeCriteria) {
     .reduce((pAll, pCurrent) => ({ ...pCurrent, ...pAll }), {});
 }
 
-function normalizeTheme(pTheme) {
+export function normalizeTheme(pTheme) {
   let lReturnValue = structuredClone(DEFAULT_THEME);
 
   if (pTheme) {
@@ -78,7 +79,20 @@ function normalizeTheme(pTheme) {
   return lReturnValue;
 }
 
-export default {
-  normalizeTheme,
-  determineAttributes,
-};
+export function applyTheme(pTheme) {
+  return (pModule) => ({
+    ...pModule,
+    dependencies: pModule.dependencies
+      .map((pDependency) => ({
+        ...pDependency,
+        themeAttrs: attributizeObject(
+          getThemeAttributes(pDependency, pTheme.dependencies),
+        ),
+      }))
+      .map((pDependency) => ({
+        ...pDependency,
+        hasExtraAttributes: Boolean(pDependency.rule || pDependency.themeAttrs),
+      })),
+    themeAttrs: attributizeObject(getThemeAttributes(pModule, pTheme.modules)),
+  });
+}

package/src/report/error-html/utl.mjs

@@ -1,7 +1,7 @@
 import { formatViolation, formatPercentage } from "../utl/index.mjs";
 import meta from "#meta.cjs";
 
-function getFormattedAllowedRule(pRuleSetUsed) {
+export function getFormattedAllowedRule(pRuleSetUsed) {
   const lAllowed = pRuleSetUsed?.allowed ?? [];
   const lCommentedRule = lAllowed.find((pRule) =>
     Object.hasOwn(pRule, "comment"),
@@ -17,7 +17,7 @@ function getFormattedAllowedRule(pRuleSetUsed) {
     : [];
 }
 
-function mergeCountsIntoRule(pRule, pViolationCounts) {
+export function mergeCountsIntoRule(pRule, pViolationCounts) {
   const lCounts = pViolationCounts[pRule.name]
     ? pViolationCounts[pRule.name]
     : { count: 0, ignoredCount: 0 };
@@ -138,12 +138,3 @@ export function aggregateViolations(pViolations, pRuleSetUsed) {
         pFirst.name.localeCompare(pSecond.name),
     );
 }
-
-export default {
-  aggregateViolations,
-  getFormattedAllowedRule,
-  mergeCountsIntoRule,
-  formatSummaryForReport,
-  determineFromExtras,
-  determineTo,
-};

package/src/report/index.mjs

@@ -35,7 +35,7 @@ const TYPE2MODULE = new Map([
  *                       an options object (specific to that function)
  *                       and returns an IReporterOutput
  */
-async function getReporter(pOutputType) {
+export async function getReporter(pOutputType) {
   let lReturnValue = {};
   if (pOutputType?.startsWith("plugin:")) {
     lReturnValue = await getExternalPluginReporter(pOutputType);
@@ -52,11 +52,6 @@ async function getReporter(pOutputType) {
  *
  * @returns {import("../../types/shared-types.js").OutputType[]} -
  */
-function getAvailableReporters() {
+export function getAvailableReporters() {
   return Array.from(TYPE2MODULE.keys());
 }
-
-export default {
-  getAvailableReporters,
-  getReporter,
-};

package/src/report/markdown.mjs

@@ -1,8 +1,10 @@
-import errorHtmlUtl from "./error-html/utl.mjs";
+import {
+  aggregateViolations,
+  determineTo,
+  determineFromExtras,
+} from "./error-html/utl.mjs";
 import meta from "#meta.cjs";
 
-const { aggregateViolations, determineTo, determineFromExtras } = errorHtmlUtl;
-
 const REPORT_DEFAULTS = {
   showTitle: true,
   title: "## Forbidden dependency check - results",

package/src/utl/regex-util.mjs

@@ -23,7 +23,7 @@ export function extractGroups(pFromRestriction, pActualPath) {
 
     if (lMatchResult && lMatchResult.length > 1) {
       lReturnValue = lMatchResult.filter(
-        (pResult) => typeof pResult === "string"
+        (pResult) => typeof pResult === "string",
       );
     }
   }
@@ -51,11 +51,6 @@ export function replaceGroupPlaceholders(pString, pExtractedGroups) {
     (pAll, pThis, pIndex) =>
       // eslint-disable-next-line security/detect-non-literal-regexp
       pAll.replace(new RegExp(`\\$${pIndex}`, "g"), pThis),
-    pString
+    pString,
   );
 }
-
-export default {
-  extractGroups,
-  replaceGroupPlaceholders,
-};

package/src/validate/index.mjs

@@ -89,22 +89,19 @@ function validateAgainstRules(pRuleSet, pFrom, pTo, pMatchModule) {
   }
   return lReturnValue;
 }
+export function validateModule(pRuleSet, pModule) {
+  return validateAgainstRules(pRuleSet, pModule, {}, matchModuleRule);
+}
 
-export default {
-  module: function module(pRuleSet, pModule) {
-    return validateAgainstRules(pRuleSet, pModule, {}, matchModuleRule);
-  },
-
-  dependency: function dependency(pRuleSet, pFrom, pTo) {
-    return validateAgainstRules(pRuleSet, pFrom, pTo, matchDependencyRule);
-  },
+export function validateDependency(pRuleSet, pFrom, pTo) {
+  return validateAgainstRules(pRuleSet, pFrom, pTo, matchDependencyRule);
+}
 
-  folder: function folder(pRuleSet, pFromFolder, pToFolder) {
-    return validateAgainstRules(
-      pRuleSet,
-      pFromFolder,
-      pToFolder,
-      matchFolderRule,
-    );
-  },
-};
+export function validateFolder(pRuleSet, pFromFolder, pToFolder) {
+  return validateAgainstRules(
+    pRuleSet,
+    pFromFolder,
+    pToFolder,
+    matchFolderRule,
+  );
+}

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

@@ -1,6 +1,20 @@
 // @ts-check
 import { isModuleOnlyRule, isFolderScope } from "./rule-classifiers.mjs";
-import matchers from "./matchers.mjs";
+import {
+  propertyEquals,
+  propertyMatches,
+  propertyMatchesNot,
+  matchesFromPath,
+  matchesFromPathNot,
+  matchesToPath,
+  matchesToPathNot,
+  matchesToDependencyTypes,
+  matchesToDependencyTypesNot,
+  matchesToVia,
+  matchesToViaOnly,
+  matchesToIsMoreUnstable,
+  matchesMoreThanOneDependencyType,
+} from "./matchers.mjs";
 import { extractGroups } from "#utl/regex-util.mjs";
 
 /**
@@ -15,34 +29,29 @@ function match(pFrom, pTo) {
     const lGroups = extractGroups(pRule.from, pFrom.source);
 
     return (
-      matchers.fromPath(pRule, pFrom) &&
-      matchers.fromPathNot(pRule, pFrom) &&
-      matchers.toPath(pRule, pTo, lGroups) &&
-      matchers.toPathNot(pRule, pTo, lGroups) &&
-      matchers.toDependencyTypes(pRule, pTo) &&
-      matchers.toDependencyTypesNot(pRule, pTo) &&
-      matchers.matchesMoreThanOneDependencyType(pRule, pTo) &&
+      matchesFromPath(pRule, pFrom) &&
+      matchesFromPathNot(pRule, pFrom) &&
+      matchesToPath(pRule, pTo, lGroups) &&
+      matchesToPathNot(pRule, pTo, lGroups) &&
+      matchesToDependencyTypes(pRule, pTo) &&
+      matchesToDependencyTypesNot(pRule, pTo) &&
+      matchesMoreThanOneDependencyType(pRule, pTo) &&
       // preCompilationOnly is not a mandatory attribute, but if the attribute
       // is in the rule but not in the dependency there won't be a match
       // anyway, so we can use the default propertyEquals method regardless
-      matchers.propertyEquals(pRule, pTo, "preCompilationOnly") &&
+      propertyEquals(pRule, pTo, "preCompilationOnly") &&
       // couldNotResolve, circular, dynamic and exoticallyRequired _are_ mandatory
-      matchers.propertyEquals(pRule, pTo, "couldNotResolve") &&
-      matchers.propertyEquals(pRule, pTo, "circular") &&
-      matchers.propertyEquals(pRule, pTo, "dynamic") &&
-      matchers.propertyEquals(pRule, pTo, "exoticallyRequired") &&
-      matchers.propertyMatches(pRule, pTo, "license", "license") &&
-      matchers.propertyMatchesNot(pRule, pTo, "licenseNot", "license") &&
-      matchers.propertyMatches(pRule, pTo, "exoticRequire", "exoticRequire") &&
-      matchers.propertyMatchesNot(
-        pRule,
-        pTo,
-        "exoticRequireNot",
-        "exoticRequire",
-      ) &&
-      matchers.toVia(pRule, pTo, lGroups) &&
-      matchers.toViaOnly(pRule, pTo, lGroups) &&
-      matchers.toIsMoreUnstable(pRule, pFrom, pTo)
+      propertyEquals(pRule, pTo, "couldNotResolve") &&
+      propertyEquals(pRule, pTo, "circular") &&
+      propertyEquals(pRule, pTo, "dynamic") &&
+      propertyEquals(pRule, pTo, "exoticallyRequired") &&
+      propertyMatches(pRule, pTo, "license", "license") &&
+      propertyMatchesNot(pRule, pTo, "licenseNot", "license") &&
+      propertyMatches(pRule, pTo, "exoticRequire", "exoticRequire") &&
+      propertyMatchesNot(pRule, pTo, "exoticRequireNot", "exoticRequire") &&
+      matchesToVia(pRule, pTo, lGroups) &&
+      matchesToViaOnly(pRule, pTo, lGroups) &&
+      matchesToIsMoreUnstable(pRule, pFrom, pTo)
     );
   };
 }

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

@@ -1,5 +1,5 @@
 import { isModuleOnlyRule, isFolderScope } from "./rule-classifiers.mjs";
-import matchers from "./matchers.mjs";
+import { propertyEquals, matchesToIsMoreUnstable } from "./matchers.mjs";
 import { extractGroups, replaceGroupPlaceholders } from "#utl/regex-util.mjs";
 
 function fromFolderPath(pRule, pFromFolder) {
@@ -44,8 +44,8 @@ function match(pFromFolder, pToFolder) {
       fromFolderPathNot(pRule, pFromFolder) &&
       toFolderPath(pRule, pToFolder, lGroups) &&
       toFolderPathNot(pRule, pToFolder, lGroups) &&
-      matchers.toIsMoreUnstable(pRule, pFromFolder, pToFolder) &&
-      matchers.propertyEquals(pRule, pToFolder, "circular")
+      matchesToIsMoreUnstable(pRule, pFromFolder, pToFolder) &&
+      propertyEquals(pRule, pToFolder, "circular")
     );
   };
 }

package/src/validate/match-module-rule-helpers.mjs

@@ -0,0 +1,132 @@
+import {
+  matchToModulePath,
+  matchToModulePathNot,
+  matchesFromPath,
+  matchesFromPathNot,
+  matchesModulePath,
+  matchesModulePathNot,
+} from "./matchers.mjs";
+import { extractGroups } from "#utl/regex-util.mjs";
+/**
+ * Returns true if pRule is an orphan rule and pModule is an orphan.
+ * Returns false in all other cases
+ *
+ * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
+ * @param {import("../../types/cruise-result.mjs").IModule} pModule
+ * @returns {boolean}
+ */
+export function matchesOrphanRule(pRule, pModule) {
+  return (
+    Object.hasOwn(pRule?.from ?? {}, "orphan") &&
+    // @ts-expect-error the 'hasOwn' above guarantees there's a 'from.orphan' attribute
+    pModule.orphan === pRule.from.orphan &&
+    matchesFromPath(pRule, pModule) &&
+    matchesFromPathNot(pRule, pModule)
+  );
+}
+
+/**
+ * Returns true if pRule is a 'reachable' rule and pModule matches the reachability
+ * criteria.
+ * Returns false in all other cases
+ *
+ * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
+ * @param {import("../../types/cruise-result.mjs").IModule} pModule
+ * @returns {boolean}
+ */
+export function matchesReachableRule(pRule, pModule) {
+  if (
+    Object.hasOwn(pRule?.to ?? {}, "reachable") &&
+    Object.hasOwn(pModule, "reachable")
+  ) {
+    // @ts-expect-error the 'hasOwn' above ensures the 'reachable' exists
+    const lReachableRecord = pModule.reachable.find(
+      (pReachable) =>
+        pReachable.asDefinedInRule === pRule.name &&
+        // @ts-expect-error the 'hasOwn' above ensures the 'to.reachable' exists
+        pReachable.value === pRule.to.reachable,
+    );
+    if (lReachableRecord) {
+      const lGroups = extractGroups(pRule.from, lReachableRecord.matchedFrom);
+
+      return (
+        matchToModulePath(pRule, pModule, lGroups) &&
+        matchToModulePathNot(pRule, pModule, lGroups)
+      );
+    }
+  }
+  return false;
+}
+
+/**
+ * Returns true if pRule is a 'reaches' rule and pModule matches the reachability
+ * criteria.
+ * Returns false in all other cases
+ *
+ * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
+ * @param {import("../../types/cruise-result.mjs").IModule} pModule
+ * @returns {boolean}
+ */
+export function matchesReachesRule(pRule, pModule) {
+  return (
+    Object.hasOwn(pRule?.to ?? {}, "reachable") &&
+    Object.hasOwn(pModule, "reaches") &&
+    // @ts-expect-error the 'hasOwn' above guarantees the .reaches exists
+    pModule.reaches.some(
+      (pReaches) =>
+        pReaches.asDefinedInRule === pRule.name &&
+        pReaches.modules.some(
+          (pReachesModule) =>
+            matchToModulePath(pRule, pReachesModule) &&
+            matchToModulePathNot(pRule, pReachesModule),
+        ),
+    )
+  );
+}
+/**
+ *
+ * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
+ * @param {string[]} pDependents
+ * @returns {boolean}
+ */
+function dependentsCountsMatch(pRule, pDependents) {
+  const lMatchingDependentsCount = pDependents.filter(
+    (pDependent) =>
+      Boolean(!pRule.from.path || pDependent.match(pRule.from.path)) &&
+      Boolean(!pRule.from.pathNot || !pDependent.match(pRule.from.pathNot)),
+  ).length;
+  return (
+    (!pRule.module.numberOfDependentsLessThan ||
+      lMatchingDependentsCount < pRule.module.numberOfDependentsLessThan) &&
+    (!pRule.module.numberOfDependentsMoreThan ||
+      lMatchingDependentsCount > pRule.module.numberOfDependentsMoreThan)
+  );
+}
+
+/**
+ *
+ * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
+ * @param {import("../../types/cruise-result.mjs").IModule} pModule
+ * @returns {boolean}
+ */
+// eslint-disable-next-line complexity
+export function matchesDependentsRule(pRule, pModule) {
+  if (
+    (Object.hasOwn(pModule, "dependents") &&
+      Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsLessThan")) ||
+    Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsMoreThan")
+  ) {
+    return (
+      // group matching seems like a nice idea, however, the 'from' part of the
+      // rule is going to match not one module (as with regular dependency rules)
+      // but a whole bunch of them, being the 'dependents'. So that match is going
+      // to produce not one result, but one per matching dependent. To get meaningful
+      // results we'd probably have to loop over these and or the
+      // matchToModulePath together.
+      matchesModulePath(pRule, pModule) &&
+      matchesModulePathNot(pRule, pModule) &&
+      dependentsCountsMatch(pRule, pModule.dependents)
+    );
+  }
+  return false;
+}

package/src/validate/match-module-rule.mjs

@@ -1,130 +1,10 @@
 import { isModuleOnlyRule, isFolderScope } from "./rule-classifiers.mjs";
-import matchers from "./matchers.mjs";
-import { extractGroups } from "#utl/regex-util.mjs";
-
-/**
- * Returns true if pRule is an orphan rule and pModule is an orphan.
- * Returns false in all other cases
- *
- * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
- * @param {import("../../types/cruise-result.mjs").IModule} pModule
- * @returns {boolean}
- */
-function matchesOrphanRule(pRule, pModule) {
-  return (
-    Object.hasOwn(pRule?.from ?? {}, "orphan") &&
-    // @ts-expect-error the 'hasOwn' above guarantees there's a 'from.orphan' attribute
-    pModule.orphan === pRule.from.orphan &&
-    matchers.fromPath(pRule, pModule) &&
-    matchers.fromPathNot(pRule, pModule)
-  );
-}
-
-/**
- * Returns true if pRule is a 'reachable' rule and pModule matches the reachability
- * criteria.
- * Returns false in all other cases
- *
- * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
- * @param {import("../../types/cruise-result.mjs").IModule} pModule
- * @returns {boolean}
- */
-function matchesReachableRule(pRule, pModule) {
-  if (
-    Object.hasOwn(pRule?.to ?? {}, "reachable") &&
-    Object.hasOwn(pModule, "reachable")
-  ) {
-    // @ts-expect-error the 'hasOwn' above ensures the 'reachable' exists
-    const lReachableRecord = pModule.reachable.find(
-      (pReachable) =>
-        pReachable.asDefinedInRule === pRule.name &&
-        // @ts-expect-error the 'hasOwn' above ensures the 'to.reachable' exists
-        pReachable.value === pRule.to.reachable,
-    );
-    if (lReachableRecord) {
-      const lGroups = extractGroups(pRule.from, lReachableRecord.matchedFrom);
-
-      return (
-        matchers.toModulePath(pRule, pModule, lGroups) &&
-        matchers.toModulePathNot(pRule, pModule, lGroups)
-      );
-    }
-  }
-  return false;
-}
-
-/**
- * Returns true if pRule is a 'reaches' rule and pModule matches the reachability
- * criteria.
- * Returns false in all other cases
- *
- * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
- * @param {import("../../types/cruise-result.mjs").IModule} pModule
- * @returns {boolean}
- */
-function matchesReachesRule(pRule, pModule) {
-  return (
-    Object.hasOwn(pRule?.to ?? {}, "reachable") &&
-    Object.hasOwn(pModule, "reaches") &&
-    // @ts-expect-error the 'hasOwn' above guarantees the .reaches exists
-    pModule.reaches.some(
-      (pReaches) =>
-        pReaches.asDefinedInRule === pRule.name &&
-        pReaches.modules.some(
-          (pReachesModule) =>
-            matchers.toModulePath(pRule, pReachesModule) &&
-            matchers.toModulePathNot(pRule, pReachesModule),
-        ),
-    )
-  );
-}
-/**
- *
- * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
- * @param {string[]} pDependents
- * @returns {boolean}
- */
-function dependentsCountsMatch(pRule, pDependents) {
-  const lMatchingDependentsCount = pDependents.filter(
-    (pDependent) =>
-      Boolean(!pRule.from.path || pDependent.match(pRule.from.path)) &&
-      Boolean(!pRule.from.pathNot || !pDependent.match(pRule.from.pathNot)),
-  ).length;
-  return (
-    (!pRule.module.numberOfDependentsLessThan ||
-      lMatchingDependentsCount < pRule.module.numberOfDependentsLessThan) &&
-    (!pRule.module.numberOfDependentsMoreThan ||
-      lMatchingDependentsCount > pRule.module.numberOfDependentsMoreThan)
-  );
-}
-
-/**
- *
- * @param {import("../../types/rule-set.mjs").IAnyRuleType} pRule
- * @param {import("../../types/cruise-result.mjs").IModule} pModule
- * @returns {boolean}
- */
-// eslint-disable-next-line complexity
-function matchesDependentsRule(pRule, pModule) {
-  if (
-    (Object.hasOwn(pModule, "dependents") &&
-      Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsLessThan")) ||
-    Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsMoreThan")
-  ) {
-    return (
-      // group matching seems like a nice idea, however, the 'from' part of the
-      // rule is going to match not one module (as with regular dependency rules)
-      // but a whole bunch of them, being the 'dependents'. So that match is going
-      // to produce not one result, but one per matching dependent. To get meaningful
-      // results we'd probably have to loop over these and or the
-      // matchers.toModulePath together.
-      matchers.modulePath(pRule, pModule) &&
-      matchers.modulePathNot(pRule, pModule) &&
-      dependentsCountsMatch(pRule, pModule.dependents)
-    );
-  }
-  return false;
-}
+import {
+  matchesOrphanRule,
+  matchesReachableRule,
+  matchesReachesRule,
+  matchesDependentsRule,
+} from "./match-module-rule-helpers.mjs";
 
 /**
  *
@@ -148,10 +28,6 @@ const isInteresting = (pRule) =>
   isModuleOnlyRule(pRule) && !isFolderScope(pRule);
 
 export default {
-  matchesOrphanRule,
-  matchesReachableRule,
-  matchesReachesRule,
-  matchesDependentsRule,
   match,
   isInteresting,
 };