dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/extract/helpers.mjs

@@ -1,45 +1,45 @@
 import { extname } from "node:path";
 
 export function dependenciesEqual(pLeftDependency) {
-  // As we're using this to compare (typescript) pre-compilation dependencies
-  // with post-compilation dependencies we do not consider the moduleSystem.
-  //
-  // In typescript the module system will typically be es6. Compiled down to
-  // javascript it can be es6, but also cjs (depends on the `module` setting
-  // in your tsconfig). In the latter case, we're still looking at the same
-  // dependency even though the module systems differ.
-  return (pRightDependency) =>
-    pLeftDependency.module === pRightDependency.module &&
-    pLeftDependency.dynamic === pRightDependency.dynamic &&
-    pLeftDependency.exoticRequire === pRightDependency.exoticRequire;
+	// As we're using this to compare (typescript) pre-compilation dependencies
+	// with post-compilation dependencies we do not consider the moduleSystem.
+	//
+	// In typescript the module system will typically be es6. Compiled down to
+	// javascript it can be es6, but also cjs (depends on the `module` setting
+	// in your tsconfig). In the latter case, we're still looking at the same
+	// dependency even though the module systems differ.
+	return (pRightDependency) =>
+		pLeftDependency.module === pRightDependency.module &&
+		pLeftDependency.dynamic === pRightDependency.dynamic &&
+		pLeftDependency.exoticRequire === pRightDependency.exoticRequire;
 }
 
 export function detectPreCompilationNess(pTSDependencies, pJSDependencies) {
-  return pTSDependencies.map((pTSDependency) =>
-    pJSDependencies.some(dependenciesEqual(pTSDependency))
-      ? { ...pTSDependency, preCompilationOnly: false }
-      : {
-          ...pTSDependency,
-          preCompilationOnly: true,
-          dependencyTypes: (pTSDependency.dependencyTypes || []).concat(
-            "pre-compilation-only",
-          ),
-        },
-  );
+	return pTSDependencies.map((pTSDependency) =>
+		pJSDependencies.some(dependenciesEqual(pTSDependency))
+			? { ...pTSDependency, preCompilationOnly: false }
+			: {
+					...pTSDependency,
+					preCompilationOnly: true,
+					dependencyTypes: (pTSDependency.dependencyTypes || []).concat(
+						"pre-compilation-only",
+					),
+				},
+	);
 }
 
 const PROTOCOL_ONLY_BUILTINS = new Set([
-  // module.builtinModules.filter(m=>m.startsWith('node:'))
-  "node:sea",
-  "node:sqlite",
-  "node:test",
-  "node:test/reporters",
-  // module.builtinModules.filter(m=>m.startsWith('bun:'))
-  "bun:ffi",
-  "bun:jsc",
-  "bun:sqlite",
-  "bun:test",
-  "bun:wrap",
+	// module.builtinModules.filter(m=>m.startsWith('node:'))
+	"node:sea",
+	"node:sqlite",
+	"node:test",
+	"node:test/reporters",
+	// module.builtinModules.filter(m=>m.startsWith('bun:'))
+	"bun:ffi",
+	"bun:jsc",
+	"bun:sqlite",
+	"bun:test",
+	"bun:wrap",
 ]);
 
 /**
@@ -49,14 +49,14 @@ const PROTOCOL_ONLY_BUILTINS = new Set([
  * @returns {string}
  */
 function getCanonicalModuleName(pModuleName, pProtocol) {
-  const lModuleWithProtocol = pProtocol + pModuleName;
-  const lIsJsIshProtocol = pProtocol === "node:" || pProtocol === "bun:";
-  const lIsProtocolOnlyModule = PROTOCOL_ONLY_BUILTINS.has(lModuleWithProtocol);
+	const lModuleWithProtocol = pProtocol + pModuleName;
+	const lIsJsIshProtocol = pProtocol === "node:" || pProtocol === "bun:";
+	const lIsProtocolOnlyModule = PROTOCOL_ONLY_BUILTINS.has(lModuleWithProtocol);
 
-  if (!lIsJsIshProtocol || lIsProtocolOnlyModule) {
-    return lModuleWithProtocol;
-  }
-  return pModuleName;
+	if (!lIsJsIshProtocol || lIsProtocolOnlyModule) {
+		return lModuleWithProtocol;
+	}
+	return pModuleName;
 }
 
 /**
@@ -75,26 +75,26 @@ function getCanonicalModuleName(pModuleName, pProtocol) {
  */
 // eslint-disable-next-line complexity
 export function extractModuleAttributes(pString) {
-  let lReturnValue = { module: pString };
-  const lModuleAttributes = pString.match(
-    // eslint-disable-next-line security/detect-unsafe-regex
-    /^(?<protocol>node:|file:|data:|bun:)(?:(?<mimeType>[^,]+),)?(?<module>.+)$/,
-  );
+	let lReturnValue = { module: pString };
+	const lModuleAttributes = pString.match(
+		// eslint-disable-next-line security/detect-unsafe-regex
+		/^(?<protocol>node:|file:|data:|bun:)(?:(?<mimeType>[^,]+),)?(?<module>.+)$/,
+	);
 
-  if (lModuleAttributes?.groups) {
-    lReturnValue.module = getCanonicalModuleName(
-      lModuleAttributes?.groups.module,
-      lModuleAttributes?.groups.protocol,
-    );
-    if (lModuleAttributes?.groups?.protocol) {
-      lReturnValue.protocol = lModuleAttributes.groups.protocol;
-    }
-    if (lModuleAttributes?.groups?.mimeType) {
-      lReturnValue.mimeType = lModuleAttributes.groups.mimeType;
-    }
-  }
+	if (lModuleAttributes?.groups) {
+		lReturnValue.module = getCanonicalModuleName(
+			lModuleAttributes?.groups.module,
+			lModuleAttributes?.groups.protocol,
+		);
+		if (lModuleAttributes?.groups?.protocol) {
+			lReturnValue.protocol = lModuleAttributes.groups.protocol;
+		}
+		if (lModuleAttributes?.groups?.mimeType) {
+			lReturnValue.mimeType = lModuleAttributes.groups.mimeType;
+		}
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 /**
@@ -108,25 +108,27 @@ export function extractModuleAttributes(pString) {
  * @returns {string} the stripped string
  */
 export function stripQueryParameters(pFilenameString) {
-  // url.parse(pFilenameString).pathname did this quite admirably, but it's
-  // deprecated, hence this funky RE replace. And accompanying unit test :-/
-  return pFilenameString.replace(/\?.+$/, "");
+	// url.parse(pFilenameString).pathname did this, but it's
+	// deprecated, hence this funky RE replace.
+	return pFilenameString.replace(/\?.+$/, "");
 }
 
+const TS_COMPATIBLE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs",
+	".vue",
+]);
+
 /**
  * Returns true if the file name has a TypeScript compatible extension
  * @param {string} pFileName
  * @returns {boolean}
  */
 export function isTypeScriptCompatible(pFileName) {
-  return [
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".mjs",
-    ".cjs",
-    ".vue",
-  ].includes(extname(pFileName));
+	return TS_COMPATIBLE_EXTENSIONS.has(extname(pFileName));
 }

package/src/extract/index.mjs

@@ -11,131 +11,131 @@ import { bus } from "#utl/bus.mjs";
 
 /* eslint max-params:0 , max-lines-per-function:0*/
 function extractRecursive(
-  pFileName,
-  pCruiseOptions,
-  pVisited,
-  pDepth,
-  pResolveOptions,
-  pTranspileOptions,
+	pFileName,
+	pCruiseOptions,
+	pVisited,
+	pDepth,
+	pResolveOptions,
+	pTranspileOptions,
 ) {
-  pVisited.add(pFileName);
-  const lDependencies =
-    pCruiseOptions.maxDepth <= 0 || pDepth < pCruiseOptions.maxDepth
-      ? extractDependencies(
-          pFileName,
-          pCruiseOptions,
-          pResolveOptions,
-          pTranspileOptions,
-        )
-      : [];
-  const lReturnValue = [
-    {
-      source: pFileName,
-      ...(pCruiseOptions.experimentalStats
-        ? {
-            experimentalStats: extractStats(
-              pFileName,
-              pCruiseOptions,
-              pTranspileOptions,
-            ),
-          }
-        : {}),
-      dependencies: lDependencies,
-    },
-  ];
+	pVisited.add(pFileName);
+	const lDependencies =
+		pCruiseOptions.maxDepth <= 0 || pDepth < pCruiseOptions.maxDepth
+			? extractDependencies(
+					pFileName,
+					pCruiseOptions,
+					pResolveOptions,
+					pTranspileOptions,
+				)
+			: [];
+	const lReturnValue = [
+		{
+			source: pFileName,
+			...(pCruiseOptions.experimentalStats
+				? {
+						experimentalStats: extractStats(
+							pFileName,
+							pCruiseOptions,
+							pTranspileOptions,
+						),
+					}
+				: {}),
+			dependencies: lDependencies,
+		},
+	];
 
-  // eslint-disable-next-line budapestian/local-variable-pattern
-  for (const { resolved, followable, matchesDoNotFollow } of lDependencies) {
-    if (followable && !matchesDoNotFollow && !pVisited.has(resolved)) {
-      lReturnValue.push(
-        ...extractRecursive(
-          resolved,
-          pCruiseOptions,
-          pVisited,
-          pDepth + 1,
-          pResolveOptions,
-          pTranspileOptions,
-        ),
-      );
-    }
-  }
-  return lReturnValue;
+	// eslint-disable-next-line budapestian/local-variable-pattern
+	for (const { resolved, followable, matchesDoNotFollow } of lDependencies) {
+		if (followable && !matchesDoNotFollow && !pVisited.has(resolved)) {
+			lReturnValue.push(
+				...extractRecursive(
+					resolved,
+					pCruiseOptions,
+					pVisited,
+					pDepth + 1,
+					pResolveOptions,
+					pTranspileOptions,
+				),
+			);
+		}
+	}
+	return lReturnValue;
 }
 
 function extractFileDirectoryArray(
-  pFileDirectoryArray,
-  pCruiseOptions,
-  pResolveOptions,
-  pTranspileOptions,
+	pFileDirectoryArray,
+	pCruiseOptions,
+	pResolveOptions,
+	pTranspileOptions,
 ) {
-  let lVisited = new Set();
+	let lVisited = new Set();
 
-  bus.info("read files: gather initial sources");
-  const lInitialSources = gatherInitialSources(
-    pFileDirectoryArray,
-    pCruiseOptions,
-  );
+	bus.info("read files: gather initial sources");
+	const lInitialSources = gatherInitialSources(
+		pFileDirectoryArray,
+		pCruiseOptions,
+	);
 
-  bus.info("read files: visit dependencies");
-  const lResult = [];
-  for (const lFilename of lInitialSources) {
-    if (!lVisited.has(lFilename)) {
-      lVisited.add(lFilename);
-      lResult.push(
-        ...extractRecursive(
-          lFilename,
-          pCruiseOptions,
-          lVisited,
-          0,
-          pResolveOptions,
-          pTranspileOptions,
-        ),
-      );
-    }
-  }
-  return lResult;
+	bus.info("read files: visit dependencies");
+	const lResult = [];
+	for (const lFilename of lInitialSources) {
+		if (!lVisited.has(lFilename)) {
+			lVisited.add(lFilename);
+			lResult.push(
+				...extractRecursive(
+					lFilename,
+					pCruiseOptions,
+					lVisited,
+					0,
+					pResolveOptions,
+					pTranspileOptions,
+				),
+			);
+		}
+	}
+	return lResult;
 }
 
 function isNotFollowable({ followable }) {
-  return !followable;
+	return !followable;
 }
 
 function notInFromListAlready(pFromList) {
-  return ({ resolved }) => !pFromList.some(({ source }) => source === resolved);
+	return ({ resolved }) => !pFromList.some(({ source }) => source === resolved);
 }
 
 function toDependencyToSource(pToListItem) {
-  return {
-    source: pToListItem.resolved,
-    followable: pToListItem.followable,
-    coreModule: pToListItem.coreModule,
-    couldNotResolve: pToListItem.couldNotResolve,
-    matchesDoNotFollow: pToListItem.matchesDoNotFollow,
-    dependencyTypes: pToListItem.dependencyTypes,
-    dependencies: [],
-  };
+	return {
+		source: pToListItem.resolved,
+		followable: pToListItem.followable,
+		coreModule: pToListItem.coreModule,
+		couldNotResolve: pToListItem.couldNotResolve,
+		matchesDoNotFollow: pToListItem.matchesDoNotFollow,
+		dependencyTypes: pToListItem.dependencyTypes,
+		dependencies: [],
+	};
 }
 
 function complete(pAll, pFromListItem) {
-  return pAll
-    .concat(pFromListItem)
-    .concat(
-      pFromListItem.dependencies
-        .filter(isNotFollowable)
-        .filter(notInFromListAlready(pAll))
-        .map(toDependencyToSource),
-    );
+	return pAll
+		.concat(pFromListItem)
+		.concat(
+			pFromListItem.dependencies
+				.filter(isNotFollowable)
+				.filter(notInFromListAlready(pAll))
+				.map(toDependencyToSource),
+		);
 }
 
 function filterExcludedDynamicDependencies(pModule, pExclude) {
-  // no need to do the 'path' thing as that was addressed in extractFileDirectoryArray already
-  return {
-    ...pModule,
-    dependencies: pModule.dependencies.filter(
-      ({ dynamic }) =>
-        !Object.hasOwn(pExclude, "dynamic") || pExclude.dynamic !== dynamic,
-    ),
-  };
+	// no need to do the 'path' thing as that was addressed in extractFileDirectoryArray already
+	return {
+		...pModule,
+		dependencies: pModule.dependencies.filter(
+			({ dynamic }) =>
+				!Object.hasOwn(pExclude, "dynamic") || pExclude.dynamic !== dynamic,
+		),
+	};
 }
 
 /**
@@ -149,24 +149,24 @@ function filterExcludedDynamicDependencies(pModule, pExclude) {
  * @returns {Partial<IModule[]>}
  */
 export default function extract(
-  pFileDirectoryArray,
-  pCruiseOptions,
-  pResolveOptions,
-  pTranspileOptions,
+	pFileDirectoryArray,
+	pCruiseOptions,
+	pResolveOptions,
+	pTranspileOptions,
 ) {
-  clearCaches();
+	clearCaches();
 
-  const lReturnValue = extractFileDirectoryArray(
-    pFileDirectoryArray,
-    pCruiseOptions,
-    pResolveOptions,
-    pTranspileOptions,
-  )
-    .reduce(complete, [])
-    .map((pModule) =>
-      filterExcludedDynamicDependencies(pModule, pCruiseOptions.exclude),
-    );
-  pResolveOptions.fileSystem.purge();
-  clearCaches();
-  return lReturnValue;
+	const lReturnValue = extractFileDirectoryArray(
+		pFileDirectoryArray,
+		pCruiseOptions,
+		pResolveOptions,
+		pTranspileOptions,
+	)
+		.reduce(complete, [])
+		.map((pModule) =>
+			filterExcludedDynamicDependencies(pModule, pCruiseOptions.exclude),
+		);
+	pResolveOptions.fileSystem.purge();
+	clearCaches();
+	return lReturnValue;
 }