@openwebf/webf 0.23.0 → 0.23.7

package/dist/dart.js

@@ -79,19 +79,55 @@ ${enumValues};
   String toString() => value;
 }`;
 }
+function hasNullInUnion(type) {
+    if (!Array.isArray(type.value))
+        return false;
+    return type.value.some(t => t.value === declaration_1.FunctionArgumentType.null);
+}
+function isBooleanType(type) {
+    if (Array.isArray(type.value)) {
+        return type.value.some(t => t.value === declaration_1.FunctionArgumentType.boolean);
+    }
+    return type.value === declaration_1.FunctionArgumentType.boolean;
+}
 function generateReturnType(type, enumName) {
     // 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 = (0, utils_1.trimNullTypeFromType)(type);
+        if (!Array.isArray(trimmed.value)) {
+            return generateReturnType(trimmed, enumName);
+        }
+        // Fallback for complex unions: use String
+        return 'String';
     }
     if ((0, utils_1.isPointerType)(type)) {
         const pointerType = (0, utils_1.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' && declaration_1.EnumObject.globalEnumSet.has(pointerType)) {
+            return 'String';
+        }
         return pointerType;
     }
     if (type.isArray && typeof type.value === 'object' && !Array.isArray(type.value)) {
-        return `${(0, utils_1.getPointerType)(type.value)}[]`;
+        const elem = (0, utils_1.getPointerType)(type.value);
+        if (typeof elem === 'string' && elem.startsWith('typeof ')) {
+            return `dynamic[]`;
+        }
+        if (typeof elem === 'string' && declaration_1.EnumObject.globalEnumSet.has(elem)) {
+            return 'String[]';
+        }
+        return `${elem}[]`;
     }
     // Handle when type.value is a ParameterType object (nested type)
     if (typeof type.value === 'object' && !Array.isArray(type.value) && type.value !== null) {
@@ -106,7 +142,8 @@ function generateReturnType(type, enumName) {
             return 'double';
         }
         case declaration_1.FunctionArgumentType.any: {
-            return 'any';
+            // Dart doesn't have `any`; use `dynamic`.
+            return 'dynamic';
         }
         case declaration_1.FunctionArgumentType.boolean: {
             return 'bool';
@@ -135,41 +172,59 @@ function generateEventHandlerType(type) {
 }
 function generateAttributeSetter(propName, type, enumName) {
     // 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) {
-        case declaration_1.FunctionArgumentType.boolean:
-            return `${propName} = value == 'true' || value == ''`;
-        case declaration_1.FunctionArgumentType.int:
-            return `${propName} = int.tryParse(value) ?? 0`;
-        case declaration_1.FunctionArgumentType.double:
-            return `${propName} = double.tryParse(value) ?? 0.0`;
-        default:
-            // String and other types can be assigned directly
-            return `${propName} = value`;
+    const effectiveType = Array.isArray(type.value) && unionHasNull
+        ? (0, utils_1.trimNullTypeFromType)(type)
+        : type;
+    const baseSetter = (() => {
+        switch (effectiveType.value) {
+            case declaration_1.FunctionArgumentType.boolean:
+                return `${propName} = value == 'true' || value == ''`;
+            case declaration_1.FunctionArgumentType.int:
+                return `${propName} = int.tryParse(value) ?? 0`;
+            case declaration_1.FunctionArgumentType.double:
+                return `${propName} = double.tryParse(value) ?? 0.0`;
+            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, type, optional, enumName) {
+function generateAttributeGetter(propName, type, isNullable, enumName) {
     // 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 !== declaration_1.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, type, optional) {
     // 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 declaration_1.FunctionArgumentType.boolean:
-            // Booleans default to false
-            return `${propName} = false`;
         case declaration_1.FunctionArgumentType.int:
             // Integers default to 0
             return `${propName} = 0`;
@@ -201,10 +256,20 @@ function generateMethodDeclaration(method) {
     return `${methodName}(${args}): ${returnType};`;
 }
 function shouldMakeNullable(prop) {
-    // Boolean properties should never be nullable in Dart, even if optional in TypeScript
-    if (prop.type.value === declaration_1.FunctionArgumentType.boolean) {
+    const type = 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 === declaration_1.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;
 }
@@ -287,8 +352,9 @@ interface ${object.name} {
         generateAttributeSetter: (propName, type) => {
             return generateAttributeSetter(propName, type, enumMap.get(propName));
         },
-        generateAttributeGetter: (propName, type, optional) => {
-            return generateAttributeGetter(propName, type, optional, enumMap.get(propName));
+        generateAttributeGetter: (propName, type, optional, prop) => {
+            const isNullable = prop ? shouldMakeNullable(prop) : optional;
+            return generateAttributeGetter(propName, type, isNullable, enumMap.get(propName));
         },
         generateAttributeDeleter,
         shouldMakeNullable,

package/dist/declaration.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeAliasObject = exports.FunctionObject = exports.ClassObject = exports.ClassObjectKind = exports.FunctionDeclaration = exports.IndexedPropertyDeclaration = exports.PropsDeclaration = exports.ParameterMode = exports.FunctionArguments = exports.FunctionArgumentType = void 0;
+exports.EnumObject = exports.EnumMemberObject = exports.ConstObject = exports.TypeAliasObject = exports.FunctionObject = exports.ClassObject = exports.ClassObjectKind = exports.FunctionDeclaration = exports.IndexedPropertyDeclaration = exports.PropsDeclaration = exports.ParameterMode = exports.FunctionArguments = exports.FunctionArgumentType = void 0;
 var FunctionArgumentType;
 (function (FunctionArgumentType) {
     // Basic types
@@ -61,3 +61,16 @@ exports.FunctionObject = FunctionObject;
 class TypeAliasObject {
 }
 exports.TypeAliasObject = TypeAliasObject;
+class ConstObject {
+}
+exports.ConstObject = ConstObject;
+class EnumMemberObject {
+}
+exports.EnumMemberObject = EnumMemberObject;
+class EnumObject {
+    constructor() {
+        this.members = [];
+    }
+}
+exports.EnumObject = EnumObject;
+EnumObject.globalEnumSet = new Set();

package/dist/generator.js

@@ -187,12 +187,17 @@ function dartGen(_a) {
                 if (!fs_1.default.existsSync(outputDir)) {
                     fs_1.default.mkdirSync(outputDir, { recursive: true });
                 }
-                // Generate Dart file
+                // Generate Dart file (skip if empty)
                 const genFilePath = path_1.default.join(outputDir, lodash_1.default.snakeCase(blob.filename));
                 const fullPath = genFilePath + '_bindings_generated.dart';
-                if (writeFileIfChanged(fullPath, result)) {
-                    filesChanged++;
-                    (0, logger_1.debug)(`Generated: ${path_1.default.basename(fullPath)}`);
+                if (result && result.trim().length > 0) {
+                    if (writeFileIfChanged(fullPath, result)) {
+                        filesChanged++;
+                        (0, logger_1.debug)(`Generated: ${path_1.default.basename(fullPath)}`);
+                    }
+                }
+                else {
+                    (0, logger_1.debug)(`Skipped ${path_1.default.basename(fullPath)} - empty bindings`);
                 }
                 // Copy the original .d.ts file to the output directory
                 const dtsOutputPath = path_1.default.join(outputDir, blob.filename + '.d.ts');
@@ -205,13 +210,8 @@ function dartGen(_a) {
                 (0, logger_1.error)(`Error generating Dart code for ${blob.filename}`, err);
             }
         }));
-        // Generate index.d.ts file with references to all .d.ts files
-        const indexDtsContent = generateTypeScriptIndex(blobs, normalizedTarget);
-        const indexDtsPath = path_1.default.join(normalizedTarget, 'index.d.ts');
-        if (writeFileIfChanged(indexDtsPath, indexDtsContent)) {
-            filesChanged++;
-            (0, logger_1.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.
         (0, logger_1.timeEnd)('dartGen');
         (0, logger_1.success)(`Dart code generation completed. ${filesChanged} files changed.`);
         (0, logger_1.info)(`Output directory: ${normalizedTarget}`);
@@ -282,6 +282,8 @@ function reactGen(_a) {
                 if (writeFileIfChanged(fullPath, result)) {
                     filesChanged++;
                     (0, logger_1.debug)(`Generated: ${path_1.default.basename(fullPath)}`);
+                    // Emit a short preview for debugging when WEBF_DEBUG is on
+                    (0, logger_1.debug)(`Preview (${path_1.default.basename(fullPath)}):\n` + result.split('\n').slice(0, 12).join('\n'));
                 }
             }
             catch (err) {
@@ -290,6 +292,8 @@ function reactGen(_a) {
         }));
         // Generate/merge index file
         const indexFilePath = path_1.default.join(normalizedTarget, 'src', 'index.ts');
+        // Always build the full index content string for downstream tooling/logging
+        const newExports = (0, react_1.generateReactIndex)(blobs);
         // Build desired export map: moduleSpecifier -> Set of names
         const desiredExports = new Map();
         const components = blobs.flatMap(blob => {
@@ -321,7 +325,6 @@ function reactGen(_a) {
         }
         if (!fs_1.default.existsSync(indexFilePath)) {
             // No index.ts -> generate fresh file from template
-            const newExports = (0, react_1.generateReactIndex)(blobs);
             if (writeFileIfChanged(indexFilePath, newExports)) {
                 filesChanged++;
                 (0, logger_1.debug)(`Generated: index.ts`);
@@ -378,6 +381,71 @@ function reactGen(_a) {
         (0, logger_1.success)(`React code generation completed. ${filesChanged} files changed.`);
         (0, logger_1.info)(`Output directory: ${normalizedTarget}`);
         (0, logger_1.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 declaration_1.ConstObject));
+            const enums = blobs.flatMap(b => b.objects.filter(o => o instanceof declaration_1.EnumObject));
+            const typeAliases = blobs.flatMap(b => b.objects.filter(o => o instanceof declaration_1.TypeAliasObject));
+            // Deduplicate by name
+            const constMap = new Map();
+            consts.forEach(c => { if (!constMap.has(c.name))
+                constMap.set(c.name, c); });
+            const typeAliasMap = new Map();
+            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_1.default.join(normalizedTarget, 'src', 'types.ts');
+                if (writeFileIfChanged(typesPath, typesContent)) {
+                    filesChanged++;
+                    (0, logger_1.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);
+                        (0, logger_1.debug)(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
+                        (0, logger_1.debug)(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
+                    }
+                    catch (_b) { }
+                }
+                // Ensure index.ts re-exports these types so consumers get them on import.
+                const indexFilePath = path_1.default.join(normalizedTarget, 'src', 'index.ts');
+                try {
+                    let current = '';
+                    if (fs_1.default.existsSync(indexFilePath)) {
+                        current = fs_1.default.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++;
+                            (0, logger_1.debug)(`Updated: src/index.ts to export aggregated types`);
+                        }
+                    }
+                }
+                catch (_c) { }
+            }
+        }
+        catch (e) {
+            (0, logger_1.warn)('Failed to generate aggregated React types');
+        }
     });
 }
 function vueGen(_a) {