js-code-detector 0.0.20 → 0.0.22

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";
@@ -136,30 +139,29 @@ async function gitDiffDetect() {
   import_utils.logger.ready("准备生成临时工作目录...");
   await import_utils.execa.execa(`mkdir -p ${today}`, { shell: "/bin/bash" });
   import_utils.logger.info("临时目录建立完成");
-  import_utils.logger.ready("准备clone源代码到临时目录下的target文件夹");
-  await import_utils.execa.execa(`git clone ${gitUrl} ${today}/target`, { shell: "/bin/bash" });
+  import_utils.logger.ready(`准备clone源代码到临时目录下的 ${import_constants.TARGET} 文件夹`);
+  await import_utils.execa.execa(`git clone ${gitUrl} ${today}/${import_constants.TARGET}`, { shell: "/bin/bash" });
   import_utils.logger.info("源代码clone完成");
   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" });
+  await import_utils.execa.execa(`cd ${today}/${import_constants.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=${gitDiffFileName}`, { shell: "/bin/bash" });
+  await import_utils.execa.execa(`cd ${today}/${import_constants.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.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}/${import_constants.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 content = (0, import_fs.readFileSync)((0, import_path.join)(process.cwd(), today, import_constants.TARGET, jsonName), "utf-8");
   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("临时目录已删除");
   });
@@ -192,6 +194,8 @@ async function getEslintCheckResult(today) {
   getEslintCheckResult,
   getGitRepositoryAndBranch,
   gitDiffDetect,
+  gitDiffFileName,
+  gitDiffJsonName,
   sameCodeDetect,
   umiPluginCallback,
   writeGitDiffTxt

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

@@ -1,7 +1,7 @@
 export interface AstNode {
     computed?: boolean;
     type: string;
-    name?: string;
+    name?: string | AstNode;
     start?: number | null;
     end?: number | null;
     loc?: Record<'start' | 'end', {
@@ -25,21 +25,27 @@ 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;
         inject: Set<AstNode>;
         provide: Set<AstNode>;
         effectIds: Set<AstNode>;
+        occupation: Set<AstNode>;
     };
 }
 export default class AstUtil {
     static invalidNodeKey: string[];
     static getNodePath(node: AstNode): string;
-    static getShortNodeMsg(node: AstNode): string;
+    static getShortNodeMsg(node: AstNode, hideParentProperty?: boolean): string;
+    static getAncestorsFromBirth(occupationId: AstNode, sourceId: AstNode): AstNode[];
+    static getNearestImpactedNode(ancestors: AstNode[]): AstNode | undefined;
+    private static getImpactedNode;
     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,11 +64,10 @@ 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;
-    private static _deepFindIdOfExpression;
-    private static getRootIdentifierOfMemberExpression;
     private static findIdOfImport;
     private static findIdOfVariable;
     private static _deepFindIdentifier;

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

@@ -28,9 +28,63 @@ var _AstUtil = class {
   static getNodePath(node) {
     return [...node._util.ancestors, node].map((n) => n.type).join(":") + ":" + node.name;
   }
-  static getShortNodeMsg(node) {
-    const { _util: { startLine, startColumn, endLine, endColumn } } = node;
-    return `${node.name || node.type}「${startLine}:${startColumn}, ${endLine}:${endColumn}」`;
+  static getShortNodeMsg(node, hideParentProperty = false) {
+    const { _util: { startLine, startColumn, endLine, endColumn, parentProperty, indexOfProperty } } = node;
+    let type = node.type;
+    let name = node.name;
+    if (name && typeof name === "object") {
+      type = name.type;
+      name = name.name;
+    }
+    const msg = [
+      hideParentProperty ? [] : [parentProperty, indexOfProperty !== null ? String(indexOfProperty) : null],
+      [type, name]
+    ].map((e) => e.filter(Boolean).join(":")).filter(Boolean).join(" ");
+    return `${msg}「${startLine}:${startColumn}, ${endLine}:${endColumn}」`;
+  }
+  static getAncestorsFromBirth(occupationId, sourceId) {
+    const { _util: { ancestors } } = occupationId;
+    return ancestors.filter((ancestor) => !sourceId._util.ancestors.includes(ancestor));
+  }
+  static getNearestImpactedNode(ancestors) {
+    for (const ancestor of ancestors) {
+      const impactedNode = this.getImpactedNode(ancestor);
+      if (impactedNode) {
+        return impactedNode;
+      }
+    }
+  }
+  static getImpactedNode(ancestor) {
+    const { type } = ancestor;
+    if (type === "JSXOpeningElement") {
+      const { name } = ancestor.name;
+      if (name && typeof name === "object") {
+        const realName = name.name;
+        if (!this.intrinsicElements.includes(realName)) {
+          return name;
+        }
+      }
+    }
+    if (type === "JSXElement") {
+      const { openingElement } = ancestor;
+      const { name } = openingElement;
+      if (name && typeof name === "object") {
+        const realName = name.name;
+        if (!this.intrinsicElements.includes(realName)) {
+          return name;
+        }
+      }
+    }
+    if (type === "VariableDeclarator") {
+      return ancestor.id;
+    }
+    if (type === "AssignmentExpression") {
+      return ancestor.left;
+    }
+    if (type === "FunctionDeclaration") {
+      return ancestor.id || ancestor;
+    }
+    return null;
   }
   static deepFirstTravel(node, filePath, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet) {
     const visitedNodeSet = /* @__PURE__ */ new Set();
@@ -57,12 +111,14 @@ var _AstUtil = class {
       uuid: "",
       variableScope: [],
       dependenceIds: /* @__PURE__ */ new Set(),
+      dependenceIdsNoScope: /* @__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()
+      effectIds: /* @__PURE__ */ new Set(),
+      occupation: /* @__PURE__ */ new Set()
     };
     node._util = _util;
     const { nodeCollection, children } = _util;
@@ -137,6 +193,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 +217,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 +266,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", "ClassMethod"].includes(node.type)) {
+      node.params.forEach((param) => this._deepFindIdentifier(param, (id) => {
         holdingIds.add(id || node);
         id._util.variableScope = [id];
         id._util.holdingIdType = "Param";
@@ -193,6 +275,8 @@ var _AstUtil = class {
     }
     holdingIds.forEach((holdingId) => {
       const holdingIdName = holdingId.name;
+      if (typeof holdingIdName !== "string")
+        return;
       const nodeSetOfIdName = holdingIdNameMap.get(holdingIdName) || /* @__PURE__ */ new Set();
       nodeSetOfIdName.add(holdingId);
       holdingIdNameMap.set(holdingIdName, nodeSetOfIdName);
@@ -207,20 +291,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 { _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 (dependenceId._util.variableScope.length === 0 && typeof dependenceId.name === "string" && holdingIdNameMap.has(dependenceId.name)) {
+        dependenceId._util.variableScope.push(...[...holdingIdNameMap.get(dependenceId.name)]);
+        const firstPick = dependenceId._util.variableScope[0];
         if (firstPick && firstPick._util.uuid !== dependenceId._util.uuid) {
-          firstPick._util.effectIds.add(dependenceId);
+          firstPick._util.occupation.add(dependenceId);
         }
       }
+      if (dependenceId._util.variableScope.length === 0) {
+        dependenceIdsNoScope.add(dependenceId);
+      }
     }
   }
   static isUseStateVarDec(node) {
@@ -235,7 +325,7 @@ var _AstUtil = class {
   static isUseMemoVarDec(node) {
     if (node.type !== "VariableDeclarator")
       return false;
-    const { id, init } = node;
+    const { init } = node;
     if (init.type !== "CallExpression")
       return false;
     const { callee } = init;
@@ -244,7 +334,7 @@ var _AstUtil = class {
   static isUseCallbackVarDec(node) {
     if (node.type !== "VariableDeclarator")
       return false;
-    const { id, init } = node;
+    const { init } = node;
     if (init.type !== "CallExpression")
       return false;
     const { callee } = init;
@@ -270,7 +360,7 @@ var _AstUtil = class {
     }
   }
   static collectEffectIdOfFnCall(node) {
-    var _a, _b, _c;
+    var _a, _b;
     if (node.type !== "CallExpression") {
       return;
     }
@@ -286,14 +376,29 @@ var _AstUtil = class {
         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);
+            const fnId = fnNode._util.parent.id;
+            if (fnId) {
+              fnId._util.effectIds.add(id);
+            } else {
+              fnNode._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 { id: fnId } = fnNode;
+          if (fnId) {
+            fnId._util.effectIds.add(id);
+          } else {
+            fnNode._util.effectIds.add(id);
+          }
+        } else if (fnNode.type === "ClassMethod") {
+          const { key: fnId } = fnNode;
+          if (fnId) {
+            fnId._util.effectIds.add(id);
+          } else {
+            fnNode._util.effectIds.add(id);
+          }
         }
       }
       const kindOfParamsElement = [...scopeId._util.effectIds].filter((e) => {
@@ -325,12 +430,12 @@ var _AstUtil = class {
       this.collectEffectIdOfUseCallback(node);
       return;
     }
-    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.collectExpressionIdentifiers(init, (id2) => createdExpIdSet.add(id2));
-    for (const createdId of idSet) {
-      createdId._util.effectIds = /* @__PURE__ */ new Set([...createdExpIdSet, ...createdId._util.effectIds]);
+    const leftIdSet = /* @__PURE__ */ new Set();
+    this._deepFindIdentifier(id, (ele) => leftIdSet.add(ele));
+    const rightIdSet = /* @__PURE__ */ new Set();
+    ["Identifier", "ArrowFunctionExpression", "FunctionExpression"].includes(init.type) ? rightIdSet.add(init) : this.collectExpressionIdentifiers(init, (id2) => rightIdSet.add(id2));
+    for (const item of leftIdSet) {
+      item._util.effectIds = /* @__PURE__ */ new Set([...rightIdSet, ...item._util.effectIds]);
     }
   }
   static collectEffectIdOfUseState(node) {
@@ -374,20 +479,13 @@ var _AstUtil = class {
   }
   static collectEffectIdOfAssign(node) {
     const { left, right } = node;
+    const idSetOfLeft = /* @__PURE__ */ new Set();
+    this.collectExpressionIdentifiers(left, (id) => idSetOfLeft.add(id));
     const idSetOfRight = /* @__PURE__ */ new Set();
     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.collectExpressionIdentifiers(left2, (id) => idSetOfLeft.add(id));
-      for (const id of idSetOfLeft) {
-        id._util.effectIds = /* @__PURE__ */ new Set([...idSetOfRight, ...id._util.effectIds]);
-      }
+    for (const id of idSetOfLeft) {
+      id._util.effectIds = /* @__PURE__ */ new Set([...idSetOfRight, ...id._util.effectIds]);
     }
-    ;
   }
   static collectEffectIdOfUnaryUpdate(node) {
     const { argument } = node;
@@ -418,13 +516,13 @@ var _AstUtil = class {
   static expressionTypeIsIdentifier(exp) {
     return (exp == null ? void 0 : exp.type) === "Identifier";
   }
-  static collectExpressionIdentifiers(exp, callback) {
+  static collectExpressionIdentifiersShallow(exp, callback) {
     if (!exp || exp.type === "ThisExpression") {
       return;
     }
-    this._collectExpressionIdentifiers(exp, callback);
+    this._collectExpressionIdentifiersShallow(exp, callback);
   }
-  static _collectExpressionIdentifiers(exp, callback) {
+  static _collectExpressionIdentifiersShallow(exp, callback) {
     var _a, _b, _c;
     if (!exp || exp.type === "ThisExpression") {
       return;
@@ -446,100 +544,36 @@ var _AstUtil = class {
       callback(exp);
       return;
     }
-    exp._util.nodeCollection.forEach((ele) => this._collectExpressionIdentifiers(ele, callback));
   }
-  static deepFindIdOfExpression(exp, callback) {
+  static collectExpressionIdentifiers(exp, callback) {
     if (!exp || exp.type === "ThisExpression") {
       return;
     }
-    this._deepFindIdOfExpression(exp, callback);
+    this._collectExpressionIdentifiers(exp, callback);
   }
-  static _deepFindIdOfExpression(exp, callback) {
-    var _a;
+  static _collectExpressionIdentifiers(exp, callback) {
+    var _a, _b, _c;
     if (!exp || exp.type === "ThisExpression") {
       return;
     }
-    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") {
-      const expression = exp.expression;
-      callback(expression);
-    } else if (exp.type === "MemberExpression" || exp.type === "JSXMemberExpression") {
-      const rootIdentifier = this.getRootIdentifierOfMemberExpression(exp);
-      this.expressionTypeIsIdentifier(rootIdentifier) && callback(rootIdentifier);
-    } else if (exp.type === "ObjectExpression") {
-      const properties = exp.properties;
-      for (const property of properties) {
-        if (property.type === "SpreadElement") {
-          this._deepFindIdOfExpression(property, callback);
-        } else {
-          const value = property.value;
-          this.expressionTypeIsIdentifier(value) ? callback(value) : this._deepFindIdOfExpression(value, callback);
+    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);
       }
-    } else if (exp.type === "ArrayExpression") {
-      const elements = exp.elements;
-      for (const element of elements) {
-        this.expressionTypeIsIdentifier(element) ? callback(element) : this._deepFindIdOfExpression(element, callback);
-      }
-    } else if (exp.type === "ArrowFunctionExpression") {
-      const body = exp.body;
-      this.expressionTypeIsIdentifier(body) ? callback(body) : this._deepFindIdOfExpression(body, callback);
-    } else if (exp.type === "CallExpression") {
-      const callee = exp.callee;
-      this.expressionTypeIsIdentifier(callee) ? callback(callee) : this._deepFindIdOfExpression(callee, callback);
-      const args = exp.arguments;
-      for (const argument of args) {
-        this.expressionTypeIsIdentifier(argument) ? callback(argument) : this._deepFindIdOfExpression(argument, callback);
-      }
-    } else if (exp.type === "AssignmentExpression" || exp.type === "BinaryExpression" || exp.type === "LogicalExpression") {
-      const { left, right } = exp;
-      [left, right].forEach((e) => this.expressionTypeIsIdentifier(e) ? callback(e) : this._deepFindIdOfExpression(e, callback));
-    } else if (exp.type === "UpdateExpression") {
-      const argument = exp.argument;
-      this.expressionTypeIsIdentifier(argument) ? callback(argument) : this._deepFindIdOfExpression(argument, callback);
-    } else if (exp.type === "SequenceExpression") {
-      const { expressions } = exp;
-      for (const expression of expressions) {
-        this.expressionTypeIsIdentifier(expression) ? callback(expression) : this._deepFindIdOfExpression(expression, callback);
-      }
-    } else if (exp.type === "ConditionalExpression") {
-      const { test, consequent, alternate } = exp;
-      [test, consequent, alternate].forEach((e) => this._deepFindIdOfExpression(e, callback));
-    } else if (exp.type === "JSXExpressionContainer") {
-      const { expression } = exp;
-      expression.name && callback(expression);
-    } 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;
-      value && this._deepFindIdOfExpression(value, callback);
-    } else if (exp.type === "JSXElement") {
-      const openingElement = exp.openingElement;
-      this._deepFindIdOfExpression(openingElement, callback);
-    } else if (exp.type === "JSXOpeningElement") {
-      const { name, attributes } = exp;
-      this._deepFindIdOfExpression(name, callback);
-      for (const attribute of attributes) {
-        this._deepFindIdOfExpression(attribute, callback);
-      }
+      return;
     }
-  }
-  static getRootIdentifierOfMemberExpression(memExp) {
-    if (memExp.type === "MemberExpression" || memExp.type === "JSXMemberExpression") {
-      return this.getRootIdentifierOfMemberExpression(memExp.object);
+    if (exp.type === "JSXIdentifier" && ((_c = exp._util.parent) == null ? void 0 : _c.type) !== "JSXAttribute") {
+      callback(exp);
+      return;
     }
-    return memExp;
+    exp._util.nodeCollection.forEach((ele) => this._collectExpressionIdentifiers(ele, callback));
   }
   static findIdOfImport(node, callback) {
     const specifiers = node.specifiers;
@@ -564,6 +598,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);
     }
@@ -641,14 +679,14 @@ var _AstUtil = class {
     return id._util.variableScope.length === 0 && !this.isPropertyOfGlobal(id) && !this.isIntrinsicElement(id) && !this.isStandardAttribute(id);
   }
   static isPropertyOfGlobal(node) {
-    return node.type === "Identifier" && !node._util.variableScope.length && this.windowProperties.includes(node.name);
+    return node.type === "Identifier" && !node._util.variableScope.length && typeof node.name === "string" && this.windowProperties.includes(node.name);
   }
   static isIntrinsicElement(node) {
     var _a;
-    return node.type === "JSXIdentifier" && ((_a = node._util.parent) == null ? void 0 : _a.type) && ["JSXOpeningElement", "JSXClosingElement"].includes(node._util.parent.type) && this.intrinsicElements.includes(node.name);
+    return node.type === "JSXIdentifier" && ((_a = node._util.parent) == null ? void 0 : _a.type) && ["JSXOpeningElement", "JSXClosingElement"].includes(node._util.parent.type) && typeof node.name === "string" && this.intrinsicElements.includes(node.name);
   }
   static isStandardAttribute(node) {
-    return node._util.parent.type === "JSXAttribute" && this.standardAttributes.includes(node.name);
+    return node._util.parent.type === "JSXAttribute" && typeof node.name === "string" && this.standardAttributes.includes(node.name);
   }
   static getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet, lineNumberStart, lineNumberEnd) {
     const nodeSet = /* @__PURE__ */ new Set();

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

@@ -28,7 +28,7 @@ var mapReportType = {
   delete: "删除"
 };
 function createMdByJson(report) {
-  const allFiles = `# 文件汇总
+  const allFiles = `# 改动文件汇总
 ${report.map((r) => `- ${r.filePath}`).join("\n")}
 
 `;
@@ -39,12 +39,11 @@ function reportItemToMd(report) {
   return [
     `## ${filePath}`,
     `### 类型: ${mapReportType[type]}`,
-    filesDependsOnMe.length > 0 ? `### 所影响的文件(重要性由高到低)
-${filesDependsOnMe.map((files, index) => files.map((file) => "  ".repeat(index) + `- ${file}`)).flat().join("\n")}` : "",
+    filesDependsOnMe.length > 0 ? `### 所影响的文件
+${filesDependsOnMe.slice(0, 1).map((files) => files.map((file) => `- ${file}`)).flat().join("\n")}` : "",
     undefinedIdentifiers.length > 0 ? `### 未定义的变量
 > ${undefinedIdentifiers.map((e) => `**${e}**`).join(", ")}` : "",
-    dangerIdentifiers.length > 0 ? `### 重点检查使用的变量
-> ${dangerIdentifiers.join(", ")}` : "",
+    // dangerIdentifiers.length > 0 ? `### 重点检查使用的变量\n> ${dangerIdentifiers.join(', ')}` : '',
     blockReports.length > 0 ? `### 对比分析 共${blockReports.length}处` : "",
     ...blockReports.map(blockReportToMd)
   ].filter(Boolean).join("\n\n");
@@ -63,16 +62,19 @@ ${diff_txt.join("\n")}
     ...infos.map(blockReportInfoItemToMd)
   ].filter(Boolean).join("\n\n");
 }
-function blockReportInfoItemToMd(info, index) {
+function blockReportInfoItemToMd(info) {
   const {
     causeBy,
-    effects
+    effects,
+    occupations
   } = info;
   return [
-    `#### 序号${index + 1}`,
     effects.length > 0 ? `#### ${causeBy}
 - 影响：
-${effects.map((e) => `> ${e}`).join("\n")}` : ""
+${effects.map((e) => `> ${e}`).join("\n")}` : "- 无影响",
+    occupations.length > 0 ? `#### ${causeBy}
+- 使用：
+${occupations.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.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.d.ts

@@ -30,9 +30,10 @@ export declare function createDetectReport(arg: Arg): {
         infos: {
             causeBy: string;
             effects: string[];
+            occupations: string[];
         }[];
     }[];
-    type: "delete" | "add" | "modify";
+    type: "delete" | "modify" | "add";
     filesDependsOnMe: string[][];
     undefinedIdentifiers: string[];
     dangerIdentifiers: string[];

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 });
     }
@@ -75,15 +76,19 @@ function createDetectReport(arg) {
         const addNodeAndPaths = blockReport.addNodeAndPaths.filter((e) => fileAddedNodesPaths.includes(e.nodePath));
         const infosList = addNodeAndPaths.map((item) => {
           const { node } = item;
-          const { effectIds } = node._util;
+          const { effectIds, occupation, holdingIdType } = node._util;
           return {
-            causeBy: import_AstUtil.default.getShortNodeMsg(node),
-            effects: [...effectIds].map((e) => import_AstUtil.default.getShortNodeMsg(e))
+            causeBy: import_AstUtil.default.getShortNodeMsg(node, true),
+            effects: holdingIdType ? [...occupation].map((occupationId) => {
+              const ans = import_AstUtil.default.getAncestorsFromBirth(occupationId, node);
+              return import_AstUtil.default.getNearestImpactedNode(ans.reverse());
+            }).filter(Boolean).map((e) => import_AstUtil.default.getShortNodeMsg(e, true)) : [...effectIds].map((e) => import_AstUtil.default.getShortNodeMsg(e, true)),
+            occupations: [...occupation].map((e) => import_AstUtil.default.getShortNodeMsg(e, true))
           };
         });
         return {
           diff_txt,
-          infos: infosList.filter((e) => e.effects.length > 0)
+          infos: infosList.filter((e) => e.effects.length > 0 || e.occupations.length > 0)
         };
       }).filter((e) => e.infos.length > 0)
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-code-detector",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "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": [

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

@@ -1,32 +0,0 @@
-import { AstNode } from "../ast_util/AstUtil";
-import { GitDiffDetail } from "../format_git_diff_content";
-type BlockReportKind = "Import" | "Declaration" | "Assignment" | "SelfUpdate" | "Invoke" | "Other";
-type EffectItem = {
-    causeBy: AstNode;
-    effects: AstNode[];
-};
-type BlockReportInfoItem = {
-    kind: BlockReportKind;
-    topAdded: AstNode[];
-    topRemoved: AstNode[];
-    added: string[];
-    addedNotUsed: string[];
-    addedNotFound: string[];
-    addedEffects: EffectItem[];
-    removed: string[];
-    removedStillUsing: string[];
-    removedEffects: EffectItem[];
-};
-export type BlockReport = {
-    index: number;
-    diff_txt: string[];
-    infos: BlockReportInfoItem[];
-};
-type Arg = {
-    gitDiffItem: GitDiffDetail;
-    absPathPrefix: string;
-    blockReports: BlockReport[];
-    index: number;
-};
-export default function codeBlockDetect(arg: Arg): void;
-export {};

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

@@ -1,277 +0,0 @@
-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/code_block_detect.ts
-var code_block_detect_exports = {};
-__export(code_block_detect_exports, {
-  default: () => codeBlockDetect
-});
-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: [],
-  infos: []
-});
-var createBlockReportInfoItem = (kind) => ({
-  kind,
-  topAdded: [],
-  topRemoved: [],
-  added: [],
-  addedNotUsed: [],
-  addedNotFound: [],
-  addedEffects: [],
-  removed: [],
-  removedStillUsing: [],
-  removedEffects: []
-});
-var findOrCreateBlockReport = (blockReports, kind, index, diff_txt) => {
-  const res = blockReports.find((item) => item.index === index) || createBlockReport(kind, index);
-  res.diff_txt = diff_txt;
-  if (!blockReports.includes(res)) {
-    blockReports.push(res);
-  }
-  const tmpInfo = res.infos.find((info) => info.kind === kind) || createBlockReportInfoItem(kind);
-  if (!res.infos.includes(tmpInfo)) {
-    res.infos.push(tmpInfo);
-  }
-  return tmpInfo;
-};
-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(), "..", import_constants.SOURCE, filePath);
-  const { mapFileLineToNodeSet: mapFileLineToNodeSetOld } = (0, import_getAstKitByFilePath.default)(filePathOfOld, absPathPrefix);
-  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);
-    iterateNodes(addNodes, "add", { blockReports, programNode, diff_txt: items }, index);
-    iterateNodes(removeNodes, "remove", { blockReports, programNode, diff_txt: items }, index);
-  }
-}
-function getPathsOfNode(topScopeNodes) {
-  const paths = [];
-  for (const topScopeNode of topScopeNodes) {
-    const nodeCollection = topScopeNode._util.nodeCollection;
-    for (const nodeItem of nodeCollection) {
-      if (nodeItem.type.endsWith("Identifier") || nodeItem.type.endsWith("Literal")) {
-        paths.push(import_AstUtil.default.getNodePath(nodeItem));
-      }
-    }
-  }
-  return [...new Set(paths)];
-}
-function mapNodePath(list) {
-  return list.map((item) => ({ ...item, effects: item.effects.map((ele) => ({ ele, path: import_AstUtil.default.getNodePath(ele) })) }));
-}
-function filterBySamePathAndLen(list, sameEffectsPaths) {
-  return list.map((e) => ({ ...e, effects: e.effects.filter((item) => !sameEffectsPaths.includes(item.path)) })).filter((e) => e.effects.length);
-}
-function extractEffectItem(list) {
-  return list.map((e) => ({ ...e, effects: e.effects.map((item) => item.ele) }));
-}
-function pushBlockReport(blockReportInfoItem, programNode, index) {
-  if (blockReportInfoItem.kind === "Other") {
-    ["added", "removed"].forEach((key) => {
-      const tailElements = blockReportInfoItem[key].map((ele) => ele.split(":").at(-1)).filter((e) => e && e !== "undefined");
-      blockReportInfoItem[key] = [...new Set(tailElements)];
-    });
-  }
-  const sameNames = blockReportInfoItem.added.filter((path) => blockReportInfoItem.removed.includes(path));
-  if (sameNames.length) {
-    ["added", "removed"].forEach((key) => {
-      blockReportInfoItem[key] = blockReportInfoItem[key].filter((path) => !sameNames.includes(path));
-    });
-  }
-  const addedEffectsList = mapNodePath(blockReportInfoItem.addedEffects);
-  const removedEffectsList = mapNodePath(blockReportInfoItem.removedEffects);
-  const addedEffectsPaths = addedEffectsList.map((item) => item.effects.map(({ path }) => path)).flat();
-  const removedEffectsPaths = removedEffectsList.map((item) => item.effects.map(({ path }) => path)).flat();
-  const sameEffectsPaths = addedEffectsPaths.filter((path) => removedEffectsPaths.includes(path));
-  if (sameEffectsPaths.length) {
-    const addedEffects = filterBySamePathAndLen(addedEffectsList, sameEffectsPaths);
-    const removedEffects = filterBySamePathAndLen(removedEffectsList, sameEffectsPaths);
-    blockReportInfoItem.addedEffects = extractEffectItem(addedEffects);
-    blockReportInfoItem.removedEffects = extractEffectItem(removedEffects);
-  }
-}
-function iterateNodes(topScopeNodes, operation, extra, index) {
-  for (const topScopeNode of topScopeNodes) {
-    if (["ImportDeclaration", "ImportSpecifier", "ImportDefaultSpecifier"].includes(topScopeNode.type)) {
-      detectImport({ topScopeNode, operation, extra }, index);
-    } else if (["VariableDeclaration", "VariableDeclarator"].includes(topScopeNode.type) || import_AstUtil.default.isSubNodeOfVariableDeclarator(topScopeNode)) {
-      detectVariableDeclaration({ topScopeNode, operation, extra }, index);
-    } else if (["FunctionDeclaration", "ClassDeclaration"].includes(topScopeNode.type)) {
-      detectFnClsDeclaration({ topScopeNode, operation, extra }, index);
-    } else if (["UnaryExpression", "UpdateExpression"].includes(topScopeNode.type)) {
-      detectUpdateEffectExp({ topScopeNode, operation, extra }, index);
-    } else if (["CallExpression"].includes(topScopeNode.type)) {
-      detectFnCallExp({ topScopeNode, operation, extra }, index);
-    } else if (["AssignmentExpression"].includes(topScopeNode.type)) {
-      detectAssignmentEffectExp({ topScopeNode, operation, extra }, index);
-    } else if (["ExpressionStatement"].includes(topScopeNode.type)) {
-      const { expression } = topScopeNode;
-      iterateNodes([expression], operation, extra, index);
-    } else {
-      detectOther({ topScopeNode, operation, extra }, index);
-    }
-  }
-}
-function detectOther(arg, index) {
-  const { topScopeNode, operation, extra: { blockReports, programNode, diff_txt } } = arg;
-  const blockReportInfoItem = findOrCreateBlockReport(blockReports, "Other", index, diff_txt);
-  const { added, removed } = blockReportInfoItem;
-  const nodePaths = getPathsOfNode(topScopeNode._util.nodeCollection);
-  (operation === "add" ? added : removed).push(...nodePaths);
-  pushBlockReport(blockReportInfoItem, programNode, index);
-}
-function detectImport(arg, index) {
-  const { topScopeNode, operation, extra: { blockReports, programNode, diff_txt } } = arg;
-  const blockReport = findOrCreateBlockReport(blockReports, "Import", index, diff_txt);
-  const { added, removed, addedEffects, removedEffects } = blockReport;
-  const specifiers = topScopeNode.type === "ImportDeclaration" ? topScopeNode.specifiers : [topScopeNode];
-  if (Array.isArray(specifiers)) {
-    specifiers.forEach((s) => {
-      const { local } = s;
-      (operation === "add" ? added : removed).push(local.name);
-      (operation === "add" ? addedEffects : removedEffects).push({ causeBy: local, effects: [...local._util.effectIds] });
-    });
-  }
-  pushBlockReport(blockReport, programNode, index);
-}
-function detectFnClsDeclaration(arg, index) {
-  const { topScopeNode, operation, extra: { blockReports, programNode, diff_txt } } = arg;
-  const blockReport = findOrCreateBlockReport(blockReports, "Declaration", index, diff_txt);
-  const { added, removed, addedEffects, removedEffects } = blockReport;
-  const { id } = topScopeNode;
-  (operation === "add" ? added : removed).push(id.name);
-  (operation === "add" ? addedEffects : removedEffects).push({ causeBy: id, effects: [...id._util.effectIds] });
-  pushBlockReport(blockReport, programNode, index);
-}
-function insertPrefix(n, prefix, sep = ":") {
-  return [prefix, n].join(sep);
-}
-function detectVariableDeclaration(arg, index) {
-  const { topScopeNode, operation, extra: { blockReports, programNode, diff_txt } } = arg;
-  const blockReport = findOrCreateBlockReport(blockReports, "Declaration", index, diff_txt);
-  const { added, removed, addedEffects, removedEffects } = blockReport;
-  if (["VariableDeclaration", "VariableDeclarator"].includes(topScopeNode.type)) {
-    let declarations = [];
-    if (topScopeNode.type === "VariableDeclarator") {
-      declarations = [topScopeNode];
-    } else {
-      declarations = topScopeNode.declarations;
-    }
-    if (Array.isArray(declarations)) {
-      for (const declaration of declarations) {
-        const { id, init } = declaration;
-        if (id) {
-          id._util.nodeCollection.forEach((item) => {
-            if (item.type === "Identifier") {
-              (operation === "add" ? added : removed).push(insertPrefix(item.name, "id"));
-              (operation === "add" ? addedEffects : removedEffects).push({ causeBy: item, effects: [...item._util.effectIds] });
-            }
-          });
-        }
-        const initIdSet = /* @__PURE__ */ new Set();
-        if (init && !["ArrowFunctionExpression", "FunctionExpression"].includes(init.type)) {
-          ["Identifier"].includes(init.type) ? initIdSet.add(init) : import_AstUtil.default.deepFindIdOfExpression(init, (id2) => initIdSet.add(id2));
-          for (const initId of initIdSet) {
-            operation === "add" ? blockReport.added.push(insertPrefix(initId.name, "init")) : blockReport.removed.push(insertPrefix(initId.name, "init"));
-          }
-        }
-      }
-    }
-  } else {
-    topScopeNode._util.nodeCollection.forEach((item) => {
-      if (item.type === "Identifier") {
-        (operation === "add" ? added : removed).push(insertPrefix(item.name, "id"));
-        (operation === "add" ? addedEffects : removedEffects).push({ causeBy: item, effects: [...item._util.effectIds] });
-      }
-    });
-  }
-  pushBlockReport(blockReport, programNode, index);
-}
-function detectUpdateEffectExp(arg, index) {
-  const { topScopeNode, operation, extra: { blockReports, programNode, diff_txt } } = arg;
-  const blockReport = findOrCreateBlockReport(blockReports, "SelfUpdate", index, diff_txt);
-  const { added, removed, addedEffects, removedEffects } = blockReport;
-  const { argument: args } = topScopeNode;
-  const createdExpIdSet = /* @__PURE__ */ new Set();
-  import_AstUtil.default.deepFindIdOfExpression(args, (id) => createdExpIdSet.add(id));
-  for (const createdExpId of createdExpIdSet) {
-    (operation === "add" ? added : removed).push(createdExpId.name);
-    (operation === "add" ? addedEffects : removedEffects).push({ causeBy: createdExpId, effects: [...createdExpId._util.effectIds] });
-  }
-  pushBlockReport(blockReport, programNode, index);
-}
-function detectFnCallExp(arg, index) {
-  const { topScopeNode, operation, extra: { blockReports, programNode, diff_txt } } = arg;
-  const blockReport = findOrCreateBlockReport(blockReports, "Invoke", index, diff_txt);
-  const { added, removed, addedEffects, removedEffects } = blockReport;
-  const { callee, arguments: args } = topScopeNode;
-  const argsIds = args.map((arg2) => arg2._util.nodeCollection.filter((n) => n.type === "Identifier")).flat();
-  for (const argsId of argsIds) {
-    (operation === "add" ? added : removed).push(argsId.name);
-    (operation === "add" ? addedEffects : removedEffects).push({ causeBy: argsId, effects: [...argsId._util.effectIds] });
-  }
-  const createdExpIdSet = /* @__PURE__ */ new Set();
-  import_AstUtil.default.deepFindIdOfExpression(callee, (id) => createdExpIdSet.add(id));
-  for (const createdExpId of createdExpIdSet) {
-    (operation === "add" ? added : removed).push(createdExpId.name);
-    (operation === "add" ? addedEffects : removedEffects).push({ causeBy: createdExpId, effects: [...createdExpId._util.effectIds] });
-  }
-  pushBlockReport(blockReport, programNode, index);
-}
-function detectAssignmentEffectExp(arg, index) {
-  const { topScopeNode, operation, extra: { blockReports, programNode, diff_txt } } = arg;
-  const blockReport = findOrCreateBlockReport(blockReports, "Assignment", index, diff_txt);
-  const { added, removed, addedEffects, removedEffects } = blockReport;
-  const { left, right } = topScopeNode;
-  const idSetLeft = /* @__PURE__ */ new Set();
-  ["Identifier"].includes(left.type) ? idSetLeft.add(left) : import_AstUtil.default.deepFindIdOfExpression(left, (id) => idSetLeft.add(id));
-  for (const createdExp of idSetLeft) {
-    (operation === "add" ? added : removed).push(insertPrefix(createdExp.name, "left"));
-    (operation === "add" ? addedEffects : removedEffects).push({ causeBy: createdExp, effects: [...createdExp._util.effectIds] });
-  }
-  const idSetRight = /* @__PURE__ */ new Set();
-  ["Identifier", "ArrowFunctionExpression", "FunctionExpression"].includes(right.type) ? idSetRight.add(right) : import_AstUtil.default.deepFindIdOfExpression(right, (id) => idSetRight.add(id));
-  for (const createdExp of idSetRight) {
-    (operation === "add" ? added : removed).push(insertPrefix(createdExp.name, "right"));
-  }
-  pushBlockReport(blockReport, programNode, index);
-}