js-code-detector 0.0.44 → 0.0.47

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

@@ -123,7 +123,7 @@ var _AstUtil = class {
       return node;
     }
     Object.keys(node).forEach((nodeKey) => {
-      if (this.invalidNodeKey.includes(nodeKey) || nodeKey.startsWith("TS") || nodeKey.endsWith("Annotation")) {
+      if (this.invalidNodeKey.includes(nodeKey)) {
         return;
       }
       const nodeValue = node[nodeKey];
@@ -190,7 +190,95 @@ var _AstUtil = class {
     }
     return node;
   }
+  static findRelatedExportNameOfDeclarationIdentifier(id) {
+    var _a;
+    const occupationInExport = [...id._util.occupation].filter((op) => {
+      var _a2;
+      return ["ExportSpecifier", "ExportDefaultDeclaration"].includes((_a2 = op._util.parent) == null ? void 0 : _a2.type);
+    });
+    for (const op of occupationInExport) {
+      const occupationParentType = (_a = op._util.parent) == null ? void 0 : _a.type;
+      if (occupationParentType === "ExportSpecifier") {
+        return op._util.parent.exported.name;
+      }
+      if (occupationParentType === "ExportDefaultDeclaration") {
+        return "default";
+      }
+    }
+  }
+  static findExportedMembersNameFromAncestors(node) {
+    var _a, _b;
+    if (!node) {
+      console.warn("findExportedMembersNameFromAncestors: node is null");
+      return [];
+    }
+    const ancestors = node._util.ancestors;
+    const nodeArray = [...ancestors, node];
+    const nameList = /* @__PURE__ */ new Set();
+    outer:
+      for (const ancestor of nodeArray) {
+        if (ancestor.type === "ExportDefaultDeclaration") {
+          const { declaration } = ancestor;
+          if (declaration) {
+            nameList.add("default");
+            break outer;
+          }
+        }
+        if (ancestor.type === "ExportNamedDeclaration") {
+          const declarationType = (_a = ancestor.declaration) == null ? void 0 : _a.type;
+          if (this.EXPORT_DECLARATION_TYPES.includes(declarationType)) {
+            const nameToAdd = ancestor.declaration.id.name;
+            if (nameToAdd) {
+              nameList.add(nameToAdd);
+            }
+            break outer;
+          } else if (["VariableDeclaration"].includes(declarationType)) {
+            this.findIdOfVariable(ancestor.declaration, (identifier) => {
+              nameList.add(identifier.name);
+            });
+            break outer;
+          } else if (declarationType) {
+            console.log("未处理的 declarationType :", declarationType);
+          }
+          const specifiers = ancestor.specifiers;
+          if (Array.isArray(specifiers)) {
+            for (const specifier of specifiers) {
+              if (specifier.type === "ExportSpecifier" || specifier.type === "ExportNamespaceSpecifier") {
+                nameList.add(specifier.exported.name);
+              }
+            }
+          }
+          break outer;
+        }
+        if (["FunctionDeclaration", "ClassDeclaration"].includes(ancestor.type) && "Program" === ((_b = ancestor._util.parent) == null ? void 0 : _b.type)) {
+          const ancestorId = ancestor.id;
+          if (ancestorId) {
+            const nameToAdd = this.findRelatedExportNameOfDeclarationIdentifier(ancestorId);
+            if (nameToAdd) {
+              nameList.add(nameToAdd);
+            }
+          }
+          break outer;
+        }
+        if (["VariableDeclarator"].includes(ancestor.type)) {
+          const id = ancestor.id;
+          const varIdentifierSet = /* @__PURE__ */ new Set();
+          this._deepFindIdentifier(id, (identifier) => {
+            varIdentifierSet.add(identifier);
+          });
+          for (const identifier of varIdentifierSet) {
+            const nameToAdd = this.findRelatedExportNameOfDeclarationIdentifier(identifier);
+            if (nameToAdd) {
+              nameList.add(nameToAdd);
+            }
+          }
+          break outer;
+        }
+      }
+    return Array.from(nameList);
+  }
   static updateImportedAndExportedMember(node, programNode) {
+    var _a;
     const { type, source, declaration, specifiers, _util } = node;
     const { filePath } = _util;
     const sourceValue = (source == null ? void 0 : source.value) || filePath;
@@ -210,10 +298,19 @@ var _AstUtil = class {
           });
           return;
         }
-        target.members.push({
-          localName: local.name,
-          importedName: (imported == null ? void 0 : imported.name) || "default"
-        });
+        if (specifier.type === "ImportDefaultSpecifier") {
+          target.members.push({
+            localName: local.name,
+            importedName: "default"
+          });
+          return;
+        }
+        if (specifier.type === "ImportSpecifier") {
+          target.members.push({
+            localName: local.name,
+            importedName: imported.name
+          });
+        }
       });
     }
     if (type === "ExportAllDeclaration") {
@@ -223,32 +320,61 @@ var _AstUtil = class {
       }
     }
     if (type === "ExportNamedDeclaration") {
-      specifiers.forEach((specifier) => {
+      Array.isArray(specifiers) && specifiers.forEach((specifier) => {
         const { local, exported } = specifier;
         let target = exportedMember.find((v) => v.sourcePath === sourceValue);
         if (!target) {
           target = { sourcePath: sourceValue, members: [], ExportAllDeclaration: false };
           exportedMember.push(target);
         }
-        target.members.push({
-          localName: (local == null ? void 0 : local.name) || "",
-          exportedName: exported.name
-        });
+        if (specifier.type === "ExportNamespaceSpecifier") {
+          target.members.push({
+            localName: "*",
+            exportedName: exported.name
+          });
+          return;
+        }
+        if (specifier.type === "ExportSpecifier") {
+          target.members.push({
+            localName: local.name,
+            exportedName: exported.name
+          });
+          return;
+        }
       });
       if (Array.isArray(declaration == null ? void 0 : declaration.declarations)) {
         declaration == null ? void 0 : declaration.declarations.forEach((dec) => {
-          var _a;
+          var _a2;
           let target = exportedMember.find((v) => v.sourcePath === sourceValue);
           if (!target) {
             target = { sourcePath: sourceValue, members: [], ExportAllDeclaration: false };
             exportedMember.push(target);
           }
-          const idName = (_a = dec.id) == null ? void 0 : _a.name;
+          try {
+            const idName = (_a2 = dec.id) == null ? void 0 : _a2.name;
+            target.members.push({
+              localName: idName,
+              exportedName: idName
+            });
+          } catch (e) {
+            console.log("declaration?.declarations.forEach", e.message);
+          }
+        });
+      } else if (this.EXPORT_DECLARATION_TYPES.includes(declaration == null ? void 0 : declaration.type)) {
+        let target = exportedMember.find((v) => v.sourcePath === filePath);
+        if (!target) {
+          target = { sourcePath: filePath, members: [], ExportAllDeclaration: false };
+          exportedMember.push(target);
+        }
+        try {
+          const idName = (_a = declaration.id) == null ? void 0 : _a.name;
           target.members.push({
             localName: idName,
             exportedName: idName
           });
-        });
+        } catch (e) {
+          console.log("declaration " + e.message);
+        }
       }
     }
     if (type === "ExportDefaultDeclaration") {
@@ -299,7 +425,7 @@ var _AstUtil = class {
     });
   }
   static handleDeclaration(node, callback) {
-    if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+    if (this.EXPORT_DECLARATION_TYPES.includes(node.type)) {
       const id = node.id;
       if (id) {
         callback(id);
@@ -387,14 +513,6 @@ var _AstUtil = class {
       holdingIdNameMap.set(holdingIdName, nodeSetOfIdName);
     });
   }
-  static isVarInit(node) {
-    var _a;
-    return node._util.parentProperty === "init" && ((_a = node._util.parent) == null ? void 0 : _a.type) === "VariableDeclarator";
-  }
-  static isReturnArgument(node) {
-    var _a;
-    return node._util.parentProperty === "argument" && ((_a = node._util.parent) == null ? void 0 : _a.type) === "ReturnStatement";
-  }
   static collectDependenceIds(node) {
     const { _util } = node;
     const { dependenceIds, holdingIdNameMap, children, dependenceIdsNoScope } = _util;
@@ -613,17 +731,17 @@ var _AstUtil = class {
       callback(node.declaration);
       return;
     }
-    if (node.type === "ExportNamedDeclaration" && Array.isArray(node.specifiers)) {
-      for (const specifier of node.specifiers) {
+    if (node.type === "ExportNamedDeclaration") {
+      Array.isArray(node.specifiers) && node.specifiers.forEach((specifier) => {
         if (specifier.type === "ExportSpecifier") {
           callback(specifier.local);
         }
+      });
+      if (node.declaration) {
+        this.handleDeclaration(node.declaration, callback);
       }
     }
   }
-  static expressionTypeIsIdentifier(exp) {
-    return (exp == null ? void 0 : exp.type) === "Identifier";
-  }
   static collectExpressionIdentifiersShallow(exp, callback) {
     if (!exp || exp.type === "ThisExpression") {
       return;
@@ -796,50 +914,40 @@ var _AstUtil = class {
   static isStandardAttribute(node) {
     return node._util.parent.type === "JSXAttribute" && typeof node.name === "string" && this.standardAttributes.includes(node.name);
   }
-  static getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet, lineNumberStart, lineNumberEnd) {
+  static getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet, lineNumberStart, lineNumberEnd, loose = false) {
     const nodeSet = /* @__PURE__ */ new Set();
     for (let i = lineNumberStart; i <= lineNumberEnd; i++) {
       const astNode = mapFileLineToNodeSet.get(i);
       if (!astNode) {
         continue;
       }
+      let added = false;
       for (const nodeItem of astNode) {
         const { startLine, endLine } = nodeItem._util;
         if (startLine >= lineNumberStart && endLine <= lineNumberEnd) {
-          nodeSet.add(nodeItem);
+          if (!["File", "Program"].includes(nodeItem.type)) {
+            nodeSet.add(nodeItem);
+          }
+          added = true;
+        }
+      }
+      if (!added && loose) {
+        const firstNode = [...astNode][0];
+        if (!["File", "Program"].includes(firstNode.type)) {
+          nodeSet.add(firstNode);
         }
       }
     }
     const collections = [...nodeSet].map((e) => e._util.nodeCollection).flat();
     return [...nodeSet].filter((e) => !collections.includes(e));
   }
-  static getTopScopeNodesByLineNumber(mapFileLineToNodeSet, lineNumber) {
-    const astNode = mapFileLineToNodeSet.get(lineNumber);
-    const lineOfNodes = [...new Set(astNode)].filter((e) => {
-      const { startLine, endLine } = e._util;
-      return startLine === lineNumber && endLine === lineNumber;
-    });
-    const collections = [...lineOfNodes].map((e) => e._util.nodeCollection).flat();
-    return lineOfNodes.filter((e) => !collections.includes(e));
-  }
-  static isSubNodeOfVariableDeclarator(node) {
-    const { ancestors } = node._util;
-    const typeList = ancestors.map((e) => e.type);
-    const index = typeList.lastIndexOf("VariableDeclarator");
-    if (index === -1) {
-      return false;
-    }
-    return ancestors.slice(index).every((ancestor) => ["Identifier", "ObjectPattern", "ArrayPattern"].includes(ancestor.type));
-  }
-  static createScopeContent(node) {
-    return [node._util.filePath, ":", node._util.startLine, "-", node._util.endLine, ":[", node.name || node.value, "]"].join("");
-  }
 };
 var AstUtil = _AstUtil;
 AstUtil.invalidNodeKey = [
   "comments",
   "tokens"
 ];
+AstUtil.EXPORT_DECLARATION_TYPES = ["FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration", "ClassDeclaration"];
 AstUtil.windowProperties = import_windowProperties.windowProperties;
 AstUtil.intrinsicElements = import_intrinsicElements.intrinsicElements;
 AstUtil.standardAttributes = import_intrinsicElements.standardAttributes;

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

@@ -135,7 +135,11 @@ var FileUtil = class {
     const existFlag = import_fs.default.existsSync(filePath);
     if (existFlag) {
       const fileContent = import_fs.default.readFileSync(filePath, "utf8");
-      return this.parseFile(filePath, fileContent)[1];
+      const [_, ast] = this.parseFile(filePath, fileContent);
+      if (ast) {
+        ast.__fileContent = fileContent;
+      }
+      return ast;
     }
     console.warn("文件不存在: " + filePath);
     return null;

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

@@ -0,0 +1 @@
+export default function createRandomStr(): string;

package/dist/cjs/util/createRandomStr.js

@@ -0,0 +1,38 @@
+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/createRandomStr.ts
+var createRandomStr_exports = {};
+__export(createRandomStr_exports, {
+  default: () => createRandomStr
+});
+module.exports = __toCommonJS(createRandomStr_exports);
+var import_dayjs = __toESM(require("dayjs"));
+function createRandomStr() {
+  return (0, import_dayjs.default)().format("YYYYMDD_HHmmss") + Math.random().toString(36).slice(-5);
+}

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

@@ -1 +1,6 @@
-export declare function createDependenceMap(usingFilePaths: string[], parsedAlias: Record<string, string>, absPathPrefix: string): any;
+export declare function createExportedNameToReferenceLocalSet(upstreamFileFullPaths: string[], parsedAlias: Record<string, string>, absPathPrefix: string, projectFilePaths: string[]): {
+    import2export: Record<string, string>;
+    export2export: Record<string, string>;
+    mapFilePathToExportAllSources: Record<string, string[]>;
+    indirectExportMembers: Record<string, string>;
+};

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

@@ -29,54 +29,99 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/util/report_util/createDependenceMap.ts
 var createDependenceMap_exports = {};
 __export(createDependenceMap_exports, {
-  createDependenceMap: () => createDependenceMap
+  createExportedNameToReferenceLocalSet: () => createExportedNameToReferenceLocalSet
 });
 module.exports = __toCommonJS(createDependenceMap_exports);
 var import_getAstKitByFilePath = __toESM(require("../ast_util/getAstKitByFilePath"));
 var import_filePathResolver = require("../ast_util/filePathResolver");
-function createDependenceMap(usingFilePaths, parsedAlias, absPathPrefix) {
-  const usingFileNoPrefix = usingFilePaths.map((item) => item.replace(absPathPrefix, ""));
-  const localAlias = Object.fromEntries(Object.entries(parsedAlias).map(([k, v]) => [k, v.startsWith(absPathPrefix) ? v.replace(absPathPrefix, "") : v]));
-  const mapFilePathToDependenceDetail = /* @__PURE__ */ new Map();
-  usingFilePaths.map((absFilePath, index) => {
+var import_path = require("path");
+function createExportedNameToReferenceLocalSet(upstreamFileFullPaths, parsedAlias, absPathPrefix, projectFilePaths) {
+  const cwd = process.cwd();
+  const systemAbsPathPrefix = absPathPrefix.startsWith(cwd) ? absPathPrefix : (0, import_path.join)(cwd, absPathPrefix);
+  const localAlias = Object.fromEntries(Object.entries(parsedAlias).map(([k, v]) => [k, v.startsWith(systemAbsPathPrefix) ? v.replace(systemAbsPathPrefix, "") : v]));
+  const import2export = {};
+  const export2export = {};
+  const mapFilePathToExportAllSources = {};
+  const validFiles = upstreamFileFullPaths.filter((e) => [".ts", ".tsx", ".js", ".jsx", ".vue"].some((ext) => e.endsWith(ext) && !e.endsWith(".d.ts")));
+  for (const absFilePath of validFiles) {
     const { mapUuidToNode } = (0, import_getAstKitByFilePath.default)(absFilePath, absPathPrefix, (travelNode) => ["ImportDeclaration", "ExportAllDeclaration", "ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(travelNode.type));
     const programNode = mapUuidToNode.get("Program");
     if (!programNode) {
-      return;
+      continue;
     }
     const { importedMember, exportedMember } = programNode._util;
-    const currentFilePath = absFilePath.replace(absPathPrefix, "");
-    const { importedMap, exportedMap } = mapFilePathToDependenceDetail.set(currentFilePath, mapFilePathToDependenceDetail.get(currentFilePath) || {
-      importedMap: /* @__PURE__ */ new Map(),
-      exportedMap: /* @__PURE__ */ new Map()
-    }).get(currentFilePath);
+    const relativeFilePath = absFilePath.replace(absPathPrefix, "");
     for (const { sourcePath, members } of importedMember) {
-      const { fullPath, isExternal } = (0, import_filePathResolver.resolveImportPath)(localAlias, sourcePath, currentFilePath);
-      const finalSourcePath = isExternal ? sourcePath : (fullPath == null ? void 0 : fullPath.find((p) => usingFileNoPrefix.includes(p))) || sourcePath;
-      const importedMemberDetail = importedMap.set(finalSourcePath, importedMap.get(finalSourcePath) || []).get(finalSourcePath);
+      const { fullPath, isExternal } = (0, import_filePathResolver.resolveImportPath)(localAlias, sourcePath, relativeFilePath);
+      const finalSourcePath = createRealSourcePath(sourcePath, isExternal, projectFilePaths, fullPath);
       for (const { importedName: imported, localName: local } of members) {
-        importedMemberDetail.push({ imported, local });
+        const importLocal = `${relativeFilePath}#${local}`;
+        const exportedName = `${finalSourcePath}#${imported}`;
+        import2export[importLocal] = exportedName;
+      }
+      if (members.length === 0) {
+        import2export[relativeFilePath] = finalSourcePath;
       }
     }
     for (const { sourcePath, members, ExportAllDeclaration } of exportedMember) {
-      const { fullPath, isExternal } = (0, import_filePathResolver.resolveImportPath)(localAlias, sourcePath, currentFilePath);
-      const finalSourcePath = isExternal ? sourcePath : (fullPath == null ? void 0 : fullPath.find((p) => usingFileNoPrefix.includes(p))) || sourcePath;
-      const exportedMemberDetail = exportedMap.set(finalSourcePath, exportedMap.get(finalSourcePath) || []).get(finalSourcePath);
+      const { fullPath, isExternal } = (0, import_filePathResolver.resolveImportPath)(localAlias, sourcePath, relativeFilePath);
+      const finalSourcePath = createRealSourcePath(sourcePath, isExternal, projectFilePaths, fullPath);
       for (const { exportedName: exported, localName: local } of members) {
-        exportedMemberDetail.push({ exported, local });
+        const exportedName = `${relativeFilePath}#${exported}`;
+        const importLocal = `${finalSourcePath}#${local}`;
+        export2export[exportedName] = importLocal;
       }
       if (ExportAllDeclaration) {
-        exportedMemberDetail.push({ exported: "*", local: "*" });
+        mapFilePathToExportAllSources[relativeFilePath] = [...mapFilePathToExportAllSources[relativeFilePath] || [], finalSourcePath];
       }
     }
-  });
-  const list = Array.from(mapFilePathToDependenceDetail.entries()).map(([k, v]) => {
-    const { importedMap, exportedMap } = v;
-    return [k, { importedMap: Object.fromEntries(importedMap.entries()), exportedMap: Object.fromEntries(exportedMap.entries()) }];
-  });
-  return Object.fromEntries(list);
+  }
+  ;
+  const indirectExportMembers = genIndirectExportMembers(mapFilePathToExportAllSources, export2export, import2export);
+  return {
+    import2export,
+    export2export,
+    mapFilePathToExportAllSources,
+    indirectExportMembers
+  };
+}
+function createRealSourcePath(sourcePath, isExternal, projectFilePaths, fullPath) {
+  return isExternal ? sourcePath : (fullPath == null ? void 0 : fullPath.find((p) => projectFilePaths.includes(p))) || sourcePath;
+}
+function genIndirectExportMembers(mapFilePathToExportAllSources, export2export, import2export) {
+  const export2exportEntries = Object.entries(export2export);
+  const potentialExportMap = {};
+  for (const exportAllSourcesKey in mapFilePathToExportAllSources) {
+    const exportAllSources = mapFilePathToExportAllSources[exportAllSourcesKey];
+    deepIterExportAllSources(exportAllSources, mapFilePathToExportAllSources, export2exportEntries, exportAllSourcesKey, potentialExportMap, [exportAllSourcesKey]);
+  }
+  const import2exportEntries = Object.entries(import2export);
+  return import2exportEntries.reduce((acc, [importMemberPath, exportMemberPath]) => {
+    const realExportPath = potentialExportMap[exportMemberPath];
+    if (realExportPath) {
+      acc[importMemberPath] = realExportPath;
+    }
+    return acc;
+  }, {});
+}
+function deepIterExportAllSources(exportAllSources, mapFilePathToExportAllSources, export2exportEntries, exportAllSourcesKey, potentialExportMap, travelledPaths) {
+  var _a;
+  for (const exportAllSource of exportAllSources) {
+    const existingExportMembers = export2exportEntries.filter(([exportPath]) => exportPath.startsWith(exportAllSource));
+    for (const [exportPath, exportRealSource] of existingExportMembers) {
+      const memberName = exportPath.split("#")[1];
+      if (memberName) {
+        potentialExportMap[`${exportAllSourcesKey}#${memberName}`] = exportRealSource;
+      }
+    }
+    travelledPaths.push(exportAllSource);
+    const tmpList = (_a = mapFilePathToExportAllSources[exportAllSource]) == null ? void 0 : _a.filter((e) => !travelledPaths.includes(e));
+    if (Array.isArray(tmpList) && tmpList.length > 0) {
+      deepIterExportAllSources(tmpList, mapFilePathToExportAllSources, export2exportEntries, exportAllSource, potentialExportMap, travelledPaths);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDependenceMap
+  createExportedNameToReferenceLocalSet
 });

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

@@ -0,0 +1,13 @@
+import { createDetectReport } from "../report_util";
+import { createExportedNameToReferenceLocalSet } from "./createDependenceMap";
+export default function filterEffectedCode(reports: ReturnType<typeof createDetectReport>, depMemberInfo: ReturnType<typeof createExportedNameToReferenceLocalSet>): ({
+    filePath: string;
+    type: "add";
+    effectedExports: string[];
+    usages: string[];
+} | {
+    filePath: string;
+    type: "modify" | "delete";
+    effectedExports: string[];
+    usages: string[];
+})[];

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

@@ -0,0 +1,72 @@
+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/filterEffectedCode.ts
+var filterEffectedCode_exports = {};
+__export(filterEffectedCode_exports, {
+  default: () => filterEffectedCode
+});
+module.exports = __toCommonJS(filterEffectedCode_exports);
+function filterEffectedCode(reports, depMemberInfo) {
+  const { import2export, export2export } = depMemberInfo;
+  const import2exportEntries = Object.entries(import2export);
+  const export2exportEntries = Object.entries(export2export);
+  return reports.map((report) => {
+    const { filePath, type, topEffectedExportsRemoved, topEffectedExportsAdded } = report;
+    if (type === "add") {
+      const directUsages2 = getDirectUsages(filePath, import2exportEntries);
+      const effectedExports1 = getEffectedExportsOfAddedFile(filePath, import2exportEntries);
+      const effectedExports2 = getExportMembersOfFile(filePath, export2exportEntries).map((exportedName) => `${filePath}#${exportedName}`);
+      const effectedExports3 = [.../* @__PURE__ */ new Set([...effectedExports1, ...effectedExports2])];
+      const inDirectUsages2 = getIndirectUsages(filePath, import2exportEntries, export2exportEntries, effectedExports3);
+      return {
+        filePath,
+        type,
+        effectedExports: [...new Set(effectedExports3.map((e) => e.split("#")[1]))],
+        usages: [.../* @__PURE__ */ new Set([...directUsages2, ...inDirectUsages2])]
+      };
+    }
+    const effectedExports = [.../* @__PURE__ */ new Set([...topEffectedExportsRemoved, ...topEffectedExportsAdded])];
+    const directUsages = getDirectUsages(filePath, import2exportEntries, effectedExports);
+    const inDirectUsages = getIndirectUsages(filePath, import2exportEntries, export2exportEntries, effectedExports.map((exportedName) => `${filePath}#${exportedName}`));
+    return {
+      filePath,
+      type,
+      effectedExports,
+      usages: [.../* @__PURE__ */ new Set([...directUsages, ...inDirectUsages])]
+    };
+  });
+}
+function getEffectedExportsOfAddedFile(filePath, import2exportEntries) {
+  const exportedMembersUsing = import2exportEntries.filter((item) => item[1].startsWith(`${filePath}#`)).map((item) => item[1]);
+  return exportedMembersUsing;
+}
+function getDirectUsages(filePath, import2exportEntries, givenExports) {
+  if (givenExports) {
+    const currentExportPaths = givenExports.map((exportedName) => `${filePath}#${exportedName}`);
+    return import2exportEntries.filter((item) => currentExportPaths.includes(item[1])).map((item) => item[0]);
+  }
+  return import2exportEntries.filter((item) => item[1].startsWith(`${filePath}#`)).map((item) => item[0]);
+}
+function getIndirectUsages(filePath, import2exportEntries, export2exportEntries, givenExports) {
+  const indirectlyExportedMembers = export2exportEntries.filter((item) => givenExports.includes(item[1])).map((item) => item[0]);
+  return import2exportEntries.filter((item) => indirectlyExportedMembers.includes(item[1])).map((item) => item[0]);
+}
+function getExportMembersOfFile(filePath, export2exportEntries) {
+  return export2exportEntries.filter((item) => item[0].startsWith(`${filePath}#`)).map((item) => item[0].split("#")[1]);
+}

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

@@ -0,0 +1 @@
+export default function filterEffectedExportMember(filePath: string, absPathPrefix: string, startLine: number, endLine: number): string[];

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

@@ -0,0 +1,43 @@
+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/filterEffectedExportMember.ts
+var filterEffectedExportMember_exports = {};
+__export(filterEffectedExportMember_exports, {
+  default: () => filterEffectedExportMember
+});
+module.exports = __toCommonJS(filterEffectedExportMember_exports);
+var import_getAstKitByFilePath = __toESM(require("../ast_util/getAstKitByFilePath"));
+var import_AstUtil = __toESM(require("../ast_util/AstUtil"));
+function filterEffectedExportMember(filePath, absPathPrefix, startLine, endLine) {
+  const astKit = (0, import_getAstKitByFilePath.default)(filePath, absPathPrefix);
+  const { mapFileLineToNodeSet } = astKit;
+  const topScopeNodes = import_AstUtil.default.getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet, startLine, endLine);
+  const exportMembers = topScopeNodes.map((node) => import_AstUtil.default.findExportedMembersNameFromAncestors(node)).flat();
+  return [...new Set(exportMembers)];
+}

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

@@ -4,14 +4,19 @@ export declare function generateGitDiffReport(arg: {
     madgeResult: IMadgeInstance;
     parsedAlias: Record<string, any>;
     targetDirPath: string;
-    generateFile?: ('dependence_map.json' | 'partial_dependence_map.json' | 'report.json' | typeof reportFileName)[];
+    generateFile?: ('dependence_map.json' | 'partial_dependence_map.json' | 'report.json' | 'gitDiffDetail.json' | typeof reportFileName)[];
 }): Promise<{
-    mdContent: string;
-    dependenceJson: Record<string, any>;
-    upstreamDependenceJson: Record<string, any>;
+    dependenceJson: {
+        import2export: Record<string, string>;
+        export2export: Record<string, string>;
+        mapFilePathToExportAllSources: Record<string, string[]>;
+        indirectExportMembers: Record<string, string>;
+    };
     partialDependenceJson: Record<string, any>;
     reports: {
         dangerIdentifiers: string[];
+        topEffectedExportsAdded: string[];
+        topEffectedExportsRemoved: string[];
         blockReports: {
             diff_txt: string[];
             infos: {