fix: remove escomplex in favor of in-house halstead+cyclomatic implem

Author: simonrenoult

package-lock.json

@@ -42,18 +42,17 @@
   "license": "MIT",
   "dependencies": {
     "@babel/core": "7.28.3",
+    "@babel/parser": "7.28.3",
     "@babel/plugin-transform-typescript": "7.28.0",
+    "@babel/preset-env": "7.28.3",
     "cli-table3": "0.6.5",
     "commander": "10.0.1",
     "debug": "4.4.1",
-    "escomplex": "2.0.0-alpha",
-    "esprima": "4.0.1",
     "micromatch": "4.0.8",
     "node-sloc": "0.2.1"
   },
   "devDependencies": {
-    "@babel/preset-env": "7.28.3",
-    "@types/babel__core": "^7.20.5",
+    "@types/babel__core": "7.20.5",
     "@types/debug": "4.1.12",
     "@types/micromatch": "4.0.9",
     "@typescript-eslint/eslint-plugin": "5.42.1",
@@ -67,8 +66,5 @@
     "prettier": "2.8.8",
     "ts-node": "10.9.2",
     "typescript": "4.9.5"
-  },
-  "bundleDependencies": [
-    "esprima"
-  ]
+  }
 }

package.json

@@ -0,0 +1,123 @@
+import * as assert from "node:assert";
+import { readFileSync } from "node:fs";
+import { ParseResult, traverse } from "@babel/core";
+import { parse, ParserOptions } from "@babel/parser";
+
+type FunctionComplexity = { name: string; complexity: number };
+
+export function compute(path: string, options: ParserOptions) {
+  const code = readFileSync(path, { encoding: "utf8" });
+  const ast = parse(code, options);
+  assert.ok(ast);
+  return cyclomaticForAst(ast, code, options);
+}
+
+export function cyclomaticForAst(
+  ast: ParseResult,
+  code: string,
+  options: ParserOptions
+): number {
+  const results: FunctionComplexity[] = [];
+  let hasTopLevelStatements = false;
+
+  traverse(ast, {
+    FunctionDeclaration(path) {
+      const fnCode = code.slice(
+        path.node.start ?? undefined,
+        path.node.end ?? undefined
+      );
+      results.push({
+        name: path.node.id?.name || "<anonymous>",
+        complexity: cyclomaticForCode(fnCode, options),
+      });
+    },
+    FunctionExpression(path) {
+      const fnCode = code.slice(
+        path.node.start ?? undefined,
+        path.node.end ?? undefined
+      );
+      results.push({
+        name: path.node.id?.name || "<anonymous>",
+        complexity: cyclomaticForCode(fnCode, options),
+      });
+    },
+    ArrowFunctionExpression(path) {
+      const fnCode = code.slice(
+        path.node.start ?? undefined,
+        path.node.end ?? undefined
+      );
+      let name = "<arrow>";
+      if (path.parent.type === "VariableDeclarator" && path.parent.id) {
+        assert.ok("name" in path.parent.id);
+        name = path.parent.id.name;
+      }
+      results.push({
+        name,
+        complexity: cyclomaticForCode(fnCode, options),
+      });
+    },
+
+    enter(path) {
+      const topLevelTypes = [
+        "ExpressionStatement",
+        "IfStatement",
+        "ForStatement",
+        "ForInStatement",
+        "ForOfStatement",
+        "WhileStatement",
+        "DoWhileStatement",
+        "SwitchStatement",
+        "TryStatement",
+      ];
+      if (path.parent.type === "Program" && topLevelTypes.includes(path.type)) {
+        hasTopLevelStatements = true;
+      }
+    },
+  });
+
+  return hasTopLevelStatements
+    ? cyclomaticForCode(code, options)
+    : results.reduce((prev, cur) => prev + cur.complexity, 0);
+}
+
+function cyclomaticForCode(code: string, options: ParserOptions) {
+  const ast = parse(code, options);
+  assert.ok(ast);
+
+  let complexity = 1;
+
+  traverse(ast, {
+    IfStatement() {
+      complexity++;
+    },
+    ForStatement() {
+      complexity++;
+    },
+    ForInStatement() {
+      complexity++;
+    },
+    ForOfStatement() {
+      complexity++;
+    },
+    WhileStatement() {
+      complexity++;
+    },
+    DoWhileStatement() {
+      complexity++;
+    },
+    SwitchCase(path) {
+      if (path.node.test) complexity++;
+    },
+    ConditionalExpression() {
+      complexity++;
+    },
+    LogicalExpression(path) {
+      if (["&&", "||"].includes(path.node.operator)) complexity++;
+    },
+    CatchClause() {
+      complexity++;
+    },
+  });
+
+  return complexity;
+}

src/lib/complexity/strategies/cyclomatic.ts

@@ -0,0 +1,27 @@
+import { extname } from "node:path";
+
+import { buildDebugger, UnsupportedExtension } from "../../../../utils";
+import { compute as computeFromBabel } from "./cyclomatic.babel";
+
+const internal = { debug: buildDebugger("cyclomatic") };
+
+export function calculate(path: string): number | UnsupportedExtension {
+  internal.debug(`Processing ${path}...`);
+
+  switch (extname(path)) {
+    case ".ts":
+      return computeFromBabel(path, {
+        sourceType: "unambiguous",
+        plugins: ["typescript"],
+      });
+    case ".mjs":
+    case ".cjs":
+    case ".js":
+      return computeFromBabel(path, { sourceType: "unambiguous" });
+    default:
+      internal.debug(
+        "Unsupported file extension. Falling back on default complexity (1)"
+      );
+      return new UnsupportedExtension();
+  }
+}