@openwebf/webf 0.23.0 → 0.23.7

package/src/dart.ts

@@ -2,9 +2,9 @@ import _ from "lodash";
 import fs from 'fs';
 import path from 'path';
 import {ParameterType} from "./analyzer";
-import {ClassObject, FunctionArgumentType, FunctionDeclaration, TypeAliasObject, PropsDeclaration} from "./declaration";
+import {ClassObject, FunctionArgumentType, FunctionDeclaration, TypeAliasObject, PropsDeclaration, EnumObject} from "./declaration";
 import {IDLBlob} from "./IDLBlob";
-import {getPointerType, isPointerType} from "./utils";
+import {getPointerType, isPointerType, trimNullTypeFromType} from "./utils";
 
 function readTemplate(name: string) {
   return fs.readFileSync(path.join(__dirname, '../templates/' + name + '.tpl'), {encoding: 'utf-8'});
@@ -82,20 +82,59 @@ ${enumValues};
 }`
 }
 
+function hasNullInUnion(type: ParameterType): boolean {
+  if (!Array.isArray(type.value)) return false;
+  return type.value.some(t => t.value === FunctionArgumentType.null);
+}
+
+function isBooleanType(type: ParameterType): boolean {
+  if (Array.isArray(type.value)) {
+    return type.value.some(t => t.value === FunctionArgumentType.boolean);
+  }
+  return type.value === FunctionArgumentType.boolean;
+}
+
 function generateReturnType(type: ParameterType, enumName?: string) {
   // Handle union types first (e.g., 'left' | 'center' | 'right')
   // so we don't incorrectly treat string literal unions as pointer types.
   if (Array.isArray(type.value)) {
-    // If we have an enum name, use it; otherwise fall back to String
-    return enumName || 'String';
+    // If we have an enum name, always use it (nullable handled separately)
+    if (enumName) {
+      return enumName;
+    }
+
+    // If this is a union that includes null and exactly one non-null type,
+    // generate the Dart type from the non-null part instead of falling back to String.
+    const trimmed = trimNullTypeFromType(type);
+    if (!Array.isArray(trimmed.value)) {
+      return generateReturnType(trimmed, enumName);
+    }
+
+    // Fallback for complex unions: use String
+    return 'String';
   }
 
   if (isPointerType(type)) {
     const pointerType = getPointerType(type);
+    // Map TS typeof expressions to Dart dynamic
+    if (typeof pointerType === 'string' && pointerType.startsWith('typeof ')) {
+      return 'dynamic';
+    }
+    // Map references to known string enums to String in Dart
+    if (typeof pointerType === 'string' && EnumObject.globalEnumSet.has(pointerType)) {
+      return 'String';
+    }
     return pointerType;
   }
   if (type.isArray && typeof type.value === 'object' && !Array.isArray(type.value)) {
-    return `${getPointerType(type.value)}[]`;
+    const elem = getPointerType(type.value);
+    if (typeof elem === 'string' && elem.startsWith('typeof ')) {
+      return `dynamic[]`;
+    }
+    if (typeof elem === 'string' && EnumObject.globalEnumSet.has(elem)) {
+      return 'String[]';
+    }
+    return `${elem}[]`;
   }
   
   // Handle when type.value is a ParameterType object (nested type)
@@ -112,7 +151,8 @@ function generateReturnType(type: ParameterType, enumName?: string) {
       return 'double';
     }
     case FunctionArgumentType.any: {
-      return 'any';
+      // Dart doesn't have `any`; use `dynamic`.
+      return 'dynamic';
     }
     case FunctionArgumentType.boolean: {
       return 'bool';
@@ -143,13 +183,23 @@ function generateEventHandlerType(type: ParameterType) {
 
 function generateAttributeSetter(propName: string, type: ParameterType, enumName?: string): string {
   // Attributes from HTML are always strings, so we need to convert them
-  
+
+  const unionHasNull = hasNullInUnion(type);
+
   // Handle enum types
   if (enumName && Array.isArray(type.value)) {
+    if (unionHasNull) {
+      return `${propName} = value == 'null' ? null : ${enumName}.parse(value)`;
+    }
     return `${propName} = ${enumName}.parse(value)`;
   }
-  
-  switch (type.value) {
+
+  const effectiveType: ParameterType = Array.isArray(type.value) && unionHasNull
+    ? trimNullTypeFromType(type)
+    : type;
+
+  const baseSetter = (() => {
+    switch (effectiveType.value) {
     case FunctionArgumentType.boolean:
       return `${propName} = value == 'true' || value == ''`;
     case FunctionArgumentType.int:
@@ -159,30 +209,43 @@ function generateAttributeSetter(propName: string, type: ParameterType, enumName
     default:
       // String and other types can be assigned directly
       return `${propName} = value`;
+    }
+  })();
+
+  if (unionHasNull) {
+    const assignmentPrefix = `${propName} = `;
+    const rhs = baseSetter.startsWith(assignmentPrefix)
+      ? baseSetter.slice(assignmentPrefix.length)
+      : 'value';
+    return `${propName} = value == 'null' ? null : (${rhs})`;
   }
+
+  return baseSetter;
 }
 
-function generateAttributeGetter(propName: string, type: ParameterType, optional: boolean, enumName?: string): string {
+function generateAttributeGetter(propName: string, type: ParameterType, isNullable: boolean, enumName?: string): string {
   // Handle enum types
   if (enumName && Array.isArray(type.value)) {
-    return optional ? `${propName}?.value` : `${propName}.value`;
+    return isNullable ? `${propName}?.value` : `${propName}.value`;
   }
   
   // Handle nullable properties - they should return null if the value is null
-  if (optional && type.value !== FunctionArgumentType.boolean) {
+  if (isNullable) {
     // For nullable properties, we need to handle null values properly
     return `${propName}?.toString()`;
   }
-  // For non-nullable properties (including booleans), always convert to string
+  // For non-nullable properties, always convert to string
   return `${propName}.toString()`;
 }
 
 function generateAttributeDeleter(propName: string, type: ParameterType, optional: boolean): string {
   // When deleting an attribute, we should reset it to its default value
+  if (isBooleanType(type)) {
+    // Booleans (including unions with null) default to false
+    return `${propName} = false`;
+  }
+
   switch (type.value) {
-    case FunctionArgumentType.boolean:
-      // Booleans default to false
-      return `${propName} = false`;
     case FunctionArgumentType.int:
       // Integers default to 0
       return `${propName} = 0`;
@@ -216,10 +279,21 @@ function generateMethodDeclaration(method: FunctionDeclaration) {
 }
 
 function shouldMakeNullable(prop: any): boolean {
-  // Boolean properties should never be nullable in Dart, even if optional in TypeScript
-  if (prop.type.value === FunctionArgumentType.boolean) {
+  const type: ParameterType = prop.type;
+
+  // Boolean properties are only nullable in Dart when explicitly unioned with `null`.
+  if (isBooleanType(type)) {
+    return hasNullInUnion(type);
+  }
+  // Dynamic (any) should not use nullable syntax; dynamic already allows null
+  if (type.value === FunctionArgumentType.any) {
     return false;
   }
+  // Properties with an explicit `null` in their type should be nullable,
+  // even if they are not marked optional in TypeScript.
+  if (hasNullInUnion(type)) {
+    return true;
+  }
   // Other optional properties remain nullable
   return prop.optional;
 }
@@ -317,8 +391,9 @@ interface ${object.name} {
     generateAttributeSetter: (propName: string, type: ParameterType) => {
       return generateAttributeSetter(propName, type, enumMap.get(propName));
     },
-    generateAttributeGetter: (propName: string, type: ParameterType, optional: boolean) => {
-      return generateAttributeGetter(propName, type, optional, enumMap.get(propName));
+    generateAttributeGetter: (propName: string, type: ParameterType, optional: boolean, prop?: PropsDeclaration) => {
+      const isNullable = prop ? shouldMakeNullable(prop) : optional;
+      return generateAttributeGetter(propName, type, isNullable, enumMap.get(propName));
     },
     generateAttributeDeleter,
     shouldMakeNullable,

package/src/declaration.ts

@@ -89,3 +89,19 @@ export class TypeAliasObject {
   name: string;
   type: string;
 }
+
+export class ConstObject {
+  name: string;
+  type: string;
+}
+
+export class EnumMemberObject {
+  name: string;
+  initializer?: string;
+}
+
+export class EnumObject {
+  name: string;
+  members: EnumMemberObject[] = [];
+  static globalEnumSet: Set<string> = new Set<string>();
+}

package/src/generator.ts

@@ -5,7 +5,7 @@ import _ from 'lodash';
 import { glob } from 'glob';
 import yaml from 'yaml';
 import { IDLBlob } from './IDLBlob';
-import { ClassObject } from './declaration';
+import { ClassObject, ConstObject, EnumObject, TypeAliasObject } from './declaration';
 import { analyzer, ParameterType, clearCaches } from './analyzer';
 import { generateDartClass } from './dart';
 import { generateReactComponent, generateReactIndex } from './react';
@@ -205,13 +205,17 @@ export async function dartGen({ source, target, command, exclude }: GenerateOpti
         fs.mkdirSync(outputDir, { recursive: true });
       }
       
-      // Generate Dart file
+      // Generate Dart file (skip if empty)
       const genFilePath = path.join(outputDir, _.snakeCase(blob.filename));
       const fullPath = genFilePath + '_bindings_generated.dart';
       
-      if (writeFileIfChanged(fullPath, result)) {
-        filesChanged++;
-        debug(`Generated: ${path.basename(fullPath)}`);
+      if (result && result.trim().length > 0) {
+        if (writeFileIfChanged(fullPath, result)) {
+          filesChanged++;
+          debug(`Generated: ${path.basename(fullPath)}`);
+        }
+      } else {
+        debug(`Skipped ${path.basename(fullPath)} - empty bindings`);
       }
       
       // Copy the original .d.ts file to the output directory
@@ -225,13 +229,8 @@ export async function dartGen({ source, target, command, exclude }: GenerateOpti
     }
   });
   
-  // Generate index.d.ts file with references to all .d.ts files
-  const indexDtsContent = generateTypeScriptIndex(blobs, normalizedTarget);
-  const indexDtsPath = path.join(normalizedTarget, 'index.d.ts');
-  if (writeFileIfChanged(indexDtsPath, indexDtsContent)) {
-    filesChanged++;
-    debug('Generated: index.d.ts');
-  }
+  // Note: We no longer generate a root index.d.ts for Dart codegen
+  // as it is not necessary for the codegen workflow.
   
   timeEnd('dartGen');
   success(`Dart code generation completed. ${filesChanged} files changed.`);
@@ -316,6 +315,8 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
       if (writeFileIfChanged(fullPath, result)) {
         filesChanged++;
         debug(`Generated: ${path.basename(fullPath)}`);
+        // Emit a short preview for debugging when WEBF_DEBUG is on
+        debug(`Preview (${path.basename(fullPath)}):\n` + result.split('\n').slice(0, 12).join('\n'));
       }
     } catch (err) {
       error(`Error generating React component for ${blob.filename}`, err);
@@ -324,6 +325,8 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
   
   // Generate/merge index file
   const indexFilePath = path.join(normalizedTarget, 'src', 'index.ts');
+  // Always build the full index content string for downstream tooling/logging
+  const newExports = generateReactIndex(blobs);
 
   // Build desired export map: moduleSpecifier -> Set of names
   const desiredExports = new Map<string, Set<string>>();
@@ -356,7 +359,6 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
 
   if (!fs.existsSync(indexFilePath)) {
     // No index.ts -> generate fresh file from template
-    const newExports = generateReactIndex(blobs);
     if (writeFileIfChanged(indexFilePath, newExports)) {
       filesChanged++;
       debug(`Generated: index.ts`);
@@ -410,6 +412,72 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
   success(`React code generation completed. ${filesChanged} files changed.`);
   info(`Output directory: ${normalizedTarget}`);
   info('You can now import these components in your React project.');
+
+  // Aggregate standalone type declarations (consts/enums/type aliases) into a single types.ts
+  try {
+    const consts = blobs.flatMap(b => b.objects.filter(o => o instanceof ConstObject) as ConstObject[]);
+    const enums = blobs.flatMap(b => b.objects.filter(o => o instanceof EnumObject) as EnumObject[]);
+    const typeAliases = blobs.flatMap(b => b.objects.filter(o => o instanceof TypeAliasObject) as TypeAliasObject[]);
+
+    // Deduplicate by name
+    const constMap = new Map<string, ConstObject>();
+    consts.forEach(c => { if (!constMap.has(c.name)) constMap.set(c.name, c); });
+    const typeAliasMap = new Map<string, TypeAliasObject>();
+    typeAliases.forEach(t => { if (!typeAliasMap.has(t.name)) typeAliasMap.set(t.name, t); });
+
+    const hasAny = constMap.size > 0 || enums.length > 0 || typeAliasMap.size > 0;
+    if (hasAny) {
+      const constDecl = Array.from(constMap.values())
+        .map(c => `export declare const ${c.name}: ${c.type};`)
+        .join('\n');
+      const enumDecl = enums
+        .map(e => `export enum ${e.name} { ${e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ')} }`)
+        .join('\n');
+      const typeAliasDecl = Array.from(typeAliasMap.values())
+        .map(t => `export type ${t.name} = ${t.type};`)
+        .join('\n');
+
+      const typesContent = [
+        '/* Generated by WebF CLI - aggregated type declarations */',
+        typeAliasDecl,
+        constDecl,
+        enumDecl,
+        ''
+      ].filter(Boolean).join('\n');
+
+      const typesPath = path.join(normalizedTarget, 'src', 'types.ts');
+      if (writeFileIfChanged(typesPath, typesContent)) {
+        filesChanged++;
+        debug(`Generated: src/types.ts`);
+        try {
+          const constNames = Array.from(constMap.keys());
+          const aliasNames = Array.from(typeAliasMap.keys());
+          const enumNames = enums.map(e => e.name);
+          debug(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
+          debug(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
+        } catch {}
+      }
+
+      // Ensure index.ts re-exports these types so consumers get them on import.
+      const indexFilePath = path.join(normalizedTarget, 'src', 'index.ts');
+      try {
+        let current = '';
+        if (fs.existsSync(indexFilePath)) {
+          current = fs.readFileSync(indexFilePath, 'utf-8');
+        }
+        const exportLine = `export * from './types';`;
+        if (!current.includes(exportLine)) {
+          const updated = current.trim().length ? `${current.trim()}\n${exportLine}\n` : `${exportLine}\n`;
+          if (writeFileIfChanged(indexFilePath, updated)) {
+            filesChanged++;
+            debug(`Updated: src/index.ts to export aggregated types`);
+          }
+        }
+      } catch {}
+    }
+  } catch (e) {
+    warn('Failed to generate aggregated React types');
+  }
 }
 
 export async function vueGen({ source, target, exclude }: GenerateOptions) {