js-code-detector 0.0.21 → 0.0.22

package/dist/cjs/index.js

@@ -139,33 +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 && npx max setup`, { shell: "/bin/bash" });
+  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("临时目录已删除");
   });

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', {
@@ -32,12 +32,16 @@ export interface AstNode {
         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;
@@ -64,9 +68,6 @@ export default class AstUtil {
     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();
@@ -63,7 +117,8 @@ var _AstUtil = class {
       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;
@@ -211,7 +266,7 @@ var _AstUtil = class {
         }
       });
     }
-    if (["FunctionDeclaration", "ArrowFunctionExpression", "FunctionExpression", "ObjectMethod"].includes(node.type)) {
+    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];
@@ -220,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);
@@ -234,7 +291,7 @@ var _AstUtil = class {
     return node._util.parentProperty === "argument" && ((_a = node._util.parent) == null ? void 0 : _a.type) === "ReturnStatement";
   }
   static collectDependenceIds(node) {
-    const { type, _util } = node;
+    const { _util } = node;
     const { dependenceIds, holdingIdNameMap, children, dependenceIdsNoScope } = _util;
     children.forEach((child) => {
       if (child._util.dependenceIdsNoScope.size > 0) {
@@ -244,18 +301,16 @@ var _AstUtil = class {
       this.collectExpressionIdentifiersShallow(child, (id) => dependenceIds.add(id));
     });
     for (const dependenceId of dependenceIds) {
-      if (dependenceId._util.variableScope.length === 0) {
-        const sameNameIds = [...holdingIdNameMap.get(dependenceId.name) || []];
-        if (sameNameIds.length > 0) {
-          dependenceId._util.variableScope.push(...sameNameIds);
-          const firstPick = sameNameIds[0];
-          if (firstPick && firstPick._util.uuid !== dependenceId._util.uuid) {
-            firstPick._util.effectIds.add(dependenceId);
-          }
-        } else {
-          dependenceIdsNoScope.add(dependenceId);
+      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.occupation.add(dependenceId);
         }
       }
+      if (dependenceId._util.variableScope.length === 0) {
+        dependenceIdsNoScope.add(dependenceId);
+      }
     }
   }
   static isUseStateVarDec(node) {
@@ -270,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;
@@ -279,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;
@@ -305,7 +360,7 @@ var _AstUtil = class {
     }
   }
   static collectEffectIdOfFnCall(node) {
-    var _a, _b, _c;
+    var _a, _b;
     if (node.type !== "CallExpression") {
       return;
     }
@@ -321,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) => {
@@ -360,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) {
@@ -409,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;
@@ -512,99 +575,6 @@ var _AstUtil = class {
     }
     exp._util.nodeCollection.forEach((ele) => this._collectExpressionIdentifiers(ele, callback));
   }
-  static deepFindIdOfExpression(exp, callback) {
-    if (!exp || exp.type === "ThisExpression") {
-      return;
-    }
-    this._deepFindIdOfExpression(exp, callback);
-  }
-  static _deepFindIdOfExpression(exp, callback) {
-    var _a;
-    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);
-        }
-      }
-    } 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);
-      }
-    }
-  }
-  static getRootIdentifierOfMemberExpression(memExp) {
-    if (memExp.type === "MemberExpression" || memExp.type === "JSXMemberExpression") {
-      return this.getRootIdentifierOfMemberExpression(memExp.object);
-    }
-    return memExp;
-  }
   static findIdOfImport(node, callback) {
     const specifiers = node.specifiers;
     for (const specifier of specifiers) {
@@ -709,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/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.slice(0, 1).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.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

@@ -76,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.21",
+  "version": "0.0.22",
   "description": "",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",

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);
-}