dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/graph-utl/match-facade.mjs

@@ -1,11 +1,11 @@
 export function filenameMatchesPattern(pFullPathToFile, pPattern) {
-  return RegExp(pPattern, "g").test(pFullPathToFile);
+	return RegExp(pPattern, "g").test(pFullPathToFile);
 }
 
 export function moduleMatchesFilter(pModule, pFilter) {
-  return filenameMatchesPattern(pModule.source, pFilter.path);
+	return filenameMatchesPattern(pModule.source, pFilter.path);
 }
 
 export function dependencyMatchesFilter(pDependency, pFilter) {
-  return filenameMatchesPattern(pDependency.resolved, pFilter.path);
+	return filenameMatchesPattern(pDependency.resolved, pFilter.path);
 }

package/src/graph-utl/rule-set.mjs

@@ -14,17 +14,17 @@
  * @return {IForbiddenRuleType|undefined} - a rule (or 'undefined' if nothing found)
  */
 export function findRuleByName(pRuleSet, pName) {
-  const lNamedRules = (pRuleSet?.forbidden ?? []).concat(
-    pRuleSet?.required ?? [],
-  );
-  return lNamedRules.find((pRule) => pRule.name === pName);
+	const lNamedRules = (pRuleSet?.forbidden ?? []).concat(
+		pRuleSet?.required ?? [],
+	);
+	return lNamedRules.find((pRule) => pRule.name === pName);
 }
 
 function ruleHasALicenseLikeAttribute(pRule) {
-  return (
-    Object.hasOwn(pRule?.to ?? {}, "license") ||
-    Object.hasOwn(pRule?.to ?? {}, "licenseNot")
-  );
+	return (
+		Object.hasOwn(pRule?.to ?? {}, "license") ||
+		Object.hasOwn(pRule?.to ?? {}, "licenseNot")
+	);
 }
 
 /**
@@ -37,10 +37,10 @@ function ruleHasALicenseLikeAttribute(pRule) {
  * @return {boolean}
  */
 export function ruleSetHasLicenseRule(pRuleSet) {
-  return (
-    (pRuleSet?.forbidden ?? []).some(ruleHasALicenseLikeAttribute) ||
-    (pRuleSet?.allowed ?? []).some(ruleHasALicenseLikeAttribute)
-  );
+	return (
+		(pRuleSet?.forbidden ?? []).some(ruleHasALicenseLikeAttribute) ||
+		(pRuleSet?.allowed ?? []).some(ruleHasALicenseLikeAttribute)
+	);
 }
 
 /**
@@ -48,12 +48,12 @@ export function ruleSetHasLicenseRule(pRuleSet) {
  * @return {boolean}
  */
 export function ruleSetHasDeprecationRule(pRuleSet) {
-  return (
-    (pRuleSet?.forbidden ?? []).some((pRule) =>
-      (pRule?.to?.dependencyTypes ?? []).includes("deprecated"),
-    ) ||
-    (pRuleSet?.allowed ?? []).some((pRule) =>
-      (pRule?.to?.dependencyTypes ?? []).includes("deprecated"),
-    )
-  );
+	return (
+		(pRuleSet?.forbidden ?? []).some((pRule) =>
+			(pRule?.to?.dependencyTypes ?? []).includes("deprecated"),
+		) ||
+		(pRuleSet?.allowed ?? []).some((pRule) =>
+			(pRule?.to?.dependencyTypes ?? []).includes("deprecated"),
+		)
+	);
 }

package/src/graph-utl/strip-self-transitions.mjs

@@ -1,8 +1,8 @@
 export default function stripSelfTransitions(pModule) {
-  return {
-    ...pModule,
-    dependencies: pModule.dependencies.filter(
-      (pDependency) => pModule.source !== pDependency.resolved,
-    ),
-  };
+	return {
+		...pModule,
+		dependencies: pModule.dependencies.filter(
+			(pDependency) => pModule.source !== pDependency.resolved,
+		),
+	};
 }

package/src/main/cruise.mjs

@@ -7,102 +7,102 @@ import { bus } from "#utl/bus.mjs";
 const TOTAL_STEPS = 10;
 
 export function c(pComplete, pTotal = TOTAL_STEPS) {
-  return { complete: pComplete / pTotal };
+	return { complete: pComplete / pTotal };
 }
 
 /** @type {import("../../types/dependency-cruiser.js").cruise} */
 // eslint-disable-next-line max-lines-per-function, max-statements
 export default async function cruise(
-  pFileAndDirectoryArray,
-  pCruiseOptions,
-  pResolveOptions,
-  pTranspileOptions,
+	pFileAndDirectoryArray,
+	pCruiseOptions,
+	pResolveOptions,
+	pTranspileOptions,
 ) {
-  bus.summary("parse options", c(1));
-  const lCruiseOptionsValid = assertCruiseOptionsValid(pCruiseOptions);
-  /** @type {import("../../types/strict-options.js").IStrictCruiseOptions} */
-  let lCruiseOptions = normalizeCruiseOptions(
-    lCruiseOptionsValid,
-    pFileAndDirectoryArray,
-  );
-  let lCache = null;
+	bus.summary("parse options", c(1));
+	const lCruiseOptionsValid = assertCruiseOptionsValid(pCruiseOptions);
+	/** @type {import("../../types/strict-options.js").IStrictCruiseOptions} */
+	let lCruiseOptions = normalizeCruiseOptions(
+		lCruiseOptionsValid,
+		pFileAndDirectoryArray,
+	);
+	let lCache = null;
 
-  if (lCruiseOptions.cache) {
-    bus.summary(
-      `cache: check freshness with ${lCruiseOptions.cache.strategy}`,
-      c(2),
-    );
+	if (lCruiseOptions.cache) {
+		bus.summary(
+			`cache: check freshness with ${lCruiseOptions.cache.strategy}`,
+			c(2),
+		);
 
-    const { default: Cache } = await import("#cache/cache.mjs");
-    lCache = new Cache(
-      lCruiseOptions.cache.strategy,
-      lCruiseOptions.cache.compress,
-    );
-    const lCachedResults = await lCache.read(lCruiseOptions.cache.folder);
+		const { default: Cache } = await import("#cache/cache.mjs");
+		lCache = new Cache(
+			lCruiseOptions.cache.strategy,
+			lCruiseOptions.cache.compress,
+		);
+		const lCachedResults = await lCache.read(lCruiseOptions.cache.folder);
 
-    if (await lCache.canServeFromCache(lCruiseOptions, lCachedResults)) {
-      bus.summary("cache: report from cache", c(8));
-      return await reportWrap(lCachedResults, lCruiseOptions);
-    }
-  }
+		if (await lCache.canServeFromCache(lCruiseOptions, lCachedResults)) {
+			bus.summary("cache: report from cache", c(8));
+			return await reportWrap(lCachedResults, lCruiseOptions);
+		}
+	}
 
-  bus.summary("import analytical modules", c(3));
-  const [
-    { default: normalizeRuleSet },
-    { default: assertRuleSetValid },
-    { default: normalizeFilesAndDirectories },
-    { default: normalizeResolveOptions },
-    { default: extract },
-    { default: enrich },
-  ] = await Promise.all([
-    // despite rule set parsing being behind an if, it's the 'normal' use case
-    // for dependency-cruiser, so import it unconditionally nonetheless
-    import("./rule-set/normalize.mjs"),
-    import("./rule-set/assert-validity.mjs"),
-    import("./files-and-dirs/normalize.mjs"),
-    import("./resolve-options/normalize.mjs"),
-    import("#extract/index.mjs"),
-    import("#enrich/index.mjs"),
-  ]);
+	bus.summary("import analytical modules", c(3));
+	const [
+		{ default: normalizeRuleSet },
+		{ default: assertRuleSetValid },
+		{ default: normalizeFilesAndDirectories },
+		{ default: normalizeResolveOptions },
+		{ default: extract },
+		{ default: enrich },
+	] = await Promise.all([
+		// despite rule set parsing being behind an if, it's the 'normal' use case
+		// for dependency-cruiser, so import it unconditionally nonetheless
+		import("./rule-set/normalize.mjs"),
+		import("./rule-set/assert-validity.mjs"),
+		import("./files-and-dirs/normalize.mjs"),
+		import("./resolve-options/normalize.mjs"),
+		import("#extract/index.mjs"),
+		import("#enrich/index.mjs"),
+	]);
 
-  if (lCruiseOptions.ruleSet) {
-    bus.summary("parse rule set", c(4));
-    lCruiseOptions.ruleSet = normalizeRuleSet(
-      assertRuleSetValid(lCruiseOptions.ruleSet),
-    );
-  }
+	if (lCruiseOptions.ruleSet) {
+		bus.summary("parse rule set", c(4));
+		lCruiseOptions.ruleSet = normalizeRuleSet(
+			assertRuleSetValid(lCruiseOptions.ruleSet),
+		);
+	}
 
-  const lNormalizedFileAndDirectoryArray = normalizeFilesAndDirectories(
-    pFileAndDirectoryArray,
-  );
+	const lNormalizedFileAndDirectoryArray = normalizeFilesAndDirectories(
+		pFileAndDirectoryArray,
+	);
 
-  bus.summary("determine how to resolve", c(5));
-  const lNormalizedResolveOptions = await normalizeResolveOptions(
-    pResolveOptions,
-    lCruiseOptions,
-    pTranspileOptions?.tsConfig,
-  );
+	bus.summary("determine how to resolve", c(5));
+	const lNormalizedResolveOptions = await normalizeResolveOptions(
+		pResolveOptions,
+		lCruiseOptions,
+		pTranspileOptions?.tsConfig,
+	);
 
-  bus.summary("read files", c(6));
-  const lExtractionResult = extract(
-    lNormalizedFileAndDirectoryArray,
-    lCruiseOptions,
-    lNormalizedResolveOptions,
-    pTranspileOptions,
-  );
+	bus.summary("read files", c(6));
+	const lExtractionResult = extract(
+		lNormalizedFileAndDirectoryArray,
+		lCruiseOptions,
+		lNormalizedResolveOptions,
+		pTranspileOptions,
+	);
 
-  bus.summary("analyze", c(7));
-  const lCruiseResult = enrich(
-    lExtractionResult,
-    lCruiseOptions,
-    lNormalizedFileAndDirectoryArray,
-  );
+	bus.summary("analyze", c(7));
+	const lCruiseResult = enrich(
+		lExtractionResult,
+		lCruiseOptions,
+		lNormalizedFileAndDirectoryArray,
+	);
 
-  if (lCruiseOptions.cache) {
-    bus.summary("cache: save", c(8));
-    await lCache.write(lCruiseOptions.cache.folder, lCruiseResult);
-  }
+	if (lCruiseOptions.cache) {
+		bus.summary("cache: save", c(8));
+		await lCache.write(lCruiseOptions.cache.folder, lCruiseResult);
+	}
 
-  bus.summary("report", c(9));
-  return await reportWrap(lCruiseResult, lCruiseOptions);
+	bus.summary("report", c(9));
+	return await reportWrap(lCruiseResult, lCruiseOptions);
 }

package/src/main/files-and-dirs/normalize.mjs

@@ -5,12 +5,12 @@ import { isAbsolute, normalize, relative } from "node:path";
  * @returns {string}
  */
 function relativize(pFileDirectory) {
-  // if pFileDirectory === process.cwd() path.relative will yield an empty string
-  // whereas we actually want something non-empty => hence normalize
-  // the thing
-  return isAbsolute(pFileDirectory)
-    ? normalize(relative(process.cwd(), pFileDirectory))
-    : pFileDirectory;
+	// if pFileDirectory === process.cwd() path.relative will yield an empty string
+	// whereas we actually want something non-empty => hence normalize
+	// the thing
+	return isAbsolute(pFileDirectory)
+		? normalize(relative(process.cwd(), pFileDirectory))
+		: pFileDirectory;
 }
 
 /**
@@ -18,5 +18,5 @@ function relativize(pFileDirectory) {
  * @returns {string[]}
  */
 export default function normalizeFileAndDirectoryArray(pFileAndDirectoryArray) {
-  return pFileAndDirectoryArray.map(relativize);
+	return pFileAndDirectoryArray.map(relativize);
 }

package/src/main/format.mjs

@@ -1,25 +1,22 @@
-import Ajv from "ajv";
-
 import { assertFormatOptionsValid } from "./options/assert-validity.mjs";
 import { normalizeFormatOptions } from "./options/normalize.mjs";
 import reportWrap from "./report-wrap.mjs";
-import cruiseResultSchema from "#cruise-result-schema";
+import validateCruiseResultSchema from "#schema/cruise-result.validate.mjs";
+import { validateErrorsToString } from "#schema/utl.mjs";
 
 function validateResultAgainstSchema(pResult) {
-  const ajv = new Ajv();
-
-  if (!ajv.validate(cruiseResultSchema, pResult)) {
-    throw new Error(
-      `The supplied dependency-cruiser result is not valid: ${ajv.errorsText()}.\n`,
-    );
-  }
+	if (!validateCruiseResultSchema(pResult)) {
+		throw new Error(
+			`The supplied dependency-cruiser result is not valid: ${validateErrorsToString(validateCruiseResultSchema.errors)}.\n`,
+		);
+	}
 }
 /** @type {import("../../types/dependency-cruiser.js").format} */
 export default async function format(pResult, pFormatOptions = {}) {
-  const lFormatOptions = normalizeFormatOptions(pFormatOptions);
-  assertFormatOptionsValid(lFormatOptions);
+	const lFormatOptions = normalizeFormatOptions(pFormatOptions);
+	assertFormatOptionsValid(lFormatOptions);
 
-  validateResultAgainstSchema(pResult);
+	validateResultAgainstSchema(pResult);
 
-  return await reportWrap(pResult, lFormatOptions);
+	return await reportWrap(pResult, lFormatOptions);
 }

package/src/main/helpers.mjs

@@ -1,12 +1,12 @@
 import { has, get, set } from "#utl/object-util.mjs";
 
 const RE_PROPERTIES = [
-  "path",
-  "pathNot",
-  "license",
-  "licenseNot",
-  "exoticRequire",
-  "exoticRequireNot",
+	"path",
+	"pathNot",
+	"license",
+	"licenseNot",
+	"exoticRequire",
+	"exoticRequireNot",
 ];
 
 /**
@@ -15,29 +15,29 @@ const RE_PROPERTIES = [
  * @returns {string}
  */
 export function normalizeToREAsString(pStringish) {
-  if (Array.isArray(pStringish)) {
-    return pStringish.join("|");
-  }
-  return pStringish;
+	if (Array.isArray(pStringish)) {
+		return pStringish.join("|");
+	}
+	return pStringish;
 }
 
 export function normalizeREProperties(
-  pPropertyContainer,
-  pREProperties = RE_PROPERTIES,
+	pPropertyContainer,
+	pREProperties = RE_PROPERTIES,
 ) {
-  let lPropertyContainer = structuredClone(pPropertyContainer);
+	let lPropertyContainer = structuredClone(pPropertyContainer);
 
-  for (const lProperty of pREProperties) {
-    // lProperty can be nested properties, so we use _.has and _.get
-    // instead of elvis operators
-    if (has(lPropertyContainer, lProperty)) {
-      set(
-        lPropertyContainer,
-        lProperty,
+	for (const lProperty of pREProperties) {
+		// lProperty can be nested properties, so we use _.has and _.get
+		// instead of elvis operators
+		if (has(lPropertyContainer, lProperty)) {
+			set(
+				lPropertyContainer,
+				lProperty,
 
-        normalizeToREAsString(get(lPropertyContainer, lProperty)),
-      );
-    }
-  }
-  return lPropertyContainer;
+				normalizeToREAsString(get(lPropertyContainer, lProperty)),
+			);
+		}
+	}
+	return lPropertyContainer;
 }

package/src/main/index.mjs

@@ -1,20 +1,20 @@
 import format from "./format.mjs";
 import cruise from "./cruise.mjs";
 import {
-  allExtensions,
-  getAvailableTranspilers,
+	allExtensions,
+	getAvailableTranspilers,
 } from "#extract/transpile/meta.mjs";
 
 export {
-  allExtensions,
-  getAvailableTranspilers,
+	allExtensions,
+	getAvailableTranspilers,
 } from "#extract/transpile/meta.mjs";
 export { default as cruise } from "./cruise.mjs";
 export { default as format } from "./format.mjs";
 
 export default {
-  cruise,
-  format,
-  allExtensions,
-  getAvailableTranspilers,
+	cruise,
+	format,
+	allExtensions,
+	getAvailableTranspilers,
 };