@openwebf/webf 0.23.0 → 0.23.2

package/dist/vue.js

@@ -131,6 +131,17 @@ interface ${object.name} {
     }).join('\n');
     return result;
 }
+function toVueTagName(className) {
+    if (className.startsWith('WebF')) {
+        const withoutPrefix = className.substring(4);
+        return 'web-f-' + lodash_1.default.kebabCase(withoutPrefix);
+    }
+    else if (className.startsWith('Flutter')) {
+        const withoutPrefix = className.substring(7);
+        return 'flutter-' + lodash_1.default.kebabCase(withoutPrefix);
+    }
+    return lodash_1.default.kebabCase(className);
+}
 function generateVueTypings(blobs) {
     const componentNames = blobs.map(blob => {
         const classObjects = blob.objects;
@@ -160,13 +171,42 @@ function generateVueTypings(blobs) {
     }).filter(component => {
         return component.length > 0;
     }).join('\n\n');
+    // Collect declare consts across blobs and render as exported ambient declarations
+    const consts = blobs
+        .flatMap(blob => blob.objects)
+        .filter(obj => obj instanceof declaration_1.ConstObject);
+    // Deduplicate by name keeping first occurrence
+    const uniqueConsts = new Map();
+    consts.forEach(c => {
+        if (!uniqueConsts.has(c.name))
+            uniqueConsts.set(c.name, c);
+    });
+    const constDeclarations = Array.from(uniqueConsts.values())
+        .map(c => `export declare const ${c.name}: ${c.type};`)
+        .join('\n');
+    // Collect declare enums across blobs
+    const enums = blobs
+        .flatMap(blob => blob.objects)
+        .filter(obj => obj instanceof declaration_1.EnumObject);
+    const enumDeclarations = enums.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');
+    // Build mapping of template tag names to class names for GlobalComponents
+    const componentMetas = componentNames.map(className => ({
+        className,
+        tagName: toVueTagName(className),
+    }));
     const content = lodash_1.default.template(readTemplate('vue.components.d.ts'), {
         interpolate: /<%=([\s\S]+?)%>/g,
         evaluate: /<%([\s\S]+?)%>/g,
         escape: /<%-([\s\S]+?)%>/g
     })({
         componentNames,
+        componentMetas,
         components,
+        consts: constDeclarations,
+        enums: enumDeclarations,
     });
     return content.split('\n').filter(str => {
         return str.trim().length > 0;

package/package.json

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

package/src/IDLBlob.ts

@@ -1,4 +1,4 @@
-import {ClassObject, FunctionObject, TypeAliasObject} from "./declaration";
+import {ClassObject, FunctionObject, TypeAliasObject, EnumObject} from "./declaration";
 
 export class IDLBlob {
   raw: string = '';
@@ -7,7 +7,7 @@ export class IDLBlob {
   filename: string;
   implement: string;
   relativeDir: string = '';
-  objects: (ClassObject | FunctionObject | TypeAliasObject)[] = [];
+  objects: (ClassObject | FunctionObject | TypeAliasObject | EnumObject)[] = [];
 
   constructor(source: string, dist: string, filename: string, implement: string, relativeDir: string = '') {
     this.source = source;

package/src/analyzer.ts

@@ -8,6 +8,9 @@ import {
   FunctionArgumentType,
   FunctionDeclaration,
   FunctionObject,
+  ConstObject,
+  EnumObject,
+  EnumMemberObject,
   IndexedPropertyDeclaration,
   ParameterMode,
   PropsDeclaration,
@@ -25,8 +28,8 @@ export interface UnionTypeCollector {
   types: Set<ParameterType[]>;
 }
 
-// Cache for parsed source files to avoid re-parsing
-const sourceFileCache = new Map<string, { content: string; sourceFile: ts.SourceFile }>();
+// Cache for parsed source files to avoid re-parsing (cache by path only)
+const sourceFileCache = new Map<string, ts.SourceFile>();
 
 // Cache for type conversions to avoid redundant processing
 const typeConversionCache = new Map<string, ParameterType>();
@@ -59,14 +62,12 @@ export function analyzer(blob: IDLBlob, definedPropertyCollector: DefinedPropert
     // Check cache first - consider both file path and content
     const cacheEntry = sourceFileCache.get(blob.source);
     let sourceFile: ts.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 = ts.createSourceFile(blob.source, blob.raw, ScriptTarget.ES2020);
-      sourceFileCache.set(blob.source, { content: blob.raw, sourceFile });
+      sourceFileCache.set(blob.source, sourceFile);
     }
     
     blob.objects = sourceFile.statements
@@ -78,7 +79,7 @@ export function analyzer(blob: IDLBlob, definedPropertyCollector: DefinedPropert
           return null;
         }
       })
-      .filter(o => o instanceof ClassObject || o instanceof FunctionObject || o instanceof TypeAliasObject) as (FunctionObject | ClassObject | TypeAliasObject)[];
+      .filter(o => o instanceof ClassObject || o instanceof FunctionObject || o instanceof TypeAliasObject || o instanceof ConstObject || o instanceof EnumObject) as (FunctionObject | ClassObject | TypeAliasObject | ConstObject | EnumObject)[];
   } catch (error) {
     console.error(`Error analyzing ${blob.source}:`, error);
     throw new Error(`Failed to analyze ${blob.source}: ${error instanceof Error ? error.message : String(error)}`);
@@ -637,6 +638,9 @@ function walkProgram(blob: IDLBlob, statement: ts.Statement, sourceFile: ts.Sour
       
     case ts.SyntaxKind.TypeAliasDeclaration:
       return processTypeAliasDeclaration(statement as ts.TypeAliasDeclaration, blob);
+    
+    case ts.SyntaxKind.EnumDeclaration:
+      return processEnumDeclaration(statement as ts.EnumDeclaration, blob);
       
     default:
       return null;
@@ -657,6 +661,48 @@ function processTypeAliasDeclaration(
   return typeAlias;
 }
 
+function processEnumDeclaration(
+  statement: ts.EnumDeclaration,
+  blob: IDLBlob
+): EnumObject {
+  const enumObj = new EnumObject();
+  enumObj.name = statement.name.text;
+
+  const printer = ts.createPrinter();
+  enumObj.members = statement.members.map(m => {
+    const mem = new EnumMemberObject();
+    if (ts.isIdentifier(m.name)) {
+      mem.name = m.name.text;
+    } else if (ts.isStringLiteral(m.name)) {
+      // Preserve quotes in output
+      mem.name = `'${m.name.text}'`;
+    } else if (ts.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 = (m.initializer as any).pos ?? 0;
+        const end = (m.initializer as any).end ?? 0;
+        if (start >= 0 && end > start) {
+          mem.initializer = blob.raw.substring(start, end).trim();
+        }
+      } catch {
+        // Fallback to printer (may normalize to decimal)
+        mem.initializer = printer.printNode(ts.EmitHint.Unspecified, m.initializer, statement.getSourceFile());
+      }
+    }
+    return mem;
+  });
+
+  return enumObj;
+}
+
 function processInterfaceDeclaration(
   statement: ts.InterfaceDeclaration,
   blob: IDLBlob,
@@ -908,34 +954,46 @@ function processConstructSignature(
 function processVariableStatement(
   statement: VariableStatement,
   unionTypeCollector: UnionTypeCollector
-): FunctionObject | null {
+): FunctionObject | ConstObject | null {
   const declaration = statement.declarationList.declarations[0];
-  
+
+  if (!declaration) return null;
+
   if (!ts.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 || !ts.isFunctionTypeNode(type)) {
+
+  const varName = declaration.name.text;
+  const typeNode = declaration.type;
+
+  if (!typeNode) {
     return null;
   }
-  
-  const functionObject = new FunctionObject();
-  functionObject.declare = new 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 (ts.isFunctionTypeNode(typeNode)) {
+    const functionObject = new FunctionObject();
+    functionObject.declare = new 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 = ts.createPrinter();
+  const typeText = printer.printNode(ts.EmitHint.Unspecified, typeNode, typeNode.getSourceFile());
+  const constObj = new ConstObject();
+  constObj.name = varName;
+  constObj.type = typeText;
+  return constObj;
 }
 
 // Clear caches when needed (e.g., between runs)
 export function clearCaches() {
   sourceFileCache.clear();
   typeConversionCache.clear();
-}
+}

package/src/commands.ts

@@ -3,6 +3,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { dartGen, reactGen, vueGen } from './generator';
+import { glob } from 'glob';
 import _ from 'lodash';
 import inquirer from 'inquirer';
 import yaml from 'yaml';
@@ -220,6 +221,53 @@ function readFlutterPackageMetadata(packagePath: string): FlutterPackageMetadata
   }
 }
 
+// Copy markdown docs that match .d.ts basenames from source to the built dist folder
+async function copyMarkdownDocsToDist(params: {
+  sourceRoot: string;
+  distRoot: string;
+  exclude?: string[];
+}): Promise<{ copied: number; skipped: number }> {
+  const { sourceRoot, distRoot, exclude } = params;
+
+  // Ensure dist exists
+  if (!fs.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.globSync('**/*.d.ts', { cwd: sourceRoot, ignore });
+  let copied = 0;
+  let skipped = 0;
+
+  for (const relDts of dtsFiles) {
+    if (path.basename(relDts) === 'global.d.ts') {
+      continue;
+    }
+
+    const relMd = relDts.replace(/\.d\.ts$/i, '.md');
+    const absMd = path.join(sourceRoot, relMd);
+    if (!fs.existsSync(absMd)) {
+      skipped++;
+      continue;
+    }
+
+    // Copy into dist preserving relative path
+    const destPath = path.join(distRoot, relMd);
+    const destDir = path.dirname(destPath);
+    if (!fs.existsSync(destDir)) {
+      fs.mkdirSync(destDir, { recursive: true });
+    }
+    fs.copyFileSync(absMd, destPath);
+    copied++;
+  }
+
+  return { copied, skipped };
+}
+
 function validateTypeScriptEnvironment(projectPath: string): { isValid: boolean; errors: string[] } {
   const errors: string[] = [];
   
@@ -310,7 +358,7 @@ function createCommand(target: string, options: { framework: string; packageName
       // Leave merge to the codegen step which appends exports safely
     }
 
-    spawnSync(NPM, ['install', '--omit=peer'], {
+    spawnSync(NPM, ['install'], {
       cwd: target,
       stdio: 'inherit'
     });
@@ -602,7 +650,9 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
       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') {
     await vueGen({
@@ -619,6 +669,18 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
   if (framework) {
     try {
       await buildPackage(resolvedDistPath);
+      // After building React package, copy any matching .md docs next to built JS files
+      if (framework === 'react' && options.flutterPackageSrc) {
+        const distOut = path.join(resolvedDistPath, 'dist');
+        const { copied } = await 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);
       // Don't exit here since generation was successful

package/src/declaration.ts

@@ -89,3 +89,18 @@ 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[] = [];
+}

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.`);
@@ -324,6 +323,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 +357,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 +410,66 @@ 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.d.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 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.join(normalizedTarget, 'src', 'types.d.ts');
+      if (writeFileIfChanged(typesPath, typesContent)) {
+        filesChanged++;
+        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.join(normalizedTarget, 'src', 'index.ts');
+      try {
+        if (fs.existsSync(indexFilePath)) {
+          let current = fs.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++;
+              debug(`Updated: src/index.ts with reference to types.d.ts`);
+            }
+          }
+        }
+      } catch {}
+    }
+  } catch (e) {
+    warn('Failed to generate aggregated React types.d.ts');
+  }
 }
 
 export async function vueGen({ source, target, exclude }: GenerateOptions) {

package/src/react.ts

@@ -2,7 +2,7 @@ import _ from "lodash";
 import fs from 'fs';
 import path from 'path';
 import {ParameterType} from "./analyzer";
-import {ClassObject, FunctionArgumentType, FunctionDeclaration, TypeAliasObject} from "./declaration";
+import {ClassObject, FunctionArgumentType, FunctionDeclaration, TypeAliasObject, ConstObject, EnumObject} from "./declaration";
 import {IDLBlob} from "./IDLBlob";
 import {getPointerType, isPointerType, isUnionType} from "./utils";
 
@@ -125,6 +125,8 @@ export function toWebFTagName(className: string): string {
 export function generateReactComponent(blob: IDLBlob, packageName?: string, relativeDir?: string) {
   const classObjects = blob.objects.filter(obj => obj instanceof ClassObject) as ClassObject[];
   const typeAliases = blob.objects.filter(obj => obj instanceof TypeAliasObject) as TypeAliasObject[];
+  const constObjects = blob.objects.filter(obj => obj instanceof ConstObject) as ConstObject[];
+  const enumObjects = blob.objects.filter(obj => obj instanceof EnumObject) as EnumObject[];
   
   const classObjectDictionary = Object.fromEntries(
     classObjects.map(object => {
@@ -153,8 +155,19 @@ export function generateReactComponent(blob: IDLBlob, packageName?: string, rela
     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 => {

package/src/vue.ts

@@ -2,7 +2,7 @@ import _ from "lodash";
 import fs from 'fs';
 import path from 'path';
 import {ParameterType} from "./analyzer";
-import {ClassObject, FunctionArgumentType, FunctionDeclaration} from "./declaration";
+import {ClassObject, FunctionArgumentType, FunctionDeclaration, ConstObject, EnumObject} from "./declaration";
 import {IDLBlob} from "./IDLBlob";
 import {getPointerType, isPointerType} from "./utils";
 
@@ -145,6 +145,17 @@ interface ${object.name} {
   return result;
 }
 
+function toVueTagName(className: string): string {
+  if (className.startsWith('WebF')) {
+    const withoutPrefix = className.substring(4);
+    return 'web-f-' + _.kebabCase(withoutPrefix);
+  } else if (className.startsWith('Flutter')) {
+    const withoutPrefix = className.substring(7);
+    return 'flutter-' + _.kebabCase(withoutPrefix);
+  }
+  return _.kebabCase(className);
+}
+
 export function generateVueTypings(blobs: IDLBlob[]) {
   const componentNames = blobs.map(blob => {
     const classObjects = blob.objects as ClassObject[];
@@ -177,13 +188,47 @@ export function generateVueTypings(blobs: IDLBlob[]) {
     return component.length > 0;
   }).join('\n\n');
 
+  // Collect declare consts across blobs and render as exported ambient declarations
+  const consts = blobs
+    .flatMap(blob => blob.objects)
+    .filter(obj => obj instanceof ConstObject) as ConstObject[];
+
+  // Deduplicate by name keeping first occurrence
+  const uniqueConsts = new Map<string, ConstObject>();
+  consts.forEach(c => {
+    if (!uniqueConsts.has(c.name)) uniqueConsts.set(c.name, c);
+  });
+
+  const constDeclarations = Array.from(uniqueConsts.values())
+    .map(c => `export declare const ${c.name}: ${c.type};`)
+    .join('\n');
+
+  // Collect declare enums across blobs
+  const enums = blobs
+    .flatMap(blob => blob.objects)
+    .filter(obj => obj instanceof EnumObject) as EnumObject[];
+
+  const enumDeclarations = enums.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');
+
+  // Build mapping of template tag names to class names for GlobalComponents
+  const componentMetas = componentNames.map(className => ({
+    className,
+    tagName: toVueTagName(className),
+  }));
+
   const content = _.template(readTemplate('vue.components.d.ts'), {
     interpolate: /<%=([\s\S]+?)%>/g,
     evaluate: /<%([\s\S]+?)%>/g,
     escape: /<%-([\s\S]+?)%>/g
   })({
     componentNames,
+    componentMetas,
     components,
+    consts: constDeclarations,
+    enums: enumDeclarations,
   });
 
   return content.split('\n').filter(str => {

package/templates/react.package.json.tpl

@@ -23,6 +23,7 @@
   "devDependencies": {
     "@types/react": "^19.1.0",
     "@types/react-dom": "^19.1.2",
+    "picomatch": "^4.0.2",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3"
   }

package/templates/vue.components.d.ts.tpl

@@ -19,6 +19,9 @@ type VueEventListeners<T extends EventMap> = {
   [K in keyof T as `on${Capitalize<string & K>}`]?: (event: T[K]) => any
 }
 
+<%= consts %>
+<%= enums %>
+
 type DefineCustomElement<
   ElementType,
   Events extends EventMap = {},
@@ -44,10 +47,10 @@ type DefineCustomElement<
 
 declare module 'vue' {
   interface GlobalComponents {
-    <% componentNames.forEach(name => { %>
-    '<%= name %>': DefineCustomElement<
-      <%= name %>Props,
-      <%= name %>Events
+    <% componentMetas.forEach(comp => { %>
+    '<%= comp.tagName %>': DefineCustomElement<
+      <%= comp.className %>Props,
+      <%= comp.className %>Events
     >
     <% }) %>
   }