js-code-detector 0.0.50 → 0.0.51

package/dist/cjs/index.d.ts

@@ -28,6 +28,7 @@ export declare function gitDiffDetect(): Promise<{
 } | 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/services/DetectService.d.ts

@@ -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

@@ -43,6 +43,7 @@ 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 = {
@@ -99,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;
@@ -155,6 +160,15 @@ var DetectService = class {
     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;
@@ -164,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

@@ -46,11 +46,14 @@ var UmiProjectService = class {
     this.gitDiffDetail = [];
     this.helpInfo = {
       projectFileList: [],
-      madgeResult: null,
       parsedAlias: {}
     };
     this.outputResult = {
-      effectedImportUsage: []
+      effectedImportUsage: [],
+      error: null
+    };
+    this.umiHelpInfo = {
+      madgeResult: null
     };
     this.detectService = detectService;
   }
@@ -58,7 +61,7 @@ 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();
@@ -69,7 +72,8 @@ var UmiProjectService = class {
     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/AstKit.d.ts

@@ -8,11 +8,17 @@ export declare class AstUtil {
     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;

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

@@ -43,6 +43,33 @@ var _AstUtil = class {
     ].map((e) => e.filter(Boolean).join(":")).filter(Boolean).join(" ");
     return `${msg}「${startLine}:${startColumn}, ${endLine}:${endColumn}」`;
   }
+  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) {
+          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 isValidNodeCollect(astNode) {
     return typeof (astNode == null ? void 0 : astNode.type) === "string";
   }
@@ -51,9 +78,118 @@ var _AstUtil = class {
   }
   static collectEffectId(id) {
   }
-  static updateImportedAndExportedMember(programBodyChild, programNode) {
-    if (programNode.type !== "Program")
-      return;
+  static findOrCreateImportedMember(importedMember, sourceValue) {
+    let target = importedMember.find((v) => v.sourcePath === sourceValue);
+    if (!target) {
+      target = { sourcePath: sourceValue, members: [] };
+      importedMember.push(target);
+    }
+    return target;
+  }
+  static findOrCreateExportedMember(exportedMember, sourceValue) {
+    let target = exportedMember.find((v) => v.sourcePath === sourceValue);
+    if (!target) {
+      target = { sourcePath: sourceValue, members: [], ExportAllDeclaration: false };
+      exportedMember.push(target);
+    }
+    return target;
+  }
+  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;
+    const { importedMember, exportedMember } = programNode._util;
+    if (type === "ImportDeclaration") {
+      specifiers.forEach((specifier) => {
+        const { local, imported } = specifier;
+        const target = this.findOrCreateImportedMember(importedMember, sourceValue);
+        if (specifier.type === "ImportNamespaceSpecifier") {
+          target.members.push({
+            localName: local.name,
+            importedName: "*"
+          });
+          return;
+        }
+        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") {
+      const target = exportedMember.find((v) => v.sourcePath === sourceValue);
+      if (!target) {
+        exportedMember.push({ sourcePath: sourceValue, members: [], ExportAllDeclaration: true });
+      }
+    }
+    if (type === "ExportNamedDeclaration") {
+      Array.isArray(specifiers) && specifiers.forEach((specifier) => {
+        const { local, exported } = specifier;
+        const target = this.findOrCreateExportedMember(exportedMember, sourceValue);
+        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) => {
+          const target = this.findOrCreateExportedMember(exportedMember, sourceValue);
+          this.collectVariableDeclarationIdentifiers(dec, (identifier) => {
+            try {
+              const idName = identifier.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)) {
+        const target = this.findOrCreateExportedMember(exportedMember, sourceValue);
+        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") {
+      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 deepSearchParamsIdentifier(id, callback) {
     if (!id) {
@@ -86,7 +222,98 @@ var _AstUtil = class {
       }
     }
   }
+  static collectDependenceIdsOfExportMembers(node, callback) {
+    if (node.type === "ExportNamedDeclaration") {
+      const { declaration, specifiers } = node;
+      if ((declaration == null ? void 0 : declaration.type) === "Identifier") {
+        callback(declaration);
+      }
+      for (const specifier of specifiers) {
+        const { local } = specifier;
+        if ((local == null ? void 0 : local.type) === "Identifier") {
+          callback(local);
+        }
+      }
+    }
+    if (node.type === "ExportDefaultDeclaration") {
+      const declaration = node.declaration;
+      if ((declaration == null ? void 0 : declaration.type) === "Identifier") {
+        callback(declaration);
+      }
+    }
+  }
+  static collectExpressionIdentifiersShallow(exp, callback) {
+    if (!exp || exp.type === "ThisExpression") {
+      return;
+    }
+    this._collectExpressionIdentifiersShallow(exp, callback);
+  }
+  static _collectExpressionIdentifiersShallow(exp, callback) {
+    var _a, _b;
+    if (!exp || exp.type === "ThisExpression" || exp._util.holdingIdType)
+      return;
+    if (exp.type === "Identifier") {
+      if ((exp._util.parentProperty === "property" || exp._util.parentProperty === "key") && !((_a = exp._util.parent) == null ? void 0 : _a.computed))
+        return;
+      callback(exp);
+      return;
+    }
+    if (exp.type === "JSXIdentifier" && ((_b = exp._util.parent) == null ? void 0 : _b.type) !== "JSXAttribute") {
+      callback(exp);
+      return;
+    }
+  }
   static collectDependenceIds(node) {
+    const { _util } = node;
+    const { dependenceIds, holdingIdNameMap, children, dependenceIdsNoScope, holdingIds } = _util;
+    children.forEach((child) => {
+      if (child._util.dependenceIdsNoScope.size > 0) {
+        child._util.dependenceIdsNoScope.forEach((id) => dependenceIds.add(id));
+      }
+      this.collectDependenceIdsOfExportMembers(child, (id) => dependenceIds.add(id));
+      this.collectExpressionIdentifiersShallow(child, (exp) => {
+        var _a, _b;
+        if (exp.type === "ThisExpression" || exp._util.holdingIdType || ["imported", "exported"].includes(exp._util.parentProperty))
+          return;
+        if (exp.type === "Identifier") {
+          if ((exp._util.parentProperty === "property" || exp._util.parentProperty === "key") && !((_a = exp._util.parent) == null ? void 0 : _a.computed))
+            return;
+        }
+        if (exp.type === "JSXIdentifier" && ((_b = exp._util.parent) == null ? void 0 : _b.type) === "JSXAttribute")
+          return;
+        dependenceIds.add(exp);
+      });
+    });
+    for (const dependenceId of [...dependenceIds]) {
+      if (!dependenceId._util) {
+        continue;
+      }
+      if (holdingIds.has(dependenceId)) {
+        dependenceIds.delete(dependenceId);
+        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];
+        if (firstPick && firstPick._util.uuid !== dependenceId._util.uuid) {
+          firstPick._util.occupation.add(dependenceId);
+        }
+      }
+      if (dependenceId._util.variableScope.length === 0) {
+        dependenceIdsNoScope.add(dependenceId);
+      }
+    }
+    if (node.type === "Program") {
+      for (const dependenceId of [...dependenceIdsNoScope]) {
+        if (dependenceId.type === "JSXIdentifier" && this.intrinsicElements.includes(dependenceId.name)) {
+          dependenceIdsNoScope.delete(dependenceId);
+          dependenceIds.delete(dependenceId);
+        } else if (dependenceId.type === "Identifier" && this.windowProperties.includes(dependenceId.name)) {
+          dependenceIdsNoScope.delete(dependenceId);
+          dependenceIds.delete(dependenceId);
+        }
+      }
+    }
   }
   static updateLoc(astNode, extra) {
     var _a, _b, _c, _d, _e, _f, _g;
@@ -109,7 +336,7 @@ var _AstUtil = class {
       var _a2, _b2;
       return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.end) == null ? void 0 : _b2.column;
     }), (_f = astNode.loc) == null ? void 0 : _f.end.column);
-    _util.uuid = `${filePath}:${type}:${name}「${_util.startLine}:${_util.startColumn},${_util.endLine}:${_util.endColumn}」`;
+    _util.uuid = `${filePath}@${type}:${name}「${_util.startLine}:${_util.startColumn},${_util.endLine}:${_util.endColumn}」`;
     mapUuidToNode.set(_util.uuid, astNode);
     for (let i = _util.startLine; i <= _util.endLine; i++) {
       mapFileLineToNodeSet.set(i, mapFileLineToNodeSet.get(i) || /* @__PURE__ */ new Set());
@@ -295,7 +522,9 @@ var _AstUtil = class {
     });
     try {
       children.forEach((child) => child._util.parent = node);
-      nodeCollection.forEach((nodeItem) => nodeItem._util.ancestors.unshift(node));
+      nodeCollection.forEach((nodeItem) => {
+        !nodeItem._util.ancestors.includes(node) && nodeItem._util.ancestors.unshift(node);
+      });
     } catch (e) {
       console.error("parent ancestors update", e.message);
     }

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

@@ -156,7 +156,9 @@ var _AstUtil = class {
     });
     try {
       children.forEach((child) => child._util.parent = node);
-      nodeCollection.forEach((nodeItem) => nodeItem._util.ancestors.unshift(node));
+      nodeCollection.forEach((nodeItem) => {
+        !nodeItem._util.ancestors.includes(node) && nodeItem._util.ancestors.unshift(node);
+      });
     } catch (e) {
       console.error("parent ancestors update", e.message);
     }
@@ -187,7 +189,7 @@ var _AstUtil = class {
       try {
         node.body.forEach((child) => this.updateImportedAndExportedMember(child, node));
       } catch (e) {
-        console.error("updateImportedAndExportedMember", e.message);
+        console.error("收集导入、导出成员 报错", e.message);
       }
     }
     try {
@@ -224,6 +226,10 @@ var _AstUtil = class {
     const nameList = /* @__PURE__ */ new Set();
     outer:
       for (const ancestor of nodeArray) {
+        if (ancestor.type === "VElement") {
+          nameList.add("default");
+          break outer;
+        }
         if (ancestor.type === "ExportDefaultDeclaration") {
           const { declaration } = ancestor;
           if (declaration) {
@@ -884,7 +890,7 @@ var _AstUtil = class {
       var _a2, _b2;
       return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.end) == null ? void 0 : _b2.column;
     }), (_f = astNode.loc) == null ? void 0 : _f.end.column);
-    _util.uuid = `${filePath}:${type}:${name}「${_util.startLine}:${_util.startColumn},${_util.endLine}:${_util.endColumn}」`;
+    _util.uuid = `${filePath}@${type}:${name}「${_util.startLine}:${_util.startColumn},${_util.endLine}:${_util.endColumn}」`;
     mapUuidToNode.set(_util.uuid, astNode);
     for (let i = _util.startLine; i <= _util.endLine; i++) {
       mapFileLineToNodeSet.set(i, mapFileLineToNodeSet.get(i) || /* @__PURE__ */ new Set());

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

@@ -39,5 +39,9 @@ function filterEffectedExportMember(filePath, absPathPrefix, startLine, endLine)
   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)];
+  const res = [...new Set(exportMembers)];
+  if (res.length === 0 && filePath.endsWith(".vue")) {
+    res.push("default");
+  }
+  return res;
 }

package/dist/cjs/util/shared/getRepoSupportFlag.d.ts

@@ -1,2 +1,2 @@
 export declare function isRepoTypeSupported(repoType: string): boolean;
-export declare function getRepoType(jsonPath: string): "unknown" | "umi" | "vue2";
+export declare function getRepoType(jsonPath: string): "umi" | "vue2" | "unknown";

package/dist/cjs/util/shared/getRepoSupportFlag.js

@@ -26,7 +26,7 @@ module.exports = __toCommonJS(getRepoSupportFlag_exports);
 var import_fs = require("fs");
 var import_utils = require("@umijs/utils");
 function isRepoTypeSupported(repoType) {
-  return ["umi"].includes(repoType);
+  return ["umi", "vue2"].includes(repoType);
 }
 function getRepoType(jsonPath) {
   var _a, _b, _c;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-code-detector",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "description": "",
   "main": "dist/cjs/index.js",
   "types": "dist/cjs/index.d.ts",