dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/extract/extract-dependencies.mjs

@@ -1,17 +1,17 @@
 import { join, extname, dirname } from "node:path";
 import { extract as acornExtract } from "./acorn/extract.mjs";
 import {
-  extract as tscExtract,
-  shouldUse as tscShouldUse,
+	extract as tscExtract,
+	shouldUse as tscShouldUse,
 } from "./tsc/extract.mjs";
 import {
-  extract as swcExtract,
-  shouldUse as swcShouldUse,
+	extract as swcExtract,
+	shouldUse as swcShouldUse,
 } from "./swc/extract.mjs";
 import resolve from "./resolve/index.mjs";
 import {
-  detectPreCompilationNess,
-  extractModuleAttributes,
+	detectPreCompilationNess,
+	extractModuleAttributes,
 } from "./helpers.mjs";
 import { uniqBy, intersects } from "#utl/array-util.mjs";
 
@@ -21,15 +21,15 @@ import { uniqBy, intersects } from "#utl/array-util.mjs";
  */
 
 function extractWithTsc(pCruiseOptions, pFileName, pTranspileOptions) {
-  let lDependencies = tscExtract(pCruiseOptions, pFileName, pTranspileOptions);
-
-  if (pCruiseOptions.tsPreCompilationDeps === "specify") {
-    lDependencies = detectPreCompilationNess(
-      lDependencies,
-      acornExtract(pCruiseOptions, pFileName, pTranspileOptions),
-    );
-  }
-  return lDependencies;
+	let lDependencies = tscExtract(pCruiseOptions, pFileName, pTranspileOptions);
+
+	if (pCruiseOptions.tsPreCompilationDeps === "specify") {
+		lDependencies = detectPreCompilationNess(
+			lDependencies,
+			acornExtract(pCruiseOptions, pFileName, pTranspileOptions),
+		);
+	}
+	return lDependencies;
 }
 
 /**
@@ -38,15 +38,15 @@ function extractWithTsc(pCruiseOptions, pFileName, pTranspileOptions) {
  * @returns {(IStrictCruiseOptions, string, any) => IDependency[]}
  */
 function determineExtractionFunction(pCruiseOptions, pFileName) {
-  let lExtractionFunction = acornExtract;
+	let lExtractionFunction = acornExtract;
 
-  if (tscShouldUse(pCruiseOptions, pFileName)) {
-    lExtractionFunction = extractWithTsc;
-  } else if (swcShouldUse(pCruiseOptions, pFileName)) {
-    lExtractionFunction = swcExtract;
-  }
+	if (tscShouldUse(pCruiseOptions, pFileName)) {
+		lExtractionFunction = extractWithTsc;
+	} else if (swcShouldUse(pCruiseOptions, pFileName)) {
+		lExtractionFunction = swcExtract;
+	}
 
-  return lExtractionFunction;
+	return lExtractionFunction;
 }
 
 /**
@@ -56,65 +56,65 @@ function determineExtractionFunction(pCruiseOptions, pFileName) {
  * @returns {IDependency[]}
  */
 function extractDependencies(pCruiseOptions, pFileName, pTranspileOptions) {
-  /** @type IDependency[] */
-  let lDependencies = [];
-
-  if (!pCruiseOptions.extraExtensionsToScan.includes(extname(pFileName))) {
-    const lExtractionFunction = determineExtractionFunction(
-      pCruiseOptions,
-      pFileName,
-    );
-    lDependencies = lExtractionFunction(
-      pCruiseOptions,
-      pFileName,
-      pTranspileOptions,
-    );
-  }
-
-  return lDependencies.map((pDependency) => ({
-    ...pDependency,
-    ...extractModuleAttributes(pDependency.module),
-  }));
+	/** @type IDependency[] */
+	let lDependencies = [];
+
+	if (!pCruiseOptions.extraExtensionsToScan.includes(extname(pFileName))) {
+		const lExtractionFunction = determineExtractionFunction(
+			pCruiseOptions,
+			pFileName,
+		);
+		lDependencies = lExtractionFunction(
+			pCruiseOptions,
+			pFileName,
+			pTranspileOptions,
+		);
+	}
+
+	return lDependencies.map((pDependency) => ({
+		...pDependency,
+		...extractModuleAttributes(pDependency.module),
+	}));
 }
 
 function matchesDoNotFollow({ resolved, dependencyTypes }, pDoNotFollow) {
-  const lMatchesPath = pDoNotFollow.path
-    ? RegExp(pDoNotFollow.path, "g").test(resolved)
-    : false;
-  const lMatchesDependencyTypes = pDoNotFollow.dependencyTypes
-    ? intersects(dependencyTypes, pDoNotFollow.dependencyTypes)
-    : false;
-
-  return lMatchesPath || lMatchesDependencyTypes;
+	const lMatchesPath = pDoNotFollow.path
+		? RegExp(pDoNotFollow.path, "g").test(resolved)
+		: false;
+	const lMatchesDependencyTypes = pDoNotFollow.dependencyTypes
+		? intersects(dependencyTypes, pDoNotFollow.dependencyTypes)
+		: false;
+
+	return lMatchesPath || lMatchesDependencyTypes;
 }
 
 function addResolutionAttributes(
-  { baseDir, doNotFollow },
-  pFileName,
-  pResolveOptions,
-  pTranspileOptions,
+	{ baseDir, doNotFollow },
+	pFileName,
+	pResolveOptions,
+	pTranspileOptions,
 ) {
-  return function addAttributes(pDependency) {
-    const lResolved = resolve(
-      pDependency,
-      baseDir,
-      join(baseDir, dirname(pFileName)),
-      pResolveOptions,
-      pTranspileOptions,
-    );
-    const lMatchesDoNotFollow = matchesDoNotFollow(lResolved, doNotFollow);
-
-    return {
-      ...pDependency,
-      ...lResolved,
-      followable: lResolved.followable && !lMatchesDoNotFollow,
-      matchesDoNotFollow: lMatchesDoNotFollow,
-    };
-  };
+	return function addAttributes(pDependency) {
+		const lResolved = resolve(
+			pDependency,
+			baseDir,
+			join(baseDir, dirname(pFileName)),
+			pResolveOptions,
+			pTranspileOptions,
+		);
+		const lMatchesDoNotFollow = matchesDoNotFollow(lResolved, doNotFollow);
+
+		return {
+			...pDependency,
+			...lResolved,
+			followable: lResolved.followable && !lMatchesDoNotFollow,
+			matchesDoNotFollow: lMatchesDoNotFollow,
+		};
+	};
 }
 
 function matchesPattern(pFullPathToFile, pPattern) {
-  return RegExp(pPattern, "g").test(pFullPathToFile);
+	return RegExp(pPattern, "g").test(pFullPathToFile);
 }
 
 /**
@@ -123,17 +123,17 @@ function matchesPattern(pFullPathToFile, pPattern) {
  * @returns {string}
  */
 function getDependencyUniqueKey({ module, moduleSystem, dependencyTypes }) {
-  // c8: dependencyTypes is hardly ever undefined anymore since PR #884, but
-  //     we keep the `|| []` in for robustness sake
-  return `${module} ${moduleSystem} ${(dependencyTypes || []).includes(
-    "type-only",
-  )}`;
+	// c8: dependencyTypes is hardly ever undefined anymore since PR #884, but
+	//     we keep the `|| []` in for robustness sake
+	return `${module} ${moduleSystem} ${(dependencyTypes || []).includes(
+		"type-only",
+	)}`;
 }
 
 function compareDeps(pLeft, pRight) {
-  return getDependencyUniqueKey(pLeft).localeCompare(
-    getDependencyUniqueKey(pRight),
-  );
+	return getDependencyUniqueKey(pLeft).localeCompare(
+		getDependencyUniqueKey(pRight),
+	);
 }
 
 /**
@@ -156,35 +156,35 @@ function compareDeps(pLeft, pRight) {
  * @return {IDependency[]} an array of dependency objects (see above)
  */
 export default function getDependencies(
-  pFileName,
-  pCruiseOptions,
-  pResolveOptions,
-  pTranspileOptions,
+	pFileName,
+	pCruiseOptions,
+	pResolveOptions,
+	pTranspileOptions,
 ) {
-  try {
-    return uniqBy(
-      extractDependencies(pCruiseOptions, pFileName, pTranspileOptions),
-      getDependencyUniqueKey,
-    )
-      .sort(compareDeps)
-      .map(
-        addResolutionAttributes(
-          pCruiseOptions,
-          pFileName,
-          pResolveOptions,
-          pTranspileOptions,
-        ),
-      )
-      .filter(
-        ({ resolved }) =>
-          (!pCruiseOptions?.exclude?.path ||
-            !matchesPattern(resolved, pCruiseOptions.exclude.path)) &&
-          (!pCruiseOptions?.includeOnly?.path ||
-            matchesPattern(resolved, pCruiseOptions.includeOnly.path)),
-      );
-  } catch (pError) {
-    throw new Error(
-      `Extracting dependencies ran afoul of...\n\n  ${pError.message}\n... in ${pFileName}\n\n`,
-    );
-  }
+	try {
+		return uniqBy(
+			extractDependencies(pCruiseOptions, pFileName, pTranspileOptions),
+			getDependencyUniqueKey,
+		)
+			.sort(compareDeps)
+			.map(
+				addResolutionAttributes(
+					pCruiseOptions,
+					pFileName,
+					pResolveOptions,
+					pTranspileOptions,
+				),
+			)
+			.filter(
+				({ resolved }) =>
+					(!pCruiseOptions?.exclude?.path ||
+						!matchesPattern(resolved, pCruiseOptions.exclude.path)) &&
+					(!pCruiseOptions?.includeOnly?.path ||
+						matchesPattern(resolved, pCruiseOptions.includeOnly.path)),
+			);
+	} catch (pError) {
+		throw new Error(
+			`Extracting dependencies ran afoul of...\n\n  ${pError.message}\n... in ${pFileName}\n\n`,
+		);
+	}
 }

package/src/extract/extract-stats.mjs

@@ -1,6 +1,6 @@
 import {
-  getStats as tscStats,
-  shouldUse as tscShouldUse,
+	getStats as tscStats,
+	shouldUse as tscShouldUse,
 } from "./tsc/extract.mjs";
 import { getStats as acornStats } from "./acorn/extract.mjs";
 
@@ -15,13 +15,13 @@ import { getStats as acornStats } from "./acorn/extract.mjs";
  * @returns {(IStrictCruiseOptions, string, any) => IDependency[]}
  */
 function determineExtractionFunction(pCruiseOptions, pFileName) {
-  let lExtractionFunction = acornStats;
+	let lExtractionFunction = acornStats;
 
-  if (tscShouldUse(pCruiseOptions, pFileName)) {
-    lExtractionFunction = tscStats;
-  }
+	if (tscShouldUse(pCruiseOptions, pFileName)) {
+		lExtractionFunction = tscStats;
+	}
 
-  return lExtractionFunction;
+	return lExtractionFunction;
 }
 
 /**
@@ -35,19 +35,19 @@ function determineExtractionFunction(pCruiseOptions, pFileName) {
  * @return {IDependency[]} an array of dependency objects (see above)
  */
 export default function extractStats(
-  pFileName,
-  pCruiseOptions,
-  pTranspileOptions,
+	pFileName,
+	pCruiseOptions,
+	pTranspileOptions,
 ) {
-  try {
-    return determineExtractionFunction(pCruiseOptions, pFileName)(
-      pCruiseOptions,
-      pFileName,
-      pTranspileOptions,
-    );
-  } catch (pError) {
-    throw new Error(
-      `Extracting stats ran afoul of...\n\n  ${pError.message}\n... in ${pFileName}\n\n`,
-    );
-  }
+	try {
+		return determineExtractionFunction(pCruiseOptions, pFileName)(
+			pCruiseOptions,
+			pFileName,
+			pTranspileOptions,
+		);
+	} catch (pError) {
+		throw new Error(
+			`Extracting stats ran afoul of...\n\n  ${pError.message}\n... in ${pFileName}\n\n`,
+		);
+	}
 }

package/src/extract/gather-initial-sources.mjs

@@ -17,27 +17,27 @@ import pathToPosix from "#utl/path-to-posix.mjs";
  * @returns {string[]}
  */
 function getScannableExtensions(pOptions) {
-  return scannableExtensions.concat(pOptions.extraExtensionsToScan);
+	return scannableExtensions.concat(pOptions.extraExtensionsToScan);
 }
 
 function fileIsScannable(pOptions, pPathToFile) {
-  return getScannableExtensions(pOptions).includes(getExtension(pPathToFile));
+	return getScannableExtensions(pOptions).includes(getExtension(pPathToFile));
 }
 
 function shouldBeIncluded(pFullPathToFile, pOptions) {
-  return (
-    !pOptions?.includeOnly?.path ||
-    filenameMatchesPattern(pFullPathToFile, pOptions.includeOnly.path)
-  );
+	return (
+		!pOptions?.includeOnly?.path ||
+		filenameMatchesPattern(pFullPathToFile, pOptions.includeOnly.path)
+	);
 }
 
 function shouldBeExcluded(pFullPathToFile, pOptions) {
-  return (
-    (pOptions?.exclude?.path &&
-      filenameMatchesPattern(pFullPathToFile, pOptions.exclude.path)) ||
-    (pOptions?.doNotFollow?.path &&
-      filenameMatchesPattern(pFullPathToFile, pOptions.doNotFollow.path))
-  );
+	return (
+		(pOptions?.exclude?.path &&
+			filenameMatchesPattern(pFullPathToFile, pOptions.exclude.path)) ||
+		(pOptions?.doNotFollow?.path &&
+			filenameMatchesPattern(pFullPathToFile, pOptions.doNotFollow.path))
+	);
 }
 
 /**
@@ -46,41 +46,41 @@ function shouldBeExcluded(pFullPathToFile, pOptions) {
  * @returns {string[]}
  */
 function gatherScannableFilesFromDirectory(pDirectoryName, pOptions) {
-  return readdirSync(join(pOptions.baseDir, pDirectoryName))
-    .map((pFileName) => join(pDirectoryName, pFileName))
-    .flatMap((pFullPathToFile) => {
-      const lPosixPath = pathToPosix(pFullPathToFile);
-      if (shouldBeExcluded(lPosixPath, pOptions)) {
-        return [];
-      }
-      const lStat = statSync(join(pOptions.baseDir, pFullPathToFile), {
-        throwIfNoEntry: false,
-      });
+	return readdirSync(join(pOptions.baseDir, pDirectoryName))
+		.map((pFileName) => join(pDirectoryName, pFileName))
+		.flatMap((pFullPathToFile) => {
+			const lPosixPath = pathToPosix(pFullPathToFile);
+			if (shouldBeExcluded(lPosixPath, pOptions)) {
+				return [];
+			}
+			const lStat = statSync(join(pOptions.baseDir, pFullPathToFile), {
+				throwIfNoEntry: false,
+			});
 
-      if (lStat) {
-        if (lStat.isDirectory()) {
-          return gatherScannableFilesFromDirectory(pFullPathToFile, pOptions);
-        }
-        if (
-          fileIsScannable(pOptions, pFullPathToFile) &&
-          shouldBeIncluded(lPosixPath, pOptions)
-        ) {
-          return lPosixPath;
-        }
-      }
-      return [];
-    });
+			if (lStat) {
+				if (lStat.isDirectory()) {
+					return gatherScannableFilesFromDirectory(pFullPathToFile, pOptions);
+				}
+				if (
+					fileIsScannable(pOptions, pFullPathToFile) &&
+					shouldBeIncluded(lPosixPath, pOptions)
+				) {
+					return lPosixPath;
+				}
+			}
+			return [];
+		});
 }
 
 function expandGlob(pBaseDirectory, pScannedGlob) {
-  const isMatch = picomatch(pathToPosix(pScannedGlob.glob), {
-    windows: platform === "win32",
-  });
-  return readdirSync(join(pBaseDirectory, pScannedGlob.base), {
-    recursive: true,
-  })
-    .filter((pFile) => isMatch(pFile))
-    .map((pFile) => pathToPosix(join(pScannedGlob.base, pFile)));
+	const isMatch = picomatch(pathToPosix(pScannedGlob.glob), {
+		windows: platform === "win32",
+	});
+	return readdirSync(join(pBaseDirectory, pScannedGlob.base), {
+		recursive: true,
+	})
+		.filter((pFile) => isMatch(pFile))
+		.map((pFile) => pathToPosix(join(pScannedGlob.base, pFile)));
 }
 
 /**
@@ -103,27 +103,27 @@ function expandGlob(pBaseDirectory, pScannedGlob) {
  * @return {string[]}            paths to files to be gathered.
  */
 export default function gatherInitialSources(
-  pFileDirectoryAndGlobArray,
-  pOptions,
+	pFileDirectoryAndGlobArray,
+	pOptions,
 ) {
-  const lOptions = { baseDir: process.cwd(), ...pOptions };
+	const lOptions = { baseDir: process.cwd(), ...pOptions };
 
-  return pFileDirectoryAndGlobArray
-    .flatMap((pFileDirectoryOrGlob) => {
-      const lScannedGlob = picomatch.scan(pFileDirectoryOrGlob, {
-        windows: platform === "win32",
-      });
-      if (lScannedGlob.isGlob) {
-        return expandGlob(lOptions.baseDir, lScannedGlob);
-      }
-      return normalize(pFileDirectoryOrGlob);
-    })
-    .flatMap((pFileOrDirectory) => {
-      if (statSync(join(lOptions.baseDir, pFileOrDirectory)).isDirectory()) {
-        return gatherScannableFilesFromDirectory(pFileOrDirectory, lOptions);
-      }
-      // Not a glob anymore, and not a directory => it's a file
-      return pathToPosix(pFileOrDirectory);
-    })
-    .sort();
+	return pFileDirectoryAndGlobArray
+		.flatMap((pFileDirectoryOrGlob) => {
+			const lScannedGlob = picomatch.scan(pFileDirectoryOrGlob, {
+				windows: platform === "win32",
+			});
+			if (lScannedGlob.isGlob) {
+				return expandGlob(lOptions.baseDir, lScannedGlob);
+			}
+			return normalize(pFileDirectoryOrGlob);
+		})
+		.flatMap((pFileOrDirectory) => {
+			if (statSync(join(lOptions.baseDir, pFileOrDirectory)).isDirectory()) {
+				return gatherScannableFilesFromDirectory(pFileOrDirectory, lOptions);
+			}
+			// Not a glob anymore, and not a directory => it's a file
+			return pathToPosix(pFileOrDirectory);
+		})
+		.sort();
 }