dependency-cruiser 17.3.2 → 17.3.3-beta-2

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

@@ -17,67 +17,67 @@ import mergePackages from "./merge-manifests.mjs";
  *               found or is invalid
  */
 const getSingleManifest = memoize((pFileDirectory) => {
-  let lReturnValue = null;
+	let lReturnValue = null;
 
-  try {
-    // find the closest package.json from pFileDirectory
-    const lPackageContent = readFileSync(
-      join(pFileDirectory, "package.json"),
-      "utf8",
-    );
+	try {
+		// find the closest package.json from pFileDirectory
+		const lPackageContent = readFileSync(
+			join(pFileDirectory, "package.json"),
+			"utf8",
+		);
 
-    try {
-      lReturnValue = JSON.parse(lPackageContent);
-    } catch (pError) {
-      // left empty on purpose
-    }
-  } catch (pError) {
-    const lNextDirectory = dirname(pFileDirectory);
+		try {
+			lReturnValue = JSON.parse(lPackageContent);
+		} catch (pError) {
+			// left empty on purpose
+		}
+	} catch (pError) {
+		const lNextDirectory = dirname(pFileDirectory);
 
-    if (lNextDirectory !== pFileDirectory) {
-      // not yet reached root directory
-      lReturnValue = getSingleManifest(lNextDirectory);
-    }
-  }
-  return lReturnValue;
+		if (lNextDirectory !== pFileDirectory) {
+			// not yet reached root directory
+			lReturnValue = getSingleManifest(lNextDirectory);
+		}
+	}
+	return lReturnValue;
 });
 
 function maybeReadPackage(pFileDirectory) {
-  let lReturnValue = {};
+	let lReturnValue = {};
 
-  try {
-    const lPackageContent = readFileSync(
-      join(pFileDirectory, "package.json"),
-      "utf8",
-    );
+	try {
+		const lPackageContent = readFileSync(
+			join(pFileDirectory, "package.json"),
+			"utf8",
+		);
 
-    try {
-      lReturnValue = JSON.parse(lPackageContent);
-    } catch (pError) {
-      // left empty on purpose
-    }
-  } catch (pError) {
-    // left empty on purpose
-  }
-  return lReturnValue;
+		try {
+			lReturnValue = JSON.parse(lPackageContent);
+		} catch (pError) {
+			// left empty on purpose
+		}
+	} catch (pError) {
+		// left empty on purpose
+	}
+	return lReturnValue;
 }
 
 function getIntermediatePaths(pFileDirectory, pBaseDirectory) {
-  let lReturnValue = [];
-  let lIntermediate = pFileDirectory;
+	let lReturnValue = [];
+	let lIntermediate = pFileDirectory;
 
-  while (
-    lIntermediate !== pBaseDirectory &&
-    // safety hatch in case pBaseDirectory is either not a part of
-    // pFileDirectory or not something uniquely comparable to a
-    // dirname
-    lIntermediate !== dirname(lIntermediate)
-  ) {
-    lReturnValue.push(lIntermediate);
-    lIntermediate = dirname(lIntermediate);
-  }
-  lReturnValue.push(pBaseDirectory);
-  return lReturnValue;
+	while (
+		lIntermediate !== pBaseDirectory &&
+		// safety hatch in case pBaseDirectory is either not a part of
+		// pFileDirectory or not something uniquely comparable to a
+		// dirname
+		lIntermediate !== dirname(lIntermediate)
+	) {
+		lReturnValue.push(lIntermediate);
+		lIntermediate = dirname(lIntermediate);
+	}
+	lReturnValue.push(pBaseDirectory);
+	return lReturnValue;
 }
 
 // despite the two parameters there's no resolver function provided
@@ -85,28 +85,28 @@ function getIntermediatePaths(pFileDirectory, pBaseDirectory) {
 // 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) => {
-  // The way this is called, this shouldn't happen. If it is, there's
-  // something gone terribly awry
-  if (
-    !pFileDirectory.startsWith(pBaseDirectory) ||
-    pBaseDirectory.endsWith(sep)
-  ) {
-    throw new Error(
-      `Unexpected Error: Unusual baseDir passed to package reading function: '${pBaseDirectory}'\n` +
-        `Please file a bug: https://github.com/sverweij/dependency-cruiser/issues/new?template=bug-report.md` +
-        `&title=Unexpected Error: Unusual baseDir passed to package reading function: '${pBaseDirectory}'`,
-    );
-  }
+	// The way this is called, this shouldn't happen. If it is, there's
+	// something gone terribly awry
+	if (
+		!pFileDirectory.startsWith(pBaseDirectory) ||
+		pBaseDirectory.endsWith(sep)
+	) {
+		throw new Error(
+			`Unexpected Error: Unusual baseDir passed to package reading function: '${pBaseDirectory}'\n` +
+				`Please file a bug: https://github.com/sverweij/dependency-cruiser/issues/new?template=bug-report.md` +
+				`&title=Unexpected Error: Unusual baseDir passed to package reading function: '${pBaseDirectory}'`,
+		);
+	}
 
-  const lReturnValue = getIntermediatePaths(
-    pFileDirectory,
-    pBaseDirectory,
-  ).reduce(
-    (pAll, pCurrent) => mergePackages(pAll, maybeReadPackage(pCurrent)),
-    {},
-  );
+	const lReturnValue = getIntermediatePaths(
+		pFileDirectory,
+		pBaseDirectory,
+	).reduce(
+		(pAll, pCurrent) => mergePackages(pAll, maybeReadPackage(pCurrent)),
+		{},
+	);
 
-  return Object.keys(lReturnValue).length > 0 ? lReturnValue : null;
+	return Object.keys(lReturnValue).length > 0 ? lReturnValue : null;
 });
 
 /**
@@ -126,18 +126,18 @@ const getCombinedManifests = memoize((pFileDirectory, pBaseDirectory) => {
  *                                        found or is invalid
  */
 export function getManifest(
-  pFileDirectory,
-  pBaseDirectory,
-  pCombinedDependencies = false,
+	pFileDirectory,
+	pBaseDirectory,
+	pCombinedDependencies = false,
 ) {
-  if (pCombinedDependencies) {
-    return getCombinedManifests(pFileDirectory, pBaseDirectory);
-  } else {
-    return getSingleManifest(pFileDirectory);
-  }
+	if (pCombinedDependencies) {
+		return getCombinedManifests(pFileDirectory, pBaseDirectory);
+	} else {
+		return getSingleManifest(pFileDirectory);
+	}
 }
 
 export function clearCache() {
-  memoizeClear(getCombinedManifests);
-  memoizeClear(getSingleManifest);
+	memoizeClear(getCombinedManifests);
+	memoizeClear(getSingleManifest);
 }

package/src/extract/resolve/index.mjs

@@ -14,6 +14,8 @@ import pathToPosix from "#utl/path-to-posix.mjs";
  * @import { IDependency } from "../../../types/cruise-result.mjs";
  */
 
+const COMMONJS_RESOLVABLE_MODULE_SYSTEMS = new Set(["cjs", "es6", "tsd"]);
+
 /**
  *
  * @param {IModule} pModule
@@ -23,138 +25,147 @@ import pathToPosix from "#utl/path-to-posix.mjs";
  * @returns {any}
  */
 function resolveModule(
-  pModule,
-  pBaseDirectory,
-  pFileDirectory,
-  pResolveOptions,
+	pModule,
+	pBaseDirectory,
+	pFileDirectory,
+	pResolveOptions,
 ) {
-  let lReturnValue = null;
-
-  const lStrippedModuleName = stripToModuleName(pModule.module);
-  if (
-    isRelativeModuleName(lStrippedModuleName) ||
-    ["cjs", "es6", "tsd"].includes(pModule.moduleSystem)
-  ) {
-    lReturnValue = resolveCommonJS(
-      lStrippedModuleName,
-      pBaseDirectory,
-      pFileDirectory,
-      pResolveOptions,
-    );
-  } else {
-    lReturnValue = resolveAMD(
-      lStrippedModuleName,
-      pBaseDirectory,
-      pFileDirectory,
-      pResolveOptions,
-    );
-  }
-  return lReturnValue;
+	let lReturnValue = null;
+
+	const lStrippedModuleName = stripToModuleName(pModule.module);
+	if (
+		isRelativeModuleName(lStrippedModuleName) ||
+		COMMONJS_RESOLVABLE_MODULE_SYSTEMS.has(pModule.moduleSystem)
+	) {
+		lReturnValue = resolveCommonJS(
+			lStrippedModuleName,
+			pBaseDirectory,
+			pFileDirectory,
+			pResolveOptions,
+		);
+	} else {
+		lReturnValue = resolveAMD(
+			lStrippedModuleName,
+			pBaseDirectory,
+			pFileDirectory,
+			pResolveOptions,
+		);
+	}
+	return lReturnValue;
 }
 
+const RESOLVABLE_TO_TS_VARIANT_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+]);
+
 function canBeResolvedToTsVariant(pModuleName) {
-  return [".js", ".jsx", ".mjs", ".cjs"].includes(extname(pModuleName));
+	return RESOLVABLE_TO_TS_VARIANT_EXTENSIONS.has(extname(pModuleName));
 }
 
+const TYPESCRIPT_ISH_EXTENSIONS = new Set([".ts", ".tsx", ".cts", ".mts"]);
+
 function isTypeScriptIshExtension(pModuleName) {
-  return [".ts", ".tsx", ".cts", ".mts"].includes(extname(pModuleName));
+	return TYPESCRIPT_ISH_EXTENSIONS.has(extname(pModuleName));
 }
 function resolveYarnVirtual(pBaseDirectory, pPath) {
-  const pnpAPI = (monkeyPatchedModule?.findPnpApi ?? (() => false))(pPath);
-
-  // the pnp api only works in plug'n play environments, and resolveVirtual
-  // only under yarn(berry). As we can't run a 'regular' nodejs environment
-  // and a yarn(berry) one at the same time, ignore in the test coverage and
-  // cover it in a separate integration test.
-  /* c8 ignore start */
-  if (pnpAPI && (pnpAPI?.VERSIONS?.resolveVirtual ?? 0) === 1) {
-    // resolveVirtual takes absolute paths, hence the path.resolve:
-    const lResolvedAbsolute = path_resolve(pBaseDirectory, pPath);
-    const lResolvedVirtual = pnpAPI.resolveVirtual(lResolvedAbsolute);
-    if (lResolvedVirtual) {
-      const lResolvedRelative = relative(pBaseDirectory, lResolvedVirtual);
-      // in win32 environments resolveVirtual might return win32 paths,
-      // so we have to convert them to posix paths again
-      return pathToPosix(lResolvedRelative);
-    }
-  }
-  /* c8 ignore stop */
-  return pPath;
+	const pnpAPI = (monkeyPatchedModule?.findPnpApi ?? (() => false))(pPath);
+
+	// the pnp api only works in plug'n play environments, and resolveVirtual
+	// only under yarn(berry). As we can't run a 'regular' nodejs environment
+	// and a yarn(berry) one at the same time, ignore in the test coverage and
+	// cover it in a separate integration test.
+	/* c8 ignore start */
+	if (pnpAPI && (pnpAPI?.VERSIONS?.resolveVirtual ?? 0) === 1) {
+		// resolveVirtual takes absolute paths, hence the path.resolve:
+		const lResolvedAbsolute = path_resolve(pBaseDirectory, pPath);
+		const lResolvedVirtual = pnpAPI.resolveVirtual(lResolvedAbsolute);
+		if (lResolvedVirtual) {
+			const lResolvedRelative = relative(pBaseDirectory, lResolvedVirtual);
+			// in win32 environments resolveVirtual might return win32 paths,
+			// so we have to convert them to posix paths again
+			return pathToPosix(lResolvedRelative);
+		}
+	}
+	/* c8 ignore stop */
+	return pPath;
 }
 
+const JS_TO_TS_MAP = new Map([
+	[".js", [".ts", ".tsx", ".d.ts"]],
+	[".jsx", [".ts", ".tsx", ".d.ts"]],
+	[".cjs", [".cts", ".d.cts"]],
+	[".mjs", [".mts", ".d.mts"]],
+]);
+
 /**
  *
  * @param {string} pJavaScriptExtension
- * @returns {string}
+ * @returns {string[]}
  */
 function getTypeScriptExtensionsToTry(pJavaScriptExtension) {
-  const lJS2TSMap = new Map([
-    [".js", [".ts", ".tsx", ".d.ts"]],
-    [".jsx", [".ts", ".tsx", ".d.ts"]],
-    [".cjs", [".cts", ".d.cts"]],
-    [".mjs", [".mts", ".d.mts"]],
-  ]);
-
-  return lJS2TSMap.get(pJavaScriptExtension) ?? [];
+	return JS_TO_TS_MAP.get(pJavaScriptExtension) ?? [];
 }
 
 // eslint-disable-next-line max-lines-per-function
 function resolveWithRetry(
-  pModule,
-  pBaseDirectory,
-  pFileDirectory,
-  pResolveOptions,
+	pModule,
+	pBaseDirectory,
+	pFileDirectory,
+	pResolveOptions,
 ) {
-  let lReturnValue = resolveModule(
-    pModule,
-    pBaseDirectory,
-    pFileDirectory,
-    pResolveOptions,
-  );
-  const lStrippedModuleName = stripToModuleName(pModule.module);
-
-  // when we feed the typescript compiler an import with an explicit .js(x) extension
-  // and the .js(x) file does not exist, it tries files with the .ts, .tsx or
-  // .d.ts extensions (this a.o. means ./hello.jsx can resolve to ./hello.ts and
-  // ./wut.js to ./wut.tsx).
-  //
-  // This behavior is very specific:
-  // - tsc only (doesn't work in ts-node for instance)
-  // - until TypeScript 4.6 only for the .js and .jsx extensions
-  // - since TypeScript 4.7 also for .cjs and .mjs (=> .cts, .mts) extensions,
-  //   which work subtly different;
-  //   .cjs resolves to .cts or .d.cts (in that order)
-  //   .mjs resolves to .mts or .d.mts (in that order)
-  // ref: https://www.typescriptlang.org/docs/handbook/esm-node.html#new-file-extensions
-  //
-  // Hence also this oddly specific looking check & retry.
-  //
-  // This should eventually probably land in either enhanced_resolve or in a
-  // plugin/ extension for it (tsconfig-paths-webpack-plugin?)
-  if (
-    lReturnValue.couldNotResolve &&
-    canBeResolvedToTsVariant(lStrippedModuleName)
-  ) {
-    const lModuleWithoutExtension = lStrippedModuleName.replace(
-      /\.(js|jsx|cjs|mjs)$/g,
-      "",
-    );
-    const lExtensionsToTry = getTypeScriptExtensionsToTry(
-      extname(lStrippedModuleName),
-    );
-
-    const lReturnValueCandidate = resolveModule(
-      { ...pModule, module: lModuleWithoutExtension },
-      pBaseDirectory,
-      pFileDirectory,
-      { ...pResolveOptions, extensions: lExtensionsToTry },
-    );
-
-    if (isTypeScriptIshExtension(lReturnValueCandidate.resolved)) {
-      lReturnValue = lReturnValueCandidate;
-    }
-  }
-  return lReturnValue;
+	let lReturnValue = resolveModule(
+		pModule,
+		pBaseDirectory,
+		pFileDirectory,
+		pResolveOptions,
+	);
+	const lStrippedModuleName = stripToModuleName(pModule.module);
+
+	// when we feed the typescript compiler an import with an explicit .js(x) extension
+	// and the .js(x) file does not exist, it tries files with the .ts, .tsx or
+	// .d.ts extensions (this a.o. means ./hello.jsx can resolve to ./hello.ts and
+	// ./wut.js to ./wut.tsx).
+	//
+	// This behavior is very specific:
+	// - tsc only (doesn't work in ts-node for instance)
+	// - until TypeScript 4.6 only for the .js and .jsx extensions
+	// - since TypeScript 4.7 also for .cjs and .mjs (=> .cts, .mts) extensions,
+	//   which work subtly different;
+	//   .cjs resolves to .cts or .d.cts (in that order)
+	//   .mjs resolves to .mts or .d.mts (in that order)
+	// ref: https://www.typescriptlang.org/docs/handbook/esm-node.html#new-file-extensions
+	//
+	// Hence also this oddly specific looking check & retry.
+	//
+	// This should eventually probably land in either enhanced_resolve or in a
+	// plugin/ extension for it (tsconfig-paths-webpack-plugin?)
+	if (
+		lReturnValue.couldNotResolve &&
+		canBeResolvedToTsVariant(lStrippedModuleName)
+	) {
+		const lModuleWithoutExtension = lStrippedModuleName.replace(
+			/\.(js|jsx|cjs|mjs)$/g,
+			"",
+		);
+		const lExtensionsToTry = getTypeScriptExtensionsToTry(
+			extname(lStrippedModuleName),
+		);
+
+		const lReturnValueCandidate = resolveModule(
+			{ ...pModule, module: lModuleWithoutExtension },
+			pBaseDirectory,
+			pFileDirectory,
+			{ ...pResolveOptions, extensions: lExtensionsToTry },
+		);
+
+		if (isTypeScriptIshExtension(lReturnValueCandidate.resolved)) {
+			lReturnValue = lReturnValueCandidate;
+		}
+	}
+	return lReturnValue;
 }
 
 /**
@@ -173,58 +184,58 @@ function resolveWithRetry(
  */
 // eslint-disable-next-line max-lines-per-function, max-params
 export default function resolve(
-  pDependency,
-  pBaseDirectory,
-  pFileDirectory,
-  pResolveOptions,
-  pTranspileOptions,
+	pDependency,
+	pBaseDirectory,
+	pFileDirectory,
+	pResolveOptions,
+	pTranspileOptions,
 ) {
-  let lResolvedDependency = resolveWithRetry(
-    pDependency,
-    pBaseDirectory,
-    pFileDirectory,
-    pResolveOptions,
-  );
-  const lStrippedModuleName = stripToModuleName(pDependency.module);
-
-  lResolvedDependency = {
-    ...lResolvedDependency,
-    ...addLicenseAttribute(
-      lStrippedModuleName,
-      lResolvedDependency.resolved,
-      { baseDirectory: pBaseDirectory, fileDirectory: pFileDirectory },
-      pResolveOptions,
-    ),
-    dependencyTypes: determineDependencyTypes(
-      { ...pDependency, ...lResolvedDependency },
-      lStrippedModuleName,
-      getManifest(
-        pFileDirectory,
-        pBaseDirectory,
-        pResolveOptions.combinedDependencies,
-      ),
-      pFileDirectory,
-      pResolveOptions,
-      pBaseDirectory,
-      pTranspileOptions,
-    ),
-  };
-
-  if (!lResolvedDependency.coreModule && !lResolvedDependency.couldNotResolve) {
-    // enhanced-resolve inserts a NULL character in front of any `#` character.
-    // This wonky replace corrects that that so the filename again corresponds
-    // with a real file on disk
-    const lResolvedEHRCorrected = lResolvedDependency.resolved.replace(
-      // eslint-disable-next-line no-control-regex
-      /\u0000#/g,
-      "#",
-    );
-    const lResolvedYarnVirtual = resolveYarnVirtual(
-      pBaseDirectory,
-      lResolvedEHRCorrected,
-    );
-
-    lResolvedDependency.resolved = lResolvedYarnVirtual;
-  }
-  return lResolvedDependency;
+	let lResolvedDependency = resolveWithRetry(
+		pDependency,
+		pBaseDirectory,
+		pFileDirectory,
+		pResolveOptions,
+	);
+	const lStrippedModuleName = stripToModuleName(pDependency.module);
+
+	lResolvedDependency = {
+		...lResolvedDependency,
+		...addLicenseAttribute(
+			lStrippedModuleName,
+			lResolvedDependency.resolved,
+			{ baseDirectory: pBaseDirectory, fileDirectory: pFileDirectory },
+			pResolveOptions,
+		),
+		dependencyTypes: determineDependencyTypes(
+			{ ...pDependency, ...lResolvedDependency },
+			lStrippedModuleName,
+			getManifest(
+				pFileDirectory,
+				pBaseDirectory,
+				pResolveOptions.combinedDependencies,
+			),
+			pFileDirectory,
+			pResolveOptions,
+			pBaseDirectory,
+			pTranspileOptions,
+		),
+	};
+
+	if (!lResolvedDependency.coreModule && !lResolvedDependency.couldNotResolve) {
+		// enhanced-resolve inserts a NULL character in front of any `#` character.
+		// This wonky replace corrects that so the filename again corresponds
+		// with a real file on disk
+		const lResolvedEHRCorrected = lResolvedDependency.resolved.replace(
+			// eslint-disable-next-line no-control-regex
+			/\u0000#/g,
+			"#",
+		);
+		const lResolvedYarnVirtual = resolveYarnVirtual(
+			pBaseDirectory,
+			lResolvedEHRCorrected,
+		);
+
+		lResolvedDependency.resolved = lResolvedYarnVirtual;
+	}
+	return lResolvedDependency;
 }

package/src/extract/resolve/is-built-in.mjs

@@ -6,29 +6,27 @@ import { isBuiltin as moduleIsBuiltin } from "node:module";
  * @returns {boolean} - true if the module is a built-in module
  */
 export function isBuiltin(pModuleName, pResolveOptions) {
-  if (pResolveOptions?.builtInModules?.override) {
-    return pResolveOptions.builtInModules.override.includes(pModuleName);
-  }
+	if (pResolveOptions?.builtInModules?.override) {
+		return pResolveOptions.builtInModules.override.includes(pModuleName);
+	}
 
-  // bun, as it turns out, has some additional builtin modules. Even when running
-  // dependency-cruiser with bunx, bunx will use node by default. To cover that scenario
-  // there's three options
-  // - tell everyone to run bunx with the --bun option, so bun uses bun instead of node
-  //   and hope everyone actually does that and it doesn't lead to a bunch of questions
-  //   in the issues section. I don't expect that to happen anytime soon => other options
-  // - add the bun builtins here.
-  //   this sounds attractive, but some of the modules ('undici', 'ws') are
-  //   also npm packages. In nodejs context that will lead to a.o. false
-  //   classifications.
-  // - add the bun builtins in dependency-cruiser.js
-  //   Current approach. The --init command will try to detect whether it's
-  //   in a bun repo and add the bun builtins to the config.
-  //
-  // Update: We now also detect modules with the 'bun:' protocol prefix as built-ins
-  // automatically, as they're unambiguous (unlike bare module names like 'undici').
-  return (
-    moduleIsBuiltin(pModuleName) ||
-    pModuleName.startsWith("bun:") ||
-    (pResolveOptions?.builtInModules?.add ?? []).includes(pModuleName)
-  );
+	// bun, as it turns out, has some additional builtin modules. Even when running
+	// dependency-cruiser with bunx, bunx will use node by default. To cover that scenario
+	// there's three options
+	// - tell everyone to run bunx with the --bun option, so bun uses bun instead of node
+	//   and hope everyone actually does that and it doesn't lead to a bunch of questions
+	//   in the issues section. I don't expect that to happen anytime soon => other options
+	// - add the bun builtins without prefix here.
+	//   this sounds attractive, but some of the modules ('undici', 'ws') are
+	//   also npm packages. In nodejs context that will lead to a.o. false
+	//   classifications.
+	// - add the bun builtins in dependency-cruiser.js + automatically detect modules with the
+	//   bun: protocol (which are unambiguous) as built-ins.
+	//   Current approach. The --init command will try to detect whether it's
+	//   in a bun repo and add the bun builtins to the config.
+	return (
+		moduleIsBuiltin(pModuleName) ||
+		pModuleName.startsWith("bun:") ||
+		(pResolveOptions?.builtInModules?.add ?? []).includes(pModuleName)
+	);
 }