@openwebf/webf 0.22.6 → 0.22.8

package/dist/analyzer.js

@@ -37,12 +37,15 @@ exports.analyzer = analyzer;
 exports.buildClassRelationship = buildClassRelationship;
 exports.clearCaches = clearCaches;
 const typescript_1 = __importStar(require("typescript"));
+const tsdoc_1 = require("@microsoft/tsdoc");
 const declaration_1 = require("./declaration");
 const utils_1 = require("./utils");
 // Cache for parsed source files to avoid re-parsing
 const sourceFileCache = new Map();
 // Cache for type conversions to avoid redundant processing
 const typeConversionCache = new Map();
+// TSDoc parser instance
+const tsdocParser = new tsdoc_1.TSDocParser();
 // Type mapping constants for better performance
 const BASIC_TYPE_MAP = {
     [typescript_1.default.SyntaxKind.StringKeyword]: declaration_1.FunctionArgumentType.dom_string,
@@ -72,7 +75,7 @@ function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
         blob.objects = sourceFile.statements
             .map(statement => {
             try {
-                return walkProgram(blob, statement, definedPropertyCollector, unionTypeCollector);
+                return walkProgram(blob, statement, sourceFile, definedPropertyCollector, unionTypeCollector);
             }
             catch (error) {
                 console.error(`Error processing statement in ${blob.source}:`, error);
@@ -106,6 +109,93 @@ function getInterfaceName(statement) {
     }
     return statement.name.escapedText;
 }
+function getJSDocComment(node, sourceFile) {
+    const sourceText = sourceFile.getFullText();
+    const nodeStart = node.getFullStart();
+    const nodePos = node.getStart(sourceFile);
+    // Get the text between full start and actual start (includes leading trivia)
+    const leadingText = sourceText.substring(nodeStart, nodePos);
+    // Find JSDoc comment in the leading text
+    const jsDocMatch = leadingText.match(/\/\*\*([\s\S]*?)\*\/\s*$/);
+    if (!jsDocMatch)
+        return undefined;
+    // Extract the full JSDoc comment including delimiters
+    const commentText = jsDocMatch[0];
+    const commentStartPos = nodeStart + leadingText.lastIndexOf(commentText);
+    // Create a TextRange for the comment
+    const textRange = tsdoc_1.TextRange.fromStringRange(sourceText, commentStartPos, commentStartPos + commentText.length);
+    // Parse the JSDoc comment using TSDoc
+    const parserContext = tsdocParser.parseRange(textRange);
+    const docComment = parserContext.docComment;
+    // For now, always use the raw comment to preserve all tags including @default
+    // TSDoc parser doesn't handle @default tags properly out of the box
+    // Fallback to raw comment if TSDoc parsing fails
+    const comment = jsDocMatch[1]
+        .split('\n')
+        .map(line => line.replace(/^\s*\*\s?/, ''))
+        .join('\n')
+        .trim();
+    return comment || undefined;
+}
+// Helper function to render TSDoc nodes to string
+function renderDocNodes(nodes) {
+    return nodes.map(node => {
+        if (node.kind === 'PlainText') {
+            return node.text;
+        }
+        else if (node.kind === 'SoftBreak') {
+            return '\n';
+        }
+        else if (node.kind === 'Paragraph') {
+            return renderDocNodes(node.nodes);
+        }
+        return '';
+    }).join('').trim();
+}
+// Special function to get the first JSDoc comment in a file for the first interface
+function getFirstInterfaceJSDoc(statement, sourceFile) {
+    // Find all interfaces in the file
+    const interfaces = [];
+    typescript_1.default.forEachChild(sourceFile, child => {
+        if (typescript_1.default.isInterfaceDeclaration(child)) {
+            interfaces.push(child);
+        }
+    });
+    // If this is the first interface, check for a file-level JSDoc
+    if (interfaces.length > 0 && interfaces[0] === statement) {
+        const sourceText = sourceFile.getFullText();
+        const firstInterfacePos = statement.getFullStart();
+        // Get all text before the first interface
+        const textBeforeInterface = sourceText.substring(0, firstInterfacePos);
+        // Find the last JSDoc comment before the interface
+        const jsDocMatches = textBeforeInterface.match(/\/\*\*([\s\S]*?)\*\//g);
+        if (jsDocMatches && jsDocMatches.length > 0) {
+            const lastJsDoc = jsDocMatches[jsDocMatches.length - 1];
+            const commentStartPos = textBeforeInterface.lastIndexOf(lastJsDoc);
+            // Create a TextRange for the comment
+            const textRange = tsdoc_1.TextRange.fromStringRange(sourceText, commentStartPos, commentStartPos + lastJsDoc.length);
+            // Parse the JSDoc comment using TSDoc
+            const parserContext = tsdocParser.parseRange(textRange);
+            const docComment = parserContext.docComment;
+            // Extract the parsed content
+            if (docComment.summarySection) {
+                const summary = renderDocNodes(docComment.summarySection.nodes);
+                if (summary)
+                    return summary;
+            }
+            // Fallback to raw comment
+            const comment = lastJsDoc
+                .replace(/^\/\*\*/, '')
+                .replace(/\*\/$/, '')
+                .split('\n')
+                .map(line => line.replace(/^\s*\*\s?/, ''))
+                .join('\n')
+                .trim();
+            return comment || undefined;
+        }
+    }
+    return undefined;
+}
 function getHeritageType(heritage) {
     if (!heritage.types.length)
         return null;
@@ -210,11 +300,15 @@ function getParameterBaseType(type, mode) {
         }
     }
     if (type.kind === typescript_1.default.SyntaxKind.LiteralType) {
-        // Handle literal types - check if it's a null literal
+        // Handle literal types
         const literalType = type;
         if (literalType.literal.kind === typescript_1.default.SyntaxKind.NullKeyword) {
             return declaration_1.FunctionArgumentType.null;
         }
+        if (literalType.literal.kind === typescript_1.default.SyntaxKind.StringLiteral) {
+            // Return the string literal value itself
+            return literalType.literal.text;
+        }
         return declaration_1.FunctionArgumentType.any;
     }
     return declaration_1.FunctionArgumentType.any;
@@ -379,10 +473,10 @@ function isParamsReadOnly(m) {
         return false;
     return m.modifiers.some(k => k.kind === typescript_1.default.SyntaxKind.ReadonlyKeyword);
 }
-function walkProgram(blob, statement, definedPropertyCollector, unionTypeCollector) {
+function walkProgram(blob, statement, sourceFile, definedPropertyCollector, unionTypeCollector) {
     switch (statement.kind) {
         case typescript_1.default.SyntaxKind.InterfaceDeclaration:
-            return processInterfaceDeclaration(statement, blob, definedPropertyCollector, unionTypeCollector);
+            return processInterfaceDeclaration(statement, blob, sourceFile, definedPropertyCollector, unionTypeCollector);
         case typescript_1.default.SyntaxKind.VariableStatement:
             return processVariableStatement(statement, unionTypeCollector);
         case typescript_1.default.SyntaxKind.TypeAliasDeclaration:
@@ -399,9 +493,13 @@ function processTypeAliasDeclaration(statement, blob) {
     typeAlias.type = printer.printNode(typescript_1.default.EmitHint.Unspecified, statement.type, statement.getSourceFile());
     return typeAlias;
 }
-function processInterfaceDeclaration(statement, blob, definedPropertyCollector, unionTypeCollector) {
+function processInterfaceDeclaration(statement, blob, sourceFile, definedPropertyCollector, unionTypeCollector) {
     const interfaceName = statement.name.escapedText.toString();
     const obj = new declaration_1.ClassObject();
+    // Capture JSDoc comment for the interface
+    const directComment = getJSDocComment(statement, sourceFile);
+    const fileComment = getFirstInterfaceJSDoc(statement, sourceFile);
+    obj.documentation = directComment || fileComment;
     // Process heritage clauses
     if (statement.heritageClauses) {
         const heritage = statement.heritageClauses[0];
@@ -420,40 +518,41 @@ function processInterfaceDeclaration(statement, blob, definedPropertyCollector,
     }
     // Process members in batches for better performance
     const members = Array.from(statement.members);
-    processMembersBatch(members, obj, definedPropertyCollector, unionTypeCollector);
+    processMembersBatch(members, obj, sourceFile, definedPropertyCollector, unionTypeCollector);
     declaration_1.ClassObject.globalClassMap[interfaceName] = obj;
     return obj;
 }
-function processMembersBatch(members, obj, definedPropertyCollector, unionTypeCollector) {
+function processMembersBatch(members, obj, sourceFile, definedPropertyCollector, unionTypeCollector) {
     for (const member of members) {
         try {
-            processMember(member, obj, definedPropertyCollector, unionTypeCollector);
+            processMember(member, obj, sourceFile, definedPropertyCollector, unionTypeCollector);
         }
         catch (error) {
             console.error(`Error processing member:`, error);
         }
     }
 }
-function processMember(member, obj, definedPropertyCollector, unionTypeCollector) {
+function processMember(member, obj, sourceFile, definedPropertyCollector, unionTypeCollector) {
     switch (member.kind) {
         case typescript_1.default.SyntaxKind.PropertySignature:
-            processPropertySignature(member, obj, definedPropertyCollector, unionTypeCollector);
+            processPropertySignature(member, obj, sourceFile, definedPropertyCollector, unionTypeCollector);
             break;
         case typescript_1.default.SyntaxKind.MethodSignature:
-            processMethodSignature(member, obj, unionTypeCollector);
+            processMethodSignature(member, obj, sourceFile, unionTypeCollector);
             break;
         case typescript_1.default.SyntaxKind.IndexSignature:
-            processIndexSignature(member, obj, unionTypeCollector);
+            processIndexSignature(member, obj, sourceFile, unionTypeCollector);
             break;
         case typescript_1.default.SyntaxKind.ConstructSignature:
-            processConstructSignature(member, obj, unionTypeCollector);
+            processConstructSignature(member, obj, sourceFile, unionTypeCollector);
             break;
     }
 }
-function processPropertySignature(member, obj, definedPropertyCollector, unionTypeCollector) {
+function processPropertySignature(member, obj, sourceFile, definedPropertyCollector, unionTypeCollector) {
     const prop = new declaration_1.PropsDeclaration();
     prop.name = getPropName(member.name, prop);
     prop.readonly = isParamsReadOnly(member);
+    prop.documentation = getJSDocComment(member, sourceFile);
     definedPropertyCollector.properties.add(prop.name);
     if (!member.type) {
         console.warn(`Property ${prop.name} has no type annotation`);
@@ -491,10 +590,11 @@ function createAsyncProperty(prop, mode) {
     };
     return asyncProp;
 }
-function processMethodSignature(member, obj, unionTypeCollector) {
+function processMethodSignature(member, obj, sourceFile, unionTypeCollector) {
     var _a;
     const f = new declaration_1.FunctionDeclaration();
     f.name = getPropName(member.name);
+    f.documentation = getJSDocComment(member, sourceFile);
     f.args = member.parameters.map(params => paramsNodeToArguments(params, unionTypeCollector));
     if (member.type) {
         const mode = new declaration_1.ParameterMode();
@@ -531,7 +631,7 @@ function createAsyncMethod(member, originalFunc, unionTypeCollector) {
     };
     return asyncFunc;
 }
-function processIndexSignature(member, obj, unionTypeCollector) {
+function processIndexSignature(member, obj, sourceFile, unionTypeCollector) {
     const prop = new declaration_1.IndexedPropertyDeclaration();
     const modifier = member.modifiers;
     prop.readonly = !!(modifier && modifier[0].kind === typescript_1.default.SyntaxKind.ReadonlyKeyword);
@@ -544,7 +644,7 @@ function processIndexSignature(member, obj, unionTypeCollector) {
     prop.typeMode = mode;
     obj.indexedProp = prop;
 }
-function processConstructSignature(member, obj, unionTypeCollector) {
+function processConstructSignature(member, obj, sourceFile, unionTypeCollector) {
     const c = new declaration_1.FunctionDeclaration();
     c.name = 'constructor';
     c.args = member.parameters.map(params => paramsNodeToArguments(params, unionTypeCollector));

package/dist/react.js

@@ -15,6 +15,9 @@ function readTemplate(name) {
     return fs_1.default.readFileSync(path_1.default.join(__dirname, '../templates/' + name + '.tpl'), { encoding: 'utf-8' });
 }
 function generateReturnType(type) {
+    if ((0, utils_1.isUnionType)(type)) {
+        return type.value.map(v => `'${v.value}'`).join(' | ');
+    }
     if ((0, utils_1.isPointerType)(type)) {
         const pointerType = (0, utils_1.getPointerType)(type);
         return pointerType;
@@ -79,6 +82,19 @@ function generateMethodDeclaration(method) {
     var returnType = generateReturnType(method.returnType);
     return `${methodName}(${args}): ${returnType};`;
 }
+function generateMethodDeclarationWithDocs(method, indent = '') {
+    let result = '';
+    if (method.documentation) {
+        result += `${indent}/**\n`;
+        const docLines = method.documentation.split('\n');
+        docLines.forEach(line => {
+            result += `${indent} * ${line}\n`;
+        });
+        result += `${indent} */\n`;
+    }
+    result += `${indent}${generateMethodDeclaration(method)}`;
+    return result;
+}
 function toReactEventName(name) {
     const eventName = 'on-' + name;
     return lodash_1.default.camelCase(eventName);
@@ -110,9 +126,13 @@ function generateReactComponent(blob, packageName, relativeDir) {
     const events = classObjects.filter(object => {
         return object.name.endsWith('Events');
     });
+    const methods = classObjects.filter(object => {
+        return object.name.endsWith('Methods');
+    });
     const others = classObjects.filter(object => {
         return !object.name.endsWith('Properties')
-            && !object.name.endsWith('Events');
+            && !object.name.endsWith('Events')
+            && !object.name.endsWith('Methods');
     });
     // Include type aliases
     const typeAliasDeclarations = typeAliases.map(typeAlias => {
@@ -120,6 +140,19 @@ function generateReactComponent(blob, packageName, relativeDir) {
     }).join('\n');
     const dependencies = [
         typeAliasDeclarations,
+        // Include Methods interfaces as dependencies
+        methods.map(object => {
+            const methodDeclarations = object.methods.map(method => {
+                return generateMethodDeclarationWithDocs(method, '  ');
+            }).join('\n');
+            let interfaceDoc = '';
+            if (object.documentation) {
+                interfaceDoc = `/**\n${object.documentation.split('\n').map(line => ` * ${line}`).join('\n')}\n */\n`;
+            }
+            return `${interfaceDoc}interface ${object.name} {
+${methodDeclarations}
+}`;
+        }).join('\n\n'),
         others.map(object => {
             const props = object.props.map(prop => {
                 if (prop.optional) {
@@ -135,7 +168,7 @@ interface ${object.name} {
     ].filter(Boolean).join('\n\n');
     // Generate all components from this file
     const components = [];
-    // Create a map of component names to their properties and events
+    // Create a map of component names to their properties, events, and methods
     const componentMap = new Map();
     // Process all Properties interfaces
     properties.forEach(prop => {
@@ -153,6 +186,14 @@ interface ${object.name} {
         }
         componentMap.get(componentName).events = event;
     });
+    // Process all Methods interfaces
+    methods.forEach(method => {
+        const componentName = method.name.replace(/Methods$/, '');
+        if (!componentMap.has(componentName)) {
+            componentMap.set(componentName, {});
+        }
+        componentMap.get(componentName).methods = method;
+    });
     // If we have multiple components, we need to generate a combined file
     const componentEntries = Array.from(componentMap.entries());
     if (componentEntries.length === 0) {
@@ -180,6 +221,7 @@ interface ${object.name} {
             className: className,
             properties: component.properties,
             events: component.events,
+            methods: component.methods,
             classObjectDictionary,
             dependencies,
             blob,
@@ -187,6 +229,7 @@ interface ${object.name} {
             toWebFTagName,
             generateReturnType,
             generateMethodDeclaration,
+            generateMethodDeclarationWithDocs,
             generateEventHandlerType,
             getEventType,
         });
@@ -214,6 +257,7 @@ interface ${object.name} {
             className: className,
             properties: component.properties,
             events: component.events,
+            methods: component.methods,
             classObjectDictionary,
             dependencies: '', // Dependencies will be at the top
             blob,
@@ -221,6 +265,7 @@ interface ${object.name} {
             toWebFTagName,
             generateReturnType,
             generateMethodDeclaration,
+            generateMethodDeclarationWithDocs,
             generateEventHandlerType,
             getEventType,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwebf/webf",
-  "version": "0.22.6",
+  "version": "0.22.8",
   "description": "Command line tools for WebF",
   "main": "index.js",
   "bin": {
@@ -36,6 +36,8 @@
     "ts-jest": "^29.1.2"
   },
   "dependencies": {
+    "@microsoft/tsdoc": "^0.15.1",
+    "@microsoft/tsdoc-config": "^0.17.1",
     "commander": "^14.0.0",
     "glob": "^10.3.10",
     "inquirer": "^8.2.6",

package/src/analyzer.ts

@@ -1,4 +1,5 @@
 import ts, {HeritageClause, ScriptTarget, VariableStatement} from 'typescript';
+import { TSDocParser, TextRange, DocComment } from '@microsoft/tsdoc';
 import {IDLBlob} from './IDLBlob';
 import {
   ClassObject,
@@ -30,6 +31,9 @@ const sourceFileCache = new Map<string, ts.SourceFile>();
 // Cache for type conversions to avoid redundant processing
 const typeConversionCache = new Map<string, ParameterType>();
 
+// TSDoc parser instance
+const tsdocParser = new TSDocParser();
+
 // Type mapping constants for better performance
 const BASIC_TYPE_MAP: Partial<Record<ts.SyntaxKind, FunctionArgumentType>> = {
   [ts.SyntaxKind.StringKeyword]: FunctionArgumentType.dom_string,
@@ -62,7 +66,7 @@ export function analyzer(blob: IDLBlob, definedPropertyCollector: DefinedPropert
     blob.objects = sourceFile.statements
       .map(statement => {
         try {
-          return walkProgram(blob, statement, definedPropertyCollector, unionTypeCollector);
+          return walkProgram(blob, statement, sourceFile, definedPropertyCollector, unionTypeCollector);
         } catch (error) {
           console.error(`Error processing statement in ${blob.source}:`, error);
           return null;
@@ -98,6 +102,118 @@ function getInterfaceName(statement: ts.Statement): string {
   return statement.name.escapedText as string;
 }
 
+function getJSDocComment(node: ts.Node, sourceFile: ts.SourceFile): string | undefined {
+  
+  const sourceText = sourceFile.getFullText();
+  const nodeStart = node.getFullStart();
+  const nodePos = node.getStart(sourceFile);
+  
+  // Get the text between full start and actual start (includes leading trivia)
+  const leadingText = sourceText.substring(nodeStart, nodePos);
+  
+  
+  // Find JSDoc comment in the leading text
+  const jsDocMatch = leadingText.match(/\/\*\*([\s\S]*?)\*\/\s*$/);
+  if (!jsDocMatch) return undefined;
+  
+  // Extract the full JSDoc comment including delimiters
+  const commentText = jsDocMatch[0];
+  const commentStartPos = nodeStart + leadingText.lastIndexOf(commentText);
+  
+  // Create a TextRange for the comment
+  const textRange = TextRange.fromStringRange(
+    sourceText,
+    commentStartPos,
+    commentStartPos + commentText.length
+  );
+  
+  // Parse the JSDoc comment using TSDoc
+  const parserContext = tsdocParser.parseRange(textRange);
+  const docComment = parserContext.docComment;
+  
+  // For now, always use the raw comment to preserve all tags including @default
+  // TSDoc parser doesn't handle @default tags properly out of the box
+  
+  // Fallback to raw comment if TSDoc parsing fails
+  const comment = jsDocMatch[1]
+    .split('\n')
+    .map(line => line.replace(/^\s*\*\s?/, ''))
+    .join('\n')
+    .trim();
+  return comment || undefined;
+}
+
+// Helper function to render TSDoc nodes to string
+function renderDocNodes(nodes: ReadonlyArray<any>): string {
+  return nodes.map(node => {
+    if (node.kind === 'PlainText') {
+      return node.text;
+    } else if (node.kind === 'SoftBreak') {
+      return '\n';
+    } else if (node.kind === 'Paragraph') {
+      return renderDocNodes(node.nodes);
+    }
+    return '';
+  }).join('').trim();
+}
+
+// Special function to get the first JSDoc comment in a file for the first interface
+function getFirstInterfaceJSDoc(statement: ts.InterfaceDeclaration, sourceFile: ts.SourceFile): string | undefined {
+  
+  // Find all interfaces in the file
+  const interfaces: ts.InterfaceDeclaration[] = [];
+  ts.forEachChild(sourceFile, child => {
+    if (ts.isInterfaceDeclaration(child)) {
+      interfaces.push(child);
+    }
+  });
+  
+  // If this is the first interface, check for a file-level JSDoc
+  if (interfaces.length > 0 && interfaces[0] === statement) {
+    const sourceText = sourceFile.getFullText();
+    const firstInterfacePos = statement.getFullStart();
+    
+    // Get all text before the first interface
+    const textBeforeInterface = sourceText.substring(0, firstInterfacePos);
+    
+    // Find the last JSDoc comment before the interface
+    const jsDocMatches = textBeforeInterface.match(/\/\*\*([\s\S]*?)\*\//g);
+    if (jsDocMatches && jsDocMatches.length > 0) {
+      const lastJsDoc = jsDocMatches[jsDocMatches.length - 1];
+      const commentStartPos = textBeforeInterface.lastIndexOf(lastJsDoc);
+      
+      // Create a TextRange for the comment
+      const textRange = TextRange.fromStringRange(
+        sourceText,
+        commentStartPos,
+        commentStartPos + lastJsDoc.length
+      );
+      
+      // Parse the JSDoc comment using TSDoc
+      const parserContext = tsdocParser.parseRange(textRange);
+      const docComment = parserContext.docComment;
+      
+      // Extract the parsed content
+      if (docComment.summarySection) {
+        const summary = renderDocNodes(docComment.summarySection.nodes);
+        if (summary) return summary;
+      }
+      
+      // Fallback to raw comment
+      const comment = lastJsDoc
+        .replace(/^\/\*\*/, '')
+        .replace(/\*\/$/, '')
+        .split('\n')
+        .map(line => line.replace(/^\s*\*\s?/, ''))
+        .join('\n')
+        .trim();
+      return comment || undefined;
+    }
+  }
+  
+  return undefined;
+}
+
 function getHeritageType(heritage: HeritageClause): string | null {
   if (!heritage.types.length) return null;
   
@@ -217,11 +333,15 @@ function getParameterBaseType(type: ts.TypeNode, mode?: ParameterMode): Paramete
   }
   
   if (type.kind === ts.SyntaxKind.LiteralType) {
-    // Handle literal types - check if it's a null literal
+    // Handle literal types
     const literalType = type as ts.LiteralTypeNode;
     if (literalType.literal.kind === ts.SyntaxKind.NullKeyword) {
       return FunctionArgumentType.null;
     }
+    if (literalType.literal.kind === ts.SyntaxKind.StringLiteral) {
+      // Return the string literal value itself
+      return (literalType.literal as ts.StringLiteral).text;
+    }
     return FunctionArgumentType.any;
   }
   
@@ -411,10 +531,10 @@ function isParamsReadOnly(m: ts.PropertySignature): boolean {
   return m.modifiers.some(k => k.kind === ts.SyntaxKind.ReadonlyKeyword);
 }
 
-function walkProgram(blob: IDLBlob, statement: ts.Statement, definedPropertyCollector: DefinedPropertyCollector, unionTypeCollector: UnionTypeCollector) {
+function walkProgram(blob: IDLBlob, statement: ts.Statement, sourceFile: ts.SourceFile, definedPropertyCollector: DefinedPropertyCollector, unionTypeCollector: UnionTypeCollector) {
   switch(statement.kind) {
     case ts.SyntaxKind.InterfaceDeclaration:
-      return processInterfaceDeclaration(statement as ts.InterfaceDeclaration, blob, definedPropertyCollector, unionTypeCollector);
+      return processInterfaceDeclaration(statement as ts.InterfaceDeclaration, blob, sourceFile, definedPropertyCollector, unionTypeCollector);
       
     case ts.SyntaxKind.VariableStatement:
       return processVariableStatement(statement as VariableStatement, unionTypeCollector);
@@ -444,12 +564,19 @@ function processTypeAliasDeclaration(
 function processInterfaceDeclaration(
   statement: ts.InterfaceDeclaration,
   blob: IDLBlob,
+  sourceFile: ts.SourceFile,
   definedPropertyCollector: DefinedPropertyCollector,
   unionTypeCollector: UnionTypeCollector
 ): ClassObject | null {
   const interfaceName = statement.name.escapedText.toString();
   const obj = new ClassObject();
   
+  // Capture JSDoc comment for the interface
+  const directComment = getJSDocComment(statement, sourceFile);
+  const fileComment = getFirstInterfaceJSDoc(statement, sourceFile);
+  obj.documentation = directComment || fileComment;
+  
+  
   // Process heritage clauses
   if (statement.heritageClauses) {
     const heritage = statement.heritageClauses[0];
@@ -470,7 +597,7 @@ function processInterfaceDeclaration(
   
   // Process members in batches for better performance
   const members = Array.from(statement.members);
-  processMembersBatch(members, obj, definedPropertyCollector, unionTypeCollector);
+  processMembersBatch(members, obj, sourceFile, definedPropertyCollector, unionTypeCollector);
   
   ClassObject.globalClassMap[interfaceName] = obj;
   
@@ -480,12 +607,13 @@ function processInterfaceDeclaration(
 function processMembersBatch(
   members: ts.TypeElement[],
   obj: ClassObject,
+  sourceFile: ts.SourceFile,
   definedPropertyCollector: DefinedPropertyCollector,
   unionTypeCollector: UnionTypeCollector
 ): void {
   for (const member of members) {
     try {
-      processMember(member, obj, definedPropertyCollector, unionTypeCollector);
+      processMember(member, obj, sourceFile, definedPropertyCollector, unionTypeCollector);
     } catch (error) {
       console.error(`Error processing member:`, error);
     }
@@ -495,24 +623,25 @@ function processMembersBatch(
 function processMember(
   member: ts.TypeElement,
   obj: ClassObject,
+  sourceFile: ts.SourceFile,
   definedPropertyCollector: DefinedPropertyCollector,
   unionTypeCollector: UnionTypeCollector
 ): void {
   switch(member.kind) {
     case ts.SyntaxKind.PropertySignature:
-      processPropertySignature(member as ts.PropertySignature, obj, definedPropertyCollector, unionTypeCollector);
+      processPropertySignature(member as ts.PropertySignature, obj, sourceFile, definedPropertyCollector, unionTypeCollector);
       break;
       
     case ts.SyntaxKind.MethodSignature:
-      processMethodSignature(member as ts.MethodSignature, obj, unionTypeCollector);
+      processMethodSignature(member as ts.MethodSignature, obj, sourceFile, unionTypeCollector);
       break;
       
     case ts.SyntaxKind.IndexSignature:
-      processIndexSignature(member as ts.IndexSignatureDeclaration, obj, unionTypeCollector);
+      processIndexSignature(member as ts.IndexSignatureDeclaration, obj, sourceFile, unionTypeCollector);
       break;
       
     case ts.SyntaxKind.ConstructSignature:
-      processConstructSignature(member as ts.ConstructSignatureDeclaration, obj, unionTypeCollector);
+      processConstructSignature(member as ts.ConstructSignatureDeclaration, obj, sourceFile, unionTypeCollector);
       break;
   }
 }
@@ -520,12 +649,14 @@ function processMember(
 function processPropertySignature(
   member: ts.PropertySignature,
   obj: ClassObject,
+  sourceFile: ts.SourceFile,
   definedPropertyCollector: DefinedPropertyCollector,
   unionTypeCollector: UnionTypeCollector
 ): void {
   const prop = new PropsDeclaration();
   prop.name = getPropName(member.name!, prop);
   prop.readonly = isParamsReadOnly(member);
+  prop.documentation = getJSDocComment(member, sourceFile);
   
   definedPropertyCollector.properties.add(prop.name);
   
@@ -577,10 +708,12 @@ function createAsyncProperty(prop: PropsDeclaration, mode: ParameterMode): Props
 function processMethodSignature(
   member: ts.MethodSignature,
   obj: ClassObject,
+  sourceFile: ts.SourceFile,
   unionTypeCollector: UnionTypeCollector
 ): void {
   const f = new FunctionDeclaration();
   f.name = getPropName(member.name!);
+  f.documentation = getJSDocComment(member, sourceFile);
   f.args = member.parameters.map(params => 
     paramsNodeToArguments(params, unionTypeCollector)
   );
@@ -639,6 +772,7 @@ function createAsyncMethod(
 function processIndexSignature(
   member: ts.IndexSignatureDeclaration,
   obj: ClassObject,
+  sourceFile: ts.SourceFile,
   unionTypeCollector: UnionTypeCollector
 ): void {
   const prop = new IndexedPropertyDeclaration();
@@ -659,6 +793,7 @@ function processIndexSignature(
 function processConstructSignature(
   member: ts.ConstructSignatureDeclaration,
   obj: ClassObject,
+  sourceFile: ts.SourceFile,
   unionTypeCollector: UnionTypeCollector
 ): void {
   const c = new FunctionDeclaration();

package/src/declaration.ts

@@ -45,6 +45,7 @@ export class PropsDeclaration {
   isSymbol?: boolean;
   readonly: boolean;
   optional: boolean;
+  documentation?: string;
 }
 
 export class IndexedPropertyDeclaration extends PropsDeclaration {
@@ -77,6 +78,7 @@ export class ClassObject {
   staticMethods: FunctionDeclaration[] = [];
   construct?: FunctionDeclaration;
   kind: ClassObjectKind = ClassObjectKind.interface;
+  documentation?: string;
 }
 
 export class FunctionObject {