@openwebf/webf 0.23.2 → 0.23.10

package/dist/commands.js

@@ -13,11 +13,13 @@ 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 glob_1 = require("glob");
 const lodash_1 = __importDefault(require("lodash"));
 const inquirer_1 = __importDefault(require("inquirer"));
@@ -141,6 +143,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,7 +177,8 @@ function readFlutterPackageMetadata(packagePath) {
         return null;
     }
 }
-// Copy markdown docs that match .d.ts basenames from source to the built dist folder
+// 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) {
     return __awaiter(this, void 0, void 0, function* () {
         const { sourceRoot, distRoot, exclude } = params;
@@ -184,9 +190,10 @@ 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 = [];
         for (const relDts of dtsFiles) {
             if (path_1.default.basename(relDts) === 'global.d.ts') {
                 continue;
@@ -197,6 +204,13 @@ function copyMarkdownDocsToDist(params) {
                 skipped++;
                 continue;
             }
+            let content = '';
+            try {
+                content = fs_1.default.readFileSync(absMd, 'utf-8');
+            }
+            catch (_a) {
+                // If we cannot read the file, still attempt to copy it and skip README aggregation for this entry.
+            }
             // Copy into dist preserving relative path
             const destPath = path_1.default.join(distRoot, relMd);
             const destDir = path_1.default.dirname(destPath);
@@ -205,6 +219,61 @@ function copyMarkdownDocsToDist(params) {
             }
             fs_1.default.copyFileSync(absMd, destPath);
             copied++;
+            if (content) {
+                const base = path_1.default.basename(relMd, '.md');
+                const title = base
+                    .split(/[-_]+/)
+                    .filter(Boolean)
+                    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+                    .join(' ');
+                readmeSections.push({
+                    title: title || base,
+                    relPath: relMd,
+                    content
+                });
+            }
+        }
+        // Generate an aggregated README.md inside distRoot so consumers can see component docs easily.
+        if (readmeSections.length > 0) {
+            const readmePath = path_1.default.join(distRoot, 'README.md');
+            let existing = '';
+            if (fs_1.default.existsSync(readmePath)) {
+                try {
+                    existing = fs_1.default.readFileSync(readmePath, 'utf-8');
+                }
+                catch (_b) {
+                    existing = '';
+                }
+            }
+            const headerLines = [
+                '# WebF Component Documentation',
+                '',
+                '> This README is generated from markdown docs co-located with TypeScript definitions in the Flutter package.',
+                ''
+            ];
+            const sectionBlocks = readmeSections.map(section => {
+                const lines = [];
+                lines.push(`## ${section.title}`);
+                lines.push('');
+                lines.push(`_Source: \`./${section.relPath}\`_`);
+                lines.push('');
+                lines.push(section.content.trim());
+                lines.push('');
+                return lines.join('\n');
+            }).join('\n');
+            let finalContent;
+            if (existing && existing.trim().length > 0) {
+                finalContent = `${existing.trim()}\n\n---\n\n${headerLines.join('\n')}${sectionBlocks}\n`;
+            }
+            else {
+                finalContent = `${headerLines.join('\n')}${sectionBlocks}\n`;
+            }
+            try {
+                fs_1.default.writeFileSync(readmePath, finalContent, 'utf-8');
+            }
+            catch (_c) {
+                // If README generation fails, do not affect overall codegen.
+            }
         }
         return { copied, skipped };
     });
@@ -311,18 +380,57 @@ function createCommand(target, options) {
     }
     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;
         // If distPath is not provided or is '.', create a temporary directory
         let resolvedDistPath;
         let isTempDir = false;
+        const isDartOnly = options.dartOnly;
         if (!distPath || distPath === '.') {
-            // Create a temporary directory for the generated package
-            const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'webf-typings-'));
-            resolvedDistPath = tempDir;
-            isTempDir = true;
-            console.log(`\nUsing temporary directory: ${tempDir}`);
+            if (isDartOnly) {
+                // In Dart-only mode we don't need a temporary Node project directory
+                resolvedDistPath = path_1.default.resolve(distPath || '.');
+            }
+            else {
+                // Create a temporary directory for the generated package
+                const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'webf-typings-'));
+                resolvedDistPath = tempDir;
+                isTempDir = true;
+                console.log(`\nUsing temporary directory: ${tempDir}`);
+            }
         }
         else {
             resolvedDistPath = path_1.default.resolve(distPath);
@@ -352,111 +460,123 @@ function generateCommand(distPath, options) {
                 console.log(`\nDetected Flutter package at: ${pubspecDir}`);
             }
         }
-        // Check if the directory exists and has required files
-        const packageJsonPath = path_1.default.join(resolvedDistPath, 'package.json');
-        const globalDtsPath = path_1.default.join(resolvedDistPath, 'global.d.ts');
-        const tsConfigPath = path_1.default.join(resolvedDistPath, 'tsconfig.json');
-        const hasPackageJson = fs_1.default.existsSync(packageJsonPath);
-        const hasGlobalDts = fs_1.default.existsSync(globalDtsPath);
-        const hasTsConfig = fs_1.default.existsSync(tsConfigPath);
-        // Determine if we need to create a new project
-        const needsProjectCreation = !hasPackageJson || !hasGlobalDts || !hasTsConfig;
-        // Track if this is an existing project (has all required files)
-        const isExistingProject = hasPackageJson && hasGlobalDts && hasTsConfig;
         let framework = options.framework;
         let packageName = options.packageName;
-        // Validate and sanitize package name if provided
-        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 (needsProjectCreation) {
-            // If project needs creation but options are missing, prompt for them
-            if (!framework) {
-                const frameworkAnswer = yield inquirer_1.default.prompt([{
-                        type: 'list',
-                        name: 'framework',
-                        message: 'Which framework would you like to use?',
-                        choices: ['react', 'vue']
-                    }]);
-                framework = frameworkAnswer.framework;
-            }
-            // Try to read Flutter package metadata if flutterPackageSrc is provided
-            let metadata = null;
-            if (options.flutterPackageSrc) {
-                metadata = readFlutterPackageMetadata(options.flutterPackageSrc);
-            }
-            if (!packageName) {
-                // Use Flutter package name as default if available, sanitized for npm
-                const rawDefaultName = (metadata === null || metadata === void 0 ? void 0 : metadata.name) || path_1.default.basename(resolvedDistPath);
-                const defaultPackageName = sanitizePackageName(rawDefaultName);
-                const packageNameAnswer = yield inquirer_1.default.prompt([{
-                        type: 'input',
-                        name: 'packageName',
-                        message: 'What is your package name?',
-                        default: defaultPackageName,
-                        validate: (input) => {
-                            if (!input || input.trim() === '') {
-                                return 'Package name is required';
-                            }
-                            // Check if it's valid as-is
-                            if (isValidNpmPackageName(input)) {
-                                return true;
+        let isExistingProject = false;
+        if (!isDartOnly) {
+            // Check if the directory exists and has required files
+            const packageJsonPath = path_1.default.join(resolvedDistPath, 'package.json');
+            const globalDtsPath = path_1.default.join(resolvedDistPath, 'global.d.ts');
+            const tsConfigPath = path_1.default.join(resolvedDistPath, 'tsconfig.json');
+            const hasPackageJson = fs_1.default.existsSync(packageJsonPath);
+            const hasGlobalDts = fs_1.default.existsSync(globalDtsPath);
+            const hasTsConfig = fs_1.default.existsSync(tsConfigPath);
+            // Determine if we need to create a new project
+            const needsProjectCreation = !hasPackageJson || !hasGlobalDts || !hasTsConfig;
+            // Track if this is an existing project (has all required files)
+            isExistingProject = hasPackageJson && hasGlobalDts && hasTsConfig;
+            // Validate and sanitize package name if provided
+            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 (needsProjectCreation) {
+                // If project needs creation but options are missing, prompt for them
+                if (!framework) {
+                    const frameworkAnswer = yield inquirer_1.default.prompt([{
+                            type: 'list',
+                            name: 'framework',
+                            message: 'Which framework would you like to use?',
+                            choices: ['react', 'vue']
+                        }]);
+                    framework = frameworkAnswer.framework;
+                }
+                // Try to read Flutter package metadata if flutterPackageSrc is provided
+                let metadata = null;
+                if (options.flutterPackageSrc) {
+                    metadata = readFlutterPackageMetadata(options.flutterPackageSrc);
+                }
+                if (!packageName) {
+                    // Use Flutter package name as default if available, sanitized for npm
+                    const rawDefaultName = (metadata === null || metadata === void 0 ? void 0 : metadata.name) || path_1.default.basename(resolvedDistPath);
+                    const defaultPackageName = sanitizePackageName(rawDefaultName);
+                    const packageNameAnswer = yield inquirer_1.default.prompt([{
+                            type: 'input',
+                            name: 'packageName',
+                            message: 'What is your package name?',
+                            default: defaultPackageName,
+                            validate: (input) => {
+                                if (!input || input.trim() === '') {
+                                    return 'Package name is required';
+                                }
+                                // Check if it's valid as-is
+                                if (isValidNpmPackageName(input)) {
+                                    return true;
+                                }
+                                // If not valid, show what it would be sanitized to
+                                const sanitized = sanitizePackageName(input);
+                                return `Invalid npm package name. Would be sanitized to: "${sanitized}". Please enter a valid name.`;
                             }
-                            // If not valid, show what it would be sanitized to
-                            const sanitized = sanitizePackageName(input);
-                            return `Invalid npm package name. Would be sanitized to: "${sanitized}". Please enter a valid name.`;
-                        }
-                    }]);
-                packageName = packageNameAnswer.packageName;
+                        }]);
+                    packageName = packageNameAnswer.packageName;
+                }
+                console.log(`\nCreating new ${framework} project in ${resolvedDistPath}...`);
+                createCommand(resolvedDistPath, {
+                    framework: framework,
+                    packageName: packageName,
+                    metadata: metadata || undefined
+                });
             }
-            console.log(`\nCreating new ${framework} project in ${resolvedDistPath}...`);
-            createCommand(resolvedDistPath, {
-                framework: framework,
-                packageName: packageName,
-                metadata: metadata || undefined
-            });
-        }
-        else {
-            // Validate existing project structure
-            if (hasPackageJson) {
-                try {
-                    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
-                    // Detect framework from existing package.json
-                    if (!framework) {
-                        if (((_a = packageJson.dependencies) === null || _a === void 0 ? void 0 : _a.react) || ((_b = packageJson.devDependencies) === null || _b === void 0 ? void 0 : _b.react)) {
-                            framework = 'react';
-                        }
-                        else if (((_c = packageJson.dependencies) === null || _c === void 0 ? void 0 : _c.vue) || ((_d = packageJson.devDependencies) === null || _d === void 0 ? void 0 : _d.vue)) {
-                            framework = 'vue';
-                        }
-                        else {
-                            // If can't detect, prompt for it
-                            const frameworkAnswer = yield inquirer_1.default.prompt([{
-                                    type: 'list',
-                                    name: 'framework',
-                                    message: 'Which framework are you using?',
-                                    choices: ['react', 'vue']
-                                }]);
-                            framework = frameworkAnswer.framework;
+            else {
+                // Validate existing project structure
+                if (hasPackageJson) {
+                    try {
+                        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+                        // Detect framework from existing package.json
+                        if (!framework) {
+                            if (((_a = packageJson.dependencies) === null || _a === void 0 ? void 0 : _a.react) || ((_b = packageJson.devDependencies) === null || _b === void 0 ? void 0 : _b.react)) {
+                                framework = 'react';
+                            }
+                            else if (((_c = packageJson.dependencies) === null || _c === void 0 ? void 0 : _c.vue) || ((_d = packageJson.devDependencies) === null || _d === void 0 ? void 0 : _d.vue)) {
+                                framework = 'vue';
+                            }
+                            else {
+                                // If can't detect, prompt for it
+                                const frameworkAnswer = yield inquirer_1.default.prompt([{
+                                        type: 'list',
+                                        name: 'framework',
+                                        message: 'Which framework are you using?',
+                                        choices: ['react', 'vue']
+                                    }]);
+                                framework = frameworkAnswer.framework;
+                            }
                         }
+                        console.log(`\nDetected existing ${framework} project in ${resolvedDistPath}`);
+                    }
+                    catch (e) {
+                        console.error('Error reading package.json:', e);
+                        process.exit(1);
                     }
-                    console.log(`\nDetected existing ${framework} project in ${resolvedDistPath}`);
-                }
-                catch (e) {
-                    console.error('Error reading package.json:', e);
-                    process.exit(1);
                 }
             }
         }
+        else {
+            // In Dart-only mode, framework/packageName are unused; ensure framework is not accidentally required later.
+            framework = options.framework;
+        }
         // Now proceed with code generation if flutter package source is provided
         if (!options.flutterPackageSrc) {
             console.log('\nProject is ready for code generation.');
             console.log('To generate code, run:');
             const displayPath = isTempDir ? '<output-dir>' : distPath;
-            console.log(`  webf codegen ${displayPath} --flutter-package-src=<path> --framework=${framework}`);
+            if (isDartOnly) {
+                console.log(`  webf codegen ${displayPath} --flutter-package-src=<path> --dart-only`);
+            }
+            else {
+                console.log(`  webf codegen ${displayPath} --flutter-package-src=<path> --framework=${framework}`);
+            }
             if (isTempDir) {
                 // Clean up temporary directory if we're not using it
                 fs_1.default.rmSync(resolvedDistPath, { recursive: true, force: true });
@@ -519,7 +639,23 @@ function generateCommand(distPath, options) {
                 process.exit(1);
             }
         }
-        const command = `webf codegen --flutter-package-src=${options.flutterPackageSrc} --framework=${framework} <distPath>`;
+        const baseCommand = 'webf codegen';
+        const flutterPart = options.flutterPackageSrc ? ` --flutter-package-src=${options.flutterPackageSrc}` : '';
+        const modePart = isDartOnly
+            ? ' --dart-only'
+            : (framework ? ` --framework=${framework}` : '');
+        const command = `${baseCommand}${flutterPart}${modePart} <distPath>`;
+        if (isDartOnly) {
+            console.log(`\nGenerating Dart bindings from ${options.flutterPackageSrc}...`);
+            yield (0, generator_1.dartGen)({
+                source: options.flutterPackageSrc,
+                target: options.flutterPackageSrc,
+                command,
+                exclude: options.exclude,
+            });
+            console.log('\nDart code generation completed successfully!');
+            return;
+        }
         // Auto-initialize typings in the output directory if needed
         ensureInitialized(resolvedDistPath);
         console.log(`\nGenerating ${framework} code from ${options.flutterPackageSrc}...`);
@@ -636,6 +772,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');