dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/cli/init-config/validators.mjs

@@ -2,15 +2,15 @@ import { statSync } from "node:fs";
 import { toSourceLocationArray } from "./environment-helpers.mjs";
 
 export function validateLocation(pLocations) {
-  for (const lLocation of toSourceLocationArray(pLocations)) {
-    try {
-      if (!statSync(lLocation).isDirectory()) {
-        return `'${lLocation}' doesn't seem to be a folder - please try again`;
-      }
-    } catch (pError) {
-      return `'${lLocation}' doesn't seem to exist - please try again`;
-    }
-  }
+	for (const lLocation of toSourceLocationArray(pLocations)) {
+		try {
+			if (!statSync(lLocation).isDirectory()) {
+				return `'${lLocation}' doesn't seem to be a folder - please try again`;
+			}
+		} catch (pError) {
+			return `'${lLocation}' doesn't seem to exist - please try again`;
+		}
+	}
 
-  return true;
+	return true;
 }

package/src/cli/init-config/write-config.mjs

@@ -1,8 +1,8 @@
 import { writeFileSync } from "node:fs";
 import { styleText } from "node:util";
 import {
-  fileExists,
-  getDefaultConfigFileName,
+	fileExists,
+	getDefaultConfigFileName,
 } from "./environment-helpers.mjs";
 
 /**
@@ -19,24 +19,24 @@ import {
  *
  */
 export default function writeConfig(
-  pConfig,
-  pFileName = getDefaultConfigFileName(),
-  pOutStream = process.stdout,
+	pConfig,
+	pFileName = getDefaultConfigFileName(),
+	pOutStream = process.stdout,
 ) {
-  if (fileExists(pFileName)) {
-    throw new Error(`A '${pFileName}' already exists here - leaving it be.\n`);
-  } else {
-    try {
-      writeFileSync(pFileName, pConfig);
-      pOutStream.write(
-        `\n  ${styleText("green", "✔")} Successfully created '${pFileName}'\n\n`,
-      );
-      /* c8 ignore start */
-    } catch (pError) {
-      throw new Error(
-        `ERROR: Writing to '${pFileName}' didn't work. ${pError}\n`,
-      );
-    }
-    /* c8 ignore stop */
-  }
+	if (fileExists(pFileName)) {
+		throw new Error(`A '${pFileName}' already exists here - leaving it be.\n`);
+	} else {
+		try {
+			writeFileSync(pFileName, pConfig);
+			pOutStream.write(
+				`\n  ${styleText("green", "✔")} Successfully created '${pFileName}'\n\n`,
+			);
+			/* c8 ignore start */
+		} catch (pError) {
+			throw new Error(
+				`ERROR: Writing to '${pFileName}' didn't work. ${pError}\n`,
+			);
+		}
+		/* c8 ignore stop */
+	}
 }

package/src/cli/init-config/write-run-scripts-to-manifest.mjs

@@ -10,52 +10,52 @@ import { folderNameArrayToRE } from "./utl.mjs";
 const PACKAGE_MANIFEST = `./${_PACKAGE_MANIFEST}`;
 
 const EXPERIMENTAL_SCRIPT_DOC = [
-  {
-    name: "depcruise",
-    headline: "npm run depcruise",
-    description:
-      "      validates against the rules in .dependency-cruiser.js and writes the" +
-      EOL +
-      "      outcome to stdout",
-  },
-  {
-    name: "depcruise:html",
-    headline: "npm run depcruise:html",
-    description:
-      "      validates against the rules in .dependency-cruiser.js and writes it to" +
-      EOL +
-      "      'dependency-violation-report.html' with a friendly layout",
-  },
-  {
-    name: "depcruise:graph",
-    headline: "npm run depcruise:graph",
-    description:
-      "      writes a detailed internal graph of your app to 'dependency-graph.html'",
-  },
-  {
-    name: "depcruise:graph:dev",
-    headline: "npm run depcruise:graph:dev",
-    description:
-      "      opens a detailed internal graph of your app in your default browser" +
-      EOL +
-      "      (uses the 'browser' command line program)",
-  },
-  {
-    name: "depcruise:graph:archi",
-    headline: "depcruise:graph:archi",
-    description:
-      "      writes a high-level internal graph of your app to" +
-      EOL +
-      "      'high-level-dependency-graph.html",
-  },
-  {
-    name: "depcruise:focus",
-    headline: "npm run depcruise:focus <regex>",
-    description:
-      "      writes all dependencies to and from modules matching the given <regex>" +
-      EOL +
-      "      to stdout - in simple text",
-  },
+	{
+		name: "depcruise",
+		headline: "npm run depcruise",
+		description:
+			"      validates against the rules in .dependency-cruiser.js and writes the" +
+			EOL +
+			"      outcome to stdout",
+	},
+	{
+		name: "depcruise:html",
+		headline: "npm run depcruise:html",
+		description:
+			"      validates against the rules in .dependency-cruiser.js and writes it to" +
+			EOL +
+			"      'dependency-violation-report.html' with a friendly layout",
+	},
+	{
+		name: "depcruise:graph",
+		headline: "npm run depcruise:graph",
+		description:
+			"      writes a detailed internal graph of your app to 'dependency-graph.html'",
+	},
+	{
+		name: "depcruise:graph:dev",
+		headline: "npm run depcruise:graph:dev",
+		description:
+			"      opens a detailed internal graph of your app in your default browser" +
+			EOL +
+			"      (uses the 'browser' command line program)",
+	},
+	{
+		name: "depcruise:graph:archi",
+		headline: "depcruise:graph:archi",
+		description:
+			"      writes a high-level internal graph of your app to" +
+			EOL +
+			"      'high-level-dependency-graph.html",
+	},
+	{
+		name: "depcruise:focus",
+		headline: "npm run depcruise:focus <regex>",
+		description:
+			"      writes all dependencies to and from modules matching the given <regex>" +
+			EOL +
+			"      to stdout - in simple text",
+	},
 ];
 
 /**
@@ -63,25 +63,25 @@ const EXPERIMENTAL_SCRIPT_DOC = [
  * @return {any} an bunch of key value pairs that can be plonked into a `scripts` attribute in a package.json
  */
 export function compileRunScripts(pInitOptions) {
-  let lReturnValue = {};
+	let lReturnValue = {};
 
-  if (pInitOptions && (pInitOptions.sourceLocation || []).length > 0) {
-    const lSourceLocations = pInitOptions.sourceLocation.join(" ");
-    const lSourceLocationRE = folderNameArrayToRE(pInitOptions.sourceLocation);
-    const lTestLocations = (pInitOptions.testLocation || []).join(" ");
+	if (pInitOptions && (pInitOptions.sourceLocation || []).length > 0) {
+		const lSourceLocations = pInitOptions.sourceLocation.join(" ");
+		const lSourceLocationRE = folderNameArrayToRE(pInitOptions.sourceLocation);
+		const lTestLocations = (pInitOptions.testLocation || []).join(" ");
 
-    lReturnValue = {
-      depcruise: `depcruise ${lSourceLocations} ${lTestLocations}`,
-      "depcruise:graph": `depcruise ${lSourceLocations} --include-only '${lSourceLocationRE}' --output-type dot | dot -T svg | depcruise-wrap-stream-in-html > dependency-graph.html`,
-      "depcruise:graph:dev": `depcruise ${lSourceLocations} --include-only '${lSourceLocationRE}' --prefix vscode://file/$(pwd)/ --output-type dot | dot -T svg | depcruise-wrap-stream-in-html | browser`,
-      "depcruise:graph:archi": `depcruise ${lSourceLocations} --include-only '${lSourceLocationRE}' --output-type archi | dot -T svg | depcruise-wrap-stream-in-html > high-level-dependency-graph.html`,
-      "depcruise:html": `depcruise ${lSourceLocations} ${lTestLocations} --progress --output-type err-html --output-to dependency-violation-report.html`,
-      "depcruise:text": `depcruise ${lSourceLocations} ${lTestLocations} --progress --output-type text`,
-      "depcruise:focus": `depcruise ${lSourceLocations} ${lTestLocations} --progress --output-type text --focus`,
-    };
-  }
+		lReturnValue = {
+			depcruise: `depcruise ${lSourceLocations} ${lTestLocations}`,
+			"depcruise:graph": `depcruise ${lSourceLocations} --include-only '${lSourceLocationRE}' --output-type dot | dot -T svg | depcruise-wrap-stream-in-html > dependency-graph.html`,
+			"depcruise:graph:dev": `depcruise ${lSourceLocations} --include-only '${lSourceLocationRE}' --prefix vscode://file/$(pwd)/ --output-type dot | dot -T svg | depcruise-wrap-stream-in-html | browser`,
+			"depcruise:graph:archi": `depcruise ${lSourceLocations} --include-only '${lSourceLocationRE}' --output-type archi | dot -T svg | depcruise-wrap-stream-in-html > high-level-dependency-graph.html`,
+			"depcruise:html": `depcruise ${lSourceLocations} ${lTestLocations} --progress --output-type err-html --output-to dependency-violation-report.html`,
+			"depcruise:text": `depcruise ${lSourceLocations} ${lTestLocations} --progress --output-type text`,
+			"depcruise:focus": `depcruise ${lSourceLocations} ${lTestLocations} --progress --output-type text --focus`,
+		};
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 /**
@@ -95,41 +95,37 @@ export function compileRunScripts(pInitOptions) {
  * pExistingRunScripts
  */
 function filterNewScriptEntries(pExistingRunScripts, pAdditionalRunScripts) {
-  return Object.keys(pAdditionalRunScripts || {})
-    .filter((pKey) => !pExistingRunScripts[pKey])
-    .reduce((pAll, pKey) => {
-      pAll[pKey] = pAdditionalRunScripts[pKey];
-      return pAll;
-    }, {});
+	return Object.keys(pAdditionalRunScripts || {})
+		.filter((pKey) => !pExistingRunScripts[pKey])
+		.reduce((pAll, pKey) => {
+			pAll[pKey] = pAdditionalRunScripts[pKey];
+			return pAll;
+		}, {});
 }
 
 export function addRunScriptsToManifest(pManifest, pAdditionalRunScripts) {
-  const lManifest = { ...(pManifest || {}) };
-  const lExistingRunScripts = lManifest.scripts || {};
+	const lManifest = { ...(pManifest || {}) };
+	const lExistingRunScripts = lManifest.scripts || {};
 
-  // This could instead be done with
-  // {...pAdditionalScriptEntries, ...lManifest} and no logic at all,
-  // but that'd add the new scripts on top, which doesn't feel right
-  //
-  // An alternative would be to sort the keys - but that'd be rude
-  lManifest.scripts = {
-    ...lExistingRunScripts,
-    ...filterNewScriptEntries(lExistingRunScripts, pAdditionalRunScripts),
-  };
+	// This ensures the new scripts are added _below_ the ones currently in the manifest
+	lManifest.scripts = {
+		...lExistingRunScripts,
+		...filterNewScriptEntries(lExistingRunScripts, pAdditionalRunScripts),
+	};
 
-  return lManifest;
+	return lManifest;
 }
 
 function getSuccessMessage(pDestinationManifestFileName) {
-  return EXPERIMENTAL_SCRIPT_DOC.reduce(
-    (pAll, pScript) => {
-      return `${pAll}${
-        `\n    ${styleText("green", "►")} ${pScript.headline}` +
-        `\n${pScript.description}\n\n`
-      }`;
-    },
-    `  ${styleText("green", "✔")} Run scripts added to '${pDestinationManifestFileName}':\n`,
-  );
+	return EXPERIMENTAL_SCRIPT_DOC.reduce(
+		(pAll, pScript) => {
+			return `${pAll}${
+				`\n    ${styleText("green", "►")} ${pScript.headline}` +
+				`\n${pScript.description}\n\n`
+			}`;
+		},
+		`  ${styleText("green", "✔")} Run scripts added to '${pDestinationManifestFileName}':\n`,
+	);
 }
 
 /**
@@ -138,24 +134,24 @@ function getSuccessMessage(pDestinationManifestFileName) {
  * @param {{manifest?: string, destinationManifestFileName?: string, outStream?: NodeJS.WritableStream}} pOptions
  */
 export function writeRunScriptsToManifest(pNormalizedInitOptions, pOptions) {
-  const lOptions = {
-    manifest: readManifest(),
-    destinationManifestFileName: PACKAGE_MANIFEST,
-    outStream: process.stdout,
-    ...pOptions,
-  };
-  const lUpdatedManifest = addRunScriptsToManifest(
-    lOptions.manifest,
-    compileRunScripts(pNormalizedInitOptions),
-  );
+	const lOptions = {
+		manifest: readManifest(),
+		destinationManifestFileName: PACKAGE_MANIFEST,
+		outStream: process.stdout,
+		...pOptions,
+	};
+	const lUpdatedManifest = addRunScriptsToManifest(
+		lOptions.manifest,
+		compileRunScripts(pNormalizedInitOptions),
+	);
 
-  writeFileSync(
-    lOptions.destinationManifestFileName,
-    JSON.stringify(lUpdatedManifest, null, "  "),
-    "utf8",
-  );
+	writeFileSync(
+		lOptions.destinationManifestFileName,
+		JSON.stringify(lUpdatedManifest, null, "  "),
+		"utf8",
+	);
 
-  lOptions.outStream.write(
-    getSuccessMessage(lOptions.destinationManifestFileName),
-  );
+	lOptions.outStream.write(
+		getSuccessMessage(lOptions.destinationManifestFileName),
+	);
 }

package/src/cli/listeners/cli-feedback.mjs

@@ -4,70 +4,70 @@ import { SUMMARY } from "#utl/bus.mjs";
 const FULL_ON = 100;
 
 function normalizeParameters(pParameters) {
-  return {
-    barSize: 10,
-    block: "■",
-    blank: "□",
-    ...(pParameters || {}),
-  };
+	return {
+		barSize: 10,
+		block: "■",
+		blank: "□",
+		...(pParameters || {}),
+	};
 }
 function getPercentageBar(pPercentage, pParameters) {
-  const lParameters = normalizeParameters(pParameters);
-  const lPercentage = Math.min(pPercentage || 0, 1);
-  const lBlocks = Math.floor(lParameters.barSize * lPercentage);
-  const lBlanks = lParameters.barSize - lBlocks;
+	const lParameters = normalizeParameters(pParameters);
+	const lPercentage = Math.min(pPercentage || 0, 1);
+	const lBlocks = Math.floor(lParameters.barSize * lPercentage);
+	const lBlanks = lParameters.barSize - lBlocks;
 
-  return `${styleText("green", lParameters.block.repeat(lBlocks))}${styleText(
-    "green",
-    lParameters.blank.repeat(lBlanks),
-  )} ${Math.round(FULL_ON * lPercentage)}%`;
+	return `${styleText("green", lParameters.block.repeat(lBlocks))}${styleText(
+		"green",
+		lParameters.blank.repeat(lBlanks),
+	)} ${Math.round(FULL_ON * lPercentage)}%`;
 }
 
 function getProgressMessageWriter(pStream, pState, pMaxLogLevel) {
-  return (pMessage, pOptions) => {
-    const lOptions = {
-      level: SUMMARY,
-      complete: pState.complete,
-      ...(pOptions || {}),
-    };
+	return (pMessage, pOptions) => {
+		const lOptions = {
+			level: SUMMARY,
+			complete: pState.complete,
+			...(pOptions || {}),
+		};
 
-    pState.complete = lOptions.complete;
+		pState.complete = lOptions.complete;
 
-    if (pStream.isTTY && lOptions.level <= pMaxLogLevel) {
-      pStream.clearLine(1);
-      pStream.write(
-        `  ${getPercentageBar(lOptions.complete)} ${pMessage} ...\n`,
-      );
-      pStream.moveCursor(0, -1);
-    }
-  };
+		if (pStream.isTTY && lOptions.level <= pMaxLogLevel) {
+			pStream.clearLine(1);
+			pStream.write(
+				`  ${getPercentageBar(lOptions.complete)} ${pMessage} ...\n`,
+			);
+			pStream.moveCursor(0, -1);
+		}
+	};
 }
 
 function getStartWriter(pStream) {
-  return () => {
-    // before writing the real business output make a decent attempt
-    // to clear the 'log' output so the cli behaviour looks more clean.
-    if (pStream.isTTY) {
-      pStream.moveCursor(0, 0);
-      pStream.clearLine(1);
-    }
-  };
+	return () => {
+		// before writing the real business output make a decent attempt
+		// to clear the 'log' output so the cli behaviour looks more clean.
+		if (pStream.isTTY) {
+			pStream.moveCursor(0, 0);
+			pStream.clearLine(1);
+		}
+	};
 }
 
 export default function setUpCliFeedbackListener(
-  pEventEmitter,
-  pMaxLogLevel = SUMMARY,
-  pStream = process.stderr,
+	pEventEmitter,
+	pMaxLogLevel = SUMMARY,
+	pStream = process.stderr,
 ) {
-  const lState = {
-    complete: 0,
-  };
-  pEventEmitter.on(
-    "progress",
-    getProgressMessageWriter(pStream, lState, pMaxLogLevel),
-  );
+	const lState = {
+		complete: 0,
+	};
+	pEventEmitter.on(
+		"progress",
+		getProgressMessageWriter(pStream, lState, pMaxLogLevel),
+	);
 
-  pEventEmitter.on("write-start", getStartWriter(pStream));
+	pEventEmitter.on("write-start", getStartWriter(pStream));
 
-  pEventEmitter.on("end", () => pStream.end());
+	pEventEmitter.on("end", () => pStream.end());
 }

package/src/cli/listeners/ndjson.mjs

@@ -4,87 +4,87 @@ import { INFO, SUMMARY } from "#utl/bus.mjs";
 const MICRO_SECONDS_PER_SECOND = 1000000;
 
 function formatPerfLine({
-  runStartTime,
-  message,
-  time,
-  elapsedTime,
-  elapsedUser,
-  elapsedSystem,
-  rss,
-  heapUsed,
-  heapTotal,
-  external,
+	runStartTime,
+	message,
+	time,
+	elapsedTime,
+	elapsedUser,
+	elapsedSystem,
+	rss,
+	heapUsed,
+	heapTotal,
+	external,
 }) {
-  return (
-    JSON.stringify({
-      runStartTime,
-      message,
-      time: Math.round(time * MICRO_SECONDS_PER_SECOND),
-      elapsedTime: Math.round(elapsedTime * MICRO_SECONDS_PER_SECOND),
-      elapsedUser,
-      elapsedSystem,
-      rss,
-      heapUsed,
-      heapTotal,
-      external,
-    }) + EOL
-  );
+	return (
+		JSON.stringify({
+			runStartTime,
+			message,
+			time: Math.round(time * MICRO_SECONDS_PER_SECOND),
+			elapsedTime: Math.round(elapsedTime * MICRO_SECONDS_PER_SECOND),
+			elapsedUser,
+			elapsedSystem,
+			rss,
+			heapUsed,
+			heapTotal,
+			external,
+		}) + EOL
+	);
 }
 
 function getProgressLine(pMessage, pState, pLevel, pMaxLevel) {
-  let lReturnValue = "";
+	let lReturnValue = "";
 
-  if (pLevel <= pMaxLevel) {
-    const lTime = process.uptime();
-    const { user, system } = process.cpuUsage();
-    const { rss, heapTotal, heapUsed, external } = process.memoryUsage();
-    const lStats = {
-      runStartTime: pState.runStartTime,
-      message: pState.previousMessage,
-      time: lTime,
-      elapsedTime: lTime - pState.previousTime,
-      elapsedUser: user - pState.previousUserUsage,
-      elapsedSystem: system - pState.previousSystemUsage,
-      rss,
-      heapUsed,
-      heapTotal,
-      external,
-    };
+	if (pLevel <= pMaxLevel) {
+		const lTime = process.uptime();
+		const { user, system } = process.cpuUsage();
+		const { rss, heapTotal, heapUsed, external } = process.memoryUsage();
+		const lStats = {
+			runStartTime: pState.runStartTime,
+			message: pState.previousMessage,
+			time: lTime,
+			elapsedTime: lTime - pState.previousTime,
+			elapsedUser: user - pState.previousUserUsage,
+			elapsedSystem: system - pState.previousSystemUsage,
+			rss,
+			heapUsed,
+			heapTotal,
+			external,
+		};
 
-    pState.previousMessage = pMessage;
-    pState.previousTime = lTime;
-    pState.previousUserUsage = user;
-    pState.previousSystemUsage = system;
+		pState.previousMessage = pMessage;
+		pState.previousTime = lTime;
+		pState.previousUserUsage = user;
+		pState.previousSystemUsage = system;
 
-    lReturnValue = formatPerfLine(lStats);
-  }
-  return lReturnValue;
+		lReturnValue = formatPerfLine(lStats);
+	}
+	return lReturnValue;
 }
 
 function getProgressWriter(pStream, pState, pMaxLevel) {
-  return (pMessage, pOptions) => {
-    const lOptions = { level: SUMMARY, ...(pOptions || {}) };
+	return (pMessage, pOptions) => {
+		const lOptions = { level: SUMMARY, ...(pOptions || {}) };
 
-    pStream.write(getProgressLine(pMessage, pState, lOptions.level, pMaxLevel));
-  };
+		pStream.write(getProgressLine(pMessage, pState, lOptions.level, pMaxLevel));
+	};
 }
 
 export default function setUpNDJSONListener(
-  pEventEmitter,
-  pMaxLevel = INFO,
-  pStream = process.stderr,
+	pEventEmitter,
+	pMaxLevel = INFO,
+	pStream = process.stderr,
 ) {
-  let lState = {
-    runStartTime: new Date(Date.now()).toISOString(),
-    previousMessage: "nodejs starting",
-    previousTime: 0,
-    previousUserUsage: 0,
-    previousSystemUsage: 0,
-  };
+	let lState = {
+		runStartTime: new Date(Date.now()).toISOString(),
+		previousMessage: "nodejs starting",
+		previousTime: 0,
+		previousUserUsage: 0,
+		previousSystemUsage: 0,
+	};
 
-  pEventEmitter.on("progress", getProgressWriter(pStream, lState, pMaxLevel));
+	pEventEmitter.on("progress", getProgressWriter(pStream, lState, pMaxLevel));
 
-  pEventEmitter.on("end", () => {
-    pStream.end();
-  });
+	pEventEmitter.on("end", () => {
+		pStream.end();
+	});
 }