js-code-detector 0.0.15 → 0.0.17

package/bin/eslintOutput.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/cjs/index').getEslintCheckResult();

package/dist/cjs/index.d.ts

@@ -7,3 +7,4 @@ export declare function getGitRepositoryAndBranch(): Promise<{
 export declare function generateReport(content: string): void;
 export declare function sameCodeDetect(dirOfCwd?: string): Promise<void>;
 export declare function gitDiffDetect(): Promise<void>;
+export declare function getEslintCheckResult(today: string): Promise<void>;

package/dist/cjs/index.js

@@ -8,13 +8,13 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
+var __copyProps = (to2, 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 });
+      if (!__hasOwnProp.call(to2, key) && key !== except)
+        __defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return to;
+  return to2;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   generateReport: () => generateReport,
+  getEslintCheckResult: () => getEslintCheckResult,
   getGitRepositoryAndBranch: () => getGitRepositoryAndBranch,
   gitDiffDetect: () => gitDiffDetect,
   sameCodeDetect: () => sameCodeDetect,
@@ -48,10 +49,17 @@ var import_dayjs = __toESM(require("dayjs"));
 var import_createMdByJson = require("./util/report_util/createMdByJson");
 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 jsonName = "git_diff_report.md";
+var gitDiffFileName = "git_diff.txt";
+var gitDiffJsonName = "git_diff.json";
+var eslintJsonName = "eslint-report.json";
+var eslintFinalJsonName = "eslint-final-report.json";
 async function umiPluginCallback(api) {
-  const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(api.cwd, "git_diff.txt"), "utf-8");
+  const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(api.cwd, gitDiffFileName), "utf-8");
   const gitDiffDetail = (0, import_format_git_diff_content.formatGitDiffContent)(diff_txt);
+  (0, import_fs2.writeFileSync)((0, import_path.join)(api.cwd, gitDiffJsonName), JSON.stringify(gitDiffDetail, null, 2), { encoding: "utf-8", flag: "w" });
   const madgeUtil = await (0, import_madge_util.default)(api);
   if (!madgeUtil) {
     return;
@@ -131,19 +139,19 @@ async function gitDiffDetect() {
   import_utils.logger.ready("准备clone源代码到临时目录下的target文件夹");
   await import_utils.execa.execa(`git clone ${gitUrl} ${today}/target`, { shell: "/bin/bash" });
   import_utils.logger.info("源代码clone完成");
-  import_utils.logger.ready("准备clone源代码到临时目录下的source文件夹");
-  await import_utils.execa.execa(`git clone ${gitUrl} ${today}/source`, { shell: "/bin/bash" });
+  import_utils.logger.ready(`准备clone源代码到临时目录下的 ${import_constants.SOURCE} 文件夹`);
+  await import_utils.execa.execa(`git clone ${gitUrl} ${today}/${import_constants.SOURCE}`, { shell: "/bin/bash" });
   import_utils.logger.info("源代码clone完成");
   import_utils.logger.ready("准备切换到目标分支");
   await import_utils.execa.execa(`cd ${today}/target && git fetch origin ${branchName}:${branchName} && git checkout ${branchName}`, { shell: "/bin/bash" });
   import_utils.logger.info("分支切换完成");
   import_utils.logger.ready("准备生成git_diff.txt文件");
-  await import_utils.execa.execa(`cd ${today}/target && git diff master..${branchName} --unified=0 --output=git_diff.txt`, { shell: "/bin/bash" });
+  await import_utils.execa.execa(`cd ${today}/target && git diff master..${branchName} --unified=0 --output=${gitDiffFileName}`, { shell: "/bin/bash" });
   import_utils.logger.info("git_diff.txt文件生成完成");
   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.ready("准备生成报告");
+  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.ready("准备移动报告");
@@ -151,10 +159,37 @@ async function gitDiffDetect() {
   const mdFileName = `${(0, import_dayjs.default)().format("YYYYMDD_HHmm")}_${jsonName}`;
   (0, import_fs2.writeFileSync)((0, import_path.join)(process.cwd(), mdFileName), content, { encoding: "utf-8", flag: "w" });
   import_utils.logger.info("报告完成: " + mdFileName);
+  await getEslintCheckResult(today);
+  (0, import_utils.rimraf)((0, import_path.join)(process.cwd(), today), () => {
+    import_utils.logger.info("临时目录已删除");
+  });
+}
+async function getEslintCheckResult(today) {
+  today = today || (0, import_dayjs.default)().format("YYYYMDD");
+  import_utils.logger.ready("准备生成 eslint 类型检查 json");
+  await (0, import_await_to_js.default)(import_utils.execa.execa(`cd ${today}/target && npx eslint src --ext .js,.jsx,.ts,.tsx --format json -o ${eslintJsonName}`, { shell: "/bin/bash" }));
+  import_utils.logger.info("eslint 类型检查 json 生成完成");
+  import_utils.logger.ready(`读取 ${eslintJsonName} 文件内容,并解析`);
+  let eslintJson = [];
+  {
+    const content = (0, import_fs.readFileSync)((0, import_path.join)(process.cwd(), today, "target", eslintJsonName), "utf-8");
+    try {
+      eslintJson = JSON.parse(content);
+    } catch (error) {
+      import_utils.logger.error("解析json文件失败");
+    }
+  }
+  const validEslintJson = eslintJson.filter((e) => {
+    const { filePath, ...rest } = e;
+    return Object.values(rest).some((v) => Array.isArray(v) && v.length > 0 || !Array.isArray(v) && v);
+  });
+  (0, import_fs2.writeFileSync)((0, import_path.join)(process.cwd(), eslintFinalJsonName), JSON.stringify(validEslintJson, null, 2), { encoding: "utf-8", flag: "w" });
+  import_utils.logger.info(`${eslintFinalJsonName} 文件生成`);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   generateReport,
+  getEslintCheckResult,
   getGitRepositoryAndBranch,
   gitDiffDetect,
   sameCodeDetect,

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

@@ -1,4 +1,5 @@
 export interface AstNode {
+    computed?: boolean;
     type: string;
     name?: string;
     start?: number | null;
@@ -26,71 +27,48 @@ export interface AstNode {
         dependenceIds: Set<AstNode>;
         holdingIds: Set<AstNode>;
         holdingIdNameMap: Map<string, Set<AstNode>>;
+        holdingIdType: 'Import' | 'Variable' | 'Function' | 'Class' | 'Param' | null;
         inject: Set<AstNode>;
         provide: Set<AstNode>;
         effectIds: Set<AstNode>;
-        crossScope: Set<AstNode>;
     };
 }
 export default class AstUtil {
     static invalidNodeKey: string[];
     static getNodePath(node: AstNode): string;
-    static deepFirstTravel(node: AstNode, filePath: string, mapUuidToNode: Map<string, AstNode>, mapFileLineToNodeSet: Map<number, Set<AstNode>>): AstNode | undefined;
-    static _deepFirstTravel(node: AstNode, visitedNodeSet: Set<typeof node>, extra: {
-        filePath: string;
-        depth: number;
-        mapUuidToNode: Map<string, AstNode>;
-        mapFileLineToNodeSet: Map<number, Set<AstNode>>;
-    }): AstNode;
-    static collectInjectProvide(ast: AstNode): void;
-    static collectHoldingIds(node: AstNode & {
-        body: AstNode | null;
-    }): void;
-    static isVarInit(node: AstNode): boolean;
+    static getShortNodeMsg(node: AstNode): string;
+    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 collectHoldingIds;
+    private static isVarInit;
     static isReturnArgument(node: AstNode): boolean;
-    static collectDependenceIds(node: AstNode): void;
-    static markDependenceIdCrossScope(node: AstNode, scopeId: AstNode): void;
-    static isUseStateVarDec(node: AstNode): node is (AstNode & {
-        type: "VariableDeclarator";
-        id: {
-            type: "ArrayPattern";
-            elements: (null | AstNode)[];
-        };
-        init: {
-            type: "CallExpression";
-            callee: AstNode;
-            arguments: [AstNode] | [];
-        };
-    });
+    private static collectDependenceIds;
+    private static isUseStateVarDec;
     static isUseMemoVarDec(node: AstNode): boolean;
-    static isUseCallbackVarDec(node: AstNode): boolean;
-    static collectEffectId(node: AstNode): void;
-    static collectEffectIdOfVarDec(node: AstNode): void;
-    static collectEffectIdOfUseState(node: AstNode): void;
-    static collectEffectIdOfUseMemo(node: AstNode): void;
-    static collectEffectIdOfUseCallback(node: AstNode): void;
-    static collectEffectIdOfAssign(node: AstNode): void;
-    static collectEffectIdOfUnaryUpdate(node: AstNode): void;
-    static isBodyArray(node: AstNode): node is ({
-        body: AstNode[];
-    } & AstNode);
-    static findExportIdentifiers(node: any, callback: (identifier: AstNode) => void): void;
-    static expressionTypeIsIdentifier(exp: AstNode | null): exp is AstNode & {
-        type: "Identifier";
-    };
+    private static isUseCallbackVarDec;
+    private static collectEffectId;
+    private static collectEffectIdOfFnCall;
+    private static collectEffectIdOfVarDec;
+    private static collectEffectIdOfUseState;
+    private static collectEffectIdOfUseMemo;
+    private static collectEffectIdOfUseCallback;
+    private static collectEffectIdOfAssign;
+    private static collectEffectIdOfUnaryUpdate;
+    private static isBodyArray;
+    private static findExportIdentifiers;
+    private static expressionTypeIsIdentifier;
+    static collectExpressionIdentifiers(exp: AstNode | null, callback: (identifier: AstNode) => void): void;
+    private static _collectExpressionIdentifiers;
     static deepFindIdOfExpression(exp: AstNode | null, callback: (identifier: AstNode) => void): void;
-    static _deepFindIdOfExpression(exp: AstNode | null, callback: (identifier: AstNode) => void): void;
-    static getRootIdentifierOfMemberExpression(memExp: AstNode): AstNode;
-    static findIdOfImport(node: AstNode, callback: (identifier: AstNode) => void): void;
-    static findIdOfFunctionOrVariableOrClass(node: AstNode, callback: (identifier: AstNode) => void): void;
-    static findIdOfVariable(node: AstNode, callback: (identifier: AstNode) => void): void;
+    private static _deepFindIdOfExpression;
+    private static getRootIdentifierOfMemberExpression;
+    private static findIdOfImport;
+    private static findIdOfVariable;
     private static _deepFindIdentifier;
-    static updateLoc(astNode: AstNode, extra: {
-        mapUuidToNode: Map<string, AstNode>;
-        mapFileLineToNodeSet: Map<number, Set<AstNode>>;
-    }): void;
-    static isValidArrayNodeCollect(astNode: any): astNode is AstNode[];
-    static isValidNodeCollect(astNode: AstNode): astNode is AstNode;
+    private static updateLoc;
+    private static isValidArrayNodeCollect;
+    private static isValidNodeCollect;
     static windowProperties: string[];
     static intrinsicElements: string[];
     static standardAttributes: string[];

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

@@ -24,20 +24,24 @@ __export(AstUtil_exports, {
 module.exports = __toCommonJS(AstUtil_exports);
 var import_windowProperties = require("./windowProperties");
 var import_intrinsicElements = require("./intrinsicElements");
-var AstUtil = class {
+var _AstUtil = class {
   static getNodePath(node) {
     return [...node._util.ancestors, node].map((n) => n.type).join(":") + ":" + node.name;
   }
-  static deepFirstTravel(node, filePath, mapUuidToNode, mapFileLineToNodeSet) {
+  static getShortNodeMsg(node) {
+    const { _util: { startLine, startColumn, endLine, endColumn } } = node;
+    return `${node.name || node.type}「${startLine}:${startColumn}, ${endLine}:${endColumn}」`;
+  }
+  static deepFirstTravel(node, filePath, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet) {
     const visitedNodeSet = /* @__PURE__ */ new Set();
     if (!node) {
       return;
     }
-    return this._deepFirstTravel(node, visitedNodeSet, { filePath, depth: 0, mapUuidToNode, mapFileLineToNodeSet });
+    return this._deepFirstTravel(node, visitedNodeSet, { filePath, depth: 0, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
   }
   static _deepFirstTravel(node, visitedNodeSet, extra) {
     visitedNodeSet.add(node);
-    const { filePath, depth, mapUuidToNode, mapFileLineToNodeSet } = extra;
+    const { filePath, depth, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet } = extra;
     const _util = {
       startLine: NaN,
       endLine: NaN,
@@ -53,12 +57,12 @@ var AstUtil = class {
       uuid: "",
       variableScope: [],
       dependenceIds: /* @__PURE__ */ new Set(),
+      holdingIdType: null,
       holdingIds: /* @__PURE__ */ new Set(),
       holdingIdNameMap: /* @__PURE__ */ new Map(),
       inject: /* @__PURE__ */ new Set(),
       provide: /* @__PURE__ */ new Set(),
-      effectIds: /* @__PURE__ */ new Set(),
-      crossScope: /* @__PURE__ */ new Set()
+      effectIds: /* @__PURE__ */ new Set()
     };
     node._util = _util;
     const { nodeCollection, children } = _util;
@@ -71,13 +75,13 @@ var AstUtil = class {
         return;
       }
       if (this.isValidNodeCollect(nodeValue)) {
-        const childNode = this._deepFirstTravel(nodeValue, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet });
+        const childNode = this._deepFirstTravel(nodeValue, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
         nodeCollection.push(childNode, ...childNode._util.nodeCollection);
         children.push(childNode);
         childNode._util.parentProperty = nodeKey;
       } else if (this.isValidArrayNodeCollect(nodeValue)) {
         const validNodeArray = nodeValue.filter((nodeItem) => this.isValidNodeCollect(nodeItem)).map((v) => {
-          return this._deepFirstTravel(v, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet });
+          return this._deepFirstTravel(v, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
         });
         nodeCollection.push(...validNodeArray.map((n) => [n, ...n._util.nodeCollection]).flat());
         children.push(...validNodeArray);
@@ -90,12 +94,15 @@ var AstUtil = class {
     children.forEach((child) => child._util.parent = node);
     nodeCollection.forEach((nodeItem) => nodeItem._util.ancestors.unshift(node));
     this.collectHoldingIds(node);
-    this.collectInjectProvide(node);
-    this.collectEffectId(node);
-    this.updateLoc(node, { mapUuidToNode, mapFileLineToNodeSet });
+    this.collectDependenceIds(node);
+    this.collectInjectAndProvide(node);
+    if (node.type === "Program") {
+      nodeCollection.forEach((child) => this.collectEffectId(child));
+    }
+    this.updateLoc(node, { mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
     return node;
   }
-  static collectInjectProvide(ast) {
+  static collectInjectAndProvide(ast) {
     const { type, _util: { inject, provide, holdingIds } } = ast;
     if (type !== "Program" || !this.isBodyArray(ast)) {
       return;
@@ -113,7 +120,7 @@ var AstUtil = class {
           const theOne = [...holdingIds].find((e) => e.name === declaration.name);
           theOne && provide.add(theOne);
         } else {
-          this.deepFindIdOfExpression(declaration, (id) => provide.add(id));
+          provide.add(declaration);
         }
       }
       if (node.type === "ExportNamedDeclaration") {
@@ -136,23 +143,53 @@ var AstUtil = class {
       const { body } = node;
       body.forEach((cur) => {
         if (cur.type === "ImportDeclaration") {
-          this.findIdOfImport(cur, (id) => holdingIds.add(id));
+          this.findIdOfImport(cur, (id) => {
+            holdingIds.add(id);
+            id._util.variableScope = [id];
+            id._util.holdingIdType = "Import";
+          });
         } else if (cur.type === "FunctionDeclaration" || cur.type === "ClassDeclaration") {
           const id = cur.id;
-          id && holdingIds.add(id);
+          if (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) => holdingIds.add(id));
+          this.findIdOfVariable(cur, (id) => {
+            holdingIds.add(id);
+            id._util.variableScope = [id];
+            id._util.holdingIdType = "Variable";
+          });
         }
       });
     }
     if (node.body && this.isBodyArray(node.body)) {
       const { body } = node.body;
       body.forEach((cur) => {
-        this.findIdOfFunctionOrVariableOrClass(cur, (id) => holdingIds.add(id));
+        if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+          const id = node.id;
+          if (id) {
+            holdingIds.add(id);
+            id._util.variableScope = [id];
+            id._util.holdingIdType = node.type === "ClassDeclaration" ? "Class" : "Function";
+          }
+        } else if (node.type === "VariableDeclaration") {
+          this.findIdOfVariable(node, (id) => {
+            holdingIds.add(id);
+            id._util.variableScope = [id];
+            id._util.holdingIdType = "Variable";
+          });
+        }
       });
     }
     if (["FunctionDeclaration", "ArrowFunctionExpression", "FunctionExpression"].includes(node.type)) {
-      node.params.forEach((param) => this._deepFindIdentifier(param, (id) => holdingIds.add(id)));
+      const params = node.params;
+      params.forEach((param) => this._deepFindIdentifier(param, (id) => {
+        holdingIds.add(id || node);
+        id._util.variableScope = [id];
+        id._util.holdingIdType = "Param";
+      }));
     }
     holdingIds.forEach((holdingId) => {
       const holdingIdName = holdingId.name;
@@ -160,7 +197,6 @@ var AstUtil = class {
       nodeSetOfIdName.add(holdingId);
       holdingIdNameMap.set(holdingIdName, nodeSetOfIdName);
     });
-    this.collectDependenceIds(node);
   }
   static isVarInit(node) {
     var _a;
@@ -173,44 +209,20 @@ var AstUtil = class {
   static collectDependenceIds(node) {
     const { nodeCollection, dependenceIds, holdingIdNameMap } = node._util;
     nodeCollection.forEach((e) => {
-      this.deepFindIdOfExpression(e, (id) => dependenceIds.add(id));
       this.findExportIdentifiers(e, (id) => dependenceIds.add(id));
-      if (e.type === "Identifier" && (this.isVarInit(e) || this.isReturnArgument(e))) {
-        dependenceIds.add(e);
-      }
+      this.collectExpressionIdentifiers(e, (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) {
+        if (firstPick && firstPick._util.uuid !== dependenceId._util.uuid) {
           firstPick._util.effectIds.add(dependenceId);
-          this.markDependenceIdCrossScope(dependenceId, firstPick);
         }
       }
     }
   }
-  static markDependenceIdCrossScope(node, scopeId) {
-    var _a, _b, _c;
-    const isParamsElement = scopeId._util.parentProperty === "params";
-    const isCalleeId = ((_a = node._util.parent) == null ? void 0 : _a.type) === "CallExpression" && node._util.parentProperty === "callee";
-    if (isParamsElement && isCalleeId) {
-      const fn = scopeId._util.parent;
-      const isFn = fn.type === "FunctionExpression" || fn.type === "ArrowFunctionExpression";
-      const isFnInVarDec = fn._util.parentProperty === "init" && ((_b = fn._util.parent) == null ? void 0 : _b.type) === "VariableDeclarator";
-      const isFnInAssign = fn._util.parentProperty === "right" && ((_c = fn._util.parent) == null ? void 0 : _c.type) === "AssignmentExpression";
-      if (isFn && isFnInVarDec) {
-        const idHolderOfFn = fn._util.parent.id;
-        node._util.crossScope.add(idHolderOfFn);
-      } else if (isFn && isFnInAssign) {
-        const idHolderOfFn = fn._util.parent.left;
-        node._util.crossScope.add(idHolderOfFn);
-      } else if (fn.type === "FunctionDeclaration") {
-        node._util.crossScope.add(fn);
-      }
-    }
-  }
   static isUseStateVarDec(node) {
     if (node.type !== "VariableDeclarator")
       return false;
@@ -250,6 +262,50 @@ var AstUtil = class {
     const isDeleteOperator = "UnaryExpression" === node.type && node.operator === "delete";
     if (isDeleteOperator || ["UpdateExpression"].includes(node.type)) {
       this.collectEffectIdOfUnaryUpdate(node);
+      return;
+    }
+    if (node.type === "CallExpression") {
+      this.collectEffectIdOfFnCall(node);
+      return;
+    }
+  }
+  static collectEffectIdOfFnCall(node) {
+    var _a, _b, _c;
+    if (node.type !== "CallExpression") {
+      return;
+    }
+    const idSet = /* @__PURE__ */ new Set();
+    this.collectExpressionIdentifiers(node, (id) => idSet.add(id));
+    for (const id of idSet) {
+      if (id._util.variableScope.length === 0) {
+        continue;
+      }
+      const scopeId = id._util.variableScope[0];
+      const isParamsElement = scopeId._util.parentProperty === "params";
+      if (isParamsElement) {
+        const fnNode = scopeId._util.parent;
+        if (fnNode.type === "FunctionExpression" || fnNode.type === "ArrowFunctionExpression") {
+          if (fnNode._util.parentProperty === "init" && ((_a = fnNode._util.parent) == null ? void 0 : _a.type) === "VariableDeclarator") {
+            fnNode._util.parent.id._util.effectIds.add(id);
+          } else if (fnNode._util.parentProperty === "right" && ((_b = fnNode._util.parent) == null ? void 0 : _b.type) === "AssignmentExpression") {
+            fnNode._util.parent.left._util.effectIds.add(id);
+          } else if (fnNode._util.parentProperty === "value" && ((_c = fnNode._util.parent) == null ? void 0 : _c.type) === "MethodDefinition") {
+            fnNode._util.parent.key._util.effectIds.add(id);
+          }
+        } else if (fnNode.type === "FunctionDeclaration") {
+          fnNode._util.effectIds.add(id);
+        }
+      }
+      const kindOfParamsElement = [...scopeId._util.effectIds].filter((e) => {
+        var _a2;
+        return ((_a2 = e._util.variableScope[0]) == null ? void 0 : _a2._util.holdingIdType) === "Param";
+      });
+      if (kindOfParamsElement.length > 0) {
+        kindOfParamsElement.map((ele) => {
+          var _a2;
+          (_a2 = ele._util.variableScope[0]._util.parent) == null ? void 0 : _a2._util.effectIds.add(id);
+        });
+      }
     }
   }
   static collectEffectIdOfVarDec(node) {
@@ -272,7 +328,7 @@ var AstUtil = class {
     const idSet = /* @__PURE__ */ new Set();
     this._deepFindIdentifier(id, (ele) => idSet.add(ele));
     const createdExpIdSet = /* @__PURE__ */ new Set();
-    ["Identifier", "ArrowFunctionExpression", "FunctionExpression"].includes(init.type) ? createdExpIdSet.add(init) : this.deepFindIdOfExpression(init, (id2) => createdExpIdSet.add(id2));
+    ["Identifier", "ArrowFunctionExpression", "FunctionExpression"].includes(init.type) ? createdExpIdSet.add(init) : this.collectExpressionIdentifiers(init, (id2) => createdExpIdSet.add(id2));
     for (const createdId of idSet) {
       createdId._util.effectIds = /* @__PURE__ */ new Set([...createdExpIdSet, ...createdId._util.effectIds]);
     }
@@ -289,7 +345,7 @@ var AstUtil = class {
       this._deepFindIdentifier(stateNode, (ele) => stateIdSet.add(ele));
       const setStateIdSet = /* @__PURE__ */ new Set();
       if (setStateNode) {
-        this._deepFindIdentifier(setStateNode, (ele) => setStateIdSet.add(ele));
+        setStateIdSet.add(setStateNode);
       }
       for (const stateId of stateIdSet) {
         stateId._util.effectIds = /* @__PURE__ */ new Set([...argsIdSet, ...setStateIdSet]);
@@ -319,14 +375,14 @@ var AstUtil = class {
   static collectEffectIdOfAssign(node) {
     const { left, right } = node;
     const idSetOfRight = /* @__PURE__ */ new Set();
-    this.deepFindIdOfExpression(right, (id) => idSetOfRight.add(id));
+    this.collectExpressionIdentifiers(right, (id) => idSetOfRight.add(id));
     if (left.type === "Identifier") {
       const { left: left2 } = node;
       left2._util.effectIds = /* @__PURE__ */ new Set([...idSetOfRight, ...left2._util.effectIds]);
     } else {
       const { left: left2 } = node;
       const idSetOfLeft = /* @__PURE__ */ new Set();
-      this.deepFindIdOfExpression(left2, (id) => idSetOfLeft.add(id));
+      this.collectExpressionIdentifiers(left2, (id) => idSetOfLeft.add(id));
       for (const id of idSetOfLeft) {
         id._util.effectIds = /* @__PURE__ */ new Set([...idSetOfRight, ...id._util.effectIds]);
       }
@@ -336,7 +392,7 @@ var AstUtil = class {
   static collectEffectIdOfUnaryUpdate(node) {
     const { argument } = node;
     const idSetOfArgument = /* @__PURE__ */ new Set();
-    this.deepFindIdOfExpression(argument, (id) => idSetOfArgument.add(id));
+    this.collectExpressionIdentifiers(argument, (id) => idSetOfArgument.add(id));
     argument._util.effectIds = /* @__PURE__ */ new Set([...argument._util.effectIds, ...idSetOfArgument]);
   }
   static isBodyArray(node) {
@@ -354,8 +410,7 @@ var AstUtil = class {
     if (node.type === "ExportNamedDeclaration" && Array.isArray(node.specifiers)) {
       for (const specifier of node.specifiers) {
         if (specifier.type === "ExportSpecifier") {
-          const local = specifier.local;
-          callback(local);
+          callback(specifier.local);
         }
       }
     }
@@ -363,6 +418,36 @@ var AstUtil = class {
   static expressionTypeIsIdentifier(exp) {
     return (exp == null ? void 0 : exp.type) === "Identifier";
   }
+  static collectExpressionIdentifiers(exp, callback) {
+    if (!exp || exp.type === "ThisExpression") {
+      return;
+    }
+    this._collectExpressionIdentifiers(exp, callback);
+  }
+  static _collectExpressionIdentifiers(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;
+    }
+    exp._util.nodeCollection.forEach((ele) => this._collectExpressionIdentifiers(ele, callback));
+  }
   static deepFindIdOfExpression(exp, callback) {
     if (!exp || exp.type === "ThisExpression") {
       return;
@@ -370,10 +455,20 @@ var AstUtil = class {
     this._deepFindIdOfExpression(exp, callback);
   }
   static _deepFindIdOfExpression(exp, callback) {
+    var _a;
     if (!exp || exp.type === "ThisExpression") {
       return;
     }
-    if (exp.type === "SpreadElement") {
+    if (exp.type === "IfStatement") {
+      const { test, alternate, consequent } = exp;
+      test.type === "Identifier" ? callback(test) : this._deepFindIdOfExpression(test, callback);
+      this._deepFindIdOfExpression(consequent, callback);
+      this._deepFindIdOfExpression(alternate, callback);
+    } else if (exp.type === "TryStatement") {
+      const { block, finalizer } = exp;
+      this._deepFindIdOfExpression(block, callback);
+      finalizer && this._deepFindIdOfExpression(finalizer, callback);
+    } else if (exp.type === "SpreadElement") {
       const { argument } = exp;
       this.expressionTypeIsIdentifier(argument) && callback(argument);
     } else if (exp.type === "JSXSpreadChild") {
@@ -424,7 +519,7 @@ var AstUtil = class {
     } else if (exp.type === "JSXExpressionContainer") {
       const { expression } = exp;
       expression.name && callback(expression);
-    } else if (exp.type === "JSXIdentifier") {
+    } else if (exp.type === "JSXIdentifier" && ((_a = exp._util.parent) == null ? void 0 : _a.type) !== "JSXAttribute") {
       callback(exp);
     } else if (exp.type === "JSXAttribute") {
       const value = exp.value;
@@ -449,16 +544,7 @@ var AstUtil = class {
   static findIdOfImport(node, callback) {
     const specifiers = node.specifiers;
     for (const specifier of specifiers) {
-      const local = specifier.local;
-      callback(local);
-    }
-  }
-  static findIdOfFunctionOrVariableOrClass(node, callback) {
-    if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
-      const id = node.id;
-      id && callback(id);
-    } else if (node.type === "VariableDeclaration") {
-      this.findIdOfVariable(node, callback);
+      callback(specifier.local);
     }
   }
   static findIdOfVariable(node, callback) {
@@ -499,10 +585,10 @@ var AstUtil = class {
     }
   }
   static updateLoc(astNode, extra) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g;
     const { _util, type, name } = astNode;
-    const { mapUuidToNode, mapFileLineToNodeSet } = extra;
-    const { nodeCollection, filePath } = _util;
+    const { mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet } = extra;
+    const { nodeCollection, filePath, parent } = _util;
     _util.startLine = Math.min(...nodeCollection.map((n) => {
       var _a2, _b2;
       return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.start) == null ? void 0 : _b2.line;
@@ -511,23 +597,31 @@ var AstUtil = class {
       var _a2, _b2;
       return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.end) == null ? void 0 : _b2.line;
     }), (_b = astNode.loc) == null ? void 0 : _b.end.line);
-    _util.startColumn = Math.min(...nodeCollection.map((n) => {
+    _util.startColumn = ((_c = astNode.loc) == null ? void 0 : _c.start.column) ?? Math.min(...nodeCollection.map((n) => {
       var _a2, _b2;
       return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.start) == null ? void 0 : _b2.column;
-    }), (_c = astNode.loc) == null ? void 0 : _c.start.column);
-    _util.endColumn = Math.max(...nodeCollection.map((n) => {
+    }), (_d = astNode.loc) == null ? void 0 : _d.start.column);
+    _util.endColumn = ((_e = astNode.loc) == null ? void 0 : _e.end.column) ?? Math.max(...nodeCollection.map((n) => {
       var _a2, _b2;
       return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.end) == null ? void 0 : _b2.column;
-    }), (_d = astNode.loc) == null ? void 0 : _d.end.column);
+    }), (_f = astNode.loc) == null ? void 0 : _f.end.column);
     _util.uuid = `${filePath}:${type}:${name}「${_util.startLine}:${_util.startColumn},${_util.endLine}:${_util.endColumn}」`;
     mapUuidToNode.set(_util.uuid, astNode);
     for (let i = _util.startLine; i <= _util.endLine; i++) {
       mapFileLineToNodeSet.set(i, mapFileLineToNodeSet.get(i) || /* @__PURE__ */ new Set());
-      (_e = mapFileLineToNodeSet.get(i)) == null ? void 0 : _e.add(astNode);
+      (_g = mapFileLineToNodeSet.get(i)) == null ? void 0 : _g.add(astNode);
     }
     if (astNode.type === "Program") {
       mapUuidToNode.set(astNode.type, astNode);
     }
+    if (parent === null) {
+      nodeCollection.forEach((n) => {
+        var _a2;
+        const path = _AstUtil.getNodePath(n);
+        mapPathToNodeSet.set(path, mapPathToNodeSet.get(path) || /* @__PURE__ */ new Set());
+        (_a2 = mapPathToNodeSet.get(path)) == null ? void 0 : _a2.add(n);
+      });
+    }
   }
   static isValidArrayNodeCollect(astNode) {
     return Array.isArray(astNode) && astNode.some((v) => typeof (v == null ? void 0 : v.type) === "string");
@@ -587,6 +681,7 @@ var AstUtil = class {
     return [node._util.filePath, ":", node._util.startLine, "-", node._util.endLine, ":[", node.name || node.value, "]"].join("");
   }
 };
+var AstUtil = _AstUtil;
 AstUtil.invalidNodeKey = [
   "comments",
   "tokens"

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

@@ -2,4 +2,5 @@ import { AstNode } from "./AstUtil";
 export default function getAstKitByFilePath(filePath: string, absPathPrefix: string): {
     mapFileLineToNodeSet: Map<number, Set<AstNode>>;
     mapUuidToNode: Map<string, AstNode>;
+    mapPathToNodeSet: Map<string, Set<AstNode>>;
 };

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

@@ -38,10 +38,11 @@ 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 filePathRelative = file.replace(absPathPrefix, "");
-  import_AstUtil.default.deepFirstTravel(ast, filePathRelative, mapUuidToNode, mapFileLineToNodeSet);
-  return { mapFileLineToNodeSet, mapUuidToNode };
+  import_AstUtil.default.deepFirstTravel(ast, filePathRelative, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet);
+  return { mapFileLineToNodeSet, mapUuidToNode, mapPathToNodeSet };
 };
 function getAstKitByFilePath(filePath, absPathPrefix) {
   let tools = mapFilePathToTools.get(filePath);

package/dist/cjs/util/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SOURCE = "source";
+export declare const TARGET = "target";

package/dist/cjs/util/constants.js

@@ -0,0 +1,32 @@
+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/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  SOURCE: () => SOURCE,
+  TARGET: () => TARGET
+});
+module.exports = __toCommonJS(constants_exports);
+var SOURCE = "source";
+var TARGET = "target";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SOURCE,
+  TARGET
+});

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

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(code_block_detect_exports);
 var import_path = require("path");
 var import_getAstKitByFilePath = __toESM(require("../ast_util/getAstKitByFilePath"));
 var import_AstUtil = __toESM(require("../ast_util/AstUtil"));
+var import_constants = require("../constants");
 var createBlockReport = (kind, index) => ({
   index,
   diff_txt: [],
@@ -68,7 +69,7 @@ function codeBlockDetect(arg) {
   const { gitDiffItem, absPathPrefix, blockReports, index } = arg;
   const { filePath, startLineOfNew, items, startLineOfOld } = gitDiffItem;
   const { mapFileLineToNodeSet, mapUuidToNode } = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
-  const filePathOfOld = (0, import_path.join)(process.cwd(), "..", "source", filePath);
+  const filePathOfOld = (0, import_path.join)(process.cwd(), "..", import_constants.SOURCE, filePath);
   const { mapFileLineToNodeSet: mapFileLineToNodeSetOld } = (0, import_getAstKitByFilePath.default)(filePathOfOld, absPathPrefix);
   const programNode = mapUuidToNode.get("Program");
   if (programNode) {
@@ -106,7 +107,7 @@ function extractEffectItem(list) {
 function pushBlockReport(blockReportInfoItem, programNode, index) {
   if (blockReportInfoItem.kind === "Other") {
     ["added", "removed"].forEach((key) => {
-      const tailElements = blockReportInfoItem[key].map((ele) => ele.split(":").at(-1)).filter(Boolean);
+      const tailElements = blockReportInfoItem[key].map((ele) => ele.split(":").at(-1)).filter((e) => e && e !== "undefined");
       blockReportInfoItem[key] = [...new Set(tailElements)];
     });
   }

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

@@ -35,12 +35,14 @@ ${report.map((r) => `- ${r.filePath}`).join("\n")}
   return allFiles + report.map(reportItemToMd).join("\n\n\n");
 }
 function reportItemToMd(report) {
-  const { filePath, filesDependsOnMe, type, dangerIdentifiers, blockReports } = report;
+  const { filePath, filesDependsOnMe, type, dangerIdentifiers, undefinedIdentifiers, blockReports } = report;
   return [
     `## ${filePath}`,
     `### 类型: ${mapReportType[type]}`,
-    filesDependsOnMe.length > 0 ? `### 所影响的文件
-${filesDependsOnMe.map((files) => `- ${files.join("、")}`).join("\n")}` : "",
+    filesDependsOnMe.length > 0 ? `### 所影响的文件(重要性由高到低)
+${filesDependsOnMe.map((files, index) => files.map((file) => "  ".repeat(index) + `- ${file}`)).flat().join("\n")}` : "",
+    undefinedIdentifiers.length > 0 ? `### 未定义的变量
+> ${undefinedIdentifiers.map((e) => `**${e}**`).join(", ")}` : "",
     dangerIdentifiers.length > 0 ? `### 重点检查使用的变量
 > ${dangerIdentifiers.join(", ")}` : "",
     blockReports.length > 0 ? `### 对比分析 共${blockReports.length}处` : "",
@@ -63,23 +65,14 @@ ${diff_txt.join("\n")}
 }
 function blockReportInfoItemToMd(info, index) {
   const {
-    kind,
-    added,
-    addedEffects,
-    removed,
-    removedEffects
+    causeBy,
+    effects
   } = info;
   return [
-    `#### 分类${index + 1}: ${kind}`,
-    added.length > 0 ? `- 新增标识符
-> ${added.join(", ")}` : "",
-    addedEffects.length > 0 ? `- 新增标识符影响
-` : "",
-    addedEffects.map(({ causeBy, effects }) => `> ${causeBy}相关: ${effects.join()}`).join("\n\n"),
-    removed.length > 0 ? `- 删除标识符
-> ${removed.join(", ")}` : "",
-    removedEffects.length > 0 ? `- 删除标识符影响` : "",
-    removedEffects.map(({ causeBy, effects }) => `> ${causeBy}相关: ${effects.join()}`).join("\n\n")
+    `#### 序号${index + 1}`,
+    effects.length > 0 ? `#### ${causeBy}
+- 影响：
+${effects.map((e) => `> ${e}`).join("\n")}` : ""
   ].filter(Boolean).join("\n\n");
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -0,0 +1,20 @@
+import { GitDiffDetail } from "../format_git_diff_content";
+import { AstNode } from "../ast_util/AstUtil";
+import { DetectReport } from "../report_util";
+export type BlockReportItem = {
+    index: number;
+    diff_txt: string[];
+    addNodeAndPaths: ReturnType<typeof createPathsOfNodes>;
+    removeNodeAndPaths: ReturnType<typeof createPathsOfNodes>;
+};
+declare function createPathsOfNodes(ast: AstNode, blockIndex: number): {
+    node: AstNode;
+    nodePath: string;
+    blockIndex: number;
+}[];
+export declare function diffBlockDetect(gitDiffDetail: GitDiffDetail, index: number, extra: {
+    reportItem: DetectReport;
+    absPathPrefix: string;
+}): void;
+export declare function reportItemDetect(reportItem: DetectReport, absPathPrefix: string): void;
+export {};

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

@@ -0,0 +1,112 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/report_util/diffBlockDetect.ts
+var diffBlockDetect_exports = {};
+__export(diffBlockDetect_exports, {
+  diffBlockDetect: () => diffBlockDetect,
+  reportItemDetect: () => reportItemDetect
+});
+module.exports = __toCommonJS(diffBlockDetect_exports);
+var import_getAstKitByFilePath = __toESM(require("../ast_util/getAstKitByFilePath"));
+var import_path = require("path");
+var import_constants = require("../constants");
+var import_AstUtil = __toESM(require("../ast_util/AstUtil"));
+var createBlockReport = (index) => ({
+  index,
+  diff_txt: [],
+  addNodeAndPaths: [],
+  removeNodeAndPaths: []
+});
+function createPathsOfNodes(ast, blockIndex) {
+  return [ast, ...ast._util.nodeCollection].map((node) => {
+    return { node, nodePath: import_AstUtil.default.getNodePath(node), blockIndex };
+  });
+}
+function findOrCreateBlockReport(blockReports, index) {
+  const res = blockReports.find((item) => item.index === index) || createBlockReport(index);
+  if (!blockReports.includes(res)) {
+    blockReports.push(res);
+  }
+  return res;
+}
+function diffBlockDetect(gitDiffDetail, index, extra) {
+  const { filePath, startLineOfNew, items, startLineOfOld } = gitDiffDetail;
+  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 { mapFileLineToNodeSet: mapFileLineToNodeSetOld } = (0, import_getAstKitByFilePath.default)(filePathOfOld, absPathPrefix.replace(`${import_constants.TARGET}/`, `${import_constants.SOURCE}/`));
+  const programNode = mapUuidToNode.get("Program");
+  if (programNode) {
+    const lineNumberStartNew = Number(startLineOfNew);
+    const lineNumberEndNew = lineNumberStartNew + items.filter((item) => item.startsWith("+")).length - 1;
+    const lineNumberStartOld = Number(startLineOfOld);
+    const lineNumberEndOld = lineNumberStartOld + items.filter((item) => item.startsWith("-")).length - 1;
+    const addNodes = import_AstUtil.default.getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet, lineNumberStartNew, lineNumberEndNew);
+    const removeNodes = import_AstUtil.default.getTopScopeNodesByLineNumberRange(mapFileLineToNodeSetOld, lineNumberStartOld, lineNumberEndOld);
+    blockReportItem.diff_txt = items;
+    const addNodeAndPaths = addNodes.map((e) => createPathsOfNodes(e, index)).flat();
+    const removeNodeAndPaths = removeNodes.map((e) => createPathsOfNodes(e, index)).flat();
+    blockReportItem.addNodeAndPaths = addNodeAndPaths;
+    blockReportItem.removeNodeAndPaths = removeNodeAndPaths;
+    _fileAddedNodesPaths.push(...addNodeAndPaths);
+    _fileRemovedNodesPaths.push(...removeNodeAndPaths);
+  }
+}
+function reportItemDetect(reportItem, absPathPrefix) {
+  const { _fileRemovedNodesPaths, _fileAddedNodesPaths, filePath } = reportItem;
+  const filePathOfOld = (0, import_path.join)(process.cwd(), "..", import_constants.SOURCE, filePath);
+  const { mapPathToNodeSet } = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
+  const _fileAddedPaths = _fileAddedNodesPaths.map((e) => e.nodePath);
+  const _fileRemovedPaths = _fileRemovedNodesPaths.map((e) => e.nodePath);
+  const _fileSamePathsNode = _fileAddedPaths.filter((e) => _fileRemovedPaths.includes(e));
+  if (_fileSamePathsNode.length) {
+    reportItem._fileAddedNodesPaths = [...new Set(_fileAddedNodesPaths)].filter((e) => !_fileSamePathsNode.includes(e.nodePath));
+    reportItem._fileRemovedNodesPaths = [...new Set(_fileRemovedNodesPaths)].filter((e) => !_fileSamePathsNode.includes(e.nodePath));
+    const { blockReports, dangerIdentifiers } = reportItem;
+    blockReports.forEach((e) => {
+      e.addNodeAndPaths = e.addNodeAndPaths.filter((item) => !_fileSamePathsNode.includes(item.nodePath));
+      e.removeNodeAndPaths = e.removeNodeAndPaths.filter((item) => !_fileSamePathsNode.includes(item.nodePath));
+      const effectedNodeOfRemove = e.removeNodeAndPaths.map((item) => [...item.node._util.effectIds]).flat();
+      effectedNodeOfRemove.forEach((item) => {
+        const path = import_AstUtil.default.getNodePath(item);
+        const nodes = mapPathToNodeSet.get(path);
+        if (nodes) {
+          dangerIdentifiers.push(...[...nodes].map((e2) => import_AstUtil.default.getShortNodeMsg(e2)));
+        }
+      });
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diffBlockDetect,
+  reportItemDetect
+});

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

@@ -1 +1,2 @@
+export declare function extractUndefinedIdentifiers(filePath: string, absPathPrefix: string): string[];
 export declare function fileIdentifierDetect(filePath: string, absPathPrefix: string): string[];

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

@@ -29,34 +29,33 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/util/report_util/file_identifier_detect.ts
 var file_identifier_detect_exports = {};
 __export(file_identifier_detect_exports, {
+  extractUndefinedIdentifiers: () => extractUndefinedIdentifiers,
   fileIdentifierDetect: () => fileIdentifierDetect
 });
 module.exports = __toCommonJS(file_identifier_detect_exports);
 var import_getAstKitByFilePath = __toESM(require("../ast_util/getAstKitByFilePath"));
 var import_AstUtil = __toESM(require("../ast_util/AstUtil"));
-function fileIdentifierDetect(filePath, absPathPrefix) {
+function extractUndefinedIdentifiers(filePath, absPathPrefix) {
   const { mapUuidToNode } = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
   const programNode = mapUuidToNode.get("Program");
   if (!programNode) {
     return [];
   }
   const { dependenceIds } = programNode._util;
-  const ids = [...dependenceIds].filter((id) => {
-    return import_AstUtil.default.isUntrackedId(id) || id._util.crossScope.size > 0;
-  });
-  return ids.map((id) => {
-    const { name, _util } = id;
-    const { crossScope } = _util;
-    const isUntracked = import_AstUtil.default.isUntrackedId(id);
-    const notFoundInfo = isUntracked ? `${name}:「${_util.startLine}:${_util.startColumn},${_util.endLine}:${_util.endColumn}」` : "";
-    const dangerScopeInfo = [...crossScope].map((scope) => {
-      const { _util: _util2 } = scope;
-      return `${scope.name}:「${_util2.startLine}:${_util2.startColumn},${_util2.endLine}:${_util2.endColumn}」`;
-    }).join("，");
-    return [notFoundInfo, dangerScopeInfo].filter(Boolean).join("，");
-  });
+  const ids = [...dependenceIds].filter((id) => import_AstUtil.default.isUntrackedId(id));
+  return ids.map((id) => import_AstUtil.default.getShortNodeMsg(id));
+}
+function fileIdentifierDetect(filePath, absPathPrefix) {
+  const { mapUuidToNode } = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
+  const programNode = mapUuidToNode.get("Program");
+  if (!programNode) {
+    return [];
+  }
+  const { effectIds } = programNode._util;
+  return [...effectIds].map((id) => import_AstUtil.default.getShortNodeMsg(id));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  extractUndefinedIdentifiers,
   fileIdentifierDetect
 });

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

@@ -1,11 +1,23 @@
 import { GitDiffDetail } from "./format_git_diff_content";
-import { BlockReport } from "./report_util/code_block_detect";
+import { AstNode } from "./ast_util/AstUtil";
+import { BlockReportItem } from "./report_util/diffBlockDetect";
 export type DetectReport = {
     filePath: string;
     type: "modify" | "add" | "delete";
     filesDependsOnMe: string[][];
+    undefinedIdentifiers: string[];
     dangerIdentifiers: string[];
-    blockReports: BlockReport[];
+    _fileAddedNodesPaths: {
+        node: AstNode;
+        nodePath: string;
+        blockIndex: number;
+    }[];
+    _fileRemovedNodesPaths: {
+        node: AstNode;
+        nodePath: string;
+        blockIndex: number;
+    }[];
+    blockReports: BlockReportItem[];
 };
 type Arg = {
     groupGitDiffLines: GitDiffDetail[];
@@ -16,25 +28,14 @@ export declare function createDetectReport(arg: Arg): {
     blockReports: {
         diff_txt: string[];
         infos: {
-            addedEffects: {
-                causeBy: string;
-                effects: string[];
-            }[];
-            removedEffects: {
-                causeBy: string;
-                effects: (string | undefined)[];
-            }[];
-            kind: "Import" | "Declaration" | "Assignment" | "SelfUpdate" | "Invoke" | "Other";
-            added: string[];
-            addedNotUsed: string[];
-            addedNotFound: string[];
-            removed: string[];
-            removedStillUsing: string[];
+            causeBy: string;
+            effects: string[];
         }[];
     }[];
-    filePath: string;
-    type: "modify" | "add" | "delete";
+    type: "delete" | "modify" | "add";
     filesDependsOnMe: string[][];
+    undefinedIdentifiers: string[];
     dangerIdentifiers: string[];
+    filePath: string;
 }[];
 export {};

package/dist/cjs/util/report_util.js

@@ -32,11 +32,10 @@ __export(report_util_exports, {
   createDetectReport: () => createDetectReport
 });
 module.exports = __toCommonJS(report_util_exports);
-var import_code_block_detect = __toESM(require("./report_util/code_block_detect"));
-var import_getAstKitByFilePath = __toESM(require("./ast_util/getAstKitByFilePath"));
 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");
 function createDetectReport(arg) {
   const { groupGitDiffLines, tree, absPathPrefix } = arg;
   const reports = [];
@@ -49,56 +48,44 @@ function createDetectReport(arg) {
         filePath,
         type,
         filesDependsOnMe,
+        undefinedIdentifiers: [],
         dangerIdentifiers: [],
+        _fileAddedNodesPaths: [],
+        _fileRemovedNodesPaths: [],
         blockReports: []
       };
       reports.push(reportItem);
     }
+    reportItem.undefinedIdentifiers = (0, import_file_identifier_detect.extractUndefinedIdentifiers)(filePath, absPathPrefix);
     reportItem.dangerIdentifiers = (0, import_file_identifier_detect.fileIdentifierDetect)(filePath, absPathPrefix);
     if (type === "modify") {
-      (0, import_code_block_detect.default)({ gitDiffItem: item, absPathPrefix, blockReports: reportItem.blockReports, index });
+      (0, import_diffBlockDetect.diffBlockDetect)(item, index, { reportItem, absPathPrefix });
     }
   });
-  return reports.map((report) => {
-    const filePath = report.filePath;
-    const astKit = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
-    const allNodes = new Map([...astKit.mapUuidToNode.values()].map((ele) => [import_AstUtil.default.getNodePath(ele), ele]));
+  return reports.map((reportItem) => {
+    const { _fileAddedNodesPaths, _fileRemovedNodesPaths, filePath, blockReports, ...reportProperties } = reportItem;
+    (0, import_diffBlockDetect.reportItemDetect)(reportItem, absPathPrefix);
+    const fileAddedNodesPaths = reportItem._fileAddedNodesPaths.map((item) => item.nodePath);
+    const fileRemovedNodesPaths = reportItem._fileRemovedNodesPaths.map((item) => item.nodePath);
     return {
-      ...report,
-      blockReports: report.blockReports.map((blockReport) => {
-        const { infos, diff_txt } = blockReport;
-        const infosList = infos.map((info) => {
-          const { addedEffects, removedEffects, topAdded, topRemoved, ...rest } = info;
-          const removedEffectsInfos = removedEffects.map((item) => {
-            const tmpList = item.effects.map((ele) => {
-              const nodePath = import_AstUtil.default.getNodePath(ele);
-              const item2 = allNodes.get(nodePath);
-              return item2 && import_AstUtil.default.createScopeContent(item2);
-            }).filter(Boolean);
-            const effects = [...new Set(tmpList)];
-            return {
-              causeBy: item.causeBy.name || item.causeBy.type,
-              effects
-            };
-          }).filter((item) => item.effects.length > 0);
-          const addedEffectsInfos = addedEffects.map((item) => {
-            const effects = [...new Set(item.effects.map(import_AstUtil.default.createScopeContent))];
-            return {
-              causeBy: item.causeBy.name || item.causeBy.type,
-              effects
-            };
-          }).filter((item) => item.effects.length > 0);
+      filePath,
+      ...reportProperties,
+      blockReports: blockReports.map((blockReport) => {
+        const { diff_txt } = blockReport;
+        const addNodeAndPaths = blockReport.addNodeAndPaths.filter((e) => fileAddedNodesPaths.includes(e.nodePath));
+        const infosList = addNodeAndPaths.map((item) => {
+          const { node } = item;
+          const { effectIds } = node._util;
           return {
-            ...rest,
-            addedEffects: addedEffectsInfos,
-            removedEffects: removedEffectsInfos
+            causeBy: import_AstUtil.default.getShortNodeMsg(node),
+            effects: [...effectIds].map((e) => import_AstUtil.default.getShortNodeMsg(e))
           };
         });
         return {
           diff_txt,
-          infos: infosList
+          infos: infosList.filter((e) => e.effects.length > 0)
         };
-      })
+      }).filter((e) => e.infos.length > 0)
     };
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-code-detector",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",
@@ -37,10 +37,12 @@
   "dependencies": {
     "@babel/parser": "^7.28.3",
     "@umijs/utils": "^4.4.12",
+    "await-to-js": "^3.0.0",
     "crypto-js": "^4.2.0",
     "dayjs": "^1.11.13",
     "lodash-es": "^4.17.21",
     "madge": "^8.0.0",
+    "tsx": "^4.20.5",
     "vue-eslint-parser": "^10.2.0"
   }
 }