@openwebf/webf 0.24.1 → 0.24.2

package/README.md

@@ -150,7 +150,7 @@ my-webf-app/
 │   └── index.ts
 ├── package.json
 ├── tsconfig.json
-├── tsup.config.ts
+├── tsdown.config.ts
 ├── global.d.ts
 └── .gitignore
 ```

package/dist/analyzer.js

@@ -365,134 +365,196 @@ function handleGenericWrapper(typeReference, mode) {
     const argument = typeReference.typeArguments[0];
     return getParameterBaseType(argument, mode);
 }
-function handleCustomEventType(typeReference) {
-    var _a;
-    // Handle CustomEvent<T> by returning the full type with generic parameter
-    if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
-        return 'CustomEvent';
+const customEventTypePrinter = typescript_1.default.createPrinter({ removeComments: true });
+function mapTypeReferenceIdentifierToTsType(identifier) {
+    const mappedType = TYPE_REFERENCE_MAP[identifier];
+    if (mappedType === undefined)
+        return null;
+    switch (mappedType) {
+        case declaration_1.FunctionArgumentType.boolean:
+            return 'boolean';
+        case declaration_1.FunctionArgumentType.dom_string:
+            return 'string';
+        case declaration_1.FunctionArgumentType.double:
+        case declaration_1.FunctionArgumentType.int:
+            return 'number';
+        case declaration_1.FunctionArgumentType.any:
+            return 'any';
+        case declaration_1.FunctionArgumentType.void:
+            return 'void';
+        case declaration_1.FunctionArgumentType.function:
+            return 'Function';
+        case declaration_1.FunctionArgumentType.promise:
+            return 'Promise<any>';
+        default:
+            return null;
     }
-    const argument = typeReference.typeArguments[0];
-    let genericType;
-    // Preserve simple union/compound generic types (e.g., boolean | null)
-    if (typescript_1.default.isUnionTypeNode(argument) || typescript_1.default.isIntersectionTypeNode(argument)) {
-        const unionTypes = (_a = argument.types) !== null && _a !== void 0 ? _a : [];
-        const parts = unionTypes.map(t => {
-            // Literal union members: handle null/undefined explicitly
-            if (typescript_1.default.isLiteralTypeNode(t)) {
-                const lit = t.literal;
-                if (lit.kind === typescript_1.default.SyntaxKind.NullKeyword)
-                    return 'null';
-                if (lit.kind === typescript_1.default.SyntaxKind.UndefinedKeyword)
-                    return 'undefined';
-                if (typescript_1.default.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 declaration_1.FunctionArgumentType.boolean:
-                        return 'boolean';
-                    case declaration_1.FunctionArgumentType.dom_string:
-                        return 'string';
-                    case declaration_1.FunctionArgumentType.double:
-                    case declaration_1.FunctionArgumentType.int:
-                        return 'number';
-                    case declaration_1.FunctionArgumentType.null:
-                        return 'null';
-                    case declaration_1.FunctionArgumentType.undefined:
-                        return 'undefined';
-                    default:
-                        return 'any';
-                }
-            }
-            // Literal null/undefined keywords that BASIC_TYPE_MAP may not cover
-            if (t.kind === typescript_1.default.SyntaxKind.NullKeyword)
-                return 'null';
-            if (t.kind === typescript_1.default.SyntaxKind.UndefinedKeyword)
-                return 'undefined';
-            // Fallback: rely on toString of node kind
+}
+function getBasicTypeKindAsTsType(kind) {
+    const basicType = BASIC_TYPE_MAP[kind];
+    if (basicType === undefined)
+        return null;
+    switch (basicType) {
+        case declaration_1.FunctionArgumentType.boolean:
+            return 'boolean';
+        case declaration_1.FunctionArgumentType.dom_string:
+            return 'string';
+        case declaration_1.FunctionArgumentType.double:
+        case declaration_1.FunctionArgumentType.int:
+            return 'number';
+        case declaration_1.FunctionArgumentType.any:
             return 'any';
-        });
-        genericType = parts.join(' | ');
+        case declaration_1.FunctionArgumentType.void:
+            return 'void';
+        case declaration_1.FunctionArgumentType.null:
+            return 'null';
+        case declaration_1.FunctionArgumentType.undefined:
+            return 'undefined';
+        default:
+            return null;
     }
-    else if (typescript_1.default.isTypeReferenceNode(argument) && typescript_1.default.isIdentifier(argument.typeName)) {
-        const typeName = argument.typeName.text;
-        // Check if it's a mapped type reference like 'int' or 'double'
-        const mappedType = TYPE_REFERENCE_MAP[typeName];
-        if (mappedType !== undefined) {
-            switch (mappedType) {
-                case declaration_1.FunctionArgumentType.boolean:
-                    genericType = 'boolean';
-                    break;
-                case declaration_1.FunctionArgumentType.dom_string:
-                    genericType = 'string';
-                    break;
-                case declaration_1.FunctionArgumentType.double:
-                case declaration_1.FunctionArgumentType.int:
-                    genericType = 'number';
-                    break;
-                case declaration_1.FunctionArgumentType.any:
-                    genericType = 'any';
-                    break;
-                case declaration_1.FunctionArgumentType.void:
-                    genericType = 'void';
-                    break;
-                case declaration_1.FunctionArgumentType.function:
-                    genericType = 'Function';
-                    break;
-                case declaration_1.FunctionArgumentType.promise:
-                    genericType = 'Promise<any>';
-                    break;
-                default:
-                    genericType = typeName;
+}
+function stringifyEntityName(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    return `${stringifyEntityName(name.left)}.${name.right.text}`;
+}
+function safePrintCustomEventNode(node) {
+    const sourceFile = node.getSourceFile();
+    const printed = customEventTypePrinter.printNode(typescript_1.default.EmitHint.Unspecified, node, sourceFile);
+    // Ensure WebF IDL-like aliases used in type definitions do not leak into generated TypeScript packages.
+    return printed.replace(/\bint\b/g, 'number').replace(/\bdouble\b/g, 'number');
+}
+function stringifyCustomEventGenericTypeNode(typeNode) {
+    if (typescript_1.default.isParenthesizedTypeNode(typeNode)) {
+        const inner = stringifyCustomEventGenericTypeNode(typeNode.type);
+        return inner ? `(${inner})` : null;
+    }
+    if (typescript_1.default.isUnionTypeNode(typeNode)) {
+        const parts = typeNode.types.map(t => stringifyCustomEventGenericTypeNode(t)).filter((t) => Boolean(t));
+        return parts.length === typeNode.types.length ? parts.join(' | ') : null;
+    }
+    if (typescript_1.default.isIntersectionTypeNode(typeNode)) {
+        const parts = typeNode.types.map(t => stringifyCustomEventGenericTypeNode(t)).filter((t) => Boolean(t));
+        return parts.length === typeNode.types.length ? parts.join(' & ') : null;
+    }
+    if (typescript_1.default.isArrayTypeNode(typeNode)) {
+        const element = stringifyCustomEventGenericTypeNode(typeNode.elementType);
+        return element ? `${element}[]` : null;
+    }
+    if (typescript_1.default.isTupleTypeNode(typeNode)) {
+        const elements = typeNode.elements.map(e => stringifyCustomEventGenericTypeNode(e)).filter((t) => Boolean(t));
+        return elements.length === typeNode.elements.length ? `[${elements.join(', ')}]` : null;
+    }
+    if (typescript_1.default.isLiteralTypeNode(typeNode)) {
+        const literal = typeNode.literal;
+        if (literal.kind === typescript_1.default.SyntaxKind.NullKeyword)
+            return 'null';
+        if (literal.kind === typescript_1.default.SyntaxKind.UndefinedKeyword)
+            return 'undefined';
+        if (literal.kind === typescript_1.default.SyntaxKind.TrueKeyword)
+            return 'true';
+        if (literal.kind === typescript_1.default.SyntaxKind.FalseKeyword)
+            return 'false';
+        if (typescript_1.default.isStringLiteral(literal))
+            return JSON.stringify(literal.text);
+        if (typescript_1.default.isNumericLiteral(literal))
+            return literal.text;
+        return null;
+    }
+    const basic = getBasicTypeKindAsTsType(typeNode.kind);
+    if (basic)
+        return basic;
+    if (typescript_1.default.isTypeReferenceNode(typeNode)) {
+        const typeName = stringifyEntityName(typeNode.typeName);
+        // Unwrap internal helpers used by WebF typings.
+        if (typeName === 'DartImpl' && typeNode.typeArguments && typeNode.typeArguments[0]) {
+            return stringifyCustomEventGenericTypeNode(typeNode.typeArguments[0]);
+        }
+        if (typeName === 'Promise') {
+            if (!typeNode.typeArguments || !typeNode.typeArguments[0])
+                return 'Promise<any>';
+            const inner = stringifyCustomEventGenericTypeNode(typeNode.typeArguments[0]);
+            return inner ? `Promise<${inner}>` : null;
+        }
+        const mapped = mapTypeReferenceIdentifierToTsType(typeName);
+        if (mapped)
+            return mapped;
+        if (!typeNode.typeArguments || typeNode.typeArguments.length === 0) {
+            return typeName;
+        }
+        const args = typeNode.typeArguments
+            .map(arg => stringifyCustomEventGenericTypeNode(arg))
+            .filter((t) => Boolean(t));
+        if (args.length !== typeNode.typeArguments.length)
+            return null;
+        return `${typeName}<${args.join(', ')}>`;
+    }
+    if (typescript_1.default.isTypeLiteralNode(typeNode)) {
+        const members = [];
+        for (const member of typeNode.members) {
+            if (typescript_1.default.isPropertySignature(member) && member.type) {
+                const typeString = stringifyCustomEventGenericTypeNode(member.type);
+                if (!typeString)
+                    return null;
+                let nameText;
+                if (typescript_1.default.isIdentifier(member.name))
+                    nameText = member.name.text;
+                else if (typescript_1.default.isStringLiteral(member.name))
+                    nameText = JSON.stringify(member.name.text);
+                else if (typescript_1.default.isNumericLiteral(member.name))
+                    nameText = member.name.text;
+                else
+                    nameText = member.name.getText();
+                const optional = member.questionToken ? '?' : '';
+                members.push(`${nameText}${optional}: ${typeString}`);
+                continue;
             }
+            if (typescript_1.default.isIndexSignatureDeclaration(member) && member.type && member.parameters.length === 1) {
+                const param = member.parameters[0];
+                const paramName = typescript_1.default.isIdentifier(param.name) ? param.name.text : param.name.getText();
+                const paramType = param.type ? stringifyCustomEventGenericTypeNode(param.type) : 'string';
+                const valueType = stringifyCustomEventGenericTypeNode(member.type);
+                if (!paramType || !valueType)
+                    return null;
+                members.push(`[${paramName}: ${paramType}]: ${valueType}`);
+                continue;
+            }
+            // Fallback for uncommon members (call signatures, method signatures, etc.).
+            members.push(safePrintCustomEventNode(member));
         }
-        else {
-            // For other type references, use the type name directly
-            genericType = typeName;
-        }
+        return `{ ${members.join('; ')} }`;
     }
-    else if (typescript_1.default.isLiteralTypeNode(argument) && typescript_1.default.isStringLiteral(argument.literal)) {
-        genericType = argument.literal.text;
+    if (typescript_1.default.isTypeOperatorNode(typeNode)) {
+        const inner = stringifyCustomEventGenericTypeNode(typeNode.type);
+        if (!inner)
+            return null;
+        const operator = typeNode.operator === typescript_1.default.SyntaxKind.KeyOfKeyword ? 'keyof' :
+            typeNode.operator === typescript_1.default.SyntaxKind.ReadonlyKeyword ? 'readonly' :
+                typeNode.operator === typescript_1.default.SyntaxKind.UniqueKeyword ? 'unique' :
+                    null;
+        return operator ? `${operator} ${inner}` : null;
+    }
+    if (typescript_1.default.isIndexedAccessTypeNode(typeNode)) {
+        const objectType = stringifyCustomEventGenericTypeNode(typeNode.objectType);
+        const indexType = stringifyCustomEventGenericTypeNode(typeNode.indexType);
+        if (!objectType || !indexType)
+            return null;
+        return `${objectType}[${indexType}]`;
     }
-    else {
-        // Handle basic types (boolean, string, number, etc.)
-        const basicType = BASIC_TYPE_MAP[argument.kind];
-        if (basicType !== undefined) {
-            switch (basicType) {
-                case declaration_1.FunctionArgumentType.boolean:
-                    genericType = 'boolean';
-                    break;
-                case declaration_1.FunctionArgumentType.dom_string:
-                    genericType = 'string';
-                    break;
-                case declaration_1.FunctionArgumentType.double:
-                case declaration_1.FunctionArgumentType.int:
-                    genericType = 'number';
-                    break;
-                case declaration_1.FunctionArgumentType.any:
-                    genericType = 'any';
-                    break;
-                case declaration_1.FunctionArgumentType.void:
-                    genericType = 'void';
-                    break;
-                case declaration_1.FunctionArgumentType.null:
-                    genericType = 'null';
-                    break;
-                case declaration_1.FunctionArgumentType.undefined:
-                    genericType = 'undefined';
-                    break;
-                default:
-                    genericType = 'any';
-            }
-        }
-        else {
-            // For truly complex types, fallback to 'any' to avoid errors
-            console.warn('Complex generic type in CustomEvent, using any');
-            genericType = 'any';
-        }
+    // As a last resort, keep the original syntax but normalize known WebF aliases.
+    return safePrintCustomEventNode(typeNode);
+}
+function handleCustomEventType(typeReference) {
+    // Handle CustomEvent<T> by returning the full type with generic parameter
+    if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
+        return 'CustomEvent';
+    }
+    const argument = typeReference.typeArguments[0];
+    const genericType = stringifyCustomEventGenericTypeNode(argument);
+    if (!genericType) {
+        console.warn('Complex generic type in CustomEvent, using any');
+        return 'CustomEvent<any>';
     }
     return `CustomEvent<${genericType}>`;
 }

package/dist/commands.js

@@ -149,10 +149,10 @@ const tsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '..
 const gitignore = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/gitignore.tpl'), 'utf-8');
 const modulePackageJson = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/module.package.json.tpl'), 'utf-8');
 const moduleTsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/module.tsconfig.json.tpl'), 'utf-8');
-const moduleTsUpConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/module.tsup.config.ts.tpl'), 'utf-8');
+const moduleTsDownConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/module.tsdown.config.ts.tpl'), 'utf-8');
 const reactPackageJson = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.package.json.tpl'), 'utf-8');
 const reactTsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.tsconfig.json.tpl'), 'utf-8');
-const reactTsUpConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.tsup.config.ts.tpl'), 'utf-8');
+const reactTsDownConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.tsdown.config.ts.tpl'), 'utf-8');
 const reactIndexTpl = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.index.ts.tpl'), 'utf-8');
 const vuePackageJson = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/vue.package.json.tpl'), 'utf-8');
 const vueTsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/vue.tsconfig.json.tpl'), 'utf-8');
@@ -181,6 +181,33 @@ function readFlutterPackageMetadata(packagePath) {
         return null;
     }
 }
+function copyReadmeToPackageRoot(params) {
+    const { sourceRoot, targetRoot } = params;
+    const targetPath = path_1.default.join(targetRoot, 'README.md');
+    if (fs_1.default.existsSync(targetPath)) {
+        return { copied: false, targetPath };
+    }
+    const candidateNames = ['README.md', 'Readme.md', 'readme.md'];
+    let sourcePath = null;
+    for (const candidate of candidateNames) {
+        const abs = path_1.default.join(sourceRoot, candidate);
+        if (fs_1.default.existsSync(abs)) {
+            sourcePath = abs;
+            break;
+        }
+    }
+    if (!sourcePath) {
+        return { copied: false, targetPath };
+    }
+    try {
+        const content = fs_1.default.readFileSync(sourcePath, 'utf-8');
+        writeFileIfChanged(targetPath, content);
+        return { copied: true, sourcePath, targetPath };
+    }
+    catch (_a) {
+        return { copied: false, targetPath };
+    }
+}
 // Copy markdown docs that match .d.ts basenames from source to the built dist folder,
 // and generate an aggregated README.md in the dist directory.
 function copyMarkdownDocsToDist(params) {
@@ -333,9 +360,9 @@ function createCommand(target, options) {
         const tsConfigPath = path_1.default.join(target, 'tsconfig.json');
         const tsConfigContent = lodash_1.default.template(reactTsConfig)({});
         writeFileIfChanged(tsConfigPath, tsConfigContent);
-        const tsupConfigPath = path_1.default.join(target, 'tsup.config.ts');
-        const tsupConfigContent = lodash_1.default.template(reactTsUpConfig)({});
-        writeFileIfChanged(tsupConfigPath, tsupConfigContent);
+        const tsdownConfigPath = path_1.default.join(target, 'tsdown.config.ts');
+        const tsdownConfigContent = lodash_1.default.template(reactTsDownConfig)({});
+        writeFileIfChanged(tsdownConfigPath, tsdownConfigContent);
         const gitignorePath = path_1.default.join(target, '.gitignore');
         const gitignoreContent = lodash_1.default.template(gitignore)({});
         writeFileIfChanged(gitignorePath, gitignoreContent);
@@ -400,9 +427,9 @@ function createModuleProject(target, options) {
     const tsConfigPath = path_1.default.join(target, 'tsconfig.json');
     const tsConfigContent = lodash_1.default.template(moduleTsConfig)({});
     writeFileIfChanged(tsConfigPath, tsConfigContent);
-    const tsupConfigPath = path_1.default.join(target, 'tsup.config.ts');
-    const tsupConfigContent = lodash_1.default.template(moduleTsUpConfig)({});
-    writeFileIfChanged(tsupConfigPath, tsupConfigContent);
+    const tsdownConfigPath = path_1.default.join(target, 'tsdown.config.ts');
+    const tsdownConfigContent = lodash_1.default.template(moduleTsDownConfig)({});
+    writeFileIfChanged(tsdownConfigPath, tsdownConfigContent);
     if (!skipGitignore) {
         const gitignorePath = path_1.default.join(target, '.gitignore');
         const gitignoreContent = lodash_1.default.template(gitignore)({});
@@ -660,6 +687,16 @@ function generateCommand(distPath, options) {
         }
         // Auto-initialize typings in the output directory if needed
         ensureInitialized(resolvedDistPath);
+        // Copy README.md from the source Flutter package into the npm package root (so `npm publish` includes it).
+        if (options.flutterPackageSrc) {
+            const { copied } = copyReadmeToPackageRoot({
+                sourceRoot: options.flutterPackageSrc,
+                targetRoot: resolvedDistPath,
+            });
+            if (copied) {
+                console.log('📄 Copied README.md to package root');
+            }
+        }
         console.log(`\nGenerating ${framework} code from ${options.flutterPackageSrc}...`);
         yield (0, generator_1.dartGen)({
             source: options.flutterPackageSrc,
@@ -880,7 +917,7 @@ function generateModuleCommand(distPath, options) {
                 }]);
             packageName = packageNameAnswer.packageName;
         }
-        // Prevent npm scaffolding (package.json, tsup.config.ts, etc.) from being written into
+        // Prevent npm scaffolding (package.json, tsdown.config.ts, etc.) from being written into
         // the Flutter package itself. Force users to choose a separate output directory.
         if (resolvedDistPath === flutterPackageSrc) {
             console.error('\n❌ Output directory must not be the Flutter package root.');
@@ -920,6 +957,14 @@ function generateModuleCommand(distPath, options) {
             flutterPackageDir: flutterPackageSrc,
             command,
         });
+        // Copy README.md from the source Flutter package into the npm package root
+        const { copied } = copyReadmeToPackageRoot({
+            sourceRoot: flutterPackageSrc,
+            targetRoot: resolvedDistPath,
+        });
+        if (copied) {
+            console.log('📄 Copied README.md to package root');
+        }
         console.log('\nModule code generation completed successfully!');
         try {
             yield buildPackage(resolvedDistPath);

package/dist/generator.js

@@ -220,6 +220,7 @@ function dartGen(_a) {
 }
 function reactGen(_a) {
     return __awaiter(this, arguments, void 0, function* ({ source, target, exclude, packageName }) {
+        var _b, _c;
         (0, logger_1.group)('React Code Generation');
         (0, logger_1.time)('reactGen');
         const { source: normalizedSource, target: normalizedTarget } = validatePaths(source, target);
@@ -296,7 +297,8 @@ function reactGen(_a) {
         // 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 desiredValueExports = new Map();
+        const desiredTypeExports = new Map();
         const components = blobs.flatMap(blob => {
             const classObjects = blob.objects.filter(obj => obj instanceof declaration_1.ClassObject);
             const properties = classObjects.filter(object => object.name.endsWith('Properties'));
@@ -318,11 +320,12 @@ function reactGen(_a) {
         }
         for (const { className, fileName, relativeDir } of unique.values()) {
             const spec = `./${relativeDir ? `${relativeDir}/` : ''}${fileName}`;
-            if (!desiredExports.has(spec))
-                desiredExports.set(spec, new Set());
-            const set = desiredExports.get(spec);
-            set.add(className);
-            set.add(`${className}Element`);
+            if (!desiredValueExports.has(spec))
+                desiredValueExports.set(spec, new Set());
+            if (!desiredTypeExports.has(spec))
+                desiredTypeExports.set(spec, new Set());
+            desiredValueExports.get(spec).add(className);
+            desiredTypeExports.get(spec).add(`${className}Element`);
         }
         if (!fs_1.default.existsSync(indexFilePath)) {
             // No index.ts -> generate fresh file from template
@@ -344,24 +347,44 @@ function reactGen(_a) {
                             : undefined;
                         if (!moduleSpecifier)
                             continue;
-                        const desired = desiredExports.get(moduleSpecifier);
-                        if (!desired)
+                        const desiredValues = desiredValueExports.get(moduleSpecifier);
+                        const desiredTypes = desiredTypeExports.get(moduleSpecifier);
+                        if (!desiredValues && !desiredTypes)
                             continue;
+                        const declIsTypeOnly = Boolean(stmt.isTypeOnly);
                         for (const el of stmt.exportClause.elements) {
                             const name = el.name.getText(sourceFile);
-                            if (desired.has(name))
-                                desired.delete(name);
+                            const specIsTypeOnly = Boolean(el.isTypeOnly);
+                            const isTypeOnly = declIsTypeOnly || specIsTypeOnly;
+                            if (isTypeOnly) {
+                                if (desiredTypes === null || desiredTypes === void 0 ? void 0 : desiredTypes.has(name))
+                                    desiredTypes.delete(name);
+                            }
+                            else {
+                                if (desiredValues === null || desiredValues === void 0 ? void 0 : desiredValues.has(name))
+                                    desiredValues.delete(name);
+                            }
                         }
                     }
                 }
                 // Prepare new export lines for any remaining names
                 const lines = [];
-                for (const [spec, names] of desiredExports) {
-                    const missing = Array.from(names);
-                    if (missing.length === 0)
+                const specs = new Set([
+                    ...desiredValueExports.keys(),
+                    ...desiredTypeExports.keys()
+                ]);
+                for (const spec of specs) {
+                    const missingValues = Array.from((_b = desiredValueExports.get(spec)) !== null && _b !== void 0 ? _b : []);
+                    const missingTypes = Array.from((_c = desiredTypeExports.get(spec)) !== null && _c !== void 0 ? _c : []);
+                    if (missingValues.length === 0 && missingTypes.length === 0)
                         continue;
                     const specEscaped = spec.replace(/\\/g, '/');
-                    lines.push(`export { ${missing.join(', ')} } from "${specEscaped}";`);
+                    if (missingValues.length > 0) {
+                        lines.push(`export { ${missingValues.join(', ')} } from "${specEscaped}";`);
+                    }
+                    if (missingTypes.length > 0) {
+                        lines.push(`export type { ${missingTypes.join(', ')} } from "${specEscaped}";`);
+                    }
                 }
                 if (lines.length > 0) {
                     const appended = (existing.endsWith('\n') ? '' : '\n') + lines.join('\n') + '\n';
@@ -420,7 +443,7 @@ function reactGen(_a) {
                     (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) { }
+                catch (_d) { }
             }
             // Only re-export from index.ts when there are actual declarations to surface.
             if (hasAny) {
@@ -438,7 +461,7 @@ function reactGen(_a) {
                         }
                     }
                 }
-                catch (_c) { }
+                catch (_e) { }
             }
         }
         catch (e) {

package/package.json

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