js-code-detector 0.0.23 → 0.0.25

package/dist/cjs/index.d.ts

@@ -1,12 +1,8 @@
 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<{
     gitUrl: string;
     branchName: string;
 }>;
-export declare function generateReport(content: string): void;
 export declare function sameCodeDetect(dirOfCwd?: string): Promise<void>;
 export declare function gitDiffDetect(): Promise<void>;
 export declare function getEslintCheckResult(today: string): Promise<void>;

package/dist/cjs/index.js

@@ -29,88 +29,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  generateReport: () => generateReport,
   getEslintCheckResult: () => getEslintCheckResult,
   getGitRepositoryAndBranch: () => getGitRepositoryAndBranch,
   gitDiffDetect: () => gitDiffDetect,
   gitDiffFileName: () => gitDiffFileName,
-  gitDiffJsonName: () => gitDiffJsonName,
-  sameCodeDetect: () => sameCodeDetect,
-  umiPluginCallback: () => umiPluginCallback,
-  writeGitDiffTxt: () => writeGitDiffTxt
+  sameCodeDetect: () => sameCodeDetect
 });
 module.exports = __toCommonJS(src_exports);
 var import_fs = require("fs");
 var import_path = require("path");
-var import_format_git_diff_content = require("./util/format_git_diff_content");
-var import_madge_util = __toESM(require("./util/madge_util"));
 var import_fs2 = require("fs");
-var import_report_util = require("./util/report_util");
 var import_utils = require("@umijs/utils");
 var import_dayjs = __toESM(require("dayjs"));
-var import_createMdByJson = require("./util/report_util/createMdByJson");
 var import_readDirFiles = require("./util/shared/readDirFiles");
 var import_Core = __toESM(require("./util/ast_util/Core"));
 var import_constants = require("./util/constants");
 var import_await_to_js = __toESM(require("await-to-js"));
 var import_generateGitDiffReport = require("./util/report_util/generateGitDiffReport");
-var jsonName = "git_diff_report.md";
 var gitDiffFileName = "git_diff.txt";
-var gitDiffJsonName = "git_diff.json";
 var eslintJsonName = "eslint-report.json";
 var eslintFinalJsonName = "eslint-final-report.json";
-async function umiPluginCallback(api) {
-  const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(api.cwd, gitDiffFileName), "utf-8");
-  const gitDiffDetail = (0, import_format_git_diff_content.formatGitDiffContent)(diff_txt);
-  (0, import_fs2.writeFileSync)((0, import_path.join)(api.cwd, gitDiffJsonName), JSON.stringify(gitDiffDetail, null, 2), { encoding: "utf-8", flag: "w" });
-  const madgeUtil = await (0, import_madge_util.default)(api);
-  if (!madgeUtil) {
-    return;
-  }
-  const { madgeInstance: { tree }, usingFiles } = madgeUtil;
-  const cwd = api.cwd;
-  const absPathPrefix = cwd + "/";
-  const usingFileNoPrefix = usingFiles.map((item) => item.filePath.replace(absPathPrefix, ""));
-  const groupGitDiffLines = gitDiffDetail.filter((item) => usingFileNoPrefix.includes(item.filePath));
-  const reports = (0, import_report_util.createDetectReport)({ groupGitDiffLines, tree, absPathPrefix });
-  (0, import_fs2.writeFileSync)((0, import_path.join)(api.cwd, "reports.json"), JSON.stringify(reports, null, 2), { encoding: "utf-8", flag: "w" });
-  const mdContent = (0, import_createMdByJson.createMdByJson)(reports);
-  (0, import_fs2.writeFileSync)((0, import_path.join)(api.cwd, jsonName), mdContent, { encoding: "utf-8", flag: "w" });
-}
-var shellFileContent = `#!/bin/sh
-time=$(date "+%Y%-m%d")
-mkdir -p $time
-cd $time
-
-git clone $1 target
-cd target
-yarn install
-
-git fetch origin $2:$2
-git checkout $2
-
-git diff master..$2 --unified=0 --output=git_diff.txt
-cd ..
-git clone $1 source
-`;
-var pluginFileContent = `import * as cb from "js-code-detector"
-
-export default async (api: any) => {
-  const buildCallback = () => cb.umiPluginCallback(api);
-  api.onBuildComplete(buildCallback);
-}`;
-async function writeGitDiffTxt(gitUrl, branchName) {
-  const today = (0, import_dayjs.default)().format("YYYYMDD");
-  (0, import_fs2.writeFileSync)((0, import_path.join)(process.cwd(), "detect.sh"), shellFileContent, { encoding: "utf-8", flag: "w" });
-  await import_utils.execa.execa("chmod +x detect.sh", { shell: "/bin/bash" });
-  const res0 = await import_utils.execa.execa("sh detect.sh", [gitUrl, branchName], { shell: "/bin/bash" });
-  import_utils.chalk.green(["临时文件夹建立，源代码clone完成"]);
-  (0, import_fs2.writeFileSync)((0, import_path.join)(process.cwd(), today, "target", "plugin.ts"), pluginFileContent, { encoding: "utf-8", flag: "w" });
-  import_utils.chalk.green(["临时文件写入完成"]);
-  await import_utils.execa.execa(`cd ${today}/target && npm run build`, { shell: "/bin/bash" });
-  import_utils.chalk.green(["临时入口文件生成"]);
-  return (0, import_fs.readFileSync)((0, import_path.join)(process.cwd(), today, "target", jsonName), "utf-8");
-}
 async function getGitRepositoryAndBranch() {
   const res = await import_utils.execa.execa("git remote get-url origin", { shell: "/bin/bash" });
   import_utils.chalk.green(["仓库地址：", res.stdout]);
@@ -121,9 +59,6 @@ async function getGitRepositoryAndBranch() {
     branchName: branch.stdout
   };
 }
-function generateReport(content) {
-  (0, import_fs2.writeFileSync)((0, import_path.join)(process.cwd(), `${(0, import_dayjs.default)().format("YYYYMDD_HHmm")}_${jsonName}`), content, { encoding: "utf-8", flag: "w" });
-}
 async function sameCodeDetect(dirOfCwd) {
   const filesAndContent = await (0, import_readDirFiles.readSrcFiles)(dirOfCwd);
   const { nodeContentGroupList, depthList } = import_Core.default.investigate(filesAndContent);
@@ -137,6 +72,10 @@ async function gitDiffDetect() {
   const today = (0, import_dayjs.default)().format("YYYYMDD");
   const { gitUrl, branchName } = await getGitRepositoryAndBranch();
   import_utils.logger.ready("准备生成临时工作目录...");
+  const [err] = await (0, import_await_to_js.default)(import_utils.execa.execa(`rm -rf ${today}`, { shell: "/bin/bash" }));
+  if (err) {
+    import_utils.logger.error("临时目录删除失败");
+  }
   await import_utils.execa.execa(`mkdir -p ${today}`, { shell: "/bin/bash" });
   import_utils.logger.info("临时目录建立完成");
   import_utils.logger.ready(`准备clone源代码到临时目录下的 ${import_constants.TARGET} 文件夹`);
@@ -155,13 +94,8 @@ async function gitDiffDetect() {
   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") });
+  await (0, import_generateGitDiffReport.generateGitDiffReport)({ targetDirPath: (0, import_path.join)(process.cwd(), today, import_constants.TARGET) });
   import_utils.logger.info("报告完成");
-  import_utils.logger.ready("准备移动报告");
-  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);
   (0, import_utils.rimraf)((0, import_path.join)(process.cwd(), today), () => {
     import_utils.logger.info("临时目录已删除");
   });
@@ -190,13 +124,9 @@ async function getEslintCheckResult(today) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  generateReport,
   getEslintCheckResult,
   getGitRepositoryAndBranch,
   gitDiffDetect,
   gitDiffFileName,
-  gitDiffJsonName,
-  sameCodeDetect,
-  umiPluginCallback,
-  writeGitDiffTxt
+  sameCodeDetect
 });

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

@@ -33,6 +33,21 @@ export interface AstNode {
         provide: Set<AstNode>;
         effectIds: Set<AstNode>;
         occupation: Set<AstNode>;
+        importedMember: {
+            sourcePath: string;
+            members: {
+                importedName: string;
+                localName: string;
+            }[];
+        }[];
+        exportedMember: {
+            sourcePath: string;
+            members: {
+                exportedName: string;
+                localName: string;
+            }[];
+            ExportAllDeclaration: boolean;
+        }[];
     };
 }
 export default class AstUtil {
@@ -42,8 +57,9 @@ export default class AstUtil {
     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;
+    static deepFirstTravel(node: AstNode, filePath: string, mapUuidToNode: Map<string, AstNode>, mapFileLineToNodeSet: Map<number, Set<AstNode>>, mapPathToNodeSet: Map<string, Set<AstNode>>, stopTravelCallback?: (node: AstNode) => boolean | void): AstNode | undefined;
     private static _deepFirstTravel;
+    private static updateImportedAndExportedMember;
     private static collectInjectAndProvide;
     private static handleDeclaration;
     private static collectHoldingIds;

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

@@ -59,20 +59,14 @@ var _AstUtil = class {
     if (type === "JSXOpeningElement") {
       const { name } = ancestor.name;
       if (name && typeof name === "object") {
-        const realName = name.name;
-        if (!this.intrinsicElements.includes(realName)) {
-          return name;
-        }
+        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;
-        }
+        return name;
       }
     }
     if (type === "VariableDeclarator") {
@@ -86,16 +80,16 @@ var _AstUtil = class {
     }
     return null;
   }
-  static deepFirstTravel(node, filePath, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet) {
+  static deepFirstTravel(node, filePath, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback) {
     const visitedNodeSet = /* @__PURE__ */ new Set();
     if (!node) {
       return;
     }
-    return this._deepFirstTravel(node, visitedNodeSet, { filePath, depth: 0, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
+    return this._deepFirstTravel(node, visitedNodeSet, { filePath, depth: 0, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback });
   }
   static _deepFirstTravel(node, visitedNodeSet, extra) {
     visitedNodeSet.add(node);
-    const { filePath, depth, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet } = extra;
+    const { filePath, depth, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback } = extra;
     const _util = {
       startLine: NaN,
       endLine: NaN,
@@ -118,10 +112,16 @@ var _AstUtil = class {
       inject: /* @__PURE__ */ new Set(),
       provide: /* @__PURE__ */ new Set(),
       effectIds: /* @__PURE__ */ new Set(),
-      occupation: /* @__PURE__ */ new Set()
+      occupation: /* @__PURE__ */ new Set(),
+      importedMember: [],
+      exportedMember: []
     };
     node._util = _util;
     const { nodeCollection, children } = _util;
+    const stopTravel = stopTravelCallback == null ? void 0 : stopTravelCallback(node);
+    if (stopTravel) {
+      return node;
+    }
     Object.keys(node).forEach((nodeKey) => {
       if (this.invalidNodeKey.includes(nodeKey) || nodeKey.startsWith("TS") || nodeKey.endsWith("Annotation")) {
         return;
@@ -131,13 +131,13 @@ var _AstUtil = class {
         return;
       }
       if (this.isValidNodeCollect(nodeValue)) {
-        const childNode = this._deepFirstTravel(nodeValue, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
+        const childNode = this._deepFirstTravel(nodeValue, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback });
         nodeCollection.push(childNode, ...childNode._util.nodeCollection);
         children.push(childNode);
         childNode._util.parentProperty = nodeKey;
       } else if (this.isValidArrayNodeCollect(nodeValue)) {
         const validNodeArray = nodeValue.filter((nodeItem) => this.isValidNodeCollect(nodeItem)).map((v) => {
-          return this._deepFirstTravel(v, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
+          return this._deepFirstTravel(v, visitedNodeSet, { filePath, depth: depth + 1, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback });
         });
         nodeCollection.push(...validNodeArray.map((n) => [n, ...n._util.nodeCollection]).flat());
         children.push(...validNodeArray);
@@ -147,17 +147,115 @@ var _AstUtil = class {
         });
       }
     });
-    children.forEach((child) => child._util.parent = node);
-    nodeCollection.forEach((nodeItem) => nodeItem._util.ancestors.unshift(node));
-    this.collectHoldingIds(node);
-    this.collectDependenceIds(node);
-    this.collectInjectAndProvide(node);
+    try {
+      children.forEach((child) => child._util.parent = node);
+      nodeCollection.forEach((nodeItem) => nodeItem._util.ancestors.unshift(node));
+    } catch (e) {
+      console.error("parent ancestors update", e.message);
+    }
+    try {
+      const skip = nodeCollection.some((nodeItem) => stopTravelCallback == null ? void 0 : stopTravelCallback(nodeItem));
+      if (!skip) {
+        this.collectHoldingIds(node);
+      }
+    } catch (e) {
+      console.error("collectHoldingIds", e.message);
+    }
+    try {
+      this.collectDependenceIds(node);
+    } catch (e) {
+      console.error("collectDependenceIds", e.message);
+    }
+    try {
+      this.collectInjectAndProvide(node);
+    } catch (e) {
+      console.error("collectInjectAndProvide", e.message);
+    }
     if (node.type === "Program") {
-      nodeCollection.forEach((child) => this.collectEffectId(child));
+      try {
+        nodeCollection.forEach((child) => this.collectEffectId(child));
+      } catch (e) {
+        console.error("collectEffectId", e.message);
+      }
+      try {
+        node.body.forEach((child) => this.updateImportedAndExportedMember(child, node));
+      } catch (e) {
+        console.error("updateImportedAndExportedMember", e.message);
+      }
+    }
+    try {
+      this.updateLoc(node, { mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
+    } catch (e) {
+      console.error("updateLoc", e.message);
     }
-    this.updateLoc(node, { mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
     return node;
   }
+  static updateImportedAndExportedMember(node, programNode) {
+    const { type, source, declaration, specifiers, _util } = node;
+    const { filePath } = _util;
+    const sourceValue = (source == null ? void 0 : source.value) || filePath;
+    const { importedMember, exportedMember } = programNode._util;
+    if (type === "ImportDeclaration") {
+      specifiers.forEach((specifier) => {
+        const { local, imported } = specifier;
+        let target = importedMember.find((v) => v.sourcePath === sourceValue);
+        if (!target) {
+          target = { sourcePath: sourceValue, members: [] };
+          importedMember.push(target);
+        }
+        target.members.push({
+          localName: local.name,
+          importedName: (imported == null ? void 0 : imported.name) || "default"
+        });
+      });
+    }
+    if (type === "ExportAllDeclaration") {
+      const target = exportedMember.find((v) => v.sourcePath === sourceValue);
+      if (!target) {
+        exportedMember.push({ sourcePath: sourceValue, members: [], ExportAllDeclaration: true });
+      }
+    }
+    if (type === "ExportNamedDeclaration") {
+      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 (Array.isArray(declaration == null ? void 0 : declaration.declarations)) {
+        declaration == null ? void 0 : declaration.declarations.forEach((dec) => {
+          var _a;
+          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;
+          target.members.push({
+            localName: idName,
+            exportedName: idName
+          });
+        });
+      }
+    }
+    if (type === "ExportDefaultDeclaration") {
+      let target = exportedMember.find((v) => v.sourcePath === filePath);
+      if (!target) {
+        target = { sourcePath: filePath, members: [], ExportAllDeclaration: false };
+        exportedMember.push(target);
+      }
+      target.members.push({
+        localName: "default",
+        exportedName: "default"
+      });
+    }
+  }
   static collectInjectAndProvide(ast) {
     const { type, _util: { inject, provide, holdingIds } } = ast;
     if (type !== "Program" || !this.isBodyArray(ast)) {
@@ -301,6 +399,9 @@ var _AstUtil = class {
       this.collectExpressionIdentifiersShallow(child, (id) => dependenceIds.add(id));
     });
     for (const dependenceId of dependenceIds) {
+      if (!dependenceId._util) {
+        continue;
+      }
       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];

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

@@ -0,0 +1,15 @@
+/**
+ * 解析导入路径为全路径，支持相对路径
+ * @param {Object} alias - 路径别名配置对象
+ * @param {string} importPath - 导入路径
+ * @param {string} currentFilePath - 当前文件的绝对路径（已处理）
+ * @param {string[]} [extensions=['.js', '.ts', '.jsx', '.tsx']] - 可能的文件扩展名
+ * @returns {Object} 包含全路径和是否为外部路径的对象
+ */
+export declare function resolveImportPath(alias: Record<string, string>, importPath: string, currentFilePath: string, extensions?: string[]): {
+    fullPath: string[];
+    isExternal: boolean;
+} | {
+    fullPath: null;
+    isExternal: boolean;
+};

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

@@ -0,0 +1,131 @@
+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/ast_util/filePathResolver.ts
+var filePathResolver_exports = {};
+__export(filePathResolver_exports, {
+  resolveImportPath: () => resolveImportPath
+});
+module.exports = __toCommonJS(filePathResolver_exports);
+function joinPath(...paths) {
+  const isAbsolute = paths.some(
+    (path) => path.startsWith("/") || path.startsWith("\\") || path.length >= 2 && path[1] === ":"
+    // 处理Windows路径如C:
+  );
+  let joined = paths.filter(Boolean).join("/").replace(/[\\/]+/g, "/");
+  if (isAbsolute && joined.length >= 2 && joined[1] === ":") {
+    joined = joined[0] + ":" + joined.slice(2);
+  }
+  const segments = joined.split("/");
+  const result = [];
+  for (const segment of segments) {
+    if (segment === ".")
+      continue;
+    if (segment === "..") {
+      if (result.length && result[result.length - 1] !== "..") {
+        result.pop();
+      } else if (!isAbsolute) {
+        result.push("..");
+      }
+    } else {
+      result.push(segment);
+    }
+  }
+  let finalPath = result.join("/");
+  if (isAbsolute && !finalPath.startsWith("/") && !(finalPath.length >= 2 && finalPath[1] === ":")) {
+    finalPath = "/" + finalPath;
+  }
+  return finalPath;
+}
+function getDirName(filePath) {
+  const normalized = filePath.replace(/[\\/]+/g, "/");
+  const lastSlashIndex = normalized.lastIndexOf("/");
+  if (lastSlashIndex === -1)
+    return ".";
+  if (lastSlashIndex === 0) {
+    return normalized[0] === "/" ? "/" : ".";
+  }
+  return normalized.slice(0, lastSlashIndex);
+}
+function resolveImportPath(alias, importPath, currentFilePath, extensions = [".js", ".ts", ".jsx", ".tsx"]) {
+  if (importPath.startsWith(".")) {
+    const currentDir = getDirName(currentFilePath);
+    const absolutePath = joinPath(currentDir, importPath);
+    const possiblePaths2 = [absolutePath];
+    extensions.forEach((ext) => {
+      possiblePaths2.push(`${absolutePath}${ext}`);
+    });
+    extensions.forEach((ext) => {
+      possiblePaths2.push(joinPath(absolutePath, `index${ext}`));
+    });
+    return {
+      fullPath: possiblePaths2,
+      isExternal: false
+    };
+  }
+  const isExternal = !Object.keys(alias).some((aliasKey) => {
+    if (aliasKey.endsWith("$")) {
+      return importPath === aliasKey.slice(0, -1);
+    }
+    return importPath === aliasKey || importPath.startsWith(`${aliasKey}/`);
+  });
+  if (isExternal) {
+    return {
+      fullPath: null,
+      isExternal: true
+    };
+  }
+  let matchedAlias = null;
+  let matchedKey = "";
+  Object.entries(alias).forEach(([key, value]) => {
+    if (key.endsWith("$") && importPath === key.slice(0, -1)) {
+      matchedAlias = value;
+      matchedKey = key.slice(0, -1);
+    }
+  });
+  if (!matchedAlias) {
+    Object.entries(alias).forEach(([key, value]) => {
+      if (!key.endsWith("$") && (importPath === key || importPath.startsWith(`${key}/`))) {
+        matchedAlias = value;
+        matchedKey = key;
+      }
+    });
+  }
+  let basePath;
+  if (importPath === matchedKey) {
+    basePath = matchedAlias;
+  } else {
+    const relativePath = importPath.slice(matchedKey.length + 1);
+    basePath = joinPath(matchedAlias, relativePath);
+  }
+  const possiblePaths = [basePath];
+  extensions.forEach((ext) => {
+    possiblePaths.push(`${basePath}${ext}`);
+  });
+  extensions.forEach((ext) => {
+    possiblePaths.push(joinPath(basePath, `index${ext}`));
+  });
+  return {
+    fullPath: possiblePaths,
+    isExternal: false
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveImportPath
+});

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

@@ -1,5 +1,5 @@
-import { AstNode } from "./AstUtil";
-export default function getAstKitByFilePath(filePath: string, absPathPrefix: string): {
+import AstUtil, { AstNode } from "./AstUtil";
+export default function getAstKitByFilePath(filePath: string, absPathPrefix: string, stopTravelCallback?: Parameters<typeof AstUtil.deepFirstTravel>[5]): {
     mapFileLineToNodeSet: Map<number, Set<AstNode>>;
     mapUuidToNode: Map<string, AstNode>;
     mapPathToNodeSet: Map<string, Set<AstNode>>;

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

@@ -35,19 +35,22 @@ module.exports = __toCommonJS(getAstKitByFilePath_exports);
 var import_AstUtil = __toESM(require("./AstUtil"));
 var import_FileUtil = __toESM(require("./FileUtil"));
 var mapFilePathToTools = /* @__PURE__ */ new Map();
-var createMapFileLineToNodeSet = (file, absPathPrefix) => {
+var createMapFileLineToNodeSet = (file, absPathPrefix, stopTravelCallback) => {
   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);
+  import_AstUtil.default.deepFirstTravel(ast, filePathRelative, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback);
   return { mapFileLineToNodeSet, mapUuidToNode, mapPathToNodeSet };
 };
-function getAstKitByFilePath(filePath, absPathPrefix) {
+function getAstKitByFilePath(filePath, absPathPrefix, stopTravelCallback) {
+  if (stopTravelCallback) {
+    return createMapFileLineToNodeSet(filePath, absPathPrefix, stopTravelCallback);
+  }
   let tools = mapFilePathToTools.get(filePath);
   if (!tools) {
-    mapFilePathToTools.set(filePath, tools = createMapFileLineToNodeSet(filePath, absPathPrefix));
+    mapFilePathToTools.set(filePath, tools = createMapFileLineToNodeSet(filePath, absPathPrefix, stopTravelCallback));
   }
   return tools;
 }

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

@@ -0,0 +1,11 @@
+/**
+ * 解析GitLab分支对比链接的工具函数（含URL解码）
+ * @param compareUrl - GitLab分支对比链接，格式需为 http://gitlab.xxx.com/项目路径/-/compare/分支1...分支2
+ * @returns 包含项目Git地址和两个解码后分支名的对象
+ * @throws 当输入链接格式不符合要求时抛出错误
+ */
+declare function parseGitLabCompareUrl(compareUrl: string): {
+    gitRepoUrl: string;
+    baseBranch: string;
+    targetBranch: string;
+};

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

@@ -0,0 +1 @@
+export declare function createDependenceMap(usingFilePaths: string[], parsedAlias: Record<string, string>, absPathPrefix: string): any;

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

@@ -0,0 +1,82 @@
+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/createDependenceMap.ts
+var createDependenceMap_exports = {};
+__export(createDependenceMap_exports, {
+  createDependenceMap: () => createDependenceMap
+});
+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) => {
+    const { mapUuidToNode } = (0, import_getAstKitByFilePath.default)(absFilePath, absPathPrefix, (travelNode) => ["ImportDeclaration", "ExportAllDeclaration", "ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(travelNode.type));
+    const programNode = mapUuidToNode.get("Program");
+    if (!programNode) {
+      return;
+    }
+    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);
+    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);
+      for (const { importedName: imported, localName: local } of members) {
+        importedMemberDetail.push({ imported, local });
+      }
+    }
+    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);
+      for (const { exportedName: exported, localName: local } of members) {
+        exportedMemberDetail.push({ exported, local });
+      }
+      if (ExportAllDeclaration) {
+        exportedMemberDetail.push({ exported: "*", local: "*" });
+      }
+    }
+  });
+  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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDependenceMap
+});

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

@@ -40,7 +40,7 @@ function reportItemToMd(report) {
     `## ${filePath}`,
     `### 类型: ${mapReportType[type]}`,
     filesDependsOnMe.length > 0 ? `### 所影响的文件
-${filesDependsOnMe.slice(0, 1).map((files) => files.map((file) => `- ${file}`)).flat().join("\n")}` : "",
+${filesDependsOnMe.map((file) => `- ${file}`).join("\n")}` : "",
     undefinedIdentifiers.length > 0 ? `### 未定义的变量
 > ${undefinedIdentifiers.map((e) => `**${e}**`).join(", ")}` : "",
     // todo 拿到具体的节点 对应的 文本

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

@@ -1,6 +1,8 @@
+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)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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/generateGitDiffReport.ts
@@ -29,7 +39,9 @@ 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 import_getMadgeInstance = require("./getMadgeInstance");
+var import_createDependenceMap = require("./createDependenceMap");
+var import_dayjs = __toESM(require("dayjs"));
 var userAliasGetter = (cwd, appData) => {
   var _a;
   return ((_a = appData.config) == null ? void 0 : _a.alias) || {
@@ -45,7 +57,6 @@ async function generateGitDiffReport(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 };
@@ -83,61 +94,27 @@ async function generateGitDiffReport(arg) {
     {}
   );
   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 res = await (0, import_getMadgeInstance.getMadgeInstance)(devTmpDir, targetDirPath, exclude, filteredAlias, tsconfig);
   const tree = res.tree;
   const absPathPrefix = targetDirPath + "/";
-  const usingFileNoPrefix = usingFiles.map((item) => item.filePath.replace(absPathPrefix, ""));
+  const usingFileNoPrefix = Object.keys(tree);
+  const usingFilePaths = usingFileNoPrefix.map((item) => (0, import_utils.winPath)((0, import_path.join)(absPathPrefix, item)));
   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 changedFilePaths = groupGitDiffLines.map((item) => item.filePath);
+  const time = (0, import_dayjs.default)().format("YYYYMDD_HHmm");
+  try {
+    const dependenceJson = (0, import_createDependenceMap.createDependenceMap)(usingFilePaths, parsedAlias, absPathPrefix);
+    (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_dependence_map.json`), JSON.stringify(dependenceJson, null, 2), { encoding: "utf-8", flag: "w" });
+    const partialDependenceJson = Object.fromEntries(changedFilePaths.map((p) => [p, dependenceJson[p]]));
+    (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_partial_dependence_map.json`), JSON.stringify(partialDependenceJson, null, 2), { encoding: "utf-8", flag: "w" });
+  } catch (e) {
+    console.warn("dependenceJson 生成失败", e);
+  }
+  (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_reports_helper.json`), JSON.stringify({ usingFilePaths, groupGitDiffLines, absPathPrefix, tree, filteredAlias, parsedAlias, tsconfig }, 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" });
+  (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_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" });
+  (0, import_fs.writeFileSync)((0, import_path.join)(targetDirPath, "..", "..", `${time}_${reportFileName}`), mdContent, { encoding: "utf-8", flag: "w" });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -1 +1,6 @@
-export declare function getMadgeInstance(devTmpDir: string, targetDirPath: string, exclude: RegExp[], filteredAlias: Record<string, string[]>, tsconfig?: any): Promise<void>;
+import { MadgeInstance } from "madge";
+interface IMadgeInstance extends MadgeInstance {
+    tree: Record<string, string[]>;
+}
+export declare function getMadgeInstance(devTmpDir: string, targetDirPath: string, exclude: RegExp[], filteredAlias: Record<string, string[]>, tsconfig?: any): Promise<IMadgeInstance>;
+export {};

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

@@ -36,7 +36,7 @@ async function getMadgeInstance(devTmpDir, targetDirPath, exclude, filteredAlias
   const madgeConfig = {
     tsConfig: {
       compilerOptions: {
-        baseUrl: tsconfig.baseUrl,
+        baseUrl: targetDirPath,
         paths: {
           ...filteredAlias,
           ...tsconfig.paths,
@@ -59,6 +59,7 @@ async function getMadgeInstance(devTmpDir, targetDirPath, exclude, filteredAlias
     baseDir: targetDirPath
   };
   const res = await madge((0, import_path.join)(devTmpDir, "umi.ts"), madgeConfig);
+  return res;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -4,7 +4,7 @@ import { BlockReportItem } from "./report_util/diffBlockDetect";
 export type DetectReport = {
     filePath: string;
     type: "modify" | "add" | "delete";
-    filesDependsOnMe: string[][];
+    filesDependsOnMe: string[];
     undefinedIdentifiers: string[];
     dangerIdentifiers: string[];
     _fileAddedNodesPaths: {
@@ -35,8 +35,8 @@ export declare function createDetectReport(arg: Arg): {
             effectsDownstream: string[];
         }[];
     }[];
-    type: "modify" | "add" | "delete";
-    filesDependsOnMe: string[][];
+    type: "add" | "delete" | "modify";
+    filesDependsOnMe: string[];
     undefinedIdentifiers: string[];
     filePath: string;
 }[];

package/dist/cjs/util/report_util.js

@@ -34,7 +34,6 @@ __export(report_util_exports, {
 module.exports = __toCommonJS(report_util_exports);
 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) {
@@ -42,7 +41,7 @@ function createDetectReport(arg) {
   const reports = [];
   groupGitDiffLines.forEach((item, index) => {
     const { filePath, type } = item;
-    const filesDependsOnMe = (0, import_getFileDepends.default)(filePath, tree);
+    const filesDependsOnMe = tree[filePath] || [];
     let reportItem = reports.find((e) => e.filePath === filePath);
     if (!reportItem) {
       reportItem = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-code-detector",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "description": "",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",
@@ -21,7 +21,6 @@
     "bin"
   ],
   "bin": {
-    "detect": "bin/detect.js",
     "gitDiffDetect": "bin/gitDiffDetect.js",
     "sameCodeDetect": "bin/sameCodeDetect.js"
   },

package/bin/detect.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-const { writeGitDiffTxt, getGitRepositoryAndBranch, generateReport } = require('../dist/cjs/index')
-async function main() {
-  const { gitUrl, branchName } = await getGitRepositoryAndBranch();
-  writeGitDiffTxt(gitUrl, branchName).then(reportContent => generateReport(reportContent));
-}
-main();