dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/utl/array-util.mjs

@@ -7,17 +7,17 @@
  * @return {boolean} true if there's at least one element in pLeftArray also in pRightArray
  */
 export function intersects(pLeftArray, pRightArray) {
-  if (pLeftArray.length === 0 || pRightArray.length === 0) {
-    return false;
-  }
-  if (pRightArray.length < pLeftArray.length) {
-    return pRightArray.some((pItem) => pLeftArray.includes(pItem));
-  }
-  return pLeftArray.some((pItem) => pRightArray.includes(pItem));
+	if (pLeftArray.length === 0 || pRightArray.length === 0) {
+		return false;
+	}
+	if (pRightArray.length < pLeftArray.length) {
+		return pRightArray.some((pItem) => pLeftArray.includes(pItem));
+	}
+	return pLeftArray.some((pItem) => pRightArray.includes(pItem));
 }
 
 export function uniq(pArray) {
-  return [...new Set(pArray)];
+	return [...new Set(pArray)];
 }
 
 /**
@@ -26,18 +26,18 @@ export function uniq(pArray) {
  * @returns {any[]}
  */
 export function uniqBy(pArray, pIteratee) {
-  const lSeen = new Map();
-  const lResult = [];
+	const lSeen = new Map();
+	const lResult = [];
 
-  for (const lElement of pArray) {
-    const lKey = pIteratee(lElement);
-    if (!lSeen.has(lKey)) {
-      lSeen.set(lKey, true);
-      lResult.push(lElement);
-    }
-  }
+	for (const lElement of pArray) {
+		const lKey = pIteratee(lElement);
+		if (!lSeen.has(lKey)) {
+			lSeen.set(lKey, true);
+			lResult.push(lElement);
+		}
+	}
 
-  return lResult;
+	return lResult;
 }
 
 /**
@@ -46,13 +46,13 @@ export function uniqBy(pArray, pIteratee) {
  * @returns {any[]}
  */
 export function uniqWith(pArray, pComparator) {
-  const lResult = [];
+	const lResult = [];
 
-  for (const lElement of pArray) {
-    if (!lResult.some((pY) => pComparator(lElement, pY))) {
-      lResult.push(lElement);
-    }
-  }
+	for (const lElement of pArray) {
+		if (!lResult.some((pY) => pComparator(lElement, pY))) {
+			lResult.push(lElement);
+		}
+	}
 
-  return lResult;
+	return lResult;
 }

package/src/utl/bus.mjs

@@ -9,21 +9,21 @@ export const EXTRA_STRONG = 80;
 export const ALL = 99;
 
 class Bus extends EventEmitter {
-  progress(pMessage, pOptions, ...pArguments) {
-    this.emit("progress", pMessage, pOptions, pArguments);
-  }
+	progress(pMessage, pOptions, ...pArguments) {
+		this.emit("progress", pMessage, pOptions, pArguments);
+	}
 
-  summary(pMessage, pOptions, ...pArguments) {
-    this.progress(pMessage, { ...pOptions, level: SUMMARY }, pArguments);
-  }
+	summary(pMessage, pOptions, ...pArguments) {
+		this.progress(pMessage, { ...pOptions, level: SUMMARY }, pArguments);
+	}
 
-  info(pMessage, pOptions, ...pArguments) {
-    this.progress(pMessage, { ...pOptions, level: INFO }, pArguments);
-  }
+	info(pMessage, pOptions, ...pArguments) {
+		this.progress(pMessage, { ...pOptions, level: INFO }, pArguments);
+	}
 
-  debug(pMessage, pOptions, ...pArguments) {
-    this.progress(pMessage, { ...pOptions, level: DEBUG }, pArguments);
-  }
+	debug(pMessage, pOptions, ...pArguments) {
+		this.progress(pMessage, { ...pOptions, level: DEBUG }, pArguments);
+	}
 }
 
 export const bus = new Bus();

package/src/utl/extract-root-module-name.cjs

@@ -12,12 +12,12 @@ const ROOT_MODULE_RE = new RegExp(`^(${SCOPED_PACKAGE_RE}|${PACKAGE_RE})`, "g");
  * @returns {string|undefined} the module name that likely contains the package.json
  */
 module.exports = function extractRootModuleName(pModuleName) {
-  if (
-    pModuleName.match(LOCAL_MODULE_RE) ||
-    pModuleName.match(ABSOLUTE_MODULE_RE)
-  ) {
-    return pModuleName;
-  } else {
-    return (pModuleName.match(ROOT_MODULE_RE) || []).shift();
-  }
+	if (
+		pModuleName.match(LOCAL_MODULE_RE) ||
+		pModuleName.match(ABSOLUTE_MODULE_RE)
+	) {
+		return pModuleName;
+	} else {
+		return (pModuleName.match(ROOT_MODULE_RE) || []).shift();
+	}
 };

package/src/utl/find-all-files.mjs

@@ -13,10 +13,10 @@ import pathToPosix from "./path-to-posix.mjs";
  * @returns {boolean}
  */
 function fileIsDirectory(pFullPathToFile, pBaseDirectory) {
-  const lStat = statSync(join(pBaseDirectory, pFullPathToFile), {
-    throwIfNoEntry: false,
-  });
-  return lStat?.isDirectory() ?? false;
+	const lStat = statSync(join(pBaseDirectory, pFullPathToFile), {
+		throwIfNoEntry: false,
+	});
+	return lStat?.isDirectory() ?? false;
 }
 
 /**
@@ -25,40 +25,40 @@ function fileIsDirectory(pFullPathToFile, pBaseDirectory) {
  * @returns {string[]}
  */
 function walk(
-  pDirectoryName,
-  { baseDir, ignoreFilterFn, excludeFilterFn, includeOnlyFilterFn },
+	pDirectoryName,
+	{ baseDir, ignoreFilterFn, excludeFilterFn, includeOnlyFilterFn },
 ) {
-  const lFilesInCurrentDirectory = readdirSync(join(baseDir, pDirectoryName))
-    .map((pFileName) => join(pDirectoryName, pFileName))
-    .filter(ignoreFilterFn)
-    .filter(excludeFilterFn)
-    .filter(includeOnlyFilterFn);
+	const lFilesInCurrentDirectory = readdirSync(join(baseDir, pDirectoryName))
+		.map((pFileName) => join(pDirectoryName, pFileName))
+		.filter(ignoreFilterFn)
+		.filter(excludeFilterFn)
+		.filter(includeOnlyFilterFn);
 
-  const lFiles = [];
-  for (const lFile of lFilesInCurrentDirectory) {
-    if (fileIsDirectory(lFile, baseDir)) {
-      lFiles.push(
-        ...walk(lFile, {
-          baseDir,
-          ignoreFilterFn,
-          excludeFilterFn,
-          includeOnlyFilterFn,
-        }),
-      );
-    } else {
-      lFiles.push(pathToPosix(lFile));
-    }
-  }
+	const lFiles = [];
+	for (const lFile of lFilesInCurrentDirectory) {
+		if (fileIsDirectory(lFile, baseDir)) {
+			lFiles.push(
+				...walk(lFile, {
+					baseDir,
+					ignoreFilterFn,
+					excludeFilterFn,
+					includeOnlyFilterFn,
+				}),
+			);
+		} else {
+			lFiles.push(pathToPosix(lFile));
+		}
+	}
 
-  return lFiles;
+	return lFiles;
 }
 
 function readIgnoreFile(pFileName) {
-  try {
-    return readFileSync(pFileName, "utf8");
-  } catch (pError) {
-    return "";
-  }
+	try {
+		return readFileSync(pFileName, "utf8");
+	} catch (pError) {
+		return "";
+	}
 }
 
 /**
@@ -66,7 +66,7 @@ function readIgnoreFile(pFileName) {
  */
 
 function identityFilter(_pString, _pIndex, _pArray) {
-  return true;
+	return true;
 }
 
 /**
@@ -75,27 +75,27 @@ function identityFilter(_pString, _pIndex, _pArray) {
  * @returns {string[]}
  */
 export default function findAllFiles(
-  pDirectoryName,
-  {
-    baseDir,
-    ignoreFileContents,
-    additionalIgnorePatterns,
-    excludeFilterFn,
-    includeOnlyFilterFn,
-  },
+	pDirectoryName,
+	{
+		baseDir,
+		ignoreFileContents,
+		additionalIgnorePatterns,
+		excludeFilterFn,
+		includeOnlyFilterFn,
+	},
 ) {
-  const lIgnoreFileContents =
-    ignoreFileContents ?? readIgnoreFile(join(baseDir, ".gitignore"));
-  const lAdditionalIgnorePatterns = additionalIgnorePatterns ?? [".git"];
-  const lIgnoreFilterFunction = ignore()
-    .add(lIgnoreFileContents)
-    .add(lAdditionalIgnorePatterns)
-    .createFilter();
+	const lIgnoreFileContents =
+		ignoreFileContents ?? readIgnoreFile(join(baseDir, ".gitignore"));
+	const lAdditionalIgnorePatterns = additionalIgnorePatterns ?? [".git"];
+	const lIgnoreFilterFunction = ignore()
+		.add(lIgnoreFileContents)
+		.add(lAdditionalIgnorePatterns)
+		.createFilter();
 
-  return walk(pDirectoryName, {
-    baseDir,
-    ignoreFilterFn: lIgnoreFilterFunction,
-    excludeFilterFn: excludeFilterFn ?? identityFilter,
-    includeOnlyFilterFn: includeOnlyFilterFn ?? identityFilter,
-  });
+	return walk(pDirectoryName, {
+		baseDir,
+		ignoreFilterFn: lIgnoreFilterFunction,
+		excludeFilterFn: excludeFilterFn ?? identityFilter,
+		includeOnlyFilterFn: includeOnlyFilterFn ?? identityFilter,
+	});
 }

package/src/utl/get-extension.mjs

@@ -16,7 +16,7 @@ const EXTENSION_RE = /(?<extension>(?:(?:\.d\.(?:[cm])?ts)|\.coffee\.md)$)/;
  * @return {string}          extension
  */
 export default function getExtension(pFileName) {
-  const lMatchResult = pFileName.match(EXTENSION_RE);
+	const lMatchResult = pFileName.match(EXTENSION_RE);
 
-  return lMatchResult?.groups?.extension ?? extname(pFileName);
+	return lMatchResult?.groups?.extension ?? extname(pFileName);
 }

package/src/utl/object-util.mjs

@@ -1,33 +1,32 @@
 /* eslint-disable security/detect-object-injection */
 
 export function get(pObject, pPath, pDefault) {
-  if (!pObject || !pPath) {
-    return pDefault;
-  }
-  // Regex explained: https://regexr.com/58j0k
-  const lPathArray = pPath.match(/([^[.\]])+/g);
+	if (!pObject || !pPath) {
+		return pDefault;
+	}
+	const lPathArray = pPath.match(/([^[.\]])+/g);
 
-  const lReturnValue = lPathArray.reduce((pPreviousObject, pKey) => {
-    return pPreviousObject && pPreviousObject[pKey];
-  }, pObject);
+	const lReturnValue = lPathArray.reduce((pPreviousObject, pKey) => {
+		return pPreviousObject && pPreviousObject[pKey];
+	}, pObject);
 
-  if (!lReturnValue) {
-    return pDefault;
-  }
-  return lReturnValue;
+	if (!lReturnValue) {
+		return pDefault;
+	}
+	return lReturnValue;
 }
 
 export function set(pObject, pPath, pValue) {
-  const lPathArray = pPath.match(/([^[.\]])+/g);
+	const lPathArray = pPath.match(/([^[.\]])+/g);
 
-  lPathArray.reduce((pPreviousObject, pKey, pIndex) => {
-    if (pIndex === lPathArray.length - 1) {
-      pPreviousObject[pKey] = pValue;
-    } else if (!pPreviousObject[pKey]) {
-      pPreviousObject[pKey] = {};
-    }
-    return pPreviousObject[pKey];
-  }, pObject);
+	lPathArray.reduce((pPreviousObject, pKey, pIndex) => {
+		if (pIndex === lPathArray.length - 1) {
+			pPreviousObject[pKey] = pValue;
+		} else if (!pPreviousObject[pKey]) {
+			pPreviousObject[pKey] = {};
+		}
+		return pPreviousObject[pKey];
+	}, pObject);
 }
 
 /**
@@ -36,5 +35,5 @@ export function set(pObject, pPath, pValue) {
  * @returns {boolean}
  */
 export function has(pObject, pPath) {
-  return Boolean(get(pObject, pPath));
+	return Boolean(get(pObject, pPath));
 }

package/src/utl/path-to-posix.mjs

@@ -20,11 +20,11 @@ import path from "node:path";
  * @return {string}             the transformed path
  */
 export default function pathToPosix(pFilePath, pPathModule = path) {
-  const lPathModule = pPathModule || path;
+	const lPathModule = pPathModule || path;
 
-  if (lPathModule.sep !== path.posix.sep) {
-    return pFilePath.split(lPathModule.sep).join(path.posix.sep);
-  }
+	if (lPathModule.sep !== path.posix.sep) {
+		return pFilePath.split(lPathModule.sep).join(path.posix.sep);
+	}
 
-  return pFilePath;
+	return pFilePath;
 }

package/src/utl/regex-util.mjs

@@ -12,22 +12,22 @@
  * @returns {string[]|null}
  */
 export function extractGroups(pFromRestriction, pActualPath) {
-  let lReturnValue = [];
+	let lReturnValue = [];
 
-  if (pFromRestriction.path) {
-    // @ts-expect-error pFromRestriction.path can be a string | string[] | null
-    // except before it enters here it has already been 'normalized' to a string
-    // so it can be safely passed to match. The right solution here (TODO)
-    // is to create a separate type for NormalizedFromRestriction
-    let lMatchResult = pActualPath.match(pFromRestriction.path);
+	if (pFromRestriction.path) {
+		// @ts-expect-error pFromRestriction.path can be a string | string[] | null
+		// except before it enters here it has already been 'normalized' to a string
+		// so it can be safely passed to match. The right solution here (TODO)
+		// is to create a separate type for NormalizedFromRestriction
+		let lMatchResult = pActualPath.match(pFromRestriction.path);
 
-    if (lMatchResult && lMatchResult.length > 1) {
-      lReturnValue = lMatchResult.filter(
-        (pResult) => typeof pResult === "string",
-      );
-    }
-  }
-  return lReturnValue;
+		if (lMatchResult && lMatchResult.length > 1) {
+			lReturnValue = lMatchResult.filter(
+				(pResult) => typeof pResult === "string",
+			);
+		}
+	}
+	return lReturnValue;
 }
 
 /**
@@ -47,10 +47,10 @@ export function extractGroups(pFromRestriction, pActualPath) {
  * groups from pExtractedgroups
  */
 export function replaceGroupPlaceholders(pString, pExtractedGroups) {
-  return pExtractedGroups.reduce(
-    (pAll, pThis, pIndex) =>
-      // eslint-disable-next-line security/detect-non-literal-regexp
-      pAll.replace(new RegExp(`\\$${pIndex}`, "g"), pThis),
-    pString,
-  );
+	return pExtractedGroups.reduce(
+		(pAll, pThis, pIndex) =>
+			// eslint-disable-next-line security/detect-non-literal-regexp
+			pAll.replace(new RegExp(`\\$${pIndex}`, "g"), pThis),
+		pString,
+	);
 }

package/src/utl/try-import.mjs

@@ -11,30 +11,31 @@ const require = createRequire(import.meta.url);
  * @returns {string}
  */
 function getVersion(pModuleName) {
-  // // The 'proper' way to do this would be with a dynamic import with an
-  // // import assertion. Because it's 'experimental' since node 16 and prints
-  // // an ugly warning on stderr since node 19 we'll be using the require
-  // // hack below in stead.
-  // const lManifest = await import(
-  //   // @ts-expect-error TS2345 extractRootModuleName can return either a string or
-  //   // undefined. If undefined this function will throw. Which is _fine_, even
-  //   // _expected_ in the context it's currently used
-  //   path.join(extractRootModuleName(pModuleName), "package.json"),
-  //   { assert: { type: "json" } }
-  // );
-  // // changes the return type to Promise<string>
-  // return lManifest.default.version;
-  // eslint-disable-next-line import/no-dynamic-require, security/detect-non-literal-require
-  const lManifest = require(
-    join(
-      // @ts-expect-error TS2345 extractRootModuleName can return either a string or
-      // undefined. If undefined this function will throw. Which is _fine_, even
-      // _expected_ in the context it's currently used
-      extractRootModuleName(pModuleName),
-      "package.json",
-    ),
-  );
-  return lManifest.version;
+	// The 'proper' way to do this would be with a dynamic import with an
+	// import assertion. Because it's 'experimental' since node 16 and prints
+	// an ugly warning on stderr since node 19 we'll be using the require
+	// hack below in stead. Code would otherwise have been:
+	//
+	// const lManifest = await import(
+	//   // @ts-expect-error TS2345 extractRootModuleName can return either a string or
+	//   // undefined. If undefined this function will throw. Which is _fine_, even
+	//   // _expected_ in the context it's currently used
+	//   path.join(extractRootModuleName(pModuleName), "package.json"),
+	//   { assert: { type: "json" } }
+	// );
+	// return lManifest.default.version;
+	//
+	// eslint-disable-next-line import/no-dynamic-require, security/detect-non-literal-require
+	const lManifest = require(
+		join(
+			// @ts-expect-error TS2345 extractRootModuleName can return either a string or
+			// undefined. If undefined this function will throw. Which is _fine_, even
+			// _expected_ in the context it's currently used
+			extractRootModuleName(pModuleName),
+			"package.json",
+		),
+	);
+	return lManifest.version;
 }
 
 /**
@@ -46,21 +47,21 @@ function getVersion(pModuleName) {
  */
 
 export default async function tryImport(pModuleName, pSemanticVersion) {
-  try {
-    if (pSemanticVersion) {
-      const lVersion = getVersion(pModuleName);
-      const lCoerced = coerce(lVersion);
-      if (
-        lVersion &&
-        lCoerced &&
-        !satisfies(lCoerced.version, pSemanticVersion)
-      ) {
-        return false;
-      }
-    }
-    const lModule = await import(pModuleName);
-    return lModule.default ? lModule.default : lModule;
-  } catch (pError) {
-    return false;
-  }
+	try {
+		if (pSemanticVersion) {
+			const lVersion = getVersion(pModuleName);
+			const lCoerced = coerce(lVersion);
+			if (
+				lVersion &&
+				lCoerced &&
+				!satisfies(lCoerced.version, pSemanticVersion)
+			) {
+				return false;
+			}
+		}
+		const lModule = await import(pModuleName);
+		return lModule.default ? lModule.default : lModule;
+	} catch (pError) {
+		return false;
+	}
 }

package/src/utl/try-require.cjs

@@ -9,12 +9,12 @@ const extractRootModuleName = require("./extract-root-module-name.cjs");
  * @return the version of the module identified by pModuleName
  */
 function getVersion(pModuleName) {
-  // @ts-expect-error TS2345 extractRootModuleName can return either a string or
-  // undefined. If undefined this function will throw. Which is _fine_, even
-  // _expected_ in the context it's currently used
-  // eslint-disable-next-line import/no-dynamic-require, n/global-require, security/detect-non-literal-require
-  return require(join(extractRootModuleName(pModuleName), "package.json"))
-    .version;
+	// @ts-expect-error TS2345 extractRootModuleName can return either a string or
+	// undefined. If undefined this function will throw. Which is _fine_, even
+	// _expected_ in the context it's currently used
+	// eslint-disable-next-line import/no-dynamic-require, n/global-require, security/detect-non-literal-require
+	return require(join(extractRootModuleName(pModuleName), "package.json"))
+		.version;
 }
 
 /**
@@ -29,23 +29,23 @@ function getVersion(pModuleName) {
  * @return {NodeModule | false }the (resolved) module identified by pModuleName or false
  */
 function tryRequire(pModuleName, pSemanticVersion) {
-  try {
-    if (pSemanticVersion) {
-      const lVersion = getVersion(pModuleName);
-      const lCoerced = coerce(lVersion);
-      if (
-        lVersion &&
-        lCoerced &&
-        !satisfies(lCoerced.version, pSemanticVersion)
-      ) {
-        return false;
-      }
-    }
-    // eslint-disable-next-line import/no-dynamic-require, n/global-require, security/detect-non-literal-require
-    return require(pModuleName);
-  } catch (pError) {
-    return false;
-  }
+	try {
+		if (pSemanticVersion) {
+			const lVersion = getVersion(pModuleName);
+			const lCoerced = coerce(lVersion);
+			if (
+				lVersion &&
+				lCoerced &&
+				!satisfies(lCoerced.version, pSemanticVersion)
+			) {
+				return false;
+			}
+		}
+		// eslint-disable-next-line import/no-dynamic-require, n/global-require, security/detect-non-literal-require
+		return require(pModuleName);
+	} catch (pError) {
+		return false;
+	}
 }
 
 module.exports = tryRequire;

package/src/utl/wrap-and-indent.mjs

@@ -1,9 +1,9 @@
 const DEFAULT_INDENT = 4;
 
 function indentString(pString, pCount) {
-  const lRegex = /^(?!\s*$)/gm;
+	const lRegex = /^(?!\s*$)/gm;
 
-  return pString.replace(lRegex, " ".repeat(pCount));
+	return pString.replace(lRegex, " ".repeat(pCount));
 }
 
 /**
@@ -11,30 +11,30 @@ function indentString(pString, pCount) {
  * @param {number} pMaxWidth
  */
 function splitLine(pLine, pMaxWidth) {
-  const lWords = pLine.split(" ");
-  const lWrappedLines = [];
-  let lCurrentLine = "";
-  let lCurrentWidth = 0;
-
-  for (const lWord of lWords) {
-    if (lCurrentWidth + lWord.length > pMaxWidth) {
-      lWrappedLines.push(lCurrentLine.trimEnd());
-      lCurrentLine = "";
-      lCurrentWidth = 0;
-    }
-
-    if (lCurrentLine) {
-      lCurrentLine += " ";
-      lCurrentWidth += 1;
-    }
-
-    lCurrentLine += lWord;
-    lCurrentWidth += lWord.length;
-  }
-
-  lWrappedLines.push(lCurrentLine.trimEnd());
-
-  return lWrappedLines.join("\n");
+	const lWords = pLine.split(" ");
+	const lWrappedLines = [];
+	let lCurrentLine = "";
+	let lCurrentWidth = 0;
+
+	for (const lWord of lWords) {
+		if (lCurrentWidth + lWord.length > pMaxWidth) {
+			lWrappedLines.push(lCurrentLine.trimEnd());
+			lCurrentLine = "";
+			lCurrentWidth = 0;
+		}
+
+		if (lCurrentLine) {
+			lCurrentLine += " ";
+			lCurrentWidth += 1;
+		}
+
+		lCurrentLine += lWord;
+		lCurrentWidth += lWord.length;
+	}
+
+	lWrappedLines.push(lCurrentLine.trimEnd());
+
+	return lWrappedLines.join("\n");
 }
 
 /**
@@ -42,15 +42,15 @@ function splitLine(pLine, pMaxWidth) {
  * @param {number} pMaxWidth - the maximum width of the wrapped string
  */
 function wrapString(pString, pMaxWidth) {
-  return pString
-    .split(/\r?\n/)
-    .map((pLine) => splitLine(pLine, pMaxWidth))
-    .join("\n");
+	return pString
+		.split(/\r?\n/)
+		.map((pLine) => splitLine(pLine, pMaxWidth))
+		.join("\n");
 }
 
 export default function wrapAndIndent(pString, pIndent = DEFAULT_INDENT) {
-  const lMaxConsoleWidth = 78;
-  const lMaxWidth = lMaxConsoleWidth - pIndent;
+	const lMaxConsoleWidth = 78;
+	const lMaxWidth = lMaxConsoleWidth - pIndent;
 
-  return indentString(wrapString(pString, lMaxWidth), pIndent);
+	return indentString(wrapString(pString, lMaxWidth), pIndent);
 }