@openwebf/webf 0.22.5 → 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/commands.js

@@ -317,6 +317,8 @@ function generateCommand(distPath, options) {
         const hasTsConfig = fs_1.default.existsSync(tsConfigPath);
         // Determine if we need to create a new project
         const needsProjectCreation = !hasPackageJson || !hasGlobalDts || !hasTsConfig;
+        // Track if this is an existing project (has all required files)
+        const isExistingProject = hasPackageJson && hasGlobalDts && hasTsConfig;
         let framework = options.framework;
         let packageName = options.packageName;
         // Validate and sanitize package name if provided
@@ -526,7 +528,7 @@ function generateCommand(distPath, options) {
         // Handle npm publishing if requested via command line option
         if (options.publishToNpm && framework) {
             try {
-                yield buildAndPublishPackage(resolvedDistPath, options.npmRegistry);
+                yield buildAndPublishPackage(resolvedDistPath, options.npmRegistry, isExistingProject);
             }
             catch (error) {
                 console.error('\nError during npm publish:', error);
@@ -561,7 +563,7 @@ function generateCommand(distPath, options) {
                         }
                     }]);
                 try {
-                    yield buildAndPublishPackage(resolvedDistPath, registryAnswer.registry || undefined);
+                    yield buildAndPublishPackage(resolvedDistPath, registryAnswer.registry || undefined, isExistingProject);
                 }
                 catch (error) {
                     console.error('\nError during npm publish:', error);
@@ -652,17 +654,34 @@ function buildPackage(packagePath) {
         }
     });
 }
-function buildAndPublishPackage(packagePath, registry) {
-    return __awaiter(this, void 0, void 0, function* () {
+function buildAndPublishPackage(packagePath_1, registry_1) {
+    return __awaiter(this, arguments, void 0, function* (packagePath, registry, isExistingProject = false) {
         const packageJsonPath = path_1.default.join(packagePath, 'package.json');
         if (!fs_1.default.existsSync(packageJsonPath)) {
             throw new Error(`No package.json found in ${packagePath}`);
         }
-        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        let packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
         const packageName = packageJson.name;
-        const packageVersion = packageJson.version;
+        let packageVersion = packageJson.version;
         // First, ensure dependencies are installed and build the package
         yield buildPackage(packagePath);
+        // If this is an existing project, increment the patch version before publishing
+        if (isExistingProject) {
+            console.log(`\nIncrementing version for existing project...`);
+            const versionResult = (0, child_process_1.spawnSync)(NPM, ['version', 'patch', '--no-git-tag-version'], {
+                cwd: packagePath,
+                encoding: 'utf-8',
+                stdio: 'pipe'
+            });
+            if (versionResult.status !== 0) {
+                console.error('Failed to increment version:', versionResult.stderr);
+                throw new Error('Failed to increment version');
+            }
+            // Re-read package.json to get the new version
+            packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            packageVersion = packageJson.version;
+            console.log(`Version updated to ${packageVersion}`);
+        }
         // Set registry if provided
         if (registry) {
             console.log(`\nUsing npm registry: ${registry}`);

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.5",
+  "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",