dependency-cruiser 17.3.3-beta-2 → 17.3.3-beta-3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dependency-cruiser",
-	"version": "17.3.3-beta-2",
+	"version": "17.3.3-beta-3",
 	"description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
 	"keywords": [
 		"static analysis",

package/src/enrich/derive/reachable.mjs

@@ -1,3 +1,4 @@
+/* eslint-disable security/detect-non-literal-regexp */
 /* eslint-disable security/detect-object-injection, no-inline-comments */
 import {
 	matchToModulePath,
@@ -22,8 +23,9 @@ function isModuleInRuleFrom(pRule) {
 		const lRuleFrom = pRule.from ?? pRule.module;
 		if (lRuleFrom) {
 			return (
-				(!lRuleFrom.path || pModule.source.match(lRuleFrom.path)) &&
-				(!lRuleFrom.pathNot || !pModule.source.match(lRuleFrom.pathNot))
+				(!lRuleFrom.path || new RegExp(lRuleFrom.path).test(pModule.source)) &&
+				(!lRuleFrom.pathNot ||
+					!new RegExp(lRuleFrom.pathNot).test(pModule.source))
 			);
 		}
 		return false;
@@ -118,12 +120,11 @@ function shouldAddReachable(pRule, pModuleTo, pGraph) {
 }
 
 function addReachesToModule(pModule, pGraph, pIndexedGraph, pReachableRule) {
-	const lToModules = pGraph.filter((pToModule) =>
-		isModuleInRuleTo(pReachableRule, pToModule, pModule),
-	);
-
-	for (const lToModule of lToModules) {
-		if (pModule.source !== lToModule.source) {
+	for (const lToModule of pGraph) {
+		if (
+			pModule.source !== lToModule.source &&
+			isModuleInRuleTo(pReachableRule, lToModule, pModule)
+		) {
 			const lPath = pIndexedGraph.getPath(pModule.source, lToModule.source);
 
 			if (lPath.length > 0) {

package/src/graph-utl/indexed-module-graph.mjs

@@ -164,25 +164,19 @@ export default class IndexedModuleGraph {
 		if (!lFromNode) {
 			return [];
 		}
+		for (const lDependency of lFromNode.dependencies) {
+			if (!pVisited.has(lDependency.name)) {
+				if (lDependency.name === pTo) {
+					return [this.#geldEdge(lDependency)];
+				}
+				let lCandidatePath = this.getPath(lDependency.name, pTo, pVisited);
 
-		const lDirectUnvisitedDependencies = lFromNode.dependencies
-			.filter((pDependency) => !pVisited.has(pDependency.name))
-			.map(this.#geldEdge);
-		const lFoundDependency = lDirectUnvisitedDependencies.find(
-			(pDependency) => pDependency.name === pTo,
-		);
-
-		if (lFoundDependency) {
-			return [lFoundDependency];
-		}
-
-		for (const lNewFrom of lDirectUnvisitedDependencies) {
-			let lCandidatePath = this.getPath(lNewFrom.name, pTo, pVisited);
-
-			if (lCandidatePath.length > 0) {
-				return [lNewFrom].concat(lCandidatePath);
+				if (lCandidatePath.length > 0) {
+					return [this.#geldEdge(lDependency)].concat(lCandidatePath);
+				}
 			}
 		}
+
 		return [];
 	}
 

package/src/main/options/normalize.mjs

@@ -64,7 +64,7 @@ function normalizeCollapse(pCollapse) {
 	const lFolderBelowNodeModules = `node_modules/${lOneOrMoreNonSlashes}`;
 	const lSingleDigitRe = /^\d$/;
 
-	if (typeof pCollapse === "number" || pCollapse.match(lSingleDigitRe)) {
+	if (typeof pCollapse === "number" || lSingleDigitRe.test(pCollapse)) {
 		lReturnValue = `${lFolderBelowNodeModules}|^${lFolderPattern.repeat(
 			Number.parseInt(pCollapse, 10),
 		)}`;

package/src/meta.cjs

@@ -1,6 +1,6 @@
 /* generated - don't edit */
 module.exports = {
-	version: "17.3.3-beta-2",
+	version: "17.3.3-beta-3",
 	engines: {
 		node: "^20.12||^22||>=24",
 	},

package/src/report/anon/index.mjs

@@ -149,8 +149,10 @@ function anonymize(pResults, pWordList) {
 function sanitizeWordList(pWordList) {
 	return pWordList
 		.map((pString) => pString.replace(/[^a-zA-Z-]/g, "_"))
-		.filter((pString) => pString.match(/^[a-zA-Z-_]+$/g))
-		.filter((pString) => !pString.match(WHITELIST_RE));
+		.filter(
+			(pString) =>
+				/^[a-zA-Z-_]+$/g.test(pString) && !WHITELIST_RE.test(pString),
+		);
 }
 
 /**

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

@@ -1,28 +1,34 @@
+/* eslint-disable security/detect-non-literal-regexp */
 import { isModuleOnlyRule, isFolderScope } from "./rule-classifiers.mjs";
 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 !pRule.from.path || new RegExp(pRule.from.path).test(pFromFolder.name);
 }
 
 function fromFolderPathNot(pRule, pFromFolder) {
-	return Boolean(
-		!pRule.from.pathNot || !pFromFolder.name.match(pRule.from.pathNot),
+	return (
+		!pRule.from.pathNot ||
+		!new RegExp(pRule.from.pathNot).test(pFromFolder.name)
 	);
 }
 
 function toFolderPath(pRule, pToFolder, pGroups) {
-	return Boolean(
+	return (
 		!pRule.to.path ||
-		pToFolder.name.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
+		new RegExp(replaceGroupPlaceholders(pRule.to.path, pGroups)).test(
+			pToFolder.name,
+		)
 	);
 }
 
 function toFolderPathNot(pRule, pToFolder, pGroups) {
-	return Boolean(
+	return (
 		!pRule.to.pathNot ||
-		!pToFolder.name.match(replaceGroupPlaceholders(pRule.to.pathNot, pGroups)),
+		!new RegExp(replaceGroupPlaceholders(pRule.to.pathNot, pGroups)).test(
+			pToFolder.name,
+		)
 	);
 }
 

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

@@ -1,3 +1,4 @@
+/* eslint-disable security/detect-non-literal-regexp */
 import {
 	matchToModulePath,
 	matchToModulePathNot,
@@ -98,8 +99,8 @@ export function matchesReachesRule(pRule, pModule) {
 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)),
+			(!pRule.from.path || new RegExp(pRule.from.path).test(pDependent)) &&
+			(!pRule.from.pathNot || !new RegExp(pRule.from.pathNot).test(pDependent)),
 	).length;
 	return (
 		(!pRule.module.numberOfDependentsLessThan ||

package/src/validate/matchers.mjs

@@ -1,3 +1,4 @@
+/* eslint-disable security/detect-non-literal-regexp */
 /* eslint-disable security/detect-object-injection */
 import { dirname, resolve, sep } from "node:path/posix";
 import { replaceGroupPlaceholders } from "#utl/regex-util.mjs";
@@ -29,10 +30,10 @@ export function propertyEquals(pRule, pDependency, pProperty) {
 }
 
 export function propertyMatches(pRule, pDependency, pRuleProperty, pProperty) {
-	return Boolean(
+	return (
 		!pRule.to[pRuleProperty] ||
 		(pDependency[pProperty] &&
-			pDependency[pProperty].match(pRule.to[pRuleProperty])),
+			new RegExp(pRule.to[pRuleProperty]).test(pDependency[pProperty]))
 	);
 }
 
@@ -42,37 +43,40 @@ export function propertyMatchesNot(
 	pRuleProperty,
 	pProperty,
 ) {
-	return Boolean(
+	return (
 		!pRule.to[pRuleProperty] ||
 		(pDependency[pProperty] &&
-			!pDependency[pProperty].match(pRule.to[pRuleProperty])),
+			!new RegExp(pRule.to[pRuleProperty]).test(pDependency[pProperty]))
 	);
 }
 
 export function matchesFromPath(pRule, pModule) {
-	return Boolean(!pRule.from.path || pModule.source.match(pRule.from.path));
+	return !pRule.from.path || new RegExp(pRule.from.path).test(pModule.source);
 }
 
 export function matchesFromPathNot(pRule, pModule) {
-	return Boolean(
-		!pRule.from.pathNot || !pModule.source.match(pRule.from.pathNot),
+	return (
+		!pRule.from.pathNot || !new RegExp(pRule.from.pathNot).test(pModule.source)
 	);
 }
 
 export function matchesModulePath(pRule, pModule) {
-	return Boolean(!pRule.module.path || pModule.source.match(pRule.module.path));
+	return (
+		!pRule.module.path || new RegExp(pRule.module.path).test(pModule.source)
+	);
 }
 
 export function matchesModulePathNot(pRule, pModule) {
-	return Boolean(
-		!pRule.module.pathNot || !pModule.source.match(pRule.module.pathNot),
+	return (
+		!pRule.module.pathNot ||
+		!new RegExp(pRule.module.pathNot).test(pModule.source)
 	);
 }
 
 function _matchesToPath(pRule, pString, pGroups = []) {
-	return Boolean(
+	return (
 		!pRule.to.path ||
-		pString.match(replaceGroupPlaceholders(pRule.to.path, pGroups)),
+		new RegExp(replaceGroupPlaceholders(pRule.to.path, pGroups)).test(pString)
 	);
 }
 
@@ -87,7 +91,9 @@ export function matchToModulePath(pRule, pModule, pGroups) {
 function _matchesToPathNot(pRule, pString, pGroups = []) {
 	return (
 		!pRule.to.pathNot ||
-		!pString.match(replaceGroupPlaceholders(pRule.to.pathNot, pGroups))
+		!new RegExp(replaceGroupPlaceholders(pRule.to.pathNot, pGroups)).test(
+			pString,
+		)
 	);
 }
 
@@ -100,16 +106,16 @@ export function matchToModulePathNot(pRule, pModule, pGroups) {
 }
 
 export function matchesToDependencyTypes(pRule, pDependency) {
-	return Boolean(
+	return (
 		!pRule.to.dependencyTypes ||
-		intersects(pDependency.dependencyTypes, pRule.to.dependencyTypes),
+		intersects(pDependency.dependencyTypes, pRule.to.dependencyTypes)
 	);
 }
 
 export function matchesToDependencyTypesNot(pRule, pDependency) {
-	return Boolean(
+	return (
 		!pRule.to.dependencyTypesNot ||
-		!intersects(pDependency.dependencyTypes, pRule.to.dependencyTypesNot),
+		!intersects(pDependency.dependencyTypes, pRule.to.dependencyTypesNot)
 	);
 }
 
@@ -118,12 +124,16 @@ export function matchesToVia(pRule, pDependency, pGroups) {
 	if (pRule.to.via && pDependency.cycle) {
 		if (pRule.to.via.path) {
 			lReturnValue = pDependency.cycle.some(({ name }) =>
-				name.match(replaceGroupPlaceholders(pRule.to.via.path, pGroups)),
+				new RegExp(replaceGroupPlaceholders(pRule.to.via.path, pGroups)).test(
+					name,
+				),
 			);
 		}
 		if (pRule.to.via.pathNot) {
 			lReturnValue = !pDependency.cycle.every(({ name }) =>
-				name.match(replaceGroupPlaceholders(pRule.to.via.pathNot, pGroups)),
+				new RegExp(
+					replaceGroupPlaceholders(pRule.to.via.pathNot, pGroups),
+				).test(name),
 			);
 		}
 		if (pRule.to.via.dependencyTypes) {
@@ -149,12 +159,16 @@ export function matchesToViaOnly(pRule, pDependency, pGroups) {
 	if (pRule.to.viaOnly && pDependency.cycle) {
 		if (pRule.to.viaOnly.path) {
 			lReturnValue = pDependency.cycle.every(({ name }) =>
-				name.match(replaceGroupPlaceholders(pRule.to.viaOnly.path, pGroups)),
+				new RegExp(
+					replaceGroupPlaceholders(pRule.to.viaOnly.path, pGroups),
+				).test(name),
 			);
 		}
 		if (pRule.to.viaOnly.pathNot) {
 			lReturnValue = !pDependency.cycle.some(({ name }) =>
-				name.match(replaceGroupPlaceholders(pRule.to.viaOnly.pathNot, pGroups)),
+				new RegExp(
+					replaceGroupPlaceholders(pRule.to.viaOnly.pathNot, pGroups),
+				).test(name),
 			);
 		}
 		if (pRule.to.viaOnly.dependencyTypes) {