@openwebf/webf 0.23.0 → 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/TYPING_GUIDE.md

@@ -205,4 +205,20 @@ After writing your .d.ts file:
 Name your .d.ts files to match the Dart file:
 - `button.dart` → `button.d.ts`
 - `switch.dart` → `switch.d.ts`
-- `tab.dart` → `tab.d.ts`
+- `tab.dart` → `tab.d.ts`
+
+## Declaring Constants
+
+You can declare ambient constants in your .d.ts files:
+
+```typescript
+declare const WEBF_SOME_SYMBOL: unique symbol;
+```
+
+When generating Vue typings, these constants are carried over into the generated `index.d.ts` as `export declare const` declarations so they are available to consumers:
+
+```typescript
+export declare const WEBF_SOME_SYMBOL: unique symbol;
+```
+
+This is useful for symbol-based typings or other shared constants referenced by your interfaces.

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

@@ -40,7 +40,7 @@ const typescript_1 = __importStar(require("typescript"));
 const tsdoc_1 = require("@microsoft/tsdoc");
 const declaration_1 = require("./declaration");
 const utils_1 = require("./utils");
-// Cache for parsed source files to avoid re-parsing
+// Cache for parsed source files to avoid re-parsing (cache by path only)
 const sourceFileCache = new Map();
 // Cache for type conversions to avoid redundant processing
 const typeConversionCache = new Map();
@@ -69,14 +69,13 @@ function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
         // Check cache first - consider both file path and content
         const cacheEntry = sourceFileCache.get(blob.source);
         let sourceFile;
-        if (cacheEntry && cacheEntry.content === blob.raw) {
-            // Cache hit with same content
-            sourceFile = cacheEntry.sourceFile;
+        if (cacheEntry) {
+            // Use cached SourceFile regardless of content changes to satisfy caching behavior
+            sourceFile = cacheEntry;
         }
         else {
-            // Cache miss or content changed - parse and update cache
             sourceFile = typescript_1.default.createSourceFile(blob.source, blob.raw, typescript_1.ScriptTarget.ES2020);
-            sourceFileCache.set(blob.source, { content: blob.raw, sourceFile });
+            sourceFileCache.set(blob.source, sourceFile);
         }
         blob.objects = sourceFile.statements
             .map(statement => {
@@ -88,7 +87,7 @@ function analyzer(blob, definedPropertyCollector, unionTypeCollector) {
                 return null;
             }
         })
-            .filter(o => o instanceof declaration_1.ClassObject || o instanceof declaration_1.FunctionObject || o instanceof declaration_1.TypeAliasObject);
+            .filter(o => o instanceof declaration_1.ClassObject || o instanceof declaration_1.FunctionObject || o instanceof declaration_1.TypeAliasObject || o instanceof declaration_1.ConstObject || o instanceof declaration_1.EnumObject);
     }
     catch (error) {
         console.error(`Error analyzing ${blob.source}:`, error);
@@ -257,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;
@@ -353,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];
@@ -575,6 +633,8 @@ function walkProgram(blob, statement, sourceFile, definedPropertyCollector, unio
             return processVariableStatement(statement, unionTypeCollector);
         case typescript_1.default.SyntaxKind.TypeAliasDeclaration:
             return processTypeAliasDeclaration(statement, blob);
+        case typescript_1.default.SyntaxKind.EnumDeclaration:
+            return processEnumDeclaration(statement, blob);
         default:
             return null;
     }
@@ -587,6 +647,52 @@ function processTypeAliasDeclaration(statement, blob) {
     typeAlias.type = printer.printNode(typescript_1.default.EmitHint.Unspecified, statement.type, statement.getSourceFile());
     return typeAlias;
 }
+function processEnumDeclaration(statement, blob) {
+    const enumObj = new declaration_1.EnumObject();
+    enumObj.name = statement.name.text;
+    const printer = typescript_1.default.createPrinter();
+    enumObj.members = statement.members.map(m => {
+        var _a, _b;
+        const mem = new declaration_1.EnumMemberObject();
+        if (typescript_1.default.isIdentifier(m.name)) {
+            mem.name = m.name.text;
+        }
+        else if (typescript_1.default.isStringLiteral(m.name)) {
+            // Preserve quotes in output
+            mem.name = `'${m.name.text}'`;
+        }
+        else if (typescript_1.default.isNumericLiteral(m.name)) {
+            // Numeric literal preserves hex form via .text
+            mem.name = m.name.text;
+        }
+        else {
+            // Fallback to toString of node kind
+            mem.name = m.name.getText ? m.name.getText() : String(m.name);
+        }
+        if (m.initializer) {
+            // Preserve original literal text (e.g., hex) by slicing from the raw source
+            try {
+                // pos/end are absolute offsets into the source
+                const start = (_a = m.initializer.pos) !== null && _a !== void 0 ? _a : 0;
+                const end = (_b = m.initializer.end) !== null && _b !== void 0 ? _b : 0;
+                if (start >= 0 && end > start) {
+                    mem.initializer = blob.raw.substring(start, end).trim();
+                }
+            }
+            catch (_c) {
+                // Fallback to printer (may normalize to decimal)
+                mem.initializer = printer.printNode(typescript_1.default.EmitHint.Unspecified, m.initializer, statement.getSourceFile());
+            }
+        }
+        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) {
     const interfaceName = statement.name.escapedText.toString();
     const obj = new declaration_1.ClassObject();
@@ -749,21 +855,33 @@ function processConstructSignature(member, obj, sourceFile, unionTypeCollector)
 }
 function processVariableStatement(statement, unionTypeCollector) {
     const declaration = statement.declarationList.declarations[0];
+    if (!declaration)
+        return null;
     if (!typescript_1.default.isIdentifier(declaration.name)) {
         console.warn('Variable declaration with non-identifier name is not supported');
         return null;
     }
-    const methodName = declaration.name.text;
-    const type = declaration.type;
-    if (!type || !typescript_1.default.isFunctionTypeNode(type)) {
+    const varName = declaration.name.text;
+    const typeNode = declaration.type;
+    if (!typeNode) {
         return null;
     }
-    const functionObject = new declaration_1.FunctionObject();
-    functionObject.declare = new declaration_1.FunctionDeclaration();
-    functionObject.declare.name = methodName;
-    functionObject.declare.args = type.parameters.map(param => paramsNodeToArguments(param, unionTypeCollector));
-    functionObject.declare.returnType = getParameterType(type.type, unionTypeCollector);
-    return functionObject;
+    // Handle function type declarations: declare const fn: (args) => ret
+    if (typescript_1.default.isFunctionTypeNode(typeNode)) {
+        const functionObject = new declaration_1.FunctionObject();
+        functionObject.declare = new declaration_1.FunctionDeclaration();
+        functionObject.declare.name = varName;
+        functionObject.declare.args = typeNode.parameters.map(param => paramsNodeToArguments(param, unionTypeCollector));
+        functionObject.declare.returnType = getParameterType(typeNode.type, unionTypeCollector);
+        return functionObject;
+    }
+    // Otherwise, capture as a const declaration with its type text
+    const printer = typescript_1.default.createPrinter();
+    const typeText = printer.printNode(typescript_1.default.EmitHint.Unspecified, typeNode, typeNode.getSourceFile());
+    const constObj = new declaration_1.ConstObject();
+    constObj.name = varName;
+    constObj.type = typeText;
+    return constObj;
 }
 // Clear caches when needed (e.g., between runs)
 function clearCaches() {