dependency-cruiser 13.0.0-beta-4 → 13.0.0-beta-5

package/README.md

@@ -59,6 +59,19 @@ a one liner:
 npx depcruise src --include-only "^src" --output-type dot | dot -T svg > dependency-graph.svg
 ```
 
+> <details>
+> <summary>dependency-cruiser v12 and older: add --config option</summary>
+>
+> While not necessary from dependency-cruiser v13, in v12 and older you'll have
+> to pass the --config option to make it find the .dependency-cruiser.js
+> configuration file:
+>
+> ```shell
+> npx depcruise src --include-only "^src" --config --output-type dot | dot -T svg > dependency-graph.svg
+> ```
+
+</details>
+
 - You can read more about what you can do with `--include-only` and other command line
   options in the [command line interface](./doc/cli.md) documentation.
 - _[Real world samples](./doc/real-world-samples.md)_
@@ -110,6 +123,19 @@ Sample rule:
 npx depcruise src
 ```
 
+> <details>
+> <summary>dependency-cruiser v12 and older: add --config option</summary>
+>
+> While not necessary from dependency-cruiser v13, in v12 and older you'll have
+> to pass the --config option to make it find the .dependency-cruiser.js
+> configuration file:
+>
+> ```shell
+> npx depcruise --config .dependency-cruiser.js src
+> ```
+
+</details>
+
 This will validate against your rules and shows any violations in an eslint-like format:
 
 ![sample err output](https://raw.githubusercontent.com/sverweij/dependency-cruiser/master/doc/assets/sample-err-output.png)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-cruiser",
-  "version": "13.0.0-beta-4",
+  "version": "13.0.0-beta-5",
   "description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
   "keywords": [
     "static analysis",

package/src/cli/format.mjs

@@ -1,5 +1,5 @@
 import getStream from "get-stream";
-import { format as _format } from "../main/index.mjs";
+import _format from "../main/format.mjs";
 import validateFileExistence from "./utl/validate-file-existence.mjs";
 import normalizeOptions from "./normalize-cli-options.mjs";
 import { getInStream, write } from "./utl/io.mjs";

package/src/cli/index.mjs

@@ -6,7 +6,7 @@ import set from "lodash/set.js";
 import isInstalledGlobally from "is-installed-globally";
 import chalk from "chalk";
 
-import { cruise } from "../main/index.mjs";
+import cruise from "../main/cruise.mjs";
 import bus from "../utl/bus.mjs";
 
 import busLogLevels from "../utl/bus-log-levels.mjs";
@@ -23,10 +23,10 @@ async function extractResolveOptions(pCruiseOptions) {
     pCruiseOptions?.ruleSet?.options?.webpackConfig?.fileName ?? null;
 
   if (lWebPackConfigFileName) {
-    const extractWebpackResolveConfig = await import(
+    const { default: extractWebpackResolveConfig } = await import(
       "../config-utl/extract-webpack-resolve-config.mjs"
     );
-    lResolveOptions = await extractWebpackResolveConfig.default(
+    lResolveOptions = await extractWebpackResolveConfig(
       lWebPackConfigFileName,
       pCruiseOptions?.ruleSet?.options?.webpackConfig?.env ?? null,
       pCruiseOptions?.ruleSet?.options?.webpackConfig?.arguments ?? null
@@ -37,10 +37,10 @@ async function extractResolveOptions(pCruiseOptions) {
 
 async function addKnownViolations(pCruiseOptions) {
   if (pCruiseOptions.knownViolationsFile) {
-    const extractKnownViolations = await import(
+    const { default: extractKnownViolations } = await import(
       "../config-utl/extract-known-violations.mjs"
     );
-    const lKnownViolations = extractKnownViolations.default(
+    const lKnownViolations = await extractKnownViolations(
       pCruiseOptions.knownViolationsFile
     );
 
@@ -59,8 +59,10 @@ async function extractTSConfigOptions(pCruiseOptions) {
     pCruiseOptions?.ruleSet?.options?.tsConfig?.fileName ?? null;
 
   if (lTSConfigFileName) {
-    const extractTSConfig = await import("../config-utl/extract-ts-config.mjs");
-    lReturnValue = extractTSConfig.default(lTSConfigFileName);
+    const { default: extractTSConfig } = await import(
+      "../config-utl/extract-ts-config.mjs"
+    );
+    lReturnValue = extractTSConfig(lTSConfigFileName);
   }
 
   return lReturnValue;
@@ -71,10 +73,10 @@ async function extractBabelConfigOptions(pCruiseOptions) {
   const lBabelConfigFileName =
     pCruiseOptions?.ruleSet?.options?.babelConfig?.fileName ?? null;
   if (lBabelConfigFileName) {
-    const extractBabelConfig = await import(
+    const { default: extractBabelConfig } = await import(
       "../config-utl/extract-babel-config.mjs"
     );
-    lReturnValue = extractBabelConfig.default(lBabelConfigFileName);
+    lReturnValue = extractBabelConfig(lBabelConfigFileName);
   }
 
   return lReturnValue;
@@ -118,14 +120,16 @@ async function runCruise(pFileDirectoryArray, pCruiseOptions) {
   setUpListener(lCruiseOptions);
 
   bus.emit("start");
+  const [lResolveOptions, tsConfig, babelConfig] = await Promise.all([
+    extractResolveOptions(lCruiseOptions),
+    extractTSConfigOptions(lCruiseOptions),
+    extractBabelConfigOptions(lCruiseOptions),
+  ]);
   const lReportingResult = await cruise(
     pFileDirectoryArray,
     lCruiseOptions,
-    await extractResolveOptions(lCruiseOptions),
-    {
-      tsConfig: await extractTSConfigOptions(lCruiseOptions),
-      babelConfig: await extractBabelConfigOptions(lCruiseOptions),
-    }
+    lResolveOptions,
+    { tsConfig, babelConfig }
   );
 
   bus.emit("progress", "cli: writing results", { complete: 1 });
@@ -162,11 +166,13 @@ export default async function executeCli(pFileDirectoryArray, pCruiseOptions) {
     }
     /* c8 ignore stop */
     if (lCruiseOptions.info === true) {
-      const formatMetaInfo = await import("./format-meta-info.mjs");
-      process.stdout.write(await formatMetaInfo.default());
+      const { default: formatMetaInfo } = await import(
+        "./format-meta-info.mjs"
+      );
+      process.stdout.write(await formatMetaInfo());
     } else if (lCruiseOptions.init) {
-      const initConfig = await import("./init-config/index.mjs");
-      initConfig.default(lCruiseOptions.init);
+      const { default: initConfig } = await import("./init-config/index.mjs");
+      initConfig(lCruiseOptions.init);
     } else {
       lExitCode = await runCruise(pFileDirectoryArray, lCruiseOptions);
     }

package/src/cli/listeners/performance-log/index.mjs

@@ -1,6 +1,9 @@
+import chalk from "chalk";
 import busLogLevels from "../../../utl/bus-log-levels.mjs";
 import { getHeader, getProgressLine, getEndText } from "./handlers.mjs";
 
+let gUnderline = false;
+
 function getHeaderWriter(pStream, pMaxLevel) {
   return (_pMessage, pOptions) => {
     const lOptions = { level: busLogLevels.SUMMARY, ...(pOptions || {}) };
@@ -12,8 +15,16 @@ function getHeaderWriter(pStream, pMaxLevel) {
 function getProgressWriter(pStream, pState, pMaxLevel) {
   return (pMessage, pOptions) => {
     const lOptions = { level: busLogLevels.SUMMARY, ...(pOptions || {}) };
-
-    pStream.write(getProgressLine(pMessage, pState, lOptions.level, pMaxLevel));
+    const lProgressLine = getProgressLine(
+      pMessage,
+      pState,
+      lOptions.level,
+      pMaxLevel
+    );
+    pStream.write(
+      gUnderline ? `${chalk.underline(lProgressLine)}` : lProgressLine
+    );
+    gUnderline = !gUnderline;
   };
 }
 

package/src/cli/tools/wrap-stream-in-html.mjs

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
 const HEADER_FILE = fileURLToPath(
@@ -25,10 +25,13 @@ const FOOTER_FILE = fileURLToPath(
  * @param {readStream} pStream stream whose characters are to be slapped between header and footer
  * @param {writeStream} pOutStream stream to write to
  */
-export default function wrap(pInStream, pOutStream) {
-  const lHeader = readFileSync(HEADER_FILE, "utf8");
-  const lScript = readFileSync(SCRIPT_FILE, "utf8");
-  const lEnd = readFileSync(FOOTER_FILE, "utf8");
+export default async function wrap(pInStream, pOutStream) {
+  const [lHeader, lScript, lEnd] = await Promise.all([
+    readFile(HEADER_FILE, "utf8"),
+    readFile(SCRIPT_FILE, "utf8"),
+    readFile(FOOTER_FILE, "utf8"),
+  ]);
+
   const lFooter = `<script>${lScript}</script>${lEnd}`;
 
   pOutStream.write(lHeader);

package/src/config-utl/extract-babel-config.mjs

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 
 import { extname } from "node:path";
 import json5 from "json5";
@@ -11,10 +11,10 @@ async function getJSConfig(pBabelConfigFileName) {
   let lReturnValue = {};
 
   try {
-    const lModule = await import(
+    const { default: lModule } = await import(
       `file://${makeAbsolute(pBabelConfigFileName)}`
     );
-    lReturnValue = lModule.default;
+    lReturnValue = lModule;
   } catch (pError) {
     throw new Error(
       `${
@@ -35,11 +35,11 @@ async function getJSConfig(pBabelConfigFileName) {
   return lReturnValue;
 }
 
-function getJSON5Config(pBabelConfigFileName) {
+async function getJSON5Config(pBabelConfigFileName) {
   let lReturnValue = {};
 
   try {
-    lReturnValue = json5.parse(readFileSync(pBabelConfigFileName, "utf8"));
+    lReturnValue = json5.parse(await readFile(pBabelConfigFileName, "utf8"));
   } catch (pError) {
     throw new Error(
       `Encountered an error while parsing the babel config '${pBabelConfigFileName}':` +

package/src/config-utl/extract-depcruise-config/read-config.mjs

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { extname } from "node:path";
 import json5 from "json5";
 
@@ -6,8 +6,10 @@ export default async function readConfig(pAbsolutePathToConfigFile) {
   if (
     [".js", ".cjs", ".mjs", ""].includes(extname(pAbsolutePathToConfigFile))
   ) {
-    const lConfig = await import(`file://${pAbsolutePathToConfigFile}`);
-    return lConfig.default;
+    const { default: config } = await import(
+      `file://${pAbsolutePathToConfigFile}`
+    );
+    return config;
   }
-  return json5.parse(readFileSync(pAbsolutePathToConfigFile, "utf8"));
+  return json5.parse(await readFile(pAbsolutePathToConfigFile, "utf8"));
 }

package/src/config-utl/extract-known-violations.mjs

@@ -1,11 +1,11 @@
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import json5 from "json5";
 import makeAbsolute from "./make-absolute.mjs";
 
-export default function extractKnownViolations(pKnownViolationsFileName) {
+export default async function extractKnownViolations(pKnownViolationsFileName) {
   try {
     return json5.parse(
-      readFileSync(makeAbsolute(pKnownViolationsFileName), "utf8")
+      await readFile(makeAbsolute(pKnownViolationsFileName), "utf8")
     );
   } catch (pError) {
     if (pError instanceof SyntaxError) {

package/src/config-utl/extract-webpack-resolve-config.mjs

@@ -78,8 +78,10 @@ function isNativelySupported(pWebpackConfigFilename) {
 async function attemptImport(pAbsoluteWebpackConfigFileName) {
   try {
     if (isNativelySupported(pAbsoluteWebpackConfigFileName)) {
-      const lModule = await import(`file://${pAbsoluteWebpackConfigFileName}`);
-      return lModule.default;
+      const { default: lModule } = await import(
+        `file://${pAbsoluteWebpackConfigFileName}`
+      );
+      return lModule;
     } else {
       tryRegisterNonNative(pAbsoluteWebpackConfigFileName);
       /* we're using still using require instead of dynamic imports here because

package/src/enrich/enrich-modules.mjs

@@ -18,7 +18,7 @@ export default function enrichModules(pModules, pOptions) {
     pDependencyName: "resolved",
   });
   bus.emit("progress", "analyzing: dependents", { level: busLogLevels.INFO });
-  lModules = addDependents(lModules, pOptions);
+  lModules = addDependents(lModules);
   bus.emit("progress", "analyzing: orphans", { level: busLogLevels.INFO });
   lModules = deriveOrphans(lModules);
   bus.emit("progress", "analyzing: reachables", { level: busLogLevels.INFO });

package/src/extract/transpile/meta.d.ts

@@ -1,3 +1,8 @@
+import {
+  IAvailableExtension,
+  IAvailableTranspiler,
+} from "../../../types/dependency-cruiser.d.ts";
+
 export interface ITranspilerWrapper {
   isAvailable: () => boolean;
   transpile: (
@@ -11,12 +16,6 @@ export function getWrapper(pExtension, pTranspileOptions): ITranspilerWrapper;
 
 export const scannableExtensions: string[];
 
-export const allExtensions: string[];
-
-export interface IAvailableTranspiler {
-  name: string;
-  version: string;
-  available: boolean;
-}
+export const allExtensions: IAvailableExtension[];
 
 export function getAvailableTranspilers(): IAvailableTranspiler[];

package/src/main/cruise.mjs

@@ -0,0 +1,107 @@
+/* eslint-disable no-return-await */
+/* eslint-disable no-magic-numbers */
+
+import bus from "../utl/bus.mjs";
+import { validateCruiseOptions } from "./options/validate.mjs";
+import { normalizeCruiseOptions } from "./options/normalize.mjs";
+import reportWrap from "./report-wrap.mjs";
+
+const TOTAL_STEPS = 10;
+
+export function c(pComplete, pTotal = TOTAL_STEPS) {
+  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
+) {
+  bus.emit("progress", "parsing options", c(1));
+  /** @type {import("../../types/strict-options.js").IStrictCruiseOptions} */
+  let lCruiseOptions = normalizeCruiseOptions(
+    validateCruiseOptions(pCruiseOptions),
+    pFileAndDirectoryArray
+  );
+  let lCache = null;
+
+  if (lCruiseOptions.cache) {
+    bus.emit(
+      "progress",
+      `cache: check freshness with ${lCruiseOptions.cache.strategy}`,
+      c(2)
+    );
+
+    const { default: Cache } = await import("../cache/cache.mjs");
+    lCache = new Cache(lCruiseOptions.cache.strategy);
+    const lCachedResults = lCache.read(lCruiseOptions.cache.folder);
+
+    if (lCache.canServeFromCache(lCruiseOptions, lCachedResults)) {
+      bus.emit("progress", "cache: reporting from cache", c(8));
+      return await reportWrap(lCachedResults, lCruiseOptions);
+    }
+  }
+
+  bus.emit("progress", "importing analytical modules", c(3));
+  const [
+    { default: normalizeRuleSet },
+    { default: validateRuleSet },
+    { 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/validate.mjs"),
+    import("./files-and-dirs/normalize.mjs"),
+    import("./resolve-options/normalize.mjs"),
+    import("../extract/index.mjs"),
+    import("../enrich/index.mjs"),
+  ]);
+
+  if (Boolean(lCruiseOptions.ruleSet)) {
+    bus.emit("progress", "parsing rule set", c(4));
+    lCruiseOptions.ruleSet = normalizeRuleSet(
+      validateRuleSet(lCruiseOptions.ruleSet)
+    );
+  }
+
+  const lNormalizedFileAndDirectoryArray = normalizeFilesAndDirectories(
+    pFileAndDirectoryArray
+  );
+
+  bus.emit("progress", "determining how to resolve", c(5));
+  const lNormalizedResolveOptions = await normalizeResolveOptions(
+    pResolveOptions,
+    lCruiseOptions,
+    pTranspileOptions?.tsConfig
+  );
+
+  bus.emit("progress", "reading files", c(6));
+  const lExtractionResult = extract(
+    lNormalizedFileAndDirectoryArray,
+    lCruiseOptions,
+    lNormalizedResolveOptions,
+    pTranspileOptions
+  );
+
+  bus.emit("progress", "analyzing", c(7));
+  const lCruiseResult = enrich(
+    lExtractionResult,
+    lCruiseOptions,
+    lNormalizedFileAndDirectoryArray
+  );
+
+  if (lCruiseOptions.cache) {
+    bus.emit("progress", "cache: save", c(8));
+    lCache.write(lCruiseOptions.cache.folder, lCruiseResult);
+  }
+
+  bus.emit("progress", "reporting", c(9));
+  return await reportWrap(lCruiseResult, lCruiseOptions);
+}

package/src/main/format.mjs

@@ -0,0 +1,26 @@
+import Ajv from "ajv";
+
+import cruiseResultSchema from "../schema/cruise-result.schema.mjs";
+import { validateFormatOptions } from "./options/validate.mjs";
+import { normalizeFormatOptions } from "./options/normalize.mjs";
+import reportWrap from "./report-wrap.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`
+    );
+  }
+}
+/** @type {import("../../types/dependency-cruiser.js").format} */
+export default async function format(pResult, pFormatOptions = {}) {
+  const lFormatOptions = normalizeFormatOptions(pFormatOptions);
+  validateFormatOptions(lFormatOptions);
+
+  validateResultAgainstSchema(pResult);
+
+  // eslint-disable-next-line no-return-await
+  return await reportWrap(pResult, lFormatOptions);
+}

package/src/main/index.mjs

@@ -1,135 +1,16 @@
-/* eslint-disable no-return-await */
-/* eslint-disable no-magic-numbers */
-
-import Ajv from "ajv";
-
-import cruiseResultSchema from "../schema/cruise-result.schema.mjs";
-import bus from "../utl/bus.mjs";
 import {
   allExtensions,
   getAvailableTranspilers,
 } from "../extract/transpile/meta.mjs";
-import normalizeFilesAndDirectories from "./files-and-dirs/normalize.mjs";
-import validateRuleSet from "./rule-set/validate.mjs";
-import {
-  validateCruiseOptions,
-  validateFormatOptions,
-} from "./options/validate.mjs";
-import {
-  normalizeCruiseOptions,
-  normalizeFormatOptions,
-} from "./options/normalize.mjs";
-import reportWrap from "./report-wrap.mjs";
-
-const TOTAL_STEPS = 9;
-
-function c(pComplete, pTotal = TOTAL_STEPS) {
-  return { complete: pComplete / pTotal };
-}
-
-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`
-    );
-  }
-}
-/** @type {import("../../types/dependency-cruiser.js").format} */
-export async function format(pResult, pFormatOptions = {}) {
-  const lFormatOptions = normalizeFormatOptions(pFormatOptions);
-  validateFormatOptions(lFormatOptions);
-
-  validateResultAgainstSchema(pResult);
-
-  return await reportWrap(pResult, lFormatOptions);
-}
-
-/** @type {import("../../types/dependency-cruiser.js").cruise} */
-// eslint-disable-next-line max-lines-per-function, max-statements
-export async function cruise(
-  pFileAndDirectoryArray,
-  pCruiseOptions,
-  pResolveOptions,
-  pTranspileOptions
-) {
-  bus.emit("progress", "parsing options", c(1));
-  /** @type {import("../../types/strict-options.js").IStrictCruiseOptions} */
-  let lCruiseOptions = normalizeCruiseOptions(
-    validateCruiseOptions(pCruiseOptions),
-    pFileAndDirectoryArray
-  );
-  let lCache = null;
-
-  if (lCruiseOptions.cache) {
-    bus.emit(
-      "progress",
-      `cache: check freshness with ${lCruiseOptions.cache.strategy}`,
-      c(2)
-    );
-
-    const CacheModule = await import("../cache/cache.mjs");
-    const Cache = CacheModule.default;
-    lCache = new Cache(lCruiseOptions.cache.strategy);
-    const lCachedResults = lCache.read(lCruiseOptions.cache.folder);
-
-    if (lCache.canServeFromCache(lCruiseOptions, lCachedResults)) {
-      bus.emit("progress", "cache: reporting from cache", c(8));
-      return await reportWrap(lCachedResults, lCruiseOptions);
-    }
-  }
-
-  if (Boolean(lCruiseOptions.ruleSet)) {
-    bus.emit("progress", "parsing rule set", c(3));
-    const normalizeRuleSet = await import("./rule-set/normalize.mjs");
-    lCruiseOptions.ruleSet = normalizeRuleSet.default(
-      validateRuleSet(lCruiseOptions.ruleSet)
-    );
-  }
-
-  const lNormalizedFileAndDirectoryArray = normalizeFilesAndDirectories(
-    pFileAndDirectoryArray
-  );
-
-  bus.emit("progress", "determining how to resolve", c(4));
-  let normalizeResolveOptions = await import("./resolve-options/normalize.mjs");
-  const lNormalizedResolveOptions = await normalizeResolveOptions.default(
-    pResolveOptions,
-    lCruiseOptions,
-    pTranspileOptions?.tsConfig
-  );
-
-  bus.emit("progress", "reading files", c(5));
-  const extract = await import("../extract/index.mjs");
-  const lExtractionResult = extract.default(
-    lNormalizedFileAndDirectoryArray,
-    lCruiseOptions,
-    lNormalizedResolveOptions,
-    pTranspileOptions
-  );
-
-  bus.emit("progress", "analyzing", c(6));
-  const enrich = await import("../enrich/index.mjs");
-  const lCruiseResult = enrich.default(
-    lExtractionResult,
-    lCruiseOptions,
-    lNormalizedFileAndDirectoryArray
-  );
-
-  if (lCruiseOptions.cache) {
-    bus.emit("progress", "cache: save", c(7));
-    lCache.write(lCruiseOptions.cache.folder, lCruiseResult);
-  }
-
-  bus.emit("progress", "reporting", c(8));
-  return await reportWrap(lCruiseResult, lCruiseOptions);
-}
+import format from "./format.mjs";
+import cruise from "./cruise.mjs";
 
 export {
   allExtensions,
   getAvailableTranspilers,
 } from "../extract/transpile/meta.mjs";
+export { default as cruise } from "./cruise.mjs";
+export { default as format } from "./format.mjs";
 
 export default {
   cruise,

package/src/main/resolve-options/normalize.mjs

@@ -84,10 +84,9 @@ async function compileResolveOptions(
   // Also: requiring the plugin only when it's necessary will save some
   // startup time (especially on a cold require cache)
   if (pResolveOptions.tsConfig && isTsConfigPathsEligible(pTSConfig)) {
-    const TsConfigPathsPluginModule = await import(
+    const { default: TsConfigPathsPlugin } = await import(
       "tsconfig-paths-webpack-plugin"
     );
-    const TsConfigPathsPlugin = TsConfigPathsPluginModule.default;
     lResolveOptions.plugins = pushPlugin(
       lResolveOptions.plugins,
       // @ts-expect-error TS2351 "TsConfPathsPlugin is not constructable" - is unjustified

package/src/meta.js

@@ -1,7 +1,7 @@
 /* generated - don't edit */
 
 module.exports = {
-  version: "13.0.0-beta-4",
+  version: "13.0.0-beta-5",
   engines: {
     node: "^16.14||>=18",
   },

package/src/report/dot/default-theme.mjs

@@ -127,6 +127,10 @@ export default {
       criteria: { "rules[0].severity": "info" },
       attributes: { fontcolor: "blue", color: "blue" },
     },
+    {
+      criteria: { dynamic: true },
+      attributes: { style: "dashed" },
+    },
     {
       criteria: { valid: false },
       attributes: { fontcolor: "red", color: "red" },

package/src/report/index.mjs

@@ -20,6 +20,7 @@ const TYPE2MODULE = {
   baseline: "./baseline.mjs",
   metrics: "./metrics.mjs",
   mermaid: "./mermaid.mjs",
+  null: "./null.mjs",
 };
 
 /**

package/src/report/null.mjs

@@ -0,0 +1,12 @@
+/**
+ * Returns the results of a cruise in JSON
+ *
+ * @param {import("../../types/cruise-result").ICruiseResult} pResults
+ * @returns {import("../../types/dependency-cruiser").IReporterOutput}
+ */
+export default function nullReporter(pResults) {
+  return {
+    output: "",
+    exitCode: pResults.summary.error,
+  };
+}