dependency-cruiser 17.3.2 → 17.3.3-beta-2

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

@@ -3,22 +3,22 @@ import { dirname } from "node:path/posix";
 import { calculateInstability, metricsAreCalculable } from "../module-utl.mjs";
 import detectCycles from "../circular.mjs";
 import {
-  findFolderByName,
-  getAfferentCouplings,
-  getEfferentCouplings,
-  getParentFolders,
-  object2Array,
+	findFolderByName,
+	getAfferentCouplings,
+	getEfferentCouplings,
+	getParentFolders,
+	object2Array,
 } from "./utl.mjs";
 import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
 import { uniq } from "#utl/array-util.mjs";
 
 function upsertCouplings(pAllDependents, pNewDependents) {
-  for (const lNewDependent of pNewDependents) {
-    pAllDependents[lNewDependent] = pAllDependents[lNewDependent] || {
-      count: 0,
-    };
-    pAllDependents[lNewDependent].count += 1;
-  }
+	for (const lNewDependent of pNewDependents) {
+		pAllDependents[lNewDependent] = pAllDependents[lNewDependent] || {
+			count: 0,
+		};
+		pAllDependents[lNewDependent].count += 1;
+	}
 }
 
 /**
@@ -30,108 +30,108 @@ function upsertCouplings(pAllDependents, pNewDependents) {
  */
 
 function upsertFolderAttributes(pAllMetrics, pModule, pDirname) {
-  pAllMetrics[pDirname] = pAllMetrics[pDirname] || {
-    dependencies: {},
-    dependents: {},
-    moduleCount: 0,
-  };
+	pAllMetrics[pDirname] = pAllMetrics[pDirname] || {
+		dependencies: {},
+		dependents: {},
+		moduleCount: 0,
+	};
 
-  upsertCouplings(
-    pAllMetrics[pDirname].dependents,
-    getAfferentCouplings(pModule, pDirname),
-  );
-  upsertCouplings(
-    pAllMetrics[pDirname].dependencies,
-    getEfferentCouplings(pModule, pDirname).map(
-      (pDependency) => pDependency.resolved,
-    ),
-  );
-  pAllMetrics[pDirname].moduleCount += 1;
+	upsertCouplings(
+		pAllMetrics[pDirname].dependents,
+		getAfferentCouplings(pModule, pDirname),
+	);
+	upsertCouplings(
+		pAllMetrics[pDirname].dependencies,
+		getEfferentCouplings(pModule, pDirname).map(
+			(pDependency) => pDependency.resolved,
+		),
+	);
+	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;
+	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;
 }
 
 function aggregateToFolder(pAllFolders, pModule) {
-  for (const lParentDirectory of getParentFolders(dirname(pModule.source))) {
-    upsertFolderAttributes(pAllFolders, pModule, lParentDirectory);
-  }
-  return pAllFolders;
+	for (const lParentDirectory of getParentFolders(dirname(pModule.source))) {
+		upsertFolderAttributes(pAllFolders, pModule, lParentDirectory);
+	}
+	return pAllFolders;
 }
 
 function sumCounts(pAll, pCurrent) {
-  return pAll + pCurrent.count;
+	return pAll + pCurrent.count;
 }
 
 function getFolderLevelCouplings(pCouplingArray) {
-  return uniq(
-    pCouplingArray.map((pCoupling) =>
-      dirname(pCoupling.name) === "."
-        ? pCoupling.name
-        : dirname(pCoupling.name),
-    ),
-  ).map((pCoupling) => ({ name: pCoupling }));
+	return uniq(
+		pCouplingArray.map((pCoupling) =>
+			dirname(pCoupling.name) === "."
+				? pCoupling.name
+				: dirname(pCoupling.name),
+		),
+	).map((pCoupling) => ({ name: pCoupling }));
 }
 
 function calculateFolderMetrics(pFolder) {
-  const lModuleDependents = object2Array(pFolder.dependents);
-  const lModuleDependencies = object2Array(pFolder.dependencies);
-  // this calculation might look superfluous (why not just .length the dependents
-  // and dependencies?), but it isn't because there can be > 1 relation between
-  // two folders
-  const lAfferentCouplings = lModuleDependents.reduce(sumCounts, 0);
-  const lEfferentCouplings = lModuleDependencies.reduce(sumCounts, 0);
+	const lModuleDependents = object2Array(pFolder.dependents);
+	const lModuleDependencies = object2Array(pFolder.dependencies);
+	// this calculation might look superfluous (why not just .length the dependents
+	// and dependencies?), but it isn't because there can be > 1 relation between
+	// two folders
+	const lAfferentCouplings = lModuleDependents.reduce(sumCounts, 0);
+	const lEfferentCouplings = lModuleDependencies.reduce(sumCounts, 0);
 
-  return {
-    ...pFolder,
-    afferentCouplings: lAfferentCouplings,
-    efferentCouplings: lEfferentCouplings,
-    instability: calculateInstability(lEfferentCouplings, lAfferentCouplings),
-    dependents: getFolderLevelCouplings(lModuleDependents),
-    dependencies: getFolderLevelCouplings(lModuleDependencies),
-  };
+	return {
+		...pFolder,
+		afferentCouplings: lAfferentCouplings,
+		efferentCouplings: lEfferentCouplings,
+		instability: calculateInstability(lEfferentCouplings, lAfferentCouplings),
+		dependents: getFolderLevelCouplings(lModuleDependents),
+		dependencies: getFolderLevelCouplings(lModuleDependencies),
+	};
 }
 
 function deNormalizeInstability(pFolder, _, pAllFolders) {
-  return {
-    ...pFolder,
-    dependencies: pFolder.dependencies.map((pDependency) => {
-      const lFolder = findFolderByName(pAllFolders, pDependency.name) || {};
-      return {
-        ...pDependency,
-        instability: lFolder.instability >= 0 ? lFolder.instability : 0,
-      };
-    }),
-  };
+	return {
+		...pFolder,
+		dependencies: pFolder.dependencies.map((pDependency) => {
+			const lFolder = findFolderByName(pAllFolders, pDependency.name) || {};
+			return {
+				...pDependency,
+				instability: lFolder.instability >= 0 ? lFolder.instability : 0,
+			};
+		}),
+	};
 }
 
 function getSinks(pFolders) {
-  const lKnownFolders = new Set(pFolders.map(({ name }) => name));
-  const lAllFolders = uniq(
-    pFolders.flatMap(({ dependencies }) =>
-      dependencies.map(({ name }) => name),
-    ),
-  );
-  const lReturnValue = lAllFolders
-    .filter((pFolder) => !lKnownFolders.has(pFolder))
-    .map((pFolder) => ({
-      name: pFolder,
-      moduleCount: -1,
-      dependencies: [],
-      dependents: [],
-    }));
-  return lReturnValue;
+	const lKnownFolders = new Set(pFolders.map(({ name }) => name));
+	const lAllFolders = uniq(
+		pFolders.flatMap(({ dependencies }) =>
+			dependencies.map(({ name }) => name),
+		),
+	);
+	const lReturnValue = lAllFolders
+		.filter((pFolder) => !lKnownFolders.has(pFolder))
+		.map((pFolder) => ({
+			name: pFolder,
+			moduleCount: -1,
+			dependencies: [],
+			dependents: [],
+		}));
+	return lReturnValue;
 }
 
 /**
@@ -141,17 +141,17 @@ function getSinks(pFolders) {
  * @returns
  */
 export default function aggregateToFolders(pModules, pOptions = {}) {
-  let lFolders = object2Array(
-    pModules.filter(metricsAreCalculable).reduce(aggregateToFolder, {}),
-  )
-    .map(calculateFolderMetrics)
-    .map(deNormalizeInstability);
-  lFolders = lFolders.concat(getSinks(lFolders));
+	let lFolders = object2Array(
+		pModules.filter(metricsAreCalculable).reduce(aggregateToFolder, {}),
+	)
+		.map(calculateFolderMetrics)
+		.map(deNormalizeInstability);
+	lFolders = lFolders.concat(getSinks(lFolders));
 
-  return detectCycles(lFolders, new IndexedModuleGraph(lFolders, "name"), {
-    pSourceAttribute: "name",
-    pDependencyName: "name",
-    pSkipAnalysisNotInRules: pOptions.skipAnalysisNotInRules,
-    pRuleSet: pOptions.ruleSet,
-  });
+	return detectCycles(lFolders, new IndexedModuleGraph(lFolders, "name"), {
+		pSourceAttribute: "name",
+		pDependencyName: "name",
+		pSkipAnalysisNotInRules: pOptions.skipAnalysisNotInRules,
+		pRuleSet: pOptions.ruleSet,
+	});
 }

package/src/enrich/derive/folders/index.mjs

@@ -7,20 +7,20 @@ import { validateFolder } from "#validate/index.mjs";
  * @returns
  */
 function validateFolderDependency(pFolder, pOptions) {
-  return (pDependency) => ({
-    ...pDependency,
-    ...validateFolder(pOptions.ruleSet || {}, pFolder, pDependency),
-  });
+	return (pDependency) => ({
+		...pDependency,
+		...validateFolder(pOptions.ruleSet || {}, pFolder, pDependency),
+	});
 }
 
 function addFolderDependencyViolations(pOptions) {
-  return (pFolder) => ({
-    ...pFolder,
+	return (pFolder) => ({
+		...pFolder,
 
-    dependencies: pFolder.dependencies.map(
-      validateFolderDependency(pFolder, pOptions),
-    ),
-  });
+		dependencies: pFolder.dependencies.map(
+			validateFolderDependency(pFolder, pOptions),
+		),
+	});
 }
 
 /**
@@ -30,13 +30,13 @@ function addFolderDependencyViolations(pOptions) {
  * @returns {any}
  */
 export default function deriveFolderMetrics(pModules, pOptions) {
-  let lReturnValue = {};
-  if (pOptions.metrics) {
-    lReturnValue = {
-      folders: aggregateToFolders(pModules, pOptions).map(
-        addFolderDependencyViolations(pOptions),
-      ),
-    };
-  }
-  return lReturnValue;
+	let lReturnValue = {};
+	if (pOptions.metrics) {
+		lReturnValue = {
+			folders: aggregateToFolders(pModules, pOptions).map(
+				addFolderDependencyViolations(pOptions),
+			),
+		};
+	}
+	return lReturnValue;
 }

package/src/enrich/derive/folders/utl.mjs

@@ -2,19 +2,19 @@
 import { sep } from "node:path/posix";
 
 export function findFolderByName(pAllFolders, pName) {
-  return pAllFolders.find((pFolder) => pFolder.name === pName);
+	return pAllFolders.find((pFolder) => pFolder.name === pName);
 }
 
 export function getAfferentCouplings(pModule, pDirname) {
-  return pModule.dependents.filter(
-    (pDependent) => !pDependent.startsWith(pDirname.concat(sep)),
-  );
+	return pModule.dependents.filter(
+		(pDependent) => !pDependent.startsWith(pDirname.concat(sep)),
+	);
 }
 
 export function getEfferentCouplings(pModule, pDirname) {
-  return pModule.dependencies.filter(
-    (pDependency) => !pDependency.resolved.startsWith(pDirname.concat(sep)),
-  );
+	return pModule.dependencies.filter(
+		(pDependency) => !pDependency.resolved.startsWith(pDirname.concat(sep)),
+	);
 }
 
 /**
@@ -23,19 +23,19 @@ export function getEfferentCouplings(pModule, pDirname) {
  * @returns string[]
  */
 export function getParentFolders(pPath) {
-  let lFragments = pPath.split("/");
-  let lReturnValue = [];
+	let lFragments = pPath.split("/");
+	let lReturnValue = [];
 
-  while (lFragments.length > 0) {
-    lReturnValue.push(lFragments.join("/"));
-    lFragments.pop();
-  }
-  return lReturnValue.reverse();
+	while (lFragments.length > 0) {
+		lReturnValue.push(lFragments.join("/"));
+		lFragments.pop();
+	}
+	return lReturnValue.reverse();
 }
 
 export function object2Array(pObject) {
-  return Object.keys(pObject).map((pKey) => ({
-    name: pKey,
-    ...pObject[pKey],
-  }));
+	return Object.keys(pObject).map((pKey) => ({
+		name: pKey,
+		...pObject[pKey],
+	}));
 }

package/src/enrich/derive/metrics/get-module-metrics.mjs

@@ -2,38 +2,38 @@ import { calculateInstability, metricsAreCalculable } from "../module-utl.mjs";
 import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
 
 export function addInstabilityMetric(pModule) {
-  return {
-    ...pModule,
-    ...(metricsAreCalculable(pModule)
-      ? {
-          instability: calculateInstability(
-            pModule.dependencies.length,
-            pModule.dependents.length,
-          ),
-        }
-      : {}),
-  };
+	return {
+		...pModule,
+		...(metricsAreCalculable(pModule)
+			? {
+					instability: calculateInstability(
+						pModule.dependencies.length,
+						pModule.dependents.length,
+					),
+				}
+			: {}),
+	};
 }
 
 function addInstabilityToDependency(pAllModules) {
-  const lIndexedModules = new IndexedModuleGraph(pAllModules);
-  return (pDependency) => ({
-    ...pDependency,
-    instability:
-      (lIndexedModules.findVertexByName(pDependency.resolved) || {})
-        .instability || 0,
-  });
+	const lIndexedModules = new IndexedModuleGraph(pAllModules);
+	return (pDependency) => ({
+		...pDependency,
+		instability:
+			(lIndexedModules.findVertexByName(pDependency.resolved) || {})
+				.instability || 0,
+	});
 }
 
 export function deNormalizeInstabilityMetricsToDependencies(
-  pModule,
-  _,
-  pAllModules,
+	pModule,
+	_,
+	pAllModules,
 ) {
-  return {
-    ...pModule,
-    dependencies: pModule.dependencies.map(
-      addInstabilityToDependency(pAllModules),
-    ),
-  };
+	return {
+		...pModule,
+		dependencies: pModule.dependencies.map(
+			addInstabilityToDependency(pAllModules),
+		),
+	};
 }

package/src/enrich/derive/metrics/index.mjs

@@ -1,13 +1,13 @@
 import {
-  addInstabilityMetric,
-  deNormalizeInstabilityMetricsToDependencies,
+	addInstabilityMetric,
+	deNormalizeInstabilityMetricsToDependencies,
 } from "./get-module-metrics.mjs";
 
 export default function deriveModulesMetrics(pModules, pOptions) {
-  if (pOptions.metrics) {
-    return pModules
-      .map(addInstabilityMetric)
-      .map(deNormalizeInstabilityMetricsToDependencies);
-  }
-  return pModules;
+	if (pOptions.metrics) {
+		return pModules
+			.map(addInstabilityMetric)
+			.map(deNormalizeInstabilityMetricsToDependencies);
+	}
+	return pModules;
 }

package/src/enrich/derive/module-utl.mjs

@@ -1,16 +1,16 @@
 export function isDependent(pResolvedName) {
-  return (pModule) =>
-    pModule.dependencies.some(
-      (pDependency) => pDependency.resolved === pResolvedName,
-    );
+	return (pModule) =>
+		pModule.dependencies.some(
+			(pDependency) => pDependency.resolved === pResolvedName,
+		);
 }
 
 export function metricsAreCalculable(pModule) {
-  return (
-    !pModule.coreModule &&
-    !pModule.couldNotResolve &&
-    !pModule.matchesDoNotFollow
-  );
+	return (
+		!pModule.coreModule &&
+		!pModule.couldNotResolve &&
+		!pModule.matchesDoNotFollow
+	);
 }
 
 /**
@@ -22,14 +22,14 @@ export function metricsAreCalculable(pModule) {
  * @returns number
  */
 export function calculateInstability(
-  pEfferentCouplingCount,
-  pAfferentCouplingCount,
+	pEfferentCouplingCount,
+	pAfferentCouplingCount,
 ) {
-  // when both afferentCouplings and efferentCouplings equal 0 instability will
-  // yield NaN. Judging Bob Martin's intention, a component with no outgoing
-  // dependencies is maximum stable (0)
-  return (
-    pEfferentCouplingCount /
-      (pEfferentCouplingCount + pAfferentCouplingCount) || 0
-  );
+	// when both afferentCouplings and efferentCouplings equal 0 instability will
+	// yield NaN. Judging Bob Martin's intention, a component with no outgoing
+	// dependencies is maximum stable (0)
+	return (
+		pEfferentCouplingCount /
+			(pEfferentCouplingCount + pAfferentCouplingCount) || 0
+	);
 }

package/src/enrich/derive/orphan/index.mjs

@@ -3,32 +3,32 @@ import isOrphan from "./is-orphan.mjs";
 /** @import { IFlattenedRuleSet } from "../../../../types/rule-set.mjs" */
 
 function isOrphanRule(pRule) {
-  return (
-    /* c8 ignore start */
-    Object.hasOwn(pRule?.from ?? {}, "orphan")
-    /* c8 ignore stop */
-  );
+	return (
+		/* c8 ignore start */
+		Object.hasOwn(pRule?.from ?? {}, "orphan")
+		/* c8 ignore stop */
+	);
 }
 /**
  * @param {IFlattenedRuleSet} pRuleSet
  * @returns {boolean}
  */
 export function hasOrphanRule(pRuleSet) {
-  return (
-    (pRuleSet?.forbidden ?? []).some(isOrphanRule) ||
-    (pRuleSet?.allowed ?? []).some(isOrphanRule)
-  );
+	return (
+		(pRuleSet?.forbidden ?? []).some(isOrphanRule) ||
+		(pRuleSet?.allowed ?? []).some(isOrphanRule)
+	);
 }
 
 export default function deriveOrphans(
-  pModules,
-  { skipAnalysisNotInRules, ruleSet },
+	pModules,
+	{ skipAnalysisNotInRules, ruleSet },
 ) {
-  if (!skipAnalysisNotInRules || hasOrphanRule(ruleSet)) {
-    return pModules.map((pModule) => ({
-      ...pModule,
-      orphan: isOrphan(pModule, pModules),
-    }));
-  }
-  return pModules;
+	if (!skipAnalysisNotInRules || hasOrphanRule(ruleSet)) {
+		return pModules.map((pModule) => ({
+			...pModule,
+			orphan: isOrphan(pModule, pModules),
+		}));
+	}
+	return pModules;
 }

package/src/enrich/derive/orphan/is-orphan.mjs

@@ -1,14 +1,14 @@
 import { isDependent } from "../module-utl.mjs";
 
 export default function isOrphan(pModule, pGraph) {
-  if (pModule.dependencies.length > 0) {
-    return false;
-  }
+	if (pModule.dependencies.length > 0) {
+		return false;
+	}
 
-  // when dependents already calculated take those
-  if (pModule.dependents) {
-    return pModule.dependents.length === 0;
-  }
-  // ... otherwise calculate them
-  return !pGraph.some(isDependent(pModule.source));
+	// when dependents already calculated take those
+	if (pModule.dependents) {
+		return pModule.dependents.length === 0;
+	}
+	// ... otherwise calculate them
+	return !pGraph.some(isDependent(pModule.source));
 }