@openwebf/webf 0.23.2 → 0.23.7

package/README.md

@@ -25,6 +25,7 @@ webf codegen [output-dir] [options]
 - `--flutter-package-src <path>`: Flutter package source path containing TypeScript definitions
 - `--framework <framework>`: Target framework - 'react' or 'vue'
 - `--package-name <name>`: Package name for the webf typings
+- `--dart-only`: Only generate Dart bindings in the Flutter package (skip React/Vue code and npm package generation)
 - `--publish-to-npm`: Automatically publish the generated package to npm
 - `--npm-registry <url>`: Custom npm registry URL (defaults to https://registry.npmjs.org/)
 
@@ -40,6 +41,9 @@ webf codegen my-vue-app --flutter-package-src=./flutter_pkg --framework=vue --pa
 
 # Use temporary directory (auto-created)
 webf codegen --flutter-package-src=../webf_cupertino_ui
+
+# Generate only Dart bindings inside the Flutter package
+webf codegen --flutter-package-src=../webf_cupertino_ui --dart-only
 ```
 
 **Create a new project without code generation:**
@@ -229,4 +233,4 @@ npm link         # Link for local testing
 
 ## License
 
-ISC
+ISC

package/bin/webf.js

@@ -16,6 +16,7 @@ program
   .option('--flutter-package-src <src>', 'Flutter package source path (for code generation)')
   .option('--framework <framework>', 'Target framework (react or vue)')
   .option('--package-name <name>', 'Package name for the webf typings')
+  .option('--dart-only', 'Only generate Dart bindings in the Flutter package (skip React/Vue code and npm package generation)')
   .option('--publish-to-npm', 'Automatically publish the generated 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')

package/dist/analyzer.js

@@ -256,6 +256,20 @@ function getParameterBaseType(type, mode) {
     if (basicType !== undefined) {
         return basicType;
     }
+    // Handle `typeof SomeIdentifier` (TypeQuery) by preserving the textual form
+    // so React/Vue can keep strong typing (e.g., `typeof CupertinoIcons`).
+    // Dart mapping will convert this to `dynamic` later.
+    if (type.kind === typescript_1.default.SyntaxKind.TypeQuery) {
+        const tq = type;
+        const getEntityNameText = (name) => {
+            if (typescript_1.default.isIdentifier(name))
+                return name.text;
+            // Qualified name: A.B.C
+            return `${getEntityNameText(name.left)}.${name.right.text}`;
+        };
+        const nameText = getEntityNameText(tq.exprName);
+        return `typeof ${nameText}`;
+    }
     if (type.kind === typescript_1.default.SyntaxKind.TypeReference) {
         const typeReference = type;
         const typeName = typeReference.typeName;
@@ -352,13 +366,58 @@ function handleGenericWrapper(typeReference, mode) {
     return getParameterBaseType(argument, mode);
 }
 function handleCustomEventType(typeReference) {
+    var _a;
     // Handle CustomEvent<T> by returning the full type with generic parameter
     if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
         return 'CustomEvent';
     }
     const argument = typeReference.typeArguments[0];
     let genericType;
-    if (typescript_1.default.isTypeReferenceNode(argument) && typescript_1.default.isIdentifier(argument.typeName)) {
+    // Preserve simple union/compound generic types (e.g., boolean | null)
+    if (typescript_1.default.isUnionTypeNode(argument) || typescript_1.default.isIntersectionTypeNode(argument)) {
+        const unionTypes = (_a = argument.types) !== null && _a !== void 0 ? _a : [];
+        const parts = unionTypes.map(t => {
+            // Literal union members: handle null/undefined explicitly
+            if (typescript_1.default.isLiteralTypeNode(t)) {
+                const lit = t.literal;
+                if (lit.kind === typescript_1.default.SyntaxKind.NullKeyword)
+                    return 'null';
+                if (lit.kind === typescript_1.default.SyntaxKind.UndefinedKeyword)
+                    return 'undefined';
+                if (typescript_1.default.isStringLiteral(lit))
+                    return JSON.stringify(lit.text);
+                return 'any';
+            }
+            // Basic keywords: boolean, string, number, null, undefined
+            const basic = BASIC_TYPE_MAP[t.kind];
+            if (basic !== undefined) {
+                switch (basic) {
+                    case declaration_1.FunctionArgumentType.boolean:
+                        return 'boolean';
+                    case declaration_1.FunctionArgumentType.dom_string:
+                        return 'string';
+                    case declaration_1.FunctionArgumentType.double:
+                    case declaration_1.FunctionArgumentType.int:
+                        return 'number';
+                    case declaration_1.FunctionArgumentType.null:
+                        return 'null';
+                    case declaration_1.FunctionArgumentType.undefined:
+                        return 'undefined';
+                    default:
+                        return 'any';
+                }
+            }
+            // Literal null/undefined keywords that BASIC_TYPE_MAP may not cover
+            if (t.kind === typescript_1.default.SyntaxKind.NullKeyword)
+                return 'null';
+            if (t.kind === typescript_1.default.SyntaxKind.UndefinedKeyword)
+                return 'undefined';
+            // Fallback: rely on toString of node kind
+            return 'any';
+        });
+        genericType = parts.join(' | ');
+    }
+    else if (typescript_1.default.isTypeReferenceNode(argument) && typescript_1.default.isIdentifier(argument.typeName)) {
         const typeName = argument.typeName.text;
         // Check if it's a mapped type reference like 'int' or 'double'
         const mappedType = TYPE_REFERENCE_MAP[typeName];
@@ -627,6 +686,11 @@ function processEnumDeclaration(statement, blob) {
         }
         return mem;
     });
+    // Register globally for cross-file lookups (e.g., Dart mapping decisions)
+    try {
+        declaration_1.EnumObject.globalEnumSet.add(enumObj.name);
+    }
+    catch (_a) { }
     return enumObj;
 }
 function processInterfaceDeclaration(statement, blob, sourceFile, definedPropertyCollector, unionTypeCollector) {

package/dist/commands.js

@@ -172,7 +172,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;
@@ -187,6 +188,7 @@ function copyMarkdownDocsToDist(params) {
         const dtsFiles = glob_1.glob.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 +199,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 +214,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 };
     });
@@ -281,6 +345,7 @@ 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'
@@ -317,12 +382,19 @@ function generateCommand(distPath, options) {
         // 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 +424,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 +603,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}...`);