@openwebf/webf 0.22.9 → 0.22.11

package/dist/analyzer.js

@@ -66,11 +66,17 @@ const TYPE_REFERENCE_MAP = {
 };
 function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
     try {
-        // Check cache first
-        let sourceFile = sourceFileCache.get(blob.source);
-        if (!sourceFile) {
+        // Check cache first - consider both file path and content
+        const cacheEntry = sourceFileCache.get(blob.source);
+        let sourceFile;
+        if (cacheEntry && cacheEntry.content === blob.raw) {
+            // Cache hit with same content
+            sourceFile = cacheEntry.sourceFile;
+        }
+        else {
+            // Cache miss or content changed - parse and update cache
             sourceFile = typescript_1.default.createSourceFile(blob.source, blob.raw, typescript_1.ScriptTarget.ES2020);
-            sourceFileCache.set(blob.source, sourceFile);
+            sourceFileCache.set(blob.source, { content: blob.raw, sourceFile });
         }
         blob.objects = sourceFile.statements
             .map(statement => {
@@ -292,6 +298,8 @@ function getParameterBaseType(type, mode) {
                 if (mode)
                     mode.staticMethod = true;
                 return handleGenericWrapper(typeReference, mode);
+            case 'CustomEvent':
+                return handleCustomEventType(typeReference);
             default:
                 if (identifier.includes('SupportAsync')) {
                     return handleSupportAsyncType(identifier, typeReference, mode);
@@ -344,6 +352,92 @@ function handleGenericWrapper(typeReference, mode) {
     const argument = typeReference.typeArguments[0];
     return getParameterBaseType(argument, mode);
 }
+function handleCustomEventType(typeReference) {
+    // Handle CustomEvent<T> by returning the full type with generic parameter
+    if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
+        return 'CustomEvent';
+    }
+    const argument = typeReference.typeArguments[0];
+    let genericType;
+    if (typescript_1.default.isTypeReferenceNode(argument) && typescript_1.default.isIdentifier(argument.typeName)) {
+        const typeName = argument.typeName.text;
+        // Check if it's a mapped type reference like 'int' or 'double'
+        const mappedType = TYPE_REFERENCE_MAP[typeName];
+        if (mappedType !== undefined) {
+            switch (mappedType) {
+                case declaration_1.FunctionArgumentType.boolean:
+                    genericType = 'boolean';
+                    break;
+                case declaration_1.FunctionArgumentType.dom_string:
+                    genericType = 'string';
+                    break;
+                case declaration_1.FunctionArgumentType.double:
+                case declaration_1.FunctionArgumentType.int:
+                    genericType = 'number';
+                    break;
+                case declaration_1.FunctionArgumentType.any:
+                    genericType = 'any';
+                    break;
+                case declaration_1.FunctionArgumentType.void:
+                    genericType = 'void';
+                    break;
+                case declaration_1.FunctionArgumentType.function:
+                    genericType = 'Function';
+                    break;
+                case declaration_1.FunctionArgumentType.promise:
+                    genericType = 'Promise<any>';
+                    break;
+                default:
+                    genericType = typeName;
+            }
+        }
+        else {
+            // For other type references, use the type name directly
+            genericType = typeName;
+        }
+    }
+    else if (typescript_1.default.isLiteralTypeNode(argument) && typescript_1.default.isStringLiteral(argument.literal)) {
+        genericType = argument.literal.text;
+    }
+    else {
+        // Handle basic types (boolean, string, number, etc.)
+        const basicType = BASIC_TYPE_MAP[argument.kind];
+        if (basicType !== undefined) {
+            switch (basicType) {
+                case declaration_1.FunctionArgumentType.boolean:
+                    genericType = 'boolean';
+                    break;
+                case declaration_1.FunctionArgumentType.dom_string:
+                    genericType = 'string';
+                    break;
+                case declaration_1.FunctionArgumentType.double:
+                case declaration_1.FunctionArgumentType.int:
+                    genericType = 'number';
+                    break;
+                case declaration_1.FunctionArgumentType.any:
+                    genericType = 'any';
+                    break;
+                case declaration_1.FunctionArgumentType.void:
+                    genericType = 'void';
+                    break;
+                case declaration_1.FunctionArgumentType.null:
+                    genericType = 'null';
+                    break;
+                case declaration_1.FunctionArgumentType.undefined:
+                    genericType = 'undefined';
+                    break;
+                default:
+                    genericType = 'any';
+            }
+        }
+        else {
+            // For truly complex types, fallback to 'any' to avoid errors
+            console.warn('Complex generic type in CustomEvent, using any');
+            genericType = 'any';
+        }
+    }
+    return `CustomEvent<${genericType}>`;
+}
 function handleSupportAsyncType(identifier, typeReference, mode) {
     if (mode) {
         mode.supportAsync = true;

package/dist/generator.js

@@ -287,64 +287,12 @@ function reactGen(_a) {
                 (0, logger_1.error)(`Error generating React component for ${blob.filename}`, err);
             }
         }));
-        // Generate or update index file
+        // Generate index file (always regenerate to avoid duplicates)
         const indexFilePath = path_1.default.join(normalizedTarget, 'src', 'index.ts');
         const newExports = (0, react_1.generateReactIndex)(blobs);
-        if (fs_1.default.existsSync(indexFilePath)) {
-            // Read existing index file
-            const existingContent = fs_1.default.readFileSync(indexFilePath, 'utf-8');
-            const existingLines = existingContent.split('\n');
-            // Parse new exports
-            const newExportLines = newExports.split('\n').filter(line => line.startsWith('export '));
-            // Find which exports are missing
-            const missingExports = [];
-            for (const newExport of newExportLines) {
-                // Extract the export statement to check if it exists
-                const exportMatch = newExport.match(/export\s*{\s*([^}]+)\s*}\s*from\s*["']([^"']+)["']/);
-                if (exportMatch) {
-                    const [, exportNames, modulePath] = exportMatch;
-                    const exportedItems = exportNames.split(',').map(s => s.trim());
-                    // Check if this exact export exists
-                    const exists = existingLines.some(line => {
-                        if (!line.startsWith('export '))
-                            return false;
-                        const lineMatch = line.match(/export\s*{\s*([^}]+)\s*}\s*from\s*["']([^"']+)["']/);
-                        if (!lineMatch)
-                            return false;
-                        const [, lineExportNames, lineModulePath] = lineMatch;
-                        const lineExportedItems = lineExportNames.split(',').map(s => s.trim());
-                        // Check if same module and same exports
-                        return lineModulePath === modulePath &&
-                            exportedItems.every(item => lineExportedItems.includes(item)) &&
-                            lineExportedItems.every(item => exportedItems.includes(item));
-                    });
-                    if (!exists) {
-                        missingExports.push(newExport);
-                    }
-                }
-            }
-            // If there are missing exports, append them
-            if (missingExports.length > 0) {
-                let updatedContent = existingContent.trimRight();
-                if (!updatedContent.endsWith('\n')) {
-                    updatedContent += '\n';
-                }
-                updatedContent += missingExports.join('\n') + '\n';
-                if (writeFileIfChanged(indexFilePath, updatedContent)) {
-                    filesChanged++;
-                    (0, logger_1.debug)(`Updated: index.ts (added ${missingExports.length} exports)`);
-                }
-            }
-            else {
-                (0, logger_1.debug)(`Skipped: index.ts (all exports already exist)`);
-            }
-        }
-        else {
-            // File doesn't exist, create it
-            if (writeFileIfChanged(indexFilePath, newExports)) {
-                filesChanged++;
-                (0, logger_1.debug)(`Generated: index.ts`);
-            }
+        if (writeFileIfChanged(indexFilePath, newExports)) {
+            filesChanged++;
+            (0, logger_1.debug)(`Generated: index.ts`);
         }
         (0, logger_1.timeEnd)('reactGen');
         (0, logger_1.success)(`React code generation completed. ${filesChanged} files changed.`);

package/dist/react.js

@@ -63,6 +63,10 @@ function getEventType(type) {
         return 'Event';
     }
     const pointerType = (0, utils_1.getPointerType)(type);
+    // Handle CustomEvent with generic parameter
+    if (pointerType.startsWith('CustomEvent<') && pointerType.endsWith('>')) {
+        return pointerType;
+    }
     if (pointerType === 'CustomEvent') {
         return 'CustomEvent';
     }
@@ -319,8 +323,15 @@ function generateReactIndex(blobs) {
     }).filter(component => {
         return component.className.length > 0;
     });
+    // Deduplicate components by className, keeping the first occurrence
+    const deduplicatedComponents = new Map();
+    components.forEach(component => {
+        if (!deduplicatedComponents.has(component.className)) {
+            deduplicatedComponents.set(component.className, component);
+        }
+    });
     const content = lodash_1.default.template(readTemplate('react.index.ts'))({
-        components,
+        components: Array.from(deduplicatedComponents.values()),
     });
     return content.split('\n').filter(str => {
         return str.trim().length > 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwebf/webf",
-  "version": "0.22.9",
+  "version": "0.22.11",
   "description": "Command line tools for WebF",
   "main": "index.js",
   "bin": {

package/src/analyzer.ts

@@ -26,7 +26,7 @@ export interface UnionTypeCollector {
 }
 
 // Cache for parsed source files to avoid re-parsing
-const sourceFileCache = new Map<string, ts.SourceFile>();
+const sourceFileCache = new Map<string, { content: string; sourceFile: ts.SourceFile }>();
 
 // Cache for type conversions to avoid redundant processing
 const typeConversionCache = new Map<string, ParameterType>();
@@ -56,11 +56,17 @@ const TYPE_REFERENCE_MAP: Record<string, FunctionArgumentType> = {
 
 export function analyzer(blob: IDLBlob, definedPropertyCollector: DefinedPropertyCollector, unionTypeCollector: UnionTypeCollector) {
   try {
-    // Check cache first
-    let sourceFile = sourceFileCache.get(blob.source);
-    if (!sourceFile) {
+    // Check cache first - consider both file path and content
+    const cacheEntry = sourceFileCache.get(blob.source);
+    let sourceFile: ts.SourceFile;
+    
+    if (cacheEntry && cacheEntry.content === blob.raw) {
+      // Cache hit with same content
+      sourceFile = cacheEntry.sourceFile;
+    } else {
+      // Cache miss or content changed - parse and update cache
       sourceFile = ts.createSourceFile(blob.source, blob.raw, ScriptTarget.ES2020);
-      sourceFileCache.set(blob.source, sourceFile);
+      sourceFileCache.set(blob.source, { content: blob.raw, sourceFile });
     }
     
     blob.objects = sourceFile.statements
@@ -324,6 +330,9 @@ function getParameterBaseType(type: ts.TypeNode, mode?: ParameterMode): Paramete
         if (mode) mode.staticMethod = true;
         return handleGenericWrapper(typeReference, mode);
         
+      case 'CustomEvent':
+        return handleCustomEventType(typeReference);
+        
       default:
         if (identifier.includes('SupportAsync')) {
           return handleSupportAsyncType(identifier, typeReference, mode);
@@ -386,6 +395,93 @@ function handleGenericWrapper(typeReference: ts.TypeReferenceNode, mode?: Parame
   return getParameterBaseType(argument, mode);
 }
 
+function handleCustomEventType(typeReference: ts.TypeReferenceNode): ParameterBaseType {
+  // Handle CustomEvent<T> by returning the full type with generic parameter
+  if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
+    return 'CustomEvent';
+  }
+  
+  const argument = typeReference.typeArguments[0];
+  let genericType: string;
+  
+  if (ts.isTypeReferenceNode(argument) && ts.isIdentifier(argument.typeName)) {
+    const typeName = argument.typeName.text;
+    
+    // Check if it's a mapped type reference like 'int' or 'double'
+    const mappedType = TYPE_REFERENCE_MAP[typeName];
+    if (mappedType !== undefined) {
+      switch (mappedType) {
+        case FunctionArgumentType.boolean:
+          genericType = 'boolean';
+          break;
+        case FunctionArgumentType.dom_string:
+          genericType = 'string';
+          break;
+        case FunctionArgumentType.double:
+        case FunctionArgumentType.int:
+          genericType = 'number';
+          break;
+        case FunctionArgumentType.any:
+          genericType = 'any';
+          break;
+        case FunctionArgumentType.void:
+          genericType = 'void';
+          break;
+        case FunctionArgumentType.function:
+          genericType = 'Function';
+          break;
+        case FunctionArgumentType.promise:
+          genericType = 'Promise<any>';
+          break;
+        default:
+          genericType = typeName;
+      }
+    } else {
+      // For other type references, use the type name directly
+      genericType = typeName;
+    }
+  } else if (ts.isLiteralTypeNode(argument) && ts.isStringLiteral(argument.literal)) {
+    genericType = argument.literal.text;
+  } else {
+    // Handle basic types (boolean, string, number, etc.)
+    const basicType = BASIC_TYPE_MAP[argument.kind];
+    if (basicType !== undefined) {
+      switch (basicType) {
+        case FunctionArgumentType.boolean:
+          genericType = 'boolean';
+          break;
+        case FunctionArgumentType.dom_string:
+          genericType = 'string';
+          break;
+        case FunctionArgumentType.double:
+        case FunctionArgumentType.int:
+          genericType = 'number';
+          break;
+        case FunctionArgumentType.any:
+          genericType = 'any';
+          break;
+        case FunctionArgumentType.void:
+          genericType = 'void';
+          break;
+        case FunctionArgumentType.null:
+          genericType = 'null';
+          break;
+        case FunctionArgumentType.undefined:
+          genericType = 'undefined';
+          break;
+        default:
+          genericType = 'any';
+      }
+    } else {
+      // For truly complex types, fallback to 'any' to avoid errors
+      console.warn('Complex generic type in CustomEvent, using any');
+      genericType = 'any';
+    }
+  }
+  
+  return `CustomEvent<${genericType}>`;
+}
+
 function handleSupportAsyncType(identifier: string, typeReference: ts.TypeReferenceNode, mode?: ParameterMode): ParameterBaseType {
   if (mode) {
     mode.supportAsync = true;

package/src/generator.ts

@@ -321,68 +321,13 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
     }
   });
   
-  // Generate or update index file
+  // Generate index file (always regenerate to avoid duplicates)
   const indexFilePath = path.join(normalizedTarget, 'src', 'index.ts');
   const newExports = generateReactIndex(blobs);
   
-  if (fs.existsSync(indexFilePath)) {
-    // Read existing index file
-    const existingContent = fs.readFileSync(indexFilePath, 'utf-8');
-    const existingLines = existingContent.split('\n');
-    
-    // Parse new exports
-    const newExportLines = newExports.split('\n').filter(line => line.startsWith('export '));
-    
-    // Find which exports are missing
-    const missingExports: string[] = [];
-    for (const newExport of newExportLines) {
-      // Extract the export statement to check if it exists
-      const exportMatch = newExport.match(/export\s*{\s*([^}]+)\s*}\s*from\s*["']([^"']+)["']/);
-      if (exportMatch) {
-        const [, exportNames, modulePath] = exportMatch;
-        const exportedItems = exportNames.split(',').map(s => s.trim());
-        
-        // Check if this exact export exists
-        const exists = existingLines.some(line => {
-          if (!line.startsWith('export ')) return false;
-          const lineMatch = line.match(/export\s*{\s*([^}]+)\s*}\s*from\s*["']([^"']+)["']/);
-          if (!lineMatch) return false;
-          const [, lineExportNames, lineModulePath] = lineMatch;
-          const lineExportedItems = lineExportNames.split(',').map(s => s.trim());
-          
-          // Check if same module and same exports
-          return lineModulePath === modulePath && 
-                 exportedItems.every(item => lineExportedItems.includes(item)) &&
-                 lineExportedItems.every(item => exportedItems.includes(item));
-        });
-        
-        if (!exists) {
-          missingExports.push(newExport);
-        }
-      }
-    }
-    
-    // If there are missing exports, append them
-    if (missingExports.length > 0) {
-      let updatedContent = existingContent.trimRight();
-      if (!updatedContent.endsWith('\n')) {
-        updatedContent += '\n';
-      }
-      updatedContent += missingExports.join('\n') + '\n';
-      
-      if (writeFileIfChanged(indexFilePath, updatedContent)) {
-        filesChanged++;
-        debug(`Updated: index.ts (added ${missingExports.length} exports)`);
-      }
-    } else {
-      debug(`Skipped: index.ts (all exports already exist)`);
-    }
-  } else {
-    // File doesn't exist, create it
-    if (writeFileIfChanged(indexFilePath, newExports)) {
-      filesChanged++;
-      debug(`Generated: index.ts`);
-    }
+  if (writeFileIfChanged(indexFilePath, newExports)) {
+    filesChanged++;
+    debug(`Generated: index.ts`);
   }
   
   timeEnd('reactGen');

package/src/react.ts

@@ -61,6 +61,12 @@ function getEventType(type: ParameterType) {
     return 'Event';
   }
   const pointerType = getPointerType(type);
+  
+  // Handle CustomEvent with generic parameter
+  if (pointerType.startsWith('CustomEvent<') && pointerType.endsWith('>')) {
+    return pointerType;
+  }
+  
   if (pointerType === 'CustomEvent') {
     return 'CustomEvent';
   }
@@ -360,8 +366,16 @@ export function generateReactIndex(blobs: IDLBlob[]) {
     return component.className.length > 0;
   });
   
+  // Deduplicate components by className, keeping the first occurrence
+  const deduplicatedComponents = new Map<string, { className: string; fileName: string; relativeDir: string }>();
+  components.forEach(component => {
+    if (!deduplicatedComponents.has(component.className)) {
+      deduplicatedComponents.set(component.className, component);
+    }
+  });
+  
   const content = _.template(readTemplate('react.index.ts'))({
-    components,
+    components: Array.from(deduplicatedComponents.values()),
   });
 
   return content.split('\n').filter(str => {