adnbn 0.2.3 → 0.2.5

package/dist/cli/entrypoint/file/parsers/ClassParser.js

@@ -0,0 +1,137 @@
+import ts from "typescript";
+import AbstractParser from "./AbstractParser.js";
+import TypeResolver from "./TypeResolver.js";
+import SignatureBuilder from "./SignatureBuilder.js";
+import NodeFinder from "./NodeFinder.js";
+import JSDocParser from "./JSDocParser.js";
+import { shouldIncludeMember } from "./helpers/memberFilters.js";
+class ClassParser extends AbstractParser {
+  constructor(sourceFile, typeResolver, signatureBuilder, nodeFinder) {
+    super(sourceFile);
+    this.typeResolver = typeResolver;
+    this.signatureBuilder = signatureBuilder;
+    this.nodeFinder = nodeFinder;
+    this.jsDocParser = new JSDocParser();
+  }
+  /**
+   * Constructor for the ClassParser.
+   *
+   * @param sourceFile The source file to parse
+   * @param typeResolver The type resolver to use for resolving types
+   * @param signatureBuilder The signature builder to use for building signatures
+   * @param nodeFinder The node finder to use for finding nodes
+   */
+  jsDocParser;
+  /**
+   * Parses a class expression or declaration: collects public members,
+   * including inherited members from base classes.
+   *
+   * @param node The class expression or declaration to parse
+   * @returns A record of member signatures
+   */
+  parse(node) {
+    let members = {};
+    if (node.heritageClauses) {
+      for (const clause of node.heritageClauses) {
+        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+          for (const typeNode of clause.types) {
+            const expr = typeNode.expression;
+            if (ts.isIdentifier(expr)) {
+              Object.assign(members, this.parseFileClass(expr.text));
+            }
+          }
+        }
+      }
+    }
+    for (const member of node.members) {
+      if (ts.isConstructorDeclaration(member)) {
+        for (const param of member.parameters) {
+          const mods = ts.getCombinedModifierFlags(param);
+          if (mods & ts.ModifierFlags.Public) {
+            const name2 = ts.isIdentifier(param.name) ? param.name.text : param.name.getText();
+            if (!shouldIncludeMember(name2)) {
+              continue;
+            }
+            const type = param.type ? param.type.getText() : "any";
+            members[name2] = { kind: "property", type };
+          }
+        }
+        continue;
+      }
+      const flags = ts.getCombinedModifierFlags(member);
+      if (flags & (ts.ModifierFlags.Private | ts.ModifierFlags.Protected | ts.ModifierFlags.Static)) {
+        continue;
+      }
+      const name = member.name && ts.isIdentifier(member.name) ? member.name.text : member.name ? member.name.getText() : "";
+      if (!name) continue;
+      if (!shouldIncludeMember(name)) {
+        continue;
+      }
+      if (ts.isMethodDeclaration(member) || ts.isGetAccessorDeclaration(member)) {
+        members[name] = this.signatureBuilder.getMethodSignature(member);
+      } else if (ts.isPropertyDeclaration(member)) {
+        const jsDocType = this.jsDocParser.getJSDocType(member);
+        const tsType = member.type ? this.typeResolver.resolveTypeNode(member.type) : "any";
+        const type = jsDocType || tsType;
+        const optional = member.questionToken !== void 0;
+        members[name] = { kind: "property", type, optional };
+      }
+    }
+    return members;
+  }
+  /**
+   * Finds and parses a class by name in current or imported files.
+   *
+   * @param name The name of the class to find
+   * @returns A record of member signatures
+   */
+  parseFileClass(name) {
+    const decl = this.nodeFinder.findClassDeclaration(name);
+    if (decl) {
+      return this.parse(decl);
+    }
+    const importPath = this.sourceFile.getImports().get(name);
+    if (importPath) {
+      const parser = this.sourceFile.constructor.make(importPath);
+      const sf = parser.getSourceFile();
+      let found;
+      const find = (node) => {
+        var _a;
+        if (ts.isClassDeclaration(node) && ((_a = node.name) == null ? void 0 : _a.text) === name) {
+          found = node;
+        } else {
+          ts.forEachChild(node, find);
+        }
+      };
+      ts.forEachChild(sf, find);
+      if (found) {
+        const typeResolver = new TypeResolver(parser);
+        const nodeFinder = new NodeFinder(parser);
+        const signatureBuilder = new SignatureBuilder(typeResolver);
+        const classParser = new ClassParser(parser, typeResolver, signatureBuilder, nodeFinder);
+        return classParser.parse(found);
+      }
+      let defaultClass;
+      const findDefault = (node) => {
+        if (ts.isClassDeclaration(node) && node.modifiers && node.modifiers.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)) {
+          defaultClass = node;
+        } else {
+          ts.forEachChild(node, findDefault);
+        }
+      };
+      ts.forEachChild(sf, findDefault);
+      if (defaultClass) {
+        const typeResolver = new TypeResolver(parser);
+        const nodeFinder = new NodeFinder(parser);
+        const signatureBuilder = new SignatureBuilder(typeResolver);
+        const classParser = new ClassParser(parser, typeResolver, signatureBuilder, nodeFinder);
+        return classParser.parse(defaultClass);
+      }
+    }
+    return {};
+  }
+}
+export {
+  ClassParser as default
+};
+//# sourceMappingURL=ClassParser.js.map

package/dist/cli/entrypoint/file/parsers/ClassParser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/cli/entrypoint/file/parsers/ClassParser.ts"],"sourcesContent":["import ts from \"typescript\";\n\nimport SourceFile from \"../SourceFile\";\nimport AbstractParser from \"./AbstractParser\";\nimport TypeResolver from \"./TypeResolver\";\nimport SignatureBuilder from \"./SignatureBuilder\";\nimport NodeFinder from \"./NodeFinder\";\nimport JSDocParser from \"./JSDocParser\";\n\nimport {shouldIncludeMember} from \"./helpers/memberFilters\";\n\nimport {MemberSignature} from \"./types\";\n\n/**\n * Parses class expressions and declarations.\n */\nexport default class ClassParser extends AbstractParser {\n    /**\n     * Constructor for the ClassParser.\n     *\n     * @param sourceFile The source file to parse\n     * @param typeResolver The type resolver to use for resolving types\n     * @param signatureBuilder The signature builder to use for building signatures\n     * @param nodeFinder The node finder to use for finding nodes\n     */\n    private readonly jsDocParser: JSDocParser;\n\n    constructor(\n        sourceFile: SourceFile,\n        private readonly typeResolver: TypeResolver,\n        private readonly signatureBuilder: SignatureBuilder,\n        private readonly nodeFinder: NodeFinder\n    ) {\n        super(sourceFile);\n\n        this.jsDocParser = new JSDocParser();\n    }\n\n    /**\n     * Parses a class expression or declaration: collects public members,\n     * including inherited members from base classes.\n     *\n     * @param node The class expression or declaration to parse\n     * @returns A record of member signatures\n     */\n    public parse(node: ts.ClassExpression | ts.ClassDeclaration): Record<string, MemberSignature> {\n        let members: Record<string, MemberSignature> = {};\n        // inherit from base class(es)\n\n        if (node.heritageClauses) {\n            for (const clause of node.heritageClauses) {\n                if (clause.token === ts.SyntaxKind.ExtendsKeyword) {\n                    for (const typeNode of clause.types) {\n                        const expr = typeNode.expression;\n\n                        if (ts.isIdentifier(expr)) {\n                            Object.assign(members, this.parseFileClass(expr.text));\n                        }\n                    }\n                }\n            }\n        }\n\n        // own members\n        for (const member of node.members) {\n            // Parameter properties in constructor: include only when extracting a specific property\n            if (ts.isConstructorDeclaration(member)) {\n                // include public parameter properties: e.g. constructor(public foo: string)\n                for (const param of member.parameters) {\n                    const mods = ts.getCombinedModifierFlags(param);\n\n                    if (mods & ts.ModifierFlags.Public) {\n                        const name = ts.isIdentifier(param.name) ? param.name.text : param.name.getText();\n\n                        // Skip constructor parameters that start with underscore\n                        if (!shouldIncludeMember(name)) {\n                            continue;\n                        }\n\n                        const type = param.type ? param.type.getText() : \"any\";\n                        members[name] = {kind: \"property\", type};\n                    }\n                }\n\n                continue;\n            }\n\n            // only public instance members (skip private, protected, or static members)\n            const flags = ts.getCombinedModifierFlags(member);\n\n            if (flags & (ts.ModifierFlags.Private | ts.ModifierFlags.Protected | ts.ModifierFlags.Static)) {\n                continue;\n            }\n\n            // determine member name\n            const name =\n                member.name && ts.isIdentifier(member.name)\n                    ? member.name.text\n                    : member.name\n                      ? member.name.getText()\n                      : \"\";\n\n            if (!name) continue;\n\n            // Skip members that start with underscore\n            if (!shouldIncludeMember(name)) {\n                continue;\n            }\n\n            if (ts.isMethodDeclaration(member) || ts.isGetAccessorDeclaration(member)) {\n                members[name] = this.signatureBuilder.getMethodSignature(member as ts.MethodDeclaration);\n            } else if (ts.isPropertyDeclaration(member)) {\n                // Check for JSDoc @type annotation\n                const jsDocType = this.jsDocParser.getJSDocType(member);\n                const tsType = member.type ? this.typeResolver.resolveTypeNode(member.type) : \"any\";\n                const type = jsDocType || tsType;\n                const optional = member.questionToken !== undefined;\n                members[name] = {kind: \"property\", type, optional};\n            }\n        }\n\n        return members;\n    }\n\n    /**\n     * Finds and parses a class by name in current or imported files.\n     *\n     * @param name The name of the class to find\n     * @returns A record of member signatures\n     */\n    public parseFileClass(name: string): Record<string, MemberSignature> {\n        // current file\n        const decl = this.nodeFinder.findClassDeclaration(name);\n\n        if (decl) {\n            return this.parse(decl);\n        }\n\n        // imported file\n        const importPath = this.sourceFile.getImports().get(name);\n\n        if (importPath) {\n            const parser = (this.sourceFile.constructor as typeof SourceFile).make(importPath);\n            const sf = parser.getSourceFile();\n\n            // Try named class export\n            let found: ts.ClassDeclaration | undefined;\n            const find = (node: ts.Node) => {\n                if (ts.isClassDeclaration(node) && node.name?.text === name) {\n                    found = node;\n                } else {\n                    ts.forEachChild(node, find);\n                }\n            };\n\n            ts.forEachChild(sf, find);\n\n            if (found) {\n                // Create a new ClassParser for the imported file\n                const typeResolver = new TypeResolver(parser);\n                const nodeFinder = new NodeFinder(parser);\n                const signatureBuilder = new SignatureBuilder(typeResolver);\n                const classParser = new ClassParser(parser, typeResolver, signatureBuilder, nodeFinder);\n                return classParser.parse(found);\n            }\n\n            // Try default exported anonymous class\n            let defaultClass: ts.ClassDeclaration | undefined;\n\n            const findDefault = (node: ts.Node) => {\n                if (\n                    ts.isClassDeclaration(node) &&\n                    node.modifiers &&\n                    node.modifiers.some(m => m.kind === ts.SyntaxKind.DefaultKeyword)\n                ) {\n                    defaultClass = node;\n                } else {\n                    ts.forEachChild(node, findDefault);\n                }\n            };\n\n            ts.forEachChild(sf, findDefault);\n\n            if (defaultClass) {\n                // Create a new ClassParser for the imported file\n                const typeResolver = new TypeResolver(parser);\n                const nodeFinder = new NodeFinder(parser);\n                const signatureBuilder = new SignatureBuilder(typeResolver);\n                const classParser = new ClassParser(parser, typeResolver, signatureBuilder, nodeFinder);\n                return classParser.parse(defaultClass);\n            }\n        }\n\n        return {};\n    }\n}\n"],"mappings":"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","names":["name"]}

package/dist/cli/entrypoint/file/parsers/FunctionParser.d.ts

@@ -0,0 +1,40 @@
+import ts from 'typescript';
+import EntryFile from '../SourceFile.js';
+import AbstractParser from './AbstractParser.js';
+import NodeFinder from './NodeFinder.js';
+import ClassParser from './ClassParser.js';
+import ObjectParser from './ObjectParser.js';
+import { MemberSignature } from './types.js';
+import '../resolvers/ImportResolver.js';
+import '../resolvers/TsResolver.js';
+import '../types.js';
+import './TypeResolver.js';
+import './SignatureBuilder.js';
+
+/**
+ * Parses function expressions and arrow functions.
+ */
+declare class FunctionParser extends AbstractParser {
+    private readonly nodeFinder;
+    private readonly objectParser;
+    private readonly classParser;
+    /**
+     * Constructor for the FunctionParser.
+     *
+     * @param sourceFile The source file to parse
+     * @param nodeFinder The node finder to use for finding nodes
+     * @param objectParser The object parser to use for parsing object literals
+     * @param classParser The class parser to use for parsing classes
+     */
+    constructor(sourceFile: EntryFile, nodeFinder: NodeFinder, objectParser: ObjectParser, classParser: ClassParser);
+    /**
+     * Parses a function or arrow function: finds its return expression,
+     * then parses that if it's an object literal or a class instantiation.
+     *
+     * @param fn The function expression or arrow function to parse
+     * @returns A record of member signatures or undefined if the function cannot be parsed
+     */
+    parse(fn: ts.FunctionExpression | ts.ArrowFunction): Record<string, MemberSignature> | undefined;
+}
+
+export { FunctionParser as default };

package/dist/cli/entrypoint/file/parsers/FunctionParser.js

@@ -0,0 +1,76 @@
+import ts from "typescript";
+import AbstractParser from "./AbstractParser.js";
+class FunctionParser extends AbstractParser {
+  /**
+   * Constructor for the FunctionParser.
+   *
+   * @param sourceFile The source file to parse
+   * @param nodeFinder The node finder to use for finding nodes
+   * @param objectParser The object parser to use for parsing object literals
+   * @param classParser The class parser to use for parsing classes
+   */
+  constructor(sourceFile, nodeFinder, objectParser, classParser) {
+    super(sourceFile);
+    this.nodeFinder = nodeFinder;
+    this.objectParser = objectParser;
+    this.classParser = classParser;
+  }
+  /**
+   * Parses a function or arrow function: finds its return expression,
+   * then parses that if it's an object literal or a class instantiation.
+   *
+   * @param fn The function expression or arrow function to parse
+   * @returns A record of member signatures or undefined if the function cannot be parsed
+   */
+  parse(fn) {
+    let retExpr;
+    if (ts.isBlock(fn.body)) {
+      for (const stmt of fn.body.statements) {
+        if (ts.isReturnStatement(stmt) && stmt.expression) {
+          retExpr = stmt.expression;
+          break;
+        }
+      }
+    } else {
+      retExpr = fn.body;
+    }
+    if (!retExpr) return void 0;
+    const expr = this.unwrapExpression(retExpr);
+    if (ts.isObjectLiteralExpression(expr)) {
+      return this.objectParser.parse(expr);
+    }
+    if (ts.isNewExpression(expr)) {
+      const ctor = expr.expression;
+      if (ts.isIdentifier(ctor)) {
+        return this.classParser.parseFileClass(ctor.text);
+      }
+      if (ts.isClassExpression(ctor)) {
+        return this.classParser.parse(ctor);
+      }
+    }
+    if (ts.isIdentifier(retExpr)) {
+      const name = retExpr.text;
+      const decl = this.nodeFinder.findVariableDeclaration(name);
+      if (decl && decl.initializer) {
+        const init = decl.initializer;
+        if (ts.isObjectLiteralExpression(init)) {
+          return this.objectParser.parse(init);
+        }
+        if (ts.isNewExpression(init)) {
+          const ctor2 = init.expression;
+          if (ts.isIdentifier(ctor2)) {
+            return this.classParser.parseFileClass(ctor2.text);
+          }
+          if (ts.isClassExpression(ctor2)) {
+            return this.classParser.parse(ctor2);
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+}
+export {
+  FunctionParser as default
+};
+//# sourceMappingURL=FunctionParser.js.map

package/dist/cli/entrypoint/file/parsers/FunctionParser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/cli/entrypoint/file/parsers/FunctionParser.ts"],"sourcesContent":["import ts from \"typescript\";\n\nimport SourceFile from \"../SourceFile\";\nimport AbstractParser from \"./AbstractParser\";\nimport NodeFinder from \"./NodeFinder\";\nimport ClassParser from \"./ClassParser\";\nimport ObjectParser from \"./ObjectParser\";\n\nimport {MemberSignature} from \"./types\";\n\n/**\n * Parses function expressions and arrow functions.\n */\nexport default class FunctionParser extends AbstractParser {\n    /**\n     * Constructor for the FunctionParser.\n     *\n     * @param sourceFile The source file to parse\n     * @param nodeFinder The node finder to use for finding nodes\n     * @param objectParser The object parser to use for parsing object literals\n     * @param classParser The class parser to use for parsing classes\n     */\n    constructor(\n        sourceFile: SourceFile,\n        private readonly nodeFinder: NodeFinder,\n        private readonly objectParser: ObjectParser,\n        private readonly classParser: ClassParser\n    ) {\n        super(sourceFile);\n    }\n\n    /**\n     * Parses a function or arrow function: finds its return expression,\n     * then parses that if it's an object literal or a class instantiation.\n     *\n     * @param fn The function expression or arrow function to parse\n     * @returns A record of member signatures or undefined if the function cannot be parsed\n     */\n    public parse(fn: ts.FunctionExpression | ts.ArrowFunction): Record<string, MemberSignature> | undefined {\n        let retExpr: ts.Expression | undefined;\n\n        // block-bodied function\n        if (ts.isBlock(fn.body)) {\n            for (const stmt of fn.body.statements) {\n                if (ts.isReturnStatement(stmt) && stmt.expression) {\n                    retExpr = stmt.expression;\n                    break;\n                }\n            }\n        } else {\n            // concise arrow\n            retExpr = fn.body;\n        }\n\n        if (!retExpr) return undefined;\n\n        // unwrap assertions, parentheses, wrapper calls\n        const expr = this.unwrapExpression(retExpr);\n\n        // object literal return\n        if (ts.isObjectLiteralExpression(expr)) {\n            return this.objectParser.parse(expr);\n        }\n\n        // class instance return: new ClassName(...) or inline class expression\n        if (ts.isNewExpression(expr)) {\n            const ctor = expr.expression;\n\n            // external named class\n            if (ts.isIdentifier(ctor)) {\n                return this.classParser.parseFileClass(ctor.text);\n            }\n\n            // inline anonymous class expression\n            if (ts.isClassExpression(ctor)) {\n                return this.classParser.parse(ctor);\n            }\n        }\n\n        // variable reference return: identifier pointing to object or class instance\n        if (ts.isIdentifier(retExpr)) {\n            const name = retExpr.text;\n            const decl = this.nodeFinder.findVariableDeclaration(name);\n\n            if (decl && decl.initializer) {\n                const init = decl.initializer;\n\n                if (ts.isObjectLiteralExpression(init)) {\n                    return this.objectParser.parse(init);\n                }\n\n                if (ts.isNewExpression(init)) {\n                    const ctor2 = init.expression;\n\n                    if (ts.isIdentifier(ctor2)) {\n                        return this.classParser.parseFileClass(ctor2.text);\n                    }\n\n                    if (ts.isClassExpression(ctor2)) {\n                        return this.classParser.parse(ctor2);\n                    }\n                }\n            }\n        }\n\n        return undefined;\n    }\n}\n"],"mappings":"AAAA,OAAO,QAAQ;AAGf,OAAO,oBAAoB;AAU3B,MAAO,uBAAqC,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASvD,YACI,YACiB,YACA,cACA,aACnB;AACE,UAAM,UAAU;AAJC;AACA;AACA;AAAA,EAGrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,MAAM,IAA2F;AACpG,QAAI;AAGJ,QAAI,GAAG,QAAQ,GAAG,IAAI,GAAG;AACrB,iBAAW,QAAQ,GAAG,KAAK,YAAY;AACnC,YAAI,GAAG,kBAAkB,IAAI,KAAK,KAAK,YAAY;AAC/C,oBAAU,KAAK;AACf;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ,OAAO;AAEH,gBAAU,GAAG;AAAA,IACjB;AAEA,QAAI,CAAC,QAAS,QAAO;AAGrB,UAAM,OAAO,KAAK,iBAAiB,OAAO;AAG1C,QAAI,GAAG,0BAA0B,IAAI,GAAG;AACpC,aAAO,KAAK,aAAa,MAAM,IAAI;AAAA,IACvC;AAGA,QAAI,GAAG,gBAAgB,IAAI,GAAG;AAC1B,YAAM,OAAO,KAAK;AAGlB,UAAI,GAAG,aAAa,IAAI,GAAG;AACvB,eAAO,KAAK,YAAY,eAAe,KAAK,IAAI;AAAA,MACpD;AAGA,UAAI,GAAG,kBAAkB,IAAI,GAAG;AAC5B,eAAO,KAAK,YAAY,MAAM,IAAI;AAAA,MACtC;AAAA,IACJ;AAGA,QAAI,GAAG,aAAa,OAAO,GAAG;AAC1B,YAAM,OAAO,QAAQ;AACrB,YAAM,OAAO,KAAK,WAAW,wBAAwB,IAAI;AAEzD,UAAI,QAAQ,KAAK,aAAa;AAC1B,cAAM,OAAO,KAAK;AAElB,YAAI,GAAG,0BAA0B,IAAI,GAAG;AACpC,iBAAO,KAAK,aAAa,MAAM,IAAI;AAAA,QACvC;AAEA,YAAI,GAAG,gBAAgB,IAAI,GAAG;AAC1B,gBAAM,QAAQ,KAAK;AAEnB,cAAI,GAAG,aAAa,KAAK,GAAG;AACxB,mBAAO,KAAK,YAAY,eAAe,MAAM,IAAI;AAAA,UACrD;AAEA,cAAI,GAAG,kBAAkB,KAAK,GAAG;AAC7B,mBAAO,KAAK,YAAY,MAAM,KAAK;AAAA,UACvC;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAEA,WAAO;AAAA,EACX;AACJ;","names":[]}

package/dist/cli/entrypoint/file/parsers/JSDocParser.d.ts

@@ -0,0 +1,81 @@
+import ts from 'typescript';
+
+/**
+ * Parses JSDoc comments to extract type information.
+ */
+declare class JSDocParser {
+    /**
+     * Extracts a type from a JSDoc tag with @type annotation.
+     *
+     * @param node The node to extract JSDoc type from
+     * @returns The extracted type or undefined if no JSDoc type is found
+     */
+    getJSDocType(node: ts.Node): string | undefined;
+    /**
+     * Extracts parameter types from JSDoc @param annotations.
+     *
+     * @param node The function-like node to extract parameter types from
+     * @returns A map of parameter names to their JSDoc types
+     */
+    getJSDocParameterTypes(node: ts.SignatureDeclaration): Map<string, string>;
+    /**
+     * Extracts the return type from a JSDoc @returns annotation.
+     *
+     * @param node The function-like node to extract return type from
+     * @returns The extracted return type or undefined if no JSDoc return type is found
+     */
+    getJSDocReturnType(node: ts.SignatureDeclaration): string | undefined;
+    /**
+     * Gets all JSDoc tags for a node.
+     *
+     * @param node The node to get JSDoc tags for
+     * @returns An array of JSDoc tags
+     */
+    private getJSDocTags;
+    /**
+     * Extracts type parameters from JSDoc @template annotations.
+     *
+     * @param node The function-like node to extract type parameters from
+     * @returns An array of type parameter names
+     */
+    getJSDocTypeParameters(node: ts.SignatureDeclaration): string[];
+    /**
+     * Extracts custom type definitions from JSDoc @typedef annotations.
+     *
+     * @param node The node to extract custom type definitions from
+     * @returns A map of type names to their definitions
+     */
+    getJSDocTypeDefinitions(node: ts.Node): Map<string, string>;
+    /**
+     * Parses a JSDoc type expression into a string representation.
+     *
+     * @param typeExpression The JSDoc type expression to parse
+     * @returns The parsed type as a string
+     */
+    private parseJSDocTypeExpression;
+    /**
+     * Formats an object type string to match the expected format.
+     *
+     * @param objectType The object type string to format
+     * @returns The formatted object type string
+     */
+    private formatObjectType;
+    /**
+     * Formats nested types in a type string.
+     *
+     * @param typeString The type string to format
+     * @returns The formatted type string
+     */
+    private formatNestedTypes;
+    /**
+     * Adds a property to an object type string.
+     *
+     * @param objectType The object type string to add the property to
+     * @param propertyName The name of the property to add
+     * @param propertyType The type of the property to add
+     * @returns The updated object type string
+     */
+    private addPropertyToObjectType;
+}
+
+export { JSDocParser as default };

package/dist/cli/entrypoint/file/parsers/JSDocParser.js

@@ -0,0 +1,313 @@
+import ts from "typescript";
+class JSDocParser {
+  /**
+   * Extracts a type from a JSDoc tag with @type annotation.
+   *
+   * @param node The node to extract JSDoc type from
+   * @returns The extracted type or undefined if no JSDoc type is found
+   */
+  getJSDocType(node) {
+    const jsDocTags = this.getJSDocTags(node);
+    for (const tag of jsDocTags) {
+      if (ts.isJSDocTypeTag(tag) && tag.typeExpression) {
+        return this.parseJSDocTypeExpression(tag.typeExpression);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Extracts parameter types from JSDoc @param annotations.
+   *
+   * @param node The function-like node to extract parameter types from
+   * @returns A map of parameter names to their JSDoc types
+   */
+  getJSDocParameterTypes(node) {
+    const result = /* @__PURE__ */ new Map();
+    const nestedParams = /* @__PURE__ */ new Map();
+    const jsDocTags = this.getJSDocTags(node);
+    const typeDefinitions = this.getJSDocTypeDefinitions(node);
+    for (const tag of jsDocTags) {
+      if (ts.isJSDocParameterTag(tag) && tag.typeExpression && tag.name) {
+        let paramName = tag.name.getText();
+        const match = paramName.match(/(\w+)(?:\.(\w+))?/);
+        if (match) {
+          if (match[2]) {
+            const parentParam = match[1];
+            const childProp = match[2];
+            if (!nestedParams.has(parentParam)) {
+              nestedParams.set(parentParam, /* @__PURE__ */ new Map());
+            }
+            let paramType = this.parseJSDocTypeExpression(tag.typeExpression);
+            if (typeDefinitions.has(paramType)) {
+              paramType = typeDefinitions.get(paramType);
+            }
+            nestedParams.get(parentParam).set(childProp, paramType);
+          } else {
+            paramName = match[1];
+            if (!nestedParams.has(paramName)) {
+              let paramType = this.parseJSDocTypeExpression(tag.typeExpression);
+              if (typeDefinitions.has(paramType)) {
+                paramType = typeDefinitions.get(paramType);
+              }
+              result.set(paramName, paramType);
+            }
+          }
+        }
+      }
+    }
+    for (const [parentParam, childParams] of nestedParams.entries()) {
+      const properties = [];
+      for (const [childProp, childType] of childParams.entries()) {
+        properties.push(`${childProp}: ${childType}`);
+      }
+      result.set(parentParam, `{${properties.join("; ")};}`);
+    }
+    return result;
+  }
+  /**
+   * Extracts the return type from a JSDoc @returns annotation.
+   *
+   * @param node The function-like node to extract return type from
+   * @returns The extracted return type or undefined if no JSDoc return type is found
+   */
+  getJSDocReturnType(node) {
+    const jsDocTags = this.getJSDocTags(node);
+    for (const tag of jsDocTags) {
+      if (ts.isJSDocReturnTag(tag) && tag.typeExpression) {
+        return this.parseJSDocTypeExpression(tag.typeExpression);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Gets all JSDoc tags for a node.
+   *
+   * @param node The node to get JSDoc tags for
+   * @returns An array of JSDoc tags
+   */
+  getJSDocTags(node) {
+    const jsDocTags = [];
+    const jsDocComments = ts.getJSDocTags(node);
+    if (jsDocComments) {
+      jsDocTags.push(...jsDocComments);
+    }
+    return jsDocTags;
+  }
+  /**
+   * Extracts type parameters from JSDoc @template annotations.
+   *
+   * @param node The function-like node to extract type parameters from
+   * @returns An array of type parameter names
+   */
+  getJSDocTypeParameters(node) {
+    const result = [];
+    const jsDocTags = this.getJSDocTags(node);
+    for (const tag of jsDocTags) {
+      if (ts.isJSDocTemplateTag(tag) && tag.typeParameters) {
+        for (const typeParam of tag.typeParameters) {
+          if (typeParam.name) {
+            const typeName = typeParam.name.getText();
+            result.push(typeName);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Extracts custom type definitions from JSDoc @typedef annotations.
+   *
+   * @param node The node to extract custom type definitions from
+   * @returns A map of type names to their definitions
+   */
+  getJSDocTypeDefinitions(node) {
+    var _a;
+    const result = /* @__PURE__ */ new Map();
+    const jsDocTags = this.getJSDocTags(node);
+    for (const tag of jsDocTags) {
+      if (ts.isJSDocTypedefTag(tag) && tag.name && tag.typeExpression) {
+        const typeName = tag.name.getText();
+        const typeExpression = this.parseJSDocTypeExpression(tag.typeExpression);
+        result.set(typeName, typeExpression);
+      }
+    }
+    const typedefProperties = /* @__PURE__ */ new Map();
+    for (const tag of jsDocTags) {
+      if (ts.isJSDocPropertyTag(tag) && tag.name && tag.typeExpression) {
+        const comment = ((_a = tag.parent) == null ? void 0 : _a.getText()) || "";
+        const typedefMatch = comment.match(/@typedef\s+\{[^}]+\}\s+(\w+)/);
+        if (typedefMatch) {
+          const typedefName = typedefMatch[1];
+          const propName = tag.name.getText();
+          const propType = this.parseJSDocTypeExpression(tag.typeExpression);
+          const isOptional = tag.isBracketed || comment.includes(`[${propName}]`);
+          if (!typedefProperties.has(typedefName)) {
+            typedefProperties.set(typedefName, /* @__PURE__ */ new Map());
+          }
+          typedefProperties.get(typedefName).set(propName, `${propName}${isOptional ? "?" : ""}: ${propType}`);
+        }
+      }
+    }
+    for (const [typedefName, properties] of typedefProperties.entries()) {
+      const props = Array.from(properties.values());
+      if (props.length > 0) {
+        result.set(typedefName, `{ ${props.join("; ")}; }`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Parses a JSDoc type expression into a string representation.
+   *
+   * @param typeExpression The JSDoc type expression to parse
+   * @returns The parsed type as a string
+   */
+  parseJSDocTypeExpression(typeExpression) {
+    if (ts.isJSDocTypeLiteral(typeExpression)) {
+      if (typeExpression.jsDocPropertyTags && typeExpression.jsDocPropertyTags.length > 0) {
+        const props = typeExpression.jsDocPropertyTags.map((tag) => {
+          const name = tag.name.getText();
+          const type = tag.typeExpression ? this.parseJSDocTypeExpression(tag.typeExpression) : "any";
+          const optional = tag.isBracketed;
+          return `${name}${optional ? "?" : ""}: ${type}`;
+        });
+        return `{ ${props.join("; ")}; }`;
+      }
+      if (typeExpression.isArrayType) {
+        return "any[]";
+      }
+      return "any";
+    }
+    const typeNode = typeExpression.type;
+    if (!typeNode) {
+      return "any";
+    }
+    const text = typeNode.getText();
+    if (text === "*") {
+      return "any";
+    }
+    if (text.endsWith("[]")) {
+      return text;
+    }
+    if (text.startsWith("{") && text.endsWith("}")) {
+      return this.formatObjectType(text);
+    }
+    if (text.includes("|")) {
+      return text;
+    }
+    if (text.includes("function(")) {
+      return text;
+    }
+    if (text.includes("import(")) {
+      return text;
+    }
+    if (text.includes("<") && text.includes(">")) {
+      const typeName = text.substring(0, text.indexOf("<"));
+      const typeArgs = text.substring(text.indexOf("<") + 1, text.lastIndexOf(">"));
+      if (typeArgs.includes("{") && typeArgs.includes("}")) {
+        const formattedTypeArgs = this.formatNestedTypes(typeArgs);
+        return `${typeName}<${formattedTypeArgs}>`;
+      }
+      return `${typeName}<${typeArgs}>`;
+    }
+    return text;
+  }
+  /**
+   * Formats an object type string to match the expected format.
+   *
+   * @param objectType The object type string to format
+   * @returns The formatted object type string
+   */
+  formatObjectType(objectType) {
+    const content = objectType.substring(1, objectType.length - 1).trim();
+    const properties = [];
+    let depth = 0;
+    let currentProp = "";
+    for (let i = 0; i < content.length; i++) {
+      const char = content[i];
+      if (char === "{") {
+        depth++;
+        currentProp += char;
+      } else if (char === "}") {
+        depth--;
+        currentProp += char;
+      } else if (char === "," && depth === 0) {
+        properties.push(currentProp.trim());
+        currentProp = "";
+      } else {
+        currentProp += char;
+      }
+    }
+    if (currentProp.trim()) {
+      properties.push(currentProp.trim());
+    }
+    const formattedProperties = properties.map((prop) => {
+      const colonIndex = prop.indexOf(":");
+      if (colonIndex === -1) return prop;
+      const propName = prop.substring(0, colonIndex).trim();
+      let propType = prop.substring(colonIndex + 1).trim();
+      if (propType.startsWith("{") && propType.endsWith("}")) {
+        propType = this.formatObjectType(propType);
+      }
+      return `${propName}: ${propType}`;
+    });
+    return `{ ${formattedProperties.join("; ")}; }`;
+  }
+  /**
+   * Formats nested types in a type string.
+   *
+   * @param typeString The type string to format
+   * @returns The formatted type string
+   */
+  formatNestedTypes(typeString) {
+    if (typeString.includes("{") && typeString.includes("}")) {
+      let result = typeString;
+      let startIndex = result.indexOf("{");
+      while (startIndex !== -1) {
+        let depth = 1;
+        let endIndex = startIndex + 1;
+        while (depth > 0 && endIndex < result.length) {
+          if (result[endIndex] === "{") {
+            depth++;
+          } else if (result[endIndex] === "}") {
+            depth--;
+          }
+          endIndex++;
+        }
+        if (depth === 0) {
+          const objectType = result.substring(startIndex, endIndex);
+          const formattedObjectType = this.formatObjectType(objectType);
+          result = result.substring(0, startIndex) + formattedObjectType + result.substring(endIndex);
+          startIndex = result.indexOf("{", startIndex + formattedObjectType.length);
+        } else {
+          break;
+        }
+      }
+      return result;
+    }
+    return typeString;
+  }
+  /**
+   * Adds a property to an object type string.
+   *
+   * @param objectType The object type string to add the property to
+   * @param propertyName The name of the property to add
+   * @param propertyType The type of the property to add
+   * @returns The updated object type string
+   */
+  addPropertyToObjectType(objectType, propertyName, propertyType) {
+    const content = objectType.substring(1, objectType.length - 1).trim();
+    const properties = content ? content.split(";").map((p) => p.trim()).filter(Boolean) : [];
+    const propIndex = properties.findIndex((p) => p.startsWith(`${propertyName}:`));
+    if (propIndex >= 0) {
+      properties[propIndex] = `${propertyName}: ${propertyType}`;
+    } else {
+      properties.push(`${propertyName}: ${propertyType}`);
+    }
+    return `{ ${properties.join("; ")}; }`;
+  }
+}
+export {
+  JSDocParser as default
+};
+//# sourceMappingURL=JSDocParser.js.map