dependency-cruiser 10.3.1-beta-3 → 10.4.0-beta-3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-cruiser",
-  "version": "10.3.1-beta-3",
+  "version": "10.4.0-beta-3",
   "description": "Validate and visualize dependencies. With your rules. JavaScript, TypeScript, CoffeeScript. ES6, CommonJS, AMD.",
   "keywords": [
     "static analysis",
@@ -139,10 +139,10 @@
     "ajv": "8.6.3",
     "chalk": "4.1.2",
     "commander": "8.2.0",
-    "enhanced-resolve": "5.8.2",
+    "enhanced-resolve": "5.8.3",
     "figures": "^3.2.0",
     "get-stream": "^6.0.1",
-    "glob": "7.1.7",
+    "glob": "7.2.0",
     "handlebars": "4.7.7",
     "indent-string": "^4.0.0",
     "inquirer": "8.1.5",
@@ -159,13 +159,13 @@
     "@babel/core": "7.15.5",
     "@babel/plugin-transform-modules-commonjs": "7.15.4",
     "@babel/preset-typescript": "7.15.0",
-    "@swc/core": "1.2.88",
-    "@typescript-eslint/eslint-plugin": "4.31.1",
-    "@typescript-eslint/parser": "4.31.1",
+    "@swc/core": "1.2.91",
+    "@typescript-eslint/eslint-plugin": "4.31.2",
+    "@typescript-eslint/parser": "4.31.2",
     "c8": "7.9.0",
     "chai": "4.3.4",
     "chai-json-schema": "1.5.1",
-    "coffeescript": "2.5.1",
+    "coffeescript": "2.6.0",
     "eslint": "7.32.0",
     "eslint-config-moving-meadow": "2.0.9",
     "eslint-config-prettier": "8.3.0",
@@ -178,12 +178,12 @@
     "husky": "^4.3.8",
     "intercept-stdout": "0.1.2",
     "lint-staged": "11.1.2",
-    "mocha": "9.1.1",
+    "mocha": "9.1.2",
     "normalize-newline": "4.1.0",
     "npm-run-all": "4.1.5",
     "prettier": "2.4.1",
     "shx": "0.3.3",
-    "svelte": "3.42.6",
+    "svelte": "3.43.0",
     "symlink-dir": "5.0.1",
     "typescript": "4.4.3",
     "upem": "^7.0.0",

package/src/extract/ast-extractors/extract-typescript-deps.js

@@ -30,6 +30,9 @@ function extractImportsAndExports(pAST) {
       module: pStatement.moduleSpecifier.text,
       moduleSystem: "es6",
       exoticallyRequired: false,
+      ...(pStatement.importClause && pStatement.importClause.isTypeOnly
+        ? { dependencyTypes: ["type-only"] }
+        : {}),
     }));
 }
 

package/src/extract/get-dependencies.js

@@ -162,8 +162,8 @@ function addResolutionAttributes(pOptions, pFileName, pResolveOptions) {
     );
 
     return {
-      ...lResolved,
       ...pDependency,
+      ...lResolved,
       followable: lResolved.followable && !lMatchesDoNotFollow,
       matchesDoNotFollow: lMatchesDoNotFollow,
     };
@@ -196,22 +196,12 @@ function compareDeps(pLeft, pRight) {
  *
  *
  * @param  {string} pFileName path to the file
- * @param  {object} pCruiseOptions  an object with one or more of these properties:
- *                            - baseDir         - the directory to consider as the
- *                                                base for all files
- *                                                Default: the current working directory
- *                            - moduleSystems   - an array of module systems to
- *                                                consider.
- *                                                Default: ["cjs", "es6", "amd"]
- *                            - exclude         - a regular expression string
- *                                                with a pattern of modules to exclude
- *                                                (e.g. "(node_modules)"). Default: none
- *                            - preserveSymlinks - don't resolve symlinks.
- * @param {object} pResolveOptions an object with webpack 'enhanced-resolve' options
+ * @param  {import("../../../types/dependency-cruiser").ICruiseOptions} pCruiseOptions cruise options
+ * @param {import("../../types/resolve-options").IResolveOptions} pResolveOptions  webpack 'enhanced-resolve' options
  * @param  {any} pTranspileOptions       an object with tsconfig ('typescript project') options
  *                               ('flattened' so there's no need for file access on any
  *                               'extends' option in there)
- * @return {array}           an array of dependency objects (see above)
+ * @return {import("../../types/dependency-cruiser").IDependency[]} an array of dependency objects (see above)
  */
 module.exports = function getDependencies(
   pFileName,

package/src/extract/resolve/determine-dependency-types.js

@@ -2,7 +2,6 @@ const path = require("path");
 const _has = require("lodash/has");
 const {
   isRelativeModuleName,
-  isCore,
   isExternalModule,
   isAliassy,
 } = require("./module-classifiers");
@@ -144,7 +143,7 @@ function determineExternalModuleDependencyTypes(
 /* eslint max-params:0, complexity:0 */
 /**
  *
- * @param {import("../../../types/cruise-result").IModule} pModule the dependency object with all information found hitherto
+ * @param {import("../../../types/cruise-result").IDependency} pDependency the dependency object with all information found hitherto
  * @param {string} pModuleName the module name as found in the source
  * @param {any} pManifest a package.json, in object format
  * @param {string} pFileDirectory the directory relative to which to resolve (only used for npm deps here)
@@ -154,7 +153,7 @@ function determineExternalModuleDependencyTypes(
  * @return {import("../../../types/shared-types").DependencyType[]} an array of dependency types for the dependency
  */
 module.exports = function determineDependencyTypes(
-  pModule,
+  pDependency,
   pModuleName,
   pManifest,
   pFileDirectory,
@@ -165,10 +164,10 @@ module.exports = function determineDependencyTypes(
   let lReturnValue = ["undetermined"];
   pResolveOptions = pResolveOptions || {};
 
-  if (pModule.couldNotResolve) {
+  if (pDependency.couldNotResolve) {
     lReturnValue = ["unknown"];
-  } else if (isCore(pModuleName)) {
-    // this 'isCore' business seems duplicate (it's already in
+  } else if (pDependency.coreModule) {
+    // this business seems duplicate (it's already in
     // the passed object as `coreModule`- determined by the resolve-AMD or
     // resolve-commonJS module). I want to deprecate the `coreModule`
     // attribute in favor of this one and determining it here will make
@@ -177,21 +176,25 @@ module.exports = function determineDependencyTypes(
   } else if (isRelativeModuleName(pModuleName)) {
     lReturnValue = ["local"];
   } else if (
-    isExternalModule(pModule.resolved, pResolveOptions.modules, pBaseDirectory)
+    isExternalModule(
+      pDependency.resolved,
+      pResolveOptions.modules,
+      pBaseDirectory
+    )
   ) {
     lReturnValue = determineExternalModuleDependencyTypes(
-      pModule,
+      pDependency,
       pModuleName,
       pManifest,
       pFileDirectory,
       pResolveOptions,
       pBaseDirectory
     );
-  } else if (isAliassy(pModuleName, pModule.resolved, pResolveOptions)) {
+  } else if (isAliassy(pModuleName, pDependency.resolved, pResolveOptions)) {
     lReturnValue = ["aliased"];
   }
 
-  return lReturnValue;
+  return lReturnValue.concat(pDependency.dependencyTypes || []);
 };
 
 /* eslint security/detect-object-injection: 0*/

package/src/extract/resolve/index.js

@@ -7,6 +7,8 @@ const { isRelativeModuleName } = require("./module-classifiers");
 const resolveAMD = require("./resolve-amd");
 const resolveCommonJS = require("./resolve-cjs");
 const resolveHelpers = require("./resolve-helpers");
+const determineDependencyTypes = require("./determine-dependency-types");
+const getManifest = require("./get-manifest");
 
 function resolveModule(
   pModule,
@@ -16,20 +18,20 @@ function resolveModule(
 ) {
   let lReturnValue = null;
 
-  const lModuleName = resolveHelpers.stripToModuleName(pModule.module);
+  const lStrippedModuleName = resolveHelpers.stripToModuleName(pModule.module);
   if (
-    isRelativeModuleName(lModuleName) ||
+    isRelativeModuleName(lStrippedModuleName) ||
     ["cjs", "es6", "tsd"].includes(pModule.moduleSystem)
   ) {
     lReturnValue = resolveCommonJS(
-      pModule.module,
+      lStrippedModuleName,
       pBaseDirectory,
       pFileDirectory,
       pResolveOptions
     );
   } else {
     lReturnValue = resolveAMD(
-      pModule.module,
+      lStrippedModuleName,
       pBaseDirectory,
       pFileDirectory,
       pResolveOptions
@@ -48,7 +50,7 @@ function isTypeScriptishExtension(pModuleName) {
 function resolveYarnVirtual(pPath) {
   const pnpAPI = get(monkeyPatchedModule, "findPnpApi", () => false)(pPath);
 
-  // the pnp api only works in plug'n play environemnts, and resolveVirtual
+  // the pnp api only works in plug'n play environments, and resolveVirtual
   // only under yarn(berry). As we can't run a 'regular' nodejs environment
   // and a yarn(berry) one at the same time, ignore in the test coverage and
   // cover it in a separate integration test.
@@ -72,7 +74,7 @@ function resolveWithRetry(
     pFileDirectory,
     pResolveOptions
   );
-  const lModuleName = resolveHelpers.stripToModuleName(pModule.module);
+  const lStrippedModuleName = resolveHelpers.stripToModuleName(pModule.module);
 
   // when we feed the typescript compiler an import with an explicit .js(x) extension
   // and the .js(x) file does not exist, it tries files with the .ts, .tsx or
@@ -87,8 +89,14 @@ function resolveWithRetry(
   //
   // This should eventually probably land in either enhanced_resolve or in a
   // plugin/ extension for it (tsconfig-paths-webpack-plugin?)
-  if (lReturnValue.couldNotResolve && canBeResolvedToTsVariant(lModuleName)) {
-    const lModuleWithOutExtension = lModuleName.replace(/\.js(x)?$/g, "");
+  if (
+    lReturnValue.couldNotResolve &&
+    canBeResolvedToTsVariant(lStrippedModuleName)
+  ) {
+    const lModuleWithOutExtension = lStrippedModuleName.replace(
+      /\.js(x)?$/g,
+      ""
+    );
 
     const lReturnValueCandidate = resolveModule(
       { ...pModule, module: lModuleWithOutExtension },
@@ -106,14 +114,13 @@ function resolveWithRetry(
 /**
  * resolves the module name of the pDependency to a file on disk.
  *
- * @param  {import("../../../types/cruise-result").IModule} pModule an object with a module and the moduleSystem
- *                              according to which this is a dependency
+ * @param  {Partial <import("../../../types/cruise-result").IDependency>} pDependency
  * @param  {string} pBaseDirectory    the directory to consider as base (or 'root')
  *                              for resolved files.
  * @param  {string} pFileDirectory    the directory of the file the dependency was
  *                              detected in
  * @param  {import(../../../types/resolve-options").IResolveOptions} pResolveOptions
- * @return {object}             an object with as attributes:
+ * @return {Partial <import("../../../types/cruise-result").IDependency>} an object with as attributes:
  *                              - resolved: a string representing the pDependency
  *                                  resolved to a file on disk (or the pDependency
  *                                  name itself when it could not be resolved)
@@ -128,26 +135,52 @@ function resolveWithRetry(
  *                              - dependencyTypes: an array of dependencyTypes
  *
  */
+// eslint-disable-next-line max-lines-per-function
 module.exports = function resolve(
-  pModule,
+  pDependency,
   pBaseDirectory,
   pFileDirectory,
   pResolveOptions
 ) {
-  let lResolvedModule = resolveWithRetry(
-    pModule,
+  let lResolvedDependency = resolveWithRetry(
+    pDependency,
     pBaseDirectory,
     pFileDirectory,
     pResolveOptions
   );
+  const lStrippedModuleName = resolveHelpers.stripToModuleName(
+    pDependency.module
+  );
+
+  lResolvedDependency = {
+    ...lResolvedDependency,
+    ...resolveHelpers.addLicenseAttribute(
+      lStrippedModuleName,
+      lResolvedDependency.resolved,
+      { baseDirectory: pBaseDirectory, fileDirectory: pFileDirectory },
+      pResolveOptions
+    ),
+    dependencyTypes: determineDependencyTypes(
+      { ...pDependency, ...lResolvedDependency },
+      lStrippedModuleName,
+      getManifest(
+        pFileDirectory,
+        pBaseDirectory,
+        pResolveOptions.combinedDependencies
+      ),
+      pFileDirectory,
+      pResolveOptions,
+      pBaseDirectory
+    ),
+  };
 
   if (
     !pResolveOptions.symlinks &&
-    !lResolvedModule.coreModule &&
-    !lResolvedModule.couldNotResolve
+    !lResolvedDependency.coreModule &&
+    !lResolvedDependency.couldNotResolve
   ) {
     try {
-      lResolvedModule.resolved = pathToPosix(
+      lResolvedDependency.resolved = pathToPosix(
         path.relative(
           pBaseDirectory,
           fs.realpathSync(
@@ -159,15 +192,15 @@ module.exports = function resolve(
                    again corresponds with a real file on disk
                  */
                 // eslint-disable-next-line no-control-regex
-                lResolvedModule.resolved.replace(/\u0000#/g, "#")
+                lResolvedDependency.resolved.replace(/\u0000#/g, "#")
               )
             )
           )
         )
       );
     } catch (pError) {
-      lResolvedModule.couldNotResolve = true;
+      lResolvedDependency.couldNotResolve = true;
     }
   }
-  return lResolvedModule;
+  return lResolvedDependency;
 };

package/src/extract/resolve/module-classifiers.js

@@ -1,4 +1,3 @@
-const { builtinModules } = require("module");
 const path = require("path");
 const getExtension = require("../utl/get-extension");
 
@@ -19,10 +18,6 @@ function isRelativeModuleName(pModuleName) {
   );
 }
 
-function isCore(pModuleName) {
-  return builtinModules.includes(pModuleName);
-}
-
 function isExternalModule(
   pResolvedModuleName,
   pModuleFolderNames = ["node_modules"],
@@ -124,7 +119,6 @@ function isAliassy(pModuleName, pResolvedModuleName, pResolveOptions) {
 module.exports = {
   isScoped,
   isRelativeModuleName,
-  isCore,
   isExternalModule,
   isFollowable,
   isAliassy,

package/src/extract/resolve/resolve-amd.js

@@ -1,11 +1,8 @@
 const fs = require("fs");
 const path = require("path");
+const { builtinModules } = require("module");
 const memoize = require("lodash/memoize");
 const pathToPosix = require("../utl/path-to-posix");
-const determineDependencyTypes = require("./determine-dependency-types");
-const { isCore } = require("./module-classifiers");
-const getManifest = require("./get-manifest");
-const resolveHelpers = require("./resolve-helpers");
 
 const fileExists = memoize((pFile) => {
   try {
@@ -27,7 +24,7 @@ function guessPath(pBaseDirectory, pFileDirectory, pStrippedModuleName) {
 }
 
 function guessLikelyPath(pBaseDirectory, pFileDirectory, pStrippedModuleName) {
-  let lReturnValue =
+  return (
     [".js", ""]
       .map((pExtension) =>
         guessPath(
@@ -36,16 +33,14 @@ function guessLikelyPath(pBaseDirectory, pFileDirectory, pStrippedModuleName) {
           `${pStrippedModuleName}${pExtension}`
         )
       )
-      .find(fileExists) || pStrippedModuleName;
-
-  return lReturnValue;
+      .find(fileExists) || pStrippedModuleName
+  );
 }
 
 module.exports = function resolveAMD(
-  pRawModuleName,
+  pStrippedModuleName,
   pBaseDirectory,
-  pFileDirectory,
-  pResolveOptions
+  pFileDirectory
 ) {
   // lookups:
   // - [x] could be relative in the end (implemented)
@@ -53,41 +48,19 @@ module.exports = function resolveAMD(
   // - [ ] maybe use mrjoelkemp/module-lookup-amd ?
   // - [ ] or https://github.com/jaredhanson/amd-resolve ?
   // - [x] funky plugins (json!wappie, ./screeching-cat!sabertooth)
-  const lModuleName = resolveHelpers.stripToModuleName(pRawModuleName);
   const lResolvedPath = guessLikelyPath(
     pBaseDirectory,
     pFileDirectory,
-    lModuleName
+    pStrippedModuleName
   );
 
-  let lReturnValue = {
+  return {
     resolved: lResolvedPath,
-    coreModule: Boolean(isCore(pRawModuleName)),
+    coreModule: builtinModules.includes(pStrippedModuleName),
     followable: fileExists(lResolvedPath) && lResolvedPath.endsWith(".js"),
     couldNotResolve:
-      !Boolean(isCore(pRawModuleName)) && !fileExists(lResolvedPath),
-  };
-
-  return {
-    ...lReturnValue,
-    ...resolveHelpers.addLicenseAttribute(
-      lModuleName,
-      pBaseDirectory,
-      pResolveOptions,
-      lReturnValue.resolved
-    ),
-    dependencyTypes: determineDependencyTypes(
-      lReturnValue,
-      lModuleName,
-      getManifest(
-        pFileDirectory,
-        pBaseDirectory,
-        pResolveOptions.combinedDependencies
-      ),
-      pFileDirectory,
-      pResolveOptions,
-      pBaseDirectory
-    ),
+      !builtinModules.includes(pStrippedModuleName) &&
+      !fileExists(lResolvedPath),
   };
 };
 

package/src/extract/resolve/resolve-cjs.js

@@ -1,9 +1,7 @@
 const path = require("path");
+const { builtinModules } = require("module");
 const pathToPosix = require("../utl/path-to-posix");
-const determineDependencyTypes = require("./determine-dependency-types");
-const { isCore, isFollowable } = require("./module-classifiers");
-const getManifest = require("./get-manifest");
-const resolveHelpers = require("./resolve-helpers");
+const { isFollowable } = require("./module-classifiers");
 const resolve = require("./resolve");
 
 function addResolutionAttributes(
@@ -14,7 +12,7 @@ function addResolutionAttributes(
 ) {
   let lReturnValue = {};
 
-  if (isCore(pModuleName)) {
+  if (builtinModules.includes(pModuleName)) {
     lReturnValue.coreModule = true;
   } else {
     try {
@@ -39,47 +37,21 @@ function addResolutionAttributes(
  * resolves both CommonJS and ES6
  */
 module.exports = function resolveCommonJS(
-  pRawModuleName,
+  pStrippedModuleName,
   pBaseDirectory,
   pFileDirectory,
   pResolveOptions
 ) {
-  const lModuleName = resolveHelpers.stripToModuleName(pRawModuleName);
-  const lManifest = getManifest(
-    pFileDirectory,
-    pBaseDirectory,
-    pResolveOptions.combinedDependencies
-  );
-
-  let lReturnValue = {
-    resolved: lModuleName,
+  return {
+    resolved: pStrippedModuleName,
     coreModule: false,
     followable: false,
     couldNotResolve: false,
-    dependencyTypes: ["undetermined"],
     ...addResolutionAttributes(
       pBaseDirectory,
-      lModuleName,
+      pStrippedModuleName,
       pFileDirectory,
       pResolveOptions
     ),
   };
-
-  return {
-    ...lReturnValue,
-    ...resolveHelpers.addLicenseAttribute(
-      lModuleName,
-      lReturnValue.resolved,
-      { baseDirectory: pBaseDirectory, fileDirectory: pFileDirectory },
-      pResolveOptions
-    ),
-    dependencyTypes: determineDependencyTypes(
-      lReturnValue,
-      lModuleName,
-      lManifest,
-      pFileDirectory,
-      pResolveOptions,
-      pBaseDirectory
-    ),
-  };
 };

package/src/main/utl/normalize-re-properties.js

@@ -10,6 +10,8 @@ const RE_PROPERTIES = [
   "licenseNot",
   "exoticRequire",
   "exoticRequireNot",
+  "via",
+  "viaNot",
 ];
 
 module.exports = function normalizeREProperties(

package/src/meta.js

@@ -1,7 +1,7 @@
 /* generated - don't edit */
 
 module.exports = {
-  version: "10.3.1-beta-3",
+  version: "10.4.0-beta-3",
   engines: {
     node: "^12.20||^14||>=16",
   },

package/src/schema/configuration.schema.js

@@ -162,6 +162,8 @@ module.exports = {
         moreThanOneDependencyType: { type: "boolean" },
         license: { $ref: "#/definitions/REAsStringsType" },
         licenseNot: { $ref: "#/definitions/REAsStringsType" },
+        via: { $ref: "#/definitions/REAsStringsType" },
+        viaNot: { $ref: "#/definitions/REAsStringsType" },
       },
     },
     DependentsModuleRestrictionType: {
@@ -234,6 +236,7 @@ module.exports = {
         "npm-unknown",
         "undetermined",
         "unknown",
+        "type-only",
       ],
     },
     REAsStringsType: {

package/src/schema/cruise-result.schema.js

@@ -116,6 +116,7 @@ module.exports = {
         matchesDoNotFollow: { type: "boolean" },
         couldNotResolve: { type: "boolean" },
         preCompilationOnly: { type: "boolean" },
+        typeOnly: { type: "boolean" },
         circular: { type: "boolean" },
         cycle: { type: "array", items: { type: "string" } },
         moduleSystem: { $ref: "#/definitions/ModuleSystemType" },
@@ -143,6 +144,7 @@ module.exports = {
         "npm-unknown",
         "undetermined",
         "unknown",
+        "type-only",
       ],
     },
     ModuleSystemType: { type: "string", enum: ["cjs", "es6", "amd", "tsd"] },
@@ -332,6 +334,8 @@ module.exports = {
         moreThanOneDependencyType: { type: "boolean" },
         license: { $ref: "#/definitions/REAsStringsType" },
         licenseNot: { $ref: "#/definitions/REAsStringsType" },
+        via: { $ref: "#/definitions/REAsStringsType" },
+        viaNot: { $ref: "#/definitions/REAsStringsType" },
       },
     },
     DependentsModuleRestrictionType: {

package/src/validate/match-dependency-rule.js

@@ -37,11 +37,13 @@ function match(pFrom, pTo) {
       matchers.toLicenseNot(pRule, pTo) &&
       matchers.toExoticRequire(pRule, pTo) &&
       matchers.toExoticRequireNot(pRule, pTo) &&
+      matchers.toVia(pRule, pTo) &&
+      matchers.toViaNot(pRule, pTo) &&
       // preCompilationOnly is not a mandatory attribute, but if the attribute
       // is in the rule but not in the dependency there won't be a match
       // anyway, so we can use the default propertyEquals method regardless
       propertyEquals(pTo, pRule, "preCompilationOnly") &&
-      // couldNotResolve, circular, dynamic and exoticallyRequired are
+      // couldNotResolve, circular, dynamic and exoticallyRequired _are_ mandatory
       propertyEquals(pTo, pRule, "couldNotResolve") &&
       propertyEquals(pTo, pRule, "circular") &&
       propertyEquals(pTo, pRule, "dynamic") &&

package/src/validate/matchers.js

@@ -100,6 +100,22 @@ function toExoticRequireNot(pRule, pDependency) {
   );
 }
 
+function toViaNot(pRule, pDependency) {
+  return Boolean(
+    !pRule.to.viaNot ||
+      (pDependency.cycle &&
+        !pDependency.cycle.some((pVia) => pVia.match(pRule.to.viaNot)))
+  );
+}
+
+function toVia(pRule, pDependency) {
+  return Boolean(
+    !pRule.to.via ||
+      (pDependency.cycle &&
+        pDependency.cycle.some((pVia) => pVia.match(pRule.to.via)))
+  );
+}
+
 module.exports = {
   _replaceGroupPlaceholders,
   fromPath,
@@ -115,4 +131,6 @@ module.exports = {
   toLicenseNot,
   toExoticRequire,
   toExoticRequireNot,
+  toVia,
+  toViaNot,
 };

package/types/cruise-result.d.ts

@@ -122,6 +122,13 @@ export interface IDependency {
    * then only when the option 'tsPreCompilationDeps' has the value 'specify'.
    */
   preCompilationOnly?: boolean;
+  /**
+   * 'true' when the module included the module explicitly as type only with the '
+   * type' keyword e.g. import type { IThingus } from 'thing' Dependency-cruiser
+   * will only specify this attribute for TypeScript and when the 'tsPreCompilationDeps'
+   * option has either the value true or 'specify'.
+   */
+  typeOnly?: boolean;
   /**
    * If following this dependency will ultimately return to the source (circular === true),
    * this attribute will contain an (ordered) array of module names that shows (one of) the

package/types/restrictions.d.ts

@@ -34,11 +34,18 @@ export interface IToRestriction extends IBaseRestrictionType {
    */
   circular?: boolean;
   /**
-   * If following this dependency will ultimately return to the source
-   * (circular === true), this attribute will contain an (ordered) array of module
-   * names that shows (one of the) circular path(s)
+   * For circular dependencies - whether or not to match cycles that include include modules
+   * with this regular expression. E.g. to allow all cycles, except when they go through one
+   * specific module. Typically to temporarily disallow some cycles with a lower severity -
+   * setting up a rule with a viaNot that ignores them.
    */
-  cycle?: string[];
+  via?: string | string[];
+  /**
+   * For circular dependencies - whether or not to match cycles that do NOT include modules
+   * with this regular expression. E.g. to disallow all cycles, except when they go through
+   * one specific module. Typically to temporarily allow some cycles until they're removed.
+   */
+  viaNot?: string | string[];
   /**
    * Whether or not to match when the dependency is a dynamic one.
    */

package/types/shared-types.d.ts

@@ -37,6 +37,7 @@ export type DependencyType =
   | "npm-peer"
   | "npm-unknown"
   | "undetermined"
-  | "unknown";
+  | "unknown"
+  | "type-only";
 
-export type ProtocolType = "data:" | "file:" | "node";
+export type ProtocolType = "data:" | "file:" | "node:";