js-code-detector 0.0.48 → 0.0.51

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

@@ -0,0 +1,574 @@
+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 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";
+  }
+  static isValidArrayNodeCollect(astNode) {
+    return Array.isArray(astNode) && astNode.some((v) => typeof (v == null ? void 0 : v.type) === "string");
+  }
+  static collectEffectId(id) {
+  }
+  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) {
+      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 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;
+    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.includes(node) && 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;

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

@@ -24,7 +24,14 @@ __export(AstUtil_exports, {
 module.exports = __toCommonJS(AstUtil_exports);
 var import_windowProperties = require("./windowProperties");
 var import_intrinsicElements = require("./intrinsicElements");
+var import_SHARED_CONSTANTS = require("./SHARED_CONSTANTS");
 var _AstUtil = class {
+  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 getNodePath(node) {
     return [...node._util.ancestors, node].map((n) => n.type).join(":") + ":" + node.name;
   }
@@ -149,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);
     }
@@ -180,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 {
@@ -217,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) {
@@ -877,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());
@@ -895,12 +908,6 @@ var _AstUtil = class {
       });
     }
   }
-  static isValidArrayNodeCollect(astNode) {
-    return Array.isArray(astNode) && astNode.some((v) => typeof (v == null ? void 0 : v.type) === "string");
-  }
-  static isValidNodeCollect(astNode) {
-    return typeof (astNode == null ? void 0 : astNode.type) === "string";
-  }
   static isUntrackedId(id) {
     return id._util.variableScope.length === 0 && !this.isPropertyOfGlobal(id) && !this.isIntrinsicElement(id) && !this.isStandardAttribute(id);
   }
@@ -943,11 +950,8 @@ var _AstUtil = class {
   }
 };
 var AstUtil = _AstUtil;
-AstUtil.invalidNodeKey = [
-  "comments",
-  "tokens"
-];
-AstUtil.EXPORT_DECLARATION_TYPES = ["FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration", "ClassDeclaration"];
+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;

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

@@ -0,0 +1,3 @@
+export declare const INVALID_NODE_KEY: string[];
+export declare const EXPORT_DECLARATION_TYPES: readonly ["FunctionDeclaration", "TSEnumDeclaration", "TSInterfaceDeclaration", "TSTypeAliasDeclaration", "ClassDeclaration"];
+export declare const FUNCTION_TYPES: string[];