@openwebf/webf 0.23.7 → 0.24.0

package/src/commands.ts

@@ -3,7 +3,9 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { dartGen, reactGen, vueGen } from './generator';
-import { glob } from 'glob';
+import { generateModuleArtifacts } from './module';
+import { getPackageTypesFileFromDir, isPackageTypesReady, readJsonFile } from './peerDeps';
+import { globSync } from 'glob';
 import _ from 'lodash';
 import inquirer from 'inquirer';
 import yaml from 'yaml';
@@ -164,6 +166,20 @@ const gitignore = fs.readFileSync(
   'utf-8'
 );
 
+const modulePackageJson = fs.readFileSync(
+  path.resolve(__dirname, '../templates/module.package.json.tpl'),
+  'utf-8'
+);
+
+const moduleTsConfig = fs.readFileSync(
+  path.resolve(__dirname, '../templates/module.tsconfig.json.tpl'),
+  'utf-8'
+);
+
+const moduleTsUpConfig = fs.readFileSync(
+  path.resolve(__dirname, '../templates/module.tsup.config.ts.tpl'),
+  'utf-8'
+);
 const reactPackageJson = fs.readFileSync(
   path.resolve(__dirname, '../templates/react.package.json.tpl'),
   'utf-8'
@@ -222,6 +238,40 @@ function readFlutterPackageMetadata(packagePath: string): FlutterPackageMetadata
   }
 }
 
+function copyReadmeToPackageRoot(params: {
+  sourceRoot: string;
+  targetRoot: string;
+}): { copied: boolean; sourcePath?: string; targetPath: string } {
+  const { sourceRoot, targetRoot } = params;
+  const targetPath = path.join(targetRoot, 'README.md');
+
+  if (fs.existsSync(targetPath)) {
+    return { copied: false, targetPath };
+  }
+
+  const candidateNames = ['README.md', 'Readme.md', 'readme.md'];
+  let sourcePath: string | null = null;
+  for (const candidate of candidateNames) {
+    const abs = path.join(sourceRoot, candidate);
+    if (fs.existsSync(abs)) {
+      sourcePath = abs;
+      break;
+    }
+  }
+
+  if (!sourcePath) {
+    return { copied: false, targetPath };
+  }
+
+  try {
+    const content = fs.readFileSync(sourcePath, 'utf-8');
+    writeFileIfChanged(targetPath, content);
+    return { copied: true, sourcePath, targetPath };
+  } catch {
+    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.
 async function copyMarkdownDocsToDist(params: {
@@ -241,7 +291,7 @@ async function copyMarkdownDocsToDist(params: {
   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 });
+  const dtsFiles = globSync('**/*.d.ts', { cwd: sourceRoot, ignore });
   let copied = 0;
   let skipped = 0;
   const readmeSections: { title: string; relPath: string; content: string }[] = [];
@@ -426,8 +476,8 @@ function createCommand(target: string, options: { framework: string; packageName
       // Leave merge to the codegen step which appends exports safely
     }
 
-    // !no '--omit=peer' here.
-    spawnSync(NPM, ['install'], {
+    // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+    spawnSync(NPM, ['install', '--production=false'], {
       cwd: target,
       stdio: 'inherit'
     });
@@ -449,12 +499,8 @@ function createCommand(target: string, options: { framework: string; packageName
     const gitignoreContent = _.template(gitignore)({});
     writeFileIfChanged(gitignorePath, gitignoreContent);
 
-    spawnSync(NPM, ['install', '@openwebf/webf-enterprise-typings'], {
-      cwd: target,
-      stdio: 'inherit'
-    });
-
-    spawnSync(NPM, ['install', 'vue', '-D'], {
+    // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+    spawnSync(NPM, ['install', '--production=false'], {
       cwd: target,
       stdio: 'inherit'
     });
@@ -463,6 +509,46 @@ function createCommand(target: string, options: { framework: string; packageName
   console.log(`WebF ${framework} package created at: ${target}`);
 }
 
+function createModuleProject(target: string, options: { packageName: string; metadata?: FlutterPackageMetadata; skipGitignore?: boolean }): void {
+  const { metadata, skipGitignore } = options;
+  const packageName = isValidNpmPackageName(options.packageName)
+    ? options.packageName
+    : sanitizePackageName(options.packageName);
+
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(target, { recursive: true });
+  }
+
+  const packageJsonPath = path.join(target, 'package.json');
+  const packageJsonContent = _.template(modulePackageJson)({
+    packageName,
+    version: metadata?.version || '0.0.1',
+    description: metadata?.description || '',
+  });
+  writeFileIfChanged(packageJsonPath, packageJsonContent);
+
+  const tsConfigPath = path.join(target, 'tsconfig.json');
+  const tsConfigContent = _.template(moduleTsConfig)({});
+  writeFileIfChanged(tsConfigPath, tsConfigContent);
+
+  const tsupConfigPath = path.join(target, 'tsup.config.ts');
+  const tsupConfigContent = _.template(moduleTsUpConfig)({});
+  writeFileIfChanged(tsupConfigPath, tsupConfigContent);
+
+  if (!skipGitignore) {
+    const gitignorePath = path.join(target, '.gitignore');
+    const gitignoreContent = _.template(gitignore)({});
+    writeFileIfChanged(gitignorePath, gitignoreContent);
+  }
+
+  const srcDir = path.join(target, 'src');
+  if (!fs.existsSync(srcDir)) {
+    fs.mkdirSync(srcDir, { recursive: true });
+  }
+
+  console.log(`WebF module package scaffold created at: ${target}`);
+}
+
 async function generateCommand(distPath: string, options: GenerateOptions): Promise<void> {
   // If distPath is not provided or is '.', create a temporary directory
   let resolvedDistPath: string;
@@ -727,6 +813,17 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
   // 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}...`);
 
   await dartGen({
@@ -846,6 +943,236 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
   }
 }
 
+async function generateModuleCommand(distPath: string, options: GenerateOptions): Promise<void> {
+  let resolvedDistPath: string;
+  let isTempDir = false;
+  if (!distPath || distPath === '.') {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'webf-module-'));
+    resolvedDistPath = tempDir;
+    isTempDir = true;
+    console.log(`\nUsing temporary directory for module package: ${tempDir}`);
+  } else {
+    resolvedDistPath = path.resolve(distPath);
+  }
+
+  // Detect Flutter package root if not provided
+  if (!options.flutterPackageSrc) {
+    let currentDir = process.cwd();
+    let foundPubspec = false;
+    let pubspecDir = '';
+
+    for (let i = 0; i < 3; i++) {
+      const pubspecPath = path.join(currentDir, 'pubspec.yaml');
+      if (fs.existsSync(pubspecPath)) {
+        foundPubspec = true;
+        pubspecDir = currentDir;
+        break;
+      }
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) break;
+      currentDir = parentDir;
+    }
+
+    if (!foundPubspec) {
+      console.error('Could not find pubspec.yaml. Please provide --flutter-package-src.');
+      process.exit(1);
+    }
+
+    options.flutterPackageSrc = pubspecDir;
+    console.log(`Detected Flutter package at: ${pubspecDir}`);
+  }
+
+  const flutterPackageSrc = path.resolve(options.flutterPackageSrc);
+
+  // Validate TS environment in the Flutter package
+  console.log(`\nValidating TypeScript environment in ${flutterPackageSrc}...`);
+  let validation = validateTypeScriptEnvironment(flutterPackageSrc);
+  if (!validation.isValid) {
+    const tsConfigPath = path.join(flutterPackageSrc, 'tsconfig.json');
+    if (!fs.existsSync(tsConfigPath)) {
+      const defaultTsConfig = {
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          lib: ['ES2020'],
+          declaration: true,
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          forceConsistentCasingInFileNames: true,
+          resolveJsonModule: true,
+          moduleResolution: 'node',
+        },
+        include: ['lib/**/*.d.ts', '**/*.d.ts'],
+        exclude: ['node_modules', 'dist', 'build'],
+      };
+
+      fs.writeFileSync(tsConfigPath, JSON.stringify(defaultTsConfig, null, 2), 'utf-8');
+      console.log('✅ Created tsconfig.json for module package');
+
+      validation = validateTypeScriptEnvironment(flutterPackageSrc);
+    }
+
+    if (!validation.isValid) {
+      console.error('\n❌ TypeScript environment validation failed:');
+      validation.errors.forEach(err => console.error(`   - ${err}`));
+      console.error('\nPlease fix the above issues before running `webf module-codegen` again.');
+      process.exit(1);
+    }
+  }
+
+  // Read Flutter metadata for package.json
+  const metadata = readFlutterPackageMetadata(flutterPackageSrc);
+
+  // Determine package name
+  let packageName = options.packageName;
+  if (packageName && !isValidNpmPackageName(packageName)) {
+    console.warn(`Warning: Package name "${packageName}" is not valid for npm.`);
+    const sanitized = sanitizePackageName(packageName);
+    console.log(`Using sanitized name: "${sanitized}"`);
+    packageName = sanitized;
+  }
+
+  if (!packageName) {
+    const rawDefaultName = metadata?.name
+      ? `@openwebf/${metadata.name.replace(/^webf_/, 'webf-')}`
+      : '@openwebf/webf-module';
+
+    const defaultPackageName = isValidNpmPackageName(rawDefaultName)
+      ? rawDefaultName
+      : sanitizePackageName(rawDefaultName);
+
+    const packageNameAnswer = await inquirer.prompt([{
+      type: 'input',
+      name: 'packageName',
+      message: 'What is your npm package name for this module?',
+      default: defaultPackageName,
+      validate: (input: string) => {
+        if (!input || input.trim() === '') {
+          return 'Package name is required';
+        }
+
+        if (isValidNpmPackageName(input)) {
+          return true;
+        }
+
+        const sanitized = sanitizePackageName(input);
+        return `Invalid npm package name. Would be sanitized to: "${sanitized}". Please enter a valid name.`;
+      }
+    }]);
+    packageName = packageNameAnswer.packageName;
+  }
+
+  // Prevent npm scaffolding (package.json, tsup.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.');
+    console.error('Please choose a separate directory for the generated npm package, for example:');
+    console.error('  webf module-codegen ../packages/webf-share --flutter-package-src=../webf_modules/share');
+    process.exit(1);
+  }
+
+  // Scaffold npm project for the module
+  if (!packageName) {
+    throw new Error('Package name could not be resolved for module package.');
+  }
+  createModuleProject(resolvedDistPath, {
+    packageName,
+    metadata: metadata || undefined,
+  });
+
+  // Locate module interface file (*.module.d.ts)
+  const defaultIgnore = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**'];
+  const ignore = options.exclude && options.exclude.length
+    ? [...defaultIgnore, ...options.exclude]
+    : defaultIgnore;
+
+  const candidates = globSync('**/*.module.d.ts', {
+    cwd: flutterPackageSrc,
+    ignore,
+  });
+
+  if (candidates.length === 0) {
+    console.error(
+      `\n❌ No module interface files (*.module.d.ts) found under ${flutterPackageSrc}.`
+    );
+    console.error('Please add a TypeScript interface file describing your module API.');
+    process.exit(1);
+  }
+
+  const moduleInterfaceRel = candidates[0];
+  const moduleInterfacePath = path.join(flutterPackageSrc, moduleInterfaceRel);
+
+  const command = `webf module-codegen --flutter-package-src=${flutterPackageSrc} <distPath>`;
+
+  console.log(`\nGenerating module npm package and Dart bindings from ${moduleInterfaceRel}...`);
+
+  generateModuleArtifacts({
+    moduleInterfacePath,
+    npmTargetDir: resolvedDistPath,
+    flutterPackageDir: flutterPackageSrc,
+    command,
+  });
+
+  console.log('\nModule code generation completed successfully!');
+
+  try {
+    await buildPackage(resolvedDistPath);
+  } catch (error) {
+    console.error('\nWarning: Build failed:', error);
+  }
+
+  if (options.publishToNpm) {
+    try {
+      await buildAndPublishPackage(resolvedDistPath, options.npmRegistry, false);
+    } catch (error) {
+      console.error('\nError during npm publish:', error);
+      process.exit(1);
+    }
+  } else {
+    const publishAnswer = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'publish',
+      message: 'Would you like to publish this module package to npm?',
+      default: false
+    }]);
+
+    if (publishAnswer.publish) {
+      const registryAnswer = await inquirer.prompt([{
+        type: 'input',
+        name: 'registry',
+        message: 'NPM registry URL (leave empty for default npm registry):',
+        default: '',
+        validate: (input: string) => {
+          if (!input) return true;
+          try {
+            new URL(input);
+            return true;
+          } catch {
+            return 'Please enter a valid URL';
+          }
+        }
+      }]);
+
+      try {
+        await buildAndPublishPackage(
+          resolvedDistPath,
+          registryAnswer.registry || undefined,
+          false
+        );
+      } catch (error) {
+        console.error('\nError during npm publish:', error);
+        // Don't exit here since generation was successful
+      }
+    }
+  }
+
+  if (isTempDir) {
+    console.log(`\n📁 Generated module npm package is in: ${resolvedDistPath}`);
+    console.log('💡 To use it, copy this directory to your packages folder or publish it directly.');
+  }
+}
+
 function writeFileIfChanged(filePath: string, content: string) {
   if (fs.existsSync(filePath)) {
     const oldContent = fs.readFileSync(filePath, 'utf-8')
@@ -895,6 +1222,101 @@ async function buildPackage(packagePath: string): Promise<void> {
   const packageName = packageJson.name;
   const packageVersion = packageJson.version;
 
+  function getInstalledPackageJsonPath(pkgName: string): string {
+    const parts = pkgName.split('/');
+    return path.join(packagePath, 'node_modules', ...parts, 'package.json');
+  }
+
+  function getInstalledPackageDir(pkgName: string): string {
+    const parts = pkgName.split('/');
+    return path.join(packagePath, 'node_modules', ...parts);
+  }
+
+  function findUp(startDir: string, relativePathToFind: string): string | null {
+    let dir = path.resolve(startDir);
+    while (true) {
+      const candidate = path.join(dir, relativePathToFind);
+      if (fs.existsSync(candidate)) return candidate;
+      const parent = path.dirname(dir);
+      if (parent === dir) return null;
+      dir = parent;
+    }
+  }
+
+  function ensurePeerDependencyAvailableForBuild(peerName: string): void {
+    const installedPkgJson = getInstalledPackageJsonPath(peerName);
+    if (fs.existsSync(installedPkgJson)) return;
+
+    const peerRange = packageJson.peerDependencies?.[peerName];
+    const localMap: Record<string, string> = {
+      '@openwebf/react-core-ui': path.join('packages', 'react-core-ui'),
+      '@openwebf/vue-core-ui': path.join('packages', 'vue-core-ui'),
+    };
+
+    let installSpec: string | null = null;
+
+    const localRel = localMap[peerName];
+    if (localRel) {
+      const localPath = findUp(process.cwd(), localRel);
+      if (localPath) {
+        if (!isPackageTypesReady(localPath)) {
+          const localPkgJsonPath = path.join(localPath, 'package.json');
+          if (fs.existsSync(localPkgJsonPath)) {
+            const localPkgJson = readJsonFile(localPkgJsonPath);
+            if (localPkgJson.scripts?.build) {
+              if (process.env.WEBF_CODEGEN_BUILD_LOCAL_PEERS !== '1') {
+                console.warn(
+                  `\n⚠️  Local ${peerName} found at ${localPath} but type declarations are missing; falling back to registry install.`
+                );
+              } else {
+                console.log(
+                  `\n🔧 Local ${peerName} found at ${localPath} but build artifacts are missing; building it for DTS...`
+                );
+                const buildLocalResult = spawnSync(NPM, ['run', 'build'], {
+                  cwd: localPath,
+                  stdio: 'inherit'
+                });
+                if (buildLocalResult.status === 0) {
+                  if (isPackageTypesReady(localPath)) {
+                    installSpec = localPath;
+                  } else {
+                    console.warn(
+                      `\n⚠️  Built local ${peerName} but type declarations are still missing; falling back to registry install.`
+                    );
+                  }
+                } else {
+                  console.warn(`\n⚠️  Failed to build local ${peerName}; falling back to registry install.`);
+                }
+              }
+            }
+          }
+        } else {
+          installSpec = localPath;
+        }
+      }
+    }
+
+    if (!installSpec) {
+      installSpec = peerRange ? `${peerName}@${peerRange}` : peerName;
+    }
+
+    console.log(`\n📦 Installing peer dependency for build: ${peerName}...`);
+    const installResult = spawnSync(NPM, ['install', '--no-save', installSpec], {
+      cwd: packagePath,
+      stdio: 'inherit'
+    });
+    if (installResult.status !== 0) {
+      throw new Error(`Failed to install peer dependency for build: ${peerName}`);
+    }
+
+    const installedTypesFile = getPackageTypesFileFromDir(getInstalledPackageDir(peerName));
+    if (installedTypesFile && !fs.existsSync(installedTypesFile)) {
+      throw new Error(
+        `Peer dependency ${peerName} was installed but type declarations were not found at ${installedTypesFile}`
+      );
+    }
+  }
+
   // Check if node_modules exists
   const nodeModulesPath = path.join(packagePath, 'node_modules');
   if (!fs.existsSync(nodeModulesPath)) {
@@ -920,6 +1342,14 @@ async function buildPackage(packagePath: string): Promise<void> {
 
   // Check if package has a build script
   if (packageJson.scripts?.build) {
+    // DTS build needs peer deps present locally to resolve types (even though they are not bundled).
+    if (packageJson.peerDependencies?.['@openwebf/react-core-ui']) {
+      ensurePeerDependencyAvailableForBuild('@openwebf/react-core-ui');
+    }
+    if (packageJson.peerDependencies?.['@openwebf/vue-core-ui']) {
+      ensurePeerDependencyAvailableForBuild('@openwebf/vue-core-ui');
+    }
+
     console.log(`\nBuilding ${packageName}@${packageVersion}...`);
     const buildResult = spawnSync(NPM, ['run', 'build'], {
       cwd: packagePath,
@@ -1016,4 +1446,4 @@ async function buildAndPublishPackage(packagePath: string, registry?: string, is
   }
 }
 
-export { generateCommand };
+export { generateCommand, generateModuleCommand };

package/src/generator.ts

@@ -2,7 +2,7 @@ import path from 'path';
 import fs from 'fs';
 import process from 'process';
 import _ from 'lodash';
-import { glob } from 'glob';
+import { globSync } from 'glob';
 import yaml from 'yaml';
 import { IDLBlob } from './IDLBlob';
 import { ClassObject, ConstObject, EnumObject, TypeAliasObject } from './declaration';
@@ -19,7 +19,7 @@ const fileContentCache = new Map<string, string>();
 // Cache for generated content to detect changes
 const generatedContentCache = new Map<string, string>();
 
-function writeFileIfChanged(filePath: string, content: string): boolean {
+export function writeFileIfChanged(filePath: string, content: string): boolean {
   // Check if content has changed by comparing with cache
   const cachedContent = generatedContentCache.get(filePath);
   if (cachedContent === content) {
@@ -107,7 +107,7 @@ function getTypeFiles(source: string, excludePatterns?: string[]): string[] {
     const defaultIgnore = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**'];
     const ignore = excludePatterns ? [...defaultIgnore, ...excludePatterns] : defaultIgnore;
     
-    const files = glob.globSync("**/*.d.ts", {
+    const files = globSync("**/*.d.ts", {
       cwd: source,
       ignore: ignore
     });
@@ -407,13 +407,9 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
       warn(`Failed to merge into existing index.ts. Skipping modifications: ${indexFilePath}`);
     }
   }
-  
-  timeEnd('reactGen');
-  success(`React code generation completed. ${filesChanged} files changed.`);
-  info(`Output directory: ${normalizedTarget}`);
-  info('You can now import these components in your React project.');
 
-  // Aggregate standalone type declarations (consts/enums/type aliases) into a single types.ts
+  // Always generate src/types.ts so generated components can safely import it.
+  // When there are no standalone declarations, emit an empty module (`export {};`).
   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[]);
@@ -426,40 +422,40 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
     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 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 typesContent = [
+      '/* Generated by WebF CLI - aggregated type declarations */',
+      hasAny ? typeAliasDecl : '',
+      hasAny ? constDecl : '',
+      hasAny ? enumDecl : '',
+      hasAny ? '' : 'export {};',
+      ''
+    ].filter(Boolean).join('\n');
 
-      const typesPath = path.join(normalizedTarget, 'src', 'types.ts');
-      if (writeFileIfChanged(typesPath, typesContent)) {
-        filesChanged++;
-        debug(`Generated: src/types.ts`);
-        try {
-          const constNames = Array.from(constMap.keys());
-          const aliasNames = Array.from(typeAliasMap.keys());
-          const enumNames = enums.map(e => e.name);
-          debug(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
-          debug(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
-        } catch {}
-      }
+    const typesPath = path.join(normalizedTarget, 'src', 'types.ts');
+    if (writeFileIfChanged(typesPath, typesContent)) {
+      filesChanged++;
+      debug(`Generated: src/types.ts`);
+      try {
+        const constNames = Array.from(constMap.keys());
+        const aliasNames = Array.from(typeAliasMap.keys());
+        const enumNames = enums.map(e => e.name);
+        debug(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
+        debug(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
+      } catch {}
+    }
 
-      // Ensure index.ts re-exports these types so consumers get them on import.
-      const indexFilePath = path.join(normalizedTarget, 'src', 'index.ts');
+    // Only re-export from index.ts when there are actual declarations to surface.
+    if (hasAny) {
       try {
         let current = '';
         if (fs.existsSync(indexFilePath)) {
@@ -478,6 +474,11 @@ export async function reactGen({ source, target, exclude, packageName }: Generat
   } catch (e) {
     warn('Failed to generate aggregated React types');
   }
+
+  timeEnd('reactGen');
+  success(`React code generation completed. ${filesChanged} files changed.`);
+  info(`Output directory: ${normalizedTarget}`);
+  info('You can now import these components in your React project.');
 }
 
 export async function vueGen({ source, target, exclude }: GenerateOptions) {