dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/extract/tsc/extract.mjs

@@ -5,33 +5,33 @@ import { getASTCached, isAvailable } from "./parse.mjs";
 import extractStats from "./extract-stats.mjs";
 
 export function shouldUse({ tsPreCompilationDeps, parser }, pFileName) {
-  return (
-    (tsPreCompilationDeps || parser === "tsc") &&
-    isAvailable() &&
-    isTypeScriptCompatible(pFileName)
-  );
+	return (
+		(tsPreCompilationDeps || parser === "tsc") &&
+		isAvailable() &&
+		isTypeScriptCompatible(pFileName)
+	);
 }
 
 export function extract(
-  {
-    baseDir,
-    exoticRequireStrings,
-    moduleSystems,
-    detectJSDocImports,
-    detectProcessBuiltinModuleCalls,
-  },
-  pFileName,
-  pTranspileOptions,
+	{
+		baseDir,
+		exoticRequireStrings,
+		moduleSystems,
+		detectJSDocImports,
+		detectProcessBuiltinModuleCalls,
+	},
+	pFileName,
+	pTranspileOptions,
 ) {
-  return extractTypeScriptDeps(
-    getASTCached(join(baseDir, pFileName), pTranspileOptions),
-    exoticRequireStrings,
-    detectJSDocImports,
-    detectProcessBuiltinModuleCalls,
-  ).filter(({ moduleSystem }) => moduleSystems.includes(moduleSystem));
+	return extractTypeScriptDeps(
+		getASTCached(join(baseDir, pFileName), pTranspileOptions),
+		exoticRequireStrings,
+		detectJSDocImports,
+		detectProcessBuiltinModuleCalls,
+	).filter(({ moduleSystem }) => moduleSystems.includes(moduleSystem));
 }
 
 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/tsc/parse.mjs

@@ -7,8 +7,8 @@ import getExtension from "#utl/get-extension.mjs";
 
 /** @type {import('typescript')} */
 const typescript = await tryImport(
-  "typescript",
-  meta.supportedTranspilers.typescript,
+	"typescript",
+	meta.supportedTranspilers.typescript,
 );
 
 /**
@@ -20,17 +20,17 @@ const typescript = await tryImport(
  * @return {object} - a (typescript) AST
  */
 export function getASTFromSource(pFileRecord, pTranspileOptions) {
-  let lSource = pFileRecord.source;
-  if (pFileRecord.extension === ".vue") {
-    lSource = transpile(pFileRecord, pTranspileOptions);
-  }
+	let lSource = pFileRecord.source;
+	if (pFileRecord.extension === ".vue") {
+		lSource = transpile(pFileRecord, pTranspileOptions);
+	}
 
-  return typescript.createSourceFile(
-    pFileRecord.filename || "$internal-file-name",
-    lSource,
-    typescript.ScriptTarget.Latest,
-    false,
-  );
+	return typescript.createSourceFile(
+		pFileRecord.filename || "$internal-file-name",
+		lSource,
+		typescript.ScriptTarget.Latest,
+		false,
+	);
 }
 
 /**
@@ -43,14 +43,14 @@ export function getASTFromSource(pFileRecord, pTranspileOptions) {
  * @return {object} - a (typescript) AST
  */
 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,
+	);
 }
 
 /**
@@ -70,5 +70,5 @@ export const getASTCached = memoize(getAST);
 export const isAvailable = () => typescript !== false;
 
 export function clearCache() {
-  memoizeClear(getASTCached);
+	memoizeClear(getASTCached);
 }

package/src/graph-utl/add-focus.mjs

@@ -2,23 +2,23 @@ import IndexedModuleGraph from "./indexed-module-graph.mjs";
 import { moduleMatchesFilter } from "./match-facade.mjs";
 
 function getFocusModules(pModules, pFilter) {
-  return pModules.filter((pModule) => moduleMatchesFilter(pModule, pFilter));
+	return pModules.filter((pModule) => moduleMatchesFilter(pModule, pFilter));
 }
 
 function tag(pModuleNamesSet) {
-  return (pModule) => ({
-    ...pModule,
-    matchesFocus: pModuleNamesSet.has(pModule.source),
-  });
+	return (pModule) => ({
+		...pModule,
+		matchesFocus: pModuleNamesSet.has(pModule.source),
+	});
 }
 
 function scrub(pModuleNamesSet) {
-  return (pModule) => ({
-    ...pModule,
-    dependencies: pModule.dependencies.filter(({ resolved }) =>
-      pModuleNamesSet.has(resolved),
-    ),
-  });
+	return (pModule) => ({
+		...pModule,
+		dependencies: pModule.dependencies.filter(({ resolved }) =>
+			pModuleNamesSet.has(resolved),
+		),
+	});
 }
 
 /**
@@ -28,31 +28,31 @@ function scrub(pModuleNamesSet) {
  * @returns
  */
 export default function addFocus(pModules, pFilter) {
-  if (pFilter?.path) {
-    const lDepth = typeof pFilter.depth === "undefined" ? 1 : pFilter.depth;
-    const lFocusedModuleNames = getFocusModules(pModules, pFilter).map(
-      ({ source }) => source,
-    );
-    let lReachableModuleNamesArray = [];
-    let lIndexedModules = new IndexedModuleGraph(pModules);
+	if (pFilter?.path) {
+		const lDepth = typeof pFilter.depth === "undefined" ? 1 : pFilter.depth;
+		const lFocusedModuleNames = getFocusModules(pModules, pFilter).map(
+			({ source }) => source,
+		);
+		let lReachableModuleNamesArray = [];
+		let lIndexedModules = new IndexedModuleGraph(pModules);
 
-    for (let lFocusedModule of lFocusedModuleNames) {
-      lReachableModuleNamesArray = lReachableModuleNamesArray
-        .concat(
-          lIndexedModules.findTransitiveDependents(lFocusedModule, lDepth),
-        )
-        .concat(
-          lIndexedModules.findTransitiveDependencies(lFocusedModule, lDepth),
-        );
-    }
+		for (const lFocusedModule of lFocusedModuleNames) {
+			lReachableModuleNamesArray = lReachableModuleNamesArray
+				.concat(
+					lIndexedModules.findTransitiveDependents(lFocusedModule, lDepth),
+				)
+				.concat(
+					lIndexedModules.findTransitiveDependencies(lFocusedModule, lDepth),
+				);
+		}
 
-    const lFocusedModuleNamesSet = new Set(lFocusedModuleNames);
-    const lReachableModuleNamesSet = new Set(lReachableModuleNamesArray);
+		const lFocusedModuleNamesSet = new Set(lFocusedModuleNames);
+		const lReachableModuleNamesSet = new Set(lReachableModuleNamesArray);
 
-    return pModules
-      .filter(({ source }) => lReachableModuleNamesSet.has(source))
-      .map(scrub(lReachableModuleNamesSet))
-      .map(tag(lFocusedModuleNamesSet));
-  }
-  return pModules;
+		return pModules
+			.filter(({ source }) => lReachableModuleNamesSet.has(source))
+			.map(scrub(lReachableModuleNamesSet))
+			.map(tag(lFocusedModuleNamesSet));
+	}
+	return pModules;
 }

package/src/graph-utl/compare.mjs

@@ -1,40 +1,40 @@
 /* eslint-disable no-magic-numbers */
 function severity2number(pSeverity) {
-  const lSeverity2Number = new Map([
-    ["error", 1],
-    ["warn", 2],
-    ["info", 3],
-    ["ignore", 4],
-  ]);
+	const lSeverity2Number = new Map([
+		["error", 1],
+		["warn", 2],
+		["info", 3],
+		["ignore", 4],
+	]);
 
-  return lSeverity2Number.get(pSeverity) || -1;
+	return lSeverity2Number.get(pSeverity) || -1;
 }
 
 export function compareSeverities(pFirstSeverity, pSecondSeverity) {
-  return Math.sign(
-    severity2number(pFirstSeverity) - severity2number(pSecondSeverity),
-  );
+	return Math.sign(
+		severity2number(pFirstSeverity) - severity2number(pSecondSeverity),
+	);
 }
 
 export function compareViolations(pFirstViolation, pSecondViolation) {
-  return (
-    compareSeverities(
-      pFirstViolation.rule.severity,
-      pSecondViolation.rule.severity,
-    ) ||
-    pFirstViolation.rule.name.localeCompare(pSecondViolation.rule.name) ||
-    pFirstViolation.from.localeCompare(pSecondViolation.from) ||
-    pFirstViolation.to.localeCompare(pSecondViolation.to)
-  );
+	return (
+		compareSeverities(
+			pFirstViolation.rule.severity,
+			pSecondViolation.rule.severity,
+		) ||
+		pFirstViolation.rule.name.localeCompare(pSecondViolation.rule.name) ||
+		pFirstViolation.from.localeCompare(pSecondViolation.from) ||
+		pFirstViolation.to.localeCompare(pSecondViolation.to)
+	);
 }
 
 export function compareRules(pLeftRule, pRightRule) {
-  return (
-    compareSeverities(pLeftRule.severity, pRightRule.severity) ||
-    pLeftRule.name.localeCompare(pRightRule.name)
-  );
+	return (
+		compareSeverities(pLeftRule.severity, pRightRule.severity) ||
+		pLeftRule.name.localeCompare(pRightRule.name)
+	);
 }
 
 export function compareModules(pLeftModule, pRightModule) {
-  return pLeftModule.source > pRightModule.source ? 1 : -1;
+	return pLeftModule.source > pRightModule.source ? 1 : -1;
 }

package/src/graph-utl/consolidate-module-dependencies.mjs

@@ -6,31 +6,31 @@ import { uniq } from "#utl/array-util.mjs";
  */
 
 function mergeDependency(pLeftDependency, pRightDependency) {
-  return {
-    ...pLeftDependency,
-    ...pRightDependency,
-    dependencyTypes: uniq(
-      pLeftDependency.dependencyTypes.concat(pRightDependency.dependencyTypes),
-    ),
-    rules: pLeftDependency.rules
-      .concat(pRightDependency?.rules ?? [])
-      .sort(compareRules),
-    valid: pLeftDependency.valid && pRightDependency.valid,
-  };
+	return {
+		...pLeftDependency,
+		...pRightDependency,
+		dependencyTypes: uniq(
+			pLeftDependency.dependencyTypes.concat(pRightDependency.dependencyTypes),
+		),
+		rules: pLeftDependency.rules
+			.concat(pRightDependency?.rules ?? [])
+			.sort(compareRules),
+		valid: pLeftDependency.valid && pRightDependency.valid,
+	};
 }
 
 function mergeDependencies(pResolvedName, pDependencies) {
-  let lReturnValue = {
-    dependencyTypes: [],
-    rules: [],
-    valid: true,
-  };
-  for (const lDependency of pDependencies) {
-    if (lDependency.resolved === pResolvedName) {
-      lReturnValue = mergeDependency(lReturnValue, lDependency);
-    }
-  }
-  return lReturnValue;
+	let lReturnValue = {
+		dependencyTypes: [],
+		rules: [],
+		valid: true,
+	};
+	for (const lDependency of pDependencies) {
+		if (lDependency.resolved === pResolvedName) {
+			lReturnValue = mergeDependency(lReturnValue, lDependency);
+		}
+	}
+	return lReturnValue;
 }
 
 /**
@@ -38,17 +38,17 @@ function mergeDependencies(pResolvedName, pDependencies) {
  * @returns {IDependency[]}
  */
 function consolidateDependencies(pDependencies) {
-  const lProcessed = new Set();
-  const lReturnValue = [];
+	const lProcessed = new Set();
+	const lReturnValue = [];
 
-  for (const lDependency of pDependencies) {
-    if (!lProcessed.has(lDependency.resolved)) {
-      lReturnValue.push(mergeDependencies(lDependency.resolved, pDependencies));
-      lProcessed.add(lDependency.resolved);
-    }
-  }
+	for (const lDependency of pDependencies) {
+		if (!lProcessed.has(lDependency.resolved)) {
+			lReturnValue.push(mergeDependencies(lDependency.resolved, pDependencies));
+			lProcessed.add(lDependency.resolved);
+		}
+	}
 
-  return lReturnValue;
+	return lReturnValue;
 }
 
 /**
@@ -56,8 +56,8 @@ function consolidateDependencies(pDependencies) {
  * @returns {IModule}
  */
 export default function consolidateModuleDependencies(pModule) {
-  return {
-    ...pModule,
-    dependencies: consolidateDependencies(pModule.dependencies),
-  };
+	return {
+		...pModule,
+		dependencies: consolidateDependencies(pModule.dependencies),
+	};
 }

package/src/graph-utl/consolidate-modules.mjs

@@ -2,45 +2,45 @@ import { compareRules } from "./compare.mjs";
 import { uniqBy } from "#utl/array-util.mjs";
 
 function mergeModule(pLeftModule, pRightModule) {
-  return {
-    ...pLeftModule,
-    ...pRightModule,
-    dependencies: uniqBy(
-      pLeftModule.dependencies.concat(pRightModule.dependencies),
-      (pDependency) => pDependency.resolved,
-    ),
-    rules: pLeftModule.rules
-      .concat(pRightModule?.rules ?? [])
-      .sort(compareRules),
-    valid: pLeftModule.valid && pRightModule.valid,
-    consolidated: pLeftModule.consolidated || pRightModule.consolidated,
-  };
+	return {
+		...pLeftModule,
+		...pRightModule,
+		dependencies: uniqBy(
+			pLeftModule.dependencies.concat(pRightModule.dependencies),
+			(pDependency) => pDependency.resolved,
+		),
+		rules: pLeftModule.rules
+			.concat(pRightModule?.rules ?? [])
+			.sort(compareRules),
+		valid: pLeftModule.valid && pRightModule.valid,
+		consolidated: pLeftModule.consolidated || pRightModule.consolidated,
+	};
 }
 
 function mergeModules(pSourceString, pModules) {
-  let lReturnValue = {
-    dependencies: [],
-    rules: [],
-    valid: true,
-  };
+	let lReturnValue = {
+		dependencies: [],
+		rules: [],
+		valid: true,
+	};
 
-  for (const lModule of pModules) {
-    if (lModule.source === pSourceString) {
-      lReturnValue = mergeModule(lReturnValue, lModule);
-    }
-  }
-  return lReturnValue;
+	for (const lModule of pModules) {
+		if (lModule.source === pSourceString) {
+			lReturnValue = mergeModule(lReturnValue, lModule);
+		}
+	}
+	return lReturnValue;
 }
 
 export default function consolidateModules(pModules) {
-  const lProcessed = new Set();
-  const lReturnValue = [];
+	const lProcessed = new Set();
+	const lReturnValue = [];
 
-  for (const lModule of pModules) {
-    if (!lProcessed.has(lModule.source)) {
-      lReturnValue.push(mergeModules(lModule.source, pModules));
-      lProcessed.add(lModule.source);
-    }
-  }
-  return lReturnValue;
+	for (const lModule of pModules) {
+		if (!lProcessed.has(lModule.source)) {
+			lReturnValue.push(mergeModules(lModule.source, pModules));
+			lProcessed.add(lModule.source);
+		}
+	}
+	return lReturnValue;
 }

package/src/graph-utl/consolidate-to-folder.mjs

@@ -3,22 +3,22 @@ import consolidateModules from "./consolidate-modules.mjs";
 import consolidateModuleDependencies from "./consolidate-module-dependencies.mjs";
 
 function squashDependencyToDirectory(pDependency) {
-  return {
-    ...pDependency,
-    resolved: dirname(pDependency.resolved),
-  };
+	return {
+		...pDependency,
+		resolved: dirname(pDependency.resolved),
+	};
 }
 function squashModuleToDirectory(pModule) {
-  return {
-    ...pModule,
-    source: dirname(pModule.source),
-    consolidated: true,
-    dependencies: pModule.dependencies.map(squashDependencyToDirectory),
-  };
+	return {
+		...pModule,
+		source: dirname(pModule.source),
+		consolidated: true,
+		dependencies: pModule.dependencies.map(squashDependencyToDirectory),
+	};
 }
 
 export default function consolidateToFolder(pModules) {
-  return consolidateModules(pModules.map(squashModuleToDirectory)).map(
-    consolidateModuleDependencies,
-  );
+	return consolidateModules(pModules.map(squashModuleToDirectory)).map(
+		consolidateModuleDependencies,
+	);
 }

package/src/graph-utl/consolidate-to-pattern.mjs

@@ -2,50 +2,50 @@ import consolidateModules from "./consolidate-modules.mjs";
 import consolidateModuleDependencies from "./consolidate-module-dependencies.mjs";
 
 function squashDependencyToPattern(pCollapsePattern) {
-  return (pDependency) => {
-    const lCollapseMatch = pDependency.resolved.match(pCollapsePattern);
+	return (pDependency) => {
+		const lCollapseMatch = pDependency.resolved.match(pCollapsePattern);
 
-    return {
-      ...pDependency,
-      resolved: lCollapseMatch ? lCollapseMatch[0] : pDependency.resolved,
-    };
-  };
+		return {
+			...pDependency,
+			resolved: lCollapseMatch ? lCollapseMatch[0] : pDependency.resolved,
+		};
+	};
 }
 
 function determineConsolidatedness(pConsolidated, pCollapseMatch, pSource) {
-  let lReturnValue = false;
+	let lReturnValue = false;
 
-  // if it was  already established it's consolidated (e.g. from an earlier
-  // consolidation step) there's no need to recalc
-  if (pConsolidated === true) {
-    lReturnValue = true;
-  } else {
-    lReturnValue = pCollapseMatch ? pCollapseMatch[0] !== pSource : false;
-  }
-  return lReturnValue;
+	// if it was  already established it's consolidated (e.g. from an earlier
+	// consolidation step) there's no need to recalc
+	if (pConsolidated === true) {
+		lReturnValue = true;
+	} else {
+		lReturnValue = pCollapseMatch ? pCollapseMatch[0] !== pSource : false;
+	}
+	return lReturnValue;
 }
 
 function squashModuleToPattern(pCollapsePattern) {
-  return (pModule) => {
-    const lCollapseMatch = pModule.source.match(pCollapsePattern);
+	return (pModule) => {
+		const lCollapseMatch = pModule.source.match(pCollapsePattern);
 
-    return {
-      ...pModule,
-      source: lCollapseMatch ? lCollapseMatch[0] : pModule.source,
-      consolidated: determineConsolidatedness(
-        pModule.consolidated,
-        lCollapseMatch,
-        pModule.source,
-      ),
-      dependencies: pModule.dependencies.map(
-        squashDependencyToPattern(pCollapsePattern),
-      ),
-    };
-  };
+		return {
+			...pModule,
+			source: lCollapseMatch ? lCollapseMatch[0] : pModule.source,
+			consolidated: determineConsolidatedness(
+				pModule.consolidated,
+				lCollapseMatch,
+				pModule.source,
+			),
+			dependencies: pModule.dependencies.map(
+				squashDependencyToPattern(pCollapsePattern),
+			),
+		};
+	};
 }
 
 export default function consolidateToPattern(pModules, pCollapsePattern) {
-  return consolidateModules(
-    pModules.map(squashModuleToPattern(pCollapsePattern)),
-  ).map(consolidateModuleDependencies);
+	return consolidateModules(
+		pModules.map(squashModuleToPattern(pCollapsePattern)),
+	).map(consolidateModuleDependencies);
 }