dependency-cruiser 10.8.0 → 11.0.0

package/package.json

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

package/src/extract/get-dependencies.js

@@ -21,15 +21,18 @@ function extractFromSwcAST(pOptions, pFileName) {
   );
 }
 
-function extractFromTypeScriptAST(pOptions, pFileName) {
+function extractFromTypeScriptAST(pOptions, pFileName, pTranspileOptions) {
   return extractTypeScriptDeps(
-    toTypescriptAST.getASTCached(path.join(pOptions.baseDir, pFileName)),
+    toTypescriptAST.getASTCached(
+      path.join(pOptions.baseDir, pFileName),
+      pTranspileOptions
+    ),
     pOptions.exoticRequireStrings
   );
 }
 
 function isTypeScriptCompatible(pFileName) {
-  return [".ts", ".tsx", ".js", ".mjs", ".cjs"].includes(
+  return [".ts", ".tsx", ".js", ".mjs", ".cjs", ".vue"].includes(
     path.extname(pFileName)
   );
 }
@@ -88,9 +91,11 @@ function extractWithTsc(
   pFileName,
   pTranspileOptions
 ) {
-  pDependencies = extractFromTypeScriptAST(pCruiseOptions, pFileName).filter(
-    (pDep) => pCruiseOptions.moduleSystems.includes(pDep.moduleSystem)
-  );
+  pDependencies = extractFromTypeScriptAST(
+    pCruiseOptions,
+    pFileName,
+    pTranspileOptions
+  ).filter((pDep) => pCruiseOptions.moduleSystems.includes(pDep.moduleSystem));
 
   if (pCruiseOptions.tsPreCompilationDeps === "specify") {
     pDependencies = detectPreCompilationNess(

package/src/extract/parse/to-typescript-ast.js

@@ -2,21 +2,28 @@ const fs = require("fs");
 const tryRequire = require("semver-try-require");
 const _memoize = require("lodash/memoize");
 const { supportedTranspilers } = require("../../../src/meta.js");
+const transpile = require("../transpile");
+const getExtension = require("../utl/get-extension");
 
 const typescript = tryRequire("typescript", supportedTranspilers.typescript);
 
 /**
  * Compiles pTypescriptSource into a (typescript) AST
  *
- * @param {string} pTypescriptSource - the source to compile
- * @param {string} [pFileName] - (optional) file name the typescript
- *                              compiler can use in error messages
+ * @param {object} pFileRecord Record with source code, an extension and a filename
+ * @param {any} [pTranspileOptions] options for the transpiler(s) - a tsconfig or
+ *                                a babel config
  * @return {object} - a (typescript) AST
  */
-function getASTFromSource(pTypescriptSource, pFileName) {
+function getASTFromSource(pFileRecord, pTranspileOptions) {
+  let lSource = pFileRecord.source;
+  if (pFileRecord.extension === ".vue") {
+    lSource = transpile(pFileRecord, pTranspileOptions);
+  }
+
   return typescript.createSourceFile(
-    pFileName || "$internal-file-name",
-    pTypescriptSource,
+    pFileRecord.filename || "$internal-file-name",
+    lSource,
     typescript.ScriptTarget.Latest,
     false
   );
@@ -27,10 +34,19 @@ function getASTFromSource(pTypescriptSource, pFileName) {
  * AST and returns it
  *
  * @param {string} pFileName - the name of the file to compile
+ * @param {any} [pTranspileOptions] options for the transpiler(s) - a tsconfig or
+ *                                a babel config
  * @return {object} - a (typescript) AST
  */
-function getAST(pFileName) {
-  return getASTFromSource(fs.readFileSync(pFileName, "utf8"), pFileName);
+function getAST(pFileName, pTranspileOptions) {
+  return getASTFromSource(
+    {
+      source: fs.readFileSync(pFileName, "utf8"),
+      extension: getExtension(pFileName),
+      filename: pFileName,
+    },
+    pTranspileOptions
+  );
 }
 
 const getASTCached = _memoize(getAST);

package/src/extract/utl/get-extension.js

@@ -5,16 +5,20 @@ const path = require("path");
  *
  * Just using path.extname would be fine for most cases,
  * except for coffeescript, where a markdown extension can
- * mean literate coffeescript.
+ * mean literate coffeescript, and for typescript where
+ * .d.ts and .ts are slightly different beasts
  *
  * @param {string} pFileName path to the file to be parsed
  * @return {string}          extension
  */
 module.exports = function getExtensions(pFileName) {
-  let lReturnValue = path.extname(pFileName);
+  if (pFileName.endsWith(".d.ts")) {
+    return ".d.ts";
+  }
 
-  if (lReturnValue === ".md") {
-    return pFileName.endsWith(".coffee.md") ? ".coffee.md" : lReturnValue;
+  if (pFileName.endsWith(".coffee.md")) {
+    return ".coffee.md";
   }
-  return lReturnValue;
+
+  return path.extname(pFileName);
 };

package/src/meta.js

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

package/types/baseline-violations.d.ts

@@ -1,3 +1,3 @@
-import { IViolation } from "./cruise-result";
+import { IViolation } from "./violations";
 
 export type IBaselineViolations = IViolation[];

package/types/cruise-result.d.ts

@@ -1,11 +1,8 @@
 import { ICruiseOptions } from "./options";
 import { IFlattenedRuleSet } from "./rule-set";
-import {
-  DependencyType,
-  ModuleSystemType,
-  SeverityType,
-  ProtocolType,
-} from "./shared-types";
+import { DependencyType, ModuleSystemType, ProtocolType } from "./shared-types";
+import { IViolation } from "./violations";
+import { IRuleSummary } from "./rule-summary";
 
 export interface ICruiseResult {
   /**
@@ -226,27 +223,6 @@ export interface IDependency {
   valid: boolean;
 }
 
-/**
- * If there was a rule violation (valid === false), this object contains the name of the
- * rule and severity of violating it.
- */
-export interface IRuleSummary {
-  /**
-   * The (short, eslint style) name of the violated rule. Typically something like
-   * 'no-core-punycode' or 'no-outside-deps'.
-   */
-  name: string;
-  /**
-   * How severe a violation of a rule is. The 'error' severity will make some reporters return
-   * a non-zero exit code, so if you want e.g. a build to stop when there's a rule violated:
-   * use that. The absence of the 'ignore' severity here is by design; ignored rules don't
-   * show up in the output.
-   *
-   * Severity to use when a dependency is not in the 'allowed' set of rules. Defaults to 'warn'
-   */
-  severity: SeverityType;
-}
-
 export interface IReachable {
   /**
    * The name of the rule where the reachability was defined
@@ -389,29 +365,6 @@ export interface IWebpackConfig {
  */
 export type WebpackEnvType = { [key: string]: any } | string;
 
-export interface IViolation {
-  /**
-   * The violated rule
-   */
-  rule: IRuleSummary;
-  /**
-   * The from part of the dependency this violation is about
-   */
-  from: string;
-  /**
-   * The to part of the dependency this violation is about
-   */
-  to: string;
-  /**
-   * The circular path if the violation is about circularity
-   */
-  cycle?: string[];
-  /**
-   * The path from the from to the to if the violation is transitive
-   */
-  via?: string[];
-}
-
 export interface IFolder {
   /**
    * The name of the folder. FOlder names are normalized to posix (so
@@ -455,3 +408,6 @@ export interface IFolder {
    */
   instability?: number;
 }
+
+export * from "./violations";
+export * from "./rule-summary";

package/types/rule-summary.d.ts

@@ -0,0 +1,23 @@
+import { SeverityType } from "./shared-types";
+
+/**
+ * If there was a rule violation (valid === false), this object contains the name of the
+ * rule and severity of violating it.
+ */
+
+export interface IRuleSummary {
+  /**
+   * The (short, eslint style) name of the violated rule. Typically something like
+   * 'no-core-punycode' or 'no-outside-deps'.
+   */
+  name: string;
+  /**
+   * How severe a violation of a rule is. The 'error' severity will make some reporters return
+   * a non-zero exit code, so if you want e.g. a build to stop when there's a rule violated:
+   * use that. The absence of the 'ignore' severity here is by design; ignored rules don't
+   * show up in the output.
+   *
+   * Severity to use when a dependency is not in the 'allowed' set of rules. Defaults to 'warn'
+   */
+  severity: SeverityType;
+}

package/types/violations.d.ts

@@ -0,0 +1,24 @@
+import { IRuleSummary } from "./rule-summary";
+
+export interface IViolation {
+  /**
+   * The violated rule
+   */
+  rule: IRuleSummary;
+  /**
+   * The from part of the dependency this violation is about
+   */
+  from: string;
+  /**
+   * The to part of the dependency this violation is about
+   */
+  to: string;
+  /**
+   * The circular path if the violation is about circularity
+   */
+  cycle?: string[];
+  /**
+   * The path from the from to the to if the violation is transitive
+   */
+  via?: string[];
+}