@openwebf/webf 0.23.7 → 0.23.10

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,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');
@@ -185,7 +190,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,7 +350,6 @@ 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'], {
             cwd: target,
             stdio: 'inherit'
@@ -376,6 +380,38 @@ 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;
@@ -736,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');

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
         });