dependency-cruiser 17.3.4 → 17.3.5

package/package.json

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

package/src/cache/cache.mjs

@@ -87,7 +87,7 @@ export default class Cache {
 				},
 			));
 		this.#revisionData.cacheFormatVersion = CACHE_FORMAT_VERSION;
-		bus.debug("cache: - compare");
+		bus.debug("cache: compare");
 		return (
 			this.cacheFormatVersionCompatible(pCachedCruiseResult) &&
 			this.#cacheStrategy.revisionDataEqual(

package/src/cache/find-content-changes.mjs

@@ -83,7 +83,7 @@ export default function findContentChanges(
 	pCachedCruiseResult,
 	pOptions,
 ) {
-	bus.debug("cache: - get revision data");
+	bus.debug("cache: content: get revision data");
 	const lFileSet = new Set(
 		findAllFiles(pDirectory, {
 			baseDir: pOptions.baseDir,
@@ -92,12 +92,12 @@ export default function findContentChanges(
 		}).filter(hasInterestingExtension(pOptions.extensions)),
 	);
 
-	bus.debug("cache: - get (cached - new)");
+	bus.debug("cache: content: get (cached - new)");
 	const lDiffCachedVsNew = pCachedCruiseResult.modules.map(
 		diffCachedModuleAgainstFileSet(lFileSet, pOptions.baseDir),
 	);
 
-	bus.debug("cache: - get (new - cached)");
+	bus.debug("cache: content: get (new - cached)");
 	// eslint-disable-next-line budapestian/local-variable-pattern
 	for (const { name } of lDiffCachedVsNew) {
 		lFileSet.delete(name);
@@ -112,6 +112,6 @@ export default function findContentChanges(
 		});
 	}
 
-	bus.debug("cache: - return revision data");
+	bus.debug("cache: content: return revision data");
 	return lDiffCachedVsNew.concat(lDiffNewVsCached);
 }

package/src/cache/metadata-strategy.mjs

@@ -21,6 +21,7 @@ export default class MetaDataStrategy {
 	/**
 	 * @param {string} _pDirectory
 	 * @param {ICruiseResult} _pCachedCruiseResult
+	 * @param {IStrictCruiseOptions} pCruiseOptions
 	 * @param {Object} pOptions
 	 * @param {Set<string>} pOptions.extensions
 	 * @param {Set<changeType>=} pOptions.interestingChangeTypes
@@ -42,9 +43,9 @@ export default class MetaDataStrategy {
 			...pOptions,
 		};
 		try {
-			bus.debug("cache: - get sha");
+			bus.debug("cache: metadata: get sha");
 			const lSHA = await lOptions.shaRetrievalFn();
-			bus.debug("cache: - get diff");
+			bus.debug("cache: metadata: get diff");
 			const lDiff = /** @type {IChange[]} */ (
 				await lOptions.diffListFn({ oldRevision: lSHA })
 			);
@@ -55,7 +56,7 @@ export default class MetaDataStrategy {
 				)
 				.filter(changeHasInterestingExtension(lOptions.extensions))
 				.filter(isInterestingChangeType(lOptions.interestingChangeTypes));
-			bus.debug("cache: - sha-sum diff");
+			bus.debug("cache: metadata: sha-sum diff");
 			return {
 				SHA1: lSHA,
 				changes: lChanges.map(lOptions.checksumFn),

package/src/cli/listeners/ndjson.mjs

@@ -76,7 +76,7 @@ export default function setUpNDJSONListener(
 ) {
 	let lState = {
 		runStartTime: new Date(Date.now()).toISOString(),
-		previousMessage: "nodejs starting",
+		previousMessage: "startup: nodejs loading",
 		previousTime: 0,
 		previousUserUsage: 0,
 		previousSystemUsage: 0,

package/src/cli/listeners/performance-log/format-helpers.mjs

@@ -1,5 +1,5 @@
 import { styleText } from "node:util";
-import { INFO } from "#utl/bus.mjs";
+import { INFO, SUMMARY } from "#utl/bus.mjs";
 
 const MS_PER_SECOND = 1000;
 const MS_PER_MICRO_SECOND = 0.001;
@@ -64,7 +64,7 @@ function formatMessage(pMessage, pLevel) {
 export function formatTime(
 	pNumber,
 	pConversionMultiplier = MS_PER_SECOND,
-	pLevel = INFO,
+	pLevel = SUMMARY,
 ) {
 	return formatMessage(
 		gTimeFormat(pConversionMultiplier * pNumber)

package/src/cli/listeners/performance-log/handlers.mjs

@@ -50,7 +50,7 @@ export function getEndText(pState, pLevel, pMaxLevel) {
 		const lTime = process.uptime();
 		const { user, system } = process.cpuUsage();
 		const { heapUsed, heapTotal, external, rss } = process.memoryUsage();
-		pState.previousMessage = "really done";
+		pState.previousMessage = "end: really done";
 
 		return (
 			getProgressLine("", pState, pLevel, pMaxLevel) +

package/src/cli/listeners/performance-log/index.mjs

@@ -35,7 +35,7 @@ export default function setUpPerformanceLogListener(
 	pStream = process.stderr,
 ) {
 	let lState = {
-		previousMessage: "nodejs starting",
+		previousMessage: "startup: nodejs loading",
 		previousTime: 0,
 		previousUserUsage: 0,
 		previousSystemUsage: 0,

package/src/enrich/derive/circular.mjs

@@ -1,4 +1,5 @@
 /* eslint-disable security/detect-object-injection */
+import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
 
 /** @import { IFlattenedRuleSet } from "../../../types/rule-set.mjs" */
 
@@ -44,29 +45,33 @@ function addCircularityCheckToDependency(
 }
 
 /**
- * Runs through all dependencies of all pNodes, for each of them determines
+ * Runs through all dependencies of all pModulesOrFolders, for each of them determines
  * whether it's (part of a) circular (relationship) and returns the
  * dependencies with that added.
  */
 export default function detectAndAddCycles(
-	pNodes,
-	pIndexedNodes,
+	pModulesOrFolders,
 	{ pSourceAttribute, pDependencyName, pSkipAnalysisNotInRules, pRuleSet },
 ) {
 	if (!pSkipAnalysisNotInRules || hasCycleRule(pRuleSet)) {
-		return pNodes.map((pModule) => ({
-			...pModule,
-			dependencies: pModule.dependencies.map((pToDep) =>
+		const lIndexedGraph = new IndexedModuleGraph(
+			pModulesOrFolders,
+			pSourceAttribute,
+		);
+
+		return pModulesOrFolders.map((pModuleOrFolder) => ({
+			...pModuleOrFolder,
+			dependencies: pModuleOrFolder.dependencies.map((pToDep) =>
 				addCircularityCheckToDependency(
-					pIndexedNodes,
-					pModule[pSourceAttribute],
+					lIndexedGraph,
+					pModuleOrFolder[pSourceAttribute],
 					pToDep,
 					pDependencyName,
 				),
 			),
 		}));
 	}
-	return pNodes.map((pModule) => ({
+	return pModulesOrFolders.map((pModule) => ({
 		...pModule,
 		dependencies: pModule.dependencies.map((pToDep) => ({
 			...pToDep,

package/src/enrich/derive/dependents.mjs

@@ -1,13 +1,14 @@
-import { isDependent } from "./module-utl.mjs";
-
 /** @import { IFlattenedRuleSet } from "../../../types/rule-set.mjs" */
 
+import ModuleGraphWithDependencySet from "#graph-utl/module-graph-with-dependency-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
+	// the 'metrics' flag in options, so not going to repeat that here
 
-	// 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.
+	// dependents are used in the orphans analysis. However, there is a fall back
+	// where it does its own analysis which is faster on itself, so not going
+	// to repeat that check here either.
 	return (
 		/* c8 ignore start */
 		Object.hasOwn(pRule?.module ?? {}, "numberOfDependentsLessThan") ||
@@ -16,13 +17,6 @@ function isDependentsRule(pRule) {
 	);
 }
 
-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);
-}
-
 /**
  * @param {IFlattenedRuleSet} pRuleSet
  * @returns {boolean}
@@ -39,9 +33,17 @@ export default function addDependents(
 	{ skipAnalysisNotInRules, metrics, ruleSet },
 ) {
 	if (!skipAnalysisNotInRules || metrics || hasDependentsRule(ruleSet)) {
+		// creating this optimized structure here might seem overkill, but on
+		// large graphs it pays off significantly - creation is a few centiseconds
+		// but it cuts analysis in half on large graphs (and even on smaller
+		// graphs it's a win, even though just a few milliseconds)
+		const lModulesWithDependencySet = new ModuleGraphWithDependencySet(
+			pModules,
+		);
+
 		return pModules.map((pModule) => ({
 			...pModule,
-			dependents: getDependents(pModule, pModules),
+			dependents: lModulesWithDependencySet.getDependents(pModule),
 		}));
 	}
 	return pModules;

package/src/enrich/derive/folders/aggregate-to-folders.mjs

@@ -9,7 +9,6 @@ import {
 	getParentFolders,
 	object2Array,
 } from "./utl.mjs";
-import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
 import { uniq } from "#utl/array-util.mjs";
 
 function upsertCouplings(pAllDependents, pNewDependents) {
@@ -148,7 +147,7 @@ export default function aggregateToFolders(pModules, pOptions = {}) {
 		.map(deNormalizeInstability);
 	lFolders = lFolders.concat(getSinks(lFolders));
 
-	return detectCycles(lFolders, new IndexedModuleGraph(lFolders, "name"), {
+	return detectCycles(lFolders, {
 		pSourceAttribute: "name",
 		pDependencyName: "name",
 		pSkipAnalysisNotInRules: pOptions.skipAnalysisNotInRules,

package/src/enrich/derive/metrics/get-module-metrics.mjs

@@ -1,5 +1,4 @@
 import { calculateInstability, metricsAreCalculable } from "../module-utl.mjs";
-import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
 
 export function addInstabilityMetric(pModule) {
 	return {
@@ -15,25 +14,23 @@ export function addInstabilityMetric(pModule) {
 	};
 }
 
-function addInstabilityToDependency(pAllModules) {
-	const lIndexedModules = new IndexedModuleGraph(pAllModules);
+function addInstabilityToDependency(pIndexedModules) {
 	return (pDependency) => ({
 		...pDependency,
 		instability:
-			(lIndexedModules.findVertexByName(pDependency.resolved) || {})
+			(pIndexedModules.findVertexByName(pDependency.resolved) || {})
 				.instability || 0,
 	});
 }
 
 export function deNormalizeInstabilityMetricsToDependencies(
 	pModule,
-	_,
-	pAllModules,
+	pIndexedModules,
 ) {
 	return {
 		...pModule,
 		dependencies: pModule.dependencies.map(
-			addInstabilityToDependency(pAllModules),
+			addInstabilityToDependency(pIndexedModules),
 		),
 	};
 }

package/src/enrich/derive/metrics/index.mjs

@@ -2,12 +2,16 @@ import {
 	addInstabilityMetric,
 	deNormalizeInstabilityMetricsToDependencies,
 } from "./get-module-metrics.mjs";
+import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
 
 export default function deriveModulesMetrics(pModules, pOptions) {
 	if (pOptions.metrics) {
-		return pModules
-			.map(addInstabilityMetric)
-			.map(deNormalizeInstabilityMetricsToDependencies);
+		const lModules = pModules.map(addInstabilityMetric);
+		const lIndexedModules = new IndexedModuleGraph(lModules);
+
+		return lModules.map((pModule) =>
+			deNormalizeInstabilityMetricsToDependencies(pModule, lIndexedModules),
+		);
 	}
 	return pModules;
 }

package/src/enrich/derive/module-utl.mjs

@@ -1,10 +1,3 @@
-export function isDependent(pResolvedName) {
-	return (pModule) =>
-		pModule.dependencies.some(
-			(pDependency) => pDependency.resolved === pResolvedName,
-		);
-}
-
 export function metricsAreCalculable(pModule) {
 	return (
 		!pModule.coreModule &&

package/src/enrich/derive/orphan/index.mjs

@@ -1,4 +1,5 @@
 import isOrphan from "./is-orphan.mjs";
+import ModuleGraphWithDependencySet from "#graph-utl/module-graph-with-dependency-set.mjs";
 
 /** @import { IFlattenedRuleSet } from "../../../../types/rule-set.mjs" */
 
@@ -25,9 +26,19 @@ export default function deriveOrphans(
 	{ skipAnalysisNotInRules, ruleSet },
 ) {
 	if (!skipAnalysisNotInRules || hasOrphanRule(ruleSet)) {
+		// just like the dependents derivation, creating this data structure
+		// might seem overkill, but it can save effort here as well, even though
+		// isOrphan has early exits the dependents derivation doesn't:
+		// - when the module already has dependencies (quick length check)
+		// - when dependents are already calculated (quick length check as well). If
+		//   they are, the lModulesWithDependencySet is created for naught.
+		const lModulesWithDependencySet = new ModuleGraphWithDependencySet(
+			pModules,
+		);
+
 		return pModules.map((pModule) => ({
 			...pModule,
-			orphan: isOrphan(pModule, pModules),
+			orphan: isOrphan(pModule, lModulesWithDependencySet),
 		}));
 	}
 	return pModules;

package/src/enrich/derive/orphan/is-orphan.mjs

@@ -1,6 +1,11 @@
-import { isDependent } from "../module-utl.mjs";
-
-export default function isOrphan(pModule, pGraph) {
+/**
+ * returns true if the given module has no dependencies and no dependents
+ *
+ * @param {import("../../../../types/dependency-cruiser.mjs").IModule} pModule
+ * @param {import("#graph-utl/module-graph-with-dependency-set.mjs").default} pModulesWithDependencySet
+ * @returns {boolean}
+ */
+export default function isOrphan(pModule, pModulesWithDependencySet) {
 	if (pModule.dependencies.length > 0) {
 		return false;
 	}
@@ -10,5 +15,5 @@ export default function isOrphan(pModule, pGraph) {
 		return pModule.dependents.length === 0;
 	}
 	// ... otherwise calculate them
-	return !pGraph.some(isDependent(pModule.source));
+	return !pModulesWithDependencySet.moduleHasDependents(pModule);
 }

package/src/enrich/enrich-modules.mjs

@@ -5,7 +5,6 @@ import deriveReachable from "./derive/reachable.mjs";
 import addValidations from "./add-validations.mjs";
 import softenKnownViolations from "./soften-known-violations.mjs";
 import deriveModuleMetrics from "./derive/metrics/index.mjs";
-import IndexedModuleGraph from "#graph-utl/indexed-module-graph.mjs";
 import addFocus from "#graph-utl/add-focus.mjs";
 import { bus } from "#utl/bus.mjs";
 
@@ -18,8 +17,8 @@ import { bus } from "#utl/bus.mjs";
  */
 export default function enrichModules(pModules, pOptions) {
 	bus.info("analyze: cycles");
-	const lIndexedModules = new IndexedModuleGraph(pModules);
-	let lModules = deriveCycles(pModules, lIndexedModules, {
+
+	let lModules = deriveCycles(pModules, {
 		pSourceAttribute: "source",
 		pDependencyName: "resolved",
 		pSkipAnalysisNotInRules: pOptions.skipAnalysisNotInRules,

package/src/extract/index.mjs

@@ -70,13 +70,13 @@ function extractFileDirectoryArray(
 ) {
 	let lVisited = new Set();
 
-	bus.info("read files: gather initial sources");
+	bus.debug("extract: gather initial sources");
 	const lInitialSources = gatherInitialSources(
 		pFileDirectoryArray,
 		pCruiseOptions,
 	);
 
-	bus.info("read files: visit dependencies");
+	bus.debug("extract: visit dependencies");
 	const lResult = [];
 	for (const lFilename of lInitialSources) {
 		if (!lVisited.has(lFilename)) {

package/src/extract/resolve/resolve.mjs

@@ -2,9 +2,21 @@ import enhancedResolve from "enhanced-resolve";
 import { stripQueryParameters } from "../helpers.mjs";
 import pathToPosix from "#utl/path-to-posix.mjs";
 
+/** @import {IResolveOptions} from "../../../types/resolve-options.mjs" */
+
+/** @type {Map<string, enhancedResolve.Resolver>} */
 let gResolvers = new Map();
+/** @type {Map<string, boolean>} */
 let gInitialized = new Map();
 
+/**
+ * Initializes a resolver for the given caching context if not already done
+ *
+ * @param {IResolveOptions} pEHResolveOptions Options to pass to enhanced resolve
+ * @param {string} pCachingContext - caching
+ *
+ * @returns {void}
+ */
 function init(pEHResolveOptions, pCachingContext) {
 	if (!gInitialized.get(pCachingContext) || pEHResolveOptions.bustTheCache) {
 		// assuming the cached file system here
@@ -23,8 +35,8 @@ function init(pEHResolveOptions, pCachingContext) {
  *
  * @param {string} pModuleName The module name to resolve (e.g. 'slodash', './myModule')
  * @param {string} pFileDirectory The directory from which to resolve the module
- * @param {any} pResolveOptions Options to pass to enhanced resolve
- * @param {any} pCachingContext - caching
+ * @param {IResolveOptions} pResolveOptions Options to pass to enhanced resolve
+ * @param {string} pCachingContext - caching
  *
  * @returns {string} path to the resolved file on disk
  */

package/src/graph-utl/module-graph-with-dependency-set.mjs

@@ -0,0 +1,41 @@
+export default class ModuleGraphWithDependencySet {
+	/** @type {Array<{source: string, dependencies: Set<string>}>} */
+	#modulesWithDependencySet;
+	/**
+	 * Creates a module graph optimized for querying dependents
+	 * @constructor
+	 * @param {import("../../types/dependency-cruiser.mjs").IModule[]} pModules
+	 */
+	constructor(pModules) {
+		this.#modulesWithDependencySet = pModules.map((pModule) => ({
+			source: pModule.source,
+			dependencies: new Set(
+				pModule.dependencies.map((pDependency) => pDependency.resolved),
+			),
+		}));
+	}
+
+	/**
+	 * Returns true if the given module has dependents in the graph, false otherwise
+	 *
+	 * @param {import("../../types/dependency-cruiser.mjs").IModule} pModule
+	 * @returns {boolean}
+	 */
+	moduleHasDependents(pModule) {
+		return this.#modulesWithDependencySet.some(({ dependencies }) =>
+			dependencies.has(pModule.source),
+		);
+	}
+
+	/**
+	 * Returns an array of module source paths that depend on the given module
+	 *
+	 * @param {import("../../types/dependency-cruiser.mjs").IModule} pModule
+	 * @returns {Array<string>}
+	 */
+	getDependents(pModule) {
+		return this.#modulesWithDependencySet
+			.filter(({ dependencies }) => dependencies.has(pModule.source))
+			.map(({ source }) => source);
+	}
+}

package/src/main/cruise.mjs

@@ -19,7 +19,7 @@ export default async function cruise(
 	pResolveOptions,
 	pTranspileOptions,
 ) {
-	bus.summary("parse options", c(1));
+	bus.summary("startup: parse options", c(1));
 	const lCruiseOptionsValid = assertCruiseOptionsValid(pCruiseOptions);
 	/** @type {import("../../types/strict-options.js").IStrictCruiseOptions} */
 	let lCruiseOptions = normalizeCruiseOptions(
@@ -47,7 +47,7 @@ export default async function cruise(
 		}
 	}
 
-	bus.summary("import analytical modules", c(3));
+	bus.summary("startup: import analytical modules", c(3));
 	const [
 		{ default: normalizeRuleSet },
 		{ default: assertRuleSetValid },
@@ -67,7 +67,7 @@ export default async function cruise(
 	]);
 
 	if (lCruiseOptions.ruleSet) {
-		bus.summary("parse rule set", c(4));
+		bus.summary("startup: parse rule set", c(4));
 		lCruiseOptions.ruleSet = normalizeRuleSet(
 			assertRuleSetValid(lCruiseOptions.ruleSet),
 		);
@@ -77,14 +77,14 @@ export default async function cruise(
 		pFileAndDirectoryArray,
 	);
 
-	bus.summary("determine how to resolve", c(5));
+	bus.summary("startup: get resolve options", c(5));
 	const lNormalizedResolveOptions = await normalizeResolveOptions(
 		pResolveOptions,
 		lCruiseOptions,
 		pTranspileOptions?.tsConfig,
 	);
 
-	bus.summary("read files", c(6));
+	bus.summary("extract", c(6));
 	const lExtractionResult = extract(
 		lNormalizedFileAndDirectoryArray,
 		lCruiseOptions,
@@ -107,7 +107,7 @@ export default async function cruise(
 	bus.summary("report", c(9));
 	const lResult = await reportWrap(lCruiseResult, lCruiseOptions);
 
-	bus.debug("clear regex cache");
+	bus.debug("end: clear regex cache");
 	clearRegExpCache();
 
 	return lResult;

package/src/main/report-wrap.mjs

@@ -4,6 +4,7 @@ import { applyFilters } from "#graph-utl/filter-bank.mjs";
 import consolidateToPattern from "#graph-utl/consolidate-to-pattern.mjs";
 import { compareModules } from "#graph-utl/compare.mjs";
 import stripSelfTransitions from "#graph-utl/strip-self-transitions.mjs";
+import { bus } from "#utl/bus.mjs";
 
 /**
  * @import { ICruiseResult } from "../../types/cruise-result.mjs";
@@ -54,12 +55,14 @@ function getReporterSection(pOutputType) {
  * @returns {IReporterOutput}
  */
 export default async function reportWrap(pResult, pFormatOptions) {
+	bus.debug("report: get");
 	const lReportFunction = await getReporter(pFormatOptions.outputType);
 	const lReportOptions =
 		pResult.summary.optionsUsed?.reporterOptions?.[
 			getReporterSection(pFormatOptions.outputType)
 		] ?? {};
 
+	bus.debug("report: execute");
 	return lReportFunction(
 		reSummarizeResults(pResult, pFormatOptions),
 		// passing format options here so reporters that read collapse patterns

package/src/main/rule-set/assert-validity.mjs

@@ -80,16 +80,16 @@ function assertRuleSafety(pRule) {
  * @throws {Error}          An error with the reason for the error as a message
  */
 export default function assertRuleSetValid(pConfiguration) {
-	bus.info("parse rule set: validate");
+	bus.debug("startup: parse rule set: validate");
 
-	bus.debug("parse rule set: validate: schema compliance");
+	bus.trace("startup: parse rule set: validate: schema");
 	assertSchemaCompliance(pConfiguration);
 
-	bus.debug("parse rule set: validate: rule safety");
+	bus.trace("startup: parse rule set: validate: rule safety");
 	(pConfiguration.allowed || []).forEach(assertRuleSafety);
 	(pConfiguration.forbidden || []).forEach(assertRuleSafety);
 
-	bus.debug("parse rule set: validate: cruise options validity");
+	bus.trace("startup: parse rule set: validate: options");
 	if (pConfiguration?.options) {
 		assertCruiseOptionsValid(pConfiguration.options);
 	}

package/src/main/rule-set/normalize.mjs

@@ -114,7 +114,7 @@ function normalizeRule(pRule) {
  * @return {IStrictRuleSet}
  */
 export default function normalizeRuleSet(pRuleSet) {
-	bus.info("parse rule set: normalize");
+	bus.debug("startup: parse rule set: normalize");
 	const lRuleSet = structuredClone(pRuleSet);
 
 	if (lRuleSet?.allowed) {

package/src/meta.cjs

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

package/src/utl/bus.mjs

@@ -24,6 +24,10 @@ class Bus extends EventEmitter {
 	debug(pMessage, pOptions, ...pArguments) {
 		this.progress(pMessage, { ...pOptions, level: DEBUG }, pArguments);
 	}
+
+	trace(pMessage, pOptions, ...pArguments) {
+		this.progress(pMessage, { ...pOptions, level: TRACE }, pArguments);
+	}
 }
 
 export const bus = new Bus();

package/types/resolve-options.d.mts

@@ -8,7 +8,6 @@ import type { ResolveOptions, CachedInputFileSystem } from "enhanced-resolve";
  */
 interface IResolveOptions extends ResolveOptions {
 	/**
-	 *
 	 * Without bustTheCache (or with the value `false`) the resolver
 	 * is initialized only once per session. If the attribute
 	 * equals `true` the resolver is initialized on each call