@openwebf/webf 0.23.2 → 0.23.7

package/dist/vue.js

@@ -8,17 +8,61 @@ const lodash_1 = __importDefault(require("lodash"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const declaration_1 = require("./declaration");
+const logger_1 = require("./logger");
 const utils_1 = require("./utils");
 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)) {
+        const values = type.value;
+        return values.map(v => {
+            if (v.value === declaration_1.FunctionArgumentType.null) {
+                return 'null';
+            }
+            if (typeof v.value === 'string') {
+                return `'${v.value}'`;
+            }
+            return 'any';
+        }).join(' | ');
+    }
+    // Handle unions like boolean | null, number | null, CustomType | null
+    if (Array.isArray(type.value)) {
+        const values = type.value;
+        const hasNull = values.some(v => v.value === declaration_1.FunctionArgumentType.null);
+        if (hasNull) {
+            const nonNulls = values.filter(v => v.value !== declaration_1.FunctionArgumentType.null);
+            if (nonNulls.length === 0) {
+                return 'null';
+            }
+            const parts = nonNulls.map(v => generateReturnType(v));
+            const unique = Array.from(new Set(parts));
+            unique.push('null');
+            return unique.join(' | ');
+        }
+        // Complex non-null unions are rare; fall back to any
+        return 'any';
+    }
     if ((0, utils_1.isPointerType)(type)) {
         const pointerType = (0, utils_1.getPointerType)(type);
+        // Map Dart's `Type` (from TS typeof) to TS `any`
+        if (pointerType === 'Type')
+            return 'any';
+        if (typeof pointerType === 'string' && pointerType.startsWith('typeof ')) {
+            const ident = pointerType.substring('typeof '.length).trim();
+            return `typeof __webfTypes.${ident}`;
+        }
         return pointerType;
     }
     if (type.isArray && typeof type.value === 'object' && !Array.isArray(type.value)) {
-        return `${(0, utils_1.getPointerType)(type.value)}[]`;
+        const elemType = (0, utils_1.getPointerType)(type.value);
+        if (elemType === 'Type')
+            return 'any[]';
+        if (typeof elemType === 'string' && elemType.startsWith('typeof ')) {
+            const ident = elemType.substring('typeof '.length).trim();
+            return `(typeof __webfTypes.${ident})[]`;
+        }
+        return `${elemType}[]`;
     }
     switch (type.value) {
         case declaration_1.FunctionArgumentType.int:
@@ -87,19 +131,34 @@ function generateVueComponent(blob) {
             && !object.name.endsWith('Events');
     });
     const dependencies = others.map(object => {
-        if (!object || !object.props) {
+        if (!object || !object.props || object.props.length === 0) {
             return '';
         }
-        const props = object.props.map(prop => {
-            if (prop.optional) {
-                return `${prop.name}?: ${generateReturnType(prop.type)};`;
+        const interfaceLines = [];
+        if (object.documentation && object.documentation.trim().length > 0) {
+            interfaceLines.push('/**');
+            object.documentation.split('\n').forEach(line => {
+                interfaceLines.push(` * ${line}`);
+            });
+            interfaceLines.push(' */');
+        }
+        interfaceLines.push(`interface ${object.name} {`);
+        const propLines = object.props.map(prop => {
+            const lines = [];
+            if (prop.documentation && prop.documentation.trim().length > 0) {
+                lines.push('  /**');
+                prop.documentation.split('\n').forEach(line => {
+                    lines.push(`   * ${line}`);
+                });
+                lines.push('   */');
             }
-            return `${prop.name}: ${generateReturnType(prop.type)};`;
-        }).join('\n  ');
-        return `
-interface ${object.name} {
-  ${props}
-}`;
+            const optionalToken = prop.optional ? '?' : '';
+            lines.push(`  ${prop.name}${optionalToken}: ${generateReturnType(prop.type)};`);
+            return lines.join('\n');
+        });
+        interfaceLines.push(propLines.join('\n'));
+        interfaceLines.push('}');
+        return interfaceLines.join('\n');
     }).filter(dep => dep.trim() !== '').join('\n\n');
     const componentProperties = properties.length > 0 ? properties[0] : undefined;
     const componentEvents = events.length > 0 ? events[0] : undefined;
@@ -192,6 +251,9 @@ function generateVueTypings(blobs) {
         const members = e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ');
         return `export declare enum ${e.name} { ${members} }`;
     }).join('\n');
+    // Always import the types namespace to support typeof references
+    const typesImport = `import * as __webfTypes from './src/types';`;
+    (0, logger_1.debug)(`[vue] Generating typings; importing types from ./src/types`);
     // Build mapping of template tag names to class names for GlobalComponents
     const componentMetas = componentNames.map(className => ({
         className,
@@ -207,6 +269,7 @@ function generateVueTypings(blobs) {
         components,
         consts: constDeclarations,
         enums: enumDeclarations,
+        typesImport,
     });
     return content.split('\n').filter(str => {
         return str.trim().length > 0;

package/package.json

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

package/src/analyzer.ts

@@ -286,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;
@@ -405,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'
@@ -699,7 +751,11 @@ function processEnumDeclaration(
     }
     return mem;
   });
-
+  
+  // Register globally for cross-file lookups (e.g., Dart mapping decisions)
+  try {
+    EnumObject.globalEnumSet.add(enumObj.name);
+  } catch {}
   return enumObj;
 }