dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/validate/index.mjs

@@ -8,61 +8,61 @@ import matchFolderRule from "./match-folder-dependency-rule.mjs";
  */
 
 function compareSeverity(pFirst, pSecond) {
-  const lSeverity2Int = {
-    error: 1,
-    warn: 2,
-    info: 3,
-  };
+	const lSeverity2Int = {
+		error: 1,
+		warn: 2,
+		info: 3,
+	};
 
-  return lSeverity2Int[pFirst.severity] - lSeverity2Int[pSecond.severity];
+	return lSeverity2Int[pFirst.severity] - lSeverity2Int[pSecond.severity];
 }
 
 function validateAgainstAllowedRules(pRuleSet, pMatchModule, pFrom, pTo) {
-  let lFoundRuleViolations = [];
+	let lFoundRuleViolations = [];
 
-  if (pRuleSet.allowed) {
-    const lInterestingAllowedRules = pRuleSet.allowed.filter(
-      pMatchModule.isInteresting,
-    );
+	if (pRuleSet.allowed) {
+		const lInterestingAllowedRules = pRuleSet.allowed.filter(
+			pMatchModule.isInteresting,
+		);
 
-    if (
-      lInterestingAllowedRules.length > 0 &&
-      !lInterestingAllowedRules.some(pMatchModule.match(pFrom, pTo))
-    ) {
-      lFoundRuleViolations.push({
-        severity: pRuleSet.allowedSeverity,
-        name: "not-in-allowed",
-      });
-    }
-  }
-  return lFoundRuleViolations;
+		if (
+			lInterestingAllowedRules.length > 0 &&
+			!lInterestingAllowedRules.some(pMatchModule.match(pFrom, pTo))
+		) {
+			lFoundRuleViolations.push({
+				severity: pRuleSet.allowedSeverity,
+				name: "not-in-allowed",
+			});
+		}
+	}
+	return lFoundRuleViolations;
 }
 
 function validateAgainstForbiddenRules(pRuleSet, pMatchModule, pFrom, pTo) {
-  pRuleSet.forbidden = pRuleSet.forbidden || [];
+	pRuleSet.forbidden = pRuleSet.forbidden || [];
 
-  return pRuleSet.forbidden
-    .filter(pMatchModule.isInteresting)
-    .filter(pMatchModule.match(pFrom, pTo))
-    .map((pMatchedRule) => ({
-      severity: pMatchedRule.severity,
-      name: pMatchedRule.name,
-    }));
+	return pRuleSet.forbidden
+		.filter(pMatchModule.isInteresting)
+		.filter(pMatchModule.match(pFrom, pTo))
+		.map((pMatchedRule) => ({
+			severity: pMatchedRule.severity,
+			name: pMatchedRule.name,
+		}));
 }
 
 function validateAgainstRequiredRules(pRuleSet, pModule, pMatchModule) {
-  let lFoundRequiredRuleViolations = [];
+	let lFoundRequiredRuleViolations = [];
 
-  if (pRuleSet?.required) {
-    lFoundRequiredRuleViolations = pRuleSet.required
-      .filter(pMatchModule.isInteresting)
-      .filter((pRule) => violatesRequiredRule(pRule, pModule))
-      .map((pMatchedRule) => ({
-        severity: pMatchedRule.severity,
-        name: pMatchedRule.name,
-      }));
-  }
-  return lFoundRequiredRuleViolations;
+	if (pRuleSet?.required) {
+		lFoundRequiredRuleViolations = pRuleSet.required
+			.filter(pMatchModule.isInteresting)
+			.filter((pRule) => violatesRequiredRule(pRule, pModule))
+			.map((pMatchedRule) => ({
+				severity: pMatchedRule.severity,
+				name: pMatchedRule.name,
+			}));
+	}
+	return lFoundRequiredRuleViolations;
 }
 
 /**
@@ -74,38 +74,38 @@ function validateAgainstRequiredRules(pRuleSet, pModule, pMatchModule) {
  * @returns {IValidationResult}
  */
 function validateAgainstRules(pRuleSet, pFrom, pTo, pMatchModule) {
-  /** @type {IValidationResult} */
-  let lReturnValue = { valid: true };
+	/** @type {IValidationResult} */
+	let lReturnValue = { valid: true };
 
-  const lFoundRuleViolations = validateAgainstAllowedRules(
-    pRuleSet,
-    pMatchModule,
-    pFrom,
-    pTo,
-  )
-    .concat(validateAgainstForbiddenRules(pRuleSet, pMatchModule, pFrom, pTo))
-    .concat(validateAgainstRequiredRules(pRuleSet, pFrom, pMatchModule))
-    .sort(compareSeverity);
+	const lFoundRuleViolations = validateAgainstAllowedRules(
+		pRuleSet,
+		pMatchModule,
+		pFrom,
+		pTo,
+	)
+		.concat(validateAgainstForbiddenRules(pRuleSet, pMatchModule, pFrom, pTo))
+		.concat(validateAgainstRequiredRules(pRuleSet, pFrom, pMatchModule))
+		.sort(compareSeverity);
 
-  lReturnValue.valid = lFoundRuleViolations.length === 0;
-  if (!lReturnValue.valid) {
-    lReturnValue.rules = lFoundRuleViolations;
-  }
-  return lReturnValue;
+	lReturnValue.valid = lFoundRuleViolations.length === 0;
+	if (!lReturnValue.valid) {
+		lReturnValue.rules = lFoundRuleViolations;
+	}
+	return lReturnValue;
 }
 export function validateModule(pRuleSet, pModule) {
-  return validateAgainstRules(pRuleSet, pModule, {}, matchModuleRule);
+	return validateAgainstRules(pRuleSet, pModule, {}, matchModuleRule);
 }
 
 export function validateDependency(pRuleSet, pFrom, pTo) {
-  return validateAgainstRules(pRuleSet, pFrom, pTo, matchDependencyRule);
+	return validateAgainstRules(pRuleSet, pFrom, pTo, matchDependencyRule);
 }
 
 export function validateFolder(pRuleSet, pFromFolder, pToFolder) {
-  return validateAgainstRules(
-    pRuleSet,
-    pFromFolder,
-    pToFolder,
-    matchFolderRule,
-  );
+	return validateAgainstRules(
+		pRuleSet,
+		pFromFolder,
+		pToFolder,
+		matchFolderRule,
+	);
 }

package/src/validate/match-dependency-rule.mjs

@@ -1,20 +1,20 @@
 // @ts-check
 import { isModuleOnlyRule, isFolderScope } from "./rule-classifiers.mjs";
 import {
-  propertyEquals,
-  propertyMatches,
-  propertyMatchesNot,
-  matchesAncestor,
-  matchesFromPath,
-  matchesFromPathNot,
-  matchesToPath,
-  matchesToPathNot,
-  matchesToDependencyTypes,
-  matchesToDependencyTypesNot,
-  matchesToVia,
-  matchesToViaOnly,
-  matchesToIsMoreUnstable,
-  matchesMoreThanOneDependencyType,
+	propertyEquals,
+	propertyMatches,
+	propertyMatchesNot,
+	matchesAncestor,
+	matchesFromPath,
+	matchesFromPathNot,
+	matchesToPath,
+	matchesToPathNot,
+	matchesToDependencyTypes,
+	matchesToDependencyTypesNot,
+	matchesToVia,
+	matchesToViaOnly,
+	matchesToIsMoreUnstable,
+	matchesMoreThanOneDependencyType,
 } from "./matchers.mjs";
 import { extractGroups } from "#utl/regex-util.mjs";
 
@@ -29,37 +29,37 @@ import { extractGroups } from "#utl/regex-util.mjs";
  * @returns {(pRule) => boolean}
  */
 function match(pFrom, pTo) {
-  // eslint-disable-next-line complexity
-  return (pRule) => {
-    const lGroups = extractGroups(pRule.from, pFrom.source);
+	// eslint-disable-next-line complexity
+	return (pRule) => {
+		const lGroups = extractGroups(pRule.from, pFrom.source);
 
-    return (
-      matchesFromPath(pRule, pFrom) &&
-      matchesFromPathNot(pRule, pFrom) &&
-      matchesToPath(pRule, pTo, lGroups) &&
-      matchesToPathNot(pRule, pTo, lGroups) &&
-      matchesToDependencyTypes(pRule, pTo) &&
-      matchesToDependencyTypesNot(pRule, pTo) &&
-      matchesMoreThanOneDependencyType(pRule, pTo) &&
-      // preCompilationOnly is not a mandatory attribute, but if the attribute
-      // is in the rule but not in the dependency there won't be a match
-      // anyway, so we can use the default propertyEquals method regardless
-      propertyEquals(pRule, pTo, "preCompilationOnly") &&
-      // couldNotResolve, circular, dynamic and exoticallyRequired _are_ mandatory
-      propertyEquals(pRule, pTo, "couldNotResolve") &&
-      propertyEquals(pRule, pTo, "circular") &&
-      propertyEquals(pRule, pTo, "dynamic") &&
-      propertyEquals(pRule, pTo, "exoticallyRequired") &&
-      propertyMatches(pRule, pTo, "license", "license") &&
-      propertyMatchesNot(pRule, pTo, "licenseNot", "license") &&
-      propertyMatches(pRule, pTo, "exoticRequire", "exoticRequire") &&
-      propertyMatchesNot(pRule, pTo, "exoticRequireNot", "exoticRequire") &&
-      matchesToVia(pRule, pTo, lGroups) &&
-      matchesToViaOnly(pRule, pTo, lGroups) &&
-      matchesToIsMoreUnstable(pRule, pFrom, pTo) &&
-      matchesAncestor(pRule, pFrom, pTo)
-    );
-  };
+		return (
+			matchesFromPath(pRule, pFrom) &&
+			matchesFromPathNot(pRule, pFrom) &&
+			matchesToPath(pRule, pTo, lGroups) &&
+			matchesToPathNot(pRule, pTo, lGroups) &&
+			matchesToDependencyTypes(pRule, pTo) &&
+			matchesToDependencyTypesNot(pRule, pTo) &&
+			matchesMoreThanOneDependencyType(pRule, pTo) &&
+			// preCompilationOnly is not a mandatory attribute, but if the attribute
+			// is in the rule but not in the dependency there won't be a match
+			// anyway, so we can use the default propertyEquals method regardless
+			propertyEquals(pRule, pTo, "preCompilationOnly") &&
+			// couldNotResolve, circular, dynamic and exoticallyRequired _are_ mandatory
+			propertyEquals(pRule, pTo, "couldNotResolve") &&
+			propertyEquals(pRule, pTo, "circular") &&
+			propertyEquals(pRule, pTo, "dynamic") &&
+			propertyEquals(pRule, pTo, "exoticallyRequired") &&
+			propertyMatches(pRule, pTo, "license", "license") &&
+			propertyMatchesNot(pRule, pTo, "licenseNot", "license") &&
+			propertyMatches(pRule, pTo, "exoticRequire", "exoticRequire") &&
+			propertyMatchesNot(pRule, pTo, "exoticRequireNot", "exoticRequire") &&
+			matchesToVia(pRule, pTo, lGroups) &&
+			matchesToViaOnly(pRule, pTo, lGroups) &&
+			matchesToIsMoreUnstable(pRule, pFrom, pTo) &&
+			matchesAncestor(pRule, pFrom, pTo)
+		);
+	};
 }
 
 /**
@@ -67,9 +67,9 @@ function match(pFrom, pTo) {
  * @returns boolean
  */
 const isInteresting = (pRule) =>
-  !isModuleOnlyRule(pRule) && !isFolderScope(pRule);
+	!isModuleOnlyRule(pRule) && !isFolderScope(pRule);
 
 export default {
-  match,
-  isInteresting,
+	match,
+	isInteresting,
 };

package/src/validate/match-folder-dependency-rule.mjs

@@ -3,27 +3,27 @@ import { propertyEquals, matchesToIsMoreUnstable } from "./matchers.mjs";
 import { extractGroups, replaceGroupPlaceholders } from "#utl/regex-util.mjs";
 
 function fromFolderPath(pRule, pFromFolder) {
-  return Boolean(!pRule.from.path || pFromFolder.name.match(pRule.from.path));
+	return Boolean(!pRule.from.path || pFromFolder.name.match(pRule.from.path));
 }
 
 function fromFolderPathNot(pRule, pFromFolder) {
-  return Boolean(
-    !pRule.from.pathNot || !pFromFolder.name.match(pRule.from.pathNot),
-  );
+	return Boolean(
+		!pRule.from.pathNot || !pFromFolder.name.match(pRule.from.pathNot),
+	);
 }
 
 function toFolderPath(pRule, pToFolder, pGroups) {
-  return Boolean(
-    !pRule.to.path ||
-    pToFolder.name.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
-  );
+	return Boolean(
+		!pRule.to.path ||
+		pToFolder.name.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
+	);
 }
 
 function toFolderPathNot(pRule, pToFolder, pGroups) {
-  return Boolean(
-    !pRule.to.pathNot ||
-    !pToFolder.name.match(replaceGroupPlaceholders(pRule.to.pathNot, pGroups)),
-  );
+	return Boolean(
+		!pRule.to.pathNot ||
+		!pToFolder.name.match(replaceGroupPlaceholders(pRule.to.pathNot, pGroups)),
+	);
 }
 
 /**
@@ -33,19 +33,19 @@ function toFolderPathNot(pRule, pToFolder, pGroups) {
  * @returns {(pRule) => boolean}
  */
 function match(pFromFolder, pToFolder) {
-  return (pRule) => {
-    const lGroups = extractGroups(pRule.from, pFromFolder.name);
+	return (pRule) => {
+		const lGroups = extractGroups(pRule.from, pFromFolder.name);
 
-    // TODO: via's
-    return (
-      fromFolderPath(pRule, pFromFolder) &&
-      fromFolderPathNot(pRule, pFromFolder) &&
-      toFolderPath(pRule, pToFolder, lGroups) &&
-      toFolderPathNot(pRule, pToFolder, lGroups) &&
-      matchesToIsMoreUnstable(pRule, pFromFolder, pToFolder) &&
-      propertyEquals(pRule, pToFolder, "circular")
-    );
-  };
+		// TODO: via's
+		return (
+			fromFolderPath(pRule, pFromFolder) &&
+			fromFolderPathNot(pRule, pFromFolder) &&
+			toFolderPath(pRule, pToFolder, lGroups) &&
+			toFolderPathNot(pRule, pToFolder, lGroups) &&
+			matchesToIsMoreUnstable(pRule, pFromFolder, pToFolder) &&
+			propertyEquals(pRule, pToFolder, "circular")
+		);
+	};
 }
 /**
  *
@@ -53,9 +53,9 @@ function match(pFromFolder, pToFolder) {
  * @returns boolean
  */
 const isInteresting = (pRule) =>
-  isFolderScope(pRule) && !isModuleOnlyRule(pRule);
+	isFolderScope(pRule) && !isModuleOnlyRule(pRule);
 
 export default {
-  match,
-  isInteresting,
+	match,
+	isInteresting,
 };

package/src/validate/match-module-rule-helpers.mjs

@@ -1,10 +1,10 @@
 import {
-  matchToModulePath,
-  matchToModulePathNot,
-  matchesFromPath,
-  matchesFromPathNot,
-  matchesModulePath,
-  matchesModulePathNot,
+	matchToModulePath,
+	matchToModulePathNot,
+	matchesFromPath,
+	matchesFromPathNot,
+	matchesModulePath,
+	matchesModulePathNot,
 } from "./matchers.mjs";
 import { extractGroups } from "#utl/regex-util.mjs";
 
@@ -22,13 +22,13 @@ import { extractGroups } from "#utl/regex-util.mjs";
  * @returns {boolean}
  */
 export function matchesOrphanRule(pRule, pModule) {
-  return (
-    Object.hasOwn(pRule?.from ?? {}, "orphan") &&
-    // @ts-expect-error the 'hasOwn' above guarantees there's a 'from.orphan' attribute
-    pModule.orphan === pRule.from.orphan &&
-    matchesFromPath(pRule, pModule) &&
-    matchesFromPathNot(pRule, pModule)
-  );
+	return (
+		Object.hasOwn(pRule?.from ?? {}, "orphan") &&
+		// @ts-expect-error the 'hasOwn' above guarantees there's a 'from.orphan' attribute
+		pModule.orphan === pRule.from.orphan &&
+		matchesFromPath(pRule, pModule) &&
+		matchesFromPathNot(pRule, pModule)
+	);
 }
 
 /**
@@ -41,27 +41,27 @@ export function matchesOrphanRule(pRule, pModule) {
  * @returns {boolean}
  */
 export function matchesReachableRule(pRule, pModule) {
-  if (
-    Object.hasOwn(pRule?.to ?? {}, "reachable") &&
-    Object.hasOwn(pModule, "reachable")
-  ) {
-    // @ts-expect-error the 'hasOwn' above ensures the 'reachable' exists
-    const lReachableRecord = pModule.reachable.find(
-      (pReachable) =>
-        pReachable.asDefinedInRule === pRule.name &&
-        // @ts-expect-error the 'hasOwn' above ensures the 'to.reachable' exists
-        pReachable.value === pRule.to.reachable,
-    );
-    if (lReachableRecord) {
-      const lGroups = extractGroups(pRule.from, lReachableRecord.matchedFrom);
+	if (
+		Object.hasOwn(pRule?.to ?? {}, "reachable") &&
+		Object.hasOwn(pModule, "reachable")
+	) {
+		// @ts-expect-error the 'hasOwn' above ensures the 'reachable' exists
+		const lReachableRecord = pModule.reachable.find(
+			(pReachable) =>
+				pReachable.asDefinedInRule === pRule.name &&
+				// @ts-expect-error the 'hasOwn' above ensures the 'to.reachable' exists
+				pReachable.value === pRule.to.reachable,
+		);
+		if (lReachableRecord) {
+			const lGroups = extractGroups(pRule.from, lReachableRecord.matchedFrom);
 
-      return (
-        matchToModulePath(pRule, pModule, lGroups) &&
-        matchToModulePathNot(pRule, pModule, lGroups)
-      );
-    }
-  }
-  return false;
+			return (
+				matchToModulePath(pRule, pModule, lGroups) &&
+				matchToModulePathNot(pRule, pModule, lGroups)
+			);
+		}
+	}
+	return false;
 }
 
 /**
@@ -74,20 +74,20 @@ export function matchesReachableRule(pRule, pModule) {
  * @returns {boolean}
  */
 export function matchesReachesRule(pRule, pModule) {
-  return (
-    Object.hasOwn(pRule?.to ?? {}, "reachable") &&
-    Object.hasOwn(pModule, "reaches") &&
-    // @ts-expect-error the 'hasOwn' above guarantees the .reaches exists
-    pModule.reaches.some(
-      (pReaches) =>
-        pReaches.asDefinedInRule === pRule.name &&
-        pReaches.modules.some(
-          (pReachesModule) =>
-            matchToModulePath(pRule, pReachesModule) &&
-            matchToModulePathNot(pRule, pReachesModule),
-        ),
-    )
-  );
+	return (
+		Object.hasOwn(pRule?.to ?? {}, "reachable") &&
+		Object.hasOwn(pModule, "reaches") &&
+		// @ts-expect-error the 'hasOwn' above guarantees the .reaches exists
+		pModule.reaches.some(
+			(pReaches) =>
+				pReaches.asDefinedInRule === pRule.name &&
+				pReaches.modules.some(
+					(pReachesModule) =>
+						matchToModulePath(pRule, pReachesModule) &&
+						matchToModulePathNot(pRule, pReachesModule),
+				),
+		)
+	);
 }
 /**
  *
@@ -96,17 +96,17 @@ export function matchesReachesRule(pRule, pModule) {
  * @returns {boolean}
  */
 function dependentsCountsMatch(pRule, pDependents) {
-  const lMatchingDependentsCount = pDependents.filter(
-    (pDependent) =>
-      Boolean(!pRule.from.path || pDependent.match(pRule.from.path)) &&
-      Boolean(!pRule.from.pathNot || !pDependent.match(pRule.from.pathNot)),
-  ).length;
-  return (
-    (!pRule.module.numberOfDependentsLessThan ||
-      lMatchingDependentsCount < pRule.module.numberOfDependentsLessThan) &&
-    (!pRule.module.numberOfDependentsMoreThan ||
-      lMatchingDependentsCount > pRule.module.numberOfDependentsMoreThan)
-  );
+	const lMatchingDependentsCount = pDependents.filter(
+		(pDependent) =>
+			Boolean(!pRule.from.path || pDependent.match(pRule.from.path)) &&
+			Boolean(!pRule.from.pathNot || !pDependent.match(pRule.from.pathNot)),
+	).length;
+	return (
+		(!pRule.module.numberOfDependentsLessThan ||
+			lMatchingDependentsCount < pRule.module.numberOfDependentsLessThan) &&
+		(!pRule.module.numberOfDependentsMoreThan ||
+			lMatchingDependentsCount > pRule.module.numberOfDependentsMoreThan)
+	);
 }
 
 /**
@@ -117,22 +117,22 @@ function dependentsCountsMatch(pRule, pDependents) {
  */
 
 export function matchesDependentsRule(pRule, pModule) {
-  if (
-    (Object.hasOwn(pModule, "dependents") &&
-      Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsLessThan")) ||
-    Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsMoreThan")
-  ) {
-    return (
-      // group matching seems like a nice idea, however, the 'from' part of the
-      // rule is going to match not one module (as with regular dependency rules)
-      // but a whole bunch of them, being the 'dependents'. So that match is going
-      // to produce not one result, but one per matching dependent. To get meaningful
-      // results we'd probably have to loop over these and or the
-      // matchToModulePath together.
-      matchesModulePath(pRule, pModule) &&
-      matchesModulePathNot(pRule, pModule) &&
-      dependentsCountsMatch(pRule, pModule.dependents)
-    );
-  }
-  return false;
+	if (
+		(Object.hasOwn(pModule, "dependents") &&
+			Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsLessThan")) ||
+		Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsMoreThan")
+	) {
+		return (
+			// group matching seems like a nice idea, however, the 'from' part of the
+			// rule is going to match not one module (as with regular dependency rules)
+			// but a whole bunch of them, being the 'dependents'. So that match is going
+			// to produce not one result, but one per matching dependent. To get meaningful
+			// results we'd probably have to loop over these and or the
+			// matchToModulePath together.
+			matchesModulePath(pRule, pModule) &&
+			matchesModulePathNot(pRule, pModule) &&
+			dependentsCountsMatch(pRule, pModule.dependents)
+		);
+	}
+	return false;
 }

package/src/validate/match-module-rule.mjs

@@ -1,9 +1,9 @@
 import { isModuleOnlyRule, isFolderScope } from "./rule-classifiers.mjs";
 import {
-  matchesOrphanRule,
-  matchesReachableRule,
-  matchesReachesRule,
-  matchesDependentsRule,
+	matchesOrphanRule,
+	matchesReachableRule,
+	matchesReachesRule,
+	matchesDependentsRule,
 } from "./match-module-rule-helpers.mjs";
 
 /**
@@ -16,11 +16,11 @@ import {
  * @returns {(pRule:IAnyRuleType) => boolean}
  */
 function match(pModule) {
-  return (pRule) =>
-    matchesOrphanRule(pRule, pModule) ||
-    matchesReachableRule(pRule, pModule) ||
-    matchesReachesRule(pRule, pModule) ||
-    matchesDependentsRule(pRule, pModule);
+	return (pRule) =>
+		matchesOrphanRule(pRule, pModule) ||
+		matchesReachableRule(pRule, pModule) ||
+		matchesReachesRule(pRule, pModule) ||
+		matchesDependentsRule(pRule, pModule);
 }
 
 /**
@@ -28,9 +28,9 @@ function match(pModule) {
  * @returns boolean
  */
 const isInteresting = (pRule) =>
-  isModuleOnlyRule(pRule) && !isFolderScope(pRule);
+	isModuleOnlyRule(pRule) && !isFolderScope(pRule);
 
 export default {
-  match,
-  isInteresting,
+	match,
+	isInteresting,
 };