@easy-electron/ts-parser 1.0.1-alpha.1

package/dist/index.cjs

@@ -0,0 +1,743 @@
+'use strict';
+
+const ts = require('typescript');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const ts__default = /*#__PURE__*/_interopDefaultCompat(ts);
+
+class TsParser {
+  compilerOptions;
+  /**
+   * 创建解析器实例
+   * @param compilerOptions TypeScript 编译选项，不传则使用默认配置（ES2020 + ESNext + Bundler）
+   */
+  constructor(compilerOptions) {
+    this.compilerOptions = compilerOptions ?? {
+      target: ts__default.ScriptTarget.ES2020,
+      module: ts__default.ModuleKind.ESNext,
+      moduleResolution: ts__default.ModuleResolutionKind.Bundler,
+      strict: true
+    };
+  }
+  /**
+   * 解析 TS 文件，返回结构化的解析结果
+   * @param filePath 文件路径
+   * @param content 文件内容（可选，不传则通过 ts.sys 从文件系统读取）
+   * @returns 解析后的源文件结构
+   * @throws 当文件无法读取时抛出错误
+   */
+  parse(filePath, content) {
+    const sourceText = content ?? ts__default.sys.readFile(filePath);
+    if (sourceText === void 0) {
+      throw new Error(`Cannot read file: ${filePath}`);
+    }
+    const sourceFile = ts__default.createSourceFile(
+      filePath,
+      sourceText,
+      this.compilerOptions.target ?? ts__default.ScriptTarget.ES2020,
+      true,
+      ts__default.ScriptKind.TS
+    );
+    const result = {
+      filePath,
+      imports: [],
+      exports: [],
+      interfaces: [],
+      typeAliases: [],
+      enums: [],
+      classes: [],
+      functions: [],
+      variables: []
+    };
+    ts__default.forEachChild(sourceFile, (node) => this.visitNode(node, sourceFile, result));
+    return result;
+  }
+  /**
+   * 从源码字符串直接解析，无需文件路径
+   * @param source TypeScript 源码字符串
+   * @param fileName 虚拟文件名，默认 'anonymous.ts'
+   * @returns 解析后的源文件结构
+   */
+  parseSource(source, fileName = "anonymous.ts") {
+    return this.parse(fileName, source);
+  }
+  // ==================== 节点遍历 ====================
+  /**
+   * 遍历源文件的顶层节点，根据节点类型分发到对应的解析方法
+   * @param node 当前遍历的 AST 节点
+   * @param sourceFile 源文件对象（用于获取文本）
+   * @param result 解析结果容器，各解析方法会将结果写入其中
+   */
+  visitNode(node, sourceFile, result) {
+    if (ts__default.isImportDeclaration(node)) {
+      result.imports.push(this.parseImport(node, sourceFile));
+    } else if (ts__default.isExportDeclaration(node)) {
+      result.exports.push(this.parseExport(node, sourceFile));
+    } else if (ts__default.isInterfaceDeclaration(node)) {
+      result.interfaces.push(this.parseInterface(node, sourceFile));
+    } else if (ts__default.isTypeAliasDeclaration(node)) {
+      result.typeAliases.push(this.parseTypeAlias(node, sourceFile));
+    } else if (ts__default.isEnumDeclaration(node)) {
+      result.enums.push(this.parseEnum(node, sourceFile));
+    } else if (ts__default.isClassDeclaration(node)) {
+      result.classes.push(this.parseClass(node, sourceFile));
+    } else if (ts__default.isFunctionDeclaration(node)) {
+      result.functions.push(this.parseFunctionDeclaration(node, sourceFile));
+    } else if (ts__default.isVariableStatement(node)) {
+      this.parseVariableStatement(node, sourceFile, result);
+    } else if (ts__default.isExportAssignment(node)) {
+      result.defaultExport = this.parseDefaultExport(node, sourceFile);
+    }
+  }
+  // ==================== 导入解析 ====================
+  /**
+   * 解析 import 声明节点
+   *
+   * 支持以下导入形式：
+   * - 默认导入: `import Foo from 'module'`
+   * - 命名导入: `import { Foo, Bar as Baz } from 'module'`
+   * - 命名空间导入: `import * as ns from 'module'`
+   * - 类型导入: `import type { Foo } from 'module'`
+   * - 混合导入: `import Foo, { Bar } from 'module'`
+   *
+   * @param node import 声明 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 导入声明信息
+   */
+  parseImport(node, sourceFile) {
+    const moduleSpecifier = node.moduleSpecifier.text;
+    const isTypeOnly = node.importClause?.isTypeOnly ?? false;
+    let defaultImport;
+    const namedImports = [];
+    let namespaceImport;
+    if (node.importClause) {
+      if (node.importClause.name) {
+        defaultImport = node.importClause.name.text;
+      }
+      const bindings = node.importClause.namedBindings;
+      if (bindings) {
+        if (ts__default.isNamedImports(bindings)) {
+          for (const element of bindings.elements) {
+            namedImports.push({
+              name: (element.propertyName ?? element.name).text,
+              alias: element.propertyName ? element.name.text : void 0,
+              isTypeOnly: element.isTypeOnly
+            });
+          }
+        } else if (ts__default.isNamespaceImport(bindings)) {
+          namespaceImport = bindings.name.text;
+        }
+      }
+    }
+    return {
+      moduleSpecifier,
+      isTypeOnly,
+      defaultImport,
+      namedImports,
+      namespaceImport,
+      text: node.getText(sourceFile)
+    };
+  }
+  // ==================== 导出解析 ====================
+  /**
+   * 解析 export 声明节点（不含 export default）
+   *
+   * 支持以下导出形式：
+   * - 命名导出: `export { Foo, Bar as Baz }`
+   * - 重导出: `export { Foo } from 'module'`
+   * - 全量重导出: `export * from 'module'`
+   * - 类型导出: `export type { Foo }`
+   *
+   * @param node export 声明 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 导出声明信息
+   */
+  parseExport(node, sourceFile) {
+    const namedExports = [];
+    const isTypeOnly = node.isTypeOnly;
+    const moduleSpecifier = node.moduleSpecifier ? node.moduleSpecifier.text : void 0;
+    if (node.exportClause && ts__default.isNamedExports(node.exportClause)) {
+      for (const element of node.exportClause.elements) {
+        namedExports.push({
+          name: (element.propertyName ?? element.name).text,
+          alias: element.propertyName ? element.name.text : void 0,
+          isTypeOnly: element.isTypeOnly
+        });
+      }
+    }
+    return {
+      namedExports,
+      moduleSpecifier,
+      isTypeOnly,
+      isDefault: false,
+      text: node.getText(sourceFile)
+    };
+  }
+  // ==================== 接口解析 ====================
+  /**
+   * 解析接口声明节点
+   *
+   * 提取接口的名称、泛型参数、继承关系、成员属性及其类型、可选性、JSDoc 注释等。
+   *
+   * @param node 接口声明 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 接口信息
+   */
+  parseInterface(node, sourceFile) {
+    const typeParameters = this.getTypeParameters(node.typeParameters);
+    const extendsClause = [];
+    if (node.heritageClauses) {
+      for (const clause of node.heritageClauses) {
+        if (clause.token === ts__default.SyntaxKind.ExtendsKeyword) {
+          for (const type of clause.types) {
+            extendsClause.push(type.getText(sourceFile));
+          }
+        }
+      }
+    }
+    const members = [];
+    for (const member of node.members) {
+      if (ts__default.isPropertySignature(member) || ts__default.isMethodSignature(member)) {
+        members.push({
+          name: member.name?.getText(sourceFile) ?? "",
+          type: member.type?.getText(sourceFile) ?? "any",
+          isOptional: !!member.questionToken,
+          comment: this.getJsDoc(member, sourceFile)
+        });
+      }
+    }
+    return {
+      name: node.name.text,
+      isExported: this.hasExportModifier(node),
+      typeParameters,
+      extends: extendsClause,
+      members,
+      comment: this.getJsDoc(node, sourceFile),
+      text: node.getText(sourceFile)
+    };
+  }
+  // ==================== 类型别名解析 ====================
+  /**
+   * 解析类型别名声明节点
+   *
+   * 如: `type Foo<T> = Bar | Baz`
+   *
+   * @param node 类型别名声明 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 类型别名信息
+   */
+  parseTypeAlias(node, sourceFile) {
+    return {
+      name: node.name.text,
+      isExported: this.hasExportModifier(node),
+      typeParameters: this.getTypeParameters(node.typeParameters),
+      type: node.type.getText(sourceFile),
+      comment: this.getJsDoc(node, sourceFile),
+      text: node.getText(sourceFile)
+    };
+  }
+  // ==================== 枚举解析 ====================
+  /**
+   * 解析枚举声明节点
+   *
+   * 支持普通枚举和 const 枚举，提取每个成员的名称、初始值和注释。
+   *
+   * @param node 枚举声明 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 枚举信息
+   */
+  parseEnum(node, sourceFile) {
+    const members = node.members.map((member) => ({
+      name: member.name.getText(sourceFile),
+      value: member.initializer?.getText(sourceFile),
+      comment: this.getJsDoc(member, sourceFile)
+    }));
+    return {
+      name: node.name.text,
+      isExported: this.hasExportModifier(node),
+      isConst: node.modifiers?.some((m) => m.kind === ts__default.SyntaxKind.ConstKeyword) ?? false,
+      members,
+      comment: this.getJsDoc(node, sourceFile),
+      text: node.getText(sourceFile)
+    };
+  }
+  // ==================== 类解析 ====================
+  /**
+   * 解析类声明节点
+   *
+   * 提取类的名称、泛型参数、继承/实现关系、是否抽象类，
+   * 以及所有成员（属性、方法、构造函数、getter/setter）。
+   *
+   * @param node 类声明 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 类信息
+   */
+  parseClass(node, sourceFile) {
+    const typeParameters = this.getTypeParameters(node.typeParameters);
+    let extendsClause;
+    const implementsClause = [];
+    if (node.heritageClauses) {
+      for (const clause of node.heritageClauses) {
+        if (clause.token === ts__default.SyntaxKind.ExtendsKeyword) {
+          extendsClause = clause.types[0]?.getText(sourceFile);
+        } else if (clause.token === ts__default.SyntaxKind.ImplementsKeyword) {
+          for (const type of clause.types) {
+            implementsClause.push(type.getText(sourceFile));
+          }
+        }
+      }
+    }
+    const members = [];
+    for (const member of node.members) {
+      const parsed = this.parseClassMember(member, sourceFile);
+      if (parsed) members.push(parsed);
+    }
+    return {
+      name: node.name?.text ?? "",
+      isExported: this.hasExportModifier(node),
+      isAbstract: node.modifiers?.some((m) => m.kind === ts__default.SyntaxKind.AbstractKeyword) ?? false,
+      typeParameters,
+      extends: extendsClause,
+      implements: implementsClause,
+      members,
+      comment: this.getJsDoc(node, sourceFile),
+      text: node.getText(sourceFile)
+    };
+  }
+  /**
+   * 解析单个类成员节点
+   *
+   * 根据成员类型（构造函数、属性、方法、getter、setter）提取对应信息，
+   * 包括访问修饰符（public/private/protected）、static、readonly、abstract 等修饰符。
+   *
+   * @param member 类成员 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 类成员信息，无法识别的成员类型返回 null
+   */
+  parseClassMember(member, sourceFile) {
+    const accessibility = this.getAccessibility(member);
+    const modifiers = ts__default.canHaveModifiers(member) ? ts__default.getModifiers(member) : void 0;
+    const isStatic = modifiers?.some((m) => m.kind === ts__default.SyntaxKind.StaticKeyword) ?? false;
+    const isReadonly = modifiers?.some((m) => m.kind === ts__default.SyntaxKind.ReadonlyKeyword) ?? false;
+    const isAbstract = modifiers?.some((m) => m.kind === ts__default.SyntaxKind.AbstractKeyword) ?? false;
+    if (ts__default.isConstructorDeclaration(member)) {
+      return {
+        name: "constructor",
+        kind: "constructor",
+        accessibility,
+        isStatic: false,
+        isReadonly: false,
+        isAbstract: false,
+        isOptional: false,
+        parameters: this.parseParameters(member.parameters, sourceFile),
+        comment: this.getJsDoc(member, sourceFile)
+      };
+    }
+    if (ts__default.isPropertyDeclaration(member)) {
+      return {
+        name: member.name.getText(sourceFile),
+        kind: "property",
+        accessibility,
+        isStatic,
+        isReadonly,
+        isAbstract,
+        isOptional: !!member.questionToken,
+        type: member.type?.getText(sourceFile),
+        comment: this.getJsDoc(member, sourceFile)
+      };
+    }
+    if (ts__default.isMethodDeclaration(member)) {
+      return {
+        name: member.name.getText(sourceFile),
+        kind: "method",
+        accessibility,
+        isStatic,
+        isReadonly: false,
+        isAbstract,
+        isOptional: !!member.questionToken,
+        type: member.type?.getText(sourceFile),
+        parameters: this.parseParameters(member.parameters, sourceFile),
+        comment: this.getJsDoc(member, sourceFile)
+      };
+    }
+    if (ts__default.isGetAccessorDeclaration(member)) {
+      return {
+        name: member.name.getText(sourceFile),
+        kind: "getter",
+        accessibility,
+        isStatic,
+        isReadonly: false,
+        isAbstract,
+        isOptional: false,
+        type: member.type?.getText(sourceFile),
+        comment: this.getJsDoc(member, sourceFile)
+      };
+    }
+    if (ts__default.isSetAccessorDeclaration(member)) {
+      return {
+        name: member.name.getText(sourceFile),
+        kind: "setter",
+        accessibility,
+        isStatic,
+        isReadonly: false,
+        isAbstract,
+        isOptional: false,
+        parameters: this.parseParameters(member.parameters, sourceFile),
+        comment: this.getJsDoc(member, sourceFile)
+      };
+    }
+    return null;
+  }
+  // ==================== 函数解析 ====================
+  /**
+   * 解析函数声明节点
+   *
+   * 如: `function foo<T>(a: string): Promise<T> { ... }`
+   * 提取函数名、泛型参数、参数列表、返回类型、async/generator 标记等。
+   *
+   * @param node 函数声明 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 函数信息
+   */
+  parseFunctionDeclaration(node, sourceFile) {
+    return {
+      name: node.name?.text ?? "",
+      isExported: this.hasExportModifier(node),
+      isDefault: node.modifiers?.some((m) => m.kind === ts__default.SyntaxKind.DefaultKeyword) ?? false,
+      isAsync: node.modifiers?.some((m) => m.kind === ts__default.SyntaxKind.AsyncKeyword) ?? false,
+      isGenerator: !!node.asteriskToken,
+      typeParameters: this.getTypeParameters(node.typeParameters),
+      parameters: this.parseParameters(node.parameters, sourceFile),
+      returnType: node.type?.getText(sourceFile),
+      comment: this.getJsDoc(node, sourceFile),
+      text: node.getText(sourceFile)
+    };
+  }
+  // ==================== 变量解析 ====================
+  /**
+   * 解析变量声明语句
+   *
+   * 对每个变量声明进行分类处理：
+   * - 如果初始化表达式是箭头函数/函数表达式，归入 functions
+   * - 如果初始化表达式是函数调用，解析为 CallExpressionInfo
+   * - 其他情况作为普通变量处理
+   *
+   * @param node 变量声明语句 AST 节点
+   * @param sourceFile 源文件对象
+   * @param result 解析结果容器
+   */
+  parseVariableStatement(node, sourceFile, result) {
+    const isExported = this.hasExportModifier(node);
+    const flags = node.declarationList.flags;
+    const declarationKind = flags & ts__default.NodeFlags.Const ? "const" : flags & ts__default.NodeFlags.Let ? "let" : "var";
+    for (const decl of node.declarationList.declarations) {
+      const name = decl.name.getText(sourceFile);
+      const type = decl.type?.getText(sourceFile);
+      const comment = this.getJsDoc(node, sourceFile);
+      if (decl.initializer && this.isFunctionLike(decl.initializer)) {
+        result.functions.push(this.parseFunctionExpression(name, decl.initializer, isExported, sourceFile, comment));
+        continue;
+      }
+      let initializer;
+      if (decl.initializer) {
+        if (ts__default.isCallExpression(decl.initializer)) {
+          initializer = this.parseCallExpression(decl.initializer, sourceFile);
+        } else {
+          initializer = decl.initializer.getText(sourceFile);
+        }
+      }
+      result.variables.push({
+        name,
+        declarationKind,
+        isExported,
+        type,
+        initializer,
+        comment,
+        text: node.getText(sourceFile)
+      });
+    }
+  }
+  /**
+   * 判断节点是否为函数类表达式（箭头函数或函数表达式）
+   * @param node AST 节点
+   * @returns 是否为函数类表达式
+   */
+  isFunctionLike(node) {
+    return ts__default.isArrowFunction(node) || ts__default.isFunctionExpression(node);
+  }
+  /**
+   * 将箭头函数/函数表达式变量解析为 FunctionInfo
+   *
+   * 如: `const foo = async (a: string) => { ... }`
+   *
+   * @param name 变量名（即函数名）
+   * @param node 函数表达式 AST 节点
+   * @param isExported 是否导出
+   * @param sourceFile 源文件对象
+   * @param comment JSDoc 注释
+   * @returns 函数信息
+   */
+  parseFunctionExpression(name, node, isExported, sourceFile, comment) {
+    if (ts__default.isArrowFunction(node) || ts__default.isFunctionExpression(node)) {
+      return {
+        name,
+        isExported,
+        isDefault: false,
+        isAsync: node.modifiers?.some((m) => m.kind === ts__default.SyntaxKind.AsyncKeyword) ?? false,
+        isGenerator: ts__default.isFunctionExpression(node) ? !!node.asteriskToken : false,
+        typeParameters: this.getTypeParameters(node.typeParameters),
+        parameters: this.parseParameters(node.parameters, sourceFile),
+        returnType: node.type?.getText(sourceFile),
+        comment,
+        text: node.getText(sourceFile)
+      };
+    }
+    return {
+      name,
+      isExported,
+      isDefault: false,
+      isAsync: false,
+      isGenerator: false,
+      typeParameters: [],
+      parameters: [],
+      comment,
+      text: node.getText(sourceFile)
+    };
+  }
+  // ==================== 表达式解析 ====================
+  /**
+   * 解析函数调用表达式
+   *
+   * 如: `defineIpc('test', { ... })` 或 `createApp<Config>(options)`
+   * 提取被调用函数名、泛型参数、实参列表（递归解析每个参数）。
+   *
+   * @param node 函数调用表达式 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 函数调用表达式信息
+   */
+  parseCallExpression(node, sourceFile) {
+    const callee = node.expression.getText(sourceFile);
+    const typeArguments = node.typeArguments?.map((t) => t.getText(sourceFile)) ?? [];
+    const args = node.arguments.map((arg) => this.parseArgument(arg, sourceFile));
+    return {
+      callee,
+      typeArguments,
+      arguments: args,
+      text: node.getText(sourceFile)
+    };
+  }
+  /**
+   * 解析表达式参数，递归处理各种字面量和复合类型
+   *
+   * 支持的参数类型：
+   * - 字符串字面量 → kind: 'string'
+   * - 数字字面量 → kind: 'number'
+   * - 布尔字面量 → kind: 'boolean'
+   * - 对象字面量 → kind: 'object'（递归解析属性）
+   * - 数组字面量 → kind: 'array'（递归解析元素）
+   * - 函数/箭头函数 → kind: 'function'
+   * - 标识符引用 → kind: 'identifier'
+   * - 其他表达式 → kind: 'other'
+   *
+   * @param node 参数 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 参数信息
+   */
+  parseArgument(node, sourceFile) {
+    if (ts__default.isStringLiteral(node) || ts__default.isNoSubstitutionTemplateLiteral(node)) {
+      return { kind: "string", value: node.text, text: node.getText(sourceFile) };
+    }
+    if (ts__default.isNumericLiteral(node)) {
+      return { kind: "number", value: Number(node.text), text: node.getText(sourceFile) };
+    }
+    if (node.kind === ts__default.SyntaxKind.TrueKeyword) {
+      return { kind: "boolean", value: true, text: "true" };
+    }
+    if (node.kind === ts__default.SyntaxKind.FalseKeyword) {
+      return { kind: "boolean", value: false, text: "false" };
+    }
+    if (ts__default.isObjectLiteralExpression(node)) {
+      const properties = [];
+      for (const prop of node.properties) {
+        if (ts__default.isPropertyAssignment(prop)) {
+          properties.push({
+            name: prop.name.getText(sourceFile),
+            value: this.parseArgument(prop.initializer, sourceFile),
+            comment: this.getJsDoc(prop, sourceFile)
+          });
+        } else if (ts__default.isShorthandPropertyAssignment(prop)) {
+          properties.push({
+            name: prop.name.getText(sourceFile),
+            value: { kind: "identifier", value: prop.name.getText(sourceFile), text: prop.name.getText(sourceFile) },
+            comment: this.getJsDoc(prop, sourceFile)
+          });
+        } else if (ts__default.isMethodDeclaration(prop)) {
+          const funcInfo = this.parseMethodAsFunctionExpression(prop, sourceFile);
+          properties.push({
+            name: prop.name.getText(sourceFile),
+            value: { kind: "function", function: funcInfo, text: prop.getText(sourceFile) },
+            comment: this.getJsDoc(prop, sourceFile)
+          });
+        }
+      }
+      return { kind: "object", properties, text: node.getText(sourceFile) };
+    }
+    if (ts__default.isArrayLiteralExpression(node)) {
+      const elements = node.elements.map((el) => this.parseArgument(el, sourceFile));
+      return { kind: "array", elements, text: node.getText(sourceFile) };
+    }
+    if (ts__default.isArrowFunction(node) || ts__default.isFunctionExpression(node)) {
+      return {
+        kind: "function",
+        function: this.parseFunctionExpressionInfo(node, sourceFile),
+        text: node.getText(sourceFile)
+      };
+    }
+    if (ts__default.isIdentifier(node)) {
+      return { kind: "identifier", value: node.text, text: node.getText(sourceFile) };
+    }
+    return { kind: "other", text: node.getText(sourceFile) };
+  }
+  /**
+   * 将箭头函数/函数表达式节点解析为 FunctionExpressionInfo
+   * @param node 箭头函数或函数表达式 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 函数表达式信息（含参数、返回类型、函数体）
+   */
+  parseFunctionExpressionInfo(node, sourceFile) {
+    return {
+      isAsync: node.modifiers?.some((m) => m.kind === ts__default.SyntaxKind.AsyncKeyword) ?? false,
+      parameters: this.parseParameters(node.parameters, sourceFile),
+      returnType: node.type?.getText(sourceFile),
+      bodyText: node.body?.getText(sourceFile)
+    };
+  }
+  /**
+   * 将对象字面量中的方法声明解析为 FunctionExpressionInfo
+   *
+   * 如: `{ getData() { ... } }` 中的 getData 方法
+   *
+   * @param node 方法声明 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 函数表达式信息
+   */
+  parseMethodAsFunctionExpression(node, sourceFile) {
+    return {
+      isAsync: node.modifiers?.some((m) => m.kind === ts__default.SyntaxKind.AsyncKeyword) ?? false,
+      parameters: this.parseParameters(node.parameters, sourceFile),
+      returnType: node.type?.getText(sourceFile),
+      bodyText: node.body?.getText(sourceFile)
+    };
+  }
+  // ==================== 默认导出解析 ====================
+  /**
+   * 解析默认导出表达式（export default ...）
+   *
+   * 根据导出表达式的类型分类：
+   * - 函数调用: `export default defineIpc(...)` → kind: 'call'
+   * - 标识符: `export default router` → kind: 'identifier'
+   * - 对象字面量: `export default { ... }` → kind: 'object'
+   * - 其他表达式 → kind: 'other'
+   *
+   * @param node 默认导出赋值 AST 节点
+   * @param sourceFile 源文件对象
+   * @returns 默认导出信息
+   */
+  parseDefaultExport(node, sourceFile) {
+    const expr = node.expression;
+    if (ts__default.isCallExpression(expr)) {
+      return {
+        kind: "call",
+        call: this.parseCallExpression(expr, sourceFile),
+        text: node.getText(sourceFile)
+      };
+    }
+    if (ts__default.isIdentifier(expr)) {
+      return {
+        kind: "identifier",
+        identifier: expr.text,
+        text: node.getText(sourceFile)
+      };
+    }
+    if (ts__default.isObjectLiteralExpression(expr)) {
+      return {
+        kind: "object",
+        text: node.getText(sourceFile)
+      };
+    }
+    return {
+      kind: "other",
+      text: node.getText(sourceFile)
+    };
+  }
+  // ==================== 工具方法 ====================
+  /**
+   * 解析函数/方法的参数列表
+   * @param params 参数声明节点数组
+   * @param sourceFile 源文件对象
+   * @returns 参数信息列表（含名称、类型、可选性、剩余参数、默认值）
+   */
+  parseParameters(params, sourceFile) {
+    return params.map((param) => ({
+      name: param.name.getText(sourceFile),
+      type: param.type?.getText(sourceFile),
+      isOptional: !!param.questionToken,
+      isRest: !!param.dotDotDotToken,
+      defaultValue: param.initializer?.getText(sourceFile)
+    }));
+  }
+  /**
+   * 提取泛型参数列表的文本表示
+   * @param typeParams 泛型参数声明节点数组
+   * @returns 泛型参数文本列表，如 ['T', 'K extends string']
+   */
+  getTypeParameters(typeParams) {
+    return typeParams?.map((tp) => tp.getText()) ?? [];
+  }
+  /**
+   * 检查节点是否具有 export 修饰符
+   * @param node AST 节点
+   * @returns 是否导出
+   */
+  hasExportModifier(node) {
+    const modifiers = ts__default.canHaveModifiers(node) ? ts__default.getModifiers(node) : void 0;
+    return modifiers?.some((m) => m.kind === ts__default.SyntaxKind.ExportKeyword) ?? false;
+  }
+  /**
+   * 获取类成员的访问修饰符
+   * @param node 类成员 AST 节点
+   * @returns 访问修饰符（public/private/protected），无显式修饰符时返回 undefined
+   */
+  getAccessibility(node) {
+    const modifiers = ts__default.canHaveModifiers(node) ? ts__default.getModifiers(node) : void 0;
+    if (!modifiers) return void 0;
+    if (modifiers.some((m) => m.kind === ts__default.SyntaxKind.PrivateKeyword)) return "private";
+    if (modifiers.some((m) => m.kind === ts__default.SyntaxKind.ProtectedKeyword)) return "protected";
+    if (modifiers.some((m) => m.kind === ts__default.SyntaxKind.PublicKeyword)) return "public";
+    return void 0;
+  }
+  /**
+   * 提取节点的 JSDoc 注释
+   *
+   * 通过 ts.getLeadingCommentRanges 获取节点前的注释块，
+   * 只返回以 `/**` 开头的 JSDoc 风格注释，忽略普通行注释和块注释。
+   *
+   * @param node AST 节点
+   * @param sourceFile 源文件对象
+   * @returns JSDoc 注释文本（含 `/**` 和 `*​/`），无 JSDoc 时返回 undefined
+   */
+  getJsDoc(node, sourceFile) {
+    const fullText = sourceFile.getFullText();
+    const ranges = ts__default.getLeadingCommentRanges(fullText, node.getFullStart());
+    if (!ranges || ranges.length === 0) return void 0;
+    const lastRange = ranges[ranges.length - 1];
+    const commentText = fullText.slice(lastRange.pos, lastRange.end);
+    if (commentText.startsWith("/**")) {
+      return commentText;
+    }
+    return void 0;
+  }
+}
+
+exports.TsParser = TsParser;