@openwebf/webf 0.23.0 → 0.23.2

package/TYPING_GUIDE.md

@@ -205,4 +205,20 @@ After writing your .d.ts file:
 Name your .d.ts files to match the Dart file:
 - `button.dart` → `button.d.ts`
 - `switch.dart` → `switch.d.ts`
-- `tab.dart` → `tab.d.ts`
+- `tab.dart` → `tab.d.ts`
+
+## Declaring Constants
+
+You can declare ambient constants in your .d.ts files:
+
+```typescript
+declare const WEBF_SOME_SYMBOL: unique symbol;
+```
+
+When generating Vue typings, these constants are carried over into the generated `index.d.ts` as `export declare const` declarations so they are available to consumers:
+
+```typescript
+export declare const WEBF_SOME_SYMBOL: unique symbol;
+```
+
+This is useful for symbol-based typings or other shared constants referenced by your interfaces.

package/dist/analyzer.js

@@ -40,7 +40,7 @@ const typescript_1 = __importStar(require("typescript"));
 const tsdoc_1 = require("@microsoft/tsdoc");
 const declaration_1 = require("./declaration");
 const utils_1 = require("./utils");
-// Cache for parsed source files to avoid re-parsing
+// Cache for parsed source files to avoid re-parsing (cache by path only)
 const sourceFileCache = new Map();
 // Cache for type conversions to avoid redundant processing
 const typeConversionCache = new Map();
@@ -69,14 +69,13 @@ function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
         // 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;
+        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 = typescript_1.default.createSourceFile(blob.source, blob.raw, typescript_1.ScriptTarget.ES2020);
-            sourceFileCache.set(blob.source, { content: blob.raw, sourceFile });
+            sourceFileCache.set(blob.source, sourceFile);
         }
         blob.objects = sourceFile.statements
             .map(statement => {
@@ -88,7 +87,7 @@ function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
                 return null;
             }
         })
-            .filter(o => o instanceof declaration_1.ClassObject || o instanceof declaration_1.FunctionObject || o instanceof declaration_1.TypeAliasObject);
+            .filter(o => o instanceof declaration_1.ClassObject || o instanceof declaration_1.FunctionObject || o instanceof declaration_1.TypeAliasObject || o instanceof declaration_1.ConstObject || o instanceof declaration_1.EnumObject);
     }
     catch (error) {
         console.error(`Error analyzing ${blob.source}:`, error);
@@ -575,6 +574,8 @@ function walkProgram(blob, statement, sourceFile, definedPropertyCollector, unio
             return processVariableStatement(statement, unionTypeCollector);
         case typescript_1.default.SyntaxKind.TypeAliasDeclaration:
             return processTypeAliasDeclaration(statement, blob);
+        case typescript_1.default.SyntaxKind.EnumDeclaration:
+            return processEnumDeclaration(statement, blob);
         default:
             return null;
     }
@@ -587,6 +588,47 @@ function processTypeAliasDeclaration(statement, blob) {
     typeAlias.type = printer.printNode(typescript_1.default.EmitHint.Unspecified, statement.type, statement.getSourceFile());
     return typeAlias;
 }
+function processEnumDeclaration(statement, blob) {
+    const enumObj = new declaration_1.EnumObject();
+    enumObj.name = statement.name.text;
+    const printer = typescript_1.default.createPrinter();
+    enumObj.members = statement.members.map(m => {
+        var _a, _b;
+        const mem = new declaration_1.EnumMemberObject();
+        if (typescript_1.default.isIdentifier(m.name)) {
+            mem.name = m.name.text;
+        }
+        else if (typescript_1.default.isStringLiteral(m.name)) {
+            // Preserve quotes in output
+            mem.name = `'${m.name.text}'`;
+        }
+        else if (typescript_1.default.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 = (_a = m.initializer.pos) !== null && _a !== void 0 ? _a : 0;
+                const end = (_b = m.initializer.end) !== null && _b !== void 0 ? _b : 0;
+                if (start >= 0 && end > start) {
+                    mem.initializer = blob.raw.substring(start, end).trim();
+                }
+            }
+            catch (_c) {
+                // Fallback to printer (may normalize to decimal)
+                mem.initializer = printer.printNode(typescript_1.default.EmitHint.Unspecified, m.initializer, statement.getSourceFile());
+            }
+        }
+        return mem;
+    });
+    return enumObj;
+}
 function processInterfaceDeclaration(statement, blob, sourceFile, definedPropertyCollector, unionTypeCollector) {
     const interfaceName = statement.name.escapedText.toString();
     const obj = new declaration_1.ClassObject();
@@ -749,21 +791,33 @@ function processConstructSignature(member, obj, sourceFile, unionTypeCollector)
 }
 function processVariableStatement(statement, unionTypeCollector) {
     const declaration = statement.declarationList.declarations[0];
+    if (!declaration)
+        return null;
     if (!typescript_1.default.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 || !typescript_1.default.isFunctionTypeNode(type)) {
+    const varName = declaration.name.text;
+    const typeNode = declaration.type;
+    if (!typeNode) {
         return null;
     }
-    const functionObject = new declaration_1.FunctionObject();
-    functionObject.declare = new declaration_1.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 (typescript_1.default.isFunctionTypeNode(typeNode)) {
+        const functionObject = new declaration_1.FunctionObject();
+        functionObject.declare = new declaration_1.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 = typescript_1.default.createPrinter();
+    const typeText = printer.printNode(typescript_1.default.EmitHint.Unspecified, typeNode, typeNode.getSourceFile());
+    const constObj = new declaration_1.ConstObject();
+    constObj.name = varName;
+    constObj.type = typeText;
+    return constObj;
 }
 // Clear caches when needed (e.g., between runs)
 function clearCaches() {

package/dist/commands.js

@@ -18,6 +18,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const generator_1 = require("./generator");
+const glob_1 = require("glob");
 const lodash_1 = __importDefault(require("lodash"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const yaml_1 = __importDefault(require("yaml"));
@@ -171,6 +172,43 @@ function readFlutterPackageMetadata(packagePath) {
         return null;
     }
 }
+// Copy markdown docs that match .d.ts basenames from source to the built dist folder
+function copyMarkdownDocsToDist(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { sourceRoot, distRoot, exclude } = params;
+        // Ensure dist exists
+        if (!fs_1.default.existsSync(distRoot)) {
+            return { copied: 0, skipped: 0 };
+        }
+        // Default ignore patterns similar to generator
+        const defaultIgnore = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**'];
+        const ignore = exclude && exclude.length ? [...defaultIgnore, ...exclude] : defaultIgnore;
+        // Find all .d.ts files and check for sibling .md files
+        const dtsFiles = glob_1.glob.globSync('**/*.d.ts', { cwd: sourceRoot, ignore });
+        let copied = 0;
+        let skipped = 0;
+        for (const relDts of dtsFiles) {
+            if (path_1.default.basename(relDts) === 'global.d.ts') {
+                continue;
+            }
+            const relMd = relDts.replace(/\.d\.ts$/i, '.md');
+            const absMd = path_1.default.join(sourceRoot, relMd);
+            if (!fs_1.default.existsSync(absMd)) {
+                skipped++;
+                continue;
+            }
+            // Copy into dist preserving relative path
+            const destPath = path_1.default.join(distRoot, relMd);
+            const destDir = path_1.default.dirname(destPath);
+            if (!fs_1.default.existsSync(destDir)) {
+                fs_1.default.mkdirSync(destDir, { recursive: true });
+            }
+            fs_1.default.copyFileSync(absMd, destPath);
+            copied++;
+        }
+        return { copied, skipped };
+    });
+}
 function validateTypeScriptEnvironment(projectPath) {
     const errors = [];
     // Check for TypeScript configuration
@@ -243,7 +281,7 @@ function createCommand(target, options) {
             // Do not overwrite existing index.ts created by the user
             // Leave merge to the codegen step which appends exports safely
         }
-        (0, child_process_1.spawnSync)(NPM, ['install', '--omit=peer'], {
+        (0, child_process_1.spawnSync)(NPM, ['install'], {
             cwd: target,
             stdio: 'inherit'
         });
@@ -509,7 +547,9 @@ function generateCommand(distPath, options) {
                 target: resolvedDistPath,
                 command,
                 exclude: options.exclude,
-                packageName: reactPackageName,
+                // Prefer CLI-provided packageName (validated/sanitized above),
+                // fallback to detected name from package.json
+                packageName: packageName || reactPackageName,
             });
         }
         else if (framework === 'vue') {
@@ -525,6 +565,18 @@ function generateCommand(distPath, options) {
         if (framework) {
             try {
                 yield buildPackage(resolvedDistPath);
+                // After building React package, copy any matching .md docs next to built JS files
+                if (framework === 'react' && options.flutterPackageSrc) {
+                    const distOut = path_1.default.join(resolvedDistPath, 'dist');
+                    const { copied } = yield copyMarkdownDocsToDist({
+                        sourceRoot: options.flutterPackageSrc,
+                        distRoot: distOut,
+                        exclude: options.exclude,
+                    });
+                    if (copied > 0) {
+                        console.log(`📄 Copied ${copied} markdown docs to dist`);
+                    }
+                }
             }
             catch (error) {
                 console.error('\nWarning: Build failed:', error);

package/dist/constants.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnionConstantsValuesTs = generateUnionConstantsValuesTs;
+exports.generateUnionConstantsDts = generateUnionConstantsDts;
+exports.generateDeclaredConstantsValuesTs = generateDeclaredConstantsValuesTs;
+exports.generateDeclaredConstantsDts = generateDeclaredConstantsDts;
+const lodash_1 = __importDefault(require("lodash"));
+const typescript_1 = __importDefault(require("typescript"));
+const dart_1 = require("./dart");
+// Generate constant name from component (Properties/Bindings trimmed) and prop name
+function getConstName(className, propName) {
+    const baseName = className.replace(/Properties$|Bindings$/, '');
+    return baseName + lodash_1.default.upperFirst(lodash_1.default.camelCase(propName));
+}
+function collectUnionStringProps(blobs) {
+    const results = [];
+    for (const blob of blobs) {
+        const classObjects = (blob.objects || []);
+        const properties = classObjects.filter(obj => obj.name && obj.name.endsWith('Properties'));
+        if (!properties.length)
+            continue;
+        const componentProps = properties[0];
+        const componentName = componentProps.name.replace(/Properties$/, '');
+        for (const prop of componentProps.props || []) {
+            if (!(0, dart_1.isStringUnionType)(prop.type))
+                continue;
+            const values = (0, dart_1.getUnionStringValues)(prop, blob);
+            if (!values || values.length === 0)
+                continue;
+            const constName = getConstName(componentProps.name, prop.name);
+            results.push({ constName, values, className: componentName, propName: prop.name });
+        }
+    }
+    return results;
+}
+function generateUnionConstantsValuesTs(blobs) {
+    const items = collectUnionStringProps(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Constants for string-union properties extracted from .d.ts definitions\n`;
+    const blocks = items.map(item => {
+        const entries = item.values.map(v => `  '${v}': '${v}',`).join('\n');
+        return `// ${item.className}.${item.propName}\nexport const ${item.constName} = {\n${entries}\n} as const;`;
+    });
+    return [header, ...blocks].join('\n\n') + '\n';
+}
+function generateUnionConstantsDts(blobs) {
+    const items = collectUnionStringProps(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Type declarations for constants representing string-union property values\n`;
+    const blocks = items.map(item => {
+        const entries = item.values.map(v => `  readonly '${v}': '${v}';`).join('\n');
+        return `// ${item.className}.${item.propName}\nexport declare const ${item.constName}: {\n${entries}\n};`;
+    });
+    return [header, ...blocks].join('\n\n') + '\n';
+}
+function parseLiteralFromType(node) {
+    if (typescript_1.default.isLiteralTypeNode(node)) {
+        const lit = node.literal;
+        if (typescript_1.default.isStringLiteral(lit))
+            return lit.text;
+        if (typescript_1.default.isNumericLiteral(lit))
+            return Number(lit.text);
+        if (lit.kind === typescript_1.default.SyntaxKind.TrueKeyword)
+            return true;
+        if (lit.kind === typescript_1.default.SyntaxKind.FalseKeyword)
+            return false;
+        return null;
+    }
+    if (typescript_1.default.isTypeQueryNode(node)) {
+        // typeof Identifier
+        if (typescript_1.default.isIdentifier(node.exprName)) {
+            return { typeofRef: node.exprName.text };
+        }
+    }
+    return null;
+}
+function collectDeclaredConstsFromSource(content, fileName = 'index.d.ts') {
+    const source = typescript_1.default.createSourceFile(fileName, content, typescript_1.default.ScriptTarget.ES2020, true, typescript_1.default.ScriptKind.TS);
+    const results = [];
+    const handleVariableStatement = (stmt) => {
+        // Only consider const declarations
+        if ((stmt.declarationList.flags & typescript_1.default.NodeFlags.Const) === 0)
+            return;
+        for (const decl of stmt.declarationList.declarations) {
+            if (!typescript_1.default.isIdentifier(decl.name) || !decl.type)
+                continue;
+            const name = decl.name.text;
+            const val = parseLiteralFromType(decl.type);
+            if (val == null)
+                continue;
+            results.push({ kind: 'const', name, value: val });
+        }
+    };
+    const handleClass = (cls) => {
+        var _a, _b, _c;
+        const container = (_a = cls.name) === null || _a === void 0 ? void 0 : _a.text;
+        if (!container)
+            return;
+        for (const m of cls.members) {
+            if (!typescript_1.default.isPropertyDeclaration(m))
+                continue;
+            const isStatic = (_b = m.modifiers) === null || _b === void 0 ? void 0 : _b.some(mod => mod.kind === typescript_1.default.SyntaxKind.StaticKeyword);
+            const isReadonly = (_c = m.modifiers) === null || _c === void 0 ? void 0 : _c.some(mod => mod.kind === typescript_1.default.SyntaxKind.ReadonlyKeyword);
+            if (!isStatic || !isReadonly || !m.type)
+                continue;
+            if (!typescript_1.default.isIdentifier(m.name))
+                continue;
+            const name = m.name.text;
+            const val = parseLiteralFromType(m.type);
+            if (val == null)
+                continue;
+            results.push({ kind: 'container', container, name, value: val });
+        }
+    };
+    const handleModule = (mod) => {
+        const container = mod.name.getText(source).replace(/['"]/g, '');
+        if (!mod.body || !typescript_1.default.isModuleBlock(mod.body))
+            return;
+        for (const stmt of mod.body.statements) {
+            if (typescript_1.default.isVariableStatement(stmt)) {
+                if ((stmt.declarationList.flags & typescript_1.default.NodeFlags.Const) === 0)
+                    continue;
+                for (const decl of stmt.declarationList.declarations) {
+                    if (!typescript_1.default.isIdentifier(decl.name) || !decl.type)
+                        continue;
+                    const name = decl.name.text;
+                    const val = parseLiteralFromType(decl.type);
+                    if (val == null)
+                        continue;
+                    results.push({ kind: 'container', container, name, value: val });
+                }
+            }
+        }
+    };
+    for (const stmt of source.statements) {
+        if (typescript_1.default.isVariableStatement(stmt))
+            handleVariableStatement(stmt);
+        else if (typescript_1.default.isClassDeclaration(stmt))
+            handleClass(stmt);
+        else if (typescript_1.default.isModuleDeclaration(stmt))
+            handleModule(stmt);
+    }
+    return results;
+}
+function collectDeclaredConsts(blobs) {
+    const all = [];
+    for (const blob of blobs) {
+        const raw = blob.raw || '';
+        if (!raw)
+            continue;
+        try {
+            const items = collectDeclaredConstsFromSource(raw, blob.filename + '.d.ts');
+            all.push(...items);
+        }
+        catch (_) {
+            // ignore parse errors per file
+        }
+    }
+    return all;
+}
+function literalToTsValue(val) {
+    if (typeof val === 'string')
+        return `'${val.replace(/'/g, "\\'")}'`;
+    if (typeof val === 'number')
+        return String(val);
+    if (typeof val === 'boolean')
+        return val ? 'true' : 'false';
+    if (typeof val.typeofRef === 'string')
+        return val.typeofRef;
+    return 'undefined';
+}
+function generateDeclaredConstantsValuesTs(blobs) {
+    const items = collectDeclaredConsts(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Runtime constants mirrored from .d.ts 'declare const' definitions\n`;
+    const topLevel = [];
+    const containers = new Map();
+    for (const it of items) {
+        if (it.kind === 'const') {
+            topLevel.push(`export const ${it.name} = ${literalToTsValue(it.value)} as const;`);
+        }
+        else {
+            if (!containers.has(it.container))
+                containers.set(it.container, []);
+            containers.get(it.container).push(it);
+        }
+    }
+    const containerBlocks = [];
+    for (const [container, arr] of containers) {
+        const lines = arr
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(a => `  ${a.name}: ${literalToTsValue(a.value)},`) // keep plain object
+            .join('\n');
+        containerBlocks.push(`export const ${container} = {\n${lines}\n} as const;`);
+    }
+    return [header, ...topLevel, ...containerBlocks].filter(Boolean).join('\n\n') + '\n';
+}
+function generateDeclaredConstantsDts(blobs) {
+    const items = collectDeclaredConsts(blobs);
+    if (!items.length)
+        return '';
+    const header = `// Auto-generated by WebF CLI\n// Type declarations for 'declare const' values mirrored into JS runtime\n`;
+    const topLevel = [];
+    const containers = new Map();
+    for (const it of items) {
+        if (it.kind === 'const') {
+            const val = typeof it.value === 'object' && it.value.typeofRef
+                ? `typeof ${it.value.typeofRef}`
+                : typeof it.value === 'string'
+                    ? `'${it.value.replace(/'/g, "\\'")}'`
+                    : String(it.value);
+            topLevel.push(`export declare const ${it.name}: ${val};`);
+        }
+        else {
+            if (!containers.has(it.container))
+                containers.set(it.container, []);
+            containers.get(it.container).push(it);
+        }
+    }
+    const containerBlocks = [];
+    for (const [container, arr] of containers) {
+        const lines = arr
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(a => {
+            const v = typeof a.value === 'object' && a.value.typeofRef
+                ? `typeof ${a.value.typeofRef}`
+                : typeof a.value === 'string'
+                    ? `'${a.value.replace(/'/g, "\\'")}'`
+                    : String(a.value);
+            return `  readonly ${a.name}: ${v};`;
+        })
+            .join('\n');
+        containerBlocks.push(`export declare const ${container}: {\n${lines}\n};`);
+    }
+    return [header, ...topLevel, ...containerBlocks].filter(Boolean).join('\n\n') + '\n';
+}

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,15 @@ 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;

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}`);
@@ -290,6 +290,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 +323,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 +379,64 @@ 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.d.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 declare 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.d.ts');
+                if (writeFileIfChanged(typesPath, typesContent)) {
+                    filesChanged++;
+                    (0, logger_1.debug)(`Generated: src/types.d.ts`);
+                }
+                // Try to help TypeScript pick up additional declarations by adding a reference comment.
+                // This avoids bundler resolution errors from importing a .d.ts file.
+                const indexFilePath = path_1.default.join(normalizedTarget, 'src', 'index.ts');
+                try {
+                    if (fs_1.default.existsSync(indexFilePath)) {
+                        let current = fs_1.default.readFileSync(indexFilePath, 'utf-8');
+                        const refLine = `/// <reference path="./types.d.ts" />`;
+                        if (!current.includes(refLine)) {
+                            // Place the reference at the very top, before any code
+                            const updated = `${refLine}\n${current}`;
+                            if (writeFileIfChanged(indexFilePath, updated)) {
+                                filesChanged++;
+                                (0, logger_1.debug)(`Updated: src/index.ts with reference to types.d.ts`);
+                            }
+                        }
+                    }
+                }
+                catch (_b) { }
+            }
+        }
+        catch (e) {
+            (0, logger_1.warn)('Failed to generate aggregated React types.d.ts');
+        }
     });
 }
 function vueGen(_a) {

package/dist/react.js

@@ -121,6 +121,8 @@ function toWebFTagName(className) {
 function generateReactComponent(blob, packageName, relativeDir) {
     const classObjects = blob.objects.filter(obj => obj instanceof declaration_1.ClassObject);
     const typeAliases = blob.objects.filter(obj => obj instanceof declaration_1.TypeAliasObject);
+    const constObjects = blob.objects.filter(obj => obj instanceof declaration_1.ConstObject);
+    const enumObjects = blob.objects.filter(obj => obj instanceof declaration_1.EnumObject);
     const classObjectDictionary = Object.fromEntries(classObjects.map(object => {
         return [object.name, object];
     }));
@@ -142,8 +144,17 @@ function generateReactComponent(blob, packageName, relativeDir) {
     const typeAliasDeclarations = typeAliases.map(typeAlias => {
         return `type ${typeAlias.name} = ${typeAlias.type};`;
     }).join('\n');
+    // Include declare const values as ambient exports for type usage (e.g., unique symbol branding)
+    const constDeclarations = constObjects.map(c => `export declare const ${c.name}: ${c.type};`).join('\n');
+    // Include enums
+    const enumDeclarations = enumObjects.map(e => {
+        const members = e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ');
+        return `export declare enum ${e.name} { ${members} }`;
+    }).join('\n');
     const dependencies = [
         typeAliasDeclarations,
+        constDeclarations,
+        enumDeclarations,
         // Include Methods interfaces as dependencies
         methods.map(object => {
             const methodDeclarations = object.methods.map(method => {