dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/extract/acorn/extract-amd-deps.mjs

@@ -1,79 +1,78 @@
 import { simple as walk_simple, base as walk_base } from "acorn-walk";
 import extractCommonJSDependencies from "./extract-cjs-deps.mjs";
 import {
-  isLikelyAMDDefineOrRequire,
-  isLikelyAMDDefine,
+	isLikelyAMDDefineOrRequire,
+	isLikelyAMDDefine,
 } from "./estree-helpers.mjs";
 
 function extractRegularAMDDependencies(pNode, pDependencies) {
-  if (isLikelyAMDDefineOrRequire(pNode)) {
-    const lArrayExpressionArguments = pNode.expression.arguments.filter(
-      (pArgument) => pArgument.type === "ArrayExpression",
-    );
+	if (isLikelyAMDDefineOrRequire(pNode)) {
+		const lArrayExpressionArguments = pNode.expression.arguments.filter(
+			(pArgument) => pArgument.type === "ArrayExpression",
+		);
 
-    for (const lArgument of lArrayExpressionArguments) {
-      for (const lElement of lArgument.elements) {
-        // eslint-disable-next-line max-depth
-        if (lElement.value && typeof lElement.value === "string") {
-          pDependencies.push({
-            module: lElement.value,
-            moduleSystem: "amd",
-            dynamic: false,
-            exoticallyRequired: false,
-            dependencyTypes: ["amd-define"],
-          });
-        }
-      }
-    }
-  }
+		for (const lArgument of lArrayExpressionArguments) {
+			for (const lElement of lArgument.elements) {
+				// eslint-disable-next-line max-depth
+				if (lElement.value && typeof lElement.value === "string") {
+					pDependencies.push({
+						module: lElement.value,
+						moduleSystem: "amd",
+						dynamic: false,
+						exoticallyRequired: false,
+						dependencyTypes: ["amd-define"],
+					});
+				}
+			}
+		}
+	}
 }
 
 function extractCommonJSWrappers(pNode, pDependencies, pExoticRequireStrings) {
-  if (isLikelyAMDDefine(pNode)) {
-    pNode.expression.arguments
-      .filter(
-        (pArgument) =>
-          pArgument.type === "FunctionExpression" &&
-          pArgument.params.some(
-            (pParameter) =>
-              pParameter.name === "require" ||
-              pExoticRequireStrings.includes(pParameter.name),
-          ),
-      )
-      .forEach((pFunction) =>
-        extractCommonJSDependencies(
-          pFunction.body,
-          pDependencies,
-          "amd",
-          pExoticRequireStrings,
-        ),
-      );
-  }
+	if (isLikelyAMDDefine(pNode)) {
+		for (const lArgument of pNode.expression.arguments) {
+			if (
+				lArgument.type === "FunctionExpression" &&
+				lArgument.params.some(
+					(pParameter) =>
+						pParameter.name === "require" ||
+						pExoticRequireStrings.includes(pParameter.name),
+				)
+			) {
+				extractCommonJSDependencies(
+					lArgument.body,
+					pDependencies,
+					"amd",
+					pExoticRequireStrings,
+				);
+			}
+		}
+	}
 }
 
 export default function extractAMDDependencies(
-  pAST,
-  pDependencies,
-  pExoticRequireStrings,
+	pAST,
+	pDependencies,
+	pExoticRequireStrings,
 ) {
-  walk_simple(
-    pAST,
-    {
-      ExpressionStatement: (pNode) => {
-        // module as a function (define(Array, function))
-        // module with a name (define(string, Array, function))
-        // 'root' require module (require(Array, function)
-        extractRegularAMDDependencies(pNode, pDependencies);
-        // CommonJS-wrappers:
-        //  (define(function(require, exports, module){
-        //  define(["require", ...], function(require, ...){
-        //      ... every 'require' call is a depencency
-        // Won't work if someone decides to name the first parameter of
-        // the function passed to the define something else from "require"
-        extractCommonJSWrappers(pNode, pDependencies, pExoticRequireStrings);
-      },
-    },
-    // see https://github.com/acornjs/acorn/issues/746
-    walk_base,
-  );
+	walk_simple(
+		pAST,
+		{
+			ExpressionStatement: (pNode) => {
+				// module as a function (define(Array, function))
+				// module with a name (define(string, Array, function))
+				// 'root' require module (require(Array, function)
+				extractRegularAMDDependencies(pNode, pDependencies);
+				// CommonJS-wrappers:
+				//  (define(function(require, exports, module){
+				//  define(["require", ...], function(require, ...){
+				//      ... every 'require' call is a depencency
+				// Won't work if someone decides to name the first parameter of
+				// the function passed to the define something else from "require"
+				extractCommonJSWrappers(pNode, pDependencies, pExoticRequireStrings);
+			},
+		},
+		// see https://github.com/acornjs/acorn/issues/746
+		walk_base,
+	);
 }

package/src/extract/acorn/extract-cjs-deps.mjs

@@ -1,109 +1,109 @@
 import { simple as walk_simple, base as walk_base } from "acorn-walk";
 import {
-  firstArgumentIsAString,
-  firstArgumentIsATemplateLiteral,
-  isRequireOfSomeSort,
+	firstArgumentIsAString,
+	firstArgumentIsATemplateLiteral,
+	isRequireOfSomeSort,
 } from "./estree-helpers.mjs";
 
 function pryStringsFromArguments(pArguments) {
-  let lReturnValue = null;
+	let lReturnValue = null;
 
-  if (firstArgumentIsAString(pArguments)) {
-    lReturnValue = pArguments[0].value;
-  } else if (firstArgumentIsATemplateLiteral(pArguments)) {
-    lReturnValue = pArguments[0].quasis[0].value.cooked;
-  }
+	if (firstArgumentIsAString(pArguments)) {
+		lReturnValue = pArguments[0].value;
+	} else if (firstArgumentIsATemplateLiteral(pArguments)) {
+		lReturnValue = pArguments[0].quasis[0].value.cooked;
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 function getRequireTypes(pModuleSystem) {
-  return pModuleSystem === "amd" ? ["amd-require"] : ["require"];
+	return pModuleSystem === "amd" ? ["amd-require"] : ["require"];
 }
 function getExoticRequireTypes(pModuleSystem) {
-  return pModuleSystem === "amd" ? ["amd-exotic-require"] : ["exotic-require"];
+	return pModuleSystem === "amd" ? ["amd-exotic-require"] : ["exotic-require"];
 }
 
 function getDependencyTypeAttributes(pName, pModuleSystem) {
-  switch (pName) {
-    case "require":
-      return {
-        exoticallyRequired: false,
-        dependencyTypes: getRequireTypes(pModuleSystem),
-      };
-    case "process.getBuiltinModule":
-    case "globalThis.process.getBuiltinModule":
-      return {
-        exoticallyRequired: false,
-        dependencyTypes: ["process-get-builtin-module"],
-      };
-    default:
-      return {
-        exoticallyRequired: true,
-        exoticRequire: pName,
-        dependencyTypes: getExoticRequireTypes(pModuleSystem),
-      };
-  }
+	switch (pName) {
+		case "require":
+			return {
+				exoticallyRequired: false,
+				dependencyTypes: getRequireTypes(pModuleSystem),
+			};
+		case "process.getBuiltinModule":
+		case "globalThis.process.getBuiltinModule":
+			return {
+				exoticallyRequired: false,
+				dependencyTypes: ["process-get-builtin-module"],
+			};
+		default:
+			return {
+				exoticallyRequired: true,
+				exoticRequire: pName,
+				dependencyTypes: getExoticRequireTypes(pModuleSystem),
+			};
+	}
 }
 
 function pushRequireCallsToDependencies(
-  pDependencies,
-  pModuleSystem,
-  pRequireStrings,
+	pDependencies,
+	pModuleSystem,
+	pRequireStrings,
 ) {
-  return (pNode) => {
-    for (let lName of pRequireStrings) {
-      if (isRequireOfSomeSort(pNode, lName)) {
-        const lModuleName = pryStringsFromArguments(pNode.arguments);
-        if (lModuleName) {
-          pDependencies.push({
-            module: lModuleName,
-            moduleSystem: pModuleSystem,
-            dynamic: false,
-            ...getDependencyTypeAttributes(lName, pModuleSystem),
-          });
-        }
-      }
-    }
-  };
+	return (pNode) => {
+		for (const lName of pRequireStrings) {
+			if (isRequireOfSomeSort(pNode, lName)) {
+				const lModuleName = pryStringsFromArguments(pNode.arguments);
+				if (lModuleName) {
+					pDependencies.push({
+						module: lModuleName,
+						moduleSystem: pModuleSystem,
+						dynamic: false,
+						...getDependencyTypeAttributes(lName, pModuleSystem),
+					});
+				}
+			}
+		}
+	};
 }
 
 // eslint-disable-next-line max-params
 export default function extractCommonJSDependencies(
-  pAST,
-  pDependencies,
-  pModuleSystem,
-  pExoticRequireStrings,
-  pDetectProcessBuiltinModuleCalls,
+	pAST,
+	pDependencies,
+	pModuleSystem,
+	pExoticRequireStrings,
+	pDetectProcessBuiltinModuleCalls,
 ) {
-  // var/const lalala = require('./lalala');
-  // require('./lalala');
-  // require('./lalala').doFunkyStuff();
-  // require('zoinks!./wappie')
-  // require(`./withatemplateliteral`)
-  // when feature switched as such it will also detect
-  //   process.getBuiltinModule('fs')
-  //   globalThis.process.getBuiltinModule('path')
-  // as well as renamed requires/ require wrappers
-  // as passed in pExoticRequireStrings ("need", "window.require")
-  const lRequireStrings = ["require"]
-    .concat(
-      pDetectProcessBuiltinModuleCalls
-        ? ["process.getBuiltinModule", "globalThis.process.getBuiltinModule"]
-        : [],
-    )
-    .concat(pExoticRequireStrings);
+	// var/const lalala = require('./lalala');
+	// require('./lalala');
+	// require('./lalala').doFunkyStuff();
+	// require('zoinks!./wappie')
+	// require(`./withatemplateliteral`)
+	// when feature switched as such it will also detect
+	//   process.getBuiltinModule('fs')
+	//   globalThis.process.getBuiltinModule('path')
+	// as well as renamed requires/ require wrappers
+	// as passed in pExoticRequireStrings ("need", "window.require")
+	const lRequireStrings = ["require"]
+		.concat(
+			pDetectProcessBuiltinModuleCalls
+				? ["process.getBuiltinModule", "globalThis.process.getBuiltinModule"]
+				: [],
+		)
+		.concat(pExoticRequireStrings);
 
-  walk_simple(
-    pAST,
-    {
-      CallExpression: pushRequireCallsToDependencies(
-        pDependencies,
-        pModuleSystem,
-        lRequireStrings,
-      ),
-    },
-    // see https://github.com/acornjs/acorn/issues/746
-    walk_base,
-  );
+	walk_simple(
+		pAST,
+		{
+			CallExpression: pushRequireCallsToDependencies(
+				pDependencies,
+				pModuleSystem,
+				lRequireStrings,
+			),
+		},
+		// see https://github.com/acornjs/acorn/issues/746
+		walk_base,
+	);
 }

package/src/extract/acorn/extract-es6-deps.mjs

@@ -1,67 +1,67 @@
 import { simple as walk_simple, base as walk_base } from "acorn-walk";
 import { extend } from "acorn-jsx-walk";
 import {
-  isStringLiteral,
-  isPlaceholderLessTemplateLiteral,
+	isStringLiteral,
+	isPlaceholderLessTemplateLiteral,
 } from "./estree-helpers.mjs";
 
 extend(walk_base);
 
 function pushImportNodeValue(pDependencies) {
-  return (pNode) => {
-    if (isStringLiteral(pNode.source)) {
-      pDependencies.push({
-        module: pNode.source.value,
-        moduleSystem: "es6",
-        dynamic: true,
-        exoticallyRequired: false,
-        dependencyTypes: ["dynamic-import"],
-      });
-    } else if (isPlaceholderLessTemplateLiteral(pNode.source)) {
-      pDependencies.push({
-        module: pNode.source.quasis[0].value.cooked,
-        moduleSystem: "es6",
-        dynamic: true,
-        exoticallyRequired: false,
-        dependencyTypes: ["dynamic-import"],
-      });
-    }
-  };
+	return (pNode) => {
+		if (isStringLiteral(pNode.source)) {
+			pDependencies.push({
+				module: pNode.source.value,
+				moduleSystem: "es6",
+				dynamic: true,
+				exoticallyRequired: false,
+				dependencyTypes: ["dynamic-import"],
+			});
+		} else if (isPlaceholderLessTemplateLiteral(pNode.source)) {
+			pDependencies.push({
+				module: pNode.source.quasis[0].value.cooked,
+				moduleSystem: "es6",
+				dynamic: true,
+				exoticallyRequired: false,
+				dependencyTypes: ["dynamic-import"],
+			});
+		}
+	};
 }
 
 export default function extractES6Dependencies(pAST, pDependencies) {
-  function pushImportSourceValue(pNode) {
-    if (pNode.source && pNode.source.value) {
-      pDependencies.push({
-        module: pNode.source.value,
-        moduleSystem: "es6",
-        dynamic: false,
-        exoticallyRequired: false,
-        dependencyTypes: ["import"],
-      });
-    }
-  }
-  function pushExportSourceValue(pNode) {
-    if (pNode.source && pNode.source.value) {
-      pDependencies.push({
-        module: pNode.source.value,
-        moduleSystem: "es6",
-        dynamic: false,
-        exoticallyRequired: false,
-        dependencyTypes: ["export"],
-      });
-    }
-  }
+	function pushImportSourceValue(pNode) {
+		if (pNode.source && pNode.source.value) {
+			pDependencies.push({
+				module: pNode.source.value,
+				moduleSystem: "es6",
+				dynamic: false,
+				exoticallyRequired: false,
+				dependencyTypes: ["import"],
+			});
+		}
+	}
+	function pushExportSourceValue(pNode) {
+		if (pNode.source && pNode.source.value) {
+			pDependencies.push({
+				module: pNode.source.value,
+				moduleSystem: "es6",
+				dynamic: false,
+				exoticallyRequired: false,
+				dependencyTypes: ["export"],
+			});
+		}
+	}
 
-  walk_simple(
-    pAST,
-    {
-      ImportDeclaration: pushImportSourceValue,
-      ImportExpression: pushImportNodeValue(pDependencies),
-      ExportAllDeclaration: pushExportSourceValue,
-      ExportNamedDeclaration: pushExportSourceValue,
-    },
-    // see https://github.com/acornjs/acorn/issues/746
-    walk_base,
-  );
+	walk_simple(
+		pAST,
+		{
+			ImportDeclaration: pushImportSourceValue,
+			ImportExpression: pushImportNodeValue(pDependencies),
+			ExportAllDeclaration: pushExportSourceValue,
+			ExportNamedDeclaration: pushExportSourceValue,
+		},
+		// see https://github.com/acornjs/acorn/issues/746
+		walk_base,
+	);
 }

package/src/extract/acorn/extract-stats.mjs

@@ -1,6 +1,6 @@
 export default function extractStats(pAST) {
-  return {
-    topLevelStatementCount: pAST?.body?.length || 0,
-    size: pAST?.end || 0,
-  };
+	return {
+		topLevelStatementCount: pAST?.body?.length || 0,
+		size: pAST?.end || 0,
+	};
 }

package/src/extract/acorn/extract.mjs

@@ -6,38 +6,38 @@ import { getASTCached } from "./parse.mjs";
 import extractStats from "./extract-stats.mjs";
 
 export function extract(
-  {
-    baseDir,
-    moduleSystems,
-    exoticRequireStrings,
-    detectProcessBuiltinModuleCalls,
-  },
-  pFileName,
-  pTranspileOptions,
+	{
+		baseDir,
+		moduleSystems,
+		exoticRequireStrings,
+		detectProcessBuiltinModuleCalls,
+	},
+	pFileName,
+	pTranspileOptions,
 ) {
-  let lDependencies = [];
-  const lAST = getASTCached(join(baseDir, pFileName), pTranspileOptions);
+	let lDependencies = [];
+	const lAST = getASTCached(join(baseDir, pFileName), pTranspileOptions);
 
-  if (moduleSystems.includes("cjs")) {
-    extractCommonJSDeps(
-      lAST,
-      lDependencies,
-      "cjs",
-      exoticRequireStrings,
-      detectProcessBuiltinModuleCalls,
-    );
-  }
-  if (moduleSystems.includes("es6")) {
-    extractES6Deps(lAST, lDependencies);
-  }
-  if (moduleSystems.includes("amd")) {
-    extractAMDDeps(lAST, lDependencies, exoticRequireStrings);
-  }
+	if (moduleSystems.includes("cjs")) {
+		extractCommonJSDeps(
+			lAST,
+			lDependencies,
+			"cjs",
+			exoticRequireStrings,
+			detectProcessBuiltinModuleCalls,
+		);
+	}
+	if (moduleSystems.includes("es6")) {
+		extractES6Deps(lAST, lDependencies);
+	}
+	if (moduleSystems.includes("amd")) {
+		extractAMDDeps(lAST, lDependencies, exoticRequireStrings);
+	}
 
-  return lDependencies;
+	return lDependencies;
 }
 
 export function getStats({ baseDir }, pFileName, pTranspileOptions) {
-  const lAST = getASTCached(join(baseDir, pFileName), pTranspileOptions);
-  return extractStats(lAST);
+	const lAST = getASTCached(join(baseDir, pFileName), pTranspileOptions);
+	return extractStats(lAST);
 }

package/src/extract/acorn/parse.mjs

@@ -8,46 +8,46 @@ import getExtension from "#utl/get-extension.mjs";
 
 /** @type acorn.Options */
 const ACORN_OPTIONS = {
-  sourceType: "module",
-  ecmaVersion: 11,
+	sourceType: "module",
+	ecmaVersion: 11,
 };
 
 const TSCONFIG_CONSTANTS = {
-  PRESERVE_JSX: 1,
+	PRESERVE_JSX: 1,
 };
 const acornJsxParser = acornParser.extend(acornJsx());
 
 function needsJSXTreatment(pFileRecord, pTranspileOptions) {
-  return (
-    pFileRecord.extension === ".jsx" ||
-    (pFileRecord.extension === ".tsx" &&
-      pTranspileOptions?.tsConfig?.options?.jsx ===
-        TSCONFIG_CONSTANTS.PRESERVE_JSX)
-  );
+	return (
+		pFileRecord.extension === ".jsx" ||
+		(pFileRecord.extension === ".tsx" &&
+			pTranspileOptions?.tsConfig?.options?.jsx ===
+				TSCONFIG_CONSTANTS.PRESERVE_JSX)
+	);
 }
 
 export function getASTFromSource(pFileRecord, pTranspileOptions) {
-  const lJavaScriptSource = transpile(pFileRecord, pTranspileOptions);
+	const lJavaScriptSource = transpile(pFileRecord, pTranspileOptions);
 
-  try {
-    if (needsJSXTreatment(pFileRecord, pTranspileOptions)) {
-      return acornJsxParser.parse(lJavaScriptSource, {
-        ...ACORN_OPTIONS,
-        // @ts-expect-error because ...
-        // acornJsxParser.parse takes an acorn.Options which doesn't include
-        // allowNamespacedObjects. acornJsx.Options doesn't include sourceType
-        // though, so a bit rock < this code > hard place hence ignore it
-        // type wise
-        allowNamespacedObjects: true,
-      });
-    }
+	try {
+		if (needsJSXTreatment(pFileRecord, pTranspileOptions)) {
+			return acornJsxParser.parse(lJavaScriptSource, {
+				...ACORN_OPTIONS,
+				// @ts-expect-error because ...
+				// acornJsxParser.parse takes an acorn.Options which doesn't include
+				// allowNamespacedObjects. acornJsx.Options doesn't include sourceType
+				// though, so a bit rock < this code > hard place hence ignore it
+				// type wise
+				allowNamespacedObjects: true,
+			});
+		}
 
-    // ecmaVersion 11 necessary for acorn to understand dynamic imports
-    // explicitly passing ecmaVersion is recommended from acorn 8
-    return acornParse(lJavaScriptSource, ACORN_OPTIONS);
-  } catch (pError) {
-    return acornLooseParse(lJavaScriptSource, ACORN_OPTIONS);
-  }
+		// ecmaVersion 11 necessary for acorn to understand dynamic imports
+		// explicitly passing ecmaVersion is recommended from acorn 8
+		return acornParse(lJavaScriptSource, ACORN_OPTIONS);
+	} catch (pError) {
+		return acornLooseParse(lJavaScriptSource, ACORN_OPTIONS);
+	}
 }
 
 /**
@@ -63,14 +63,14 @@ export function getASTFromSource(pFileRecord, pTranspileOptions) {
  * @returns {acorn.Node}              the abstract syntax tree
  */
 function getAST(pFileName, pTranspileOptions) {
-  return getASTFromSource(
-    {
-      source: readFileSync(pFileName, "utf8"),
-      extension: getExtension(pFileName),
-      filename: pFileName,
-    },
-    pTranspileOptions,
-  );
+	return getASTFromSource(
+		{
+			source: readFileSync(pFileName, "utf8"),
+			extension: getExtension(pFileName),
+			filename: pFileName,
+		},
+		pTranspileOptions,
+	);
 }
 
 /**
@@ -90,5 +90,5 @@ function getAST(pFileName, pTranspileOptions) {
 export const getASTCached = memoize(getAST);
 
 export function clearCache() {
-  memoizeClear(getASTCached);
+	memoizeClear(getASTCached);
 }

package/src/extract/clear-caches.mjs

@@ -7,11 +7,11 @@ import { clearCache as resolveAMD_clearCache } from "./resolve/resolve-amd.mjs";
 import { clearCache as resolve_clearCache } from "./resolve/resolve.mjs";
 
 export default function clearCaches() {
-  tscClearCache();
-  acornClearCache();
-  swcClearCache();
-  externalModuleHelpers_clearCache();
-  getManifest_clearCache();
-  resolveAMD_clearCache();
-  resolve_clearCache();
+	tscClearCache();
+	acornClearCache();
+	swcClearCache();
+	externalModuleHelpers_clearCache();
+	getManifest_clearCache();
+	resolveAMD_clearCache();
+	resolve_clearCache();
 }