adnbn 0.2.4 → 0.2.6

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/cli/entrypoint/file/parsers/JSDocParser.ts"],"sourcesContent":["import ts from \"typescript\";\n\n/**\n * Parses JSDoc comments to extract type information.\n */\nexport default class JSDocParser {\n    /**\n     * Extracts a type from a JSDoc tag with @type annotation.\n     *\n     * @param node The node to extract JSDoc type from\n     * @returns The extracted type or undefined if no JSDoc type is found\n     */\n    public getJSDocType(node: ts.Node): string | undefined {\n        const jsDocTags = this.getJSDocTags(node);\n\n        // Look for @type tag\n        for (const tag of jsDocTags) {\n            if (ts.isJSDocTypeTag(tag) && tag.typeExpression) {\n                return this.parseJSDocTypeExpression(tag.typeExpression);\n            }\n        }\n\n        return undefined;\n    }\n\n    /**\n     * Extracts parameter types from JSDoc @param annotations.\n     *\n     * @param node The function-like node to extract parameter types from\n     * @returns A map of parameter names to their JSDoc types\n     */\n    public getJSDocParameterTypes(node: ts.SignatureDeclaration): Map<string, string> {\n        const result = new Map<string, string>();\n        const nestedParams = new Map<string, Map<string, string>>();\n        const jsDocTags = this.getJSDocTags(node);\n\n        // Get custom type definitions\n        const typeDefinitions = this.getJSDocTypeDefinitions(node);\n\n        // First pass: collect all parameters and their types\n        for (const tag of jsDocTags) {\n            if (ts.isJSDocParameterTag(tag) && tag.typeExpression && tag.name) {\n                // Extract just the parameter name without any JSDoc comments\n                let paramName = tag.name.getText();\n\n                // Clean up the parameter name to remove any JSDoc comments\n                // This handles both regular parameters and nested parameters like options.method\n                const match = paramName.match(/(\\w+)(?:\\.(\\w+))?/);\n                if (match) {\n                    if (match[2]) {\n                        // This is a nested parameter like options.method\n                        const parentParam = match[1];\n                        const childProp = match[2];\n\n                        // Create or update the nested parameter map\n                        if (!nestedParams.has(parentParam)) {\n                            nestedParams.set(parentParam, new Map<string, string>());\n                        }\n\n                        let paramType = this.parseJSDocTypeExpression(tag.typeExpression);\n\n                        // Check if the parameter type is a custom type definition\n                        if (typeDefinitions.has(paramType)) {\n                            paramType = typeDefinitions.get(paramType)!;\n                        }\n\n                        nestedParams.get(parentParam)!.set(childProp, paramType);\n                    } else {\n                        // This is a regular parameter\n                        paramName = match[1];\n\n                        // If this parameter already has nested properties, don't override it\n                        if (!nestedParams.has(paramName)) {\n                            let paramType = this.parseJSDocTypeExpression(tag.typeExpression);\n\n                            // Check if the parameter type is a custom type definition\n                            if (typeDefinitions.has(paramType)) {\n                                paramType = typeDefinitions.get(paramType)!;\n                            }\n\n                            result.set(paramName, paramType);\n                        }\n                    }\n                }\n            }\n        }\n\n        // Second pass: build object types for nested parameters\n        for (const [parentParam, childParams] of nestedParams.entries()) {\n            const properties: string[] = [];\n\n            for (const [childProp, childType] of childParams.entries()) {\n                properties.push(`${childProp}: ${childType}`);\n            }\n\n            // Create the object type\n            result.set(parentParam, `{${properties.join(\"; \")};}`);\n        }\n\n        return result;\n    }\n\n    /**\n     * Extracts the return type from a JSDoc @returns annotation.\n     *\n     * @param node The function-like node to extract return type from\n     * @returns The extracted return type or undefined if no JSDoc return type is found\n     */\n    public getJSDocReturnType(node: ts.SignatureDeclaration): string | undefined {\n        const jsDocTags = this.getJSDocTags(node);\n\n        // Look for @returns tag\n        for (const tag of jsDocTags) {\n            if (ts.isJSDocReturnTag(tag) && tag.typeExpression) {\n                return this.parseJSDocTypeExpression(tag.typeExpression);\n            }\n        }\n\n        return undefined;\n    }\n\n    /**\n     * Gets all JSDoc tags for a node.\n     *\n     * @param node The node to get JSDoc tags for\n     * @returns An array of JSDoc tags\n     */\n    private getJSDocTags(node: ts.Node): ts.JSDocTag[] {\n        const jsDocTags: ts.JSDocTag[] = [];\n\n        // Get all JSDoc comments attached to the node\n        const jsDocComments = ts.getJSDocTags(node);\n        if (jsDocComments) {\n            jsDocTags.push(...jsDocComments);\n        }\n\n        return jsDocTags;\n    }\n\n    /**\n     * Extracts type parameters from JSDoc @template annotations.\n     *\n     * @param node The function-like node to extract type parameters from\n     * @returns An array of type parameter names\n     */\n    public getJSDocTypeParameters(node: ts.SignatureDeclaration): string[] {\n        const result: string[] = [];\n        const jsDocTags = this.getJSDocTags(node);\n\n        // Look for @template tags\n        for (const tag of jsDocTags) {\n            if (ts.isJSDocTemplateTag(tag) && tag.typeParameters) {\n                // Iterate through each type parameter and extract its name\n                for (const typeParam of tag.typeParameters) {\n                    if (typeParam.name) {\n                        const typeName = typeParam.name.getText();\n                        result.push(typeName);\n                    }\n                }\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * Extracts custom type definitions from JSDoc @typedef annotations.\n     *\n     * @param node The node to extract custom type definitions from\n     * @returns A map of type names to their definitions\n     */\n    public getJSDocTypeDefinitions(node: ts.Node): Map<string, string> {\n        const result = new Map<string, string>();\n        const jsDocTags = this.getJSDocTags(node);\n\n        // Look for @typedef tags\n        for (const tag of jsDocTags) {\n            if (ts.isJSDocTypedefTag(tag) && tag.name && tag.typeExpression) {\n                const typeName = tag.name.getText();\n                const typeExpression = this.parseJSDocTypeExpression(tag.typeExpression);\n\n                // Store the type definition\n                result.set(typeName, typeExpression);\n            }\n        }\n\n        // Look for @property tags to build object type definitions\n        const typedefProperties = new Map<string, Map<string, string>>();\n\n        for (const tag of jsDocTags) {\n            if (ts.isJSDocPropertyTag(tag) && tag.name && tag.typeExpression) {\n                // The property tag should be associated with a typedef\n                const comment = tag.parent?.getText() || \"\";\n                const typedefMatch = comment.match(/@typedef\\s+\\{[^}]+\\}\\s+(\\w+)/);\n\n                if (typedefMatch) {\n                    const typedefName = typedefMatch[1];\n                    const propName = tag.name.getText();\n                    const propType = this.parseJSDocTypeExpression(tag.typeExpression);\n                    const isOptional = tag.isBracketed || comment.includes(`[${propName}]`);\n\n                    // Create or update the property map for this typedef\n                    if (!typedefProperties.has(typedefName)) {\n                        typedefProperties.set(typedefName, new Map<string, string>());\n                    }\n\n                    // Add the property to the map\n                    typedefProperties\n                        .get(typedefName)!\n                        .set(propName, `${propName}${isOptional ? \"?\" : \"\"}: ${propType}`);\n                }\n            }\n        }\n\n        // Build object type definitions from properties\n        for (const [typedefName, properties] of typedefProperties.entries()) {\n            const props = Array.from(properties.values());\n            if (props.length > 0) {\n                result.set(typedefName, `{ ${props.join(\"; \")}; }`);\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * Parses a JSDoc type expression into a string representation.\n     *\n     * @param typeExpression The JSDoc type expression to parse\n     * @returns The parsed type as a string\n     */\n    private parseJSDocTypeExpression(typeExpression: ts.JSDocTypeExpression | ts.JSDocTypeLiteral): string {\n        // Handle JSDocTypeLiteral\n        if (ts.isJSDocTypeLiteral(typeExpression)) {\n            // For JSDocTypeLiteral, we need to build a type string from its properties\n            if (typeExpression.jsDocPropertyTags && typeExpression.jsDocPropertyTags.length > 0) {\n                const props = typeExpression.jsDocPropertyTags.map(tag => {\n                    const name = tag.name.getText();\n                    const type = tag.typeExpression ? this.parseJSDocTypeExpression(tag.typeExpression) : \"any\";\n                    const optional = tag.isBracketed;\n                    return `${name}${optional ? \"?\" : \"\"}: ${type}`;\n                });\n                return `{ ${props.join(\"; \")}; }`;\n            }\n            // If it's an array type, return array of any\n            if (typeExpression.isArrayType) {\n                return \"any[]\";\n            }\n            // Default to any for empty type literals\n            return \"any\";\n        }\n\n        // Extract the type from the JSDoc type expression (for JSDocTypeExpression)\n        const typeNode = typeExpression.type;\n\n        // Check if typeNode is undefined\n        if (!typeNode) {\n            return \"any\";\n        }\n\n        // Simple approach: extract the text directly from the JSDoc comment\n        // This handles most common JSDoc type formats\n        const text = typeNode.getText();\n\n        // Handle special cases for common JSDoc types\n        if (text === \"*\") {\n            return \"any\";\n        }\n\n        // Handle array types (e.g., string[])\n        if (text.endsWith(\"[]\")) {\n            return text;\n        }\n\n        // Handle object types (e.g., {foo: string, bar: number})\n        if (text.startsWith(\"{\") && text.endsWith(\"}\")) {\n            return this.formatObjectType(text);\n        }\n\n        // Handle union types (e.g., string|number)\n        if (text.includes(\"|\")) {\n            return text;\n        }\n\n        // Handle function types (e.g., function(string): number)\n        if (text.includes(\"function(\")) {\n            return text;\n        }\n\n        // Handle import types (e.g., import('somelib').SomeType)\n        if (text.includes(\"import(\")) {\n            return text;\n        }\n\n        // Handle generic types (e.g., Array<string>, Promise<Object>)\n        if (text.includes(\"<\") && text.includes(\">\")) {\n            // Extract the type name and arguments\n            const typeName = text.substring(0, text.indexOf(\"<\"));\n            const typeArgs = text.substring(text.indexOf(\"<\") + 1, text.lastIndexOf(\">\"));\n\n            // Check if the type arguments contain an object type\n            if (typeArgs.includes(\"{\") && typeArgs.includes(\"}\")) {\n                // Format the object type in the type arguments\n                const formattedTypeArgs = this.formatNestedTypes(typeArgs);\n                return `${typeName}<${formattedTypeArgs}>`;\n            }\n\n            return `${typeName}<${typeArgs}>`;\n        }\n\n        // For simple types, just return the text\n        return text;\n    }\n\n    /**\n     * Formats an object type string to match the expected format.\n     *\n     * @param objectType The object type string to format\n     * @returns The formatted object type string\n     */\n    private formatObjectType(objectType: string): string {\n        // Remove the braces and get the content\n        const content = objectType.substring(1, objectType.length - 1).trim();\n\n        // Split by commas, but only at the top level (not inside nested objects)\n        const properties: string[] = [];\n        let depth = 0;\n        let currentProp = \"\";\n\n        for (let i = 0; i < content.length; i++) {\n            const char = content[i];\n\n            if (char === \"{\") {\n                depth++;\n                currentProp += char;\n            } else if (char === \"}\") {\n                depth--;\n                currentProp += char;\n            } else if (char === \",\" && depth === 0) {\n                properties.push(currentProp.trim());\n                currentProp = \"\";\n            } else {\n                currentProp += char;\n            }\n        }\n\n        if (currentProp.trim()) {\n            properties.push(currentProp.trim());\n        }\n\n        // Process each property to handle nested objects\n        const formattedProperties = properties.map(prop => {\n            const colonIndex = prop.indexOf(\":\");\n            if (colonIndex === -1) return prop;\n\n            const propName = prop.substring(0, colonIndex).trim();\n            let propType = prop.substring(colonIndex + 1).trim();\n\n            // If the property type is an object, format it recursively\n            if (propType.startsWith(\"{\") && propType.endsWith(\"}\")) {\n                propType = this.formatObjectType(propType);\n            }\n\n            return `${propName}: ${propType}`;\n        });\n\n        // Join properties with semicolons\n        return `{ ${formattedProperties.join(\"; \")}; }`;\n    }\n\n    /**\n     * Formats nested types in a type string.\n     *\n     * @param typeString The type string to format\n     * @returns The formatted type string\n     */\n    private formatNestedTypes(typeString: string): string {\n        // Check if the type string contains an object type\n        if (typeString.includes(\"{\") && typeString.includes(\"}\")) {\n            // Find all object types in the type string\n            let result = typeString;\n            let startIndex = result.indexOf(\"{\");\n\n            while (startIndex !== -1) {\n                // Find the matching closing brace\n                let depth = 1;\n                let endIndex = startIndex + 1;\n\n                while (depth > 0 && endIndex < result.length) {\n                    if (result[endIndex] === \"{\") {\n                        depth++;\n                    } else if (result[endIndex] === \"}\") {\n                        depth--;\n                    }\n                    endIndex++;\n                }\n\n                if (depth === 0) {\n                    // Extract the object type\n                    const objectType = result.substring(startIndex, endIndex);\n                    // Format the object type\n                    const formattedObjectType = this.formatObjectType(objectType);\n                    // Replace the object type in the result\n                    result = result.substring(0, startIndex) + formattedObjectType + result.substring(endIndex);\n                    // Find the next object type\n                    startIndex = result.indexOf(\"{\", startIndex + formattedObjectType.length);\n                } else {\n                    // No matching closing brace found, break the loop\n                    break;\n                }\n            }\n\n            return result;\n        }\n\n        return typeString;\n    }\n\n    /**\n     * Adds a property to an object type string.\n     *\n     * @param objectType The object type string to add the property to\n     * @param propertyName The name of the property to add\n     * @param propertyType The type of the property to add\n     * @returns The updated object type string\n     */\n    private addPropertyToObjectType(objectType: string, propertyName: string, propertyType: string): string {\n        // Remove the braces and split by semicolons\n        const content = objectType.substring(1, objectType.length - 1).trim();\n        const properties = content\n            ? content\n                  .split(\";\")\n                  .map(p => p.trim())\n                  .filter(Boolean)\n            : [];\n\n        // Check if the property already exists\n        const propIndex = properties.findIndex(p => p.startsWith(`${propertyName}:`));\n\n        if (propIndex >= 0) {\n            // Update the existing property\n            properties[propIndex] = `${propertyName}: ${propertyType}`;\n        } else {\n            // Add the new property\n            properties.push(`${propertyName}: ${propertyType}`);\n        }\n\n        // Reconstruct the object type\n        return `{ ${properties.join(\"; \")}; }`;\n    }\n}\n"],"mappings":"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","names":[]}

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

@@ -0,0 +1,63 @@
+import ts from 'typescript';
+import EntryFile from '../SourceFile.js';
+import '../resolvers/ImportResolver.js';
+import '../resolvers/TsResolver.js';
+import '../types.js';
+
+/**
+ * Finds nodes in the TypeScript AST.
+ */
+declare class NodeFinder {
+    private sourceFile;
+    /**
+     * Constructor for the NodeFinder.
+     *
+     * @param sourceFile The source file to find nodes in
+     */
+    constructor(sourceFile: EntryFile);
+    /**
+     * Generic method to find a node of a specific type by name in the AST.
+     *
+     * @param predicate The predicate to match the node
+     * @param name The name to search for
+     * @returns The found node or undefined if not found
+     */
+    findNodeByName<T extends ts.Node>(predicate: (node: ts.Node, name: string) => node is T, name: string): T | undefined;
+    /**
+     * Searches the AST of this file for a class declaration by name.
+     *
+     * @param name The name of the class to find
+     * @returns The class declaration or undefined if not found
+     */
+    findClassDeclaration(name: string): ts.ClassDeclaration | undefined;
+    /**
+     * Searches the AST of this file for a type alias declaration by name.
+     *
+     * @param name The name of the type alias to find
+     * @returns The type alias declaration or undefined if not found
+     */
+    findTypeAliasDeclaration(name: string): ts.TypeAliasDeclaration | undefined;
+    /**
+     * Searches the AST of this file for an interface declaration by name.
+     *
+     * @param name The name of the interface to find
+     * @returns The interface declaration or undefined if not found
+     */
+    findInterfaceDeclaration(name: string): ts.InterfaceDeclaration | undefined;
+    /**
+     * Searches the AST of this file for a variable declaration by name.
+     *
+     * @param name The name of the variable to find
+     * @returns The variable declaration or undefined if not found
+     */
+    findVariableDeclaration(name: string): ts.VariableDeclaration | undefined;
+    /**
+     * Searches the AST of this file for an import equals declaration by name.
+     *
+     * @param name The name of the import equals declaration to find
+     * @returns The import equals declaration or undefined if not found
+     */
+    findImportEqualsDeclaration(name: string): ts.ImportEqualsDeclaration | undefined;
+}
+
+export { NodeFinder as default };

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

@@ -0,0 +1,98 @@
+import ts from "typescript";
+class NodeFinder {
+  /**
+   * Constructor for the NodeFinder.
+   *
+   * @param sourceFile The source file to find nodes in
+   */
+  constructor(sourceFile) {
+    this.sourceFile = sourceFile;
+  }
+  /**
+   * Generic method to find a node of a specific type by name in the AST.
+   *
+   * @param predicate The predicate to match the node
+   * @param name The name to search for
+   * @returns The found node or undefined if not found
+   */
+  findNodeByName(predicate, name) {
+    const sf = this.sourceFile.getSourceFile();
+    let found;
+    const visit = (node) => {
+      if (predicate(node, name)) {
+        found = node;
+      } else {
+        ts.forEachChild(node, visit);
+      }
+    };
+    ts.forEachChild(sf, visit);
+    return found;
+  }
+  /**
+   * Searches the AST of this file for a class declaration by name.
+   *
+   * @param name The name of the class to find
+   * @returns The class declaration or undefined if not found
+   */
+  findClassDeclaration(name) {
+    return this.findNodeByName(
+      (node, searchName) => {
+        var _a;
+        return ts.isClassDeclaration(node) && ((_a = node.name) == null ? void 0 : _a.text) === searchName;
+      },
+      name
+    );
+  }
+  /**
+   * Searches the AST of this file for a type alias declaration by name.
+   *
+   * @param name The name of the type alias to find
+   * @returns The type alias declaration or undefined if not found
+   */
+  findTypeAliasDeclaration(name) {
+    return this.findNodeByName(
+      (node, searchName) => ts.isTypeAliasDeclaration(node) && node.name.text === searchName,
+      name
+    );
+  }
+  /**
+   * Searches the AST of this file for an interface declaration by name.
+   *
+   * @param name The name of the interface to find
+   * @returns The interface declaration or undefined if not found
+   */
+  findInterfaceDeclaration(name) {
+    return this.findNodeByName(
+      (node, searchName) => ts.isInterfaceDeclaration(node) && node.name.text === searchName,
+      name
+    );
+  }
+  /**
+   * Searches the AST of this file for a variable declaration by name.
+   *
+   * @param name The name of the variable to find
+   * @returns The variable declaration or undefined if not found
+   */
+  findVariableDeclaration(name) {
+    return this.findNodeByName(
+      (node, searchName) => ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === searchName,
+      name
+    );
+  }
+  /**
+   * Searches the AST of this file for an import equals declaration by name.
+   *
+   * @param name The name of the import equals declaration to find
+   * @returns The import equals declaration or undefined if not found
+   */
+  findImportEqualsDeclaration(name) {
+    return this.findNodeByName(
+      (node, searchName) => ts.isImportEqualsDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === searchName,
+      name
+    );
+  }
+}
+export {
+  NodeFinder as default
+};
+//# sourceMappingURL=NodeFinder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/cli/entrypoint/file/parsers/NodeFinder.ts"],"sourcesContent":["import ts from \"typescript\";\nimport SourceFile from \"../SourceFile\";\n\n/**\n * Finds nodes in the TypeScript AST.\n */\nexport default class NodeFinder {\n    /**\n     * Constructor for the NodeFinder.\n     *\n     * @param sourceFile The source file to find nodes in\n     */\n    constructor(private sourceFile: SourceFile) {}\n\n    /**\n     * Generic method to find a node of a specific type by name in the AST.\n     *\n     * @param predicate The predicate to match the node\n     * @param name The name to search for\n     * @returns The found node or undefined if not found\n     */\n    public findNodeByName<T extends ts.Node>(\n        predicate: (node: ts.Node, name: string) => node is T,\n        name: string\n    ): T | undefined {\n        const sf = this.sourceFile.getSourceFile();\n        let found: T | undefined;\n\n        const visit = (node: ts.Node) => {\n            if (predicate(node, name)) {\n                found = node;\n            } else {\n                ts.forEachChild(node, visit);\n            }\n        };\n\n        ts.forEachChild(sf, visit);\n        return found;\n    }\n\n    /**\n     * Searches the AST of this file for a class declaration by name.\n     *\n     * @param name The name of the class to find\n     * @returns The class declaration or undefined if not found\n     */\n    public findClassDeclaration(name: string): ts.ClassDeclaration | undefined {\n        return this.findNodeByName<ts.ClassDeclaration>(\n            (node, searchName): node is ts.ClassDeclaration =>\n                ts.isClassDeclaration(node) && node.name?.text === searchName,\n            name\n        );\n    }\n\n    /**\n     * Searches the AST of this file for a type alias declaration by name.\n     *\n     * @param name The name of the type alias to find\n     * @returns The type alias declaration or undefined if not found\n     */\n    public findTypeAliasDeclaration(name: string): ts.TypeAliasDeclaration | undefined {\n        return this.findNodeByName<ts.TypeAliasDeclaration>(\n            (node, searchName): node is ts.TypeAliasDeclaration =>\n                ts.isTypeAliasDeclaration(node) && node.name.text === searchName,\n            name\n        );\n    }\n\n    /**\n     * Searches the AST of this file for an interface declaration by name.\n     *\n     * @param name The name of the interface to find\n     * @returns The interface declaration or undefined if not found\n     */\n    public findInterfaceDeclaration(name: string): ts.InterfaceDeclaration | undefined {\n        return this.findNodeByName<ts.InterfaceDeclaration>(\n            (node, searchName): node is ts.InterfaceDeclaration =>\n                ts.isInterfaceDeclaration(node) && node.name.text === searchName,\n            name\n        );\n    }\n\n    /**\n     * Searches the AST of this file for a variable declaration by name.\n     *\n     * @param name The name of the variable to find\n     * @returns The variable declaration or undefined if not found\n     */\n    public findVariableDeclaration(name: string): ts.VariableDeclaration | undefined {\n        return this.findNodeByName<ts.VariableDeclaration>(\n            (node, searchName): node is ts.VariableDeclaration =>\n                ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === searchName,\n            name\n        );\n    }\n\n    /**\n     * Searches the AST of this file for an import equals declaration by name.\n     *\n     * @param name The name of the import equals declaration to find\n     * @returns The import equals declaration or undefined if not found\n     */\n    public findImportEqualsDeclaration(name: string): ts.ImportEqualsDeclaration | undefined {\n        return this.findNodeByName<ts.ImportEqualsDeclaration>(\n            (node, searchName): node is ts.ImportEqualsDeclaration =>\n                ts.isImportEqualsDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === searchName,\n            name\n        );\n    }\n}\n"],"mappings":"AAAA,OAAO,QAAQ;AAMf,MAAO,WAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM5B,YAAoB,YAAwB;AAAxB;AAAA,EAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAStC,eACH,WACA,MACa;AACb,UAAM,KAAK,KAAK,WAAW,cAAc;AACzC,QAAI;AAEJ,UAAM,QAAQ,CAAC,SAAkB;AAC7B,UAAI,UAAU,MAAM,IAAI,GAAG;AACvB,gBAAQ;AAAA,MACZ,OAAO;AACH,WAAG,aAAa,MAAM,KAAK;AAAA,MAC/B;AAAA,IACJ;AAEA,OAAG,aAAa,IAAI,KAAK;AACzB,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,qBAAqB,MAA+C;AACvE,WAAO,KAAK;AAAA,MACR,CAAC,MAAM,eAAyC;AAhD5D;AAiDgB,kBAAG,mBAAmB,IAAI,OAAK,UAAK,SAAL,mBAAW,UAAS;AAAA;AAAA,MACvD;AAAA,IACJ;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,yBAAyB,MAAmD;AAC/E,WAAO,KAAK;AAAA,MACR,CAAC,MAAM,eACH,GAAG,uBAAuB,IAAI,KAAK,KAAK,KAAK,SAAS;AAAA,MAC1D;AAAA,IACJ;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,yBAAyB,MAAmD;AAC/E,WAAO,KAAK;AAAA,MACR,CAAC,MAAM,eACH,GAAG,uBAAuB,IAAI,KAAK,KAAK,KAAK,SAAS;AAAA,MAC1D;AAAA,IACJ;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,wBAAwB,MAAkD;AAC7E,WAAO,KAAK;AAAA,MACR,CAAC,MAAM,eACH,GAAG,sBAAsB,IAAI,KAAK,GAAG,aAAa,KAAK,IAAI,KAAK,KAAK,KAAK,SAAS;AAAA,MACvF;AAAA,IACJ;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,4BAA4B,MAAsD;AACrF,WAAO,KAAK;AAAA,MACR,CAAC,MAAM,eACH,GAAG,0BAA0B,IAAI,KAAK,GAAG,aAAa,KAAK,IAAI,KAAK,KAAK,KAAK,SAAS;AAAA,MAC3F;AAAA,IACJ;AAAA,EACJ;AACJ;","names":[]}

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

@@ -0,0 +1,41 @@
+import ts from 'typescript';
+import EntryFile from '../SourceFile.js';
+import AbstractParser from './AbstractParser.js';
+import SignatureBuilder from './SignatureBuilder.js';
+import { MemberSignature } from './types.js';
+import '../resolvers/ImportResolver.js';
+import '../resolvers/TsResolver.js';
+import '../types.js';
+import './TypeResolver.js';
+import './NodeFinder.js';
+
+/**
+ * Parses object literal expressions.
+ */
+declare class ObjectParser extends AbstractParser {
+    private readonly signatureBuilder;
+    /**
+     * Constructor for the ObjectParser.
+     *
+     * @param sourceFile The source file to parse
+     * @param signatureBuilder The signature builder to use for building signatures
+     */
+    private readonly jsDocParser;
+    constructor(sourceFile: EntryFile, signatureBuilder: SignatureBuilder);
+    /**
+     * Parses an object literal: each property becomes a member signature.
+     *
+     * @param obj The object literal expression to parse
+     * @returns A record of member signatures
+     */
+    parse(obj: ts.ObjectLiteralExpression): Record<string, MemberSignature>;
+    /**
+     * Infers a type string from an expression.
+     *
+     * @param expr The expression to infer a type from
+     * @returns The inferred type as a string
+     */
+    inferTypeFromExpression(expr: ts.Expression): string;
+}
+
+export { ObjectParser as default };

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

@@ -0,0 +1,96 @@
+import ts from "typescript";
+import _ from "lodash";
+import AbstractParser from "./AbstractParser.js";
+import JSDocParser from "./JSDocParser.js";
+import { shouldIncludeMember } from "./helpers/memberFilters.js";
+class ObjectParser extends AbstractParser {
+  constructor(sourceFile, signatureBuilder) {
+    super(sourceFile);
+    this.signatureBuilder = signatureBuilder;
+    this.jsDocParser = new JSDocParser();
+  }
+  /**
+   * Constructor for the ObjectParser.
+   *
+   * @param sourceFile The source file to parse
+   * @param signatureBuilder The signature builder to use for building signatures
+   */
+  jsDocParser;
+  /**
+   * Parses an object literal: each property becomes a member signature.
+   *
+   * @param obj The object literal expression to parse
+   * @returns A record of member signatures
+   */
+  parse(obj) {
+    const result = {};
+    for (const prop of obj.properties) {
+      const key = this.getName(prop.name ?? prop);
+      if (!shouldIncludeMember(key)) {
+        continue;
+      }
+      if (ts.isPropertyAssignment(prop)) {
+        const init = prop.initializer;
+        if (ts.isFunctionExpression(init) || ts.isArrowFunction(init)) {
+          result[key] = this.signatureBuilder.getMethodSignature(init);
+        } else {
+          const jsDocType = this.jsDocParser.getJSDocType(prop);
+          const tsType = this.inferTypeFromExpression(init);
+          result[key] = {
+            kind: "property",
+            type: jsDocType || tsType
+          };
+        }
+      } else if (ts.isMethodDeclaration(prop)) {
+        result[key] = this.signatureBuilder.getMethodSignature(prop);
+      } else if (ts.isShorthandPropertyAssignment(prop)) {
+        const name = prop.name.text;
+        const variable = this.sourceFile.getVariables().get(name);
+        const val = variable ? variable.value : void 0;
+        let type = "any";
+        if (!_.isUndefined(val)) {
+          if (_.isString(val)) {
+            type = "string";
+          } else if (_.isNumber(val)) {
+            type = "number";
+          } else if (_.isBoolean(val)) {
+            type = "boolean";
+          } else if (_.isArray(val)) {
+            type = "array";
+          } else if (_.isPlainObject(val)) {
+            type = "object";
+          }
+        }
+        result[key] = { kind: "property", type };
+      }
+    }
+    return result;
+  }
+  /**
+   * Infers a type string from an expression.
+   *
+   * @param expr The expression to infer a type from
+   * @returns The inferred type as a string
+   */
+  inferTypeFromExpression(expr) {
+    const val = this.sourceFile.parseNode(expr);
+    switch (typeof val) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "object":
+        if (val === null) return "null";
+        if (_.isArray(val)) return "array";
+        return "object";
+      default:
+        return "any";
+    }
+  }
+}
+export {
+  ObjectParser as default
+};
+//# sourceMappingURL=ObjectParser.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/cli/entrypoint/file/parsers/ObjectParser.ts"],"sourcesContent":["import ts from \"typescript\";\nimport _ from \"lodash\";\n\nimport SourceFile from \"../SourceFile\";\nimport AbstractParser from \"./AbstractParser\";\nimport SignatureBuilder from \"./SignatureBuilder\";\nimport JSDocParser from \"./JSDocParser\";\n\nimport {shouldIncludeMember} from \"./helpers/memberFilters\";\n\nimport {MemberSignature} from \"./types\";\n\n/**\n * Parses object literal expressions.\n */\nexport default class ObjectParser extends AbstractParser {\n    /**\n     * Constructor for the ObjectParser.\n     *\n     * @param sourceFile The source file to parse\n     * @param signatureBuilder The signature builder to use for building signatures\n     */\n    private readonly jsDocParser: JSDocParser;\n\n    constructor(\n        sourceFile: SourceFile,\n        private readonly signatureBuilder: SignatureBuilder\n    ) {\n        super(sourceFile);\n\n        this.jsDocParser = new JSDocParser();\n    }\n\n    /**\n     * Parses an object literal: each property becomes a member signature.\n     *\n     * @param obj The object literal expression to parse\n     * @returns A record of member signatures\n     */\n    public parse(obj: ts.ObjectLiteralExpression): Record<string, MemberSignature> {\n        const result: Record<string, MemberSignature> = {};\n\n        for (const prop of obj.properties) {\n            // key name helper\n            const key = this.getName(prop.name ?? prop);\n\n            // Skip members that start with underscore\n            if (!shouldIncludeMember(key)) {\n                continue;\n            }\n\n            if (ts.isPropertyAssignment(prop)) {\n                const init = prop.initializer;\n\n                if (ts.isFunctionExpression(init) || ts.isArrowFunction(init)) {\n                    result[key] = this.signatureBuilder.getMethodSignature(init);\n                } else {\n                    // Check for JSDoc @type annotation\n                    const jsDocType = this.jsDocParser.getJSDocType(prop);\n                    const tsType = this.inferTypeFromExpression(init);\n\n                    result[key] = {\n                        kind: \"property\",\n                        type: jsDocType || tsType,\n                    };\n                }\n            } else if (ts.isMethodDeclaration(prop)) {\n                result[key] = this.signatureBuilder.getMethodSignature(prop);\n            } else if (ts.isShorthandPropertyAssignment(prop)) {\n                const name = prop.name.text;\n                const variable = this.sourceFile.getVariables().get(name);\n                const val = variable ? variable.value : undefined;\n\n                let type = \"any\";\n\n                if (!_.isUndefined(val)) {\n                    if (_.isString(val)) {\n                        type = \"string\";\n                    } else if (_.isNumber(val)) {\n                        type = \"number\";\n                    } else if (_.isBoolean(val)) {\n                        type = \"boolean\";\n                    } else if (_.isArray(val)) {\n                        type = \"array\";\n                    } else if (_.isPlainObject(val)) {\n                        type = \"object\";\n                    }\n                }\n\n                result[key] = {kind: \"property\", type};\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * Infers a type string from an expression.\n     *\n     * @param expr The expression to infer a type from\n     * @returns The inferred type as a string\n     */\n    public inferTypeFromExpression(expr: ts.Expression): string {\n        const val = this.sourceFile.parseNode(expr);\n\n        switch (typeof val) {\n            case \"string\":\n                return \"string\";\n            case \"number\":\n                return \"number\";\n            case \"boolean\":\n                return \"boolean\";\n            case \"object\":\n                if (val === null) return \"null\";\n                if (_.isArray(val)) return \"array\";\n                return \"object\";\n            default:\n                return \"any\";\n        }\n    }\n}\n"],"mappings":"AAAA,OAAO,QAAQ;AACf,OAAO,OAAO;AAGd,OAAO,oBAAoB;AAE3B,OAAO,iBAAiB;AAExB,SAAQ,2BAA0B;AAOlC,MAAO,qBAAmC,eAAe;AAAA,EASrD,YACI,YACiB,kBACnB;AACE,UAAM,UAAU;AAFC;AAIjB,SAAK,cAAc,IAAI,YAAY;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EATiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBV,MAAM,KAAkE;AAC3E,UAAM,SAA0C,CAAC;AAEjD,eAAW,QAAQ,IAAI,YAAY;AAE/B,YAAM,MAAM,KAAK,QAAQ,KAAK,QAAQ,IAAI;AAG1C,UAAI,CAAC,oBAAoB,GAAG,GAAG;AAC3B;AAAA,MACJ;AAEA,UAAI,GAAG,qBAAqB,IAAI,GAAG;AAC/B,cAAM,OAAO,KAAK;AAElB,YAAI,GAAG,qBAAqB,IAAI,KAAK,GAAG,gBAAgB,IAAI,GAAG;AAC3D,iBAAO,GAAG,IAAI,KAAK,iBAAiB,mBAAmB,IAAI;AAAA,QAC/D,OAAO;AAEH,gBAAM,YAAY,KAAK,YAAY,aAAa,IAAI;AACpD,gBAAM,SAAS,KAAK,wBAAwB,IAAI;AAEhD,iBAAO,GAAG,IAAI;AAAA,YACV,MAAM;AAAA,YACN,MAAM,aAAa;AAAA,UACvB;AAAA,QACJ;AAAA,MACJ,WAAW,GAAG,oBAAoB,IAAI,GAAG;AACrC,eAAO,GAAG,IAAI,KAAK,iBAAiB,mBAAmB,IAAI;AAAA,MAC/D,WAAW,GAAG,8BAA8B,IAAI,GAAG;AAC/C,cAAM,OAAO,KAAK,KAAK;AACvB,cAAM,WAAW,KAAK,WAAW,aAAa,EAAE,IAAI,IAAI;AACxD,cAAM,MAAM,WAAW,SAAS,QAAQ;AAExC,YAAI,OAAO;AAEX,YAAI,CAAC,EAAE,YAAY,GAAG,GAAG;AACrB,cAAI,EAAE,SAAS,GAAG,GAAG;AACjB,mBAAO;AAAA,UACX,WAAW,EAAE,SAAS,GAAG,GAAG;AACxB,mBAAO;AAAA,UACX,WAAW,EAAE,UAAU,GAAG,GAAG;AACzB,mBAAO;AAAA,UACX,WAAW,EAAE,QAAQ,GAAG,GAAG;AACvB,mBAAO;AAAA,UACX,WAAW,EAAE,cAAc,GAAG,GAAG;AAC7B,mBAAO;AAAA,UACX;AAAA,QACJ;AAEA,eAAO,GAAG,IAAI,EAAC,MAAM,YAAY,KAAI;AAAA,MACzC;AAAA,IACJ;AAEA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,wBAAwB,MAA6B;AACxD,UAAM,MAAM,KAAK,WAAW,UAAU,IAAI;AAE1C,YAAQ,OAAO,KAAK;AAAA,MAChB,KAAK;AACD,eAAO;AAAA,MACX,KAAK;AACD,eAAO;AAAA,MACX,KAAK;AACD,eAAO;AAAA,MACX,KAAK;AACD,YAAI,QAAQ,KAAM,QAAO;AACzB,YAAI,EAAE,QAAQ,GAAG,EAAG,QAAO;AAC3B,eAAO;AAAA,MACX;AACI,eAAO;AAAA,IACf;AAAA,EACJ;AACJ;","names":[]}

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

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import { MethodSignature, MemberSignature } from './types.js';
+import TypeResolver from './TypeResolver.js';
+import '../SourceFile.js';
+import '../resolvers/ImportResolver.js';
+import '../resolvers/TsResolver.js';
+import '../types.js';
+import './NodeFinder.js';
+
+/**
+ * Builds method and property signatures from TypeScript nodes.
+ */
+declare class SignatureBuilder {
+    private readonly typeResolver;
+    /**
+     * Constructor for the SignatureBuilder.
+     *
+     * @param typeResolver The type resolver to use for resolving types
+     */
+    private readonly jsDocParser;
+    constructor(typeResolver: TypeResolver);
+    /**
+     * Builds a method signature from a function-like node.
+     *
+     * @param method The function-like node to build a signature from
+     * @returns The method signature
+     */
+    getMethodSignature(method: ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.FunctionExpression | ts.ArrowFunction): MethodSignature;
+    /**
+     * Builds a function type string from a method signature.
+     *
+     * @param sig The method signature to build a function type from
+     * @returns The function type as a string
+     */
+    buildFunctionType(sig: MethodSignature): string;
+    /**
+     * Formats a record of member signatures into a string representation.
+     *
+     * @param members The record of member signatures to format
+     * @returns The formatted members as a string
+     */
+    formatMembers(members: Record<string, MemberSignature>): string;
+}
+
+export { SignatureBuilder as default };

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

@@ -0,0 +1,99 @@
+import ts from "typescript";
+import JSDocParser from "./JSDocParser.js";
+class SignatureBuilder {
+  constructor(typeResolver) {
+    this.typeResolver = typeResolver;
+    this.jsDocParser = new JSDocParser();
+  }
+  /**
+   * Constructor for the SignatureBuilder.
+   *
+   * @param typeResolver The type resolver to use for resolving types
+   */
+  jsDocParser;
+  /**
+   * Builds a method signature from a function-like node.
+   *
+   * @param method The function-like node to build a signature from
+   * @returns The method signature
+   */
+  getMethodSignature(method) {
+    const jsDocParamTypes = "parameters" in method ? this.jsDocParser.getJSDocParameterTypes(method) : /* @__PURE__ */ new Map();
+    const params = ("parameters" in method ? method.parameters : []).map((p) => {
+      const name = ts.isIdentifier(p.name) ? p.name.text : p.name.getText();
+      const tsType = p.type ? this.typeResolver.resolveTypeNode(p.type) : "any";
+      const jsDocType = jsDocParamTypes.get(name);
+      const type = jsDocType || tsType;
+      const formattedType = type.replace(/\{\s+/g, "{").replace(/\s+\}/g, "}");
+      const optional = p.questionToken !== void 0 || p.initializer !== void 0;
+      return { name, type: formattedType, optional };
+    });
+    let typeParams = [];
+    if ("parameters" in method) {
+      const jsDocTypeParams = this.jsDocParser.getJSDocTypeParameters(method);
+      if (jsDocTypeParams.length > 0) {
+        typeParams = jsDocTypeParams;
+      } else if (method.typeParameters) {
+        typeParams = method.typeParameters.map((tp) => tp.getText());
+      }
+    } else {
+      const methodWithTypeParams = method;
+      if (methodWithTypeParams.typeParameters) {
+        typeParams = methodWithTypeParams.typeParameters.map((tp) => tp.getText());
+      }
+    }
+    const jsDocReturnType = "parameters" in method ? this.jsDocParser.getJSDocReturnType(method) : void 0;
+    const returnNode = method.type;
+    const tsReturnType = returnNode ? this.typeResolver.resolveTypeNode(returnNode) : "any";
+    const returnType = jsDocReturnType || tsReturnType;
+    const formattedReturnType = returnType.replace(/\{\s+/g, "{").replace(/\s+\}/g, "}");
+    return {
+      kind: "method",
+      typeParameters: typeParams,
+      parameters: params,
+      returnType: formattedReturnType
+    };
+  }
+  /**
+   * Builds a function type string from a method signature.
+   *
+   * @param sig The method signature to build a function type from
+   * @returns The function type as a string
+   */
+  buildFunctionType(sig) {
+    const params = sig.parameters.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ");
+    return `(${params}) => ${sig.returnType}`;
+  }
+  /**
+   * Formats a record of member signatures into a string representation.
+   *
+   * @param members The record of member signatures to format
+   * @returns The formatted members as a string
+   */
+  formatMembers(members) {
+    const parts = [];
+    for (const [name, member] of Object.entries(members)) {
+      if (member.kind === "method") {
+        const typeParams = member.typeParameters.length ? `<${member.typeParameters.join(", ")}>` : "";
+        const params = member.parameters.map((p) => {
+          let paramType = p.type;
+          if (paramType.includes("@param")) {
+            const match = paramType.match(/\{([^}]+)\}/);
+            if (match) {
+              paramType = match[1];
+            }
+          }
+          return `${p.name}${p.optional ? "?" : ""}: ${paramType}`;
+        }).join(", ");
+        parts.push(`${name}${typeParams}(${params}): ${member.returnType};`);
+      } else {
+        parts.push(`${name}${member.optional ? "?" : ""}: ${member.type};`);
+      }
+    }
+    return `{ ${parts.join(" ")} }`;
+  }
+}
+export {
+  SignatureBuilder as default
+};
+//# sourceMappingURL=SignatureBuilder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/cli/entrypoint/file/parsers/SignatureBuilder.ts"],"sourcesContent":["import ts from \"typescript\";\nimport {MemberSignature, MethodSignature, ParameterSignature} from \"./types\";\nimport TypeResolver from \"./TypeResolver\";\nimport JSDocParser from \"./JSDocParser\";\n\n/**\n * Builds method and property signatures from TypeScript nodes.\n */\nexport default class SignatureBuilder {\n    /**\n     * Constructor for the SignatureBuilder.\n     *\n     * @param typeResolver The type resolver to use for resolving types\n     */\n    private readonly jsDocParser: JSDocParser;\n\n    constructor(private readonly typeResolver: TypeResolver) {\n        this.jsDocParser = new JSDocParser();\n    }\n\n    /**\n     * Builds a method signature from a function-like node.\n     *\n     * @param method The function-like node to build a signature from\n     * @returns The method signature\n     */\n    public getMethodSignature(\n        method: ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.FunctionExpression | ts.ArrowFunction\n    ): MethodSignature {\n        // Get JSDoc parameter types if available\n        const jsDocParamTypes =\n            \"parameters\" in method\n                ? this.jsDocParser.getJSDocParameterTypes(method as ts.SignatureDeclaration)\n                : new Map<string, string>();\n\n        // parameters\n        const params: ParameterSignature[] = (\"parameters\" in method ? method.parameters : []).map(p => {\n            const name = ts.isIdentifier(p.name) ? p.name.text : p.name.getText();\n\n            // Use JSDoc type if available, otherwise use TypeScript type\n            const tsType = p.type ? this.typeResolver.resolveTypeNode(p.type) : \"any\";\n            const jsDocType = jsDocParamTypes.get(name);\n            const type = jsDocType || tsType;\n\n            // Remove spaces in object types to match expected format\n            const formattedType = type.replace(/\\{\\s+/g, \"{\").replace(/\\s+\\}/g, \"}\");\n            const optional = p.questionToken !== undefined || p.initializer !== undefined;\n            return {name, type: formattedType, optional};\n        });\n\n        // Get JSDoc type parameters if available, otherwise use TypeScript type parameters\n        let typeParams: string[] = [];\n\n        if (\"parameters\" in method) {\n            const jsDocTypeParams = this.jsDocParser.getJSDocTypeParameters(method as ts.SignatureDeclaration);\n            if (jsDocTypeParams.length > 0) {\n                typeParams = jsDocTypeParams;\n            } else if (method.typeParameters) {\n                typeParams = method.typeParameters.map(tp => tp.getText());\n            }\n        } else {\n            // For non-SignatureDeclaration types, check if typeParameters exists\n            const methodWithTypeParams = method as {typeParameters?: ts.NodeArray<ts.TypeParameterDeclaration>};\n            if (methodWithTypeParams.typeParameters) {\n                typeParams = methodWithTypeParams.typeParameters.map(tp => tp.getText());\n            }\n        }\n\n        // Get JSDoc return type if available\n        const jsDocReturnType =\n            \"parameters\" in method ? this.jsDocParser.getJSDocReturnType(method as ts.SignatureDeclaration) : undefined;\n\n        // return type (inline aliases when possible)\n        const returnNode = (method as ts.MethodDeclaration).type;\n        const tsReturnType = returnNode ? this.typeResolver.resolveTypeNode(returnNode) : \"any\";\n\n        // Use JSDoc return type if available, otherwise use TypeScript return type\n        const returnType = jsDocReturnType || tsReturnType;\n\n        // Remove spaces in object types to match expected format\n        const formattedReturnType = returnType.replace(/\\{\\s+/g, \"{\").replace(/\\s+\\}/g, \"}\");\n\n        return {\n            kind: \"method\",\n            typeParameters: typeParams,\n            parameters: params,\n            returnType: formattedReturnType,\n        };\n    }\n\n    /**\n     * Builds a function type string from a method signature.\n     *\n     * @param sig The method signature to build a function type from\n     * @returns The function type as a string\n     */\n    public buildFunctionType(sig: MethodSignature): string {\n        const params = sig.parameters.map(p => `${p.name}${p.optional ? \"?\" : \"\"}: ${p.type}`).join(\", \");\n        return `(${params}) => ${sig.returnType}`;\n    }\n\n    /**\n     * Formats a record of member signatures into a string representation.\n     *\n     * @param members The record of member signatures to format\n     * @returns The formatted members as a string\n     */\n    public formatMembers(members: Record<string, MemberSignature>): string {\n        const parts: string[] = [];\n\n        for (const [name, member] of Object.entries(members)) {\n            if (member.kind === \"method\") {\n                const typeParams = member.typeParameters.length ? `<${member.typeParameters.join(\", \")}>` : \"\";\n\n                // Clean up parameter types to remove any JSDoc comments\n                const params = member.parameters\n                    .map(p => {\n                        // If the parameter type contains JSDoc comments, extract just the type\n                        let paramType = p.type;\n                        if (paramType.includes(\"@param\")) {\n                            // This is a parameter with JSDoc comments, extract just the type\n                            const match = paramType.match(/\\{([^}]+)\\}/);\n                            if (match) {\n                                paramType = match[1];\n                            }\n                        }\n\n                        return `${p.name}${p.optional ? \"?\" : \"\"}: ${paramType}`;\n                    })\n                    .join(\", \");\n\n                parts.push(`${name}${typeParams}(${params}): ${member.returnType};`);\n            } else {\n                parts.push(`${name}${member.optional ? \"?\" : \"\"}: ${member.type};`);\n            }\n        }\n\n        return `{ ${parts.join(\" \")} }`;\n    }\n}\n"],"mappings":"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","names":[]}

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

@@ -0,0 +1,89 @@
+import ts from 'typescript';
+import EntryFile from '../SourceFile.js';
+import NodeFinder from './NodeFinder.js';
+import '../resolvers/ImportResolver.js';
+import '../resolvers/TsResolver.js';
+import '../types.js';
+
+/**
+ * Resolves TypeScript type nodes to string representations.
+ */
+declare class TypeResolver {
+    private readonly sourceFile;
+    private readonly nodeFinder?;
+    /**
+     * Constructor for the TypeResolver.
+     *
+     * @param sourceFile The source file to resolve types from
+     * @param nodeFinder Optional NodeFinder instance to use for finding nodes
+     */
+    constructor(sourceFile: EntryFile, nodeFinder?: NodeFinder | undefined);
+    /**
+     * Resolves a TypeScript type node to a string, inlining type aliases when possible.
+     *
+     * @param typeNode The type node to resolve
+     * @returns The resolved type as a string
+     */
+    resolveTypeNode(typeNode: ts.TypeNode): string;
+    /**
+     * Resolves a union type node to a string.
+     *
+     * @param typeNode The union type node to resolve
+     * @returns The resolved union type as a string
+     */
+    resolveUnionType(typeNode: ts.UnionTypeNode): string;
+    /**
+     * Resolves an array type node to a string.
+     *
+     * @param typeNode The array type node to resolve
+     * @returns The resolved array type as a string
+     */
+    resolveArrayType(typeNode: ts.ArrayTypeNode): string;
+    /**
+     * Resolves a type reference node to a string, inlining type aliases when possible.
+     *
+     * @param typeNode The type reference node to resolve
+     * @returns The resolved type reference as a string
+     */
+    resolveTypeReference(typeNode: ts.TypeReferenceNode): string;
+    /**
+     * Attempts to inline a type alias.
+     *
+     * @param name The name of the type alias
+     * @returns The inlined type alias or undefined if it cannot be inlined
+     */
+    inlineAliasType(name: string): string | undefined;
+    /**
+     * Processes an intersection type node by flattening its members
+     */
+    private processIntersectionType;
+    /**
+     * Extracts segments from a type string, handling nested braces
+     */
+    private extractSegmentsFromType;
+    /**
+     * Extracts a textual property name.
+     */
+    private getName;
+    /**
+     * Extracts properties from an interface declaration
+     */
+    extractInterfaceProperties(interfaceDecl: ts.InterfaceDeclaration, parser?: TypeResolver): string[];
+    /**
+     * Searches the AST of this file for a type alias declaration by name.
+     *
+     * @param name The name of the type alias to find
+     * @returns The type alias declaration or undefined if not found
+     */
+    private findTypeAliasDeclaration;
+    /**
+     * Generic method to find a node of a specific type by name in the AST.
+     *
+     * @param predicate The predicate to match the node
+     * @param name The name to search for
+     * @returns The found node or undefined if not found
+     */
+    private findNodeByName;
+}
+
+export { TypeResolver as default };