dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/report/dot/module-utl.mjs

@@ -2,80 +2,80 @@ import { basename, sep, dirname } from "node:path/posix";
 import { formatPercentage, getURLForModule } from "../utl/index.mjs";
 
 export function attributizeObject(pObject) {
-  return (
-    Object.keys(pObject)
-      // eslint-disable-next-line security/detect-object-injection
-      .map((pKey) => `${pKey}="${pObject[pKey]}"`)
-      .join(" ")
-  );
+	return (
+		Object.keys(pObject)
+			// eslint-disable-next-line security/detect-object-injection
+			.map((pKey) => `${pKey}="${pObject[pKey]}"`)
+			.join(" ")
+	);
 }
 
 export function extractFirstTransgression(pModule) {
-  return {
-    ...(pModule?.rules?.[0]
-      ? { ...pModule, tooltip: pModule.rules[0].name }
-      : pModule),
-    dependencies: pModule.dependencies.map((pDependency) =>
-      pDependency.rules
-        ? {
-            ...pDependency,
-            rule: pDependency.rules[0],
-          }
-        : pDependency,
-    ),
-  };
+	return {
+		...(pModule?.rules?.[0]
+			? { ...pModule, tooltip: pModule.rules[0].name }
+			: pModule),
+		dependencies: pModule.dependencies.map((pDependency) =>
+			pDependency.rules
+				? {
+						...pDependency,
+						rule: pDependency.rules[0],
+					}
+				: pDependency,
+		),
+	};
 }
 
 function toFullPath(pAll, pCurrent) {
-  return `${pAll}${pCurrent}${sep}`;
+	return `${pAll}${pCurrent}${sep}`;
 }
 
 function aggregate(pPathSnippet, pCounter, pPathArray) {
-  return {
-    snippet: pPathSnippet,
-    aggregateSnippet: `${pPathArray
-      .slice(0, pCounter)
-      .reduce(toFullPath, "")}${pPathSnippet}`,
-  };
+	return {
+		snippet: pPathSnippet,
+		aggregateSnippet: `${pPathArray
+			.slice(0, pCounter)
+			.reduce(toFullPath, "")}${pPathSnippet}`,
+	};
 }
 
 function makeInstabilityString(pModule, pShowMetrics = false) {
-  let lInstabilityString = "";
+	let lInstabilityString = "";
 
-  if (
-    pShowMetrics &&
-    Object.hasOwn(pModule, "instability") &&
-    !pModule.consolidated
-  ) {
-    lInstabilityString = ` <FONT color="#808080" point-size="8">${formatPercentage(
-      pModule.instability,
-    )}</FONT>`;
-  }
-  return lInstabilityString;
+	if (
+		pShowMetrics &&
+		Object.hasOwn(pModule, "instability") &&
+		!pModule.consolidated
+	) {
+		lInstabilityString = ` <FONT color="#808080" point-size="8">${formatPercentage(
+			pModule.instability,
+		)}</FONT>`;
+	}
+	return lInstabilityString;
 }
 
 export function folderify(pShowMetrics) {
-  /** @param {import("../../../types/cruise-result").IModule} pModule*/
-  return (pModule) => {
-    let lAdditions = {};
-    let lDirectoryName = dirname(pModule.source);
+	/** @param {import("../../../types/cruise-result").IModule} pModule*/
+	return (pModule) => {
+		let lAdditions = {};
+		let lDirectoryName = dirname(pModule.source);
 
-    if (lDirectoryName !== ".") {
-      lAdditions.folder = lDirectoryName;
-      lAdditions.path = lDirectoryName.split(sep).map(aggregate);
-    }
+		if (lDirectoryName !== ".") {
+			lAdditions.folder = lDirectoryName;
+			lAdditions.path = lDirectoryName.split(sep).map(aggregate);
+		}
 
-    lAdditions.label = `<${basename(pModule.source)}${makeInstabilityString(
-      pModule,
-      pShowMetrics,
-    )}>`;
-    lAdditions.tooltip = basename(pModule.source);
+		lAdditions.label = `<${basename(pModule.source)}${makeInstabilityString(
+			pModule,
+			pShowMetrics,
+		)}>`;
+		lAdditions.tooltip = basename(pModule.source);
 
-    return {
-      ...pModule,
-      ...lAdditions,
-    };
-  };
+		return {
+			...pModule,
+			...lAdditions,
+		};
+	};
 }
 
 /**
@@ -84,28 +84,28 @@ export function folderify(pShowMetrics) {
  * @returns {URL?: string}
  */
 export function addURL(pPrefix, pSuffix) {
-  return (pModule) => {
-    if (pModule.couldNotResolve) {
-      return pModule;
-    }
+	return (pModule) => {
+		if (pModule.couldNotResolve) {
+			return pModule;
+		}
 
-    return {
-      ...pModule,
-      URL: getURLForModule(pModule, pPrefix, pSuffix),
-    };
-  };
+		return {
+			...pModule,
+			URL: getURLForModule(pModule, pPrefix, pSuffix),
+		};
+	};
 }
 
 function makeLabel(pModule, pShowMetrics) {
-  return `<${dirname(pModule.source)}/<BR/><B>${basename(
-    pModule.source,
-  )}</B>${makeInstabilityString(pModule, pShowMetrics)}>`;
+	return `<${dirname(pModule.source)}/<BR/><B>${basename(
+		pModule.source,
+	)}</B>${makeInstabilityString(pModule, pShowMetrics)}>`;
 }
 
 export function flatLabel(pShowMetrics) {
-  return (pModule) => ({
-    ...pModule,
-    label: makeLabel(pModule, pShowMetrics),
-    tooltip: basename(pModule.source),
-  });
+	return (pModule) => ({
+		...pModule,
+		label: makeLabel(pModule, pShowMetrics),
+		tooltip: basename(pModule.source),
+	});
 }

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

@@ -5,25 +5,25 @@ import { compareModules } from "#graph-utl/compare.mjs";
 import stripSelfTransitions from "#graph-utl/strip-self-transitions.mjs";
 
 export default function prepareCustomLevel(
-  pResults,
-  pTheme,
-  pCollapsePattern,
-  pShowMetrics,
+	pResults,
+	pTheme,
+	pCollapsePattern,
+	pShowMetrics,
 ) {
-  return (
-    pCollapsePattern
-      ? consolidateToPattern(pResults.modules, pCollapsePattern)
-      : pResults.modules
-  )
-    .sort(compareModules)
-    .map(folderify(pShowMetrics))
-    .map(extractFirstTransgression)
-    .map(stripSelfTransitions)
-    .map(applyTheme(pTheme))
-    .map(
-      addURL(
-        pResults.summary.optionsUsed?.prefix ?? "",
-        pResults.summary.optionsUsed?.suffix ?? "",
-      ),
-    );
+	return (
+		pCollapsePattern
+			? consolidateToPattern(pResults.modules, pCollapsePattern)
+			: pResults.modules
+	)
+		.sort(compareModules)
+		.map(folderify(pShowMetrics))
+		.map(extractFirstTransgression)
+		.map(stripSelfTransitions)
+		.map(applyTheme(pTheme))
+		.map(
+			addURL(
+				pResults.summary.optionsUsed?.prefix ?? "",
+				pResults.summary.optionsUsed?.suffix ?? "",
+			),
+		);
 }

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

@@ -3,15 +3,15 @@ import { applyTheme } from "./theming.mjs";
 import { compareModules } from "#graph-utl/compare.mjs";
 
 export default function prepareFlatLevel(pResults, pTheme, _, pShowMetrics) {
-  return pResults.modules
-    .sort(compareModules)
-    .map(flatLabel(pShowMetrics))
-    .map(extractFirstTransgression)
-    .map(applyTheme(pTheme))
-    .map(
-      addURL(
-        pResults.summary.optionsUsed?.prefix ?? "",
-        pResults.summary.optionsUsed?.suffix ?? "",
-      ),
-    );
+	return pResults.modules
+		.sort(compareModules)
+		.map(flatLabel(pShowMetrics))
+		.map(extractFirstTransgression)
+		.map(applyTheme(pTheme))
+		.map(
+			addURL(
+				pResults.summary.optionsUsed?.prefix ?? "",
+				pResults.summary.optionsUsed?.suffix ?? "",
+			),
+		);
 }

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

@@ -3,19 +3,18 @@ import { applyTheme } from "./theming.mjs";
 import consolidateToFolder from "#graph-utl/consolidate-to-folder.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(compareModules)
-    .map(extractFirstTransgression)
-    .map(folderify(pShowMetrics))
-    .map(stripSelfTransitions)
-    .map(applyTheme(pTheme))
-    .map(
-      addURL(
-        pResults.summary.optionsUsed?.prefix ?? "",
-        pResults.summary.optionsUsed?.suffix ?? "",
-      ),
-    );
+	return consolidateToFolder(pResults.modules)
+		.sort(compareModules)
+		.map(extractFirstTransgression)
+		.map(folderify(pShowMetrics))
+		.map(stripSelfTransitions)
+		.map(applyTheme(pTheme))
+		.map(
+			addURL(
+				pResults.summary.optionsUsed?.prefix ?? "",
+				pResults.summary.optionsUsed?.suffix ?? "",
+			),
+		);
 }

package/src/report/dot/theming.mjs

@@ -3,96 +3,96 @@ import { attributizeObject } from "./module-utl.mjs";
 import { has, get } from "#utl/object-util.mjs";
 
 function matchesRE(pValue, pRE) {
-  const lMatchResult = pValue.match && pValue.match(pRE);
+	const lMatchResult = pValue.match && pValue.match(pRE);
 
-  return lMatchResult && lMatchResult.length > 0;
+	return lMatchResult && lMatchResult.length > 0;
 }
 
 function matchesCriterion(pModuleKey, pCriterion) {
-  return pModuleKey === pCriterion || matchesRE(pModuleKey, pCriterion);
+	return pModuleKey === pCriterion || matchesRE(pModuleKey, pCriterion);
 }
 
 function moduleOrDependencyMatchesCriteria(pSchemeEntry, pModule) {
-  return Object.keys(pSchemeEntry.criteria).every((pKey) => {
-    // the keys can have paths in them like {"rules[0].severity": "info"}
-    // To get the criterion treat that key as a string and not as a path
-    // eslint-disable-next-line security/detect-object-injection
-    const lCriterion = pSchemeEntry.criteria[pKey];
-    // we use a bespoke 'get' here because in the criteria you can enter
-    // nested keys like "rules[0].severity" : "error", and that function
-    // handles those for us
-    const lModuleKey = get(pModule, pKey);
+	return Object.keys(pSchemeEntry.criteria).every((pKey) => {
+		// the keys can have paths in them like {"rules[0].severity": "info"}
+		// To get the criterion treat that key as a string and not as a path
+		// eslint-disable-next-line security/detect-object-injection
+		const lCriterion = pSchemeEntry.criteria[pKey];
+		// we use a bespoke 'get' here because in the criteria you can enter
+		// nested keys like "rules[0].severity" : "error", and that function
+		// handles those for us
+		const lModuleKey = get(pModule, pKey);
 
-    if (!(lModuleKey || has(pModule, pKey))) {
-      return false;
-    }
+		if (!(lModuleKey || has(pModule, pKey))) {
+			return false;
+		}
 
-    if (Array.isArray(lModuleKey)) {
-      if (Array.isArray(lCriterion)) {
-        return lCriterion.some((pCriterionEntry) =>
-          lModuleKey.some((pModuleKeyEntry) =>
-            matchesCriterion(pModuleKeyEntry, pCriterionEntry),
-          ),
-        );
-      } else {
-        return lModuleKey.some((pModuleKeyEntry) =>
-          matchesCriterion(pModuleKeyEntry, lCriterion),
-        );
-      }
-    }
-    if (Array.isArray(lCriterion)) {
-      return lCriterion.some((pCriterionEntry) =>
-        matchesCriterion(lModuleKey, pCriterionEntry),
-      );
-    }
-    return matchesCriterion(lModuleKey, lCriterion);
-  });
+		if (Array.isArray(lModuleKey)) {
+			if (Array.isArray(lCriterion)) {
+				return lCriterion.some((pCriterionEntry) =>
+					lModuleKey.some((pModuleKeyEntry) =>
+						matchesCriterion(pModuleKeyEntry, pCriterionEntry),
+					),
+				);
+			} else {
+				return lModuleKey.some((pModuleKeyEntry) =>
+					matchesCriterion(pModuleKeyEntry, lCriterion),
+				);
+			}
+		}
+		if (Array.isArray(lCriterion)) {
+			return lCriterion.some((pCriterionEntry) =>
+				matchesCriterion(lModuleKey, pCriterionEntry),
+			);
+		}
+		return matchesCriterion(lModuleKey, lCriterion);
+	});
 }
 
 export function getThemeAttributes(pModuleOrDependency, pAttributeCriteria) {
-  return (pAttributeCriteria || [])
-    .filter((pSchemeEntry) =>
-      moduleOrDependencyMatchesCriteria(pSchemeEntry, pModuleOrDependency),
-    )
-    .map((pSchemeEntry) => pSchemeEntry.attributes)
-    .reduce((pAll, pCurrent) => ({ ...pCurrent, ...pAll }), {});
+	return (pAttributeCriteria || [])
+		.filter((pSchemeEntry) =>
+			moduleOrDependencyMatchesCriteria(pSchemeEntry, pModuleOrDependency),
+		)
+		.map((pSchemeEntry) => pSchemeEntry.attributes)
+		.reduce((pAll, pCurrent) => ({ ...pCurrent, ...pAll }), {});
 }
 
 export function normalizeTheme(pTheme) {
-  let lReturnValue = structuredClone(DEFAULT_THEME);
+	let lReturnValue = structuredClone(DEFAULT_THEME);
 
-  if (pTheme) {
-    if (pTheme.replace) {
-      lReturnValue = pTheme;
-    } else {
-      lReturnValue.graph = { ...DEFAULT_THEME.graph, ...pTheme.graph };
-      lReturnValue.node = { ...DEFAULT_THEME.node, ...pTheme.node };
-      lReturnValue.edge = { ...DEFAULT_THEME.edge, ...pTheme.edge };
-      lReturnValue.modules = (pTheme.modules || []).concat(
-        DEFAULT_THEME.modules,
-      );
-      lReturnValue.dependencies = (pTheme.dependencies || []).concat(
-        DEFAULT_THEME.dependencies,
-      );
-    }
-  }
-  return lReturnValue;
+	if (pTheme) {
+		if (pTheme.replace) {
+			lReturnValue = pTheme;
+		} else {
+			lReturnValue.graph = { ...DEFAULT_THEME.graph, ...pTheme.graph };
+			lReturnValue.node = { ...DEFAULT_THEME.node, ...pTheme.node };
+			lReturnValue.edge = { ...DEFAULT_THEME.edge, ...pTheme.edge };
+			lReturnValue.modules = (pTheme.modules || []).concat(
+				DEFAULT_THEME.modules,
+			);
+			lReturnValue.dependencies = (pTheme.dependencies || []).concat(
+				DEFAULT_THEME.dependencies,
+			);
+		}
+	}
+	return lReturnValue;
 }
 
 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)),
-  });
+	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/dot-webpage/dot-module.mjs

@@ -4,8 +4,8 @@ import dotModuleReporter from "../dot/dot-module.mjs";
 import { wrapInHTML } from "./wrap-in-html.mjs";
 
 const CONSTANTS = {
-  exec: "dot",
-  format: "svg",
+	exec: "dot",
+	format: "svg",
 };
 
 /**
@@ -14,22 +14,22 @@ const CONSTANTS = {
  * @returns {string} the dot program converted to svg, wrapped in html
  */
 function convert(pDot, pOptions) {
-  /* c8 ignore next */
-  const lSpawnFunction = pOptions.spawnFunction || spawnSync;
-  const { stdout, status, error } = lSpawnFunction(
-    CONSTANTS.exec,
-    [`-T${CONSTANTS.format}`],
-    {
-      input: pDot,
-    },
-  );
-  if (status === 0) {
-    return stdout.toString("utf8");
-  } else if (error) {
-    throw error;
-  } else {
-    throw new Error(`GraphViz' dot returned an error (exit code ${status})`);
-  }
+	/* c8 ignore next */
+	const lSpawnFunction = pOptions.spawnFunction || spawnSync;
+	const { stdout, status, error } = lSpawnFunction(
+		CONSTANTS.exec,
+		[`-T${CONSTANTS.format}`],
+		{
+			input: pDot,
+		},
+	);
+	if (status === 0) {
+		return stdout.toString("utf8");
+	} else if (error) {
+		throw error;
+	} else {
+		throw new Error(`GraphViz' dot returned an error (exit code ${status})`);
+	}
 }
 
 /**
@@ -37,12 +37,12 @@ function convert(pDot, pOptions) {
  * @returns {boolean}
  */
 function isAvailable(pOptions) {
-  /* c8 ignore next */
-  const lSpawnFunction = pOptions.spawnFunction || spawnSync;
-  const { status, stderr } = lSpawnFunction(CONSTANTS.exec, ["-V"]);
-  return (
-    status === 0 && stderr.toString("utf8").startsWith("dot - graphviz version")
-  );
+	/* c8 ignore next */
+	const lSpawnFunction = pOptions.spawnFunction || spawnSync;
+	const { status, stderr } = lSpawnFunction(CONSTANTS.exec, ["-V"]);
+	return (
+		status === 0 && stderr.toString("utf8").startsWith("dot - graphviz version")
+	);
 }
 
 /**
@@ -61,16 +61,16 @@ function isAvailable(pOptions) {
  * @returns {IReporterOutput}
  */
 export default function dotWebpage(pResults, pDotWebpageReporterOptions) {
-  if (!isAvailable(pDotWebpageReporterOptions)) {
-    throw new Error(
-      "GraphViz dot, which is required for the 'x-dot-webpage' reporter doesn't " +
-        "seem to be available on this system. See the GraphViz download page for " +
-        "instruction on how to get it on your system: https://www.graphviz.org/download/",
-    );
-  }
-  const { output } = dotModuleReporter(pResults, pDotWebpageReporterOptions);
-  return {
-    output: wrapInHTML(convert(output, pDotWebpageReporterOptions)),
-    exitCode: 0,
-  };
+	if (!isAvailable(pDotWebpageReporterOptions)) {
+		throw new Error(
+			"GraphViz dot, which is required for the 'x-dot-webpage' reporter doesn't " +
+				"seem to be available on this system. See the GraphViz download page for " +
+				"instruction on how to get it on your system: https://www.graphviz.org/download/",
+		);
+	}
+	const { output } = dotModuleReporter(pResults, pDotWebpageReporterOptions);
+	return {
+		output: wrapInHTML(convert(output, pDotWebpageReporterOptions)),
+		exitCode: 0,
+	};
 }