dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/report/error.mjs

@@ -1,142 +1,142 @@
 import { EOL } from "node:os";
 import { styleText } from "node:util";
 import {
-  formatPercentage,
-  formatViolation as _formatViolation,
+	formatPercentage,
+	formatViolation as _formatViolation,
 } from "./utl/index.mjs";
 import { findRuleByName } from "#graph-utl/rule-set.mjs";
 import wrapAndIndent from "#utl/wrap-and-indent.mjs";
 
 const SEVERITY2COLOR = new Map([
-  ["error", "red"],
-  ["warn", "yellow"],
-  ["info", "cyan"],
-  ["ignore", "gray"],
+	["error", "red"],
+	["warn", "yellow"],
+	["info", "cyan"],
+	["ignore", "gray"],
 ]);
 
 const EXTRA_PATH_INFORMATION_INDENT = 6;
 
 function formatMiniDependency(pMiniDependency) {
-  return EOL.concat(
-    wrapAndIndent(
-      pMiniDependency.map(({ name }) => name).join(` → ${EOL}`),
-      EXTRA_PATH_INFORMATION_INDENT,
-    ),
-  );
+	return EOL.concat(
+		wrapAndIndent(
+			pMiniDependency.map(({ name }) => name).join(` → ${EOL}`),
+			EXTRA_PATH_INFORMATION_INDENT,
+		),
+	);
 }
 
 function formatModuleViolation(pViolation) {
-  return styleText("bold", pViolation.from);
+	return styleText("bold", pViolation.from);
 }
 
 function formatDependencyViolation(pViolation) {
-  return `${styleText("bold", pViolation.from)} → ${styleText("bold", pViolation.to)}`;
+	return `${styleText("bold", pViolation.from)} → ${styleText("bold", pViolation.to)}`;
 }
 
 function formatCycleViolation(pViolation) {
-  return `${styleText("bold", pViolation.from)} → ${formatMiniDependency(pViolation.cycle)}`;
+	return `${styleText("bold", pViolation.from)} → ${formatMiniDependency(pViolation.cycle)}`;
 }
 
 function formatReachabilityViolation(pViolation) {
-  return `${styleText("bold", pViolation.from)} → ${styleText("bold", pViolation.to)}${formatMiniDependency(pViolation.via)}`;
+	return `${styleText("bold", pViolation.from)} → ${styleText("bold", pViolation.to)}${formatMiniDependency(pViolation.via)}`;
 }
 
 function formatInstabilityViolation(pViolation) {
-  return `${formatDependencyViolation(pViolation)}${EOL}${styleText(
-    "dim",
-    wrapAndIndent(
-      `instability: ${formatPercentage(pViolation.metrics.from.instability)} → ${formatPercentage(pViolation.metrics.to.instability)}`,
-      EXTRA_PATH_INFORMATION_INDENT,
-    ),
-  )}`;
+	return `${formatDependencyViolation(pViolation)}${EOL}${styleText(
+		"dim",
+		wrapAndIndent(
+			`instability: ${formatPercentage(pViolation.metrics.from.instability)} → ${formatPercentage(pViolation.metrics.to.instability)}`,
+			EXTRA_PATH_INFORMATION_INDENT,
+		),
+	)}`;
 }
 
 function formatViolation(pViolation) {
-  const lViolationType2Formatter = {
-    module: formatModuleViolation,
-    dependency: formatDependencyViolation,
-    cycle: formatCycleViolation,
-    reachability: formatReachabilityViolation,
-    instability: formatInstabilityViolation,
-  };
-  const lFormattedViolators = _formatViolation(
-    pViolation,
-    lViolationType2Formatter,
-    formatDependencyViolation,
-  );
-
-  return (
-    `${styleText(
-      SEVERITY2COLOR.get(pViolation.rule.severity),
-      pViolation.rule.severity,
-    )} ${pViolation.rule.name}: ${lFormattedViolators}` +
-    `${
-      pViolation.comment
-        ? `${EOL}${styleText("dim", wrapAndIndent(pViolation.comment))}${EOL}`
-        : ""
-    }`
-  );
+	const lViolationType2Formatter = {
+		module: formatModuleViolation,
+		dependency: formatDependencyViolation,
+		cycle: formatCycleViolation,
+		reachability: formatReachabilityViolation,
+		instability: formatInstabilityViolation,
+	};
+	const lFormattedViolators = _formatViolation(
+		pViolation,
+		lViolationType2Formatter,
+		formatDependencyViolation,
+	);
+
+	return (
+		`${styleText(
+			SEVERITY2COLOR.get(pViolation.rule.severity),
+			pViolation.rule.severity,
+		)} ${pViolation.rule.name}: ${lFormattedViolators}` +
+		`${
+			pViolation.comment
+				? `${EOL}${styleText("dim", wrapAndIndent(pViolation.comment))}${EOL}`
+				: ""
+		}`
+	);
 }
 
 function formatMeta(pMeta) {
-  return `${pMeta.error} errors, ${pMeta.warn} warnings`;
+	return `${pMeta.error} errors, ${pMeta.warn} warnings`;
 }
 
 function sumMeta(pMeta) {
-  return pMeta.error + pMeta.warn + pMeta.info;
+	return pMeta.error + pMeta.warn + pMeta.info;
 }
 
 function formatSummary(pSummary) {
-  let lMessage = `${EOL}x ${sumMeta(
-    pSummary,
-  )} dependency violations (${formatMeta(pSummary)}). ${
-    pSummary.totalCruised
-  } modules, ${pSummary.totalDependenciesCruised} dependencies cruised.${EOL}`;
+	let lMessage = `${EOL}x ${sumMeta(
+		pSummary,
+	)} dependency violations (${formatMeta(pSummary)}). ${
+		pSummary.totalCruised
+	} modules, ${pSummary.totalDependenciesCruised} dependencies cruised.${EOL}`;
 
-  return pSummary.error > 0 ? styleText("red", lMessage) : lMessage;
+	return pSummary.error > 0 ? styleText("red", lMessage) : lMessage;
 }
 
 function addExplanation(pRuleSet, pLong) {
-  return pLong
-    ? (pViolation) => ({
-        ...pViolation,
-        comment: findRuleByName(pRuleSet, pViolation.rule.name)?.comment ?? "-",
-      })
-    : (pViolation) => pViolation;
+	return pLong
+		? (pViolation) => ({
+				...pViolation,
+				comment: findRuleByName(pRuleSet, pViolation.rule.name)?.comment ?? "-",
+			})
+		: (pViolation) => pViolation;
 }
 
 function formatIgnoreWarning(pNumberOfIgnoredViolations) {
-  if (pNumberOfIgnoredViolations > 0) {
-    return styleText(
-      "yellow",
-      `‼ ${pNumberOfIgnoredViolations} known violations ignored. Run with --no-ignore-known to see them.${EOL}`,
-    );
-  }
-  return "";
+	if (pNumberOfIgnoredViolations > 0) {
+		return styleText(
+			"yellow",
+			`‼ ${pNumberOfIgnoredViolations} known violations ignored. Run with --no-ignore-known to see them.${EOL}`,
+		);
+	}
+	return "";
 }
 
 function report(pResults, pLong) {
-  const lNonIgnorableViolations = pResults.summary.violations.filter(
-    (pViolation) => pViolation.rule.severity !== "ignore",
-  );
-
-  if (lNonIgnorableViolations.length === 0) {
-    return `${EOL}${styleText("green", "✔")} no dependency violations found (${
-      pResults.summary.totalCruised
-    } modules, ${
-      pResults.summary.totalDependenciesCruised
-    } dependencies cruised)${EOL}${formatIgnoreWarning(
-      pResults.summary.ignore,
-    )}${EOL}`;
-  }
-
-  return lNonIgnorableViolations
-    .reverse()
-    .map(addExplanation(pResults.summary.ruleSetUsed, pLong))
-    .reduce((pAll, pThis) => `${pAll}  ${formatViolation(pThis)}${EOL}`, EOL)
-    .concat(formatSummary(pResults.summary))
-    .concat(formatIgnoreWarning(pResults.summary.ignore))
-    .concat(EOL);
+	const lNonIgnorableViolations = pResults.summary.violations.filter(
+		(pViolation) => pViolation.rule.severity !== "ignore",
+	);
+
+	if (lNonIgnorableViolations.length === 0) {
+		return `${EOL}${styleText("green", "✔")} no dependency violations found (${
+			pResults.summary.totalCruised
+		} modules, ${
+			pResults.summary.totalDependenciesCruised
+		} dependencies cruised)${EOL}${formatIgnoreWarning(
+			pResults.summary.ignore,
+		)}${EOL}`;
+	}
+
+	return lNonIgnorableViolations
+		.reverse()
+		.map(addExplanation(pResults.summary.ruleSetUsed, pLong))
+		.reduce((pAll, pThis) => `${pAll}  ${formatViolation(pThis)}${EOL}`, EOL)
+		.concat(formatSummary(pResults.summary))
+		.concat(formatIgnoreWarning(pResults.summary.ignore))
+		.concat(EOL);
 }
 
 /**
@@ -153,8 +153,8 @@ function report(pResults, pLong) {
  *                              exitCode: the number of errors found
  */
 export default function error(pResults, pOptions) {
-  return {
-    output: report(pResults, (pOptions || {}).long),
-    exitCode: pResults.summary.error,
-  };
+	return {
+		output: report(pResults, (pOptions || {}).long),
+		exitCode: pResults.summary.error,
+	};
 }

package/src/report/html/index.mjs

@@ -7,71 +7,71 @@ import templateText from "./html-template.mjs";
 const EOL = "\n";
 
 function addShowTitle(pDependencyEntry) {
-  return {
-    ...pDependencyEntry,
-    incidences: pDependencyEntry.incidences.map((pIncidence) => ({
-      ...pIncidence,
-      hasRelation: pIncidence.incidence !== "false",
-    })),
-  };
+	return {
+		...pDependencyEntry,
+		incidences: pDependencyEntry.incidences.map((pIncidence) => ({
+			...pIncidence,
+			hasRelation: pIncidence.incidence !== "false",
+		})),
+	};
 }
 
 function getClasses(pModule, pOtherClasses) {
-  let lClasses = pOtherClasses || [];
-  if (pModule.coreModule) {
-    lClasses.push("cell-core-module");
-  }
-  if (pModule.couldNotResolve) {
-    lClasses.push("cell-unresolvable-module");
-  }
-  return lClasses.length > 0 ? ` class="${lClasses.join(" ")}"` : "";
+	let lClasses = pOtherClasses || [];
+	if (pModule.coreModule) {
+		lClasses.push("cell-core-module");
+	}
+	if (pModule.couldNotResolve) {
+		lClasses.push("cell-unresolvable-module");
+	}
+	return lClasses.length > 0 ? ` class="${lClasses.join(" ")}"` : "";
 }
 
 function constructTableHead(pModules) {
-  return pModules
-    .map(
-      (pModule) =>
-        `<th><div${getClasses(pModule)}>${pModule.source}</div></th>`,
-    )
-    .join("");
+	return pModules
+		.map(
+			(pModule) =>
+				`<th><div${getClasses(pModule)}>${pModule.source}</div></th>`,
+		)
+		.join("");
 }
 
 function constructTableCellTitle(pModule, pIncidence) {
-  let lTitleLines = [];
-  if (pIncidence.rule) {
-    lTitleLines.push(`${pIncidence.rule}:`);
-  }
-  if (pIncidence.hasRelation) {
-    lTitleLines.push(`${pModule.source} -> ${pIncidence.to}`);
-  }
-  return lTitleLines.length > 0 ? ` title="${lTitleLines.join(EOL)}"` : "";
+	let lTitleLines = [];
+	if (pIncidence.rule) {
+		lTitleLines.push(`${pIncidence.rule}:`);
+	}
+	if (pIncidence.hasRelation) {
+		lTitleLines.push(`${pModule.source} -> ${pIncidence.to}`);
+	}
+	return lTitleLines.length > 0 ? ` title="${lTitleLines.join(EOL)}"` : "";
 }
 
 function constructTableCell(pModule) {
-  return (pIncidence) => {
-    const lReturnValue = `<td class="cell cell-${
-      pIncidence.incidence
-    }"${constructTableCellTitle(pModule, pIncidence)}></td>`;
-    return lReturnValue;
-  };
+	return (pIncidence) => {
+		const lReturnValue = `<td class="cell cell-${
+			pIncidence.incidence
+		}"${constructTableCellTitle(pModule, pIncidence)}></td>`;
+		return lReturnValue;
+	};
 }
 
 function constructTableRow(pModule) {
-  const lReturnValue = `
+	const lReturnValue = `
       <tr>
         <td${getClasses(pModule, ["first-cell"])}>${pModule.source}</td>
         ${pModule.incidences.map(constructTableCell(pModule)).join("")}
         <td${getClasses(pModule, ["first-cell"])}>${pModule.source}</td>
       </tr>`;
-  return lReturnValue;
+	return lReturnValue;
 }
 
 function constructTableBody(pModules) {
-  return pModules.map(constructTableRow).join("");
+	return pModules.map(constructTableRow).join("");
 }
 
 function constructTable(pModules) {
-  const lReturnValue = `
+	const lReturnValue = `
   <table id="table-rotated">
     <thead>
       <tr>
@@ -96,14 +96,14 @@ function constructTable(pModules) {
   </table>
 `;
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 function report(pResults) {
-  const lModules = dependencyToIncidenceTransformer(pResults.modules).map(
-    addShowTitle,
-  );
-  return templateText.replace("{{table-here}}", constructTable(lModules));
+	const lModules = dependencyToIncidenceTransformer(pResults.modules).map(
+		addShowTitle,
+	);
+	return templateText.replace("{{table-here}}", constructTable(lModules));
 }
 
 /**
@@ -113,8 +113,8 @@ function report(pResults) {
  * @returns {import("../../../types/dependency-cruiser.js").IReporterOutput}
  */
 export default function html(pResults) {
-  return {
-    output: report(pResults),
-    exitCode: 0,
-  };
+	return {
+		output: report(pResults),
+		exitCode: 0,
+	};
 }

package/src/report/identity.mjs

@@ -5,8 +5,8 @@
  * @returns {import("../../types/dependency-cruiser").IReporterOutput}
  */
 export default function identity(pResults) {
-  return {
-    output: pResults,
-    exitCode: 0,
-  };
+	return {
+		output: pResults,
+		exitCode: 0,
+	};
 }

package/src/report/index.mjs

@@ -1,29 +1,29 @@
 import { getExternalPluginReporter } from "./plugins.mjs";
 
 const TYPE2MODULE = new Map([
-  ["anon", "./anon/index.mjs"],
-  ["archi", "./dot/dot-custom.mjs"],
-  ["azure-devops", "./azure-devops.mjs"],
-  ["baseline", "./baseline.mjs"],
-  ["cdot", "./dot/dot-custom.mjs"],
-  ["csv", "./csv.mjs"],
-  ["d2", "./d2.mjs"],
-  ["ddot", "./dot/dot-folder.mjs"],
-  ["dot", "./dot/dot-module.mjs"],
-  ["err-html", "./error-html/index.mjs"],
-  ["err-long", "./error-long.mjs"],
-  ["err", "./error.mjs"],
-  ["fdot", "./dot/dot-flat.mjs"],
-  ["flat", "./dot/dot-flat.mjs"],
-  ["html", "./html/index.mjs"],
-  ["json", "./json.mjs"],
-  ["markdown", "./markdown.mjs"],
-  ["mermaid", "./mermaid.mjs"],
-  ["metrics", "./metrics.mjs"],
-  ["null", "./null.mjs"],
-  ["teamcity", "./teamcity.mjs"],
-  ["text", "./text.mjs"],
-  ["x-dot-webpage", "./dot-webpage/dot-module.mjs"],
+	["anon", "./anon/index.mjs"],
+	["archi", "./dot/dot-custom.mjs"],
+	["azure-devops", "./azure-devops.mjs"],
+	["baseline", "./baseline.mjs"],
+	["cdot", "./dot/dot-custom.mjs"],
+	["csv", "./csv.mjs"],
+	["d2", "./d2.mjs"],
+	["ddot", "./dot/dot-folder.mjs"],
+	["dot", "./dot/dot-module.mjs"],
+	["err-html", "./error-html/index.mjs"],
+	["err-long", "./error-long.mjs"],
+	["err", "./error.mjs"],
+	["fdot", "./dot/dot-flat.mjs"],
+	["flat", "./dot/dot-flat.mjs"],
+	["html", "./html/index.mjs"],
+	["json", "./json.mjs"],
+	["markdown", "./markdown.mjs"],
+	["mermaid", "./mermaid.mjs"],
+	["metrics", "./metrics.mjs"],
+	["null", "./null.mjs"],
+	["teamcity", "./teamcity.mjs"],
+	["text", "./text.mjs"],
+	["x-dot-webpage", "./dot-webpage/dot-module.mjs"],
 ]);
 
 /**
@@ -36,15 +36,15 @@ const TYPE2MODULE = new Map([
  *                       and returns an IReporterOutput
  */
 export async function getReporter(pOutputType) {
-  let lReturnValue = {};
-  if (pOutputType?.startsWith("plugin:")) {
-    lReturnValue = await getExternalPluginReporter(pOutputType);
-  } else {
-    const lModuleToImport = TYPE2MODULE.get(pOutputType) ?? "./identity.mjs";
-    const lModule = await import(lModuleToImport);
-    lReturnValue = lModule.default;
-  }
-  return lReturnValue;
+	let lReturnValue = {};
+	if (pOutputType?.startsWith("plugin:")) {
+		lReturnValue = await getExternalPluginReporter(pOutputType);
+	} else {
+		const lModuleToImport = TYPE2MODULE.get(pOutputType) ?? "./identity.mjs";
+		const lModule = await import(lModuleToImport);
+		lReturnValue = lModule.default;
+	}
+	return lReturnValue;
 }
 
 /**
@@ -53,5 +53,5 @@ export async function getReporter(pOutputType) {
  * @returns {import("../../types/shared-types.js").OutputType[]} -
  */
 export function getAvailableReporters() {
-  return Array.from(TYPE2MODULE.keys());
+	return Array.from(TYPE2MODULE.keys());
 }

package/src/report/json.mjs

@@ -6,8 +6,8 @@ const EOL = "\n";
  * @returns {import("../../types/dependency-cruiser").IReporterOutput}
  */
 export default function json(pResults) {
-  return {
-    output: JSON.stringify(pResults, null, "  ") + EOL,
-    exitCode: 0,
-  };
+	return {
+		output: JSON.stringify(pResults, null, "  ") + EOL,
+		exitCode: 0,
+	};
 }