dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/cli/normalize-cli-options.mjs

@@ -1,193 +1,193 @@
 import { accessSync, constants } from "node:fs";
 import { isAbsolute } from "node:path";
 import {
-  RULES_FILE_NAME_SEARCH_ARRAY,
-  DEFAULT_BASELINE_FILE_NAME,
-  OUTPUT_TO,
-  OUTPUT_TYPE,
-  WEBPACK_CONFIG,
-  TYPESCRIPT_CONFIG,
-  BABEL_CONFIG,
-  OLD_DEFAULT_RULES_FILE_NAME,
+	RULES_FILE_NAME_SEARCH_ARRAY,
+	DEFAULT_BASELINE_FILE_NAME,
+	OUTPUT_TO,
+	OUTPUT_TYPE,
+	WEBPACK_CONFIG,
+	TYPESCRIPT_CONFIG,
+	BABEL_CONFIG,
+	OLD_DEFAULT_RULES_FILE_NAME,
 } from "./defaults.mjs";
 import { set } from "#utl/object-util.mjs";
 import loadConfig from "#config-utl/extract-depcruise-config/index.mjs";
 
 function getOptionValue(pDefault) {
-  return (pValue) => (typeof pValue === "string" ? pValue : pDefault);
+	return (pValue) => (typeof pValue === "string" ? pValue : pDefault);
 }
 
 // eslint-disable-next-line complexity
 function normalizeConfigFileName(pCliOptions, pConfigWrapperName, pDefault) {
-  let lOptions = structuredClone(pCliOptions);
-
-  if (Object.hasOwn(lOptions, pConfigWrapperName)) {
-    set(
-      lOptions,
-      `ruleSet.options.${pConfigWrapperName}.fileName`,
-      getOptionValue(pDefault)(lOptions[pConfigWrapperName]),
-      /* eslint security/detect-object-injection: 0 */
-    );
-    Reflect.deleteProperty(lOptions, pConfigWrapperName);
-  }
-
-  if (
-    (lOptions?.ruleSet?.options?.[pConfigWrapperName] ?? null) &&
-    !(lOptions?.ruleSet?.options?.[pConfigWrapperName]?.fileName ?? null)
-  ) {
-    set(lOptions, `ruleSet.options.${pConfigWrapperName}.fileName`, pDefault);
-  }
-
-  return lOptions;
+	let lOptions = structuredClone(pCliOptions);
+
+	if (Object.hasOwn(lOptions, pConfigWrapperName)) {
+		set(
+			lOptions,
+			`ruleSet.options.${pConfigWrapperName}.fileName`,
+			getOptionValue(pDefault)(lOptions[pConfigWrapperName]),
+			/* eslint security/detect-object-injection: 0 */
+		);
+		Reflect.deleteProperty(lOptions, pConfigWrapperName);
+	}
+
+	if (
+		(lOptions?.ruleSet?.options?.[pConfigWrapperName] ?? null) &&
+		!(lOptions?.ruleSet?.options?.[pConfigWrapperName]?.fileName ?? null)
+	) {
+		set(lOptions, `ruleSet.options.${pConfigWrapperName}.fileName`, pDefault);
+	}
+
+	return lOptions;
 }
 
 function fileExists(pFileName) {
-  try {
-    accessSync(pFileName, constants.R_OK);
-    return true;
-  } catch (pError) {
-    return false;
-  }
+	try {
+		accessSync(pFileName, constants.R_OK);
+		return true;
+	} catch (pError) {
+		return false;
+	}
 }
 
 function validateAndGetCustomRulesFileName(pValidate) {
-  let lReturnValue = "";
-
-  if (fileExists(pValidate)) {
-    lReturnValue = pValidate;
-  } else {
-    throw new Error(
-      `Can't open config file '${pValidate}' for reading. Does it exist?\n` +
-        `         - You can create a config file by running 'npx dependency-cruiser --init'\n` +
-        `         - If you intended to run without a config file use --no-config\n`,
-    );
-  }
-  return lReturnValue;
+	let lReturnValue = "";
+
+	if (fileExists(pValidate)) {
+		lReturnValue = pValidate;
+	} else {
+		throw new Error(
+			`Can't open config file '${pValidate}' for reading. Does it exist?\n` +
+				`         - You can create a config file by running 'npx dependency-cruiser --init'\n` +
+				`         - If you intended to run without a config file use --no-config\n`,
+		);
+	}
+	return lReturnValue;
 }
 
 function validateAndGetDefaultRulesFileName() {
-  let lReturnValue = RULES_FILE_NAME_SEARCH_ARRAY.find(fileExists);
-
-  if (typeof lReturnValue === "undefined") {
-    throw new TypeError(
-      `Can't open a config file (.dependency-cruiser.(c)js) at the default location. Does it exist?\n` +
-        `         - You can create one by running 'npx dependency-cruiser --init'\n` +
-        `         - Want to run a without a config file? Use --no-config\n`,
-    );
-  }
-  return lReturnValue;
+	let lReturnValue = RULES_FILE_NAME_SEARCH_ARRAY.find(fileExists);
+
+	if (typeof lReturnValue === "undefined") {
+		throw new TypeError(
+			`Can't open a config file (.dependency-cruiser.(c)js) at the default location. Does it exist?\n` +
+				`         - You can create one by running 'npx dependency-cruiser --init'\n` +
+				`         - Want to run a without a config file? Use --no-config\n`,
+		);
+	}
+	return lReturnValue;
 }
 
 function validateAndNormalizeRulesFileName(pValidate) {
-  let lReturnValue = "";
+	let lReturnValue = "";
 
-  if (typeof pValidate === "string") {
-    lReturnValue = validateAndGetCustomRulesFileName(pValidate);
-  } else {
-    lReturnValue = validateAndGetDefaultRulesFileName();
-  }
+	if (typeof pValidate === "string") {
+		lReturnValue = validateAndGetCustomRulesFileName(pValidate);
+	} else {
+		lReturnValue = validateAndGetDefaultRulesFileName();
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 function validateAndGetKnownViolationsFileName(pKnownViolations) {
-  const lKnownViolationsFileName =
-    typeof pKnownViolations === "string"
-      ? pKnownViolations
-      : DEFAULT_BASELINE_FILE_NAME;
-
-  if (fileExists(lKnownViolationsFileName)) {
-    return lKnownViolationsFileName;
-  } else {
-    throw new Error(
-      `Can't open '${lKnownViolationsFileName}' for reading. Does it exist?\n` +
-        `         (You can create a .dependency-cruiser-known-violations.json with --output-type baseline)\n`,
-    );
-  }
+	const lKnownViolationsFileName =
+		typeof pKnownViolations === "string"
+			? pKnownViolations
+			: DEFAULT_BASELINE_FILE_NAME;
+
+	if (fileExists(lKnownViolationsFileName)) {
+		return lKnownViolationsFileName;
+	} else {
+		throw new Error(
+			`Can't open '${lKnownViolationsFileName}' for reading. Does it exist?\n` +
+				`         (You can create a .dependency-cruiser-known-violations.json with --output-type baseline)\n`,
+		);
+	}
 }
 
 function normalizeKnownViolationsOption(pCliOptions) {
-  if (
-    !Object.hasOwn(pCliOptions, "ignoreKnown") ||
-    pCliOptions.ignoreKnown === false
-  ) {
-    return {};
-  }
-  return {
-    knownViolationsFile: validateAndGetKnownViolationsFileName(
-      pCliOptions.ignoreKnown,
-    ),
-  };
+	if (
+		!Object.hasOwn(pCliOptions, "ignoreKnown") ||
+		pCliOptions.ignoreKnown === false
+	) {
+		return {};
+	}
+	return {
+		knownViolationsFile: validateAndGetKnownViolationsFileName(
+			pCliOptions.ignoreKnown,
+		),
+	};
 }
 
 async function normalizeValidationOption(pCliOptions) {
-  if (!pCliOptions.validate) {
-    return {
-      validate: false,
-    };
-  }
-  const rulesFile = validateAndNormalizeRulesFileName(pCliOptions.validate);
-  return {
-    rulesFile,
-    ruleSet: await loadConfig(
-      isAbsolute(rulesFile) ? rulesFile : `./${rulesFile}`,
-    ),
-    validate: true,
-  };
+	if (!pCliOptions.validate) {
+		return {
+			validate: false,
+		};
+	}
+	const rulesFile = validateAndNormalizeRulesFileName(pCliOptions.validate);
+	return {
+		rulesFile,
+		ruleSet: await loadConfig(
+			isAbsolute(rulesFile) ? rulesFile : `./${rulesFile}`,
+		),
+		validate: true,
+	};
 }
 
 function normalizeProgress(pCliOptions) {
-  if (!Object.hasOwn(pCliOptions, "progress")) {
-    return {};
-  }
-
-  let lProgress = pCliOptions.progress;
-  if (lProgress === true) {
-    lProgress = "cli-feedback";
-  }
-  return { progress: lProgress };
+	if (!Object.hasOwn(pCliOptions, "progress")) {
+		return {};
+	}
+
+	let lProgress = pCliOptions.progress;
+	if (lProgress === true) {
+		lProgress = "cli-feedback";
+	}
+	return { progress: lProgress };
 }
 
 function normalizeCacheStrategy(pCliOptions) {
-  if (!Object.hasOwn(pCliOptions, "cacheStrategy")) {
-    return {};
-  }
-  const lStrategy =
-    pCliOptions.cacheStrategy === "content" ? "content" : "metadata";
-
-  let lReturnValue = {};
-
-  if (pCliOptions.cache && typeof pCliOptions.cache === "object") {
-    lReturnValue.cache = structuredClone(pCliOptions.cache);
-    lReturnValue.cache.strategy = lStrategy;
-  } else {
-    lReturnValue = {
-      cache: {
-        strategy: lStrategy,
-      },
-    };
-  }
-  return lReturnValue;
+	if (!Object.hasOwn(pCliOptions, "cacheStrategy")) {
+		return {};
+	}
+	const lStrategy =
+		pCliOptions.cacheStrategy === "content" ? "content" : "metadata";
+
+	let lReturnValue = {};
+
+	if (pCliOptions.cache && typeof pCliOptions.cache === "object") {
+		lReturnValue.cache = structuredClone(pCliOptions.cache);
+		lReturnValue.cache.strategy = lStrategy;
+	} else {
+		lReturnValue = {
+			cache: {
+				strategy: lStrategy,
+			},
+		};
+	}
+	return lReturnValue;
 }
 
 function normalizeCache(pCliOptions) {
-  if (!Object.hasOwn(pCliOptions, "cache")) {
-    return {};
-  }
-
-  if (pCliOptions.cache === true) {
-    return { cache: {} };
-  }
-
-  if (typeof pCliOptions.cache === "string") {
-    return {
-      cache: {
-        folder: pCliOptions.cache,
-      },
-    };
-  }
-
-  return { cache: false };
+	if (!Object.hasOwn(pCliOptions, "cache")) {
+		return {};
+	}
+
+	if (pCliOptions.cache === true) {
+		return { cache: {} };
+	}
+
+	if (typeof pCliOptions.cache === "string") {
+		return {
+			cache: {
+				folder: pCliOptions.cache,
+			},
+		};
+	}
+
+	return { cache: false };
 }
 
 /**
@@ -199,43 +199,43 @@ function normalizeCache(pCliOptions) {
  * @return {object}          [description]
  */
 export default async function normalizeOptions(pOptionsAsPassedFromCommander) {
-  let lOptions = {
-    outputTo: OUTPUT_TO,
-    outputType: OUTPUT_TYPE,
-    ...pOptionsAsPassedFromCommander,
-  };
-
-  if (Object.hasOwn(lOptions, "moduleSystems")) {
-    lOptions.moduleSystems = lOptions.moduleSystems
-      .split(",")
-      .map((pString) => pString.trim());
-  }
-
-  if (Object.hasOwn(lOptions, "config")) {
-    lOptions.validate = lOptions.config;
-  }
-
-  lOptions = { ...lOptions, ...(await normalizeValidationOption(lOptions)) };
-  lOptions = { ...lOptions, ...normalizeProgress(lOptions) };
-  lOptions = { ...lOptions, ...normalizeCache(lOptions) };
-  lOptions = { ...lOptions, ...normalizeCacheStrategy(lOptions) };
-  lOptions = { ...lOptions, ...normalizeKnownViolationsOption(lOptions) };
-  lOptions = normalizeConfigFileName(lOptions, "webpackConfig", WEBPACK_CONFIG);
-  lOptions = normalizeConfigFileName(lOptions, "tsConfig", TYPESCRIPT_CONFIG);
-  lOptions = normalizeConfigFileName(lOptions, "babelConfig", BABEL_CONFIG);
-  if (Object.hasOwn(lOptions, "affected") && lOptions.affected !== false) {
-    const { list } = await import("watskeburt");
-    lOptions.reaches = await list({
-      oldRevision: lOptions.affected === true ? "main" : lOptions.affected,
-      outputType: "regex",
-      extensions:
-        "cjs,cjsx,coffee,csx,cts,js,json,jsx,litcoffee,ls,mjs,mts,svelte,ts,tsx,vue,vuex",
-    });
-  }
-
-  return lOptions;
+	let lOptions = {
+		outputTo: OUTPUT_TO,
+		outputType: OUTPUT_TYPE,
+		...pOptionsAsPassedFromCommander,
+	};
+
+	if (Object.hasOwn(lOptions, "moduleSystems")) {
+		lOptions.moduleSystems = lOptions.moduleSystems
+			.split(",")
+			.map((pString) => pString.trim());
+	}
+
+	if (Object.hasOwn(lOptions, "config")) {
+		lOptions.validate = lOptions.config;
+	}
+
+	lOptions = { ...lOptions, ...(await normalizeValidationOption(lOptions)) };
+	lOptions = { ...lOptions, ...normalizeProgress(lOptions) };
+	lOptions = { ...lOptions, ...normalizeCache(lOptions) };
+	lOptions = { ...lOptions, ...normalizeCacheStrategy(lOptions) };
+	lOptions = { ...lOptions, ...normalizeKnownViolationsOption(lOptions) };
+	lOptions = normalizeConfigFileName(lOptions, "webpackConfig", WEBPACK_CONFIG);
+	lOptions = normalizeConfigFileName(lOptions, "tsConfig", TYPESCRIPT_CONFIG);
+	lOptions = normalizeConfigFileName(lOptions, "babelConfig", BABEL_CONFIG);
+	if (Object.hasOwn(lOptions, "affected") && lOptions.affected !== false) {
+		const { list } = await import("watskeburt");
+		lOptions.reaches = await list({
+			oldRevision: lOptions.affected === true ? "main" : lOptions.affected,
+			outputType: "regex",
+			extensions:
+				"cjs,cjsx,coffee,csx,cts,js,json,jsx,litcoffee,ls,mjs,mts,svelte,ts,tsx,vue,vuex",
+		});
+	}
+
+	return lOptions;
 }
 
 export const determineRulesFileName = getOptionValue(
-  OLD_DEFAULT_RULES_FILE_NAME,
+	OLD_DEFAULT_RULES_FILE_NAME,
 );

package/src/cli/tools/wrap-stream-in-html.mjs

@@ -3,16 +3,16 @@ import { fileURLToPath } from "node:url";
 import { getHeader, getFooter } from "#report/dot-webpage/wrap-in-html.mjs";
 
 const STYLESHEET_FILE = fileURLToPath(
-  new URL(
-    "../../report/dot-webpage/svg-in-html-snippets/style.css",
-    import.meta.url,
-  ),
+	new URL(
+		"../../report/dot-webpage/svg-in-html-snippets/style.css",
+		import.meta.url,
+	),
 );
 const SCRIPT_FILE = fileURLToPath(
-  new URL(
-    "../../report/dot-webpage/svg-in-html-snippets/script.cjs",
-    import.meta.url,
-  ),
+	new URL(
+		"../../report/dot-webpage/svg-in-html-snippets/script.cjs",
+		import.meta.url,
+	),
 );
 
 /**
@@ -30,34 +30,34 @@ const SCRIPT_FILE = fileURLToPath(
  * @param {writeStream} pOutStream stream to write to
  */
 export default async function wrap(pInStream, pOutStream) {
-  const [lStylesheet, lScript] = await Promise.all([
-    readFile(STYLESHEET_FILE, "utf8"),
-    readFile(SCRIPT_FILE, "utf8"),
-  ]);
+	const [lStylesheet, lScript] = await Promise.all([
+		readFile(STYLESHEET_FILE, "utf8"),
+		readFile(SCRIPT_FILE, "utf8"),
+	]);
 
-  pOutStream.write(getHeader(lStylesheet));
-  pInStream
-    .on("end", () => {
-      pOutStream.write(getFooter(lScript));
-      pOutStream.end();
-    })
-    .on(
-      "error",
-      /* c8 ignore start */
-      (pError) => {
-        process.stderr.write(`${pError}\n`);
-      },
-      /* c8 ignore stop */
-    )
-    /*
-     * We could have put the whole html in a template literal, but we don't know
-     * how large the svg that's going to be injected is going to be - it could just
-     * as well be as large that if we're going to buffer it, it's going into out
-     * of memory territory.
-     *
-     * We circumvent that by streaming the svg in between the header and the footer.
-     */
-    .on("data", (pChunk) => {
-      pOutStream.write(pChunk);
-    });
+	pOutStream.write(getHeader(lStylesheet));
+	pInStream
+		.on("end", () => {
+			pOutStream.write(getFooter(lScript));
+			pOutStream.end();
+		})
+		.on(
+			"error",
+			/* c8 ignore start */
+			(pError) => {
+				process.stderr.write(`${pError}\n`);
+			},
+			/* c8 ignore stop */
+		)
+		/*
+		 * We could have put the whole html in a template literal, but we don't know
+		 * how large the svg that's going to be injected is going to be - it could just
+		 * as well be as large that if we're going to buffer it, it's going into out
+		 * of memory territory.
+		 *
+		 * We circumvent that by streaming the svg in between the header and the footer.
+		 */
+		.on("data", (pChunk) => {
+			pOutStream.write(pChunk);
+		});
 }

package/src/cli/utl/assert-file-existence.mjs

@@ -1,11 +1,11 @@
 import { accessSync, constants } from "node:fs";
 
 export default function assertFileExistence(pDirectoryOrFile) {
-  try {
-    accessSync(pDirectoryOrFile, constants.R_OK);
-  } catch (pError) {
-    throw new Error(
-      `Can't open '${pDirectoryOrFile}' for reading. Does it exist?\n`,
-    );
-  }
+	try {
+		accessSync(pDirectoryOrFile, constants.R_OK);
+	} catch (pError) {
+		throw new Error(
+			`Can't open '${pDirectoryOrFile}' for reading. Does it exist?\n`,
+		);
+	}
 }

package/src/cli/utl/io.mjs

@@ -3,14 +3,14 @@ import { writeFileSync, createReadStream } from "node:fs";
 const PIPE_BUFFER_SIZE = 512;
 
 function writeToFile(pOutputTo, pDependencyString) {
-  try {
-    writeFileSync(pOutputTo, pDependencyString, {
-      encoding: "utf8",
-      flag: "w",
-    });
-  } catch (pError) {
-    throw new Error(`Writing to '${pOutputTo}' didn't work. ${pError}`);
-  }
+	try {
+		writeFileSync(pOutputTo, pDependencyString, {
+			encoding: "utf8",
+			flag: "w",
+		});
+	} catch (pError) {
+		throw new Error(`Writing to '${pOutputTo}' didn't work. ${pError}`);
+	}
 }
 
 /**
@@ -27,33 +27,30 @@ function writeToFile(pOutputTo, pDependencyString) {
  * @returns {void} nothing
  */
 function writeToStdOut(pString, pBufferSize = PIPE_BUFFER_SIZE) {
-  const lNumberOfChunks = Math.ceil(pString.length / pBufferSize);
+	const lNumberOfChunks = Math.ceil(pString.length / pBufferSize);
 
-  /* eslint no-plusplus: 0 */
-  for (let lIndex = 0; lIndex < lNumberOfChunks; lIndex++) {
-    const lChunkStart = lIndex * pBufferSize;
-    process.stdout.write(
-      pString.substring(lChunkStart, lChunkStart + pBufferSize),
-      "utf8",
-    );
-  }
+	/* eslint no-plusplus: 0 */
+	for (let lIndex = 0; lIndex < lNumberOfChunks; lIndex++) {
+		const lChunkStart = lIndex * pBufferSize;
+		process.stdout.write(
+			pString.substring(lChunkStart, lChunkStart + pBufferSize),
+			"utf8",
+		);
+	}
 }
 export function write(pOutputTo, pContent) {
-  // previously we checked here to ensure pContent ended on an EOL (and if it
-  // didn't we added one). As for one or two reporters we DON'T want this
-  // to happen automatically (e.g. the 'null' one) we've moved that check
-  // to the individual reporters and with a unit test ensured that all
-  // reporters (current and future) keep doing that.
-  if ("-" === pOutputTo) {
-    writeToStdOut(pContent);
-  } else {
-    writeToFile(pOutputTo, pContent);
-  }
+	// Reporters are responsible for ensuring output ends with a newline so the
+	// write function intentionally does not append an EOL
+	if ("-" === pOutputTo) {
+		writeToStdOut(pContent);
+	} else {
+		writeToFile(pOutputTo, pContent);
+	}
 }
 
 export function getInStream(pInputFrom) {
-  if ("-" === pInputFrom) {
-    return process.stdin;
-  }
-  return createReadStream(pInputFrom);
+	if ("-" === pInputFrom) {
+		return process.stdin;
+	}
+	return createReadStream(pInputFrom);
 }