js-code-detector 0.0.48 → 0.0.51

package/dist/cjs/index.d.ts

@@ -1,9 +1,3 @@
-import { cloneGitRepoAndGetDiff } from "./util/shared/gitDiffTool";
-export declare const gitDiffFileName = "git_diff.txt";
-export declare function getGitRepositoryAndBranch(): Promise<{
-    gitUrl: string;
-    branchName: string;
-}>;
 export declare function sameCodeDetect(dirOfCwd?: string): Promise<void>;
 export declare function gitDiffDetect(): Promise<{
     dependenceJson: {
@@ -32,45 +26,9 @@ export declare function gitDiffDetect(): Promise<{
         filePath: string;
     }[];
 } | undefined>;
-export declare function getUpstreamDependenceJson(inputUrl: string, token: string, jsonKeys?: (keyof Awaited<ReturnType<typeof cloneGitRepoAndGetDiff>>)[]): Promise<{
-    reports: {
-        dangerIdentifiers: string[];
-        topEffectedExportsAdded: string[];
-        topEffectedExportsRemoved: string[];
-        blockReports: {
-            diff_txt: string[];
-            infos: {
-                causeBy: string;
-                effectsUpstream: string[];
-                occupations: string[];
-                effectsDownstream: string[];
-            }[];
-        }[];
-        type: "modify" | "add" | "delete";
-        filesDependsOnMe: string[];
-        undefinedIdentifiers: string[];
-        filePath: string;
-    }[];
-    dependenceJson: {
-        import2export: Record<string, string>;
-        export2export: Record<string, string>;
-        mapFilePathToExportAllSources: Record<string, string[]>;
-        indirectExportMembers: Record<string, string>;
-    };
-    effectedCode: Record<string, any>;
-    upstreamDependenceJson: {};
-    repoType: string;
-    message: string;
-} | {
-    effectedCode: Record<string, any>;
-    upstreamDependenceJson: {};
-    repoType: string;
-    message: any;
-    reports?: undefined;
-    dependenceJson?: undefined;
-}>;
 export { isRepoTypeSupported } from "./util/shared/getRepoSupportFlag";
 export declare function runDiffDetect(compareUrl?: string, token?: string): Promise<{
+    error: Error | null;
     repoType: string;
     effectedImportUsage: [string, string][];
 }>;

package/dist/cjs/index.js

@@ -29,10 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  getGitRepositoryAndBranch: () => getGitRepositoryAndBranch,
-  getUpstreamDependenceJson: () => getUpstreamDependenceJson,
   gitDiffDetect: () => gitDiffDetect,
-  gitDiffFileName: () => gitDiffFileName,
   isRepoTypeSupported: () => import_getRepoSupportFlag.isRepoTypeSupported,
   runDiffDetect: () => runDiffDetect,
   sameCodeDetect: () => sameCodeDetect
@@ -40,25 +37,13 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_path = require("path");
 var import_fs = require("fs");
-var import_utils = require("@umijs/utils");
 var import_dayjs = __toESM(require("dayjs"));
 var import_readDirFiles = require("./util/shared/readDirFiles");
 var import_Core = __toESM(require("./util/ast_util/Core"));
-var import_parseGitLabDiffUril = require("./util/parseGitLabDiffUril");
 var import_gitDiffTool = require("./util/shared/gitDiffTool");
 var import_DetectService = require("./services/DetectService");
+var import_getGitRepositoryAndBranch = __toESM(require("./util/git_util/getGitRepositoryAndBranch"));
 var import_getRepoSupportFlag = require("./util/shared/getRepoSupportFlag");
-var gitDiffFileName = "git_diff.txt";
-async function getGitRepositoryAndBranch() {
-  const res = await import_utils.execa.execa("git remote get-url origin", { shell: true });
-  import_utils.chalk.green(["仓库地址：", res.stdout]);
-  const branch = await import_utils.execa.execa("git rev-parse --abbrev-ref HEAD", { shell: true });
-  import_utils.chalk.green(["分支名称：", branch.stdout]);
-  return {
-    gitUrl: res.stdout,
-    branchName: branch.stdout
-  };
-}
 async function sameCodeDetect(dirOfCwd) {
   const filesAndContent = await (0, import_readDirFiles.readSrcFiles)(dirOfCwd);
   const { nodeContentGroupList, depthList } = import_Core.default.investigate(filesAndContent);
@@ -69,14 +54,10 @@ async function sameCodeDetect(dirOfCwd) {
   (0, import_fs.writeFileSync)((0, import_path.join)(process.cwd(), `${(0, import_dayjs.default)().format("YYYYMDD_HHmm")}_same_code.md`), md, { encoding: "utf-8", flag: "w" });
 }
 async function gitDiffDetect() {
-  const { gitUrl, branchName } = await getGitRepositoryAndBranch();
+  const { gitUrl, branchName } = await (0, import_getGitRepositoryAndBranch.default)();
   const today = (0, import_dayjs.default)().format("YYYYMDD_HHmmss");
   return (0, import_gitDiffTool.gitDiffTool)({ gitRepoUrl: gitUrl, targetBranch: branchName, baseBranch: "master", tempDirPath: today, generateFile: void 0 });
 }
-async function getUpstreamDependenceJson(inputUrl, token, jsonKeys) {
-  const gitInfo = (0, import_parseGitLabDiffUril.parseGitLabCompareUrl)(inputUrl);
-  return (0, import_gitDiffTool.cloneGitRepoAndGetDiff)(gitInfo.gitRepoUrl, gitInfo.targetBranch, { token, jsonKeys });
-}
 async function runDiffDetect(compareUrl, token) {
   const option = {
     compareUrl,
@@ -85,7 +66,7 @@ async function runDiffDetect(compareUrl, token) {
     branchName: ""
   };
   if (!compareUrl || !token) {
-    const { gitUrl, branchName } = await getGitRepositoryAndBranch();
+    const { gitUrl, branchName } = await (0, import_getGitRepositoryAndBranch.default)();
     option.gitRepoUrl = gitUrl;
     option.branchName = branchName;
   }
@@ -95,10 +76,7 @@ async function runDiffDetect(compareUrl, token) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getGitRepositoryAndBranch,
-  getUpstreamDependenceJson,
   gitDiffDetect,
-  gitDiffFileName,
   isRepoTypeSupported,
   runDiffDetect,
   sameCodeDetect

package/dist/cjs/services/DetectService.d.ts

@@ -1,4 +1,4 @@
-import { parseGitLabCompareUrl } from "../util/parseGitLabDiffUril";
+import { parseGitLabCompareUrl } from "../util/git_util/parseGitLabDiffUril";
 import { ProjectService } from "./ProjectService";
 export declare class DetectService {
     directoryInfo: {
@@ -27,8 +27,10 @@ export declare class DetectService {
     clean(): Promise<void>;
     mkdir(): Promise<void>;
     clone(): Promise<void>;
+    move(): Promise<void>;
     projectHandle(): Promise<void>;
     formatResult(): {
+        error: Error | null;
         repoType: string;
         effectedImportUsage: [string, string][];
     };

package/dist/cjs/services/DetectService.js

@@ -35,13 +35,15 @@ module.exports = __toCommonJS(DetectService_exports);
 var import_path = require("path");
 var import_await_to_js = __toESM(require("await-to-js"));
 var import_utils = require("@umijs/utils");
-var import_parseGitLabDiffUril = require("../util/parseGitLabDiffUril");
-var import_createRandomStr = __toESM(require("../util/createRandomStr"));
+var import_parseGitLabDiffUril = require("../util/git_util/parseGitLabDiffUril");
+var import_createRandomStr = __toESM(require("../util/shared/createRandomStr"));
 var import_constants = require("../util/constants");
-var import_gitUtil = require("../util/shared/gitUtil");
+var import_execGitDiff = __toESM(require("../util/git_util/execGitDiff"));
 var import_getRepoSupportFlag = require("../util/shared/getRepoSupportFlag");
 var import_UmiProjectService = __toESM(require("./projectServiceClass/UmiProjectService"));
 var import_perf_hooks = require("perf_hooks");
+var import_cloneRepoWithBranchAndDefault = __toESM(require("../util/git_util/cloneRepoWithBranchAndDefault"));
+var import_VueProjectService = __toESM(require("./projectServiceClass/VueProjectService"));
 var DetectService = class {
   constructor(option) {
     this.directoryInfo = {
@@ -61,7 +63,7 @@ var DetectService = class {
     this.init(option);
   }
   async init(option) {
-    const { compareUrl, token, gitRepoUrl, branchName } = option;
+    const { compareUrl, token = "", gitRepoUrl, branchName } = option;
     const tmpWorkDir = (0, import_createRandomStr.default)();
     this.directoryInfo = {
       tmpWorkDir,
@@ -72,6 +74,7 @@ var DetectService = class {
       this.gitInfo = {
         ...this.gitInfo,
         ...(0, import_parseGitLabDiffUril.parseGitLabCompareUrl)(compareUrl),
+        token,
         repoType: ""
       };
     }
@@ -97,6 +100,10 @@ var DetectService = class {
         import_utils.logger.info(`mkdir 耗时: ${duration}ms`);
       }
       await this.clone();
+      const token = this.gitInfo.token;
+      if (token) {
+        await this.move();
+      }
       import_perf_hooks.performance.mark("projectHandle");
       {
         const duration = import_perf_hooks.performance.measure("clone", "clone", "projectHandle").duration;
@@ -130,7 +137,10 @@ var DetectService = class {
     import_utils.logger.info("开始克隆仓库");
     const { tmpWorkDir } = this.directoryInfo;
     const { gitRepoUrl, token, baseBranch, targetBranch } = this.gitInfo;
+    import_utils.logger.info(`开始克隆仓库: ${gitRepoUrl}`);
+    import_utils.logger.info(`token: ${token}`);
     const repoUrl = token ? (0, import_parseGitLabDiffUril.getGitRepoUrlByToken)(gitRepoUrl, token || "") : gitRepoUrl;
+    import_utils.logger.info(`克隆仓库URL: ${repoUrl}`);
     const branchesAndTargetDirPaths = [
       {
         branch: baseBranch,
@@ -142,14 +152,23 @@ var DetectService = class {
       }
     ];
     await Promise.all(branchesAndTargetDirPaths.map(({ branch, targetDirPath: targetDirPath2 }) => {
-      return (0, import_gitUtil.cloneRepoWithBranchAndDefault)(repoUrl, branch, targetDirPath2);
+      return (0, import_cloneRepoWithBranchAndDefault.default)(repoUrl, branch, targetDirPath2);
     }));
     const targetDirPath = (0, import_path.join)(tmpWorkDir, import_constants.TARGET);
-    await (0, import_gitUtil.execGitDiff)(targetDirPath, baseBranch, targetBranch);
+    await (0, import_execGitDiff.default)(targetDirPath, baseBranch, targetBranch);
     const repoType = await (0, import_getRepoSupportFlag.getRepoType)((0, import_path.join)(targetDirPath, "package.json"));
     this.gitInfo.repoType = repoType;
     import_utils.logger.info("克隆仓库成功");
   }
+  async move() {
+    const repoType = this.gitInfo.repoType;
+    const tmpWorkDir = this.directoryInfo.tmpWorkDir;
+    const newTmpWorkDir = (0, import_path.join)(repoType, tmpWorkDir);
+    this.directoryInfo.tmpWorkDir = newTmpWorkDir;
+    this.directoryInfo.sourceBranchDir = (0, import_path.join)(newTmpWorkDir, import_constants.SOURCE);
+    this.directoryInfo.targetBranchDir = (0, import_path.join)(newTmpWorkDir, import_constants.TARGET);
+    await import_utils.execa.execa(`mv ${tmpWorkDir} ${newTmpWorkDir}`, { shell: true });
+  }
   async projectHandle() {
     var _a;
     const { repoType } = this.gitInfo;
@@ -159,13 +178,17 @@ var DetectService = class {
     if (repoType === "umi") {
       this.projectService = new import_UmiProjectService.default(this);
     }
+    if (repoType === "vue2") {
+      this.projectService = new import_VueProjectService.default(this);
+    }
     await ((_a = this.projectService) == null ? void 0 : _a.run());
   }
   formatResult() {
     var _a;
     const repoType = this.gitInfo.repoType;
-    const { effectedImportUsage } = ((_a = this.projectService) == null ? void 0 : _a.outputResult) || { effectedImportUsage: [] };
+    const { effectedImportUsage, error } = ((_a = this.projectService) == null ? void 0 : _a.outputResult) || { effectedImportUsage: [], error: null };
     return {
+      error,
       repoType,
       effectedImportUsage
     };

package/dist/cjs/services/ProjectService.d.ts

@@ -1,16 +1,15 @@
 import { DetectService } from "./DetectService";
 import { formatGitDiffContent } from "../util/format_git_diff_content";
-import { IMadgeInstance } from "../util/report_util/getMadgeInstance";
 export interface ProjectService {
     detectService: DetectService;
     gitDiffDetail: ReturnType<typeof formatGitDiffContent>;
     helpInfo: {
         projectFileList: string[];
-        madgeResult: IMadgeInstance | null;
         parsedAlias: Record<string, any>;
     };
     outputResult: {
         effectedImportUsage: [string, string][];
+        error: Error | null;
     };
     run(): void;
 }

package/dist/cjs/services/projectServiceClass/UmiProjectService.d.ts

@@ -1,11 +1,15 @@
 import { GitDiffDetail } from "../../util/format_git_diff_content";
 import { DetectService } from "../DetectService";
 import { ProjectService } from "../ProjectService";
+import { IMadgeInstance } from "../../util/report_util/getMadgeInstance";
 export default class UmiProjectService implements ProjectService {
     detectService: DetectService;
     gitDiffDetail: GitDiffDetail[];
     helpInfo: ProjectService['helpInfo'];
     outputResult: ProjectService['outputResult'];
+    umiHelpInfo: {
+        madgeResult: IMadgeInstance | null;
+    };
     constructor(detectService: DetectService);
     run(): Promise<void>;
     parseGitDiffContent(): Promise<void>;

package/dist/cjs/services/projectServiceClass/UmiProjectService.js

@@ -33,24 +33,27 @@ __export(UmiProjectService_exports, {
 });
 module.exports = __toCommonJS(UmiProjectService_exports);
 var import_format_git_diff_content = require("../../util/format_git_diff_content");
-var import_umi4ProjectUtil = require("../../util/shared/umi4ProjectUtil");
+var import_umi4ProjectUtil = require("../../util/project_umi_util/umi4ProjectUtil");
 var import_fs = require("fs");
 var import_path = require("path");
-var import__ = require("../../index");
 var import_collectUpstreamFiles = __toESM(require("../../util/shared/collectUpstreamFiles"));
 var import_createDependenceMap = require("../../util/report_util/createDependenceMap");
 var import_filterEffectedExportMember = __toESM(require("../../util/report_util/filterEffectedExportMember"));
+var import_constants = require("../../util/constants");
 var UmiProjectService = class {
   constructor(detectService) {
     this.detectService = detectService;
     this.gitDiffDetail = [];
     this.helpInfo = {
       projectFileList: [],
-      madgeResult: null,
       parsedAlias: {}
     };
     this.outputResult = {
-      effectedImportUsage: []
+      effectedImportUsage: [],
+      error: null
+    };
+    this.umiHelpInfo = {
+      madgeResult: null
     };
     this.detectService = detectService;
   }
@@ -58,18 +61,19 @@ var UmiProjectService = class {
     const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
     const { madgeResult, parsedAlias } = await (0, import_umi4ProjectUtil.umi4SetUp)({ targetDirPath, invokeType: "remote" });
     this.helpInfo.projectFileList = Object.keys(madgeResult.tree);
-    this.helpInfo.madgeResult = madgeResult;
+    this.umiHelpInfo.madgeResult = madgeResult;
     this.helpInfo.parsedAlias = parsedAlias;
     await this.parseGitDiffContent();
     await this.collectEffectedFiles();
   }
   async parseGitDiffContent() {
     const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
-    const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(targetDirPath, import__.gitDiffFileName), "utf-8");
+    const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(targetDirPath, import_constants.gitDiffFileName), "utf-8");
     this.gitDiffDetail = (0, import_format_git_diff_content.formatGitDiffContent)(diff_txt);
   }
   async collectEffectedFiles() {
-    const { madgeResult, parsedAlias } = this.helpInfo;
+    const { parsedAlias } = this.helpInfo;
+    const { madgeResult } = this.umiHelpInfo;
     const projectFileList = this.helpInfo.projectFileList;
     const targetBranchDir = this.detectService.directoryInfo.targetBranchDir;
     const absPathPrefix = (0, import_path.join)(targetBranchDir, "/");

package/dist/cjs/services/projectServiceClass/VueProjectService.d.ts

@@ -0,0 +1,31 @@
+import { GitDiffDetail } from "../../util/format_git_diff_content";
+import { ProjectService } from "../ProjectService";
+import { DetectService } from "../DetectService";
+import { IMadgeInstance } from "../../util/report_util/getMadgeInstance";
+export default class VueProjectService implements ProjectService {
+    detectService: DetectService;
+    gitDiffDetail: GitDiffDetail[];
+    helpInfo: ProjectService['helpInfo'];
+    outputResult: ProjectService['outputResult'];
+    vueHelpInfo: {
+        madgeResult: IMadgeInstance | null;
+        webpackConfigPath: string;
+        webpackConfigTextLines: string[];
+        entryFiles: string[];
+    };
+    constructor(detectService: DetectService);
+    run(): Promise<void>;
+    readSrcDirFiles(): Promise<void>;
+    parseGitDiffContent(): Promise<void>;
+    handleWebpackConfigText(webpackConfigText: string): Promise<void>;
+    getWebpackConfigText(): Promise<void>;
+    createSimpleWebpackConfig(): {
+        resolve: {
+            alias: Record<string, any>;
+        };
+    };
+    getEntryFiles(): void;
+    getWebpackAlias(): void;
+    getMadgeResult(): Promise<void>;
+    collectEffectedFiles(): Promise<void>;
+}

package/dist/cjs/services/projectServiceClass/VueProjectService.js

@@ -0,0 +1,191 @@
+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 = (to2, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to2, key) && key !== except)
+        __defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to2;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // 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/services/projectServiceClass/VueProjectService.ts
+var VueProjectService_exports = {};
+__export(VueProjectService_exports, {
+  default: () => VueProjectService
+});
+module.exports = __toCommonJS(VueProjectService_exports);
+var import_format_git_diff_content = require("../../util/format_git_diff_content");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_constants = require("../../util/constants");
+var import_utils = require("@umijs/utils");
+var import_madge = __toESM(require("madge"));
+var import_collectUpstreamFiles = __toESM(require("../../util/shared/collectUpstreamFiles"));
+var import_createDependenceMap = require("../../util/report_util/createDependenceMap");
+var import_filterEffectedExportMember = __toESM(require("../../util/report_util/filterEffectedExportMember"));
+var import_await_to_js = __toESM(require("await-to-js"));
+var VueProjectService = class {
+  constructor(detectService) {
+    this.detectService = detectService;
+    this.gitDiffDetail = [];
+    this.helpInfo = {
+      projectFileList: [],
+      parsedAlias: {}
+    };
+    this.outputResult = {
+      effectedImportUsage: [],
+      error: null
+    };
+    this.vueHelpInfo = {
+      madgeResult: null,
+      webpackConfigPath: "",
+      webpackConfigTextLines: [],
+      entryFiles: []
+    };
+    this.detectService = detectService;
+  }
+  async run() {
+    import_utils.logger.info("格式化 git diff 内容...");
+    await this.parseGitDiffContent();
+    import_utils.logger.info("获取 webpack 配置...");
+    await this.getWebpackConfigText();
+    await this.collectEffectedFiles();
+  }
+  async readSrcDirFiles() {
+    const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
+    const projectFileList = (0, import_utils.readDirFiles)({ dir: (0, import_path.join)(targetDirPath, "src") });
+  }
+  async parseGitDiffContent() {
+    const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
+    const diff_txt = (0, import_fs.readFileSync)((0, import_path.join)(targetDirPath, import_constants.gitDiffFileName), "utf-8");
+    this.gitDiffDetail = (0, import_format_git_diff_content.formatGitDiffContent)(diff_txt);
+  }
+  async handleWebpackConfigText(webpackConfigText) {
+    const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
+    this.vueHelpInfo.webpackConfigTextLines = webpackConfigText.split("\n");
+    this.getWebpackAlias();
+    this.getEntryFiles();
+    const wb = this.createSimpleWebpackConfig();
+    (0, import_fs.writeFileSync)(this.vueHelpInfo.webpackConfigPath = (0, import_path.join)(targetDirPath, "webpack.config.js"), `module.exports = ${JSON.stringify(wb, null, 2)}`, "utf-8");
+    await this.getMadgeResult();
+  }
+  async getWebpackConfigText() {
+    const targetDirPath = this.detectService.directoryInfo.targetBranchDir;
+    let [err, data] = await (0, import_await_to_js.default)(import_utils.execa.execa(`cd ${targetDirPath} && npx vue-cli-service inspect`, { shell: true }));
+    if (err) {
+      await import_utils.execa.execa(`cd ${targetDirPath} && yarn`, { shell: true });
+      [err, data] = await (0, import_await_to_js.default)(import_utils.execa.execa(`cd ${targetDirPath} && npx vue-cli-service inspect`, { shell: true }));
+    }
+    this.outputResult.error = err;
+    const webpackConfigText = data == null ? void 0 : data.stdout;
+    if (webpackConfigText) {
+      await this.handleWebpackConfigText(webpackConfigText);
+    }
+  }
+  createSimpleWebpackConfig() {
+    return {
+      resolve: {
+        alias: this.helpInfo.parsedAlias
+      }
+    };
+  }
+  getEntryFiles() {
+    const lines = this.vueHelpInfo.webpackConfigTextLines;
+    let entryObject = {};
+    const entryLines = [];
+    let entryFind = false;
+    for (const line of lines) {
+      if (!entryFind && line.trim().startsWith("entry:")) {
+        entryLines.push(line.replace("entry:", ""));
+        entryFind = true;
+      } else if (entryFind && line.trim().startsWith("}")) {
+        entryLines.push(line.replace(/,/g, ""));
+        break;
+      } else if (entryFind) {
+        entryLines.push(line);
+      }
+    }
+    const entryLinesJoin = entryLines.join("\n");
+    entryObject = eval(`(${entryLinesJoin})`);
+    this.vueHelpInfo.entryFiles = Object.values({ ...entryObject }).flat();
+  }
+  getWebpackAlias() {
+    const lines = this.vueHelpInfo.webpackConfigTextLines;
+    const aliasLines = [];
+    let aliasFind = false;
+    for (const line of lines) {
+      if (!aliasFind && line.trim().startsWith("alias:")) {
+        aliasLines.push(line.replace("alias:", ""));
+        aliasFind = true;
+      } else if (aliasFind && line.trim().startsWith("}")) {
+        aliasLines.push(line.replace(/,/g, ""));
+        break;
+      } else if (aliasFind) {
+        aliasLines.push(line);
+      }
+    }
+    const userAlias = eval(`(${aliasLines.join("\n")})`);
+    this.helpInfo.parsedAlias = userAlias;
+  }
+  async getMadgeResult() {
+    const targetBranchDir = this.detectService.directoryInfo.targetBranchDir;
+    const entryFilePath = this.vueHelpInfo.entryFiles.map((file) => (0, import_path.join)(targetBranchDir, file));
+    const madgeConfig = {
+      baseDir: this.detectService.directoryInfo.targetBranchDir,
+      fileExtensions: ["js", "ts", "jsx", "tsx", "vue"],
+      webpackConfig: this.vueHelpInfo.webpackConfigPath
+    };
+    const res = await (0, import_madge.default)(entryFilePath, madgeConfig);
+    this.vueHelpInfo.madgeResult = res;
+    this.helpInfo.projectFileList = Object.keys(res.tree);
+  }
+  async collectEffectedFiles() {
+    const { parsedAlias } = this.helpInfo;
+    const { madgeResult } = this.vueHelpInfo;
+    const projectFileList = this.helpInfo.projectFileList;
+    const targetBranchDir = this.detectService.directoryInfo.targetBranchDir;
+    const absPathPrefix = (0, import_path.join)(targetBranchDir, "/");
+    const validModifiedFiles = this.gitDiffDetail.reduce((acc, item) => {
+      const { filePath } = item;
+      this.helpInfo.projectFileList.includes(filePath) && acc.push(filePath);
+      return acc;
+    }, []);
+    const possibleEffectedFiles = (0, import_collectUpstreamFiles.default)(madgeResult, validModifiedFiles);
+    const possibleEffectedFilesFullPath = possibleEffectedFiles.map((file) => (0, import_path.join)(absPathPrefix, file));
+    const { import2export, indirectExportMembers } = (0, import_createDependenceMap.createExportedNameToReferenceLocalSet)(possibleEffectedFilesFullPath, parsedAlias, absPathPrefix, projectFileList);
+    const gitDiffDetail = this.gitDiffDetail;
+    const validGitDiffDetail = gitDiffDetail.filter((item) => possibleEffectedFiles.includes(item.filePath));
+    const effectedExportNames = validGitDiffDetail.map((item) => {
+      const { filePath, newBranchLineScope, startLineOfNew } = item;
+      const exportedNames = (0, import_filterEffectedExportMember.default)((0, import_path.join)(absPathPrefix, filePath), absPathPrefix, Number(startLineOfNew), Number(startLineOfNew) + Number(newBranchLineScope));
+      return exportedNames.map((name) => [filePath, name].join("#"));
+    }).flat();
+    const effectedImportUsage = [...Object.entries(import2export), ...Object.entries(indirectExportMembers)].filter(([_, value]) => {
+      return effectedExportNames.includes(value);
+    });
+    this.outputResult.effectedImportUsage = effectedImportUsage;
+    const token = this.detectService.gitInfo.token;
+    if (!token) {
+      const pwd = (0, import_path.join)(this.detectService.directoryInfo.tmpWorkDir, "..");
+      (0, import_fs.writeFileSync)((0, import_path.join)(pwd, "effectedImportUsage.json"), JSON.stringify(effectedImportUsage, null, 2));
+    }
+  }
+};

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

@@ -37,6 +37,7 @@ var import_sha1 = __toESM(require("crypto-js/sha1"));
 var import_enc_base64 = __toESM(require("crypto-js/enc-base64"));
 var import_featureLevel = require("../shared/featureLevel");
 var import_astNodeFeatureExtractorMap = require("../shared/astNodeFeatureExtractorMap");
+var import_SHARED_CONSTANTS = require("./SHARED_CONSTANTS");
 var AstFeatUtil = class {
   // 单节点判断
   static isValidNodeCollect(astNode) {
@@ -220,10 +221,7 @@ var AstFeatUtil = class {
   }
 };
 AstFeatUtil.skipHashCreateTypes = ["Program", "File", "ExportDeclaration"];
-AstFeatUtil.invalidNodeKey = [
-  "comments",
-  "tokens"
-];
+AstFeatUtil.invalidNodeKey = import_SHARED_CONSTANTS.INVALID_NODE_KEY;
 // 忽略的 节点类型
 AstFeatUtil.AstNodeTypeConf = /* @__PURE__ */ new Map([
   ["ImportDeclaration", {

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

@@ -0,0 +1,30 @@
+import { AstNode } from "./AstUtil";
+export declare class AstUtil {
+    static invalidNodeKey: string[];
+    static EXPORT_DECLARATION_TYPES: readonly ["FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration", "ClassDeclaration"];
+    static windowProperties: string[];
+    static intrinsicElements: string[];
+    static standardAttributes: string[];
+    static FUNCTION_TYPES: string[];
+    static getNodePath(node: AstNode): string;
+    static getShortNodeMsg(node: AstNode, hideParentProperty?: boolean): string;
+    static getTopScopeNodesByLineNumberRange(mapFileLineToNodeSet: Map<number, Set<AstNode>>, lineNumberStart: number, lineNumberEnd: number, loose?: boolean): AstNode[];
+    private static isValidNodeCollect;
+    private static isValidArrayNodeCollect;
+    private static collectEffectId;
+    private static findOrCreateImportedMember;
+    private static findOrCreateExportedMember;
+    private static updateImportedAndExportedMember;
+    private static deepSearchParamsIdentifier;
+    private static collectDependenceIdsOfExportMembers;
+    private static collectExpressionIdentifiersShallow;
+    private static _collectExpressionIdentifiersShallow;
+    private static collectDependenceIds;
+    private static updateLoc;
+    private static collectVariableDeclarationIdentifiers;
+    private static collectDeclarationIdentifiers;
+    private static collectImportDeclarationIdentifiers;
+    private static collectHoldingIds;
+    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;
+}