dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/extract/resolve/determine-dependency-types.mjs

@@ -1,12 +1,12 @@
 import { join } from "node:path/posix";
 import {
-  isRelativeModuleName,
-  isExternalModule,
-  getAliasTypes,
+	isRelativeModuleName,
+	isExternalModule,
+	getAliasTypes,
 } from "./module-classifiers.mjs";
 import {
-  dependencyIsDeprecated,
-  getPackageRoot,
+	dependencyIsDeprecated,
+	getPackageRoot,
 } from "./external-module-helpers.mjs";
 
 /**
@@ -17,69 +17,69 @@ import {
  */
 
 function dependencyKeyHasModuleName(
-  pPackageDependencies,
-  pModuleName,
-  pPrefix,
+	pPackageDependencies,
+	pModuleName,
+	pPrefix,
 ) {
-  return (pKey) =>
-    pKey.includes("ependencies") &&
-    Object.hasOwn(pPackageDependencies[pKey], join(pPrefix, pModuleName));
+	return (pKey) =>
+		pKey.includes("ependencies") &&
+		Object.hasOwn(pPackageDependencies[pKey], join(pPrefix, pModuleName));
 }
 
 const NPM2DEP_TYPE = new Map([
-  ["dependencies", "npm"],
-  ["devDependencies", "npm-dev"],
-  ["optionalDependencies", "npm-optional"],
-  ["peerDependencies", "npm-peer"],
+	["dependencies", "npm"],
+	["devDependencies", "npm-dev"],
+	["optionalDependencies", "npm-optional"],
+	["peerDependencies", "npm-peer"],
 ]);
 
 function findModuleInPackageDependencies(
-  pPackageDependencies,
-  pModuleName,
-  pPrefix,
+	pPackageDependencies,
+	pModuleName,
+	pPrefix,
 ) {
-  return Object.keys(pPackageDependencies)
-    .filter(
-      dependencyKeyHasModuleName(pPackageDependencies, pModuleName, pPrefix),
-    )
-    .map((pKey) => NPM2DEP_TYPE.get(pKey) || "npm-no-pkg");
+	return Object.keys(pPackageDependencies)
+		.filter(
+			dependencyKeyHasModuleName(pPackageDependencies, pModuleName, pPrefix),
+		)
+		.map((pKey) => NPM2DEP_TYPE.get(pKey) || "npm-no-pkg");
 }
 
 function needToLookAtTypesToo(pResolverModulePaths) {
-  return (pResolverModulePaths || ["node_modules", "node_modules/@types"]).some(
-    (pPath) => pPath.includes("@types"),
-  );
+	return (pResolverModulePaths || ["node_modules", "node_modules/@types"]).some(
+		(pPath) => pPath.includes("@types"),
+	);
 }
 
 function determineManifestDependencyTypes(
-  pModuleName,
-  pPackageDependencies,
-  pResolverModulePaths,
+	pModuleName,
+	pPackageDependencies,
+	pResolverModulePaths,
 ) {
-  /** @type {DependencyType[]} */
-  let lReturnValue = ["npm-unknown"];
-
-  if (pPackageDependencies) {
-    lReturnValue = findModuleInPackageDependencies(
-      pPackageDependencies,
-      pModuleName,
-      "",
-    );
-
-    if (
-      lReturnValue.length === 0 &&
-      needToLookAtTypesToo(pResolverModulePaths)
-    ) {
-      lReturnValue = findModuleInPackageDependencies(
-        pPackageDependencies,
-        pModuleName,
-        "@types",
-      );
-    }
-    lReturnValue = lReturnValue.length === 0 ? ["npm-no-pkg"] : lReturnValue;
-  }
-
-  return lReturnValue;
+	/** @type {DependencyType[]} */
+	let lReturnValue = ["npm-unknown"];
+
+	if (pPackageDependencies) {
+		lReturnValue = findModuleInPackageDependencies(
+			pPackageDependencies,
+			pModuleName,
+			"",
+		);
+
+		if (
+			lReturnValue.length === 0 &&
+			needToLookAtTypesToo(pResolverModulePaths)
+		) {
+			lReturnValue = findModuleInPackageDependencies(
+				pPackageDependencies,
+				pModuleName,
+				"@types",
+			);
+		}
+		lReturnValue = lReturnValue.length === 0 ? ["npm-no-pkg"] : lReturnValue;
+	}
+
+	return lReturnValue;
 }
 
 /*
@@ -87,17 +87,17 @@ function determineManifestDependencyTypes(
  * an array, and not an object, hence needs different treatment
  */
 function dependencyIsBundled(pModule, pPackageDeps) {
-  let lReturnValue = false;
+	let lReturnValue = false;
 
-  if (pPackageDeps) {
-    const lBundledDependencies =
-      pPackageDeps.bundledDependencies || pPackageDeps.bundleDependencies;
+	if (pPackageDeps) {
+		const lBundledDependencies =
+			pPackageDeps.bundledDependencies || pPackageDeps.bundleDependencies;
 
-    if (lBundledDependencies) {
-      lReturnValue = lBundledDependencies.includes(pModule);
-    }
-  }
-  return lReturnValue;
+		if (lBundledDependencies) {
+			lReturnValue = lBundledDependencies.includes(pModule);
+		}
+	}
+	return lReturnValue;
 }
 
 /**
@@ -109,27 +109,27 @@ function dependencyIsBundled(pModule, pPackageDeps) {
  * @returns {DependencyType[]}
  */
 function determineNodeModuleDependencyTypes(
-  pModuleName,
-  pPackageDeps,
-  pFileDirectory,
-  pResolveOptions,
+	pModuleName,
+	pPackageDeps,
+	pFileDirectory,
+	pResolveOptions,
 ) {
-  /** @type { DependencyType[] } */
-  let lReturnValue = determineManifestDependencyTypes(
-    getPackageRoot(pModuleName),
-    pPackageDeps,
-    pResolveOptions.modules,
-  );
-  if (
-    pResolveOptions.resolveDeprecations &&
-    dependencyIsDeprecated(pModuleName, pFileDirectory, pResolveOptions)
-  ) {
-    lReturnValue.push("deprecated");
-  }
-  if (dependencyIsBundled(pModuleName, pPackageDeps)) {
-    lReturnValue.push("npm-bundled");
-  }
-  return lReturnValue;
+	/** @type { DependencyType[] } */
+	let lReturnValue = determineManifestDependencyTypes(
+		getPackageRoot(pModuleName),
+		pPackageDeps,
+		pResolveOptions.modules,
+	);
+	if (
+		pResolveOptions.resolveDeprecations &&
+		dependencyIsDeprecated(pModuleName, pFileDirectory, pResolveOptions)
+	) {
+		lReturnValue.push("deprecated");
+	}
+	if (dependencyIsBundled(pModuleName, pPackageDeps)) {
+		lReturnValue.push("npm-bundled");
+	}
+	return lReturnValue;
 }
 
 /**
@@ -143,29 +143,29 @@ function determineNodeModuleDependencyTypes(
  * @returns {DependencyType[]}
  */
 function determineExternalModuleDependencyTypes(
-  pDependency,
-  pModuleName,
-  pPackageDeps,
-  pFileDirectory,
-  pResolveOptions,
-  pBaseDirectory,
+	pDependency,
+	pModuleName,
+	pPackageDeps,
+	pFileDirectory,
+	pResolveOptions,
+	pBaseDirectory,
 ) {
-  /** @type { DependencyType[] } */
-  let lReturnValue = [];
-
-  if (
-    isExternalModule(pDependency.resolved, ["node_modules"], pBaseDirectory)
-  ) {
-    lReturnValue = determineNodeModuleDependencyTypes(
-      pModuleName,
-      pPackageDeps,
-      pFileDirectory,
-      pResolveOptions,
-    );
-  } else {
-    lReturnValue = ["localmodule"];
-  }
-  return lReturnValue;
+	/** @type { DependencyType[] } */
+	let lReturnValue = [];
+
+	if (
+		isExternalModule(pDependency.resolved, ["node_modules"], pBaseDirectory)
+	) {
+		lReturnValue = determineNodeModuleDependencyTypes(
+			pModuleName,
+			pPackageDeps,
+			pFileDirectory,
+			pResolveOptions,
+		);
+	} else {
+		lReturnValue = ["localmodule"];
+	}
+	return lReturnValue;
 }
 
 /* eslint max-params:0, complexity:0 */
@@ -183,72 +183,69 @@ function determineExternalModuleDependencyTypes(
  */
 // eslint-disable-next-line max-lines-per-function
 export default function determineDependencyTypes(
-  pDependency,
-  pModuleName,
-  pManifest,
-  pFileDirectory,
-  pResolveOptions,
-  pBaseDirectory,
-  pTranspileOptions,
+	pDependency,
+	pModuleName,
+	pManifest,
+	pFileDirectory,
+	pResolveOptions,
+	pBaseDirectory,
+	pTranspileOptions,
 ) {
-  /** @type {DependencyType[]}*/
-  let lReturnValue = [];
-  const lResolveOptions = pResolveOptions || {};
-
-  if (pDependency.couldNotResolve) {
-    return ["unknown"];
-  }
-
-  const lAliases = getAliasTypes(
-    pModuleName,
-    pDependency.resolved,
-    lResolveOptions,
-    pManifest,
-    pTranspileOptions,
-  );
-  if (lAliases.length > 0) {
-    lReturnValue = lAliases;
-  }
-
-  if (pDependency.coreModule) {
-    // this business seems duplicate (it's already in
-    // the passed object as `coreModule`- determined by the resolve-AMD or
-    // resolve-commonJS module). I want to deprecate the `coreModule`
-    // attribute in favor of this one and determining it here will make
-    // live easier in the future
-    lReturnValue.push("core");
-  } else if (
-    isRelativeModuleName(pModuleName) ||
-    (lAliases.length > 0 &&
-      !isExternalModule(
-        pDependency.resolved,
-        lResolveOptions.modules,
-        pBaseDirectory,
-      ))
-  ) {
-    lReturnValue.push("local");
-  } else if (
-    isExternalModule(
-      pDependency.resolved,
-      lResolveOptions.modules,
-      pBaseDirectory,
-    )
-  ) {
-    lReturnValue = lReturnValue.concat(
-      determineExternalModuleDependencyTypes(
-        pDependency,
-        pModuleName,
-        pManifest,
-        pFileDirectory,
-        lResolveOptions,
-        pBaseDirectory,
-      ),
-    );
-  } else {
-    lReturnValue.push("undetermined");
-  }
-
-  return lReturnValue.concat(pDependency.dependencyTypes || []);
+	/** @type {DependencyType[]}*/
+	let lReturnValue = [];
+	const lResolveOptions = pResolveOptions || {};
+
+	if (pDependency.couldNotResolve) {
+		return ["unknown"];
+	}
+
+	const lAliases = getAliasTypes(
+		pModuleName,
+		pDependency.resolved,
+		lResolveOptions,
+		pManifest,
+		pTranspileOptions,
+	);
+	if (lAliases.length > 0) {
+		lReturnValue = lAliases;
+	}
+
+	if (pDependency.coreModule) {
+		// keeping coreModule for backwards compatibility
+		// would prefer using only the core dependency-type, though
+		lReturnValue.push("core");
+	} else if (
+		isRelativeModuleName(pModuleName) ||
+		(lAliases.length > 0 &&
+			!isExternalModule(
+				pDependency.resolved,
+				lResolveOptions.modules,
+				pBaseDirectory,
+			))
+	) {
+		lReturnValue.push("local");
+	} else if (
+		isExternalModule(
+			pDependency.resolved,
+			lResolveOptions.modules,
+			pBaseDirectory,
+		)
+	) {
+		lReturnValue = lReturnValue.concat(
+			determineExternalModuleDependencyTypes(
+				pDependency,
+				pModuleName,
+				pManifest,
+				pFileDirectory,
+				lResolveOptions,
+				pBaseDirectory,
+			),
+		);
+	} else {
+		lReturnValue.push("undetermined");
+	}
+
+	return lReturnValue.concat(pDependency.dependencyTypes || []);
 }
 
 /* eslint security/detect-object-injection: 0*/

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

@@ -32,26 +32,26 @@ import { isScoped, isRelativeModuleName } from "./module-classifiers.mjs";
  * @return {string}         the module name root
  */
 export function getPackageRoot(pModule) {
-  if (!pModule || isRelativeModuleName(pModule)) {
-    return pModule;
-  }
+	if (!pModule || isRelativeModuleName(pModule)) {
+		return pModule;
+	}
 
-  let lPathElements = pModule.split("/");
+	let lPathElements = pModule.split("/");
 
-  if (isScoped(pModule)) {
-    // '@imdoingweirdvoodoo'
-    if (lPathElements.length === 1) {
-      return pModule;
-    }
+	if (isScoped(pModule)) {
+		// '@imdoingweirdvoodoo'
+		if (lPathElements.length === 1) {
+			return pModule;
+		}
 
-    // @scope/package
-    // @scope/package/some/thing
-    return `${lPathElements[0]}/${lPathElements[1]}`;
-  }
+		// @scope/package
+		// @scope/package/some/thing
+		return `${lPathElements[0]}/${lPathElements[1]}`;
+	}
 
-  // godash
-  // godash/fp
-  return lPathElements[0];
+	// godash
+	// godash/fp
+	return lPathElements[0];
 }
 
 /**
@@ -63,7 +63,7 @@ export function getPackageRoot(pModule) {
  *
  * The pBaseDirectory parameter is necessary because dependency-cruiser/ this module
  * will have a different base dir, and will hence resolve either to the
- * wrong package or not to a package at all.
+ * wrong package or to no package.
  *
  * @param  {string} pModuleName  The name of the module to get the package.json of
  * @param  {string} pFileDirectory The folder the module resides in. Defaults to the current working directory
@@ -73,40 +73,40 @@ export function getPackageRoot(pModule) {
  *                           not be found
  */
 function bareGetPackageJson(pModuleName, pFileDirectory, pResolveOptions) {
-  let lReturnValue = null;
+	let lReturnValue = null;
 
-  try {
-    const lPackageJsonFilename = resolve(
-      join(getPackageRoot(pModuleName), "package.json"),
-      pFileDirectory ?? process.cwd(),
-      {
-        ...pResolveOptions,
-        // if a module has exports fields _and_ does not expose package.json
-        // in those exports, enhanced-resolve (nor node!) will not be able to
-        // resolve the package.json if it actually heeds those exports fields.
-        // We can instruct enhanced-resolve to ignore them, however, by passing
-        // it the empty array for exports fields (overriding anything in
-        // the pResvolveOptions)
-        exportsFields: [],
-        // we don't need to try any extensions; we already
-        // know it as we have passed the complete module name to resolve =>
-        // override whatever the default is with [""] ('use no extensions please')
-        extensions: [""],
-      },
-      // we need a separate caching context so as not to **** up the regular
-      // cruise, which might actually want to utilize the exportsFields
-      // and an array of extensions
-      "manifest-resolution",
-    );
-    lReturnValue = JSON.parse(readFileSync(lPackageJsonFilename, "utf8"));
-  } catch (pError) {
-    // left empty on purpose
-  }
-  return lReturnValue;
+	try {
+		const lPackageJsonFilename = resolve(
+			join(getPackageRoot(pModuleName), "package.json"),
+			pFileDirectory ?? process.cwd(),
+			{
+				...pResolveOptions,
+				// if a module has exports fields _and_ does not expose package.json
+				// in those exports, enhanced-resolve (nr node!) won't be able to
+				// resolve the package.json if it actually heeds those exports fields.
+				// We can instruct enhanced-resolve to ignore them by passing
+				// it the empty array for exports fields (overriding anything in
+				// the pResvolveOptions)
+				exportsFields: [],
+				// we don't need to try any extensions; we already
+				// know it as we have passed the complete module name to resolve =>
+				// override whatever the default is with [""] ('use no extensions please')
+				extensions: [""],
+			},
+			// we need a separate caching context so as not to **** up the regular
+			// cruise, which might actually want to utilize the exportsFields
+			// and an array of extensions
+			"manifest-resolution",
+		);
+		lReturnValue = JSON.parse(readFileSync(lPackageJsonFilename, "utf8"));
+	} catch (pError) {
+		// left empty on purpose
+	}
+	return lReturnValue;
 }
 
 export const getPackageJson = memoize(bareGetPackageJson, {
-  cacheKey: (pArguments) => `${pArguments[0]}|${pArguments[1]}`,
+	cacheKey: (pArguments) => `${pArguments[0]}|${pArguments[1]}`,
 });
 
 /**
@@ -118,22 +118,22 @@ export const getPackageJson = memoize(bareGetPackageJson, {
  * @return {boolean}         true when deprecated, false in all other cases
  */
 export function dependencyIsDeprecated(
-  pModuleName,
-  pFileDirectory,
-  pResolveOptions,
+	pModuleName,
+	pFileDirectory,
+	pResolveOptions,
 ) {
-  let lReturnValue = false;
-  let lPackageJson = getPackageJson(
-    pModuleName,
-    pFileDirectory,
-    pResolveOptions,
-  );
+	let lReturnValue = false;
+	let lPackageJson = getPackageJson(
+		pModuleName,
+		pFileDirectory,
+		pResolveOptions,
+	);
 
-  if (lPackageJson) {
-    lReturnValue =
-      Object.hasOwn(lPackageJson, "deprecated") && lPackageJson.deprecated;
-  }
-  return lReturnValue;
+	if (lPackageJson) {
+		lReturnValue =
+			Object.hasOwn(lPackageJson, "deprecated") && lPackageJson.deprecated;
+	}
+	return lReturnValue;
 }
 
 /**
@@ -146,23 +146,23 @@ export function dependencyIsDeprecated(
  *                           there is no package.json or no license field
  */
 export function getLicense(pModuleName, pFileDirectory, pResolveOptions) {
-  let lReturnValue = "";
-  let lPackageJson = getPackageJson(
-    pModuleName,
-    pFileDirectory,
-    pResolveOptions,
-  );
+	let lReturnValue = "";
+	let lPackageJson = getPackageJson(
+		pModuleName,
+		pFileDirectory,
+		pResolveOptions,
+	);
 
-  if (
-    lPackageJson &&
-    Object.hasOwn(lPackageJson, "license") &&
-    typeof lPackageJson.license === "string"
-  ) {
-    lReturnValue = lPackageJson.license;
-  }
-  return lReturnValue;
+	if (
+		lPackageJson &&
+		Object.hasOwn(lPackageJson, "license") &&
+		typeof lPackageJson.license === "string"
+	) {
+		lReturnValue = lPackageJson.license;
+	}
+	return lReturnValue;
 }
 
 export function clearCache() {
-  memoizeClear(getPackageJson);
+	memoizeClear(getPackageJson);
 }