js-code-detector 0.0.47 → 0.0.50

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,8 @@ 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<{
     repoType: string;
-    effectedImportUsage: 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: {
@@ -30,6 +30,6 @@ export declare class DetectService {
     projectHandle(): Promise<void>;
     formatResult(): {
         repoType: string;
-        effectedImportUsage: string[];
+        effectedImportUsage: [string, string][];
     };
 }

package/dist/cjs/services/DetectService.js

@@ -35,13 +35,14 @@ 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 DetectService = class {
   constructor(option) {
     this.directoryInfo = {
@@ -61,7 +62,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 +73,7 @@ var DetectService = class {
       this.gitInfo = {
         ...this.gitInfo,
         ...(0, import_parseGitLabDiffUril.parseGitLabCompareUrl)(compareUrl),
+        token,
         repoType: ""
       };
     }
@@ -130,7 +132,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,10 +147,10 @@ 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("克隆仓库成功");

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

@@ -10,7 +10,7 @@ export interface ProjectService {
         parsedAlias: Record<string, any>;
     };
     outputResult: {
-        effectedImportUsage: string[];
+        effectedImportUsage: [string, string][];
     };
     run(): void;
 }

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

@@ -33,13 +33,13 @@ __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;
@@ -65,7 +65,7 @@ var UmiProjectService = class {
   }
   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() {
@@ -88,10 +88,9 @@ var UmiProjectService = class {
       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)].reduce((acc, [key, value]) => {
-      effectedExportNames.includes(value) && acc.push(key);
-      return acc;
-    }, []);
+    const effectedImportUsage = [...Object.entries(import2export), ...Object.entries(indirectExportMembers)].filter(([_, value]) => {
+      return effectedExportNames.includes(value);
+    });
     this.outputResult.effectedImportUsage = effectedImportUsage;
   }
 };

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,24 @@
+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;
+    private static isValidNodeCollect;
+    private static isValidArrayNodeCollect;
+    private static collectEffectId;
+    private static updateImportedAndExportedMember;
+    private static deepSearchParamsIdentifier;
+    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;
+}

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

@@ -0,0 +1,345 @@
+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/AstKit.ts
+var AstKit_exports = {};
+__export(AstKit_exports, {
+  AstUtil: () => AstUtil
+});
+module.exports = __toCommonJS(AstKit_exports);
+var import_intrinsicElements = require("./intrinsicElements");
+var import_SHARED_CONSTANTS = require("./SHARED_CONSTANTS");
+var import_windowProperties = require("./windowProperties");
+var _AstUtil = class {
+  static getNodePath(node) {
+    return [...node._util.ancestors, node].map((n) => n.type).join(":") + ":" + node.name;
+  }
+  static getShortNodeMsg(node, hideParentProperty = false) {
+    const { _util: { startLine, startColumn, endLine, endColumn, parentProperty, indexOfProperty } } = node;
+    let type = node.type;
+    let name = node.name;
+    if (name && typeof name === "object") {
+      type = name.type;
+      name = name.name;
+    }
+    const msg = [
+      hideParentProperty ? [] : [parentProperty, indexOfProperty !== null ? String(indexOfProperty) : null],
+      [type, name]
+    ].map((e) => e.filter(Boolean).join(":")).filter(Boolean).join(" ");
+    return `${msg}「${startLine}:${startColumn}, ${endLine}:${endColumn}」`;
+  }
+  static isValidNodeCollect(astNode) {
+    return typeof (astNode == null ? void 0 : astNode.type) === "string";
+  }
+  static isValidArrayNodeCollect(astNode) {
+    return Array.isArray(astNode) && astNode.some((v) => typeof (v == null ? void 0 : v.type) === "string");
+  }
+  static collectEffectId(id) {
+  }
+  static updateImportedAndExportedMember(programBodyChild, programNode) {
+    if (programNode.type !== "Program")
+      return;
+  }
+  static deepSearchParamsIdentifier(id, callback) {
+    if (!id) {
+      return;
+    }
+    if (id.type === "Identifier") {
+      callback(id);
+    }
+    if (id.type === "AssignmentPattern") {
+      const left = id.left;
+      this.deepSearchParamsIdentifier(left, callback);
+    }
+    if (id.type === "RestElement") {
+      this.deepSearchParamsIdentifier(id.argument, callback);
+    }
+    if (id.type === "ObjectProperty") {
+      const value = id.value;
+      this.deepSearchParamsIdentifier(value, callback);
+    }
+    if (id.type === "ObjectPattern") {
+      const properties = id.properties;
+      for (const property of properties) {
+        this.deepSearchParamsIdentifier(property, callback);
+      }
+    }
+    if (id.type === "ArrayPattern") {
+      const elements = id.elements;
+      for (const element of elements) {
+        this.deepSearchParamsIdentifier(element, callback);
+      }
+    }
+  }
+  static collectDependenceIds(node) {
+  }
+  static updateLoc(astNode, extra) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const { _util, type, name } = astNode;
+    const { mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet } = extra;
+    const { nodeCollection, filePath, parent } = _util;
+    _util.startLine = Math.min(...nodeCollection.map((n) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.start) == null ? void 0 : _b2.line;
+    }), (_a = astNode.loc) == null ? void 0 : _a.start.line);
+    _util.endLine = Math.max(...nodeCollection.map((n) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.end) == null ? void 0 : _b2.line;
+    }), (_b = astNode.loc) == null ? void 0 : _b.end.line);
+    _util.startColumn = ((_c = astNode.loc) == null ? void 0 : _c.start.column) ?? Math.min(...nodeCollection.map((n) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = n.loc) == null ? void 0 : _a2.start) == null ? void 0 : _b2.column;
+    }), (_d = astNode.loc) == null ? void 0 : _d.start.column);
+    _util.endColumn = ((_e = astNode.loc) == null ? void 0 : _e.end.column) ?? Math.max(...nodeCollection.map((n) => {
+      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}」`;
+    mapUuidToNode.set(_util.uuid, astNode);
+    for (let i = _util.startLine; i <= _util.endLine; i++) {
+      mapFileLineToNodeSet.set(i, mapFileLineToNodeSet.get(i) || /* @__PURE__ */ new Set());
+      (_g = mapFileLineToNodeSet.get(i)) == null ? void 0 : _g.add(astNode);
+    }
+    if (astNode.type === "Program") {
+      mapUuidToNode.set(astNode.type, astNode);
+    }
+    if (parent === null) {
+      nodeCollection.forEach((n) => {
+        var _a2;
+        const path = _AstUtil.getNodePath(n);
+        mapPathToNodeSet.set(path, mapPathToNodeSet.get(path) || /* @__PURE__ */ new Set());
+        (_a2 = mapPathToNodeSet.get(path)) == null ? void 0 : _a2.add(n);
+      });
+    }
+  }
+  static collectVariableDeclarationIdentifiers(node, callback) {
+    if (node.type !== "VariableDeclaration")
+      return;
+    const declarations = node.declarations;
+    for (const declaration of declarations) {
+      this.deepSearchParamsIdentifier(declaration.id, callback);
+    }
+  }
+  static collectDeclarationIdentifiers(node, callback) {
+    if (!this.EXPORT_DECLARATION_TYPES.includes(node.type))
+      return;
+    const id = node.id;
+    id && callback(id);
+  }
+  static collectImportDeclarationIdentifiers(node, callback) {
+    if (node.type !== "Program")
+      return;
+    const { body } = node;
+    Array.isArray(body) && body.forEach((node2) => {
+      if (node2.type === "ImportDeclaration") {
+        const specifiers = node2.specifiers;
+        for (const specifier of specifiers) {
+          const local = specifier.local;
+          callback(local);
+        }
+      }
+    });
+  }
+  static collectHoldingIds(node) {
+    const { holdingIds, holdingIdNameMap } = node._util;
+    if (this.FUNCTION_TYPES.includes(node.type)) {
+      const { params, id } = node;
+      if (Array.isArray(params) && params.length > 0) {
+        params.forEach((param) => this.deepSearchParamsIdentifier(param, (id2) => {
+          holdingIds.add(id2 || node);
+          id2._util.variableScope = [id2];
+          id2._util.holdingIdType = "Param";
+        }));
+      }
+      if (node.body && node.body.type === "BlockStatement") {
+        node.body._util.holdingIds.forEach((id2) => {
+          holdingIds.add(id2);
+        });
+      }
+    }
+    this.collectImportDeclarationIdentifiers(node, (id) => {
+      holdingIds.add(id);
+      id._util.variableScope = [id];
+      id._util.holdingIdType = "Import";
+    });
+    if (["BlockStatement", "Program"].includes(node.type)) {
+      const body = node.body;
+      Array.isArray(body) && body.forEach((bodyChild) => {
+        this.collectVariableDeclarationIdentifiers(bodyChild, (id) => {
+          holdingIds.add(id);
+          id._util.variableScope = [id];
+          id._util.holdingIdType = "Variable";
+        });
+        if (this.EXPORT_DECLARATION_TYPES.includes(bodyChild.type)) {
+          this.collectDeclarationIdentifiers(bodyChild, (id) => {
+            var _a, _b;
+            holdingIds.add(id);
+            (_b = (_a = id._util.parent) == null ? void 0 : _a._util.holdingIds) == null ? void 0 : _b.add(id);
+            id._util.variableScope = [id];
+            id._util.holdingIdType = node.type.replace("Declaration", "");
+          });
+        }
+        if (["ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(bodyChild.type)) {
+          const declaration = bodyChild.declaration;
+          if (declaration) {
+            if (declaration.type === "VariableDeclaration") {
+              this.collectVariableDeclarationIdentifiers(declaration, (id) => {
+                holdingIds.add(id);
+                id._util.variableScope = [id];
+                id._util.holdingIdType = "Variable";
+              });
+            } else {
+              this.collectDeclarationIdentifiers(declaration, (id) => {
+                var _a, _b;
+                holdingIds.add(id);
+                (_b = (_a = id._util.parent) == null ? void 0 : _a._util.holdingIds) == null ? void 0 : _b.add(id);
+                id._util.variableScope = [id];
+                id._util.holdingIdType = declaration.type.replace("Declaration", "");
+              });
+            }
+          }
+        }
+      });
+    }
+    ;
+    holdingIds.forEach((holdingId) => {
+      const holdingIdName = holdingId.name;
+      if (typeof holdingIdName !== "string")
+        return;
+      const nodeSetOfIdName = holdingIdNameMap.get(holdingIdName) || /* @__PURE__ */ new Set();
+      nodeSetOfIdName.add(holdingId);
+      holdingIdNameMap.set(holdingIdName, nodeSetOfIdName);
+    });
+  }
+  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, stopTravelCallback });
+  }
+  static _deepFirstTravel(node, visitedNodeSet, extra) {
+    visitedNodeSet.add(node);
+    const { filePath, depth, mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet, stopTravelCallback } = extra;
+    const _util = {
+      startLine: NaN,
+      endLine: NaN,
+      startColumn: NaN,
+      endColumn: NaN,
+      filePath,
+      parent: null,
+      parentProperty: "",
+      indexOfProperty: null,
+      ancestors: [],
+      nodeCollection: [],
+      children: [],
+      uuid: "",
+      variableScope: [],
+      dependenceIds: /* @__PURE__ */ new Set(),
+      dependenceIdsNoScope: /* @__PURE__ */ new Set(),
+      holdingIdType: null,
+      holdingIds: /* @__PURE__ */ new Set(),
+      holdingIdNameMap: /* @__PURE__ */ new Map(),
+      inject: /* @__PURE__ */ new Set(),
+      provide: /* @__PURE__ */ new Set(),
+      effectIds: /* @__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)) {
+        return;
+      }
+      const nodeValue = node[nodeKey];
+      if (visitedNodeSet.has(nodeValue) || !nodeValue) {
+        return;
+      }
+      if (this.isValidNodeCollect(nodeValue)) {
+        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, stopTravelCallback });
+        });
+        nodeCollection.push(...validNodeArray.map((n) => [n, ...n._util.nodeCollection]).flat());
+        children.push(...validNodeArray);
+        validNodeArray.forEach((v, index) => {
+          v._util.parentProperty = nodeKey;
+          v._util.indexOfProperty = index;
+        });
+      }
+    });
+    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("收集持有的 identifier 出错", e.message);
+    }
+    try {
+      this.collectDependenceIds(node);
+    } catch (e) {
+      console.error("收集使用的标识符号", e.message);
+    }
+    if (node.type === "Program") {
+      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("收集导入、导出成员信息报错", e.message);
+      }
+    }
+    try {
+      this.updateLoc(node, { mapUuidToNode, mapFileLineToNodeSet, mapPathToNodeSet });
+    } catch (e) {
+      console.error("updateLoc", e.message);
+    }
+    return node;
+  }
+};
+var AstUtil = _AstUtil;
+AstUtil.invalidNodeKey = import_SHARED_CONSTANTS.INVALID_NODE_KEY;
+AstUtil.EXPORT_DECLARATION_TYPES = import_SHARED_CONSTANTS.EXPORT_DECLARATION_TYPES;
+AstUtil.windowProperties = import_windowProperties.windowProperties;
+AstUtil.intrinsicElements = import_intrinsicElements.intrinsicElements;
+AstUtil.standardAttributes = import_intrinsicElements.standardAttributes;
+AstUtil.FUNCTION_TYPES = import_SHARED_CONSTANTS.FUNCTION_TYPES;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AstUtil
+});

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

@@ -28,7 +28,7 @@ export interface AstNode {
         dependenceIdsNoScope: Set<AstNode>;
         holdingIds: Set<AstNode>;
         holdingIdNameMap: Map<string, Set<AstNode>>;
-        holdingIdType: 'Import' | 'Variable' | 'Function' | 'Class' | 'Param' | null;
+        holdingIdType: 'Import' | 'Variable' | 'Function' | 'Class' | 'Param' | 'Enum' | 'Interface' | 'TypeAlias' | null;
         inject: Set<AstNode>;
         provide: Set<AstNode>;
         effectIds: Set<AstNode>;
@@ -52,7 +52,12 @@ export interface AstNode {
 }
 export default class AstUtil {
     static invalidNodeKey: string[];
-    static EXPORT_DECLARATION_TYPES: string[];
+    static EXPORT_DECLARATION_TYPES: readonly ["FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration", "ClassDeclaration"];
+    static windowProperties: string[];
+    static intrinsicElements: string[];
+    static standardAttributes: string[];
+    private static isValidNodeCollect;
+    private static isValidArrayNodeCollect;
     static getNodePath(node: AstNode): string;
     static getShortNodeMsg(node: AstNode, hideParentProperty?: boolean): string;
     static getAncestorsFromBirth(occupationId: AstNode, sourceId: AstNode): AstNode[];
@@ -88,11 +93,6 @@ export default class AstUtil {
     private static findIdOfVariable;
     private static _deepFindIdentifier;
     private static updateLoc;
-    private static isValidArrayNodeCollect;
-    private static isValidNodeCollect;
-    static windowProperties: string[];
-    static intrinsicElements: string[];
-    static standardAttributes: string[];
     static isUntrackedId(id: AstNode): boolean;
     static isPropertyOfGlobal(node: AstNode): boolean;
     static isIntrinsicElement(node: AstNode): boolean | "" | undefined;