@openwebf/webf 0.23.7 → 0.24.0

package/README.md

@@ -64,6 +64,34 @@ webf codegen my-typings --flutter-package-src=../webf_ui --publish-to-npm
 webf codegen my-typings --flutter-package-src=../webf_ui --publish-to-npm --npm-registry=https://custom.registry.com/
 ```
 
+### Generate Module Packages
+
+The `webf module-codegen` command generates a typed npm package and Dart bindings for a WebF module based on a TypeScript interface file (`*.module.d.ts`) in your Flutter package.
+
+```bash
+webf module-codegen [output-dir] [options]
+```
+
+#### Options:
+- `--flutter-package-src <path>`: Flutter module package path containing `*.module.d.ts`
+- `--package-name <name>`: NPM package name for the module (defaults to a name derived from `pubspec.yaml`)
+- `--publish-to-npm`: Automatically publish the generated package to npm
+- `--npm-registry <url>`: Custom npm registry URL (defaults to https://registry.npmjs.org/)
+- `--exclude <patterns...>`: Additional glob patterns to exclude from scanning (e.g. build directories)
+
+#### Example:
+
+```bash
+# From the CLI repo root
+webf module-codegen ../packages/webf-share --flutter-package-src=../webf_modules/share --package-name=@openwebf/webf-share
+```
+
+This will:
+- Scaffold an npm package at `../packages/webf-share`
+- Read `*.module.d.ts` from `../webf_modules/share`
+- Generate `src/index.ts` and `src/types.ts` that wrap `webf.invokeModuleAsync('Share', ...)`
+- Generate Dart bindings in `../webf_modules/share/lib/src/share_module_bindings_generated.dart`
+
 ### Interactive Mode
 
 If you don't provide all required options, the CLI will prompt you interactively:

package/bin/webf.js

@@ -2,7 +2,7 @@
 
 const { Command } = require('commander');
 const version = require('../package.json').version;
-const { generateCommand } = require('../dist/commands');
+const { generateCommand, generateModuleCommand } = require('../dist/commands');
 
 const program = new Command();
 
@@ -24,4 +24,15 @@ program
   .description('Generate dart abstract classes and React/Vue components (auto-creates project if needed)')
   .action(generateCommand);
 
+program
+  .command('module-codegen')
+  .option('--flutter-package-src <src>', 'Flutter module package source path (for module code generation)')
+  .option('--package-name <name>', 'NPM package name for the WebF module')
+  .option('--publish-to-npm', 'Automatically publish the generated module package to npm')
+  .option('--npm-registry <url>', 'Custom npm registry URL (defaults to https://registry.npmjs.org/)')
+  .option('--exclude <patterns...>', 'Additional glob patterns to exclude from code generation')
+  .argument('[distPath]', 'Path to output generated files', '.')
+  .description('Generate NPM package and Dart bindings for a WebF module from TypeScript interfaces (*.module.d.ts)')
+  .action(generateModuleCommand);
+
 program.parse();

package/dist/commands.js

@@ -13,11 +13,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCommand = generateCommand;
+exports.generateModuleCommand = generateModuleCommand;
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const generator_1 = require("./generator");
+const module_1 = require("./module");
+const peerDeps_1 = require("./peerDeps");
 const glob_1 = require("glob");
 const lodash_1 = __importDefault(require("lodash"));
 const inquirer_1 = __importDefault(require("inquirer"));
@@ -141,6 +144,9 @@ const NPM = platform == 'win32' ? 'npm.cmd' : 'npm';
 const gloabalDts = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../global.d.ts'), 'utf-8');
 const tsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/tsconfig.json.tpl'), 'utf-8');
 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 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');
@@ -172,6 +178,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) {
@@ -185,7 +218,7 @@ function copyMarkdownDocsToDist(params) {
         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 });
+        const dtsFiles = (0, glob_1.globSync)('**/*.d.ts', { cwd: sourceRoot, ignore });
         let copied = 0;
         let skipped = 0;
         const readmeSections = [];
@@ -345,8 +378,8 @@ function createCommand(target, options) {
             // Do not overwrite existing index.ts created by the user
             // Leave merge to the codegen step which appends exports safely
         }
-        // !no '--omit=peer' here.
-        (0, child_process_1.spawnSync)(NPM, ['install'], {
+        // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+        (0, child_process_1.spawnSync)(NPM, ['install', '--production=false'], {
             cwd: target,
             stdio: 'inherit'
         });
@@ -365,17 +398,46 @@ function createCommand(target, options) {
         const gitignorePath = path_1.default.join(target, '.gitignore');
         const gitignoreContent = lodash_1.default.template(gitignore)({});
         writeFileIfChanged(gitignorePath, gitignoreContent);
-        (0, child_process_1.spawnSync)(NPM, ['install', '@openwebf/webf-enterprise-typings'], {
-            cwd: target,
-            stdio: 'inherit'
-        });
-        (0, child_process_1.spawnSync)(NPM, ['install', 'vue', '-D'], {
+        // Ensure devDependencies are installed even if the user's shell has NODE_ENV=production.
+        (0, child_process_1.spawnSync)(NPM, ['install', '--production=false'], {
             cwd: target,
             stdio: 'inherit'
         });
     }
     console.log(`WebF ${framework} package created at: ${target}`);
 }
+function createModuleProject(target, options) {
+    const { metadata, skipGitignore } = options;
+    const packageName = isValidNpmPackageName(options.packageName)
+        ? options.packageName
+        : sanitizePackageName(options.packageName);
+    if (!fs_1.default.existsSync(target)) {
+        fs_1.default.mkdirSync(target, { recursive: true });
+    }
+    const packageJsonPath = path_1.default.join(target, 'package.json');
+    const packageJsonContent = lodash_1.default.template(modulePackageJson)({
+        packageName,
+        version: (metadata === null || metadata === void 0 ? void 0 : metadata.version) || '0.0.1',
+        description: (metadata === null || metadata === void 0 ? void 0 : metadata.description) || '',
+    });
+    writeFileIfChanged(packageJsonPath, packageJsonContent);
+    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);
+    if (!skipGitignore) {
+        const gitignorePath = path_1.default.join(target, '.gitignore');
+        const gitignoreContent = lodash_1.default.template(gitignore)({});
+        writeFileIfChanged(gitignorePath, gitignoreContent);
+    }
+    const srcDir = path_1.default.join(target, 'src');
+    if (!fs_1.default.existsSync(srcDir)) {
+        fs_1.default.mkdirSync(srcDir, { recursive: true });
+    }
+    console.log(`WebF module package scaffold created at: ${target}`);
+}
 function generateCommand(distPath, options) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d;
@@ -622,6 +684,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,
@@ -736,6 +808,208 @@ function generateCommand(distPath, options) {
         }
     });
 }
+function generateModuleCommand(distPath, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let resolvedDistPath;
+        let isTempDir = false;
+        if (!distPath || distPath === '.') {
+            const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'webf-module-'));
+            resolvedDistPath = tempDir;
+            isTempDir = true;
+            console.log(`\nUsing temporary directory for module package: ${tempDir}`);
+        }
+        else {
+            resolvedDistPath = path_1.default.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_1.default.join(currentDir, 'pubspec.yaml');
+                if (fs_1.default.existsSync(pubspecPath)) {
+                    foundPubspec = true;
+                    pubspecDir = currentDir;
+                    break;
+                }
+                const parentDir = path_1.default.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_1.default.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_1.default.join(flutterPackageSrc, 'tsconfig.json');
+            if (!fs_1.default.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_1.default.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 === null || metadata === void 0 ? void 0 : metadata.name)
+                ? `@openwebf/${metadata.name.replace(/^webf_/, 'webf-')}`
+                : '@openwebf/webf-module';
+            const defaultPackageName = isValidNpmPackageName(rawDefaultName)
+                ? rawDefaultName
+                : sanitizePackageName(rawDefaultName);
+            const packageNameAnswer = yield inquirer_1.default.prompt([{
+                    type: 'input',
+                    name: 'packageName',
+                    message: 'What is your npm package name for this module?',
+                    default: defaultPackageName,
+                    validate: (input) => {
+                        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 = (0, glob_1.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_1.default.join(flutterPackageSrc, moduleInterfaceRel);
+        const command = `webf module-codegen --flutter-package-src=${flutterPackageSrc} <distPath>`;
+        console.log(`\nGenerating module npm package and Dart bindings from ${moduleInterfaceRel}...`);
+        (0, module_1.generateModuleArtifacts)({
+            moduleInterfacePath,
+            npmTargetDir: resolvedDistPath,
+            flutterPackageDir: flutterPackageSrc,
+            command,
+        });
+        console.log('\nModule code generation completed successfully!');
+        try {
+            yield buildPackage(resolvedDistPath);
+        }
+        catch (error) {
+            console.error('\nWarning: Build failed:', error);
+        }
+        if (options.publishToNpm) {
+            try {
+                yield buildAndPublishPackage(resolvedDistPath, options.npmRegistry, false);
+            }
+            catch (error) {
+                console.error('\nError during npm publish:', error);
+                process.exit(1);
+            }
+        }
+        else {
+            const publishAnswer = yield inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'publish',
+                    message: 'Would you like to publish this module package to npm?',
+                    default: false
+                }]);
+            if (publishAnswer.publish) {
+                const registryAnswer = yield inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'registry',
+                        message: 'NPM registry URL (leave empty for default npm registry):',
+                        default: '',
+                        validate: (input) => {
+                            if (!input)
+                                return true;
+                            try {
+                                new URL(input);
+                                return true;
+                            }
+                            catch (_a) {
+                                return 'Please enter a valid URL';
+                            }
+                        }
+                    }]);
+                try {
+                    yield 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, content) {
     if (fs_1.default.existsSync(filePath)) {
         const oldContent = fs_1.default.readFileSync(filePath, 'utf-8');
@@ -765,7 +1039,7 @@ function ensureInitialized(targetPath) {
 }
 function buildPackage(packagePath) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
+        var _a, _b, _c;
         const packageJsonPath = path_1.default.join(packagePath, 'package.json');
         if (!fs_1.default.existsSync(packageJsonPath)) {
             // Skip the error in test environment to avoid console warnings
@@ -777,6 +1051,91 @@ function buildPackage(packagePath) {
         const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
         const packageName = packageJson.name;
         const packageVersion = packageJson.version;
+        function getInstalledPackageJsonPath(pkgName) {
+            const parts = pkgName.split('/');
+            return path_1.default.join(packagePath, 'node_modules', ...parts, 'package.json');
+        }
+        function getInstalledPackageDir(pkgName) {
+            const parts = pkgName.split('/');
+            return path_1.default.join(packagePath, 'node_modules', ...parts);
+        }
+        function findUp(startDir, relativePathToFind) {
+            let dir = path_1.default.resolve(startDir);
+            while (true) {
+                const candidate = path_1.default.join(dir, relativePathToFind);
+                if (fs_1.default.existsSync(candidate))
+                    return candidate;
+                const parent = path_1.default.dirname(dir);
+                if (parent === dir)
+                    return null;
+                dir = parent;
+            }
+        }
+        function ensurePeerDependencyAvailableForBuild(peerName) {
+            var _a, _b;
+            const installedPkgJson = getInstalledPackageJsonPath(peerName);
+            if (fs_1.default.existsSync(installedPkgJson))
+                return;
+            const peerRange = (_a = packageJson.peerDependencies) === null || _a === void 0 ? void 0 : _a[peerName];
+            const localMap = {
+                '@openwebf/react-core-ui': path_1.default.join('packages', 'react-core-ui'),
+                '@openwebf/vue-core-ui': path_1.default.join('packages', 'vue-core-ui'),
+            };
+            let installSpec = null;
+            const localRel = localMap[peerName];
+            if (localRel) {
+                const localPath = findUp(process.cwd(), localRel);
+                if (localPath) {
+                    if (!(0, peerDeps_1.isPackageTypesReady)(localPath)) {
+                        const localPkgJsonPath = path_1.default.join(localPath, 'package.json');
+                        if (fs_1.default.existsSync(localPkgJsonPath)) {
+                            const localPkgJson = (0, peerDeps_1.readJsonFile)(localPkgJsonPath);
+                            if ((_b = localPkgJson.scripts) === null || _b === void 0 ? void 0 : _b.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 = (0, child_process_1.spawnSync)(NPM, ['run', 'build'], {
+                                        cwd: localPath,
+                                        stdio: 'inherit'
+                                    });
+                                    if (buildLocalResult.status === 0) {
+                                        if ((0, peerDeps_1.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 = (0, child_process_1.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 = (0, peerDeps_1.getPackageTypesFileFromDir)(getInstalledPackageDir(peerName));
+            if (installedTypesFile && !fs_1.default.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_1.default.join(packagePath, 'node_modules');
         if (!fs_1.default.existsSync(nodeModulesPath)) {
@@ -797,6 +1156,13 @@ function buildPackage(packagePath) {
         }
         // Check if package has a build script
         if ((_a = packageJson.scripts) === null || _a === void 0 ? void 0 : _a.build) {
+            // DTS build needs peer deps present locally to resolve types (even though they are not bundled).
+            if ((_b = packageJson.peerDependencies) === null || _b === void 0 ? void 0 : _b['@openwebf/react-core-ui']) {
+                ensurePeerDependencyAvailableForBuild('@openwebf/react-core-ui');
+            }
+            if ((_c = packageJson.peerDependencies) === null || _c === void 0 ? void 0 : _c['@openwebf/vue-core-ui']) {
+                ensurePeerDependencyAvailableForBuild('@openwebf/vue-core-ui');
+            }
             console.log(`\nBuilding ${packageName}@${packageVersion}...`);
             const buildResult = (0, child_process_1.spawnSync)(NPM, ['run', 'build'], {
                 cwd: packagePath,

package/dist/generator.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileIfChanged = writeFileIfChanged;
 exports.dartGen = dartGen;
 exports.reactGen = reactGen;
 exports.vueGen = vueGen;
@@ -101,7 +102,7 @@ function getTypeFiles(source, excludePatterns) {
     try {
         const defaultIgnore = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/example/**'];
         const ignore = excludePatterns ? [...defaultIgnore, ...excludePatterns] : defaultIgnore;
-        const files = glob_1.glob.globSync("**/*.d.ts", {
+        const files = (0, glob_1.globSync)("**/*.d.ts", {
             cwd: source,
             ignore: ignore
         });
@@ -377,11 +378,8 @@ function reactGen(_a) {
                 (0, logger_1.warn)(`Failed to merge into existing index.ts. Skipping modifications: ${indexFilePath}`);
             }
         }
-        (0, logger_1.timeEnd)('reactGen');
-        (0, logger_1.success)(`React code generation completed. ${filesChanged} files changed.`);
-        (0, logger_1.info)(`Output directory: ${normalizedTarget}`);
-        (0, logger_1.info)('You can now import these components in your React project.');
-        // Aggregate standalone type declarations (consts/enums/type aliases) into a single types.ts
+        // 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 declaration_1.ConstObject));
             const enums = blobs.flatMap(b => b.objects.filter(o => o instanceof declaration_1.EnumObject));
@@ -394,38 +392,38 @@ function reactGen(_a) {
             typeAliases.forEach(t => { if (!typeAliasMap.has(t.name))
                 typeAliasMap.set(t.name, t); });
             const hasAny = constMap.size > 0 || enums.length > 0 || typeAliasMap.size > 0;
-            if (hasAny) {
-                const constDecl = Array.from(constMap.values())
-                    .map(c => `export declare const ${c.name}: ${c.type};`)
-                    .join('\n');
-                const enumDecl = enums
-                    .map(e => `export enum ${e.name} { ${e.members.map(m => m.initializer ? `${m.name} = ${m.initializer}` : `${m.name}`).join(', ')} }`)
-                    .join('\n');
-                const typeAliasDecl = Array.from(typeAliasMap.values())
-                    .map(t => `export type ${t.name} = ${t.type};`)
-                    .join('\n');
-                const typesContent = [
-                    '/* Generated by WebF CLI - aggregated type declarations */',
-                    typeAliasDecl,
-                    constDecl,
-                    enumDecl,
-                    ''
-                ].filter(Boolean).join('\n');
-                const typesPath = path_1.default.join(normalizedTarget, 'src', 'types.ts');
-                if (writeFileIfChanged(typesPath, typesContent)) {
-                    filesChanged++;
-                    (0, logger_1.debug)(`Generated: src/types.ts`);
-                    try {
-                        const constNames = Array.from(constMap.keys());
-                        const aliasNames = Array.from(typeAliasMap.keys());
-                        const enumNames = enums.map(e => e.name);
-                        (0, logger_1.debug)(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
-                        (0, logger_1.debug)(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
-                    }
-                    catch (_b) { }
+            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 */',
+                hasAny ? typeAliasDecl : '',
+                hasAny ? constDecl : '',
+                hasAny ? enumDecl : '',
+                hasAny ? '' : 'export {};',
+                ''
+            ].filter(Boolean).join('\n');
+            const typesPath = path_1.default.join(normalizedTarget, 'src', 'types.ts');
+            if (writeFileIfChanged(typesPath, typesContent)) {
+                filesChanged++;
+                (0, logger_1.debug)(`Generated: src/types.ts`);
+                try {
+                    const constNames = Array.from(constMap.keys());
+                    const aliasNames = Array.from(typeAliasMap.keys());
+                    const enumNames = enums.map(e => e.name);
+                    (0, logger_1.debug)(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
+                    (0, logger_1.debug)(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
                 }
-                // Ensure index.ts re-exports these types so consumers get them on import.
-                const indexFilePath = path_1.default.join(normalizedTarget, 'src', 'index.ts');
+                catch (_b) { }
+            }
+            // Only re-export from index.ts when there are actual declarations to surface.
+            if (hasAny) {
                 try {
                     let current = '';
                     if (fs_1.default.existsSync(indexFilePath)) {
@@ -446,6 +444,10 @@ function reactGen(_a) {
         catch (e) {
             (0, logger_1.warn)('Failed to generate aggregated React types');
         }
+        (0, logger_1.timeEnd)('reactGen');
+        (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.');
     });
 }
 function vueGen(_a) {