dependency-cruiser 16.6.0 → 16.7.0-beta-1

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

@@ -9,6 +9,13 @@ import {
   getPackageRoot,
 } from "./external-module-helpers.mjs";
 
+/**
+ * @import { DependencyType } from "../../../types/shared-types.mjs"
+ * @import { IResolveOptions, ITranspileOptions } from "../../../types/dependency-cruiser.mjs"
+ * @import { IDependency } from "../../../types/cruise-result.mjs"
+ * @import { IResolveOptions } from "../../../types/resolve-options.mjs"
+ */
+
 function dependencyKeyHasModuleName(
   pPackageDependencies,
   pModuleName,
@@ -49,7 +56,7 @@ function determineManifestDependencyTypes(
   pPackageDependencies,
   pResolverModulePaths,
 ) {
-  /** @type {import("../../../types/shared-types.js").DependencyType[]} */
+  /** @type {DependencyType[]} */
   let lReturnValue = ["npm-unknown"];
 
   if (Boolean(pPackageDependencies)) {
@@ -98,8 +105,8 @@ function dependencyIsBundled(pModule, pPackageDeps) {
  * @param {string} pModuleName
  * @param {string} pPackageDeps
  * @param {string} pFileDirectory
- * @param {import("../../../types/dependency-cruiser.js").IResolveOptions} pResolveOptions
- * @returns {import("../../../types/shared-types.js").DependencyType[]}
+ * @param {IResolveOptions} pResolveOptions
+ * @returns {DependencyType[]}
  */
 function determineNodeModuleDependencyTypes(
   pModuleName,
@@ -107,7 +114,7 @@ function determineNodeModuleDependencyTypes(
   pFileDirectory,
   pResolveOptions,
 ) {
-  /** @type {import("../../../types/shared-types.js").DependencyType[]} */
+  /** @type { DependencyType[] } */
   let lReturnValue = determineManifestDependencyTypes(
     getPackageRoot(pModuleName),
     pPackageDeps,
@@ -127,13 +134,13 @@ function determineNodeModuleDependencyTypes(
 
 /**
  *
- * @param {import("../../../types/cruise-result.mjs").IDependency} pDependency
+ * @param {IDependency} pDependency
  * @param {string} pModuleName
  * @param {any} pPackageDeps
  * @param {string} pFileDirectory
- * @param {import("../../../types/dependency-cruiser.js").IResolveOptions} pResolveOptions
+ * @param {IResolveOptions} pResolveOptions
  * @param {string} pBaseDirectory
- * @returns {import("../../../types/shared-types.js").DependencyType[]}
+ * @returns {DependencyType[]}
  */
 function determineExternalModuleDependencyTypes(
   pDependency,
@@ -143,7 +150,7 @@ function determineExternalModuleDependencyTypes(
   pResolveOptions,
   pBaseDirectory,
 ) {
-  /** @type {import("../../../types/shared-types.js").DependencyType[]} */
+  /** @type { DependencyType[] } */
   let lReturnValue = [];
 
   if (
@@ -164,15 +171,15 @@ function determineExternalModuleDependencyTypes(
 /* eslint max-params:0, complexity:0 */
 /**
  *
- * @param {import("../../../types/cruise-result.mjs").IDependency} pDependency the dependency object with all information found hitherto
+ * @param {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)
- * @param {import("../../../types/resolve-options.mjs").IResolveOptions} pResolveOptions an enhanced resolve 'resolve' key
+ * @param {IResolveOptions} pResolveOptions an enhanced resolve 'resolve' key
  * @param {string} pBaseDirectory the base directory dependency cruise is run on
- * @param {import("../../../types/dependency-cruiser.mjs").ITranspileOptions} pTranspileOptions
+ * @param {ITranspileOptions} pTranspileOptions
  *
- * @return {import("../../../types/shared-types.js").DependencyType[]} an array of dependency types for the dependency
+ * @return { DependencyType[] }an array of dependency types for the dependency
  */
 // eslint-disable-next-line max-lines-per-function
 export default function determineDependencyTypes(
@@ -184,7 +191,7 @@ export default function determineDependencyTypes(
   pBaseDirectory,
   pTranspileOptions,
 ) {
-  /** @type {import("../../../types/shared-types.js").DependencyType[]}*/
+  /** @type {DependencyType[]}*/
   let lReturnValue = [];
   const lResolveOptions = pResolveOptions || {};
 

package/src/extract/resolve/index.mjs

@@ -8,12 +8,18 @@ import determineDependencyTypes from "./determine-dependency-types.mjs";
 import { getManifest } from "./get-manifest.mjs";
 import pathToPosix from "#utl/path-to-posix.mjs";
 
+/**
+ * @import { IModule, IResolveOptions } from "../../../types/dependency-cruiser.mjs";
+ * @import { IResolveOptions } from "../../../types/resolve-options.mjs";
+ * @import { IDependency } from "../../../types/cruise-result.mjs";
+ */
+
 /**
  *
- * @param {import("../../../types/dependency-cruiser.js").IModule} pModule
+ * @param {IModule} pModule
  * @param {string} pBaseDirectory
  * @param {string} pFileDirectory
- * @param {import("../../../types/dependency-cruiser.js").IResolveOptions} pResolveOptions
+ * @param {IResolveOptions} pResolveOptions
  * @returns {any}
  */
 function resolveModule(
@@ -154,14 +160,14 @@ function resolveWithRetry(
 /**
  * resolves the module name of the pDependency to a file on disk.
  *
- * @param  {Partial <import("../../../types/cruise-result.mjs").IDependency>} pDependency
+ * @param  {Partial <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.mjs").IResolveOptions} pResolveOptions
+ * @param  {IResolveOptions} pResolveOptions
  * @param  {any} pTranspileOptions
- * @return {Partial <import("../../../types/cruise-result.mjs").IDependency>}
+ * @return {Partial <IDependency>}
  *
  *
  */

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

@@ -4,6 +4,11 @@ import { join as posix_join } from "node:path/posix";
 import picomatch from "picomatch";
 import getExtension from "#utl/get-extension.mjs";
 
+/**
+ * @import { IResolveOptions } from "../../../types/resolve-options.mjs"
+ * @import { ITranspileOptions } from "../../../types/dependency-cruiser.mjs"
+ */
+
 let gFollowableExtensionsCache = new Set();
 let gFollowableExtensionsCacheInitialized = false;
 
@@ -278,9 +283,9 @@ function matchesTSConfigBaseURL(
 /**
  * @param {string} pModuleName
  * @param {string} pResolvedModuleName
- * @param {import("../../../types/resolve-options.mjs").IResolveOptions} pResolveOptions
+ * @param {importIResolveOptions} pResolveOptions
  * @param {any} pManifest
- * @param {import("../../../types/dependency-cruiser.mjs").ITranspileOptions} pTranspileOptions
+ * @param {ITranspileOptions} pTranspileOptions
  * @returns {string[]}
  */
 // eslint-disable-next-line max-params, complexity

package/src/extract/swc/parse.mjs

@@ -2,10 +2,14 @@ import memoize, { memoizeClear } from "memoize";
 import tryImport from "#utl/try-import.mjs";
 import meta from "#meta.cjs";
 
-/** @type {import('@swc/core')} */
+/**
+ * @import swcCore, { ParseOptions, ModuleItem } from "@swc/core";
+ */
+
+/** @type {swcCore} */
 const swc = await tryImport("@swc/core", meta.supportedTranspilers.swc);
 
-/** @type {import('@swc/core').ParseOptions} */
+/** @type {ParseOptions} */
 const SWC_PARSE_OPTIONS = {
   dynamicImport: true,
   // typescript is a superset of ecmascript, so we use typescript always
@@ -22,7 +26,7 @@ export function getASTFromSource(pSource) {
 }
 
 function getAST(pFileName) {
-  /** @type {import('@swc/core')} swc */
+  /** @type {swcCore swc} */
   return swc.parseFileSync(pFileName, SWC_PARSE_OPTIONS);
 }
 
@@ -32,7 +36,7 @@ function getAST(pFileName) {
  * return the result from a cache
  *
  * @param {string} pFileName - the name of the file to compile
- * @return {import('@swc/core').ModuleItem[]} - an (swc) AST
+ * @return {ModuleItem[]} - an (swc) AST
  */
 export const getASTCached = memoize(getAST);
 

package/src/extract/tsc/extract-typescript-deps.mjs

@@ -1,9 +1,14 @@
+/* eslint-disable unicorn/prevent-abbreviations */
 /* eslint-disable max-lines */
 /* eslint-disable no-inline-comments */
 import tryImport from "#utl/try-import.mjs";
 import meta from "#meta.cjs";
 
-/** @type {import("typescript")} */
+/**
+ * @import typescript, {Node} from "typescript"
+ */
+
+/** @type {typescript} */
 const typescript = await tryImport(
   "typescript",
   meta.supportedTranspilers.typescript,
@@ -24,7 +29,7 @@ function isTypeOnlyImport(pStatement) {
 function isTypeOnlyExport(pStatement) {
   return (
     // for some reason the isTypeOnly indicator is on _statement_ level
-    // and not in exportClause as it is in the importClause ¯\_ (ツ)_/¯.
+    // and not in exportClause as it is in the importClause ¯\_(ツ)_/¯.
     // Also in the case of the omission of an alias the exportClause
     // is not there entirely. So regardless whether there is a
     // pStatement.exportClause or not, we can directly test for the
@@ -46,7 +51,7 @@ function isTypeOnlyExport(pStatement) {
 /**
  * Get all import statements from the top level AST node
  *
- * @param {import("typescript").Node} pAST - the (top-level in this case) AST node
+ * @param {Node} pAST - the (top-level in this case) AST node
  * @returns {{module: string; moduleSystem: string; exoticallyRequired: boolean; dependencyTypes?: string[];}[]} -
  *                                  all import statements in the (top level) AST node
  */
@@ -70,7 +75,7 @@ function extractImports(pAST) {
 /**
  * Get all export statements from the top level AST node
  *
- * @param {import("typescript").Node} pAST - the (top-level in this case) AST node
+ * @param {Node} pAST - the (top-level in this case) AST node
  * @returns {{module: string; moduleSystem: string; exoticallyRequired: boolean; dependencyTypes?: string[];}[]} -
  *                                  all export statements in the (top level) AST node
  */
@@ -98,7 +103,7 @@ function extractExports(pAST) {
  * Ignores import equals of variables (e.g. import protocol = ts.server.protocol
  * which happens in typescript/lib/protocol.d.ts)
  *
- * @param {import("typescript").Node} pAST - the (top-level in this case) AST node
+ * @param {Node} pAST - the (top-level in this case) AST node
  * @returns {{module: string, moduleSystem: string;exoticallyRequired: boolean;}[]} - all import equals statements in the
  *                                  (top level) AST node
  */
@@ -123,7 +128,7 @@ function extractImportEquals(pAST) {
  * might be wise to distinguish the three types of /// directive that
  * can come out of this as the resolution algorithm might differ
  *
- * @param {import("typescript").Node} pAST - typescript syntax tree
+ * @param {Node} pAST - typescript syntax tree
  * @returns {{module: string, moduleSystem: string}[]} - 'tripple slash' dependencies
  */
 function extractTripleSlashDirectives(pAST) {
@@ -252,7 +257,41 @@ function isTypeImport(pASTNode) {
         "FirstTemplateToken")
   );
 }
-function walk(pResult, pExoticRequireStrings) {
+
+function extractJSDocImportTags(pJSDocTags) {
+  return pJSDocTags
+    .filter(
+      (pTag) =>
+        pTag.tagName.escapedText === "import" &&
+        pTag.moduleSpecifier?.kind &&
+        typescript.SyntaxKind[pTag.moduleSpecifier.kind] === "StringLiteral" &&
+        Boolean(pTag.moduleSpecifier.text),
+    )
+    .map((pTag) => ({
+      module: pTag.moduleSpecifier.text,
+      moduleSystem: "es6",
+      exoticallyRequired: false,
+      dependencyTypes: ["type-only", "import", "jsdoc", "jsdoc-import-tag"],
+    }));
+}
+
+function extractJSDocImports(pJSDocNodes) {
+  return pJSDocNodes
+    .filter((pJSDocLine) => Boolean(pJSDocLine.tags))
+    .flatMap((pJSDocLine) => extractJSDocImportTags(pJSDocLine.tags));
+}
+
+/**
+ * Walks the AST and collects all dependencies
+ *
+ * @param {Node} pASTNode - the AST node to start from
+ * @param {string[]} pExoticRequireStrings - exotic require strings to look for
+ * @param {boolean} pDetectJSDocImports - whether to detect jsdoc imports
+ * @returns {(pASTNode: Node) => void} - the walker function
+ */
+// eslint-disable-next-line max-lines-per-function
+function walk(pResult, pExoticRequireStrings, pDetectJSDocImports) {
+  // eslint-disable-next-line max-lines-per-function
   return (pASTNode) => {
     // require('a-string'), require(`a-template-literal`)
     if (isRequireCallExpression(pASTNode)) {
@@ -298,7 +337,28 @@ function walk(pResult, pExoticRequireStrings) {
         dependencyTypes: ["type-import"],
       });
     }
-    typescript.forEachChild(pASTNode, walk(pResult, pExoticRequireStrings));
+
+    // /** @import thing from './module' */
+    // /** @import {thing} from './module' */
+    // /** @import * as thing from './module' */
+    // see https://devblogs.microsoft.com/typescript/announcing-typescript-5-5/#the-jsdoc-import-tag
+    //
+    // TODO: all the kinds of tags that can have import statements as type declarations
+    //      (e.g. @type, @param, @returns, @typedef, @property, @prop, @arg, ...)
+    // https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html
+    if (pDetectJSDocImports && Boolean(pASTNode.jsDoc)) {
+      const lJSDocImports = extractJSDocImports(pASTNode.jsDoc);
+
+      // pResult = pResult.concat(lJSDocImports) looks like the more obvious
+      // way to do this, but it re-assigns the pResult parameter
+      lJSDocImports.forEach((pImport) => {
+        pResult.push(pImport);
+      });
+    }
+    typescript.forEachChild(
+      pASTNode,
+      walk(pResult, pExoticRequireStrings, pDetectJSDocImports),
+    );
   };
 }
 
@@ -306,13 +366,19 @@ function walk(pResult, pExoticRequireStrings) {
  * returns an array of dependencies that come potentially nested within
  * a source file, like commonJS or dynamic imports
  *
- * @param {import("typescript").Node} pAST - typescript syntax tree
+ * @param {Node} pAST - typescript syntax tree
+ * @param {string[]} pExoticRequireStrings - exotic require strings to look for
+ * @param {boolean} pDetectJSDocImports - whether to detect jsdoc imports
  * @returns {{module: string, moduleSystem: string}[]} - all commonJS dependencies
  */
-function extractNestedDependencies(pAST, pExoticRequireStrings) {
+function extractNestedDependencies(
+  pAST,
+  pExoticRequireStrings,
+  pDetectJSDocImports,
+) {
   let lResult = [];
 
-  walk(lResult, pExoticRequireStrings)(pAST);
+  walk(lResult, pExoticRequireStrings, pDetectJSDocImports)(pAST);
 
   return lResult;
 }
@@ -320,19 +386,25 @@ function extractNestedDependencies(pAST, pExoticRequireStrings) {
 /**
  * returns all dependencies in the AST
  *
- * @type {(pTypeScriptAST: (import("typescript").Node), pExoticRequireStrings: string[]) => {module: string, moduleSystem: string, dynamic: boolean}[]}
+ * @type {(pTypeScriptAST: (Node), pExoticRequireStrings: string[], pDetectJSDocImports: boolean) => {module: string, moduleSystem: string, dynamic: boolean}[]}
  */
 export default function extractTypeScriptDependencies(
   pTypeScriptAST,
   pExoticRequireStrings,
+  pDetectJSDocImports,
 ) {
+  // console.dir(pTypeScriptAST, { depth: 100 });
   return Boolean(typescript)
     ? extractImports(pTypeScriptAST)
         .concat(extractExports(pTypeScriptAST))
         .concat(extractImportEquals(pTypeScriptAST))
         .concat(extractTripleSlashDirectives(pTypeScriptAST))
         .concat(
-          extractNestedDependencies(pTypeScriptAST, pExoticRequireStrings),
+          extractNestedDependencies(
+            pTypeScriptAST,
+            pExoticRequireStrings,
+            pDetectJSDocImports,
+          ),
         )
         .map((pModule) => ({ dynamic: false, ...pModule }))
     : /* c8 ignore next */ [];

package/src/extract/tsc/extract.mjs

@@ -13,13 +13,14 @@ export function shouldUse({ tsPreCompilationDeps, parser }, pFileName) {
 }
 
 export function extract(
-  { baseDir, exoticRequireStrings, moduleSystems },
+  { baseDir, exoticRequireStrings, moduleSystems, detectJSDocImports },
   pFileName,
   pTranspileOptions,
 ) {
   return extractTypeScriptDeps(
     getASTCached(join(baseDir, pFileName), pTranspileOptions),
     exoticRequireStrings,
+    detectJSDocImports,
   ).filter(({ moduleSystem }) => moduleSystems.includes(moduleSystem));
 }
 

package/src/graph-utl/consolidate-module-dependencies.mjs

@@ -1,6 +1,10 @@
 import { compareRules } from "./compare.mjs";
 import { uniq } from "#utl/array-util.mjs";
 
+/**
+ * @import { IDependency, IModule } from "../../types/cruise-result.mjs";
+ */
+
 function mergeDependency(pLeftDependency, pRightDependency) {
   return {
     ...pLeftDependency,
@@ -30,8 +34,8 @@ function mergeDependencies(pResolvedName, pDependencies) {
 }
 
 /**
- * @param {import('../../types/dependency-cruiser.mjs').IDependency[]} pDependencies
- * @returns {import('../../types/dependency-cruiser.mjs').IDependency[]}
+ * @param {IDependency[]} pDependencies
+ * @returns {IDependency[]}
  */
 function consolidateDependencies(pDependencies) {
   let lDependencies = structuredClone(pDependencies);
@@ -51,8 +55,8 @@ function consolidateDependencies(pDependencies) {
 }
 
 /**
- * @param {import('../../types/dependency-cruiser.mjs').IModule} pModule
- * @returns {import('../../types/dependency-cruiser.mjs').IModule}
+ * @param {IModule} pModule
+ * @returns {IModule}
  */
 export default function consolidateModuleDependencies(pModule) {
   return {

package/src/graph-utl/filter-bank.mjs

@@ -5,6 +5,11 @@ import {
   dependencyMatchesFilter,
 } from "./match-facade.mjs";
 
+/**
+ * @import { IModule } from "../../types/cruise-result.mjs";
+ * @import { IStrictReachesType } from "../../types/strict-filter-types.mjs";
+ */
+
 function includeOnly(pModules, pIncludeFilter) {
   return pIncludeFilter.path
     ? pModules
@@ -33,9 +38,9 @@ function exclude(pModules, pExcludeFilter) {
 }
 /**
  *
- * @param {import("../../types/cruise-result.mjs").IModule[]} pModules
- * @param {import("../../types/strict-filter-types.js").IStrictReachesType} pReachesFilter
- * @returns {import("../../types/cruise-result.mjs").IModule[]}
+ * @param {IModule[]} pModules
+ * @param {IStrictReachesType} pReachesFilter
+ * @returns {IModule[]}
  */
 function filterReaches(pModules, pReachesFilter) {
   const lModuleNamesToReach = pModules

package/src/graph-utl/indexed-module-graph.mjs

@@ -1,14 +1,10 @@
 // @ts-check
 /* eslint-disable security/detect-object-injection */
 /**
- * @typedef {import("../../types/cruise-result.d.mts").IFolderDependency} IFolderDependency
- * @typedef {import("../../types/cruise-result.d.mts").IDependency} IDependency
- * @typedef {import("../../types/cruise-result.d.mts").IFolder} IFolder
- * @typedef {import("../../types/cruise-result.d.mts").IModule} IModule
- * @typedef {import("../../types/shared-types.d.mts").DependencyType} DependencyType
- * @typedef {import("../../types/shared-types.d.mjs").IMiniDependency} IMiniDependency
- *
- * @typedef {(IDependency|IFolderDependency) & {name:string; dependencyTypes?: DependencyType[]}} IEdge
+ * @import { IFolderDependency, IDependency, IFolder, IModule } from "../../types/cruise-result.mjs"
+ * @import { DependencyType, IMiniDependency } from "../../types/shared-types.mjs"
+ 
+* @typedef {(IDependency|IFolderDependency) & {name:string; dependencyTypes?: DependencyType[]}} IEdge
  * @typedef {IModule|IFolder} IModuleOrFolder
  * @typedef {IModuleOrFolder & {dependencies: IEdge[]}} IVertex
  */
@@ -201,7 +197,7 @@ export default class IndexedModuleGraph {
    * @param {Set<string>=} pVisited  Technical parameter - best to leave out of direct calls
    * @return {Array<IMiniDependency>}             see description above
    */
-  #getCycleNew(pInitialSource, pCurrentDependency, pVisited) {
+  #getCycle(pInitialSource, pCurrentDependency, pVisited) {
     let lVisited = pVisited || new Set();
     const lCurrentVertex = this.findVertexByName(pCurrentDependency.name);
     const lEdges = lCurrentVertex.dependencies.filter(
@@ -226,7 +222,7 @@ export default class IndexedModuleGraph {
        */
       (pAll, pDependency) => {
         if (!pAll.some((pSome) => pSome.name === pCurrentDependency.name)) {
-          const lCycle = this.#getCycleNew(
+          const lCycle = this.#getCycle(
             pInitialSource,
             pDependency,
             lVisited.add(pDependency.name),
@@ -266,6 +262,6 @@ export default class IndexedModuleGraph {
     if (!lCurrentDependency) {
       return [];
     }
-    return this.#getCycleNew(pInitialSource, lCurrentDependency);
+    return this.#getCycle(pInitialSource, lCurrentDependency);
   }
 }

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

@@ -1,3 +1,7 @@
+/**
+ * @import {IFlattenedRuleSet, IForbiddenRuleType} from '../../types/rule-set.mjs';
+ */
+
 /**
  * Finds the first rule in the rule set that has name pName,
  * and undefined if no such rule exists/ the rule is an 'allowed'
@@ -5,9 +9,9 @@
  *
  * (this thing probably belongs in a model-like folder and not in utl)
  *
- * @param {import("../../types/dependency-cruiser").IFlattenedRuleSet} pRuleSet - The rule set to search in
+ * @param {IFlattenedRuleSet} pRuleSet - The rule set to search in
  * @param {string} pName - The rule name to look for
- * @return {import("../../types/rule-set").IForbiddenRuleType|undefined} - a rule (or 'undefined' if nothing found)
+ * @return {IForbiddenRuleType|undefined} - a rule (or 'undefined' if nothing found)
  */
 export function findRuleByName(pRuleSet, pName) {
   const lNamedRules = (pRuleSet?.forbidden ?? []).concat(
@@ -29,7 +33,7 @@ function ruleHasALicenseLikeAttribute(pRule) {
  *
  * Returns false in all other cases
  *
- * @param {import('../../types/dependency-cruiser').IFlattenedRuleSet} pRuleSet
+ * @param {IFlattenedRuleSet} pRuleSet
  * @return {boolean}
  */
 export function ruleSetHasLicenseRule(pRuleSet) {
@@ -38,9 +42,9 @@ export function ruleSetHasLicenseRule(pRuleSet) {
     (pRuleSet?.allowed ?? []).some(ruleHasALicenseLikeAttribute)
   );
 }
+
 /**
- *
- * @param {import('../../types/dependency-cruiser').IFlattenedRuleSet} pRuleSet
+ * @param {IFlattenedRuleSet} pRuleSet
  * @return {boolean}
  */
 export function ruleSetHasDeprecationRule(pRuleSet) {

package/src/main/options/assert-validity.mjs

@@ -2,6 +2,10 @@
 import safeRegex from "safe-regex";
 import { getAvailableReporters } from "#report/index.mjs";
 
+/**
+ * @import { ICruiseOptions, IFormatOptions } from "../../../types/options.mjs";
+ */
+
 const MODULE_SYSTEM_LIST_RE = /^(?:(?:cjs|amd|es6|tsd)(?:,|$)){1,4}/gi;
 const VALID_DEPTH_RE = /^\d{1,2}$/g;
 
@@ -96,7 +100,7 @@ function assertPathsSafety(pFilterOption) {
 /**
  * @param {any} pOptions
  * @throws {Error}
- * @returns {import("../../../types/dependency-cruiser.js").ICruiseOptions}
+ * @returns {ICruiseOptions}
  */
 export function assertCruiseOptionsValid(pOptions) {
   let lReturnValue = {};
@@ -132,7 +136,7 @@ export function assertCruiseOptionsValid(pOptions) {
 
 /**
  *
- * @param {import("../../../types/dependency-cruiser.js").IFormatOptions} pFormatOptions
+ * @param {IFormatOptions} pFormatOptions
  * @throws {Error}
  */
 export function assertFormatOptionsValid(pFormatOptions) {

package/src/main/options/defaults.mjs

@@ -3,6 +3,7 @@ export default {
   validate: false,
   maxDepth: 0,
   moduleSystems: ["es6", "cjs", "tsd", "amd"],
+  detectJSDocImports: false,
   tsPreCompilationDeps: false,
   preserveSymlinks: false,
   combinedDependencies: false,