@openwebf/webf 0.23.2 → 0.23.10

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:**
@@ -60,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:
@@ -229,4 +261,4 @@ npm link         # Link for local testing
 
 ## License
 
-ISC
+ISC

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();
 
@@ -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')
@@ -23,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/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) {