dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/validate/matchers.mjs

@@ -8,227 +8,227 @@ import { intersects } from "#utl/array-util.mjs";
 // occur paired with 'local', 'npm' or core. Hence we only include
 // a subset of dependency types where we _care_ if they are duplicates
 const DEPENDENCY_TYPE_DUPLICATES_THAT_MATTER = new Set([
-  "core",
-  "local",
-  "localmodule",
-  "npm",
-  "npm-bundled",
-  "npm-dev",
-  "npm-no-pkg",
-  "npm-optional",
-  "npm-peer",
-  "npm-unknown",
+	"core",
+	"local",
+	"localmodule",
+	"npm",
+	"npm-bundled",
+	"npm-dev",
+	"npm-no-pkg",
+	"npm-optional",
+	"npm-peer",
+	"npm-unknown",
 ]);
 
 export function propertyEquals(pRule, pDependency, pProperty) {
-  // The properties can be booleans, so we can't use !pRule.to[pProperty]
-  if (Object.hasOwn(pRule.to, pProperty)) {
-    return pDependency[pProperty] === pRule.to[pProperty];
-  }
-  return true;
+	// The properties can be booleans, so we can't use !pRule.to[pProperty]
+	if (Object.hasOwn(pRule.to, pProperty)) {
+		return pDependency[pProperty] === pRule.to[pProperty];
+	}
+	return true;
 }
 
 export function propertyMatches(pRule, pDependency, pRuleProperty, pProperty) {
-  return Boolean(
-    !pRule.to[pRuleProperty] ||
-    (pDependency[pProperty] &&
-      pDependency[pProperty].match(pRule.to[pRuleProperty])),
-  );
+	return Boolean(
+		!pRule.to[pRuleProperty] ||
+		(pDependency[pProperty] &&
+			pDependency[pProperty].match(pRule.to[pRuleProperty])),
+	);
 }
 
 export function propertyMatchesNot(
-  pRule,
-  pDependency,
-  pRuleProperty,
-  pProperty,
+	pRule,
+	pDependency,
+	pRuleProperty,
+	pProperty,
 ) {
-  return Boolean(
-    !pRule.to[pRuleProperty] ||
-    (pDependency[pProperty] &&
-      !pDependency[pProperty].match(pRule.to[pRuleProperty])),
-  );
+	return Boolean(
+		!pRule.to[pRuleProperty] ||
+		(pDependency[pProperty] &&
+			!pDependency[pProperty].match(pRule.to[pRuleProperty])),
+	);
 }
 
 export function matchesFromPath(pRule, pModule) {
-  return Boolean(!pRule.from.path || pModule.source.match(pRule.from.path));
+	return Boolean(!pRule.from.path || pModule.source.match(pRule.from.path));
 }
 
 export function matchesFromPathNot(pRule, pModule) {
-  return Boolean(
-    !pRule.from.pathNot || !pModule.source.match(pRule.from.pathNot),
-  );
+	return Boolean(
+		!pRule.from.pathNot || !pModule.source.match(pRule.from.pathNot),
+	);
 }
 
 export function matchesModulePath(pRule, pModule) {
-  return Boolean(!pRule.module.path || pModule.source.match(pRule.module.path));
+	return Boolean(!pRule.module.path || pModule.source.match(pRule.module.path));
 }
 
 export function matchesModulePathNot(pRule, pModule) {
-  return Boolean(
-    !pRule.module.pathNot || !pModule.source.match(pRule.module.pathNot),
-  );
+	return Boolean(
+		!pRule.module.pathNot || !pModule.source.match(pRule.module.pathNot),
+	);
 }
 
 function _matchesToPath(pRule, pString, pGroups = []) {
-  return Boolean(
-    !pRule.to.path ||
-    pString.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
-  );
+	return Boolean(
+		!pRule.to.path ||
+		pString.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
+	);
 }
 
 export function matchesToPath(pRule, pDependency, pGroups) {
-  return _matchesToPath(pRule, pDependency.resolved, pGroups);
+	return _matchesToPath(pRule, pDependency.resolved, pGroups);
 }
 
 export function matchToModulePath(pRule, pModule, pGroups) {
-  return _matchesToPath(pRule, pModule.source, pGroups);
+	return _matchesToPath(pRule, pModule.source, pGroups);
 }
 
 function _matchesToPathNot(pRule, pString, pGroups = []) {
-  return (
-    !pRule.to.pathNot ||
-    !pString.match(replaceGroupPlaceholders(pRule.to.pathNot, pGroups))
-  );
+	return (
+		!pRule.to.pathNot ||
+		!pString.match(replaceGroupPlaceholders(pRule.to.pathNot, pGroups))
+	);
 }
 
 export function matchesToPathNot(pRule, pDependency, pGroups) {
-  return _matchesToPathNot(pRule, pDependency.resolved, pGroups);
+	return _matchesToPathNot(pRule, pDependency.resolved, pGroups);
 }
 
 export function matchToModulePathNot(pRule, pModule, pGroups) {
-  return _matchesToPathNot(pRule, pModule.source, pGroups);
+	return _matchesToPathNot(pRule, pModule.source, pGroups);
 }
 
 export function matchesToDependencyTypes(pRule, pDependency) {
-  return Boolean(
-    !pRule.to.dependencyTypes ||
-    intersects(pDependency.dependencyTypes, pRule.to.dependencyTypes),
-  );
+	return Boolean(
+		!pRule.to.dependencyTypes ||
+		intersects(pDependency.dependencyTypes, pRule.to.dependencyTypes),
+	);
 }
 
 export function matchesToDependencyTypesNot(pRule, pDependency) {
-  return Boolean(
-    !pRule.to.dependencyTypesNot ||
-    !intersects(pDependency.dependencyTypes, pRule.to.dependencyTypesNot),
-  );
+	return Boolean(
+		!pRule.to.dependencyTypesNot ||
+		!intersects(pDependency.dependencyTypes, pRule.to.dependencyTypesNot),
+	);
 }
 
 export function matchesToVia(pRule, pDependency, pGroups) {
-  let lReturnValue = true;
-  if (pRule.to.via && pDependency.cycle) {
-    if (pRule.to.via.path) {
-      lReturnValue = pDependency.cycle.some(({ name }) =>
-        name.match(replaceGroupPlaceholders(pRule.to.via.path, pGroups)),
-      );
-    }
-    if (pRule.to.via.pathNot) {
-      lReturnValue = !pDependency.cycle.every(({ name }) =>
-        name.match(replaceGroupPlaceholders(pRule.to.via.pathNot, pGroups)),
-      );
-    }
-    if (pRule.to.via.dependencyTypes) {
-      lReturnValue &&= pDependency.cycle.some(({ dependencyTypes }) =>
-        pRule.to.via.dependencyTypes.some((pRuleDependencyType) =>
-          dependencyTypes.includes(pRuleDependencyType),
-        ),
-      );
-    }
-    if (pRule.to.via.dependencyTypesNot) {
-      lReturnValue &&= !pDependency.cycle.every(({ dependencyTypes }) =>
-        pRule.to.via.dependencyTypesNot.some((pRuleDependencyType) =>
-          dependencyTypes.includes(pRuleDependencyType),
-        ),
-      );
-    }
-  }
-  return lReturnValue;
+	let lReturnValue = true;
+	if (pRule.to.via && pDependency.cycle) {
+		if (pRule.to.via.path) {
+			lReturnValue = pDependency.cycle.some(({ name }) =>
+				name.match(replaceGroupPlaceholders(pRule.to.via.path, pGroups)),
+			);
+		}
+		if (pRule.to.via.pathNot) {
+			lReturnValue = !pDependency.cycle.every(({ name }) =>
+				name.match(replaceGroupPlaceholders(pRule.to.via.pathNot, pGroups)),
+			);
+		}
+		if (pRule.to.via.dependencyTypes) {
+			lReturnValue &&= pDependency.cycle.some(({ dependencyTypes }) =>
+				pRule.to.via.dependencyTypes.some((pRuleDependencyType) =>
+					dependencyTypes.includes(pRuleDependencyType),
+				),
+			);
+		}
+		if (pRule.to.via.dependencyTypesNot) {
+			lReturnValue &&= !pDependency.cycle.every(({ dependencyTypes }) =>
+				pRule.to.via.dependencyTypesNot.some((pRuleDependencyType) =>
+					dependencyTypes.includes(pRuleDependencyType),
+				),
+			);
+		}
+	}
+	return lReturnValue;
 }
 
 export function matchesToViaOnly(pRule, pDependency, pGroups) {
-  let lReturnValue = true;
-  if (pRule.to.viaOnly && pDependency.cycle) {
-    if (pRule.to.viaOnly.path) {
-      lReturnValue = pDependency.cycle.every(({ name }) =>
-        name.match(replaceGroupPlaceholders(pRule.to.viaOnly.path, pGroups)),
-      );
-    }
-    if (pRule.to.viaOnly.pathNot) {
-      lReturnValue = !pDependency.cycle.some(({ name }) =>
-        name.match(replaceGroupPlaceholders(pRule.to.viaOnly.pathNot, pGroups)),
-      );
-    }
-    if (pRule.to.viaOnly.dependencyTypes) {
-      lReturnValue &&= pDependency.cycle.every(({ dependencyTypes }) =>
-        pRule.to.viaOnly.dependencyTypes.some((pRuleDependencyType) =>
-          dependencyTypes.includes(pRuleDependencyType),
-        ),
-      );
-    }
-    if (pRule.to.viaOnly.dependencyTypesNot) {
-      lReturnValue &&= !pDependency.cycle.some(({ dependencyTypes }) =>
-        pRule.to.viaOnly.dependencyTypesNot.some((pRuleDependencyType) =>
-          dependencyTypes.includes(pRuleDependencyType),
-        ),
-      );
-    }
-  }
-  return lReturnValue;
+	let lReturnValue = true;
+	if (pRule.to.viaOnly && pDependency.cycle) {
+		if (pRule.to.viaOnly.path) {
+			lReturnValue = pDependency.cycle.every(({ name }) =>
+				name.match(replaceGroupPlaceholders(pRule.to.viaOnly.path, pGroups)),
+			);
+		}
+		if (pRule.to.viaOnly.pathNot) {
+			lReturnValue = !pDependency.cycle.some(({ name }) =>
+				name.match(replaceGroupPlaceholders(pRule.to.viaOnly.pathNot, pGroups)),
+			);
+		}
+		if (pRule.to.viaOnly.dependencyTypes) {
+			lReturnValue &&= pDependency.cycle.every(({ dependencyTypes }) =>
+				pRule.to.viaOnly.dependencyTypes.some((pRuleDependencyType) =>
+					dependencyTypes.includes(pRuleDependencyType),
+				),
+			);
+		}
+		if (pRule.to.viaOnly.dependencyTypesNot) {
+			lReturnValue &&= !pDependency.cycle.some(({ dependencyTypes }) =>
+				pRule.to.viaOnly.dependencyTypesNot.some((pRuleDependencyType) =>
+					dependencyTypes.includes(pRuleDependencyType),
+				),
+			);
+		}
+	}
+	return lReturnValue;
 }
 
 export function matchesToIsMoreUnstable(pRule, pModule, pDependency) {
-  if (Object.hasOwn(pRule.to, "moreUnstable")) {
-    return (
-      (pRule.to.moreUnstable &&
-        pModule.instability < pDependency.instability) ||
-      (!pRule.to.moreUnstable && pModule.instability >= pDependency.instability)
-    );
-  }
-  return true;
+	if (Object.hasOwn(pRule.to, "moreUnstable")) {
+		return (
+			(pRule.to.moreUnstable &&
+				pModule.instability < pDependency.instability) ||
+			(!pRule.to.moreUnstable && pModule.instability >= pDependency.instability)
+		);
+	}
+	return true;
 }
 
 export function matchesMoreThanOneDependencyType(pRule, pDependency) {
-  /**
-   * this rule exists to weed out i.e. dependencies declared in both
-   * dependencies and devDependencies. We, however, also use the dependencyTypes
-   * to specify closer to the source what kind of dependency it is (aliased via
-   * a subpath import => both 'aliased' and 'aliased-subpath-import').
-   *
-   * Moreover an alias per definition is also a regular dependency. So we also
-   * need to exclude those.
-   *
-   * Something similar goes for dependencies that are imported as 'type-only' -
-   * which are some sort of regular dependency as well. Hence the use of the
-   * DEPENDENCY_TYPE_DUPLICATES_THAT_MATTER set.
-   */
-
-  if (Object.hasOwn(pRule.to, "moreThanOneDependencyType")) {
-    return (
-      pRule.to.moreThanOneDependencyType ===
-      pDependency.dependencyTypes.filter((pDependencyType) =>
-        DEPENDENCY_TYPE_DUPLICATES_THAT_MATTER.has(pDependencyType),
-      ).length >
-        1
-    );
-  }
-  return true;
+	/**
+	 * this rule exists to weed out i.e. dependencies declared in both
+	 * dependencies and devDependencies. We, however, also use the dependencyTypes
+	 * to specify closer to the source what kind of dependency it is (aliased via
+	 * a subpath import => both 'aliased' and 'aliased-subpath-import').
+	 *
+	 * Moreover an alias per definition is also a regular dependency. So we also
+	 * need to exclude those.
+	 *
+	 * Something similar goes for dependencies that are imported as 'type-only' -
+	 * which are some sort of regular dependency as well. Hence the use of the
+	 * DEPENDENCY_TYPE_DUPLICATES_THAT_MATTER set.
+	 */
+
+	if (Object.hasOwn(pRule.to, "moreThanOneDependencyType")) {
+		return (
+			pRule.to.moreThanOneDependencyType ===
+			pDependency.dependencyTypes.filter((pDependencyType) =>
+				DEPENDENCY_TYPE_DUPLICATES_THAT_MATTER.has(pDependencyType),
+			).length >
+				1
+		);
+	}
+	return true;
 }
 
 export function matchesAncestor(pRule, pModule, pDependency) {
-  if (Object.hasOwn(pRule.to, "ancestor")) {
-    if (pDependency.coreModule || pDependency.couldNotResolve) {
-      return false;
-    }
-    const lModulePath = dirname(resolve(pModule.source)) + sep;
-    const lDependencyPath = dirname(resolve(pDependency.resolved)) + sep;
-    const lDoesMatchAncestor =
-      lModulePath.startsWith(lDependencyPath) &&
-      lModulePath.length > lDependencyPath.length;
-
-    if (pRule.to.ancestor) {
-      return lDoesMatchAncestor;
-    } else {
-      return !lDoesMatchAncestor;
-    }
-  }
-  return true;
+	if (Object.hasOwn(pRule.to, "ancestor")) {
+		if (pDependency.coreModule || pDependency.couldNotResolve) {
+			return false;
+		}
+		const lModulePath = dirname(resolve(pModule.source)) + sep;
+		const lDependencyPath = dirname(resolve(pDependency.resolved)) + sep;
+		const lDoesMatchAncestor =
+			lModulePath.startsWith(lDependencyPath) &&
+			lModulePath.length > lDependencyPath.length;
+
+		if (pRule.to.ancestor) {
+			return lDoesMatchAncestor;
+		} else {
+			return !lDoesMatchAncestor;
+		}
+	}
+	return true;
 }

package/src/validate/rule-classifiers.mjs

@@ -3,12 +3,12 @@
  * @returns {boolean} whether or not the rule is 'module only'
  */
 export function isModuleOnlyRule(pRule) {
-  return (
-    Object.hasOwn(pRule?.from ?? {}, "orphan") ||
-    // note: the to might become optional for required rules
-    Object.hasOwn(pRule?.to ?? {}, "reachable") ||
-    Object.hasOwn(pRule, "module")
-  );
+	return (
+		Object.hasOwn(pRule?.from ?? {}, "orphan") ||
+		// note: the to might become optional for required rules
+		Object.hasOwn(pRule?.to ?? {}, "reachable") ||
+		Object.hasOwn(pRule, "module")
+	);
 }
 /**
  *
@@ -16,7 +16,7 @@ export function isModuleOnlyRule(pRule) {
  * @returns {boolean} whether or not the scope of the rule is "folder" or something else
  */
 export function isFolderScope(pRule) {
-  // TODO might be possible to just rule pRule.scope as it's now
-  // normalized away before getting here.
-  return (pRule?.scope ?? "module") === "folder";
+	// TODO might be possible to just rule pRule.scope as it's now
+	// normalized away before getting here.
+	return (pRule?.scope ?? "module") === "folder";
 }

package/src/validate/violates-required-rule.mjs

@@ -1,8 +1,8 @@
 import {
-  matchesToPath,
-  matchesModulePath,
-  matchesModulePathNot,
-  matchToModulePath,
+	matchesToPath,
+	matchesModulePath,
+	matchesModulePathNot,
+	matchToModulePath,
 } from "./matchers.mjs";
 import { matchesReachesRule } from "./match-module-rule-helpers.mjs";
 import { extractGroups } from "#utl/regex-util.mjs";
@@ -16,25 +16,25 @@ import { extractGroups } from "#utl/regex-util.mjs";
  * @returns {boolean}
  */
 export default function violatesRequiredRule(pRule, pModule) {
-  let lReturnValue = false;
+	let lReturnValue = false;
 
-  if (
-    matchesModulePath(pRule, pModule) &&
-    matchesModulePathNot(pRule, pModule)
-  ) {
-    if (pRule.to.reachable) {
-      lReturnValue = !matchesReachesRule(pRule, pModule);
-    }
+	if (
+		matchesModulePath(pRule, pModule) &&
+		matchesModulePathNot(pRule, pModule)
+	) {
+		if (pRule.to.reachable) {
+			lReturnValue = !matchesReachesRule(pRule, pModule);
+		}
 
-    if (lReturnValue || !pRule.to.reachable) {
-      const lGroups = extractGroups(pRule.module, pModule.source);
-      const lMatchesSelf = matchToModulePath(pRule, pModule, lGroups);
-      lReturnValue =
-        !lMatchesSelf &&
-        !pModule.dependencies.some((pDependency) =>
-          matchesToPath(pRule, pDependency, lGroups),
-        );
-    }
-  }
-  return lReturnValue;
+		if (lReturnValue || !pRule.to.reachable) {
+			const lGroups = extractGroups(pRule.module, pModule.source);
+			const lMatchesSelf = matchToModulePath(pRule, pModule, lGroups);
+			lReturnValue =
+				!lMatchesSelf &&
+				!pModule.dependencies.some((pDependency) =>
+					matchesToPath(pRule, pDependency, lGroups),
+				);
+		}
+	}
+	return lReturnValue;
 }

package/types/cache-options.d.mts

@@ -1,31 +1,31 @@
 export type cacheStrategyType = "metadata" | "content";
 
 export interface ICacheOptions {
-  /**
-   * The folder to store the cache in.
-   *
-   * Defaults to node_modules/.cache/dependency-cruiser/
-   */
-  folder: string;
-  /**
-   * The strategy to use for caching.
-   * - 'metadata': use git metadata to detect changes;
-   * - 'content': use (a checksum of) the contents of files to detect changes.
-   *
-   * 'content'is useful if you're not on git or work on partial clones
-   * (which is typical on CI's). Trade-of: the 'content' strategy is typically
-   * slower.
-   *
-   * Defaults to 'metadata'
-   */
-  strategy: cacheStrategyType;
-  /**
-   * Whether to compress the cache or not
-   *
-   *  Setting this to true adds a few ms to the execution time, but
-   * typically reduces the cache size by 80-90%.
-   *
-   * Defaults to false.
-   */
-  compress: boolean;
+	/**
+	 * The folder to store the cache in.
+	 *
+	 * Defaults to node_modules/.cache/dependency-cruiser/
+	 */
+	folder: string;
+	/**
+	 * The strategy to use for caching.
+	 * - 'metadata': use git metadata to detect changes;
+	 * - 'content': use (a checksum of) the contents of files to detect changes.
+	 *
+	 * 'content'is useful if you're not on git or work on partial clones
+	 * (which is typical on CI's). Trade-of: the 'content' strategy is typically
+	 * slower.
+	 *
+	 * Defaults to 'metadata'
+	 */
+	strategy: cacheStrategyType;
+	/**
+	 * Whether to compress the cache or not
+	 *
+	 *  Setting this to true adds a few ms to the execution time, but
+	 * typically reduces the cache size by 80-90%.
+	 *
+	 * Defaults to false.
+	 */
+	compress: boolean;
 }

package/types/config-utl/extract-babel-config.d.mts

@@ -11,7 +11,7 @@
  *         when dependency-cruiser can't yet process it
  */
 export default function extractBabelConfig(
-  pBabelConfigFileName: string
+	pBabelConfigFileName: string,
 ): Promise<object>;
 
 // regarding the rather unspecific _object_ type - this is what's

package/types/config-utl/extract-depcruise-config.d.mts

@@ -21,7 +21,7 @@ import type { IConfiguration } from "../configuration.mjs";
  * @throws when the config is not valid (/ does not exist/ isn't readable)
  */
 export default function extractDepcruiseConfig(
-  pConfigFileName: string,
-  pAlreadyVisited?: Set<string>,
-  pBaseDirectory?: string,
+	pConfigFileName: string,
+	pAlreadyVisited?: Set<string>,
+	pBaseDirectory?: string,
 ): Promise<IConfiguration>;

package/types/config-utl/extract-depcruise-options.d.mts

@@ -14,5 +14,5 @@ import type { ICruiseOptions } from "../options.mjs";
  * @throws when the config is not valid (/ does not exist/ isn't readable)
  */
 export default function extractDepcruiseOptions(
-  pConfigFileName: string,
+	pConfigFileName: string,
 ): Promise<ICruiseOptions>;

package/types/config-utl/extract-ts-config.d.mts

@@ -12,5 +12,5 @@ import type { ParsedCommandLine } from "typescript";
  * @throws {TypeError} when the tsconfig is unreadable
  */
 export default function extractTSConfig(
-  pTSConfigFileName: string,
+	pTSConfigFileName: string,
 ): ParsedCommandLine;

package/types/config-utl/extract-webpack-resolve-config.d.mts

@@ -13,7 +13,7 @@ import type { ResolveOptions } from "enhanced-resolve";
  *         doesn't exist, or because it's invalid)
  */
 export default function extractWebpackResolveConfig(
-  pWebpackConfigFilename: string,
-  pEnvironment?: { [key: string]: any },
-  pArguments?: { [key: string]: any } | string
+	pWebpackConfigFilename: string,
+	pEnvironment?: { [key: string]: any },
+	pArguments?: { [key: string]: any } | string,
 ): Promise<ResolveOptions>;

package/types/configuration.d.mts

@@ -2,16 +2,16 @@ import type { ICruiseOptions } from "./options.mjs";
 import type { IFlattenedRuleSet } from "./rule-set.mjs";
 
 export interface IConfiguration extends IFlattenedRuleSet {
-  /**
-   * A (node require resolvable) file path to a dependency-cruiser config
-   * that serves as the base for this one...
-   * ... or an array of these
-   */
-  extends?: string | string[];
-  /**
-   * Runtime configuration options
-   */
-  options?: ICruiseOptions;
+	/**
+	 * A (node require resolvable) file path to a dependency-cruiser config
+	 * that serves as the base for this one...
+	 * ... or an array of these
+	 */
+	extends?: string | string[];
+	/**
+	 * Runtime configuration options
+	 */
+	options?: ICruiseOptions;
 }
 
 // for backwards compatibility: