dependency-cruiser 13.0.0-beta-4 → 13.0.0-beta-6

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-6",
   "description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
   "keywords": [
     "static analysis",
@@ -169,19 +169,19 @@
     "semver-try-require": "6.2.2",
     "teamcity-service-messages": "0.1.14",
     "tsconfig-paths-webpack-plugin": "4.0.1",
-    "watskeburt": "0.10.2",
+    "watskeburt": "0.11.1",
     "wrap-ansi": "8.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.21.4",
-    "@babel/plugin-transform-modules-commonjs": "7.21.2",
-    "@babel/preset-typescript": "7.21.4",
-    "@swc/core": "1.3.53",
+    "@babel/core": "7.21.5",
+    "@babel/plugin-transform-modules-commonjs": "7.21.5",
+    "@babel/preset-typescript": "7.21.5",
+    "@swc/core": "1.3.55",
     "@types/lodash": "4.14.194",
-    "@types/node": "18.16.0",
+    "@types/node": "18.16.3",
     "@types/prompts": "2.4.4",
-    "@typescript-eslint/eslint-plugin": "5.59.0",
-    "@typescript-eslint/parser": "5.59.0",
+    "@typescript-eslint/eslint-plugin": "5.59.1",
+    "@typescript-eslint/parser": "5.59.1",
     "@vue/compiler-sfc": "3.2.47",
     "c8": "7.13.0",
     "chai": "4.3.7",
@@ -199,7 +199,7 @@
     "eslint-plugin-unicorn": "^46.0.0",
     "husky": "8.0.3",
     "intercept-stdout": "0.1.2",
-    "lint-staged": "13.2.1",
+    "lint-staged": "13.2.2",
     "mocha": "10.2.0",
     "normalize-newline": "4.1.0",
     "npm-run-all": "4.1.5",

package/src/cache/cache.mjs

@@ -1,6 +1,7 @@
-import { readFileSync, mkdirSync, writeFileSync } from "node:fs";
+import { readFile, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { scannableExtensions } from "../extract/transpile/meta.mjs";
+import { bus } from "../utl/bus.mjs";
 import { optionsAreCompatible } from "./options-compatible.mjs";
 import MetadataStrategy from "./metadata-strategy.mjs";
 import ContentStrategy from "./content-strategy.mjs";
@@ -25,10 +26,10 @@ export default class Cache {
    * @param {import("../../types/dependency-cruiser.js").IRevisionData=} pRevisionData
    * @returns {boolean}
    */
-  canServeFromCache(pCruiseOptions, pCachedCruiseResult, pRevisionData) {
+  async canServeFromCache(pCruiseOptions, pCachedCruiseResult, pRevisionData) {
     this.revisionData =
       pRevisionData ??
-      this.cacheStrategy.getRevisionData(
+      (await this.cacheStrategy.getRevisionData(
         ".",
         pCachedCruiseResult,
         pCruiseOptions,
@@ -37,7 +38,8 @@ export default class Cache {
             scannableExtensions.concat(pCruiseOptions.extraExtensionsToScan)
           ),
         }
-      );
+      ));
+    bus.debug("cache: - comparing");
     return (
       this.cacheStrategy.revisionDataEqual(
         pCachedCruiseResult.revisionData,
@@ -54,10 +56,10 @@ export default class Cache {
    * @param {string} pCacheFolder
    * @returns {import("../../types/dependency-cruiser.js").ICruiseResult}
    */
-  read(pCacheFolder) {
+  async read(pCacheFolder) {
     try {
       return JSON.parse(
-        readFileSync(join(pCacheFolder, CACHE_FILE_NAME), "utf8")
+        await readFile(join(pCacheFolder, CACHE_FILE_NAME), "utf8")
       );
     } catch (pError) {
       return { modules: [], summary: {} };
@@ -69,11 +71,11 @@ export default class Cache {
    * @param {import("../../types/dependency-cruiser.js").ICruiseResult} pCruiseResult
    * @param {import("../../types/dependency-cruiser.js").IRevisionData=} pRevisionData
    */
-  write(pCacheFolder, pCruiseResult, pRevisionData) {
+  async write(pCacheFolder, pCruiseResult, pRevisionData) {
     const lRevisionData = pRevisionData ?? this.revisionData;
 
-    mkdirSync(pCacheFolder, { recursive: true });
-    writeFileSync(
+    await mkdir(pCacheFolder, { recursive: true });
+    await writeFile(
       join(pCacheFolder, CACHE_FILE_NAME),
       JSON.stringify(
         this.cacheStrategy.prepareRevisionDataForSaving(

package/src/cache/content-strategy.mjs

@@ -2,9 +2,8 @@ import { isDeepStrictEqual } from "node:util";
 import { join } from "node:path/posix";
 import findContentChanges from "./find-content-changes.mjs";
 import {
-  getFileHash,
+  getFileHashSync,
   isInterestingChangeType,
-  addCheckSumToChange,
   moduleIsInterestingForDiff,
 } from "./helpers.mjs";
 
@@ -17,7 +16,7 @@ function addCheckSumToModule(pBaseDirectory) {
     if (moduleIsInterestingForDiff(pModule)) {
       return {
         ...pModule,
-        checksum: getFileHash(join(pBaseDirectory, pModule.source)),
+        checksum: getFileHashSync(join(pBaseDirectory, pModule.source)),
       };
     }
     return pModule;
@@ -56,7 +55,6 @@ export default class ContentStrategy {
   getRevisionData(pDirectory, pCachedCruiseResult, pCruiseOptions, pOptions) {
     const lOptions = {
       diffListFn: findContentChanges,
-      checksumFn: addCheckSumToChange,
       baseDir: process.cwd(),
       ...pOptions,
     };

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

@@ -1,26 +1,23 @@
 import { join } from "node:path/posix";
-import bus from "../utl/bus.mjs";
-import busLogLevels from "../utl/bus-log-levels.mjs";
+import { bus } from "../utl/bus.mjs";
 import findAllFiles from "../utl/find-all-files.mjs";
 import {
-  getFileHash,
+  getFileHashSync,
   excludeFilter,
   includeOnlyFilter,
   hasInterestingExtension,
   moduleIsInterestingForDiff,
 } from "./helpers.mjs";
 
-const { DEBUG } = busLogLevels;
-
 /**
  * @param {Set<string>} pFileSet
- * @param {typeof getFileHash} pFileHashFunction
+ * @param {typeof getFileHashSync} pFileHashFunction
  * @returns {(pModule:import("../..").IModule) => import('../..').IRevisionChange}
  */
 function diffCachedModuleAgainstFileSet(
   pFileSet,
   pBaseDirectory,
-  pFileHashFunction = getFileHash
+  pFileHashFunction = getFileHashSync
 ) {
   return (pModule) => {
     if (!moduleIsInterestingForDiff(pModule)) {
@@ -75,7 +72,7 @@ export default function findContentChanges(
   pCachedCruiseResult,
   pOptions
 ) {
-  bus.emit("progress", "cache: - hauling revision data", { level: DEBUG });
+  bus.debug("cache: - getting revision data");
   const lFileSet = new Set(
     findAllFiles(pDirectory, {
       baseDir: pOptions.baseDir,
@@ -84,12 +81,12 @@ export default function findContentChanges(
     }).filter(hasInterestingExtension(pOptions.extensions))
   );
 
-  bus.emit("progress", "cache: - determining cached vs new", { level: DEBUG });
+  bus.debug("cache: - getting (cached - new)");
   const lDiffCachedVsNew = pCachedCruiseResult.modules.map(
     diffCachedModuleAgainstFileSet(lFileSet, pOptions.baseDir)
   );
 
-  bus.emit("progress", "cache: - determining new vs cached", { level: DEBUG });
+  bus.debug("cache: - getting (new - cached)");
   lDiffCachedVsNew.forEach(({ name }) => lFileSet.delete(name));
 
   const lDiffNewVsCached = [];
@@ -97,10 +94,10 @@ export default function findContentChanges(
     lDiffNewVsCached.push({
       name: lFileName,
       changeType: "added",
-      checksum: getFileHash(join(pOptions.baseDir, lFileName)),
+      checksum: getFileHashSync(join(pOptions.baseDir, lFileName)),
     });
   }
 
-  bus.emit("progress", "cache: - returning revision data", { level: DEBUG });
+  bus.debug("cache: - returning revision data");
   return lDiffCachedVsNew.concat(lDiffNewVsCached);
 }

package/src/cache/helpers.mjs

@@ -1,6 +1,7 @@
 /* eslint-disable import/exports-last */
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { extname } from "node:path";
 import memoize from "lodash/memoize.js";
 import { filenameMatchesPattern } from "../graph-utl/match-facade.mjs";
@@ -13,11 +14,32 @@ function hash(pString) {
   return createHash("sha1").update(pString).digest("base64");
 }
 
+/**
+ * @param {import("fs").PathOrFileDescriptor} pFileName
+ * @returns {Promise<string>}
+ */
+async function _getFileHash(pFileName) {
+  try {
+    return hash(await readFile(pFileName, "utf8"));
+  } catch (pError) {
+    return "file not found";
+  }
+}
+
+export const getFileHash = memoize(_getFileHash);
+
+export async function addCheckSumToChange(pChange) {
+  return {
+    ...pChange,
+    checksum: await getFileHash(pChange.name),
+  };
+}
+
 /**
  * @param {import("fs").PathOrFileDescriptor} pFileName
  * @returns {string}
  */
-function _getFileHash(pFileName) {
+function _getFileHashSync(pFileName) {
   try {
     return hash(readFileSync(pFileName, "utf8"));
   } catch (pError) {
@@ -25,16 +47,16 @@ function _getFileHash(pFileName) {
   }
 }
 
-export const getFileHash = memoize(_getFileHash);
+export const getFileHashSync = memoize(_getFileHashSync);
 
 /**
  * @param {import("watskeburt").IChange} pChange
  * @param {import("../../types/dependency-cruiser.js").IRevisionChange}
  */
-export function addCheckSumToChange(pChange) {
+export function addCheckSumToChangeSync(pChange) {
   return {
     ...pChange,
-    checksum: getFileHash(pChange.name),
+    checksum: getFileHashSync(pChange.name),
   };
 }
 

package/src/cache/metadata-strategy.mjs

@@ -1,8 +1,9 @@
 import { isDeepStrictEqual } from "node:util";
-import { getSHASync, listSync } from "watskeburt";
+import { getSHA, list } from "watskeburt";
+import { bus } from "../utl/bus.mjs";
 import {
   isInterestingChangeType,
-  addCheckSumToChange,
+  addCheckSumToChangeSync,
   excludeFilter,
   includeOnlyFilter,
   changeHasInterestingExtension,
@@ -21,26 +22,34 @@ export default class MetaDataStrategy {
    * @param {(import("watskeburt").IChange) => import("../..").IRevisionChange} pOptions.checksumFn
    * @returns {import("../../types/dependency-cruiser.js").IRevisionData}
    */
-  getRevisionData(pDirectory, pCachedCruiseResult, pCruiseOptions, pOptions) {
+  async getRevisionData(
+    pDirectory,
+    pCachedCruiseResult,
+    pCruiseOptions,
+    pOptions
+  ) {
     const lOptions = {
-      shaRetrievalFn: getSHASync,
-      diffListFn: listSync,
-      checksumFn: addCheckSumToChange,
+      shaRetrievalFn: getSHA,
+      diffListFn: list,
+      checksumFn: addCheckSumToChangeSync,
       ...pOptions,
     };
     try {
-      const lSHA = lOptions.shaRetrievalFn();
+      bus.debug("cache: - getting sha");
+      const lSHA = await lOptions.shaRetrievalFn();
+      bus.debug("cache: - getting diff");
+      const lDiff = await lOptions.diffListFn(lSHA);
+      const lChanges = lDiff
+        .filter(({ name }) => excludeFilter(pCruiseOptions.exclude)(name))
+        .filter(({ name }) =>
+          includeOnlyFilter(pCruiseOptions.includeOnly)(name)
+        )
+        .filter(changeHasInterestingExtension(lOptions.extensions))
+        .filter(isInterestingChangeType(lOptions.interestingChangeTypes));
+      bus.debug("cache: - sha-summing diff");
       return {
         SHA1: lSHA,
-        changes: lOptions
-          .diffListFn(lSHA)
-          .filter(({ name }) => excludeFilter(pCruiseOptions.exclude)(name))
-          .filter(({ name }) =>
-            includeOnlyFilter(pCruiseOptions.includeOnly)(name)
-          )
-          .filter(changeHasInterestingExtension(lOptions.extensions))
-          .filter(isInterestingChangeType(lOptions.interestingChangeTypes))
-          .map(lOptions.checksumFn),
+        changes: lChanges.map(lOptions.checksumFn),
       };
     } catch (pError) {
       throw new Error(

package/src/cache/options-compatible.mjs

@@ -117,8 +117,8 @@ export function optionsAreCompatible(pOldOptions, pNewOptions) {
     filterOptionIsCompatible(pOldOptions.collapse, pNewOptions.collapse) &&
     limitIsCompatible(pOldOptions.maxDepth, pNewOptions.maxDepth) &&
     optionIsCompatible(
-      pOldOptions.knownViolations,
-      pNewOptions.knownViolations
+      pOldOptions.knownViolations || [],
+      pNewOptions.knownViolations || []
     ) &&
     optionIsCompatible(
       pOldOptions.enhancedResolveOptions,

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

@@ -1,4 +1,3 @@
-/* eslint-disable import/max-dependencies */
 import { join } from "node:path";
 import { glob } from "glob";
 import cloneDeep from "lodash/cloneDeep.js";
@@ -6,10 +5,9 @@ import set from "lodash/set.js";
 import isInstalledGlobally from "is-installed-globally";
 import chalk from "chalk";
 
-import { cruise } from "../main/index.mjs";
-import bus from "../utl/bus.mjs";
+import cruise from "../main/cruise.mjs";
+import { INFO, bus } from "../utl/bus.mjs";
 
-import busLogLevels from "../utl/bus-log-levels.mjs";
 import validateFileExistence from "./utl/validate-file-existence.mjs";
 import normalizeCliOptions from "./normalize-cli-options.mjs";
 import { write } from "./utl/io.mjs";
@@ -23,10 +21,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 +35,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 +57,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 +71,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;
@@ -95,8 +95,7 @@ function setUpListener(pCruiseOptions) {
   if (Boolean(lListenerFunction)) {
     lListenerFunction(
       bus,
-      pCruiseOptions?.ruleSet?.options?.progress?.maximumLevel ??
-        busLogLevels.INFO
+      pCruiseOptions?.ruleSet?.options?.progress?.maximumLevel ?? INFO
     );
   }
 }
@@ -118,17 +117,19 @@ 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 });
+  bus.progress("cli: writing results", { complete: 1 });
   bus.emit("write-start");
   write(lCruiseOptions.outputTo, lReportingResult.output);
 
@@ -162,11 +163,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/cli-feedback.mjs

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import figures from "figures";
-import busLogLevels from "../../utl/bus-log-levels.mjs";
+import { SUMMARY } from "../../utl/bus.mjs";
 
 const FULL_ON = 100;
 
@@ -26,7 +26,7 @@ function getPercentageBar(pPercentage, pParameters) {
 function getProgressMessageWriter(pStream, pState, pMaxLogLevel) {
   return (pMessage, pOptions) => {
     const lOptions = {
-      level: busLogLevels.SUMMARY,
+      level: SUMMARY,
       complete: pState.complete,
       ...(pOptions || {}),
     };
@@ -56,7 +56,7 @@ function getStartWriter(pStream) {
 
 export default function setUpCliFeedbackListener(
   pEventEmitter,
-  pMaxLogLevel = busLogLevels.SUMMARY,
+  pMaxLogLevel = SUMMARY,
   pStream = process.stderr
 ) {
   const lState = {

package/src/cli/listeners/ndjson.mjs

@@ -1,5 +1,5 @@
 import { EOL } from "node:os";
-import busLogLevels from "../../utl/bus-log-levels.mjs";
+import { INFO, SUMMARY } from "../../utl/bus.mjs";
 
 const MICRO_SECONDS_PER_SECOND = 1000000;
 
@@ -63,7 +63,7 @@ function getProgressLine(pMessage, pState, pLevel, pMaxLevel) {
 
 function getProgressWriter(pStream, pState, pMaxLevel) {
   return (pMessage, pOptions) => {
-    const lOptions = { level: busLogLevels.SUMMARY, ...(pOptions || {}) };
+    const lOptions = { level: SUMMARY, ...(pOptions || {}) };
 
     pStream.write(getProgressLine(pMessage, pState, lOptions.level, pMaxLevel));
   };
@@ -71,12 +71,12 @@ function getProgressWriter(pStream, pState, pMaxLevel) {
 
 export default function setUpNDJSONListener(
   pEventEmitter,
-  pMaxLevel = busLogLevels.INFO,
+  pMaxLevel = INFO,
   pStream = process.stderr
 ) {
   let lState = {
     runStartTime: new Date(Date.now()).toISOString(),
-    previousMessage: "start of node process",
+    previousMessage: "starting nodejs",
     previousTime: 0,
     previousUserUsage: 0,
     previousSystemUsage: 0,

package/src/cli/listeners/performance-log/format-helpers.mjs

@@ -38,13 +38,13 @@ export function formatHeader() {
   return chalk
     .bold(
       `${
-        pad("elapsed real") +
-        pad("user") +
-        pad("system") +
         pad("∆ rss") +
         pad("∆ heapTotal") +
         pad("∆ heapUsed") +
-        pad("∆ external")
+        pad("∆ external") +
+        pad("⏱ system") +
+        pad("⏱ user") +
+        pad("⏱ real")
       }after step...\n`
     )
     .concat(formatDividerLine());
@@ -73,13 +73,13 @@ export function formatPerfLine({
   message,
 }) {
   return `${
-    formatTime(elapsedTime) +
-    formatTime(elapsedUser, MS_PER_MICRO_SECOND) +
-    formatTime(elapsedSystem, MS_PER_MICRO_SECOND) +
     formatMemory(deltaRss) +
     formatMemory(deltaHeapTotal) +
     formatMemory(deltaHeapUsed) +
     formatMemory(deltaExternal) +
+    formatTime(elapsedSystem, MS_PER_MICRO_SECOND) +
+    formatTime(elapsedUser, MS_PER_MICRO_SECOND) +
+    formatTime(elapsedTime) +
     message
   }\n`;
 }

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

@@ -1,9 +1,9 @@
-import busLogLevels from "../../../utl/bus-log-levels.mjs";
+import { INFO, SUMMARY } from "../../../utl/bus.mjs";
 import { getHeader, getProgressLine, getEndText } from "./handlers.mjs";
 
 function getHeaderWriter(pStream, pMaxLevel) {
   return (_pMessage, pOptions) => {
-    const lOptions = { level: busLogLevels.SUMMARY, ...(pOptions || {}) };
+    const lOptions = { level: SUMMARY, ...(pOptions || {}) };
 
     pStream.write(getHeader(lOptions.level, pMaxLevel));
   };
@@ -11,14 +11,19 @@ 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 lOptions = { level: SUMMARY, ...(pOptions || {}) };
+    const lProgressLine = getProgressLine(
+      pMessage,
+      pState,
+      lOptions.level,
+      pMaxLevel
+    );
+    pStream.write(lProgressLine);
   };
 }
 
 function getEndWriter(pStream, pState, pMaxLevel) {
-  return (_pMessage, pLevel = busLogLevels.SUMMARY) => {
+  return (_pMessage, pLevel = SUMMARY) => {
     pStream.write(getEndText(pState, pLevel, pMaxLevel));
     pStream.end();
   };
@@ -26,11 +31,11 @@ function getEndWriter(pStream, pState, pMaxLevel) {
 
 export default function setUpPerformanceLogListener(
   pEventEmitter,
-  pMaxLevel = busLogLevels.INFO,
+  pMaxLevel = INFO,
   pStream = process.stderr
 ) {
   let lState = {
-    previousMessage: "start of node process",
+    previousMessage: "starting nodejs",
     previousTime: 0,
     previousUserUsage: 0,
     previousSystemUsage: 0,

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

@@ -1,5 +1,4 @@
-import bus from "../utl/bus.mjs";
-import busLogLevels from "../utl/bus-log-levels.mjs";
+import { bus } from "../utl/bus.mjs";
 import addFocus from "../graph-utl/add-focus.mjs";
 import IndexedModuleGraph from "../graph-utl/indexed-module-graph.mjs";
 import deriveCycles from "./derive/circular.mjs";
@@ -11,31 +10,27 @@ import softenKnownViolations from "./soften-known-violations.mjs";
 import deriveModuleMetrics from "./derive/metrics/index.mjs";
 
 export default function enrichModules(pModules, pOptions) {
-  bus.emit("progress", "analyzing: cycles", { level: busLogLevels.INFO });
+  bus.info("analyzing: cycles");
   const lIndexedModules = new IndexedModuleGraph(pModules);
   let lModules = deriveCycles(pModules, lIndexedModules, {
     pSourceAttribute: "source",
     pDependencyName: "resolved",
   });
-  bus.emit("progress", "analyzing: dependents", { level: busLogLevels.INFO });
-  lModules = addDependents(lModules, pOptions);
-  bus.emit("progress", "analyzing: orphans", { level: busLogLevels.INFO });
+  bus.info("analyzing: dependents");
+  lModules = addDependents(lModules);
+  bus.info("analyzing: orphans");
   lModules = deriveOrphans(lModules);
-  bus.emit("progress", "analyzing: reachables", { level: busLogLevels.INFO });
+  bus.info("analyzing: reachables");
   lModules = deriveReachable(lModules, pOptions.ruleSet);
-  bus.emit("progress", "analyzing: module metrics", {
-    level: busLogLevels.INFO,
-  });
+  bus.info("analyzing: module metrics");
   lModules = deriveModuleMetrics(lModules, pOptions);
-  bus.emit("progress", "analyzing: add focus (if any)", {
-    level: busLogLevels.INFO,
-  });
+  bus.info("analyzing: add focus (if any)");
   lModules = addFocus(lModules, pOptions.focus);
 
   // when validate === false we might want to skip the addValidations.
   // We don't at this time, however, as "valid" is a mandatory
   // attribute (to simplify reporter logic)
-  bus.emit("progress", "analyzing: validations", { level: busLogLevels.INFO });
+  bus.info("analyzing: validations");
   lModules = addValidations(lModules, pOptions.ruleSet, pOptions.validate);
 
   lModules = softenKnownViolations(lModules, pOptions.knownViolations);

package/src/enrich/soften-known-violations.mjs

@@ -1,5 +1,4 @@
-import bus from "../utl/bus.mjs";
-import busLogLevels from "../utl/bus-log-levels.mjs";
+import { bus } from "../utl/bus.mjs";
 import isSameViolation from "./summarize/is-same-violation.mjs";
 
 function softenModuleViolation(
@@ -118,9 +117,7 @@ export default function softenKnownViolations(
   pSoftenedSeverity = "ignore"
 ) {
   if (Boolean(pKnownViolations)) {
-    bus.emit("progress", "analyzing: comparing against known errors", {
-      level: busLogLevels.INFO,
-    });
+    bus.info("analyzing: comparing against known errors");
     return pModules.map((pModule) =>
       softenKnownViolation(pModule, pKnownViolations, pSoftenedSeverity)
     );

package/src/extract/index.mjs

@@ -1,6 +1,5 @@
 import has from "lodash/has.js";
-import bus from "../utl/bus.mjs";
-import busLogLevels from "../utl/bus-log-levels.mjs";
+import { bus } from "../utl/bus.mjs";
 import getDependencies from "./get-dependencies.mjs";
 import gatherInitialSources from "./gather-initial-sources.mjs";
 import clearCaches from "./clear-caches.mjs";
@@ -62,17 +61,13 @@ function extractFileDirectoryArray(
 ) {
   let lVisited = new Set();
 
-  bus.emit("progress", "reading files: gathering initial sources", {
-    level: busLogLevels.INFO,
-  });
+  bus.info("reading files: gathering initial sources");
   const lInitialSources = gatherInitialSources(
     pFileDirectoryArray,
     pCruiseOptions
   );
 
-  bus.emit("progress", "reading files: visiting dependencies", {
-    level: busLogLevels.INFO,
-  });
+  bus.info("reading files: visiting dependencies");
   return lInitialSources.reduce((pDependencies, pFilename) => {
     if (!lVisited.has(pFilename)) {
       lVisited.add(pFilename);

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,105 @@
+/* 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.summary("parsing options", c(1));
+  /** @type {import("../../types/strict-options.js").IStrictCruiseOptions} */
+  let lCruiseOptions = normalizeCruiseOptions(
+    validateCruiseOptions(pCruiseOptions),
+    pFileAndDirectoryArray
+  );
+  let lCache = null;
+
+  if (lCruiseOptions.cache) {
+    bus.summary(
+      `cache: checking freshness with ${lCruiseOptions.cache.strategy}`,
+      c(2)
+    );
+
+    const { default: Cache } = await import("../cache/cache.mjs");
+    lCache = new Cache(lCruiseOptions.cache.strategy);
+    const lCachedResults = await lCache.read(lCruiseOptions.cache.folder);
+
+    if (await lCache.canServeFromCache(lCruiseOptions, lCachedResults)) {
+      bus.summary("cache: reporting from cache", c(8));
+      return await reportWrap(lCachedResults, lCruiseOptions);
+    }
+  }
+
+  bus.summary("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.summary("parsing rule set", c(4));
+    lCruiseOptions.ruleSet = normalizeRuleSet(
+      validateRuleSet(lCruiseOptions.ruleSet)
+    );
+  }
+
+  const lNormalizedFileAndDirectoryArray = normalizeFilesAndDirectories(
+    pFileAndDirectoryArray
+  );
+
+  bus.summary("determining how to resolve", c(5));
+  const lNormalizedResolveOptions = await normalizeResolveOptions(
+    pResolveOptions,
+    lCruiseOptions,
+    pTranspileOptions?.tsConfig
+  );
+
+  bus.summary("reading files", c(6));
+  const lExtractionResult = extract(
+    lNormalizedFileAndDirectoryArray,
+    lCruiseOptions,
+    lNormalizedResolveOptions,
+    pTranspileOptions
+  );
+
+  bus.summary("analyzing", c(7));
+  const lCruiseResult = enrich(
+    lExtractionResult,
+    lCruiseOptions,
+    lNormalizedFileAndDirectoryArray
+  );
+
+  if (lCruiseOptions.cache) {
+    bus.summary("cache: saving", c(8));
+    await lCache.write(lCruiseOptions.cache.folder, lCruiseResult);
+  }
+
+  bus.summary("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-6",
   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,
+  };
+}

package/src/utl/bus.mjs

@@ -1,5 +1,30 @@
+/* eslint-disable import/exports-last */
 import EventEmitter from "node:events";
 
-const gBus = new EventEmitter();
+export const OFF = -1;
+export const SUMMARY = 40;
+export const INFO = 50;
+export const DEBUG = 60;
+export const TRACE = 70;
+export const EXTRA_STRONG = 80;
+export const ALL = 99;
 
-export default gBus;
+class Bus extends EventEmitter {
+  progress(pMessage, pOptions, ...pArguments) {
+    this.emit("progress", pMessage, pOptions, pArguments);
+  }
+
+  summary(pMessage, pOptions, ...pArguments) {
+    this.progress(pMessage, { ...pOptions, level: SUMMARY }, pArguments);
+  }
+
+  info(pMessage, pOptions, ...pArguments) {
+    this.progress(pMessage, { ...pOptions, level: INFO }, pArguments);
+  }
+
+  debug(pMessage, pOptions, ...pArguments) {
+    this.progress(pMessage, { ...pOptions, level: DEBUG }, pArguments);
+  }
+}
+
+export const bus = new Bus();

package/src/utl/bus-log-levels.mjs

@@ -1,9 +0,0 @@
-export default {
-  OFF: -1,
-  SUMMARY: 40,
-  INFO: 50,
-  DEBUG: 60,
-  TRACE: 70,
-  EXTRA_STRONG: 80,
-  ALL: 99,
-};