js-code-detector 0.0.19 → 0.0.21

package/dist/cjs/index.d.ts

@@ -1,3 +1,5 @@
+export declare const gitDiffFileName = "git_diff.txt";
+export declare const gitDiffJsonName = "git_diff.json";
 export declare function umiPluginCallback(api: any): Promise<void>;
 export declare function writeGitDiffTxt(gitUrl: string, branchName: string): Promise<string>;
 export declare function getGitRepositoryAndBranch(): Promise<{

package/dist/cjs/index.js

@@ -33,6 +33,8 @@ __export(src_exports, {
   getEslintCheckResult: () => getEslintCheckResult,
   getGitRepositoryAndBranch: () => getGitRepositoryAndBranch,
   gitDiffDetect: () => gitDiffDetect,
+  gitDiffFileName: () => gitDiffFileName,
+  gitDiffJsonName: () => gitDiffJsonName,
   sameCodeDetect: () => sameCodeDetect,
   umiPluginCallback: () => umiPluginCallback,
   writeGitDiffTxt: () => writeGitDiffTxt
@@ -51,6 +53,7 @@ var import_readDirFiles = require("./util/shared/readDirFiles");
 var import_Core = __toESM(require("./util/ast_util/Core"));
 var import_constants = require("./util/constants");
 var import_await_to_js = __toESM(require("await-to-js"));
+var import_generateGitDiffReport = require("./util/report_util/generateGitDiffReport");
 var jsonName = "git_diff_report.md";
 var gitDiffFileName = "git_diff.txt";
 var gitDiffJsonName = "git_diff.json";
@@ -151,9 +154,12 @@ async function gitDiffDetect() {
   import_utils.logger.ready("准备生成插件文件");
   (0, import_fs2.writeFileSync)((0, import_path.join)(process.cwd(), today, "target", "plugin.ts"), pluginFileContent, { encoding: "utf-8", flag: "w" });
   import_utils.logger.info("插件文件生成完成");
-  import_utils.logger.wait("准备生成报告");
-  await import_utils.execa.execa(`cd ${today}/target && yarn install && npm run build`, { shell: "/bin/bash" });
-  import_utils.logger.info("报告生成完成！");
+  import_utils.logger.wait("准备生成 入口文件");
+  await import_utils.execa.execa(`cd ${today}/target && npx max setup`, { shell: "/bin/bash" });
+  import_utils.logger.info("入口文件 生成完成！");
+  import_utils.logger.ready("准备生成报告");
+  await (0, import_generateGitDiffReport.generateGitDiffReport)({ targetDirPath: (0, import_path.join)(process.cwd(), today, "target") });
+  import_utils.logger.info("报告完成");
   import_utils.logger.ready("准备移动报告");
   const content = (0, import_fs.readFileSync)((0, import_path.join)(process.cwd(), today, "target", jsonName), "utf-8");
   const mdFileName = `${(0, import_dayjs.default)().format("YYYYMDD_HHmm")}_${jsonName}`;
@@ -192,6 +198,8 @@ async function getEslintCheckResult(today) {
   getEslintCheckResult,
   getGitRepositoryAndBranch,
   gitDiffDetect,
+  gitDiffFileName,
+  gitDiffJsonName,
   sameCodeDetect,
   umiPluginCallback,
   writeGitDiffTxt

package/dist/cjs/util/ast_util/AstUtil.d.ts

@@ -25,6 +25,7 @@ export interface AstNode {
         uuid: string;
         variableScope: AstNode[];
         dependenceIds: Set<AstNode>;
+        dependenceIdsNoScope: Set<AstNode>;
         holdingIds: Set<AstNode>;
         holdingIdNameMap: Map<string, Set<AstNode>>;
         holdingIdType: 'Import' | 'Variable' | 'Function' | 'Class' | 'Param' | null;
@@ -40,6 +41,7 @@ export default class AstUtil {
     static deepFirstTravel(node: AstNode, filePath: string, mapUuidToNode: Map<string, AstNode>, mapFileLineToNodeSet: Map<number, Set<AstNode>>, mapPathToNodeSet: Map<string, Set<AstNode>>): AstNode | undefined;
     private static _deepFirstTravel;
     private static collectInjectAndProvide;
+    private static handleDeclaration;
     private static collectHoldingIds;
     private static isVarInit;
     static isReturnArgument(node: AstNode): boolean;
@@ -58,6 +60,8 @@ export default class AstUtil {
     private static isBodyArray;
     private static findExportIdentifiers;
     private static expressionTypeIsIdentifier;
+    static collectExpressionIdentifiersShallow(exp: AstNode | null, callback: (identifier: AstNode) => void): void;
+    private static _collectExpressionIdentifiersShallow;
     static collectExpressionIdentifiers(exp: AstNode | null, callback: (identifier: AstNode) => void): void;
     private static _collectExpressionIdentifiers;
     static deepFindIdOfExpression(exp: AstNode | null, callback: (identifier: AstNode) => void): void;

package/dist/cjs/util/ast_util/AstUtil.js

@@ -57,6 +57,7 @@ var _AstUtil = class {
       uuid: "",
       variableScope: [],
       dependenceIds: /* @__PURE__ */ new Set(),
+      dependenceIdsNoScope: /* @__PURE__ */ new Set(),
       holdingIdType: null,
       holdingIds: /* @__PURE__ */ new Set(),
       holdingIdNameMap: /* @__PURE__ */ new Map(),
@@ -137,6 +138,18 @@ var _AstUtil = class {
       }
     });
   }
+  static handleDeclaration(node, callback) {
+    if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+      const id = node.id;
+      if (id) {
+        callback(id);
+      }
+    } else if (node.type === "VariableDeclaration") {
+      this.findIdOfVariable(node, (id) => {
+        callback(id);
+      });
+    }
+  }
   static collectHoldingIds(node) {
     const { holdingIds, holdingIdNameMap } = node._util;
     if (this.isBodyArray(node)) {
@@ -149,18 +162,33 @@ var _AstUtil = class {
             id._util.holdingIdType = "Import";
           });
         } else if (cur.type === "FunctionDeclaration" || cur.type === "ClassDeclaration") {
-          const id = cur.id;
-          if (id) {
+          this.handleDeclaration(cur, (id) => {
             holdingIds.add(id);
             id._util.variableScope = [id];
             id._util.holdingIdType = cur.type === "ClassDeclaration" ? "Class" : "Function";
-          }
+          });
         } else if (cur.type === "VariableDeclaration") {
-          this.findIdOfVariable(cur, (id) => {
+          this.handleDeclaration(cur, (id) => {
             holdingIds.add(id);
             id._util.variableScope = [id];
             id._util.holdingIdType = "Variable";
           });
+        } else if (cur.type === "ExportDefaultDeclaration") {
+          const declaration = cur.declaration;
+          this.handleDeclaration(declaration, (id) => {
+            holdingIds.add(id);
+            id._util.variableScope = [id];
+            id._util.holdingIdType = cur.type === "ClassDeclaration" ? "Class" : "Function";
+          });
+        } else if (cur.type === "ExportNamedDeclaration") {
+          const { declaration } = cur;
+          if (declaration) {
+            this.handleDeclaration(declaration, (id) => {
+              holdingIds.add(id);
+              id._util.variableScope = [id];
+              id._util.holdingIdType = "Variable";
+            });
+          }
         }
       });
     }
@@ -183,9 +211,8 @@ var _AstUtil = class {
         }
       });
     }
-    if (["FunctionDeclaration", "ArrowFunctionExpression", "FunctionExpression"].includes(node.type)) {
-      const params = node.params;
-      params.forEach((param) => this._deepFindIdentifier(param, (id) => {
+    if (["FunctionDeclaration", "ArrowFunctionExpression", "FunctionExpression", "ObjectMethod"].includes(node.type)) {
+      node.params.forEach((param) => this._deepFindIdentifier(param, (id) => {
         holdingIds.add(id || node);
         id._util.variableScope = [id];
         id._util.holdingIdType = "Param";
@@ -207,18 +234,26 @@ var _AstUtil = class {
     return node._util.parentProperty === "argument" && ((_a = node._util.parent) == null ? void 0 : _a.type) === "ReturnStatement";
   }
   static collectDependenceIds(node) {
-    const { nodeCollection, dependenceIds, holdingIdNameMap } = node._util;
-    nodeCollection.forEach((e) => {
-      this.findExportIdentifiers(e, (id) => dependenceIds.add(id));
-      this.collectExpressionIdentifiers(e, (id) => dependenceIds.add(id));
+    const { type, _util } = node;
+    const { dependenceIds, holdingIdNameMap, children, dependenceIdsNoScope } = _util;
+    children.forEach((child) => {
+      if (child._util.dependenceIdsNoScope.size > 0) {
+        child._util.dependenceIdsNoScope.forEach((id) => dependenceIds.add(id));
+      }
+      this.findExportIdentifiers(child, (id) => dependenceIds.add(id));
+      this.collectExpressionIdentifiersShallow(child, (id) => dependenceIds.add(id));
     });
     for (const dependenceId of dependenceIds) {
       if (dependenceId._util.variableScope.length === 0) {
         const sameNameIds = [...holdingIdNameMap.get(dependenceId.name) || []];
-        dependenceId._util.variableScope.push(...sameNameIds);
-        const firstPick = sameNameIds[0];
-        if (firstPick && firstPick._util.uuid !== dependenceId._util.uuid) {
-          firstPick._util.effectIds.add(dependenceId);
+        if (sameNameIds.length > 0) {
+          dependenceId._util.variableScope.push(...sameNameIds);
+          const firstPick = sameNameIds[0];
+          if (firstPick && firstPick._util.uuid !== dependenceId._util.uuid) {
+            firstPick._util.effectIds.add(dependenceId);
+          }
+        } else {
+          dependenceIdsNoScope.add(dependenceId);
         }
       }
     }
@@ -418,6 +453,35 @@ var _AstUtil = class {
   static expressionTypeIsIdentifier(exp) {
     return (exp == null ? void 0 : exp.type) === "Identifier";
   }
+  static collectExpressionIdentifiersShallow(exp, callback) {
+    if (!exp || exp.type === "ThisExpression") {
+      return;
+    }
+    this._collectExpressionIdentifiersShallow(exp, callback);
+  }
+  static _collectExpressionIdentifiersShallow(exp, callback) {
+    var _a, _b, _c;
+    if (!exp || exp.type === "ThisExpression") {
+      return;
+    }
+    if (exp._util.holdingIdType !== null) {
+      return;
+    }
+    if (exp.type === "Identifier") {
+      if (exp._util.parentProperty === "property" || exp._util.parentProperty === "key") {
+        if (exp._util.parent.computed) {
+          callback(exp);
+        }
+      } else if (!((_b = (_a = exp._util.parent) == null ? void 0 : _a.type) == null ? void 0 : _b.startsWith("TS"))) {
+        callback(exp);
+      }
+      return;
+    }
+    if (exp.type === "JSXIdentifier" && ((_c = exp._util.parent) == null ? void 0 : _c.type) !== "JSXAttribute") {
+      callback(exp);
+      return;
+    }
+  }
   static collectExpressionIdentifiers(exp, callback) {
     if (!exp || exp.type === "ThisExpression") {
       return;
@@ -564,6 +628,10 @@ var _AstUtil = class {
     if (!id) {
       return;
     }
+    if (id.type === "AssignmentPattern") {
+      const left = id.left;
+      this._deepFindIdentifier(left, callback);
+    }
     if (id.type === "Identifier") {
       callback(id);
     }
@@ -574,8 +642,11 @@ var _AstUtil = class {
           const argument = property.argument;
           this._deepFindIdentifier(argument, callback);
         } else {
-          const value = property.value;
+          const { value, key, computed } = property;
           this._deepFindIdentifier(value, callback);
+          if (computed) {
+            this._deepFindIdentifier(key, callback);
+          }
         }
       }
     }

package/dist/cjs/util/ast_util/FileUtil.js

@@ -36,6 +36,7 @@ __export(FileUtil_exports, {
 module.exports = __toCommonJS(FileUtil_exports);
 var babelParse = __toESM(require("@babel/parser"));
 var vueParse = __toESM(require("vue-eslint-parser"));
+var import_fs = __toESM(require("fs"));
 var extensionsOfJs = [".js", ".jsx", ".ts", ".tsx"];
 var extensions = [...extensionsOfJs, ".vue"];
 var commonParsePlugins = [
@@ -131,8 +132,13 @@ var FileUtil = class {
     return ["", null];
   }
   static getASTByFilePath(filePath) {
-    const fileContent = require("fs").readFileSync(filePath, "utf8");
-    return this.parseFile(filePath, fileContent)[1];
+    const existFlag = import_fs.default.existsSync(filePath);
+    if (existFlag) {
+      const fileContent = import_fs.default.readFileSync(filePath, "utf8");
+      return this.parseFile(filePath, fileContent)[1];
+    }
+    console.warn("文件不存在: " + filePath);
+    return null;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/util/ast_util/getAstKitByFilePath.js

@@ -36,10 +36,10 @@ var import_AstUtil = __toESM(require("./AstUtil"));
 var import_FileUtil = __toESM(require("./FileUtil"));
 var mapFilePathToTools = /* @__PURE__ */ new Map();
 var createMapFileLineToNodeSet = (file, absPathPrefix) => {
-  const ast = import_FileUtil.default.getASTByFilePath(file);
   const mapUuidToNode = /* @__PURE__ */ new Map();
   const mapPathToNodeSet = /* @__PURE__ */ new Map();
   const mapFileLineToNodeSet = /* @__PURE__ */ new Map();
+  const ast = import_FileUtil.default.getASTByFilePath(file);
   const filePathRelative = file.replace(absPathPrefix, "");
   import_AstUtil.default.deepFirstTravel(ast, filePathRelative, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet);
   return { mapFileLineToNodeSet, mapUuidToNode, mapPathToNodeSet };

package/dist/cjs/util/report_util/createMdByJson.js

@@ -40,7 +40,7 @@ function reportItemToMd(report) {
     `## ${filePath}`,
     `### 类型: ${mapReportType[type]}`,
     filesDependsOnMe.length > 0 ? `### 所影响的文件(重要性由高到低)
-${filesDependsOnMe.map((files, index) => files.map((file) => "  ".repeat(index) + `- ${file}`)).flat().join("\n")}` : "",
+${filesDependsOnMe.slice(0, 1).map((files, index) => files.map((file) => "  ".repeat(index) + `- ${file}`)).flat().join("\n")}` : "",
     undefinedIdentifiers.length > 0 ? `### 未定义的变量
 > ${undefinedIdentifiers.map((e) => `**${e}**`).join(", ")}` : "",
     dangerIdentifiers.length > 0 ? `### 重点检查使用的变量

package/dist/cjs/util/report_util/diffBlockDetect.js

@@ -60,8 +60,9 @@ function diffBlockDetect(gitDiffDetail, index, extra) {
   const { reportItem, absPathPrefix } = extra;
   const { blockReports, _fileRemovedNodesPaths, _fileAddedNodesPaths } = reportItem;
   const blockReportItem = findOrCreateBlockReport(blockReports, index);
-  const { mapFileLineToNodeSet, mapUuidToNode } = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
-  const filePathOfOld = (0, import_path.join)(process.cwd(), "..", import_constants.SOURCE, filePath);
+  const filePathOfOld = (0, import_path.join)((0, import_path.dirname)(absPathPrefix), import_constants.SOURCE, filePath);
+  const filePathOfNew = (0, import_path.join)((0, import_path.dirname)(absPathPrefix), import_constants.TARGET, filePath);
+  const { mapFileLineToNodeSet, mapUuidToNode } = (0, import_getAstKitByFilePath.default)(filePathOfNew, absPathPrefix);
   const { mapFileLineToNodeSet: mapFileLineToNodeSetOld } = (0, import_getAstKitByFilePath.default)(filePathOfOld, absPathPrefix.replace(`${import_constants.TARGET}/`, `${import_constants.SOURCE}/`));
   const programNode = mapUuidToNode.get("Program");
   if (programNode) {

package/dist/cjs/util/report_util/generateGitDiffReport.d.ts

@@ -0,0 +1,3 @@
+export declare function generateGitDiffReport(arg: {
+    targetDirPath: string;
+}): Promise<void>;

package/dist/cjs/util/report_util/generateGitDiffReport.js

@@ -0,0 +1,145 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/report_util/generateGitDiffReport.ts
+var generateGitDiffReport_exports = {};
+__export(generateGitDiffReport_exports, {
+  generateGitDiffReport: () => generateGitDiffReport
+});
+module.exports = __toCommonJS(generateGitDiffReport_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import__ = require("../../index");
+var import_format_git_diff_content = require("../format_git_diff_content");
+var import_utils = require("@umijs/utils");
+var import_report_util = require("../report_util");
+var import_createMdByJson = require("./createMdByJson");
+var MADGE_NAME = "madge";
+var userAliasGetter = (cwd, appData) => {
+  var _a;
+  return ((_a = appData.config) == null ? void 0 : _a.alias) || {
+    umi: "@@/exports",
+    "@": cwd + "/src",
+    "@@": cwd + "/src/.umi",
+    "@umijs/max": "@@/exports"
+  };
+};
+var reportFileName = "git_diff_report.md";
+async function generateGitDiffReport(arg) {
+  const { targetDirPath } = arg;
+  const absSrcPath = (0, import_path.join)(targetDirPath, "src");
+  const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(targetDirPath, import__.gitDiffFileName), "utf-8");
+  const gitDiffDetail = (0, import_format_git_diff_content.formatGitDiffContent)(diff_txt);
+  (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, import__.gitDiffJsonName), JSON.stringify(gitDiffDetail, null, 2), { encoding: "utf-8", flag: "w" });
+  const tsconfig = await import_utils.tsconfigPaths.loadConfig(targetDirPath);
+  const appDataContent = (0, import_fs.readFileSync)((0, import_path.join)(targetDirPath, "src", ".umi", "appData.json"), "utf-8");
+  let appData = { config: null };
+  try {
+    appData = JSON.parse(appDataContent);
+  } catch (e) {
+    console.warn("appData.json 解析失败，将使用默认别名");
+  }
+  const userAlias = userAliasGetter(targetDirPath, appData);
+  const exclude = [/node_modules/, /\.d\.ts$/, /\.umi/];
+  const isExclude = (path) => {
+    return exclude.some((reg) => reg.test(path));
+  };
+  const parsedAlias = import_utils.aliasUtils.parseCircleAlias({
+    alias: userAlias
+  });
+  const filteredAlias = Object.keys(parsedAlias).reduce(
+    (acc, key) => {
+      var _a, _b;
+      const value = parsedAlias[key];
+      if (isExclude(value)) {
+        return acc;
+      }
+      if ((_a = tsconfig.paths) == null ? void 0 : _a[key]) {
+        return acc;
+      }
+      const tsconfigValue = [(0, import_path.join)((0, import_path.relative)(targetDirPath, value), "/*")];
+      const tsconfigKey = `${key}/*`;
+      if ((_b = tsconfig.paths) == null ? void 0 : _b[tsconfigKey]) {
+        return acc;
+      }
+      acc[tsconfigKey] = tsconfigValue;
+      return acc;
+    },
+    {}
+  );
+  const devTmpDir = (0, import_path.join)(absSrcPath, ".umi");
+  const exportsFile = (0, import_path.join)(devTmpDir, "exports.ts");
+  const madgePkg = (0, import_path.dirname)(
+    import_utils.resolve.sync(`${MADGE_NAME}/package.json`, {
+      basedir: process.cwd()
+    })
+  );
+  const madge = require(madgePkg);
+  const madgeConfig = {
+    tsConfig: {
+      compilerOptions: {
+        baseUrl: targetDirPath,
+        paths: {
+          ...filteredAlias,
+          ...tsconfig.paths,
+          umi: [exportsFile],
+          "@umijs/max": [exportsFile]
+        },
+        target: "esnext",
+        module: "esnext",
+        moduleResolution: "node",
+        importHelpers: true,
+        jsx: "react-jsx",
+        esModuleInterop: true,
+        strict: true,
+        resolveJsonModule: true,
+        allowSyntheticDefaultImports: true
+      }
+    },
+    fileExtensions: ["ts", "tsx", "js", "jsx"],
+    excludeRegExp: exclude,
+    baseDir: targetDirPath
+  };
+  const res = await madge((0, import_path.join)(devTmpDir, "umi.ts"), madgeConfig);
+  const treeMap = res.tree;
+  const dependenceMap = Object.keys(treeMap).reduce(
+    (acc, key) => {
+      const path = (0, import_utils.winPath)((0, import_path.join)(targetDirPath, key));
+      acc[path] = true;
+      return acc;
+    },
+    {}
+  );
+  const usingFiles = (0, import_utils.readDirFiles)({
+    dir: absSrcPath,
+    exclude
+  }).filter(({ filePath }) => dependenceMap[filePath]);
+  const tree = res.tree;
+  const absPathPrefix = targetDirPath + "/";
+  const usingFileNoPrefix = usingFiles.map((item) => item.filePath.replace(absPathPrefix, ""));
+  const groupGitDiffLines = gitDiffDetail.filter((item) => usingFileNoPrefix.includes(item.filePath));
+  (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "reports_helper.json"), JSON.stringify({ groupGitDiffLines, absPathPrefix, tree, filteredAlias, parsedAlias, tsconfig, madgeConfig }, null, 2), { encoding: "utf-8", flag: "w" });
+  const reports = (0, import_report_util.createDetectReport)({ groupGitDiffLines, tree, absPathPrefix });
+  (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "reports.json"), JSON.stringify(reports, null, 2), { encoding: "utf-8", flag: "w" });
+  const mdContent = (0, import_createMdByJson.createMdByJson)(reports);
+  (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, reportFileName), mdContent, { encoding: "utf-8", flag: "w" });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateGitDiffReport
+});

package/dist/cjs/util/report_util/getMadgeInstance.d.ts

@@ -0,0 +1 @@
+export declare function getMadgeInstance(devTmpDir: string, targetDirPath: string, exclude: RegExp[], filteredAlias: Record<string, string[]>, tsconfig?: any): Promise<void>;

package/dist/cjs/util/report_util/getMadgeInstance.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/report_util/getMadgeInstance.ts
+var getMadgeInstance_exports = {};
+__export(getMadgeInstance_exports, {
+  getMadgeInstance: () => getMadgeInstance
+});
+module.exports = __toCommonJS(getMadgeInstance_exports);
+var import_path = require("path");
+var import_utils = require("@umijs/utils");
+var MADGE_NAME = "madge";
+async function getMadgeInstance(devTmpDir, targetDirPath, exclude, filteredAlias, tsconfig = {}) {
+  const exportsFile = (0, import_path.join)(devTmpDir, "exports.ts");
+  const madgePkg = (0, import_path.dirname)(
+    import_utils.resolve.sync(`${MADGE_NAME}/package.json`, {
+      basedir: process.cwd()
+    })
+  );
+  const madge = require(madgePkg);
+  const madgeConfig = {
+    tsConfig: {
+      compilerOptions: {
+        baseUrl: tsconfig.baseUrl,
+        paths: {
+          ...filteredAlias,
+          ...tsconfig.paths,
+          umi: [exportsFile],
+          "@umijs/max": [exportsFile]
+        },
+        target: "esnext",
+        module: "esnext",
+        moduleResolution: "node",
+        importHelpers: true,
+        jsx: "react-jsx",
+        esModuleInterop: true,
+        strict: true,
+        resolveJsonModule: true,
+        allowSyntheticDefaultImports: true
+      }
+    },
+    fileExtensions: ["ts", "tsx", "js", "jsx"],
+    excludeRegExp: exclude,
+    baseDir: targetDirPath
+  };
+  const res = await madge((0, import_path.join)(devTmpDir, "umi.ts"), madgeConfig);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMadgeInstance
+});

package/dist/cjs/util/report_util.js

@@ -36,6 +36,7 @@ var import_AstUtil = __toESM(require("./ast_util/AstUtil"));
 var import_file_identifier_detect = require("./report_util/file_identifier_detect");
 var import_getFileDepends = __toESM(require("./report_util/getFileDepends"));
 var import_diffBlockDetect = require("./report_util/diffBlockDetect");
+var import_path = require("path");
 function createDetectReport(arg) {
   const { groupGitDiffLines, tree, absPathPrefix } = arg;
   const reports = [];
@@ -56,8 +57,8 @@ function createDetectReport(arg) {
       };
       reports.push(reportItem);
     }
-    reportItem.undefinedIdentifiers = (0, import_file_identifier_detect.extractUndefinedIdentifiers)(filePath, absPathPrefix);
-    reportItem.dangerIdentifiers = (0, import_file_identifier_detect.fileIdentifierDetect)(filePath, absPathPrefix);
+    reportItem.undefinedIdentifiers = (0, import_file_identifier_detect.extractUndefinedIdentifiers)((0, import_path.join)(absPathPrefix, filePath), absPathPrefix);
+    reportItem.dangerIdentifiers = (0, import_file_identifier_detect.fileIdentifierDetect)((0, import_path.join)(absPathPrefix, filePath), absPathPrefix);
     if (type === "modify") {
       (0, import_diffBlockDetect.diffBlockDetect)(item, index, { reportItem, absPathPrefix });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-code-detector",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",
@@ -8,7 +8,7 @@
     "dev": "father dev",
     "build": "father build",
     "build:deps": "father prebundle",
-    "prepublishOnly": "father doctor && npm run build"
+    "prepublishOnly": "nrm use npm && father doctor && npm run build"
   },
   "keywords": [],
   "authors": [