dependency-cruiser 17.3.2 → 17.3.3-beta-2

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

@@ -4,52 +4,52 @@ import { compareViolations } from "#graph-utl/compare.mjs";
 import { uniqWith } from "#utl/array-util.mjs";
 
 function cutNonTransgressions(pModule) {
-  return {
-    ...pModule,
-    dependencies: pModule.dependencies.filter(
-      (pDependency) => pDependency.valid === false,
-    ),
-  };
+	return {
+		...pModule,
+		dependencies: pModule.dependencies.filter(
+			(pDependency) => pDependency.valid === false,
+		),
+	};
 }
 
 function toDependencyViolationSummary(pRule, pModule, pDependency, pRuleSet) {
-  let lReturnValue = {
-    type: "dependency",
-    from: pModule.source,
-    to: pDependency.resolved,
-    rule: pRule,
-  };
+	let lReturnValue = {
+		type: "dependency",
+		from: pModule.source,
+		to: pDependency.resolved,
+		rule: pRule,
+	};
 
-  if (
-    Object.hasOwn(pDependency, "cycle") &&
-    findRuleByName(pRuleSet, pRule.name)?.to?.circular
-  ) {
-    lReturnValue = {
-      ...lReturnValue,
-      type: "cycle",
-      cycle: pDependency.cycle,
-    };
-  }
+	if (
+		Object.hasOwn(pDependency, "cycle") &&
+		findRuleByName(pRuleSet, pRule.name)?.to?.circular
+	) {
+		lReturnValue = {
+			...lReturnValue,
+			type: "cycle",
+			cycle: pDependency.cycle,
+		};
+	}
 
-  if (
-    Object.hasOwn(pModule, "instability") &&
-    Object.hasOwn(pDependency, "instability") &&
-    Object.hasOwn(
-      findRuleByName(pRuleSet, pRule.name)?.to ?? {},
-      "moreUnstable",
-    )
-  ) {
-    lReturnValue = {
-      ...lReturnValue,
-      type: "instability",
-      metrics: {
-        from: { instability: pModule.instability },
-        to: { instability: pDependency.instability },
-      },
-    };
-  }
+	if (
+		Object.hasOwn(pModule, "instability") &&
+		Object.hasOwn(pDependency, "instability") &&
+		Object.hasOwn(
+			findRuleByName(pRuleSet, pRule.name)?.to ?? {},
+			"moreUnstable",
+		)
+	) {
+		lReturnValue = {
+			...lReturnValue,
+			type: "instability",
+			metrics: {
+				from: { instability: pModule.instability },
+				to: { instability: pDependency.instability },
+			},
+		};
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 /**
@@ -70,71 +70,71 @@ function toDependencyViolationSummary(pRule, pModule, pDependency, pRuleSet) {
  * @return {any} an array of violations
  */
 function extractDependencyViolations(pModules, pRuleSet) {
-  return pModules
-    .map(cutNonTransgressions)
-    .filter((pModule) => pModule.dependencies.length > 0)
-    .map((pModule) =>
-      pModule.dependencies.map((pDependency) =>
-        pDependency.rules.map((pRule) =>
-          toDependencyViolationSummary(pRule, pModule, pDependency, pRuleSet),
-        ),
-      ),
-    )
-    .flat(Infinity);
+	return pModules
+		.map(cutNonTransgressions)
+		.filter((pModule) => pModule.dependencies.length > 0)
+		.map((pModule) =>
+			pModule.dependencies.map((pDependency) =>
+				pDependency.rules.map((pRule) =>
+					toDependencyViolationSummary(pRule, pModule, pDependency, pRuleSet),
+				),
+			),
+		)
+		.flat(Infinity);
 }
 
 function toModuleViolationSummary(pRule, pModule, pRuleSet) {
-  let lReturnValue = [
-    { type: "module", from: pModule.source, to: pModule.source, rule: pRule },
-  ];
-  if (pModule.reaches && findRuleByName(pRuleSet, pRule.name)?.to?.reachable) {
-    lReturnValue = pModule.reaches
-      .filter((pReachable) => pReachable.asDefinedInRule === pRule.name)
-      .reduce(
-        (pAll, pReachable) =>
-          pAll.concat(
-            pReachable.modules.map((pReachableModule) => ({
-              to: pReachableModule.source,
-              via: pReachableModule.via,
-            })),
-          ),
-        [],
-      )
-      .map((pToModule) => ({
-        type: "reachability",
-        from: pModule.source,
-        to: pToModule.to,
-        rule: pRule,
-        via: pToModule.via,
-      }));
-  }
+	let lReturnValue = [
+		{ type: "module", from: pModule.source, to: pModule.source, rule: pRule },
+	];
+	if (pModule.reaches && findRuleByName(pRuleSet, pRule.name)?.to?.reachable) {
+		lReturnValue = pModule.reaches
+			.filter((pReachable) => pReachable.asDefinedInRule === pRule.name)
+			.reduce(
+				(pAll, pReachable) =>
+					pAll.concat(
+						pReachable.modules.map((pReachableModule) => ({
+							to: pReachableModule.source,
+							via: pReachableModule.via,
+						})),
+					),
+				[],
+			)
+			.map((pToModule) => ({
+				type: "reachability",
+				from: pModule.source,
+				to: pToModule.to,
+				rule: pRule,
+				via: pToModule.via,
+			}));
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 function extractModuleViolations(pModules, pRuleSet) {
-  return pModules
-    .filter((pModule) => pModule.valid === false)
-    .reduce(
-      (pAllModules, pModule) =>
-        pAllModules.concat(
-          pModule.rules.reduce(
-            (pAllRules, pRule) =>
-              pAllRules.concat(
-                toModuleViolationSummary(pRule, pModule, pRuleSet),
-              ),
-            [],
-          ),
-        ),
-      [],
-    );
+	return pModules
+		.filter((pModule) => pModule.valid === false)
+		.reduce(
+			(pAllModules, pModule) =>
+				pAllModules.concat(
+					pModule.rules.reduce(
+						(pAllRules, pRule) =>
+							pAllRules.concat(
+								toModuleViolationSummary(pRule, pModule, pRuleSet),
+							),
+						[],
+					),
+				),
+			[],
+		);
 }
 
 export default function summarizeModules(pModules, pRuleSet) {
-  return uniqWith(
-    extractDependencyViolations(pModules, pRuleSet)
-      .concat(extractModuleViolations(pModules, pRuleSet))
-      .sort(compareViolations),
-    isSameViolation,
-  );
+	return uniqWith(
+		extractDependencyViolations(pModules, pRuleSet)
+			.concat(extractModuleViolations(pModules, pRuleSet))
+			.sort(compareViolations),
+		isSameViolation,
+	);
 }

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

@@ -1,83 +1,83 @@
 const SHAREABLE_OPTIONS = [
-  "babelConfig",
-  "baseDir",
-  "cache",
-  "collapse",
-  "combinedDependencies",
-  "detectJSDocImports",
-  "detectProcessBuiltinModuleCalls",
-  "doNotFollow",
-  "enhancedResolveOptions",
-  "exclude",
-  "exoticallyRequired",
-  "exoticRequireStrings",
-  "experimentalStats",
-  "externalModuleResolutionStrategy",
-  "focus",
-  "focusDepth",
-  "includeOnly",
-  "knownViolations",
-  "maxDepth",
-  "metrics",
-  "moduleSystems",
-  "outputTo",
-  "outputType",
-  "parser",
-  "prefix",
-  "preserveSymlinks",
-  "reaches",
-  "reporterOptions",
-  "rulesFile",
-  "skipAnalysisNotInRules",
-  "suffix",
-  "tsConfig",
-  "tsPreCompilationDeps",
-  "webpackConfig",
-  // "progress", TODO: could be enabled
+	"babelConfig",
+	"baseDir",
+	"cache",
+	"collapse",
+	"combinedDependencies",
+	"detectJSDocImports",
+	"detectProcessBuiltinModuleCalls",
+	"doNotFollow",
+	"enhancedResolveOptions",
+	"exclude",
+	"exoticallyRequired",
+	"exoticRequireStrings",
+	"experimentalStats",
+	"externalModuleResolutionStrategy",
+	"focus",
+	"focusDepth",
+	"includeOnly",
+	"knownViolations",
+	"maxDepth",
+	"metrics",
+	"moduleSystems",
+	"outputTo",
+	"outputType",
+	"parser",
+	"prefix",
+	"preserveSymlinks",
+	"reaches",
+	"reporterOptions",
+	"rulesFile",
+	"skipAnalysisNotInRules",
+	"suffix",
+	"tsConfig",
+	"tsPreCompilationDeps",
+	"webpackConfig",
+	// "progress", TODO: could be enabled
 ];
 
 function makeOptionsPresentable(pOptions) {
-  return SHAREABLE_OPTIONS.filter(
-    (pShareableOptionKey) =>
-      Object.hasOwn(pOptions, pShareableOptionKey) &&
-      pOptions?.[pShareableOptionKey] !== 0,
-  )
-    .filter(
-      (pShareableOptionKey) =>
-        pShareableOptionKey !== "doNotFollow" ||
-        Object.keys(pOptions.doNotFollow).length > 0,
-    )
-    .filter(
-      (pShareableOptionKey) =>
-        pShareableOptionKey !== "exclude" ||
-        Object.keys(pOptions.exclude).length > 0,
-    )
-    .filter(
-      (pShareableOptionKey) =>
-        pShareableOptionKey !== "knownViolations" ||
-        pOptions.knownViolations.length > 0,
-    )
-    .reduce((pAll, pShareableOptionKey) => {
-      pAll[pShareableOptionKey] = pOptions[pShareableOptionKey];
-      return pAll;
-    }, {});
+	return SHAREABLE_OPTIONS.filter(
+		(pShareableOptionKey) =>
+			Object.hasOwn(pOptions, pShareableOptionKey) &&
+			pOptions?.[pShareableOptionKey] !== 0,
+	)
+		.filter(
+			(pShareableOptionKey) =>
+				pShareableOptionKey !== "doNotFollow" ||
+				Object.keys(pOptions.doNotFollow).length > 0,
+		)
+		.filter(
+			(pShareableOptionKey) =>
+				pShareableOptionKey !== "exclude" ||
+				Object.keys(pOptions.exclude).length > 0,
+		)
+		.filter(
+			(pShareableOptionKey) =>
+				pShareableOptionKey !== "knownViolations" ||
+				pOptions.knownViolations.length > 0,
+		)
+		.reduce((pAll, pShareableOptionKey) => {
+			pAll[pShareableOptionKey] = pOptions[pShareableOptionKey];
+			return pAll;
+		}, {});
 }
 
 function makeIncludeOnlyBackwardsCompatible(pOptions) {
-  return pOptions.includeOnly
-    ? {
-        ...pOptions,
-        includeOnly: pOptions?.includeOnly?.path,
-      }
-    : pOptions;
+	return pOptions.includeOnly
+		? {
+				...pOptions,
+				includeOnly: pOptions?.includeOnly?.path,
+			}
+		: pOptions;
 }
 
 export default function summarizeOptions(pFileDirectoryArray, pOptions) {
-  return {
-    optionsUsed: {
-      ...makeOptionsPresentable(makeIncludeOnlyBackwardsCompatible(pOptions)),
-      args: pFileDirectoryArray.join(" "),
-    },
-  };
+	return {
+		optionsUsed: {
+			...makeOptionsPresentable(makeIncludeOnlyBackwardsCompatible(pOptions)),
+			args: pFileDirectoryArray.join(" "),
+		},
+	};
 }
 /* eslint security/detect-object-injection: 0 */

package/src/extract/acorn/estree-helpers.mjs

@@ -1,99 +1,99 @@
 /* eslint-disable no-inline-comments */
 export function isStringLiteral(pArgument) {
-  return pArgument.type === "Literal" && typeof pArgument.value === "string";
+	return pArgument.type === "Literal" && typeof pArgument.value === "string";
 }
 
 export function firstArgumentIsAString(pArgumentsNode) {
-  return (
-    pArgumentsNode && pArgumentsNode[0] && isStringLiteral(pArgumentsNode[0])
-  );
+	return (
+		pArgumentsNode && pArgumentsNode[0] && isStringLiteral(pArgumentsNode[0])
+	);
 }
 
 export function isPlaceholderLessTemplateLiteral(pArgument) {
-  return (
-    pArgument.type === "TemplateLiteral" &&
-    pArgument.quasis.length === 1 &&
-    pArgument.expressions.length === 0
-  );
+	return (
+		pArgument.type === "TemplateLiteral" &&
+		pArgument.quasis.length === 1 &&
+		pArgument.expressions.length === 0
+	);
 }
 
 export function firstArgumentIsATemplateLiteral(pArgumentsNode) {
-  return (
-    pArgumentsNode &&
-    pArgumentsNode[0] &&
-    isPlaceholderLessTemplateLiteral(pArgumentsNode[0])
-  );
+	return (
+		pArgumentsNode &&
+		pArgumentsNode[0] &&
+		isPlaceholderLessTemplateLiteral(pArgumentsNode[0])
+	);
 }
 
 function isMemberCallExpression(pNode, pObjectName, pPropertyName) {
-  return (
-    pNode.type === "CallExpression" &&
-    pNode.callee.type === "MemberExpression" &&
-    pNode.callee.object.type === "Identifier" &&
-    pNode.callee.object.name === pObjectName &&
-    pNode.callee.property.type === "Identifier" &&
-    pNode.callee.property.name === pPropertyName
-  );
+	return (
+		pNode.type === "CallExpression" &&
+		pNode.callee.type === "MemberExpression" &&
+		pNode.callee.object.type === "Identifier" &&
+		pNode.callee.object.name === pObjectName &&
+		pNode.callee.property.type === "Identifier" &&
+		pNode.callee.property.name === pPropertyName
+	);
 }
 
 function isNestedMemberCallExpression(
-  pNode,
-  pObjectName,
-  pSecondObjectName,
-  pPropertyName,
+	pNode,
+	pObjectName,
+	pSecondObjectName,
+	pPropertyName,
 ) {
-  return (
-    pNode.type === "CallExpression" &&
-    pNode.callee.type === "MemberExpression" &&
-    pNode.callee.object.type === "MemberExpression" &&
-    pNode.callee.object.object.type === "Identifier" &&
-    pNode.callee.object.object.name === pObjectName && // i.e. globalThis
-    pNode.callee.object.property.type === "Identifier" &&
-    pNode.callee.object.property.name === pSecondObjectName && // i.e. process
-    pNode.callee.property.type === "Identifier" &&
-    pNode.callee.property.name === pPropertyName // i.e. getBuiltinModule
-  );
+	return (
+		pNode.type === "CallExpression" &&
+		pNode.callee.type === "MemberExpression" &&
+		pNode.callee.object.type === "MemberExpression" &&
+		pNode.callee.object.object.type === "Identifier" &&
+		pNode.callee.object.object.name === pObjectName && // i.e. globalThis
+		pNode.callee.object.property.type === "Identifier" &&
+		pNode.callee.object.property.name === pSecondObjectName && // i.e. process
+		pNode.callee.property.type === "Identifier" &&
+		pNode.callee.property.name === pPropertyName // i.e. getBuiltinModule
+	);
 }
 
 function isCalleeIdentifier(pNode, pName) {
-  return "Identifier" === pNode?.callee?.type && pName === pNode?.callee?.name;
+	return "Identifier" === pNode?.callee?.type && pName === pNode?.callee?.name;
 }
 
 export function isRequireOfSomeSort(pNode, pName) {
-  // prevent doing the pName.split for the common case
-  if (pName === "require") {
-    return isCalleeIdentifier(pNode, pName);
-  }
+	// prevent doing the pName.split for the common case
+	if (pName === "require") {
+		return isCalleeIdentifier(pNode, pName);
+	}
 
-  const lRequireStringElements = pName.split(".");
+	const lRequireStringElements = pName.split(".");
 
-  switch (lRequireStringElements.length) {
-    case 1:
-      return isCalleeIdentifier(pNode, pName);
-    // eslint-disable-next-line no-magic-numbers
-    case 2:
-      return isMemberCallExpression(pNode, ...lRequireStringElements);
-    // eslint-disable-next-line no-magic-numbers
-    case 3:
-      return isNestedMemberCallExpression(pNode, ...lRequireStringElements);
-    default:
-      return false;
-  }
+	switch (lRequireStringElements.length) {
+		case 1:
+			return isCalleeIdentifier(pNode, pName);
+		// eslint-disable-next-line no-magic-numbers
+		case 2:
+			return isMemberCallExpression(pNode, ...lRequireStringElements);
+		// eslint-disable-next-line no-magic-numbers
+		case 3:
+			return isNestedMemberCallExpression(pNode, ...lRequireStringElements);
+		default:
+			return false;
+	}
 }
 
 export function isLikelyAMDDefineOrRequire(pNode) {
-  return (
-    pNode.expression.type === "CallExpression" &&
-    pNode.expression.callee.type === "Identifier" &&
-    (pNode.expression.callee.name === "define" ||
-      pNode.expression.callee.name === "require")
-  );
+	return (
+		pNode.expression.type === "CallExpression" &&
+		pNode.expression.callee.type === "Identifier" &&
+		(pNode.expression.callee.name === "define" ||
+			pNode.expression.callee.name === "require")
+	);
 }
 
 export function isLikelyAMDDefine(pNode) {
-  return (
-    pNode.expression.type === "CallExpression" &&
-    pNode.expression.callee.type === "Identifier" &&
-    pNode.expression.callee.name === "define"
-  );
+	return (
+		pNode.expression.type === "CallExpression" &&
+		pNode.expression.callee.type === "Identifier" &&
+		pNode.expression.callee.name === "define"
+	);
 }