dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/src/cache/cache.mjs

@@ -2,9 +2,9 @@
 import { readFile, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import {
-  brotliCompressSync,
-  brotliDecompressSync,
-  constants as zlibConstants,
+	brotliCompressSync,
+	brotliDecompressSync,
+	constants as zlibConstants,
 } from "node:zlib";
 import { optionsAreCompatible } from "./options-compatible.mjs";
 import MetadataStrategy from "./metadata-strategy.mjs";
@@ -20,16 +20,16 @@ import { bus } from "#utl/bus.mjs";
 
 const CACHE_FILE_NAME = "cache.json";
 const EMPTY_CACHE = {
-  modules: [],
-  summary: {
-    error: 0,
-    warn: 0,
-    info: 0,
-    ignore: 0,
-    totalCruised: 0,
-    violations: [],
-    optionsUsed: {},
-  },
+	modules: [],
+	summary: {
+		error: 0,
+		warn: 0,
+		info: 0,
+		ignore: 0,
+		totalCruised: 0,
+		violations: [],
+		optionsUsed: {},
+	},
 };
 // Bump this to the current major.minor version when the cache format changes in
 // a way that's not backwards compatible.
@@ -44,137 +44,137 @@ const EMPTY_CACHE = {
 const CACHE_FORMAT_VERSION = 16.2;
 
 export default class Cache {
-  #revisionData;
-  #cacheStrategy;
-  #compress;
-  /**
-   * @param {cacheStrategyType=} pCacheStrategy
-   * @param {boolean=} pCompress
-   */
-  constructor(pCacheStrategy, pCompress) {
-    this.#revisionData = null;
-    this.#cacheStrategy =
-      pCacheStrategy === "content"
-        ? new ContentStrategy()
-        : new MetadataStrategy();
-    this.#compress = pCompress ?? false;
-  }
+	#revisionData;
+	#cacheStrategy;
+	#compress;
+	/**
+	 * @param {cacheStrategyType=} pCacheStrategy
+	 * @param {boolean=} pCompress
+	 */
+	constructor(pCacheStrategy, pCompress) {
+		this.#revisionData = null;
+		this.#cacheStrategy =
+			pCacheStrategy === "content"
+				? new ContentStrategy()
+				: new MetadataStrategy();
+		this.#compress = pCompress ?? false;
+	}
 
-  cacheFormatVersionCompatible(pCachedCruiseResult) {
-    return (
-      (pCachedCruiseResult?.revisionData?.cacheFormatVersion ?? 1) >=
-      CACHE_FORMAT_VERSION
-    );
-  }
+	cacheFormatVersionCompatible(pCachedCruiseResult) {
+		return (
+			(pCachedCruiseResult?.revisionData?.cacheFormatVersion ?? 1) >=
+			CACHE_FORMAT_VERSION
+		);
+	}
 
-  /**
-   * @param {IStrictCruiseOptions} pCruiseOptions
-   * @param {ICruiseResult} pCachedCruiseResult
-   * @param {IRevisionData=} pRevisionData
-   * @returns {Promise<boolean>}
-   */
-  async canServeFromCache(pCruiseOptions, pCachedCruiseResult, pRevisionData) {
-    this.#revisionData =
-      pRevisionData ??
-      (await this.#cacheStrategy.getRevisionData(
-        ".",
-        pCachedCruiseResult,
-        pCruiseOptions,
-        {
-          extensions: new Set(
-            scannableExtensions.concat(pCruiseOptions.extraExtensionsToScan),
-          ),
-        },
-      ));
-    this.#revisionData.cacheFormatVersion = CACHE_FORMAT_VERSION;
-    bus.debug("cache: - compare");
-    return (
-      this.cacheFormatVersionCompatible(pCachedCruiseResult) &&
-      this.#cacheStrategy.revisionDataEqual(
-        pCachedCruiseResult.revisionData,
-        this.#revisionData,
-      ) &&
-      optionsAreCompatible(
-        pCachedCruiseResult.summary.optionsUsed,
-        pCruiseOptions,
-      )
-    );
-  }
+	/**
+	 * @param {IStrictCruiseOptions} pCruiseOptions
+	 * @param {ICruiseResult} pCachedCruiseResult
+	 * @param {IRevisionData=} pRevisionData
+	 * @returns {Promise<boolean>}
+	 */
+	async canServeFromCache(pCruiseOptions, pCachedCruiseResult, pRevisionData) {
+		this.#revisionData =
+			pRevisionData ??
+			(await this.#cacheStrategy.getRevisionData(
+				".",
+				pCachedCruiseResult,
+				pCruiseOptions,
+				{
+					extensions: new Set(
+						scannableExtensions.concat(pCruiseOptions.extraExtensionsToScan),
+					),
+				},
+			));
+		this.#revisionData.cacheFormatVersion = CACHE_FORMAT_VERSION;
+		bus.debug("cache: - compare");
+		return (
+			this.cacheFormatVersionCompatible(pCachedCruiseResult) &&
+			this.#cacheStrategy.revisionDataEqual(
+				pCachedCruiseResult.revisionData,
+				this.#revisionData,
+			) &&
+			optionsAreCompatible(
+				pCachedCruiseResult.summary.optionsUsed,
+				pCruiseOptions,
+			)
+		);
+	}
 
-  /**
-   * @param {string} pCacheFolder
-   * @returns {Promise<ICruiseResult>}
-   */
-  async read(pCacheFolder) {
-    try {
-      let lPayload = "";
-      if (this.#compress === true) {
-        const lCompressedPayload = await readFile(
-          join(pCacheFolder, CACHE_FILE_NAME),
-        );
-        const lPayloadAsBuffer = brotliDecompressSync(lCompressedPayload);
-        lPayload = lPayloadAsBuffer.toString("utf8");
-      } else {
-        lPayload = await readFile(join(pCacheFolder, CACHE_FILE_NAME), "utf8");
-      }
-      return JSON.parse(lPayload);
-    } catch (pError) {
-      return EMPTY_CACHE;
-    }
-  }
+	/**
+	 * @param {string} pCacheFolder
+	 * @returns {Promise<ICruiseResult>}
+	 */
+	async read(pCacheFolder) {
+		try {
+			let lPayload = "";
+			if (this.#compress === true) {
+				const lCompressedPayload = await readFile(
+					join(pCacheFolder, CACHE_FILE_NAME),
+				);
+				const lPayloadAsBuffer = brotliDecompressSync(lCompressedPayload);
+				lPayload = lPayloadAsBuffer.toString("utf8");
+			} else {
+				lPayload = await readFile(join(pCacheFolder, CACHE_FILE_NAME), "utf8");
+			}
+			return JSON.parse(lPayload);
+		} catch (pError) {
+			return EMPTY_CACHE;
+		}
+	}
 
-  /**
-   * @param {string} pPayload
-   * @param {boolean} pCompress
-   * @return {Buffer|string}
-   */
-  #compact(pPayload, pCompress) {
-    if (pCompress) {
-      /**
-       * we landed on brotli with BROTLI_MIN_QUALITY because:
-       * - even with BROTLI_MIN_QUALITY it compresses better than gzip
-       *   (regardless of compression level)
-       * - at BROTLI_MIN_QUALITY it's faster than gzip
-       * - BROTLI_MAX_QUALITY gives a bit better compression but is _much_
-       *   slower than even gzip
-       *
-       * In our situation the sync version is significantly faster than the
-       * async version + zlib functions need to be promisified before they
-       * can be used in promises, which will add the to the execution time
-       * as well.
-       *
-       * As sync or async doesn't _really_
-       * matter for the cli, we're using the sync version here.
-       */
-      return brotliCompressSync(pPayload, {
-        params: {
-          [zlibConstants.BROTLI_PARAM_QUALITY]:
-            zlibConstants.BROTLI_MIN_QUALITY,
-        },
-      });
-    }
-    return pPayload;
-  }
+	/**
+	 * @param {string} pPayload
+	 * @param {boolean} pCompress
+	 * @return {Buffer|string}
+	 */
+	#compact(pPayload, pCompress) {
+		if (pCompress) {
+			/**
+			 * we landed on brotli with BROTLI_MIN_QUALITY because:
+			 * - even with BROTLI_MIN_QUALITY it compresses better than gzip
+			 *   (regardless of compression level)
+			 * - at BROTLI_MIN_QUALITY it's faster than gzip
+			 * - BROTLI_MAX_QUALITY gives a bit better compression but is _much_
+			 *   slower than even gzip
+			 *
+			 * In our situation the sync version is significantly faster than the
+			 * async version + zlib functions need to be promisified before they
+			 * can be used in promises, which will add the to the execution time
+			 * as well.
+			 *
+			 * As sync or async doesn't _really_
+			 * matter for the cli, we're using the sync version here.
+			 */
+			return brotliCompressSync(pPayload, {
+				params: {
+					[zlibConstants.BROTLI_PARAM_QUALITY]:
+						zlibConstants.BROTLI_MIN_QUALITY,
+				},
+			});
+		}
+		return pPayload;
+	}
 
-  /**
-   * @param {string} pCacheFolder
-   * @param {ICruiseResult} pCruiseResult
-   * @param {IRevisionData=} pRevisionData
-   */
-  async write(pCacheFolder, pCruiseResult, pRevisionData) {
-    let lRevisionData = pRevisionData ?? this.#revisionData;
+	/**
+	 * @param {string} pCacheFolder
+	 * @param {ICruiseResult} pCruiseResult
+	 * @param {IRevisionData=} pRevisionData
+	 */
+	async write(pCacheFolder, pCruiseResult, pRevisionData) {
+		let lRevisionData = pRevisionData ?? this.#revisionData;
 
-    await mkdir(pCacheFolder, { recursive: true });
-    const lUncompressedPayload = JSON.stringify(
-      this.#cacheStrategy.prepareRevisionDataForSaving(
-        pCruiseResult,
-        lRevisionData,
-      ),
-    );
-    let lPayload = this.#compact(lUncompressedPayload, this.#compress);
+		await mkdir(pCacheFolder, { recursive: true });
+		const lUncompressedPayload = JSON.stringify(
+			this.#cacheStrategy.prepareRevisionDataForSaving(
+				pCruiseResult,
+				lRevisionData,
+			),
+		);
+		let lPayload = this.#compact(lUncompressedPayload, this.#compress);
 
-    // relying on writeFile defaults to 'do the right thing' (i.e. utf8
-    // when the payload is a string; raw buffer otherwise)
-    await writeFile(join(pCacheFolder, CACHE_FILE_NAME), lPayload);
-  }
+		// relying on writeFile defaults to 'do the right thing' (i.e. utf8
+		// when the payload is a string; raw buffer otherwise)
+		await writeFile(join(pCacheFolder, CACHE_FILE_NAME), lPayload);
+	}
 }

package/src/cache/content-strategy.mjs

@@ -4,9 +4,9 @@ import { isDeepStrictEqual } from "node:util";
 import { join } from "node:path/posix";
 import findContentChanges from "./find-content-changes.mjs";
 import {
-  getFileHashSync,
-  isInterestingChangeType,
-  moduleIsInterestingForDiff,
+	getFileHashSync,
+	isInterestingChangeType,
+	moduleIsInterestingForDiff,
 } from "./helpers.mjs";
 
 /**
@@ -20,15 +20,15 @@ import {
  * @returns {(IModule) => IModule}
  */
 function addCheckSumToModule(pBaseDirectory) {
-  return (pModule) => {
-    if (moduleIsInterestingForDiff(pModule)) {
-      return {
-        ...pModule,
-        checksum: getFileHashSync(join(pBaseDirectory, pModule.source)),
-      };
-    }
-    return pModule;
-  };
+	return (pModule) => {
+		if (moduleIsInterestingForDiff(pModule)) {
+			return {
+				...pModule,
+				checksum: getFileHashSync(join(pBaseDirectory, pModule.source)),
+			};
+		}
+		return pModule;
+	};
 }
 
 /**
@@ -37,86 +37,86 @@ function addCheckSumToModule(pBaseDirectory) {
  * @returns {IRevisionChange[]}
  */
 function refreshChanges(pChanges, pModules) {
-  return pChanges.filter(
-    (pChange) =>
-      !pModules.some(
-        (pModule) =>
-          pModule.source === pChange.name &&
-          pModule.checksum === pChange.checksum,
-      ),
-  );
+	return pChanges.filter(
+		(pChange) =>
+			!pModules.some(
+				(pModule) =>
+					pModule.source === pChange.name &&
+					pModule.checksum === pChange.checksum,
+			),
+	);
 }
 
 export default class ContentStrategy {
-  /**
-   * @param {string} pDirectory
-   * @param {ICruiseResult} pCachedCruiseResult
-   * @param {IStrictCruiseOptions} pCruiseOptions
-   * @param {Object} pOptions
-   * @param {Set<string>} pOptions.extensions
-   * @param {Set<changeType>=} pOptions.interestingChangeTypes?
-   * @param {string=} pOptions.baseDir
-   * @param {typeof findContentChanges=} pOptions.diffListFn
-   * @param {typeof getSHA=} pOptions.checksumFn
-   * @returns {IRevisionData}
-   */
-  getRevisionData(pDirectory, pCachedCruiseResult, pCruiseOptions, pOptions) {
-    const lOptions = {
-      diffListFn: findContentChanges,
-      baseDir: process.cwd(),
-      ...pOptions,
-    };
-    return {
-      SHA1: "unknown-in-content-cache-strategy",
-      changes: /** @type {IRevisionChange[]} */ (
-        lOptions.diffListFn(pDirectory, pCachedCruiseResult, {
-          baseDir: lOptions.baseDir,
-          extensions: lOptions.extensions,
-          includeOnly: pCruiseOptions.includeOnly,
-          exclude: pCruiseOptions.exclude,
-        })
-      ).filter(isInterestingChangeType(lOptions.interestingChangeTypes)),
-    };
-  }
+	/**
+	 * @param {string} pDirectory
+	 * @param {ICruiseResult} pCachedCruiseResult
+	 * @param {IStrictCruiseOptions} pCruiseOptions
+	 * @param {Object} pOptions
+	 * @param {Set<string>} pOptions.extensions
+	 * @param {Set<changeType>=} pOptions.interestingChangeTypes?
+	 * @param {string=} pOptions.baseDir
+	 * @param {typeof findContentChanges=} pOptions.diffListFn
+	 * @param {typeof getSHA=} pOptions.checksumFn
+	 * @returns {IRevisionData}
+	 */
+	getRevisionData(pDirectory, pCachedCruiseResult, pCruiseOptions, pOptions) {
+		const lOptions = {
+			diffListFn: findContentChanges,
+			baseDir: process.cwd(),
+			...pOptions,
+		};
+		return {
+			SHA1: "unknown-in-content-cache-strategy",
+			changes: /** @type {IRevisionChange[]} */ (
+				lOptions.diffListFn(pDirectory, pCachedCruiseResult, {
+					baseDir: lOptions.baseDir,
+					extensions: lOptions.extensions,
+					includeOnly: pCruiseOptions.includeOnly,
+					exclude: pCruiseOptions.exclude,
+				})
+			).filter(isInterestingChangeType(lOptions.interestingChangeTypes)),
+		};
+	}
 
-  /**
-   * @param {IRevisionData=} pExistingRevisionData
-   * @param {IRevisionData=} pNewRevisionData
-   * @returns {boolean}
-   */
-  revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
-    return Boolean(
-      pExistingRevisionData &&
-      pNewRevisionData &&
-      // Even though we don't really have a SHA1, it might be the previous version
-      // of the cache did, e.g. because it was rendered with the metadata cache
-      // strategy. In that case the SHA1 comparison is a reliable, fast bailout.
-      pExistingRevisionData.SHA1 === pNewRevisionData.SHA1 &&
-      isDeepStrictEqual(
-        pExistingRevisionData.changes,
-        pNewRevisionData.changes,
-      ),
-    );
-  }
+	/**
+	 * @param {IRevisionData=} pExistingRevisionData
+	 * @param {IRevisionData=} pNewRevisionData
+	 * @returns {boolean}
+	 */
+	revisionDataEqual(pExistingRevisionData, pNewRevisionData) {
+		return Boolean(
+			pExistingRevisionData &&
+			pNewRevisionData &&
+			// Even though we don't really have a SHA1, it might be the previous version
+			// of the cache did, e.g. because it was rendered with the metadata cache
+			// strategy. In that case the SHA1 comparison is a reliable, fast bailout.
+			pExistingRevisionData.SHA1 === pNewRevisionData.SHA1 &&
+			isDeepStrictEqual(
+				pExistingRevisionData.changes,
+				pNewRevisionData.changes,
+			),
+		);
+	}
 
-  /**
-   * @param {ICruiseResult} pCruiseResult
-   * @param {IRevisionData=} pRevisionData
-   * @returns {ICruiseResult}
-   */
-  prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
-    const lModulesWithCheckSum = pCruiseResult.modules.map(
-      addCheckSumToModule(pCruiseResult.summary.optionsUsed.baseDir || "."),
-    );
-    const lRevisionData = {
-      ...pRevisionData,
-      changes: refreshChanges(pRevisionData.changes, lModulesWithCheckSum),
-    };
+	/**
+	 * @param {ICruiseResult} pCruiseResult
+	 * @param {IRevisionData=} pRevisionData
+	 * @returns {ICruiseResult}
+	 */
+	prepareRevisionDataForSaving(pCruiseResult, pRevisionData) {
+		const lModulesWithCheckSum = pCruiseResult.modules.map(
+			addCheckSumToModule(pCruiseResult.summary.optionsUsed.baseDir || "."),
+		);
+		const lRevisionData = {
+			...pRevisionData,
+			changes: refreshChanges(pRevisionData.changes, lModulesWithCheckSum),
+		};
 
-    return {
-      ...pCruiseResult,
-      modules: lModulesWithCheckSum,
-      revisionData: lRevisionData,
-    };
-  }
+		return {
+			...pCruiseResult,
+			modules: lModulesWithCheckSum,
+			revisionData: lRevisionData,
+		};
+	}
 }

package/src/cache/find-content-changes.mjs

@@ -2,11 +2,11 @@
 // @ts-check
 import { join } from "node:path/posix";
 import {
-  getFileHashSync,
-  excludeFilter,
-  includeOnlyFilter,
-  hasInterestingExtension,
-  moduleIsInterestingForDiff,
+	getFileHashSync,
+	excludeFilter,
+	includeOnlyFilter,
+	hasInterestingExtension,
+	moduleIsInterestingForDiff,
 } from "./helpers.mjs";
 import { bus } from "#utl/bus.mjs";
 import findAllFiles from "#utl/find-all-files.mjs";
@@ -24,36 +24,36 @@ import findAllFiles from "#utl/find-all-files.mjs";
  * @returns {(pModule:IModule) => IRevisionChange}
  */
 function diffCachedModuleAgainstFileSet(
-  pFileSet,
-  pBaseDirectory,
-  pFileHashFunction = getFileHashSync,
+	pFileSet,
+	pBaseDirectory,
+	pFileHashFunction = getFileHashSync,
 ) {
-  return (pModule) => {
-    if (!moduleIsInterestingForDiff(pModule)) {
-      return { name: pModule.source, type: "ignored" };
-    }
+	return (pModule) => {
+		if (!moduleIsInterestingForDiff(pModule)) {
+			return { name: pModule.source, type: "ignored" };
+		}
 
-    if (!pFileSet.has(pModule.source)) {
-      return { name: pModule.source, type: "deleted" };
-    }
+		if (!pFileSet.has(pModule.source)) {
+			return { name: pModule.source, type: "deleted" };
+		}
 
-    const lNewCheckSum = pFileHashFunction(
-      join(pBaseDirectory, pModule.source),
-    );
-    if (lNewCheckSum !== pModule.checksum) {
-      return {
-        name: pModule.source,
-        type: "modified",
-        checksum: lNewCheckSum,
-      };
-    }
+		const lNewCheckSum = pFileHashFunction(
+			join(pBaseDirectory, pModule.source),
+		);
+		if (lNewCheckSum !== pModule.checksum) {
+			return {
+				name: pModule.source,
+				type: "modified",
+				checksum: lNewCheckSum,
+			};
+		}
 
-    return {
-      name: pModule.source,
-      type: "unmodified",
-      checksum: pModule.checksum,
-    };
-  };
+		return {
+			name: pModule.source,
+			type: "unmodified",
+			checksum: pModule.checksum,
+		};
+	};
 }
 
 /**
@@ -79,36 +79,36 @@ function diffCachedModuleAgainstFileSet(
  * @returns {IRevisionChange[]}
  */
 export default function findContentChanges(
-  pDirectory,
-  pCachedCruiseResult,
-  pOptions,
+	pDirectory,
+	pCachedCruiseResult,
+	pOptions,
 ) {
-  bus.debug("cache: - get revision data");
-  const lFileSet = new Set(
-    findAllFiles(pDirectory, {
-      baseDir: pOptions.baseDir,
-      excludeFilterFn: excludeFilter(pOptions.exclude),
-      includeOnlyFilterFn: includeOnlyFilter(pOptions.includeOnly),
-    }).filter(hasInterestingExtension(pOptions.extensions)),
-  );
+	bus.debug("cache: - get revision data");
+	const lFileSet = new Set(
+		findAllFiles(pDirectory, {
+			baseDir: pOptions.baseDir,
+			excludeFilterFn: excludeFilter(pOptions.exclude),
+			includeOnlyFilterFn: includeOnlyFilter(pOptions.includeOnly),
+		}).filter(hasInterestingExtension(pOptions.extensions)),
+	);
 
-  bus.debug("cache: - get (cached - new)");
-  const lDiffCachedVsNew = pCachedCruiseResult.modules.map(
-    diffCachedModuleAgainstFileSet(lFileSet, pOptions.baseDir),
-  );
+	bus.debug("cache: - get (cached - new)");
+	const lDiffCachedVsNew = pCachedCruiseResult.modules.map(
+		diffCachedModuleAgainstFileSet(lFileSet, pOptions.baseDir),
+	);
 
-  bus.debug("cache: - get (new - cached)");
-  lDiffCachedVsNew.forEach(({ name }) => lFileSet.delete(name));
+	bus.debug("cache: - get (new - cached)");
+	lDiffCachedVsNew.forEach(({ name }) => lFileSet.delete(name));
 
-  const lDiffNewVsCached = [];
-  for (let lFileName of lFileSet) {
-    lDiffNewVsCached.push({
-      name: lFileName,
-      type: /** @type import('watskeburt').changeType */ ("added"),
-      checksum: getFileHashSync(join(pOptions.baseDir, lFileName)),
-    });
-  }
+	const lDiffNewVsCached = [];
+	for (const lFileName of lFileSet) {
+		lDiffNewVsCached.push({
+			name: lFileName,
+			type: /** @type import('watskeburt').changeType */ ("added"),
+			checksum: getFileHashSync(join(pOptions.baseDir, lFileName)),
+		});
+	}
 
-  bus.debug("cache: - return revision data");
-  return lDiffCachedVsNew.concat(lDiffNewVsCached);
+	bus.debug("cache: - return revision data");
+	return lDiffCachedVsNew.concat(lDiffNewVsCached);
 }