@openwebf/webf 0.23.2 → 0.23.10

package/src/commands.ts

@@ -3,7 +3,8 @@ 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 { globSync } from 'glob';
 import _ from 'lodash';
 import inquirer from 'inquirer';
 import yaml from 'yaml';
@@ -15,6 +16,7 @@ interface GenerateOptions {
   publishToNpm?: boolean;
   npmRegistry?: string;
   exclude?: string[];
+  dartOnly?: boolean;
 }
 
 interface FlutterPackageMetadata {
@@ -39,12 +41,12 @@ interface FlutterPackageMetadata {
 function sanitizePackageName(name: string): string {
   // Remove any leading/trailing whitespace
   let sanitized = name.trim();
-  
+
   // Check if it's a scoped package
   const isScoped = sanitized.startsWith('@');
   let scope = '';
   let packageName = sanitized;
-  
+
   if (isScoped) {
     const parts = sanitized.split('/');
     if (parts.length >= 2) {
@@ -55,7 +57,7 @@ function sanitizePackageName(name: string): string {
       packageName = sanitized.substring(1);
     }
   }
-  
+
   // Sanitize scope if present
   if (scope) {
     scope = scope.toLowerCase();
@@ -65,7 +67,7 @@ function sanitizePackageName(name: string): string {
       scope = '@pkg'; // Default scope if only @ remains
     }
   }
-  
+
   // Sanitize package name part
   packageName = packageName.toLowerCase();
   packageName = packageName.replace(/\s+/g, '-');
@@ -74,20 +76,20 @@ function sanitizePackageName(name: string): string {
   packageName = packageName.replace(/[._]+$/, '');
   packageName = packageName.replace(/[-_.]{2,}/g, '-');
   packageName = packageName.replace(/^-+/, '').replace(/-+$/, '');
-  
+
   // Ensure package name is not empty
   if (!packageName) {
     packageName = 'package';
   }
-  
+
   // Ensure it starts with a letter or number
   if (!/^[a-z0-9]/.test(packageName)) {
     packageName = 'pkg-' + packageName;
   }
-  
+
   // Combine scope and package name
   let result = scope ? `${scope}/${packageName}` : packageName;
-  
+
   // Truncate to 214 characters (npm limit)
   if (result.length > 214) {
     if (scope) {
@@ -101,7 +103,7 @@ function sanitizePackageName(name: string): string {
       result = result.replace(/[._-]+$/, '');
     }
   }
-  
+
   return result;
 }
 
@@ -112,36 +114,36 @@ function isValidNpmPackageName(name: string): boolean {
   // Check basic rules
   if (!name || name.length === 0 || name.length > 214) return false;
   if (name.trim() !== name) return false;
-  
+
   // Check if it's a scoped package
   if (name.startsWith('@')) {
     const parts = name.split('/');
     if (parts.length !== 2) return false; // Scoped packages must have exactly one /
-    
+
     const scope = parts[0];
     const packageName = parts[1];
-    
+
     // Validate scope
     if (!/^@[a-z0-9][a-z0-9-]*$/.test(scope)) return false;
-    
+
     // Validate package name part
     return isValidNpmPackageName(packageName);
   }
-  
+
   // For non-scoped packages
   if (name !== name.toLowerCase()) return false;
   if (name.startsWith('.') || name.startsWith('_')) return false;
-  
+
   // Check for valid characters (letters, numbers, hyphens, underscores, dots)
   if (!/^[a-z0-9][a-z0-9\-_.]*$/.test(name)) return false;
-  
+
   // Check for URL-safe characters
   try {
     if (encodeURIComponent(name) !== name) return false;
   } catch {
     return false;
   }
-  
+
   return true;
 }
 
@@ -163,6 +165,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'
@@ -200,15 +216,15 @@ function readFlutterPackageMetadata(packagePath: string): FlutterPackageMetadata
       console.warn(`Warning: pubspec.yaml not found at ${pubspecPath}. Using default metadata.`);
       return null;
     }
-    
+
     const pubspecContent = fs.readFileSync(pubspecPath, 'utf-8');
     const pubspec = yaml.parse(pubspecContent);
-    
+
     // Validate required fields
     if (!pubspec.name) {
       console.warn(`Warning: Flutter package name not found in ${pubspecPath}. Using default name.`);
     }
-    
+
     return {
       name: pubspec.name || '',
       version: pubspec.version || '0.0.1',
@@ -221,7 +237,8 @@ function readFlutterPackageMetadata(packagePath: string): FlutterPackageMetadata
   }
 }
 
-// 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.
 async function copyMarkdownDocsToDist(params: {
   sourceRoot: string;
   distRoot: string;
@@ -239,9 +256,10 @@ 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 }[] = [];
 
   for (const relDts of dtsFiles) {
     if (path.basename(relDts) === 'global.d.ts') {
@@ -255,6 +273,13 @@ async function copyMarkdownDocsToDist(params: {
       continue;
     }
 
+    let content = '';
+    try {
+      content = fs.readFileSync(absMd, 'utf-8');
+    } catch {
+      // 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.join(distRoot, relMd);
     const destDir = path.dirname(destPath);
@@ -263,6 +288,64 @@ async function copyMarkdownDocsToDist(params: {
     }
     fs.copyFileSync(absMd, destPath);
     copied++;
+
+    if (content) {
+      const base = path.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.join(distRoot, 'README.md');
+    let existing = '';
+    if (fs.existsSync(readmePath)) {
+      try {
+        existing = fs.readFileSync(readmePath, 'utf-8');
+      } catch {
+        existing = '';
+      }
+    }
+
+    const headerLines: string[] = [
+      '# 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: string[] = [];
+      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: string;
+    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.writeFileSync(readmePath, finalContent, 'utf-8');
+    } catch {
+      // If README generation fails, do not affect overall codegen.
+    }
   }
 
   return { copied, skipped };
@@ -270,40 +353,40 @@ async function copyMarkdownDocsToDist(params: {
 
 function validateTypeScriptEnvironment(projectPath: string): { isValid: boolean; errors: string[] } {
   const errors: string[] = [];
-  
+
   // Check for TypeScript configuration
   const tsConfigPath = path.join(projectPath, 'tsconfig.json');
   if (!fs.existsSync(tsConfigPath)) {
     errors.push('Missing tsconfig.json - TypeScript configuration is required for type definitions');
   }
-  
+
   // Check for .d.ts files - this is critical
   const libPath = path.join(projectPath, 'lib');
   let hasDtsFiles = false;
-  
+
   if (fs.existsSync(libPath)) {
     // Check in lib directory
-    hasDtsFiles = fs.readdirSync(libPath).some(file => 
-      file.endsWith('.d.ts') || 
-      (fs.statSync(path.join(libPath, file)).isDirectory() && 
+    hasDtsFiles = fs.readdirSync(libPath).some(file =>
+      file.endsWith('.d.ts') ||
+      (fs.statSync(path.join(libPath, file)).isDirectory() &&
        fs.readdirSync(path.join(libPath, file)).some(f => f.endsWith('.d.ts')))
     );
   }
-  
+
   // Also check in root directory
   if (!hasDtsFiles) {
-    hasDtsFiles = fs.readdirSync(projectPath).some(file => 
-      file.endsWith('.d.ts') || 
-      (fs.statSync(path.join(projectPath, file)).isDirectory() && 
-       file !== 'node_modules' && 
+    hasDtsFiles = fs.readdirSync(projectPath).some(file =>
+      file.endsWith('.d.ts') ||
+      (fs.statSync(path.join(projectPath, file)).isDirectory() &&
+       file !== 'node_modules' &&
        fs.existsSync(path.join(projectPath, file, 'index.d.ts')))
     );
   }
-  
+
   if (!hasDtsFiles) {
     errors.push('No TypeScript definition files (.d.ts) found in the project - Please create .d.ts files for your components');
   }
-  
+
   return {
     isValid: errors.length === 0,
     errors
@@ -313,8 +396,8 @@ function validateTypeScriptEnvironment(projectPath: string): { isValid: boolean;
 function createCommand(target: string, options: { framework: string; packageName: string; metadata?: FlutterPackageMetadata }): void {
   const { framework, metadata } = options;
   // Ensure package name is always valid
-  const packageName = isValidNpmPackageName(options.packageName) 
-    ? options.packageName 
+  const packageName = isValidNpmPackageName(options.packageName)
+    ? options.packageName
     : sanitizePackageName(options.packageName);
 
   if (!fs.existsSync(target)) {
@@ -394,28 +477,74 @@ 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;
   let isTempDir = false;
-  
+  const isDartOnly = options.dartOnly;
+
   if (!distPath || distPath === '.') {
-    // Create a temporary directory for the generated package
-    const tempDir = fs.mkdtempSync(path.join(os.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.resolve(distPath || '.');
+    } else {
+      // Create a temporary directory for the generated package
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'webf-typings-'));
+      resolvedDistPath = tempDir;
+      isTempDir = true;
+      console.log(`\nUsing temporary directory: ${tempDir}`);
+    }
   } else {
     resolvedDistPath = path.resolve(distPath);
   }
-  
+
   // First, check if we're in a Flutter package directory when flutter-package-src is not provided
   if (!options.flutterPackageSrc) {
     // Check if current directory or parent directories contain pubspec.yaml
     let currentDir = process.cwd();
     let foundPubspec = false;
     let pubspecDir = '';
-    
+
     // Search up to 3 levels up for pubspec.yaml
     for (let i = 0; i < 3; i++) {
       const pubspecPath = path.join(currentDir, 'pubspec.yaml');
@@ -428,141 +557,151 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
       if (parentDir === currentDir) break; // Reached root
       currentDir = parentDir;
     }
-    
+
     if (foundPubspec) {
       // Use the directory containing pubspec.yaml as the flutter package source
       options.flutterPackageSrc = pubspecDir;
       console.log(`\nDetected Flutter package at: ${pubspecDir}`);
     }
   }
-  
-  // Check if the directory exists and has required files
-  const packageJsonPath = path.join(resolvedDistPath, 'package.json');
-  const globalDtsPath = path.join(resolvedDistPath, 'global.d.ts');
-  const tsConfigPath = path.join(resolvedDistPath, 'tsconfig.json');
-  
-  const hasPackageJson = fs.existsSync(packageJsonPath);
-  const hasGlobalDts = fs.existsSync(globalDtsPath);
-  const hasTsConfig = fs.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 = await inquirer.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: FlutterPackageMetadata | null = null;
-    if (options.flutterPackageSrc) {
-      metadata = readFlutterPackageMetadata(options.flutterPackageSrc);
-    }
-    
-    if (!packageName) {
-      // Use Flutter package name as default if available, sanitized for npm
-      const rawDefaultName = metadata?.name || path.basename(resolvedDistPath);
-      const defaultPackageName = sanitizePackageName(rawDefaultName);
-      
-      const packageNameAnswer = await inquirer.prompt([{
-        type: 'input',
-        name: 'packageName',
-        message: 'What is your package name?',
-        default: defaultPackageName,
-        validate: (input: string) => {
-          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.join(resolvedDistPath, 'package.json');
+    const globalDtsPath = path.join(resolvedDistPath, 'global.d.ts');
+    const tsConfigPath = path.join(resolvedDistPath, 'tsconfig.json');
+
+    const hasPackageJson = fs.existsSync(packageJsonPath);
+    const hasGlobalDts = fs.existsSync(globalDtsPath);
+    const hasTsConfig = fs.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 = await inquirer.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: FlutterPackageMetadata | null = null;
+      if (options.flutterPackageSrc) {
+        metadata = readFlutterPackageMetadata(options.flutterPackageSrc);
+      }
+
+      if (!packageName) {
+        // Use Flutter package name as default if available, sanitized for npm
+        const rawDefaultName = metadata?.name || path.basename(resolvedDistPath);
+        const defaultPackageName = sanitizePackageName(rawDefaultName);
+
+        const packageNameAnswer = await inquirer.prompt([{
+          type: 'input',
+          name: 'packageName',
+          message: 'What is your package name?',
+          default: defaultPackageName,
+          validate: (input: string) => {
+            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;
-    }
-    
-    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.readFileSync(packageJsonPath, 'utf-8'));
-        
-        // Detect framework from existing package.json
-        if (!framework) {
-          if (packageJson.dependencies?.react || packageJson.devDependencies?.react) {
-            framework = 'react';
-          } else if (packageJson.dependencies?.vue || packageJson.devDependencies?.vue) {
-            framework = 'vue';
-          } else {
-            // If can't detect, prompt for it
-            const frameworkAnswer = await inquirer.prompt([{
-              type: 'list',
-              name: 'framework',
-              message: 'Which framework are you using?',
-              choices: ['react', 'vue']
-            }]);
-            framework = frameworkAnswer.framework;
+        }]);
+        packageName = packageNameAnswer.packageName;
+      }
+
+      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.readFileSync(packageJsonPath, 'utf-8'));
+
+          // Detect framework from existing package.json
+          if (!framework) {
+            if (packageJson.dependencies?.react || packageJson.devDependencies?.react) {
+              framework = 'react';
+            } else if (packageJson.dependencies?.vue || packageJson.devDependencies?.vue) {
+              framework = 'vue';
+            } else {
+              // If can't detect, prompt for it
+              const frameworkAnswer = await inquirer.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.rmSync(resolvedDistPath, { recursive: true, force: true });
     }
     return;
   }
-  
+
   // Validate TypeScript environment in the Flutter package
   console.log(`\nValidating TypeScript environment in ${options.flutterPackageSrc}...`);
   const validation = validateTypeScriptEnvironment(options.flutterPackageSrc);
-  
+
   if (!validation.isValid) {
     // Check specifically for missing tsconfig.json
     const tsConfigPath = path.join(options.flutterPackageSrc, 'tsconfig.json');
@@ -573,7 +712,7 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
         message: 'No tsconfig.json found. Would you like me to create one for you?',
         default: true
       }]);
-      
+
       if (createTsConfigAnswer.createTsConfig) {
         // Create a default tsconfig.json
         const defaultTsConfig = {
@@ -592,10 +731,10 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
           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');
-        
+
         // Re-validate after creating tsconfig
         const newValidation = validateTypeScriptEnvironment(options.flutterPackageSrc);
         if (!newValidation.isValid) {
@@ -617,21 +756,40 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
       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}...`);
+
+    await 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}...`);
-  
+
   await dartGen({
     source: options.flutterPackageSrc,
     target: options.flutterPackageSrc,
     command,
     exclude: options.exclude,
   });
-  
+
   if (framework === 'react') {
     // Get the package name from package.json if it exists
     let reactPackageName: string | undefined;
@@ -644,7 +802,7 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
     } catch (e) {
       // Ignore errors
     }
-    
+
     await reactGen({
       source: options.flutterPackageSrc,
       target: resolvedDistPath,
@@ -662,9 +820,9 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
       exclude: options.exclude,
     });
   }
-  
+
   console.log('\nCode generation completed successfully!');
-  
+
   // Automatically build the generated package
   if (framework) {
     try {
@@ -686,7 +844,7 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
       // Don't exit here since generation was successful
     }
   }
-  
+
   // Handle npm publishing if requested via command line option
   if (options.publishToNpm && framework) {
     try {
@@ -703,7 +861,7 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
       message: 'Would you like to publish this package to npm?',
       default: false
     }]);
-    
+
     if (publishAnswer.publish) {
       // Ask for registry
       const registryAnswer = await inquirer.prompt([{
@@ -721,10 +879,10 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
           }
         }
       }]);
-      
+
       try {
         await buildAndPublishPackage(
-          resolvedDistPath, 
+          resolvedDistPath,
           registryAnswer.registry || undefined,
           isExistingProject
         );
@@ -734,7 +892,7 @@ async function generateCommand(distPath: string, options: GenerateOptions): Prom
       }
     }
   }
-  
+
   // If using a temporary directory, remind the user where the files are
   if (isTempDir) {
     console.log(`\n📁 Generated files are in: ${resolvedDistPath}`);
@@ -742,6 +900,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')
@@ -756,19 +1144,19 @@ function writeFileIfChanged(filePath: string, content: string) {
 function ensureInitialized(targetPath: string): void {
   const globalDtsPath = path.join(targetPath, 'global.d.ts');
   const tsConfigPath = path.join(targetPath, 'tsconfig.json');
-  
+
   // Check if initialization files already exist
   const needsInit = !fs.existsSync(globalDtsPath) || !fs.existsSync(tsConfigPath);
-  
+
   if (needsInit) {
     console.log('Initializing WebF typings...');
     fs.mkdirSync(targetPath, { recursive: true });
-    
+
     if (!fs.existsSync(globalDtsPath)) {
       fs.writeFileSync(globalDtsPath, gloabalDts, 'utf-8');
       console.log('Created global.d.ts');
     }
-    
+
     if (!fs.existsSync(tsConfigPath)) {
       fs.writeFileSync(tsConfigPath, tsConfig, 'utf-8');
       console.log('Created tsconfig.json');
@@ -778,7 +1166,7 @@ function ensureInitialized(targetPath: string): void {
 
 async function buildPackage(packagePath: string): Promise<void> {
   const packageJsonPath = path.join(packagePath, 'package.json');
-  
+
   if (!fs.existsSync(packageJsonPath)) {
     // Skip the error in test environment to avoid console warnings
     if (process.env.NODE_ENV === 'test' || process.env.JEST_WORKER_ID !== undefined) {
@@ -786,34 +1174,34 @@ async function buildPackage(packagePath: string): Promise<void> {
     }
     throw new Error(`No package.json found in ${packagePath}`);
   }
-  
+
   const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
   const packageName = packageJson.name;
   const packageVersion = packageJson.version;
-  
+
   // Check if node_modules exists
   const nodeModulesPath = path.join(packagePath, 'node_modules');
   if (!fs.existsSync(nodeModulesPath)) {
     console.log(`\n📦 Installing dependencies for ${packageName}...`);
-    
+
     // Check if yarn.lock exists to determine package manager
     const yarnLockPath = path.join(packagePath, 'yarn.lock');
     const useYarn = fs.existsSync(yarnLockPath);
-    
+
     const installCommand = useYarn ? 'yarn' : NPM;
     const installArgs = useYarn ? [] : ['install'];
-    
+
     const installResult = spawnSync(installCommand, installArgs, {
       cwd: packagePath,
       stdio: 'inherit'
     });
-    
+
     if (installResult.status !== 0) {
       throw new Error('Failed to install dependencies');
     }
     console.log('✅ Dependencies installed successfully!');
   }
-  
+
   // Check if package has a build script
   if (packageJson.scripts?.build) {
     console.log(`\nBuilding ${packageName}@${packageVersion}...`);
@@ -821,7 +1209,7 @@ async function buildPackage(packagePath: string): Promise<void> {
       cwd: packagePath,
       stdio: 'inherit'
     });
-    
+
     if (buildResult.status !== 0) {
       throw new Error('Build failed');
     }
@@ -833,18 +1221,18 @@ async function buildPackage(packagePath: string): Promise<void> {
 
 async function buildAndPublishPackage(packagePath: string, registry?: string, isExistingProject: boolean = false): Promise<void> {
   const packageJsonPath = path.join(packagePath, 'package.json');
-  
+
   if (!fs.existsSync(packageJsonPath)) {
     throw new Error(`No package.json found in ${packagePath}`);
   }
-  
+
   let packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
   const packageName = packageJson.name;
   let packageVersion = packageJson.version;
-  
+
   // First, ensure dependencies are installed and build the package
   await buildPackage(packagePath);
-  
+
   // If this is an existing project, increment the patch version before publishing
   if (isExistingProject) {
     console.log(`\nIncrementing version for existing project...`);
@@ -853,18 +1241,18 @@ async function buildAndPublishPackage(packagePath: string, registry?: string, is
       encoding: 'utf-8',
       stdio: 'pipe'
     });
-    
+
     if (versionResult.status !== 0) {
       console.error('Failed to increment version:', versionResult.stderr);
       throw new Error('Failed to increment version');
     }
-    
+
     // Re-read package.json to get the new version
     packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
     packageVersion = packageJson.version;
     console.log(`Version updated to ${packageVersion}`);
   }
-  
+
   // Set registry if provided
   if (registry) {
     console.log(`\nUsing npm registry: ${registry}`);
@@ -872,38 +1260,38 @@ async function buildAndPublishPackage(packagePath: string, registry?: string, is
       cwd: packagePath,
       stdio: 'inherit'
     });
-    
+
     if (setRegistryResult.status !== 0) {
       throw new Error('Failed to set npm registry');
     }
   }
-  
+
   // Check if user is logged in to npm
   const whoamiResult = spawnSync(NPM, ['whoami'], {
     cwd: packagePath,
     encoding: 'utf-8'
   });
-  
+
   if (whoamiResult.status !== 0) {
     console.error('\nError: You must be logged in to npm to publish packages.');
     console.error('Please run "npm login" first.');
     throw new Error('Not logged in to npm');
   }
-  
+
   console.log(`\nPublishing ${packageName}@${packageVersion} to npm...`);
-  
+
   // Publish the package
   const publishResult = spawnSync(NPM, ['publish'], {
     cwd: packagePath,
     stdio: 'inherit'
   });
-  
+
   if (publishResult.status !== 0) {
     throw new Error('Publish failed');
   }
-  
+
   console.log(`\n✅ Successfully published ${packageName}@${packageVersion}`);
-  
+
   // Reset registry to default if it was changed
   if (registry) {
     spawnSync(NPM, ['config', 'delete', 'registry'], {
@@ -912,4 +1300,4 @@ async function buildAndPublishPackage(packagePath: string, registry?: string, is
   }
 }
 
-export { generateCommand };
+export { generateCommand, generateModuleCommand };