dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/config-utl/extract-ts-config.mjs

@@ -3,28 +3,28 @@ import tryImport from "#utl/try-import.mjs";
 import meta from "#meta.cjs";
 
 const typescript = await tryImport(
-  "typescript",
-  meta.supportedTranspilers.typescript,
+	"typescript",
+	meta.supportedTranspilers.typescript,
 );
 
 const FORMAT_DIAGNOSTICS_HOST = {
-  getCanonicalFileName(pFileName) {
-    let lReturnValue = pFileName.toLowerCase();
+	getCanonicalFileName(pFileName) {
+		let lReturnValue = pFileName.toLowerCase();
 
-    // depends on the platform which branch is taken, hence the c8 ignore
-    /* c8 ignore start */
-    if (typescript?.sys?.useCaseSensitiveFileNames ?? false) {
-      lReturnValue = pFileName;
-    }
-    /* c8 ignore stop */
-    return lReturnValue;
-  },
-  getCurrentDirectory() {
-    return process.cwd();
-  },
-  getNewLine() {
-    return "\n";
-  },
+		// depends on the platform which branch is taken, hence the c8 ignore
+		/* c8 ignore start */
+		if (typescript?.sys?.useCaseSensitiveFileNames ?? false) {
+			lReturnValue = pFileName;
+		}
+		/* c8 ignore stop */
+		return lReturnValue;
+	},
+	getCurrentDirectory() {
+		return process.cwd();
+	},
+	getNewLine() {
+		return "\n";
+	},
 };
 
 /**
@@ -39,38 +39,36 @@ const FORMAT_DIAGNOSTICS_HOST = {
  * @throws {TypeError} when the tsconfig is unreadable
  */
 export default function extractTSConfig(pTSConfigFileName) {
-  let lReturnValue = {};
+	let lReturnValue = {};
 
-  if (typescript) {
-    const lConfig = typescript.readConfigFile(
-      pTSConfigFileName,
-      typescript.sys.readFile,
-    );
+	if (typescript) {
+		const lConfig = typescript.readConfigFile(
+			pTSConfigFileName,
+			typescript.sys.readFile,
+		);
 
-    if (typeof lConfig.error !== "undefined") {
-      throw new TypeError(
-        typescript.formatDiagnostics([lConfig.error], FORMAT_DIAGNOSTICS_HOST),
-      );
-    }
-    lReturnValue = typescript.parseJsonConfigFileContent(
-      lConfig.config,
-      typescript.sys,
-      dirname(resolve(pTSConfigFileName)),
-      {},
-      pTSConfigFileName,
-    );
+		if (typeof lConfig.error !== "undefined") {
+			throw new TypeError(
+				typescript.formatDiagnostics([lConfig.error], FORMAT_DIAGNOSTICS_HOST),
+			);
+		}
+		lReturnValue = typescript.parseJsonConfigFileContent(
+			lConfig.config,
+			typescript.sys,
+			dirname(resolve(pTSConfigFileName)),
+			{},
+			pTSConfigFileName,
+		);
 
-    if (lReturnValue.errors.length > 0) {
-      throw new Error(
-        typescript.formatDiagnostics(
-          lReturnValue.errors,
-          FORMAT_DIAGNOSTICS_HOST,
-        ),
-      );
-    }
-    // lRetval.fileNames; // all files included in the project
-    // lRetval.options; // CompilerOptions
-  }
+		if (lReturnValue.errors.length > 0) {
+			throw new Error(
+				typescript.formatDiagnostics(
+					lReturnValue.errors,
+					FORMAT_DIAGNOSTICS_HOST,
+				),
+			);
+		}
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }

package/src/config-utl/extract-webpack-resolve-config.mjs

@@ -6,99 +6,99 @@ import makeAbsolute from "./make-absolute.mjs";
 const require = createRequire(import.meta.url);
 
 function pryConfigFromTheConfig(
-  pWebpackConfigModule,
-  pEnvironment,
-  pArguments,
+	pWebpackConfigModule,
+	pEnvironment,
+	pArguments,
 ) {
-  let lReturnValue = pWebpackConfigModule;
+	let lReturnValue = pWebpackConfigModule;
 
-  if (typeof pWebpackConfigModule === "function") {
-    lReturnValue = pWebpackConfigModule(pEnvironment, pArguments);
-  }
+	if (typeof pWebpackConfigModule === "function") {
+		lReturnValue = pWebpackConfigModule(pEnvironment, pArguments);
+	}
 
-  if (Array.isArray(pWebpackConfigModule)) {
-    lReturnValue = pryConfigFromTheConfig(
-      pWebpackConfigModule[0],
-      pEnvironment,
-      pArguments,
-    );
-  }
+	if (Array.isArray(pWebpackConfigModule)) {
+		lReturnValue = pryConfigFromTheConfig(
+			pWebpackConfigModule[0],
+			pEnvironment,
+			pArguments,
+		);
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 function suggestModules(pSuggestionList, pWebpackConfigFilename) {
-  let lReturnValue = "";
-  let lSuggestionList = pSuggestionList;
+	let lReturnValue = "";
+	let lSuggestionList = pSuggestionList;
 
-  if (pSuggestionList && typeof pSuggestionList === "string") {
-    lSuggestionList = [pSuggestionList];
-  }
+	if (pSuggestionList && typeof pSuggestionList === "string") {
+		lSuggestionList = [pSuggestionList];
+	}
 
-  if (Array.isArray(lSuggestionList) && lSuggestionList.length > 0) {
-    lReturnValue = lSuggestionList.reduce(
-      (pAll, pCurrent) => `${pAll}         - ${pCurrent.module || pCurrent}\n`,
-      `\n         Some npm modules that might fix that problem (one of which you'll` +
-        `\n         need so '${pWebpackConfigFilename}' works with webpack anyway):\n`,
-    );
-  }
-  return lReturnValue;
+	if (Array.isArray(lSuggestionList) && lSuggestionList.length > 0) {
+		lReturnValue = lSuggestionList.reduce(
+			(pAll, pCurrent) => `${pAll}         - ${pCurrent.module || pCurrent}\n`,
+			`\n         Some npm modules that might fix that problem (one of which you'll` +
+				`\n         need so '${pWebpackConfigFilename}' works with webpack anyway):\n`,
+		);
+	}
+	return lReturnValue;
 }
 
 function tryRegisterNonNative(pWebpackConfigFilename) {
-  const lConfigExtension = extname(pWebpackConfigFilename);
-  const interpret = require("interpret");
-  const rechoir = require("rechoir");
+	const lConfigExtension = extname(pWebpackConfigFilename);
+	const interpret = require("interpret");
+	const rechoir = require("rechoir");
 
-  try {
-    rechoir.prepare(interpret.extensions, pWebpackConfigFilename);
-  } catch (pError) {
-    throw new Error(
-      `${pError.message}` +
-        `\n${suggestModules(
-          // eslint-disable-next-line security/detect-object-injection
-          interpret.extensions[lConfigExtension],
-          pWebpackConfigFilename,
-        )}`,
-    );
-  }
+	try {
+		rechoir.prepare(interpret.extensions, pWebpackConfigFilename);
+	} catch (pError) {
+		throw new Error(
+			`${pError.message}` +
+				`\n${suggestModules(
+					// eslint-disable-next-line security/detect-object-injection
+					interpret.extensions[lConfigExtension],
+					pWebpackConfigFilename,
+				)}`,
+		);
+	}
 }
 
 function isNativelySupported(pWebpackConfigFilename) {
-  const lNativelySupportedExtensions = [
-    ".js",
-    ".cjs",
-    ".mjs",
-    ".json",
-    ".node",
-  ];
-  const lWebpackConfigExtension = extname(pWebpackConfigFilename);
-  return lNativelySupportedExtensions.includes(lWebpackConfigExtension);
+	const lNativelySupportedExtensions = [
+		".js",
+		".cjs",
+		".mjs",
+		".json",
+		".node",
+	];
+	const lWebpackConfigExtension = extname(pWebpackConfigFilename);
+	return lNativelySupportedExtensions.includes(lWebpackConfigExtension);
 }
 
 async function attemptImport(pAbsoluteWebpackConfigFileName) {
-  try {
-    if (isNativelySupported(pAbsoluteWebpackConfigFileName)) {
-      const { default: lModule } = await import(
-        `file://${pAbsoluteWebpackConfigFileName}`
-      );
-      return lModule;
-    } else {
-      tryRegisterNonNative(pAbsoluteWebpackConfigFileName);
-      /* we're using still using require instead of dynamic imports here because
-       * the modules webpack uses for non-native formats monkey-patch on the commonjs
-       * module system. If we'd use a dynamic import, these monkey-patches wouldn't
-       * be used.
-       */
-      /* eslint n/global-require:0, security/detect-non-literal-require:0, import/no-dynamic-require:0 */
-      return require(pAbsoluteWebpackConfigFileName);
-    }
-  } catch (pError) {
-    throw new Error(
-      `The webpack config '${pAbsoluteWebpackConfigFileName}' seems to be not quite valid for use:` +
-        `\n\n          "${pError}"\n`,
-    );
-  }
+	try {
+		if (isNativelySupported(pAbsoluteWebpackConfigFileName)) {
+			const { default: lModule } = await import(
+				`file://${pAbsoluteWebpackConfigFileName}`
+			);
+			return lModule;
+		} else {
+			tryRegisterNonNative(pAbsoluteWebpackConfigFileName);
+			/* we're using still using require instead of dynamic imports here because
+			 * the modules webpack uses for non-native formats monkey-patch on the commonjs
+			 * module system. If we'd use a dynamic import, these monkey-patches wouldn't
+			 * be used.
+			 */
+			/* eslint n/global-require:0, security/detect-non-literal-require:0, import/no-dynamic-require:0 */
+			return require(pAbsoluteWebpackConfigFileName);
+		}
+	} catch (pError) {
+		throw new Error(
+			`The webpack config '${pAbsoluteWebpackConfigFileName}' seems to be not quite valid for use:` +
+				`\n\n          "${pError}"\n`,
+		);
+	}
 }
 
 /**
@@ -117,21 +117,21 @@ async function attemptImport(pAbsoluteWebpackConfigFileName) {
  *                 doesn't exist, or because it's invalid)
  */
 export default async function extractWebpackResolveConfig(
-  pWebpackConfigFilename,
-  pEnvironment,
-  pArguments,
+	pWebpackConfigFilename,
+	pEnvironment,
+	pArguments,
 ) {
-  let lReturnValue = {};
-  const lAbsoluteConfigFilename = makeAbsolute(pWebpackConfigFilename);
-  const lWebpackConfig = pryConfigFromTheConfig(
-    await attemptImport(lAbsoluteConfigFilename),
-    pEnvironment,
-    pArguments,
-  );
+	let lReturnValue = {};
+	const lAbsoluteConfigFilename = makeAbsolute(pWebpackConfigFilename);
+	const lWebpackConfig = pryConfigFromTheConfig(
+		await attemptImport(lAbsoluteConfigFilename),
+		pEnvironment,
+		pArguments,
+	);
 
-  if (lWebpackConfig.resolve) {
-    lReturnValue = lWebpackConfig.resolve;
-  }
+	if (lWebpackConfig.resolve) {
+		lReturnValue = lWebpackConfig.resolve;
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }

package/src/config-utl/make-absolute.mjs

@@ -1,10 +1,10 @@
 import { join, isAbsolute } from "node:path";
 
 export default function makeAbsolute(pFilename) {
-  let lReturnValue = pFilename;
+	let lReturnValue = pFilename;
 
-  if (!isAbsolute(pFilename)) {
-    lReturnValue = join(process.cwd(), pFilename);
-  }
-  return lReturnValue;
+	if (!isAbsolute(pFilename)) {
+		lReturnValue = join(process.cwd(), pFilename);
+	}
+	return lReturnValue;
 }

package/src/enrich/add-validations.mjs

@@ -1,12 +1,12 @@
 import { validateDependency, validateModule } from "#validate/index.mjs";
 
 function addDependencyViolations(pModule, pDependency, pRuleSet, pValidate) {
-  return {
-    ...pDependency,
-    ...(pValidate
-      ? validateDependency(pRuleSet, pModule, pDependency)
-      : { valid: true }),
-  };
+	return {
+		...pDependency,
+		...(pValidate
+			? validateDependency(pRuleSet, pModule, pDependency)
+			: { valid: true }),
+	};
 }
 
 /**
@@ -22,11 +22,11 @@ function addDependencyViolations(pModule, pDependency, pRuleSet, pValidate) {
  *                  valid and if not which rules were violated
  */
 export default function addValidations(pModules, pRuleSet, pValidate) {
-  return pModules.map((pModule) => ({
-    ...pModule,
-    ...(pValidate ? validateModule(pRuleSet, pModule) : { valid: true }),
-    dependencies: pModule.dependencies.map((pDependency) =>
-      addDependencyViolations(pModule, pDependency, pRuleSet, pValidate),
-    ),
-  }));
+	return pModules.map((pModule) => ({
+		...pModule,
+		...(pValidate ? validateModule(pRuleSet, pModule) : { valid: true }),
+		dependencies: pModule.dependencies.map((pDependency) =>
+			addDependencyViolations(pModule, pDependency, pRuleSet, pValidate),
+		),
+	}));
 }

package/src/enrich/derive/circular.mjs

@@ -3,44 +3,44 @@
 /** @import { IFlattenedRuleSet } from "../../../types/rule-set.mjs" */
 
 function isCycleRule(pRule) {
-  return (
-    /* c8 ignore start */
-    Object.hasOwn(pRule?.to ?? {}, "circular")
-    /* c8 ignore stop */
-  );
+	return (
+		/* c8 ignore start */
+		Object.hasOwn(pRule?.to ?? {}, "circular")
+		/* c8 ignore stop */
+	);
 }
 /**
  * @param {IFlattenedRuleSet} pRuleSet
  * @returns {boolean}
  */
 export function hasCycleRule(pRuleSet) {
-  return (
-    (pRuleSet?.forbidden ?? []).some(isCycleRule) ||
-    (pRuleSet?.allowed ?? []).some(isCycleRule)
-  );
+	return (
+		(pRuleSet?.forbidden ?? []).some(isCycleRule) ||
+		(pRuleSet?.allowed ?? []).some(isCycleRule)
+	);
 }
 
 function addCircularityCheckToDependency(
-  pIndexedGraph,
-  pFrom,
-  pToDep,
-  pDependencyName,
+	pIndexedGraph,
+	pFrom,
+	pToDep,
+	pDependencyName,
 ) {
-  let lReturnValue = {
-    ...pToDep,
-    circular: false,
-  };
-  const lCycle = pIndexedGraph.getCycle(pFrom, pToDep[pDependencyName]);
+	let lReturnValue = {
+		...pToDep,
+		circular: false,
+	};
+	const lCycle = pIndexedGraph.getCycle(pFrom, pToDep[pDependencyName]);
 
-  if (lCycle.length > 0) {
-    lReturnValue = {
-      ...lReturnValue,
-      circular: true,
-      cycle: lCycle,
-    };
-  }
+	if (lCycle.length > 0) {
+		lReturnValue = {
+			...lReturnValue,
+			circular: true,
+			cycle: lCycle,
+		};
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 /**
@@ -49,28 +49,28 @@ function addCircularityCheckToDependency(
  * dependencies with that added.
  */
 export default function detectAndAddCycles(
-  pNodes,
-  pIndexedNodes,
-  { pSourceAttribute, pDependencyName, pSkipAnalysisNotInRules, pRuleSet },
+	pNodes,
+	pIndexedNodes,
+	{ pSourceAttribute, pDependencyName, pSkipAnalysisNotInRules, pRuleSet },
 ) {
-  if (!pSkipAnalysisNotInRules || hasCycleRule(pRuleSet)) {
-    return pNodes.map((pModule) => ({
-      ...pModule,
-      dependencies: pModule.dependencies.map((pToDep) =>
-        addCircularityCheckToDependency(
-          pIndexedNodes,
-          pModule[pSourceAttribute],
-          pToDep,
-          pDependencyName,
-        ),
-      ),
-    }));
-  }
-  return pNodes.map((pModule) => ({
-    ...pModule,
-    dependencies: pModule.dependencies.map((pToDep) => ({
-      ...pToDep,
-      circular: false,
-    })),
-  }));
+	if (!pSkipAnalysisNotInRules || hasCycleRule(pRuleSet)) {
+		return pNodes.map((pModule) => ({
+			...pModule,
+			dependencies: pModule.dependencies.map((pToDep) =>
+				addCircularityCheckToDependency(
+					pIndexedNodes,
+					pModule[pSourceAttribute],
+					pToDep,
+					pDependencyName,
+				),
+			),
+		}));
+	}
+	return pNodes.map((pModule) => ({
+		...pModule,
+		dependencies: pModule.dependencies.map((pToDep) => ({
+			...pToDep,
+			circular: false,
+		})),
+	}));
 }

package/src/enrich/derive/dependents.mjs

@@ -3,24 +3,24 @@ import { isDependent } from "./module-utl.mjs";
 /** @import { IFlattenedRuleSet } from "../../../types/rule-set.mjs" */
 
 function isDependentsRule(pRule) {
-  // used in folder rules and when moreUnstable is in the 'to' => governed by
-  // the 'metrics' flag in options, sot not going to repeat that here
+	// used in folder rules and when moreUnstable is in the 'to' => governed by
+	// the 'metrics' flag in options, sot not going to repeat that here
 
-  // dependents are used in the orphans analsys. hHwever, there is a fall back
-  // where it does its own analysis, so not going to repeat that check here.
-  return (
-    /* c8 ignore start */
-    Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsLessThan") ||
-    Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsMoreThan")
-    /* c8 ignore stop */
-  );
+	// dependents are used in the orphans analsys. However, there is a fall back
+	// where it does its own analysis, so not going to repeat that check here.
+	return (
+		/* c8 ignore start */
+		Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsLessThan") ||
+		Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsMoreThan")
+		/* c8 ignore stop */
+	);
 }
 
 export function getDependents(pModule, pModules) {
-  // perf between O(n) in an unconnected graph and O(n^2) in a fully connected one
-  return pModules
-    .filter(isDependent(pModule.source))
-    .map((pDependentModule) => pDependentModule.source);
+	// perf between O(n) in an unconnected graph and O(n^2) in a fully connected one
+	return pModules
+		.filter(isDependent(pModule.source))
+		.map((pDependentModule) => pDependentModule.source);
 }
 
 /**
@@ -28,21 +28,21 @@ export function getDependents(pModule, pModules) {
  * @returns {boolean}
  */
 export function hasDependentsRule(pRuleSet) {
-  return (
-    (pRuleSet?.forbidden ?? []).some(isDependentsRule) ||
-    (pRuleSet?.allowed ?? []).some(isDependentsRule)
-  );
+	return (
+		(pRuleSet?.forbidden ?? []).some(isDependentsRule) ||
+		(pRuleSet?.allowed ?? []).some(isDependentsRule)
+	);
 }
 
 export default function addDependents(
-  pModules,
-  { skipAnalysisNotInRules, metrics, ruleSet },
+	pModules,
+	{ skipAnalysisNotInRules, metrics, ruleSet },
 ) {
-  if (!skipAnalysisNotInRules || metrics || hasDependentsRule(ruleSet)) {
-    return pModules.map((pModule) => ({
-      ...pModule,
-      dependents: getDependents(pModule, pModules),
-    }));
-  }
-  return pModules;
+	if (!skipAnalysisNotInRules || metrics || hasDependentsRule(ruleSet)) {
+		return pModules.map((pModule) => ({
+			...pModule,
+			dependents: getDependents(pModule, pModules),
+		}));
+	}
+	return pModules;
 }