dependency-cruiser 17.3.5 → 17.3.7

package/src/config-utl/extract-depcruise-config/merge-configs.mjs

@@ -105,7 +105,7 @@ function mergeAllowedSeverities(pConfigExtended, pConfigBase) {
  * @returns {Object} - The merged rule set
  */
 // eslint-disable-next-line complexity
-export default (pConfigExtended, pConfigBase) => {
+export default function mergeConfigs(pConfigExtended, pConfigBase) {
 	const lForbidden = mergeRules(
 		pConfigExtended?.forbidden ?? [],
 		pConfigBase?.forbidden ?? [],
@@ -133,4 +133,4 @@ export default (pConfigExtended, pConfigBase) => {
 			pConfigBase?.options ?? {},
 		),
 	};
-};
+}

package/src/extract/acorn/parse.mjs

@@ -2,7 +2,6 @@ import { readFileSync } from "node:fs";
 import { Parser as acornParser, parse as acornParse } from "acorn";
 import { parse as acornLooseParse } from "acorn-loose";
 import acornJsx from "acorn-jsx";
-import memoize, { memoizeClear } from "memoize";
 import transpile from "../transpile/index.mjs";
 import getExtension from "#utl/get-extension.mjs";
 
@@ -11,10 +10,12 @@ const ACORN_OPTIONS = {
 	sourceType: "module",
 	ecmaVersion: 11,
 };
-
 const TSCONFIG_CONSTANTS = {
 	PRESERVE_JSX: 1,
 };
+/**@type {Map<string, acorn.Node>} */
+const CACHE = new Map();
+
 const acornJsxParser = acornParser.extend(acornJsx());
 
 function needsJSXTreatment(pFileRecord, pTranspileOptions) {
@@ -57,13 +58,19 @@ export function getASTFromSource(pFileRecord, pTranspileOptions) {
  *
  * If parsing fails we fall back to acorn's 'loose' parser
  *
- * @param {string} pFileName      path to the file to be parsed
- * @param {any} pTranspileOptions options for the transpiler(s) - a tsconfig or
- *                                a babel config
- * @returns {acorn.Node}              the abstract syntax tree
+ * Subsequent calls for the same file name will return the result from a cache.
+ *
+ * @param {string} pFileName - the name of the file to compile
+ * @param {any} pTranspileOptions - options for the transpiler(s) - typically a tsconfig or a babel config
+ * @return {acorn.Node} - a (javascript) AST
  */
-function getAST(pFileName, pTranspileOptions) {
-	return getASTFromSource(
+export function getASTCached(pFileName, pTranspileOptions) {
+	// taking the transpile options into account of the cache key seems like
+	// a good idea, but a.t.m. isn't necessary. Easy to add later if needed.
+	if (CACHE.has(pFileName)) {
+		return CACHE.get(pFileName);
+	}
+	const lAST = getASTFromSource(
 		{
 			source: readFileSync(pFileName, "utf8"),
 			extension: getExtension(pFileName),
@@ -71,24 +78,10 @@ function getAST(pFileName, pTranspileOptions) {
 		},
 		pTranspileOptions,
 	);
+	CACHE.set(pFileName, lAST);
+	return lAST;
 }
 
-/**
- * Compiles the file identified by pFileName into a (javascript)
- * AST and returns it. Subsequent calls for the same file name will
- * return the result from a cache.
- *
- * @param {string} pFileName - the name of the file to compile
- * @param {any} pTranspileOptions - options for the transpiler(s) - typically a tsconfig or a babel config
- * @return {acorn.Node} - a (javascript) AST
- */
-// taking the transpile options into account of the memoize cache key seems like
-// a good idea. However, previously we use `${pTranspileOptions}` which always
-// serializes to [object Object], which doesn't help. So for now we're not
-// taking the transpile options into account. If we ever need to, it'll be
-// a JSON.stringify away (which _will_ be significantly slower)
-export const getASTCached = memoize(getAST);
-
 export function clearCache() {
-	memoizeClear(getASTCached);
+	CACHE.clear();
 }

package/src/extract/resolve/external-module-helpers.mjs

@@ -1,9 +1,10 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import memoize, { memoizeClear } from "memoize";
 import { resolve } from "./resolve.mjs";
 import { isScoped, isRelativeModuleName } from "./module-classifiers.mjs";
 
+const PACKAGE_JSON_CACHE = new Map();
+
 /**
  * Returns the 'root' of the package - the spot where we can probably find
  * the package.json of that package, and the reference we'd usualy have
@@ -72,7 +73,11 @@ export function getPackageRoot(pModule) {
  *                           null if either module or package.json could
  *                           not be found
  */
-function bareGetPackageJson(pModuleName, pFileDirectory, pResolveOptions) {
+export function getPackageJson(pModuleName, pFileDirectory, pResolveOptions) {
+	const lCacheKey = `${pModuleName}|${pFileDirectory}`;
+	if (PACKAGE_JSON_CACHE.has(lCacheKey)) {
+		return PACKAGE_JSON_CACHE.get(lCacheKey);
+	}
 	let lReturnValue = null;
 
 	try {
@@ -102,13 +107,10 @@ function bareGetPackageJson(pModuleName, pFileDirectory, pResolveOptions) {
 	} catch (pError) {
 		// left empty on purpose
 	}
+	PACKAGE_JSON_CACHE.set(lCacheKey, lReturnValue);
 	return lReturnValue;
 }
 
-export const getPackageJson = memoize(bareGetPackageJson, {
-	cacheKey: (pArguments) => `${pArguments[0]}|${pArguments[1]}`,
-});
-
 /**
  * Tells whether the pModule as resolved to pBaseDirectory is deprecated
  *
@@ -164,5 +166,5 @@ export function getLicense(pModuleName, pFileDirectory, pResolveOptions) {
 }
 
 export function clearCache() {
-	memoizeClear(getPackageJson);
+	PACKAGE_JSON_CACHE.clear();
 }

package/src/extract/resolve/get-manifest.mjs

@@ -1,8 +1,10 @@
 import { join, dirname, sep } from "node:path";
 import { readFileSync } from "node:fs";
-import memoize, { memoizeClear } from "memoize";
 import mergePackages from "./merge-manifests.mjs";
 
+const SINGLE_MANIFEST_CACHE = new Map();
+const COMBINED_MANIFEST_CACHE = new Map();
+
 /**
  * return the contents of the package manifest ('package.json' closest to
  * the passed folder (or null if there's no such package.json/ that
@@ -16,7 +18,11 @@ import mergePackages from "./merge-manifests.mjs";
  *               object or null if the package.json could not be
  *               found or is invalid
  */
-const getSingleManifest = memoize((pFileDirectory) => {
+function getSingleManifest(pFileDirectory) {
+	if (SINGLE_MANIFEST_CACHE.has(pFileDirectory)) {
+		return SINGLE_MANIFEST_CACHE.get(pFileDirectory);
+	}
+
 	let lReturnValue = null;
 
 	try {
@@ -39,8 +45,9 @@ const getSingleManifest = memoize((pFileDirectory) => {
 			lReturnValue = getSingleManifest(lNextDirectory);
 		}
 	}
+	SINGLE_MANIFEST_CACHE.set(pFileDirectory, lReturnValue);
 	return lReturnValue;
-});
+}
 
 function maybeReadPackage(pFileDirectory) {
 	let lReturnValue = {};
@@ -80,11 +87,7 @@ function getIntermediatePaths(pFileDirectory, pBaseDirectory) {
 	return lReturnValue;
 }
 
-// despite the two parameters there's no resolver function provided
-// to memoize. This is deliberate - the pBaseDirectory will typically
-// be the same for each call in a typical cruise, so the default
-// memoize resolver (the first param) will suffice.
-const getCombinedManifests = memoize((pFileDirectory, pBaseDirectory) => {
+function getCombinedManifests(pFileDirectory, pBaseDirectory) {
 	// The way this is called, this shouldn't happen. If it is, there's
 	// something gone terribly awry
 	if (
@@ -97,8 +100,14 @@ const getCombinedManifests = memoize((pFileDirectory, pBaseDirectory) => {
 				`&title=Unexpected Error: Unusual baseDir passed to package reading function: '${pBaseDirectory}'`,
 		);
 	}
+	// despite the two parameters this function has, we only use the pFileDirectory
+	// parameter as cache key. This is deliberate as the pBaseDirectory will
+	// be the same for each call in a typical cruise.
+	if (COMBINED_MANIFEST_CACHE.has(pFileDirectory)) {
+		return COMBINED_MANIFEST_CACHE.get(pFileDirectory);
+	}
 
-	const lReturnValue = getIntermediatePaths(
+	const lMergedPackages = getIntermediatePaths(
 		pFileDirectory,
 		pBaseDirectory,
 	).reduce(
@@ -106,8 +115,11 @@ const getCombinedManifests = memoize((pFileDirectory, pBaseDirectory) => {
 		{},
 	);
 
-	return Object.keys(lReturnValue).length > 0 ? lReturnValue : null;
-});
+	const lReturnValue =
+		Object.keys(lMergedPackages).length > 0 ? lMergedPackages : null;
+	COMBINED_MANIFEST_CACHE.set(pFileDirectory, lReturnValue);
+	return lReturnValue;
+}
 
 /**
  * return
@@ -138,6 +150,6 @@ export function getManifest(
 }
 
 export function clearCache() {
-	memoizeClear(getCombinedManifests);
-	memoizeClear(getSingleManifest);
+	SINGLE_MANIFEST_CACHE.clear();
+	COMBINED_MANIFEST_CACHE.clear();
 }

package/src/extract/resolve/resolve-amd.mjs

@@ -1,18 +1,23 @@
 import { accessSync, constants } from "node:fs";
 import { relative, join } from "node:path";
-import memoize, { memoizeClear } from "memoize";
 import { isBuiltin } from "./is-built-in.mjs";
 import pathToPosix from "#utl/path-to-posix.mjs";
 
-const fileExists = memoize((pFile) => {
+const FILE_EXISTENCE_CACHE = new Map();
+const fileExists = (pFile) => {
+	if (FILE_EXISTENCE_CACHE.has(pFile)) {
+		return FILE_EXISTENCE_CACHE.get(pFile);
+	}
+
 	try {
 		accessSync(pFile, constants.R_OK);
 	} catch (pError) {
+		FILE_EXISTENCE_CACHE.set(pFile, false);
 		return false;
 	}
-
+	FILE_EXISTENCE_CACHE.set(pFile, true);
 	return true;
-});
+};
 
 function guessPath(pBaseDirectory, pFileDirectory, pStrippedModuleName) {
 	return pathToPosix(
@@ -63,5 +68,5 @@ export function resolveAMD(
 }
 
 export function clearCache() {
-	memoizeClear(fileExists);
+	FILE_EXISTENCE_CACHE.clear();
 }

package/src/extract/resolve/resolve.mjs

@@ -6,8 +6,8 @@ import pathToPosix from "#utl/path-to-posix.mjs";
 
 /** @type {Map<string, enhancedResolve.Resolver>} */
 let gResolvers = new Map();
-/** @type {Map<string, boolean>} */
-let gInitialized = new Map();
+/** @type {Set<string>} */
+let gInitialized = new Set();
 
 /**
  * Initializes a resolver for the given caching context if not already done
@@ -18,15 +18,14 @@ let gInitialized = new Map();
  * @returns {void}
  */
 function init(pEHResolveOptions, pCachingContext) {
-	if (!gInitialized.get(pCachingContext) || pEHResolveOptions.bustTheCache) {
+	if (!gInitialized.has(pCachingContext) || pEHResolveOptions.bustTheCache) {
 		// assuming the cached file system here
 		pEHResolveOptions.fileSystem.purge();
 		gResolvers.set(
 			pCachingContext,
 			enhancedResolve.ResolverFactory.createResolver(pEHResolveOptions),
 		);
-		/* eslint security/detect-object-injection:0 */
-		gInitialized.set(pCachingContext, true);
+		gInitialized.add(pCachingContext);
 	}
 }
 

package/src/extract/swc/parse.mjs

@@ -1,4 +1,3 @@
-import memoize, { memoizeClear } from "memoize";
 import tryImport from "#utl/try-import.mjs";
 import meta from "#meta.cjs";
 
@@ -20,16 +19,13 @@ const SWC_PARSE_OPTIONS = {
 	decorators: true,
 	// TODO: {tj}sx ?
 };
+/** @type {Map<string, ModuleItem[]>} */
+const CACHE = new Map();
 
 export function getASTFromSource(pSource) {
 	return swc.parseSync(pSource, SWC_PARSE_OPTIONS);
 }
 
-function getAST(pFileName) {
-	/** @type {swcCore swc} */
-	return swc.parseFileSync(pFileName, SWC_PARSE_OPTIONS);
-}
-
 /**
  * Compiles the file identified by pFileName into an (swc)
  * AST and returns it. Subsequent calls for the same file name will
@@ -38,10 +34,18 @@ function getAST(pFileName) {
  * @param {string} pFileName - the name of the file to compile
  * @return {ModuleItem[]} - an (swc) AST
  */
-export const getASTCached = memoize(getAST);
+export function getASTCached(pFileName) {
+	if (CACHE.has(pFileName)) {
+		return CACHE.get(pFileName);
+	}
+	/** @type {swcCore} */
+	const lAST = swc.parseFileSync(pFileName, SWC_PARSE_OPTIONS);
+	CACHE.set(pFileName, lAST);
+	return lAST;
+}
 
 export function clearCache() {
-	memoizeClear(getASTCached);
+	CACHE.clear();
 }
 
 /**

package/src/extract/tsc/parse.mjs

@@ -1,5 +1,4 @@
 import { readFileSync } from "node:fs";
-import memoize, { memoizeClear } from "memoize";
 import transpile from "../transpile/index.mjs";
 import tryImport from "#utl/try-import.mjs";
 import meta from "#meta.cjs";
@@ -10,6 +9,8 @@ const typescript = await tryImport(
 	"typescript",
 	meta.supportedTranspilers.typescript,
 );
+/** @type {Map<string, any>} */
+const CACHE = new Map();
 
 /**
  * Compiles pTypescriptSource into a (typescript) AST
@@ -35,15 +36,19 @@ export function getASTFromSource(pFileRecord, pTranspileOptions) {
 
 /**
  * Compiles the file identified by pFileName into a (typescript)
- * AST and returns it
+ * AST and returns it. Subsequent calls for the same file name will
+ * return the result from a cache
  *
  * @param {string} pFileName - the name of the file to compile
  * @param {any} [pTranspileOptions] options for the transpiler(s) - a tsconfig or
  *                                a babel config
  * @return {object} - a (typescript) AST
  */
-function getAST(pFileName, pTranspileOptions) {
-	return getASTFromSource(
+export function getASTCached(pFileName, pTranspileOptions) {
+	if (CACHE.has(pFileName)) {
+		return CACHE.get(pFileName);
+	}
+	const lAST = getASTFromSource(
 		{
 			source: readFileSync(pFileName, "utf8"),
 			extension: getExtension(pFileName),
@@ -51,18 +56,10 @@ function getAST(pFileName, pTranspileOptions) {
 		},
 		pTranspileOptions,
 	);
+	CACHE.set(pFileName, lAST);
+	return lAST;
 }
 
-/**
- * Compiles the file identified by pFileName into a (typescript)
- * AST and returns it. Subsequent calls for the same file name will
- * return the result from a cache
- *
- * @param {string} pFileName - the name of the file to compile
- * @return {object} - a (typescript) AST
- */
-export const getASTCached = memoize(getAST);
-
 /**
  * @return {boolean} - true if the typescript compiler is available,
  *                     false in all other cases
@@ -70,5 +67,5 @@ export const getASTCached = memoize(getAST);
 export const isAvailable = () => typescript !== false;
 
 export function clearCache() {
-	memoizeClear(getASTCached);
+	CACHE.clear();
 }

package/src/main/cruise.mjs

@@ -11,7 +11,7 @@ export function c(pComplete, pTotal = TOTAL_STEPS) {
 	return { complete: pComplete / pTotal };
 }
 
-/** @type {import("../../types/dependency-cruiser.js").cruise} */
+/** @type {import("../../types/dependency-cruiser.mjs").cruise} */
 // eslint-disable-next-line max-lines-per-function, max-statements
 export default async function cruise(
 	pFileAndDirectoryArray,
@@ -21,7 +21,7 @@ export default async function cruise(
 ) {
 	bus.summary("startup: parse options", c(1));
 	const lCruiseOptionsValid = assertCruiseOptionsValid(pCruiseOptions);
-	/** @type {import("../../types/strict-options.js").IStrictCruiseOptions} */
+	/** @type {import("../../types/strict-options.mjs").IStrictCruiseOptions} */
 	let lCruiseOptions = normalizeCruiseOptions(
 		lCruiseOptionsValid,
 		pFileAndDirectoryArray,
@@ -42,7 +42,7 @@ export default async function cruise(
 		const lCachedResults = await lCache.read(lCruiseOptions.cache.folder);
 
 		if (await lCache.canServeFromCache(lCruiseOptions, lCachedResults)) {
-			bus.summary("cache: report from cache", c(8));
+			bus.summary("report: from cache", c(8));
 			return await reportWrap(lCachedResults, lCruiseOptions);
 		}
 	}
@@ -54,7 +54,7 @@ export default async function cruise(
 		{ default: normalizeFilesAndDirectories },
 		{ default: normalizeResolveOptions },
 		{ default: extract },
-		{ default: enrich },
+		{ default: analyze },
 	] = await Promise.all([
 		// despite rule set parsing being behind an if, it's the 'normal' use case
 		// for dependency-cruiser, so import it unconditionally nonetheless
@@ -63,7 +63,7 @@ export default async function cruise(
 		import("./files-and-dirs/normalize.mjs"),
 		import("./resolve-options/normalize.mjs"),
 		import("#extract/index.mjs"),
-		import("#enrich/index.mjs"),
+		import("#analyze/index.mjs"),
 	]);
 
 	if (lCruiseOptions.ruleSet) {
@@ -93,7 +93,7 @@ export default async function cruise(
 	);
 
 	bus.summary("analyze", c(7));
-	const lCruiseResult = enrich(
+	const lCruiseResult = analyze(
 		lExtractionResult,
 		lCruiseOptions,
 		lNormalizedFileAndDirectoryArray,

package/src/main/report-wrap.mjs

@@ -1,5 +1,5 @@
 import { getReporter } from "#report/index.mjs";
-import summarize from "#enrich/summarize/index.mjs";
+import summarize from "#analyze/summarize/index.mjs";
 import { applyFilters } from "#graph-utl/filter-bank.mjs";
 import consolidateToPattern from "#graph-utl/consolidate-to-pattern.mjs";
 import { compareModules } from "#graph-utl/compare.mjs";

package/src/meta.cjs

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

package/src/report/anon/anonymize-path-element.mjs

@@ -1,11 +1,19 @@
-import memoize, { memoizeClear } from "memoize";
 import randomString from "./random-string.mjs";
 
+const ALREADY_USED_WORDS = new Map();
+
 function replace(pElement, pIndex, pWordList) {
 	return pIndex === 0 ? pWordList.shift() || randomString(pElement) : pElement;
 }
 
-const replaceCached = memoize(replace);
+function replaceCached(pElement, pIndex, pWordList) {
+	if (ALREADY_USED_WORDS.has(pElement)) {
+		return ALREADY_USED_WORDS.get(pElement);
+	}
+	const lReplaced = replace(pElement, pIndex, pWordList);
+	ALREADY_USED_WORDS.set(pElement, lReplaced);
+	return lReplaced;
+}
 
 function replaceFromWordList(pPathElement, pWordList, pCached) {
 	return pPathElement
@@ -49,5 +57,5 @@ export function anonymizePathElement(
  * @returns {void}
  */
 export function clearCache() {
-	memoizeClear(replaceCached);
+	ALREADY_USED_WORDS.clear();
 }

package/src/report/dot/prepare-flat-level.mjs

@@ -1,9 +1,19 @@
 import { flatLabel, extractFirstTransgression, addURL } from "./module-utl.mjs";
 import { applyTheme } from "./theming.mjs";
 import { compareModules } from "#graph-utl/compare.mjs";
+import consolidateToPattern from "#graph-utl/consolidate-to-pattern.mjs";
 
-export default function prepareFlatLevel(pResults, pTheme, _, pShowMetrics) {
-	return pResults.modules
+export default function prepareFlatLevel(
+	pResults,
+	pTheme,
+	pCollapsePattern,
+	pShowMetrics,
+) {
+	return (
+		pCollapsePattern
+			? consolidateToPattern(pResults.modules, pCollapsePattern)
+			: pResults.modules
+	)
 		.sort(compareModules)
 		.map(flatLabel(pShowMetrics))
 		.map(extractFirstTransgression)

package/src/report/plugins.mjs

@@ -1,6 +1,6 @@
 export function isValidPlugin(pPluginFunction) {
 	let lReturnValue = false;
-	/** @type {import('../../types/dependency-cruiser').ICruiseResult} */
+	/** @type {import('../../types/dependency-cruiser.mjs').ICruiseResult} */
 	const lMinimalCruiseResult = {
 		modules: [],
 		summary: {