dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/enrich/soften-known-violations.mjs

@@ -2,62 +2,62 @@ import isSameViolation from "./summarize/is-same-violation.mjs";
 import { bus } from "#utl/bus.mjs";
 
 function softenModuleViolation(
-  pRule,
-  pModuleSource,
-  pKnownModuleViolations,
-  pSoftenedSeverity,
+	pRule,
+	pModuleSource,
+	pKnownModuleViolations,
+	pSoftenedSeverity,
 ) {
-  return {
-    ...pRule,
-    severity: pKnownModuleViolations.some(
-      (pKnownError) =>
-        pKnownError.from === pModuleSource &&
-        pKnownError.rule.name === pRule.name,
-    )
-      ? pSoftenedSeverity
-      : pRule.severity,
-  };
+	return {
+		...pRule,
+		severity: pKnownModuleViolations.some(
+			(pKnownError) =>
+				pKnownError.from === pModuleSource &&
+				pKnownError.rule.name === pRule.name,
+		)
+			? pSoftenedSeverity
+			: pRule.severity,
+	};
 }
 
 function softenDependencyViolation(
-  pViolationKey,
-  pKnownDependencyViolations,
-  pSoftenedSeverity,
+	pViolationKey,
+	pKnownDependencyViolations,
+	pSoftenedSeverity,
 ) {
-  return {
-    ...pViolationKey.rule,
-    severity: pKnownDependencyViolations.some((pKnownError) =>
-      isSameViolation(pKnownError, pViolationKey),
-    )
-      ? pSoftenedSeverity
-      : pViolationKey.rule.severity,
-  };
+	return {
+		...pViolationKey.rule,
+		severity: pKnownDependencyViolations.some((pKnownError) =>
+			isSameViolation(pKnownError, pViolationKey),
+		)
+			? pSoftenedSeverity
+			: pViolationKey.rule.severity,
+	};
 }
 
 function softenDependencyViolations(
-  pDependency,
-  pModuleSource,
-  pKnownDependencyViolations,
-  pSoftenedSeverity,
+	pDependency,
+	pModuleSource,
+	pKnownDependencyViolations,
+	pSoftenedSeverity,
 ) {
-  if (!pDependency.valid) {
-    return {
-      ...pDependency,
-      rules: pDependency.rules.map((pRule) =>
-        softenDependencyViolation(
-          {
-            rule: pRule,
-            from: pModuleSource,
-            to: pDependency.resolved,
-            cycle: pDependency.cycle,
-          },
-          pKnownDependencyViolations,
-          pSoftenedSeverity,
-        ),
-      ),
-    };
-  }
-  return pDependency;
+	if (!pDependency.valid) {
+		return {
+			...pDependency,
+			rules: pDependency.rules.map((pRule) =>
+				softenDependencyViolation(
+					{
+						rule: pRule,
+						from: pModuleSource,
+						to: pDependency.resolved,
+						cycle: pDependency.cycle,
+					},
+					pKnownDependencyViolations,
+					pSoftenedSeverity,
+				),
+			),
+		};
+	}
+	return pDependency;
 }
 
 /**
@@ -68,43 +68,43 @@ function softenDependencyViolations(
  * @returns {import("../../types/cruise-result.mjs").IModule}
  */
 function softenKnownViolation(pModule, pKnownViolations, pSoftenedSeverity) {
-  let lReturnValue = pModule;
+	let lReturnValue = pModule;
 
-  if (!pModule.valid) {
-    lReturnValue = {
-      ...pModule,
-      rules: pModule.rules.map((pRule) =>
-        softenModuleViolation(
-          pRule,
-          pModule.source,
-          pKnownViolations.filter((pKnownViolation) =>
-            ["module", "reachability"].includes(pKnownViolation.type),
-          ),
-          pSoftenedSeverity,
-        ),
-      ),
-    };
-  }
+	if (!pModule.valid) {
+		lReturnValue = {
+			...pModule,
+			rules: pModule.rules.map((pRule) =>
+				softenModuleViolation(
+					pRule,
+					pModule.source,
+					pKnownViolations.filter((pKnownViolation) =>
+						["module", "reachability"].includes(pKnownViolation.type),
+					),
+					pSoftenedSeverity,
+				),
+			),
+		};
+	}
 
-  lReturnValue = {
-    ...lReturnValue,
-    dependencies: pModule.dependencies.map((pDependency) =>
-      softenDependencyViolations(
-        pDependency,
-        pModule.source,
-        pKnownViolations.filter((pKnownViolation) =>
-          ["dependency", "cycle", "instability"].includes(pKnownViolation.type),
-        ),
-        pSoftenedSeverity,
-      ),
-    ),
-  };
+	lReturnValue = {
+		...lReturnValue,
+		dependencies: pModule.dependencies.map((pDependency) =>
+			softenDependencyViolations(
+				pDependency,
+				pModule.source,
+				pKnownViolations.filter((pKnownViolation) =>
+					["dependency", "cycle", "instability"].includes(pKnownViolation.type),
+				),
+				pSoftenedSeverity,
+			),
+		),
+	};
 
-  // TODO: folder level violations (e.g. with 'instability' rules - these need
-  // to be softened within the "folders" node, which lives next to the "modules"
-  // one)
+	// TODO: folder level violations (e.g. with 'instability' rules - these need
+	// to be softened within the "folders" node, which lives next to the "modules"
+	// one)
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 /**
@@ -115,15 +115,15 @@ function softenKnownViolation(pModule, pKnownViolations, pSoftenedSeverity) {
  * @returns {import("../../types/cruise-result.mjs").IModule[]}
  */
 export default function softenKnownViolations(
-  pModules,
-  pKnownViolations,
-  pSoftenedSeverity = "ignore",
+	pModules,
+	pKnownViolations,
+	pSoftenedSeverity = "ignore",
 ) {
-  if (pKnownViolations) {
-    bus.info("analyze: compare to known errors");
-    return pModules.map((pModule) =>
-      softenKnownViolation(pModule, pKnownViolations, pSoftenedSeverity),
-    );
-  }
-  return pModules;
+	if (pKnownViolations) {
+		bus.info("analyze: compare to known errors");
+		return pModules.map((pModule) =>
+			softenKnownViolation(pModule, pKnownViolations, pSoftenedSeverity),
+		);
+	}
+	return pModules;
 }

package/src/enrich/summarize/add-rule-set-used.mjs

@@ -1,23 +1,23 @@
 // the fixed name for allowed rules served a purpose during the extraction
 // process - but it's not necessary to reflect it in the output.
 function removeNames(pRule) {
-  const lReturnValue = structuredClone(pRule);
+	const lReturnValue = structuredClone(pRule);
 
-  Reflect.deleteProperty(lReturnValue, "name");
-  return lReturnValue;
+	Reflect.deleteProperty(lReturnValue, "name");
+	return lReturnValue;
 }
 
 // eslint-disable-next-line complexity
 export default function addRuleSetUsed(pOptions) {
-  const lForbidden = pOptions?.ruleSet?.forbidden;
-  const lAllowed = pOptions?.ruleSet?.allowed;
-  const lAllowedSeverity = pOptions?.ruleSet?.allowedSeverity;
-  const lRequired = pOptions?.ruleSet?.required;
+	const lForbidden = pOptions?.ruleSet?.forbidden;
+	const lAllowed = pOptions?.ruleSet?.allowed;
+	const lAllowedSeverity = pOptions?.ruleSet?.allowedSeverity;
+	const lRequired = pOptions?.ruleSet?.required;
 
-  return Object.assign(
-    lForbidden ? { forbidden: lForbidden } : {},
-    lAllowed ? { allowed: lAllowed.map(removeNames) } : {},
-    lAllowedSeverity ? { allowedSeverity: lAllowedSeverity } : {},
-    lRequired ? { required: lRequired } : {},
-  );
+	return Object.assign(
+		lForbidden ? { forbidden: lForbidden } : {},
+		lAllowed ? { allowed: lAllowed.map(removeNames) } : {},
+		lAllowedSeverity ? { allowedSeverity: lAllowedSeverity } : {},
+		lRequired ? { required: lRequired } : {},
+	);
 }

package/src/enrich/summarize/get-stats.mjs

@@ -1,25 +1,25 @@
 export function getViolationStats(pViolations) {
-  return pViolations.reduce(
-    (pAll, pThis) => {
-      pAll[pThis.rule.severity] += 1;
-      return pAll;
-    },
-    {
-      error: 0,
-      warn: 0,
-      info: 0,
-      ignore: 0,
-    },
-  );
+	return pViolations.reduce(
+		(pAll, pThis) => {
+			pAll[pThis.rule.severity] += 1;
+			return pAll;
+		},
+		{
+			error: 0,
+			warn: 0,
+			info: 0,
+			ignore: 0,
+		},
+	);
 }
 
 export function getModulesCruised(pModules) {
-  return pModules.length;
+	return pModules.length;
 }
 
 export function getDependenciesCruised(pModules) {
-  return pModules.reduce(
-    (pAll, pModule) => pAll + pModule.dependencies.length,
-    0,
-  );
+	return pModules.reduce(
+		(pAll, pModule) => pAll + pModule.dependencies.length,
+		0,
+	);
 }

package/src/enrich/summarize/index.mjs

@@ -3,9 +3,9 @@ import summarizeModules from "./summarize-modules.mjs";
 import summarizeFolders from "./summarize-folders.mjs";
 import summarizeOptions from "./summarize-options.mjs";
 import {
-  getViolationStats,
-  getModulesCruised,
-  getDependenciesCruised,
+	getViolationStats,
+	getModulesCruised,
+	getDependenciesCruised,
 } from "./get-stats.mjs";
 import { compareViolations } from "#graph-utl/compare.mjs";
 
@@ -24,21 +24,21 @@ import { compareViolations } from "#graph-utl/compare.mjs";
  *    a summary of the found modules, dependencies and any violations
  */
 export default function summarize(
-  pModules,
-  pOptions,
-  pFileDirectoryArray,
-  pFolders,
+	pModules,
+	pOptions,
+	pFileDirectoryArray,
+	pFolders,
 ) {
-  const lViolations = summarizeModules(pModules, pOptions.ruleSet)
-    .concat(summarizeFolders(pFolders || [], pOptions.ruleSet))
-    .sort(compareViolations);
+	const lViolations = summarizeModules(pModules, pOptions.ruleSet)
+		.concat(summarizeFolders(pFolders || [], pOptions.ruleSet))
+		.sort(compareViolations);
 
-  return {
-    violations: lViolations,
-    ...getViolationStats(lViolations),
-    totalCruised: getModulesCruised(pModules),
-    totalDependenciesCruised: getDependenciesCruised(pModules),
-    ...summarizeOptions(pFileDirectoryArray, pOptions),
-    ...(pOptions.ruleSet ? { ruleSetUsed: addRuleSetUsed(pOptions) } : {}),
-  };
+	return {
+		violations: lViolations,
+		...getViolationStats(lViolations),
+		totalCruised: getModulesCruised(pModules),
+		totalDependenciesCruised: getDependenciesCruised(pModules),
+		...summarizeOptions(pFileDirectoryArray, pOptions),
+		...(pOptions.ruleSet ? { ruleSetUsed: addRuleSetUsed(pOptions) } : {}),
+	};
 }

package/src/enrich/summarize/is-same-violation.mjs

@@ -1,36 +1,36 @@
 function pluckName({ name }) {
-  return name;
+	return name;
 }
 
 // eslint-disable-next-line complexity
 export default function isSameViolation(pLeftViolation, pRightViolation) {
-  if (pLeftViolation.rule.name === pRightViolation.rule.name) {
-    if (pRightViolation.cycle && pLeftViolation.cycle) {
-      return (
-        pLeftViolation.cycle.length === pRightViolation.cycle.length &&
-        pLeftViolation.cycle
-          .map(pluckName)
-          .every((pModule) =>
-            pRightViolation.cycle.map(pluckName).includes(pModule),
-          )
-      );
-    }
-    if (pRightViolation.via && pLeftViolation.via) {
-      return (
-        pLeftViolation.from === pRightViolation.from &&
-        pLeftViolation.to === pRightViolation.to &&
-        pLeftViolation.via.length === pRightViolation.via.length &&
-        pLeftViolation.via
-          .map(pluckName)
-          .every((pModule) =>
-            pRightViolation.via.map(pluckName).includes(pModule),
-          )
-      );
-    }
-    return (
-      pLeftViolation.from === pRightViolation.from &&
-      pLeftViolation.to === pRightViolation.to
-    );
-  }
-  return false;
+	if (pLeftViolation.rule.name === pRightViolation.rule.name) {
+		if (pRightViolation.cycle && pLeftViolation.cycle) {
+			return (
+				pLeftViolation.cycle.length === pRightViolation.cycle.length &&
+				pLeftViolation.cycle
+					.map(pluckName)
+					.every((pModule) =>
+						pRightViolation.cycle.map(pluckName).includes(pModule),
+					)
+			);
+		}
+		if (pRightViolation.via && pLeftViolation.via) {
+			return (
+				pLeftViolation.from === pRightViolation.from &&
+				pLeftViolation.to === pRightViolation.to &&
+				pLeftViolation.via.length === pRightViolation.via.length &&
+				pLeftViolation.via
+					.map(pluckName)
+					.every((pModule) =>
+						pRightViolation.via.map(pluckName).includes(pModule),
+					)
+			);
+		}
+		return (
+			pLeftViolation.from === pRightViolation.from &&
+			pLeftViolation.to === pRightViolation.to
+		);
+	}
+	return false;
 }

package/src/enrich/summarize/summarize-folders.mjs

@@ -1,46 +1,46 @@
 import { findRuleByName } from "#graph-utl/rule-set.mjs";
 
 function classifyViolation(pRule, pRuleSet) {
-  const lRule = findRuleByName(pRuleSet, pRule.name);
-  if (Object.hasOwn(lRule?.to ?? {}, "moreUnstable")) {
-    return "instability";
-  }
-  if (Object.hasOwn(lRule?.to ?? {}, "circular")) {
-    return "cycle";
-  }
-  return "folder";
+	const lRule = findRuleByName(pRuleSet, pRule.name);
+	if (Object.hasOwn(lRule?.to ?? {}, "moreUnstable")) {
+		return "instability";
+	}
+	if (Object.hasOwn(lRule?.to ?? {}, "circular")) {
+		return "cycle";
+	}
+	return "folder";
 }
 
 function getViolations(pFolder, pRuleSet) {
-  return pFolder.dependencies
-    .filter((pDependency) => !pDependency.valid)
-    .flatMap((pDependency) =>
-      pDependency.rules.map((pRule) => {
-        const lViolationType = classifyViolation(pRule, pRuleSet);
+	return pFolder.dependencies
+		.filter((pDependency) => !pDependency.valid)
+		.flatMap((pDependency) =>
+			pDependency.rules.map((pRule) => {
+				const lViolationType = classifyViolation(pRule, pRuleSet);
 
-        return {
-          type: lViolationType,
-          from: pFolder.name,
-          to: pDependency.name,
-          rule: pRule,
-          ...(lViolationType === "instability"
-            ? {
-                metrics: {
-                  from: { instability: pFolder.instability },
-                  to: { instability: pDependency.instability },
-                },
-              }
-            : {}),
-          ...(lViolationType === "cycle"
-            ? {
-                cycle: pDependency.cycle,
-              }
-            : {}),
-        };
-      }),
-    );
+				return {
+					type: lViolationType,
+					from: pFolder.name,
+					to: pDependency.name,
+					rule: pRule,
+					...(lViolationType === "instability"
+						? {
+								metrics: {
+									from: { instability: pFolder.instability },
+									to: { instability: pDependency.instability },
+								},
+							}
+						: {}),
+					...(lViolationType === "cycle"
+						? {
+								cycle: pDependency.cycle,
+							}
+						: {}),
+				};
+			}),
+		);
 }
 
 export default function summarizeFolders(pFolders, pRuleSet) {
-  return pFolders.flatMap((pFolder) => getViolations(pFolder, pRuleSet));
+	return pFolders.flatMap((pFolder) => getViolations(pFolder, pRuleSet));
 }