dependency-cruiser 15.5.0 → 16.0.0-beta-1

package/package.json

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

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

@@ -8,16 +8,31 @@ const typescript = await tryImport(
   meta.supportedTranspilers.typescript,
 );
 
-function isTypeOnly(pStatement) {
+function isTypeOnlyImport(pStatement) {
+  return (
+    pStatement.importClause &&
+    (pStatement.importClause.isTypeOnly ||
+      (pStatement.importClause.namedBindings &&
+        pStatement.importClause.namedBindings.elements &&
+        pStatement.importClause.namedBindings.elements.every(
+          (pElement) => pElement.isTypeOnly,
+        )))
+  );
+}
+
+function isTypeOnlyExport(pStatement) {
   return (
-    (pStatement.importClause && pStatement.importClause.isTypeOnly) ||
     // for some reason the isTypeOnly indicator is on _statement_ level
     // 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
     // isTypeOnly attribute.
-    pStatement.isTypeOnly
+    pStatement.isTypeOnly ||
+    // named reexports are per-element though
+    (pStatement.exportClause &&
+      pStatement.exportClause.elements &&
+      pStatement.exportClause.elements.every((pElement) => pElement.isTypeOnly))
   );
 }
 
@@ -47,7 +62,9 @@ function extractImportsAndExports(pAST) {
       module: pStatement.moduleSpecifier.text,
       moduleSystem: "es6",
       exoticallyRequired: false,
-      ...(isTypeOnly(pStatement) ? { dependencyTypes: ["type-only"] } : {}),
+      ...(isTypeOnlyImport(pStatement) || isTypeOnlyExport(pStatement)
+        ? { dependencyTypes: ["type-only"] }
+        : {}),
     }));
 }
 

package/src/extract/resolve/merge-manifests.mjs

@@ -24,12 +24,12 @@ function mergeDependencyArray(pClosestDependencyKey, pFurtherDependencyKey) {
   return uniq(pClosestDependencyKey.concat(pFurtherDependencyKey));
 }
 
-function isDependencyKey(pKey) {
-  return pKey.endsWith("ependencies");
+function isInterestingKey(pKey) {
+  return pKey.endsWith("ependencies") || pKey === "workspaces";
 }
 
 function getDependencyKeys(pPackage) {
-  return Object.keys(pPackage).filter(isDependencyKey);
+  return Object.keys(pPackage).filter(isInterestingKey);
 }
 
 function getJointUniqueDependencyKeys(pClosestPackage, pFurtherPackage) {
@@ -40,6 +40,10 @@ function getJointUniqueDependencyKeys(pClosestPackage, pFurtherPackage) {
   );
 }
 
+function isAnArrayKey(pKey) {
+  return pKey.startsWith("bundle") || pKey === "workspaces";
+}
+
 /**
  * returns an object with
  * - the *dependencies keys from both passed packages
@@ -63,7 +67,7 @@ export default function mergeManifests(pClosestManifest, pFurtherManifest) {
   )
     .map((pKey) => ({
       key: pKey,
-      value: pKey.startsWith("bundle")
+      value: isAnArrayKey(pKey)
         ? mergeDependencyArray(
             pClosestManifest?.[pKey] ?? [],
             pFurtherManifest?.[pKey] ?? [],

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

@@ -154,7 +154,7 @@ function isWorkspaceAliased(pModuleName, pResolvedModuleName, pManifest) {
     //
     // oh and: ```picomatch.isMatch('asdf', 'asdf/**') === true``` so
     // in case it's only 'asdf' that's in the resolved module name for some reason
-    //  we're good as well.
+    // we're good as well.
     const lModuleFriendlyWorkspaceGlobs = pManifest.workspaces.map(
       (pWorkspace) =>
         pWorkspace.endsWith("/") ? `${pWorkspace}**` : `${pWorkspace}/**`,
@@ -185,7 +185,7 @@ function isWorkspaceAliased(pModuleName, pResolvedModuleName, pManifest) {
 /**
  * @param {string} pModuleName
  * @param {string} pResolvedModuleName
- * @param {import("../../../types/resolve-options").IResolveOptions} pResolveOptions
+ * @param {import("../../../types/resolve-options.mjs").IResolveOptions} pResolveOptions
  * @param {string} pBaseDirectory
  * @returns {boolean}
  */
@@ -206,7 +206,7 @@ function isLikelyTSAliased(
 /**
  * @param {string} pModuleName
  * @param {string} pResolvedModuleName
- * @param {import("../../../types/resolve-options").IResolveOptions} pResolveOptions
+ * @param {import("../../../types/resolve-options.mjs").IResolveOptions} pResolveOptions
  * @param {object} pManifest
  * @returns {string[]}
  */
@@ -216,15 +216,32 @@ export function getAliasTypes(
   pResolveOptions,
   pManifest,
 ) {
-  if (isSubpathImport(pModuleName, pManifest)) {
-    return ["aliased", "aliased-subpath-import"];
+  if (isRelativeModuleName(pModuleName)) {
+    return [];
   }
+  // the order of these ifs is deliberate. First stuff bolted on by bundlers & transpilers.
   if (isWebPackAliased(pModuleName, pResolveOptions.alias)) {
     return ["aliased", "aliased-webpack"];
   }
+  // The order of subpath imports and workspaces isn't _that_ important, as they
+  // can't be confused
+  // - subpath imports _must_ start with a #
+  // - workspaces (or, more precise: package names) are forbidden to even _contain_ a #
+  if (isSubpathImport(pModuleName, pManifest)) {
+    return ["aliased", "aliased-subpath-import"];
+  }
   if (isWorkspaceAliased(pModuleName, pResolvedModuleName, pManifest)) {
     return ["aliased", "aliased-workspace"];
   }
+  // We'd like to classify for ts config paths/ aliases earlier, but it's currently
+  // partly guess work (the resolver wouldn't know, so it'd mean checking
+  // against the tsconfig paths _again_ here which might not be conducive to
+  // performance).
+  // Putting it last is close enough for now because
+  // - it's not a common scenario to have _both_ tsconfig paths and one of the
+  //   other (clearly superior) aliasing mechanisms
+  // - if it does happen it's even less likely to have the same names for both
+  //   in both mechanisms
   if (
     isLikelyTSAliased(
       pModuleName,

package/src/meta.js

@@ -1,7 +1,7 @@
 /* generated - don't edit */
 
 module.exports = {
-  version: "15.5.0",
+  version: "16.0.0-beta-1",
   engines: {
     node: "^18.17||>=20",
   },