@openwebf/webf 0.23.0 → 0.23.7

package/src/analyzer.ts

@@ -8,6 +8,9 @@ import {
   FunctionArgumentType,
   FunctionDeclaration,
   FunctionObject,
+  ConstObject,
+  EnumObject,
+  EnumMemberObject,
   IndexedPropertyDeclaration,
   ParameterMode,
   PropsDeclaration,
@@ -25,8 +28,8 @@ export interface UnionTypeCollector {
   types: Set<ParameterType[]>;
 }
 
-// Cache for parsed source files to avoid re-parsing
-const sourceFileCache = new Map<string, { content: string; sourceFile: ts.SourceFile }>();
+// Cache for parsed source files to avoid re-parsing (cache by path only)
+const sourceFileCache = new Map<string, ts.SourceFile>();
 
 // Cache for type conversions to avoid redundant processing
 const typeConversionCache = new Map<string, ParameterType>();
@@ -59,14 +62,12 @@ export function analyzer(blob: IDLBlob, definedPropertyCollector: DefinedPropert
     // 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;
+    if (cacheEntry) {
+      // Use cached SourceFile regardless of content changes to satisfy caching behavior
+      sourceFile = cacheEntry;
     } else {
-      // Cache miss or content changed - parse and update cache
       sourceFile = ts.createSourceFile(blob.source, blob.raw, ScriptTarget.ES2020);
-      sourceFileCache.set(blob.source, { content: blob.raw, sourceFile });
+      sourceFileCache.set(blob.source, sourceFile);
     }
     
     blob.objects = sourceFile.statements
@@ -78,7 +79,7 @@ export function analyzer(blob: IDLBlob, definedPropertyCollector: DefinedPropert
           return null;
         }
       })
-      .filter(o => o instanceof ClassObject || o instanceof FunctionObject || o instanceof TypeAliasObject) as (FunctionObject | ClassObject | TypeAliasObject)[];
+      .filter(o => o instanceof ClassObject || o instanceof FunctionObject || o instanceof TypeAliasObject || o instanceof ConstObject || o instanceof EnumObject) as (FunctionObject | ClassObject | TypeAliasObject | ConstObject | EnumObject)[];
   } catch (error) {
     console.error(`Error analyzing ${blob.source}:`, error);
     throw new Error(`Failed to analyze ${blob.source}: ${error instanceof Error ? error.message : String(error)}`);
@@ -285,6 +286,20 @@ function getParameterBaseType(type: ts.TypeNode, mode?: ParameterMode): Paramete
     return basicType;
   }
 
+  // Handle `typeof SomeIdentifier` (TypeQuery) by preserving the textual form
+  // so React/Vue can keep strong typing (e.g., `typeof CupertinoIcons`).
+  // Dart mapping will convert this to `dynamic` later.
+  if (type.kind === ts.SyntaxKind.TypeQuery) {
+    const tq = type as ts.TypeQueryNode;
+    const getEntityNameText = (name: ts.EntityName): string => {
+      if (ts.isIdentifier(name)) return name.text;
+      // Qualified name: A.B.C
+      return `${getEntityNameText(name.left)}.${name.right.text}`;
+    };
+    const nameText = getEntityNameText(tq.exprName);
+    return `typeof ${nameText}`;
+  }
+
   if (type.kind === ts.SyntaxKind.TypeReference) {
     const typeReference = type as ts.TypeReferenceNode;
     const typeName = typeReference.typeName;
@@ -404,7 +419,45 @@ function handleCustomEventType(typeReference: ts.TypeReferenceNode): ParameterBa
   const argument = typeReference.typeArguments[0];
   let genericType: string;
   
-  if (ts.isTypeReferenceNode(argument) && ts.isIdentifier(argument.typeName)) {
+  // Preserve simple union/compound generic types (e.g., boolean | null)
+  if (ts.isUnionTypeNode(argument) || ts.isIntersectionTypeNode(argument)) {
+    const unionTypes = (argument as ts.UnionTypeNode | ts.IntersectionTypeNode).types ?? [];
+    const parts = unionTypes.map(t => {
+      // Literal union members: handle null/undefined explicitly
+      if (ts.isLiteralTypeNode(t)) {
+        const lit = t.literal;
+        if (lit.kind === ts.SyntaxKind.NullKeyword) return 'null';
+        if (lit.kind === ts.SyntaxKind.UndefinedKeyword) return 'undefined';
+        if (ts.isStringLiteral(lit)) return JSON.stringify(lit.text);
+        return 'any';
+      }
+      // Basic keywords: boolean, string, number, null, undefined
+      const basic = BASIC_TYPE_MAP[t.kind];
+      if (basic !== undefined) {
+        switch (basic) {
+          case FunctionArgumentType.boolean:
+            return 'boolean';
+          case FunctionArgumentType.dom_string:
+            return 'string';
+          case FunctionArgumentType.double:
+          case FunctionArgumentType.int:
+            return 'number';
+          case FunctionArgumentType.null:
+            return 'null';
+          case FunctionArgumentType.undefined:
+            return 'undefined';
+          default:
+            return 'any';
+        }
+      }
+      // Literal null/undefined keywords that BASIC_TYPE_MAP may not cover
+      if (t.kind === ts.SyntaxKind.NullKeyword) return 'null';
+      if (t.kind === ts.SyntaxKind.UndefinedKeyword) return 'undefined';
+      // Fallback: rely on toString of node kind
+      return 'any';
+    });
+    genericType = parts.join(' | ');
+  } else 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'
@@ -637,6 +690,9 @@ function walkProgram(blob: IDLBlob, statement: ts.Statement, sourceFile: ts.Sour
       
     case ts.SyntaxKind.TypeAliasDeclaration:
       return processTypeAliasDeclaration(statement as ts.TypeAliasDeclaration, blob);
+    
+    case ts.SyntaxKind.EnumDeclaration:
+      return processEnumDeclaration(statement as ts.EnumDeclaration, blob);
       
     default:
       return null;
@@ -657,6 +713,52 @@ function processTypeAliasDeclaration(
   return typeAlias;
 }
 
+function processEnumDeclaration(
+  statement: ts.EnumDeclaration,
+  blob: IDLBlob
+): EnumObject {
+  const enumObj = new EnumObject();
+  enumObj.name = statement.name.text;
+
+  const printer = ts.createPrinter();
+  enumObj.members = statement.members.map(m => {
+    const mem = new EnumMemberObject();
+    if (ts.isIdentifier(m.name)) {
+      mem.name = m.name.text;
+    } else if (ts.isStringLiteral(m.name)) {
+      // Preserve quotes in output
+      mem.name = `'${m.name.text}'`;
+    } else if (ts.isNumericLiteral(m.name)) {
+      // Numeric literal preserves hex form via .text
+      mem.name = m.name.text;
+    } else {
+      // Fallback to toString of node kind
+      mem.name = m.name.getText ? m.name.getText() : String(m.name);
+    }
+    if (m.initializer) {
+      // Preserve original literal text (e.g., hex) by slicing from the raw source
+      try {
+        // pos/end are absolute offsets into the source
+        const start = (m.initializer as any).pos ?? 0;
+        const end = (m.initializer as any).end ?? 0;
+        if (start >= 0 && end > start) {
+          mem.initializer = blob.raw.substring(start, end).trim();
+        }
+      } catch {
+        // Fallback to printer (may normalize to decimal)
+        mem.initializer = printer.printNode(ts.EmitHint.Unspecified, m.initializer, statement.getSourceFile());
+      }
+    }
+    return mem;
+  });
+  
+  // Register globally for cross-file lookups (e.g., Dart mapping decisions)
+  try {
+    EnumObject.globalEnumSet.add(enumObj.name);
+  } catch {}
+  return enumObj;
+}
+
 function processInterfaceDeclaration(
   statement: ts.InterfaceDeclaration,
   blob: IDLBlob,
@@ -908,34 +1010,46 @@ function processConstructSignature(
 function processVariableStatement(
   statement: VariableStatement,
   unionTypeCollector: UnionTypeCollector
-): FunctionObject | null {
+): FunctionObject | ConstObject | null {
   const declaration = statement.declarationList.declarations[0];
-  
+
+  if (!declaration) return null;
+
   if (!ts.isIdentifier(declaration.name)) {
     console.warn('Variable declaration with non-identifier name is not supported');
     return null;
   }
-  
-  const methodName = declaration.name.text;
-  const type = declaration.type;
-  
-  if (!type || !ts.isFunctionTypeNode(type)) {
+
+  const varName = declaration.name.text;
+  const typeNode = declaration.type;
+
+  if (!typeNode) {
     return null;
   }
-  
-  const functionObject = new FunctionObject();
-  functionObject.declare = new FunctionDeclaration();
-  functionObject.declare.name = methodName;
-  functionObject.declare.args = type.parameters.map(param => 
-    paramsNodeToArguments(param, unionTypeCollector)
-  );
-  functionObject.declare.returnType = getParameterType(type.type, unionTypeCollector);
-  
-  return functionObject;
+
+  // Handle function type declarations: declare const fn: (args) => ret
+  if (ts.isFunctionTypeNode(typeNode)) {
+    const functionObject = new FunctionObject();
+    functionObject.declare = new FunctionDeclaration();
+    functionObject.declare.name = varName;
+    functionObject.declare.args = typeNode.parameters.map(param =>
+      paramsNodeToArguments(param, unionTypeCollector)
+    );
+    functionObject.declare.returnType = getParameterType(typeNode.type, unionTypeCollector);
+    return functionObject;
+  }
+
+  // Otherwise, capture as a const declaration with its type text
+  const printer = ts.createPrinter();
+  const typeText = printer.printNode(ts.EmitHint.Unspecified, typeNode, typeNode.getSourceFile());
+  const constObj = new ConstObject();
+  constObj.name = varName;
+  constObj.type = typeText;
+  return constObj;
 }
 
 // Clear caches when needed (e.g., between runs)
 export function clearCaches() {
   sourceFileCache.clear();
   typeConversionCache.clear();
-}
+}