@openwebf/webf 0.24.1 → 0.24.3

package/dist/module.js

@@ -14,12 +14,12 @@ function parseModuleDefinition(modulePath) {
     const sourceFile = typescript_1.default.createSourceFile(modulePath, sourceText, typescript_1.default.ScriptTarget.ES2020, true, typescript_1.default.ScriptKind.TS);
     let interfaceDecl;
     const supporting = [];
+    const webfInterfaceDecls = [];
     for (const stmt of sourceFile.statements) {
         if (typescript_1.default.isInterfaceDeclaration(stmt)) {
             const name = stmt.name.text;
-            if (!interfaceDecl && name.startsWith('WebF')) {
-                interfaceDecl = stmt;
-            }
+            if (name.startsWith('WebF'))
+                webfInterfaceDecls.push(stmt);
             supporting.push(stmt);
         }
         else if (typescript_1.default.isTypeAliasDeclaration(stmt) ||
@@ -28,6 +28,13 @@ function parseModuleDefinition(modulePath) {
             supporting.push(stmt);
         }
     }
+    // Prefer the "main module interface": first WebF* interface that declares methods.
+    if (!interfaceDecl) {
+        interfaceDecl = webfInterfaceDecls.find(decl => decl.members.some(member => typescript_1.default.isMethodSignature(member)));
+    }
+    if (!interfaceDecl) {
+        interfaceDecl = webfInterfaceDecls[0];
+    }
     if (!interfaceDecl) {
         throw new Error(`No interface starting with "WebF" found in module interface file: ${modulePath}`);
     }
@@ -70,10 +77,65 @@ function parseModuleDefinition(modulePath) {
             documentation,
         });
     }
+    // Optional module events declaration:
+    // `interface WebF<ModuleName>ModuleEvents { scanResult: [Event, Payload]; }`
+    const eventsInterfaceName = `${interfaceName}ModuleEvents`;
+    const eventsDecl = sourceFile.statements.find(stmt => typescript_1.default.isInterfaceDeclaration(stmt) && stmt.name.text === eventsInterfaceName);
+    let events;
+    if (eventsDecl) {
+        const eventSpecs = [];
+        for (const member of eventsDecl.members) {
+            if (!typescript_1.default.isPropertySignature(member) || !member.name)
+                continue;
+            const rawName = member.name.getText(sourceFile);
+            const eventName = rawName.replace(/['"]/g, '');
+            let eventTypeText = 'Event';
+            let extraTypeText = 'any';
+            if (member.type) {
+                if (typescript_1.default.isTupleTypeNode(member.type) && member.type.elements.length === 2) {
+                    eventTypeText = printer.printNode(typescript_1.default.EmitHint.Unspecified, member.type.elements[0], sourceFile);
+                    extraTypeText = printer.printNode(typescript_1.default.EmitHint.Unspecified, member.type.elements[1], sourceFile);
+                }
+                else {
+                    eventTypeText = printer.printNode(typescript_1.default.EmitHint.Unspecified, member.type, sourceFile);
+                }
+            }
+            let documentation;
+            const jsDocs = member.jsDoc;
+            if (jsDocs && jsDocs.length > 0) {
+                documentation = jsDocs
+                    .map(doc => doc.comment)
+                    .filter(Boolean)
+                    .join('\n');
+            }
+            eventSpecs.push({
+                name: eventName,
+                eventTypeText,
+                extraTypeText,
+                documentation,
+            });
+        }
+        if (eventSpecs.length > 0) {
+            events = {
+                interfaceName: eventsInterfaceName,
+                eventNameTypeName: `${interfaceName}ModuleEventName`,
+                eventArgsTypeName: `${interfaceName}ModuleEventArgs`,
+                listenerTypeName: `${interfaceName}ModuleEventListener`,
+                events: eventSpecs,
+            };
+        }
+    }
     if (methods.length === 0) {
         throw new Error(`Interface ${interfaceName} in ${modulePath} does not declare any methods`);
     }
-    return { interfaceName, moduleName, methods, supportingStatements: supporting, sourceFile };
+    return {
+        interfaceName,
+        moduleName,
+        methods,
+        events,
+        supportingStatements: supporting,
+        sourceFile,
+    };
 }
 function buildTypesFile(def) {
     const printer = typescript_1.default.createPrinter();
@@ -102,6 +164,19 @@ function buildTypesFile(def) {
         lines.push(printed);
     }
     lines.push('');
+    if (def.events) {
+        const { interfaceName, eventNameTypeName, eventArgsTypeName, listenerTypeName } = def.events;
+        lines.push(`export type ${eventNameTypeName} = Extract<keyof ${interfaceName}, string>;`);
+        lines.push(`export type ${eventArgsTypeName}<K extends ${eventNameTypeName} = ${eventNameTypeName}> =`);
+        lines.push(`  ${interfaceName}[K] extends readonly [infer E, infer X]`);
+        lines.push(`    ? [event: (E & { type: K }), extra: X]`);
+        lines.push(`    : [event: (${interfaceName}[K] & { type: K }), extra: any];`);
+        lines.push('');
+        lines.push(`export type ${listenerTypeName} = (...args: {`);
+        lines.push(`  [K in ${eventNameTypeName}]: ${eventArgsTypeName}<K>;`);
+        lines.push(`}[${eventNameTypeName}]) => any;`);
+        lines.push('');
+    }
     // Ensure file is treated as a module even if no declarations were emitted.
     lines.push('export {};');
     return lines.join('\n');
@@ -128,6 +203,10 @@ function buildIndexFile(def) {
             typeImportNames.add(name);
         }
     }
+    if (def.events) {
+        typeImportNames.add(def.events.eventNameTypeName);
+        typeImportNames.add(def.events.eventArgsTypeName);
+    }
     const typeImportsSorted = Array.from(typeImportNames).sort();
     if (typeImportsSorted.length > 0) {
         lines.push(`import type { ${typeImportsSorted.join(', ')} } from './types';`);
@@ -138,6 +217,49 @@ function buildIndexFile(def) {
     lines.push("    return typeof webf !== 'undefined' && typeof (webf as any).invokeModuleAsync === 'function';");
     lines.push('  }');
     lines.push('');
+    if (def.events) {
+        lines.push('  private static _moduleListenerInstalled = false;');
+        lines.push('  private static _listeners: Record<string, Set<(event: Event, extra: any) => any>> = Object.create(null);');
+        lines.push('');
+        lines.push(`  static addListener<K extends ${def.events.eventNameTypeName}>(type: K, listener: (...args: ${def.events.eventArgsTypeName}<K>) => any): () => void {`);
+        lines.push("    if (typeof webf === 'undefined' || typeof (webf as any).addWebfModuleListener !== 'function') {");
+        lines.push("      throw new Error('WebF module event API is not available. Make sure you are running in WebF runtime.');");
+        lines.push('    }');
+        lines.push('');
+        lines.push('    if (!this._moduleListenerInstalled) {');
+        lines.push(`      (webf as any).addWebfModuleListener('${def.moduleName}', (event: Event, extra: any) => {`);
+        lines.push('        const set = this._listeners[event.type];');
+        lines.push('        if (!set) return;');
+        lines.push('        for (const fn of set) { fn(event, extra); }');
+        lines.push('      });');
+        lines.push('      this._moduleListenerInstalled = true;');
+        lines.push('    }');
+        lines.push('');
+        lines.push('    (this._listeners[type] ??= new Set()).add(listener as any);');
+        lines.push('');
+        lines.push('    const cls = this;');
+        lines.push('    return () => {');
+        lines.push('      const set = cls._listeners[type];');
+        lines.push('      if (!set) return;');
+        lines.push('      set.delete(listener as any);');
+        lines.push('      if (set.size === 0) { delete cls._listeners[type]; }');
+        lines.push('');
+        lines.push('      if (Object.keys(cls._listeners).length === 0) {');
+        lines.push('        cls.removeListener();');
+        lines.push('      }');
+        lines.push('    };');
+        lines.push('  }');
+        lines.push('');
+        lines.push('  static removeListener(): void {');
+        lines.push('    this._listeners = Object.create(null);');
+        lines.push('    this._moduleListenerInstalled = false;');
+        lines.push("    if (typeof webf === 'undefined' || typeof (webf as any).removeWebfModuleListener !== 'function') {");
+        lines.push('      return;');
+        lines.push('    }');
+        lines.push(`    (webf as any).removeWebfModuleListener('${def.moduleName}');`);
+        lines.push('  }');
+        lines.push('');
+    }
     for (const method of def.methods) {
         if (method.documentation) {
             lines.push('  /**');
@@ -173,6 +295,11 @@ function buildIndexFile(def) {
             typeExportNames.add(stmt.name.text);
         }
     }
+    if (def.events) {
+        typeExportNames.add(def.events.eventNameTypeName);
+        typeExportNames.add(def.events.eventArgsTypeName);
+        typeExportNames.add(def.events.listenerTypeName);
+    }
     const sorted = Array.from(typeExportNames).sort();
     if (sorted.length) {
         lines.push('  ' + sorted.join(','));
@@ -260,6 +387,7 @@ function mapTsPropertyTypeToDart(type, optional) {
     }
 }
 function buildDartBindings(def, command) {
+    var _a;
     const dartClassBase = `${def.moduleName}Module`;
     const dartBindingsClass = `${dartClassBase}Bindings`;
     const lines = [];
@@ -268,6 +396,9 @@ function buildDartBindings(def, command) {
     lines.push('// Generated by `webf module-codegen`');
     lines.push('');
     lines.push("import 'package:webf/module.dart';");
+    if (def.events) {
+        lines.push("import 'package:webf/dom.dart';");
+    }
     if (def.methods.some(m => m.params.some(p => isTsByteArrayUnion(p.typeText)))) {
         lines.push("import 'package:webf/bridge.dart';");
     }
@@ -275,7 +406,9 @@ function buildDartBindings(def, command) {
     // Generate Dart classes for supporting TS interfaces (compound option types).
     const optionInterfaces = [];
     for (const stmt of def.supportingStatements) {
-        if (typescript_1.default.isInterfaceDeclaration(stmt) && stmt.name.text !== def.interfaceName) {
+        if (typescript_1.default.isInterfaceDeclaration(stmt) &&
+            stmt.name.text !== def.interfaceName &&
+            stmt.name.text !== ((_a = def.events) === null || _a === void 0 ? void 0 : _a.interfaceName)) {
             optionInterfaces.push(stmt);
         }
     }
@@ -365,6 +498,25 @@ function buildDartBindings(def, command) {
     lines.push(`  @override`);
     lines.push(`  String get name => '${def.moduleName}';`);
     lines.push('');
+    if (def.events) {
+        for (const evt of def.events.events) {
+            const methodName = `emit${lodash_1.default.upperFirst(lodash_1.default.camelCase(evt.name))}`;
+            const mappedExtra = mapTsParamTypeToDart(evt.extraTypeText, optionTypeNames);
+            const dataParamType = mappedExtra.optionClassName
+                ? `${mappedExtra.optionClassName}?`
+                : 'dynamic';
+            lines.push(`  dynamic ${methodName}({Event? event, ${dataParamType} data}) {`);
+            if (mappedExtra.optionClassName) {
+                lines.push('    final mapped = data?.toMap();');
+                lines.push(`    return dispatchEvent(event: event ?? Event('${evt.name}'), data: mapped);`);
+            }
+            else {
+                lines.push(`    return dispatchEvent(event: event ?? Event('${evt.name}'), data: data);`);
+            }
+            lines.push('  }');
+            lines.push('');
+        }
+    }
     for (const method of def.methods) {
         const dartMethodName = lodash_1.default.camelCase(method.name);
         let dartReturnType = mapTsReturnTypeToDart(method.returnTypeText);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwebf/webf",
-  "version": "0.24.1",
+  "version": "0.24.3",
   "description": "Command line tools for WebF",
   "main": "index.js",
   "bin": {

package/src/analyzer.ts

@@ -410,6 +410,188 @@ function handleGenericWrapper(typeReference: ts.TypeReferenceNode, mode?: Parame
   return getParameterBaseType(argument, mode);
 }
 
+const customEventTypePrinter = ts.createPrinter({ removeComments: true });
+
+function mapTypeReferenceIdentifierToTsType(identifier: string): string | null {
+  const mappedType = TYPE_REFERENCE_MAP[identifier];
+  if (mappedType === undefined) return null;
+  switch (mappedType) {
+    case FunctionArgumentType.boolean:
+      return 'boolean';
+    case FunctionArgumentType.dom_string:
+      return 'string';
+    case FunctionArgumentType.double:
+    case FunctionArgumentType.int:
+      return 'number';
+    case FunctionArgumentType.any:
+      return 'any';
+    case FunctionArgumentType.void:
+      return 'void';
+    case FunctionArgumentType.function:
+      return 'Function';
+    case FunctionArgumentType.promise:
+      return 'Promise<any>';
+    default:
+      return null;
+  }
+}
+
+function getBasicTypeKindAsTsType(kind: ts.SyntaxKind): string | null {
+  const basicType = BASIC_TYPE_MAP[kind];
+  if (basicType === undefined) return null;
+  switch (basicType) {
+    case FunctionArgumentType.boolean:
+      return 'boolean';
+    case FunctionArgumentType.dom_string:
+      return 'string';
+    case FunctionArgumentType.double:
+    case FunctionArgumentType.int:
+      return 'number';
+    case FunctionArgumentType.any:
+      return 'any';
+    case FunctionArgumentType.void:
+      return 'void';
+    case FunctionArgumentType.null:
+      return 'null';
+    case FunctionArgumentType.undefined:
+      return 'undefined';
+    default:
+      return null;
+  }
+}
+
+function stringifyEntityName(name: ts.EntityName): string {
+  if (ts.isIdentifier(name)) return name.text;
+  return `${stringifyEntityName(name.left)}.${name.right.text}`;
+}
+
+function safePrintCustomEventNode(node: ts.Node): string {
+  const sourceFile = node.getSourceFile();
+  const printed = customEventTypePrinter.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+  // Ensure WebF IDL-like aliases used in type definitions do not leak into generated TypeScript packages.
+  return printed.replace(/\bint\b/g, 'number').replace(/\bdouble\b/g, 'number');
+}
+
+function stringifyCustomEventGenericTypeNode(typeNode: ts.TypeNode): string | null {
+  if (ts.isParenthesizedTypeNode(typeNode)) {
+    const inner = stringifyCustomEventGenericTypeNode(typeNode.type);
+    return inner ? `(${inner})` : null;
+  }
+
+  if (ts.isUnionTypeNode(typeNode)) {
+    const parts = typeNode.types.map(t => stringifyCustomEventGenericTypeNode(t)).filter((t): t is string => Boolean(t));
+    return parts.length === typeNode.types.length ? parts.join(' | ') : null;
+  }
+
+  if (ts.isIntersectionTypeNode(typeNode)) {
+    const parts = typeNode.types.map(t => stringifyCustomEventGenericTypeNode(t)).filter((t): t is string => Boolean(t));
+    return parts.length === typeNode.types.length ? parts.join(' & ') : null;
+  }
+
+  if (ts.isArrayTypeNode(typeNode)) {
+    const element = stringifyCustomEventGenericTypeNode(typeNode.elementType);
+    return element ? `${element}[]` : null;
+  }
+
+  if (ts.isTupleTypeNode(typeNode)) {
+    const elements = typeNode.elements.map(e => stringifyCustomEventGenericTypeNode(e)).filter((t): t is string => Boolean(t));
+    return elements.length === typeNode.elements.length ? `[${elements.join(', ')}]` : null;
+  }
+
+  if (ts.isLiteralTypeNode(typeNode)) {
+    const literal = typeNode.literal;
+    if (literal.kind === ts.SyntaxKind.NullKeyword) return 'null';
+    if (literal.kind === ts.SyntaxKind.UndefinedKeyword) return 'undefined';
+    if (literal.kind === ts.SyntaxKind.TrueKeyword) return 'true';
+    if (literal.kind === ts.SyntaxKind.FalseKeyword) return 'false';
+    if (ts.isStringLiteral(literal)) return JSON.stringify(literal.text);
+    if (ts.isNumericLiteral(literal)) return literal.text;
+    return null;
+  }
+
+  const basic = getBasicTypeKindAsTsType(typeNode.kind);
+  if (basic) return basic;
+
+  if (ts.isTypeReferenceNode(typeNode)) {
+    const typeName = stringifyEntityName(typeNode.typeName);
+
+    // Unwrap internal helpers used by WebF typings.
+    if (typeName === 'DartImpl' && typeNode.typeArguments && typeNode.typeArguments[0]) {
+      return stringifyCustomEventGenericTypeNode(typeNode.typeArguments[0]);
+    }
+
+    if (typeName === 'Promise') {
+      if (!typeNode.typeArguments || !typeNode.typeArguments[0]) return 'Promise<any>';
+      const inner = stringifyCustomEventGenericTypeNode(typeNode.typeArguments[0]);
+      return inner ? `Promise<${inner}>` : null;
+    }
+
+    const mapped = mapTypeReferenceIdentifierToTsType(typeName);
+    if (mapped) return mapped;
+
+    if (!typeNode.typeArguments || typeNode.typeArguments.length === 0) {
+      return typeName;
+    }
+
+    const args = typeNode.typeArguments
+      .map(arg => stringifyCustomEventGenericTypeNode(arg))
+      .filter((t): t is string => Boolean(t));
+    if (args.length !== typeNode.typeArguments.length) return null;
+    return `${typeName}<${args.join(', ')}>`;
+  }
+
+  if (ts.isTypeLiteralNode(typeNode)) {
+    const members: string[] = [];
+    for (const member of typeNode.members) {
+      if (ts.isPropertySignature(member) && member.type) {
+        const typeString = stringifyCustomEventGenericTypeNode(member.type);
+        if (!typeString) return null;
+        let nameText: string;
+        if (ts.isIdentifier(member.name)) nameText = member.name.text;
+        else if (ts.isStringLiteral(member.name)) nameText = JSON.stringify(member.name.text);
+        else if (ts.isNumericLiteral(member.name)) nameText = member.name.text;
+        else nameText = member.name.getText();
+        const optional = member.questionToken ? '?' : '';
+        members.push(`${nameText}${optional}: ${typeString}`);
+        continue;
+      }
+      if (ts.isIndexSignatureDeclaration(member) && member.type && member.parameters.length === 1) {
+        const param = member.parameters[0];
+        const paramName = ts.isIdentifier(param.name) ? param.name.text : param.name.getText();
+        const paramType = param.type ? stringifyCustomEventGenericTypeNode(param.type) : 'string';
+        const valueType = stringifyCustomEventGenericTypeNode(member.type);
+        if (!paramType || !valueType) return null;
+        members.push(`[${paramName}: ${paramType}]: ${valueType}`);
+        continue;
+      }
+      // Fallback for uncommon members (call signatures, method signatures, etc.).
+      members.push(safePrintCustomEventNode(member));
+    }
+    return `{ ${members.join('; ')} }`;
+  }
+
+  if (ts.isTypeOperatorNode(typeNode)) {
+    const inner = stringifyCustomEventGenericTypeNode(typeNode.type);
+    if (!inner) return null;
+    const operator =
+      typeNode.operator === ts.SyntaxKind.KeyOfKeyword ? 'keyof' :
+      typeNode.operator === ts.SyntaxKind.ReadonlyKeyword ? 'readonly' :
+      typeNode.operator === ts.SyntaxKind.UniqueKeyword ? 'unique' :
+      null;
+    return operator ? `${operator} ${inner}` : null;
+  }
+
+  if (ts.isIndexedAccessTypeNode(typeNode)) {
+    const objectType = stringifyCustomEventGenericTypeNode(typeNode.objectType);
+    const indexType = stringifyCustomEventGenericTypeNode(typeNode.indexType);
+    if (!objectType || !indexType) return null;
+    return `${objectType}[${indexType}]`;
+  }
+
+  // As a last resort, keep the original syntax but normalize known WebF aliases.
+  return safePrintCustomEventNode(typeNode);
+}
+
 function handleCustomEventType(typeReference: ts.TypeReferenceNode): ParameterBaseType {
   // Handle CustomEvent<T> by returning the full type with generic parameter
   if (!typeReference.typeArguments || !typeReference.typeArguments[0]) {
@@ -417,121 +599,11 @@ function handleCustomEventType(typeReference: ts.TypeReferenceNode): ParameterBa
   }
   
   const argument = typeReference.typeArguments[0];
-  let genericType: string;
-  
-  // Preserve simple union/compound generic types (e.g., boolean | null)
-  if (ts.isUnionTypeNode(argument) || ts.isIntersectionTypeNode(argument)) {
-    const unionTypes = (argument as ts.UnionTypeNode | ts.IntersectionTypeNode).types ?? [];
-    const parts = unionTypes.map(t => {
-      // Literal union members: handle null/undefined explicitly
-      if (ts.isLiteralTypeNode(t)) {
-        const lit = t.literal;
-        if (lit.kind === ts.SyntaxKind.NullKeyword) return 'null';
-        if (lit.kind === ts.SyntaxKind.UndefinedKeyword) return 'undefined';
-        if (ts.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 FunctionArgumentType.boolean:
-            return 'boolean';
-          case FunctionArgumentType.dom_string:
-            return 'string';
-          case FunctionArgumentType.double:
-          case FunctionArgumentType.int:
-            return 'number';
-          case FunctionArgumentType.null:
-            return 'null';
-          case FunctionArgumentType.undefined:
-            return 'undefined';
-          default:
-            return 'any';
-        }
-      }
-      // Literal null/undefined keywords that BASIC_TYPE_MAP may not cover
-      if (t.kind === ts.SyntaxKind.NullKeyword) return 'null';
-      if (t.kind === ts.SyntaxKind.UndefinedKeyword) return 'undefined';
-      // Fallback: rely on toString of node kind
-      return 'any';
-    });
-    genericType = parts.join(' | ');
-  } else if (ts.isTypeReferenceNode(argument) && ts.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];
-    if (mappedType !== undefined) {
-      switch (mappedType) {
-        case FunctionArgumentType.boolean:
-          genericType = 'boolean';
-          break;
-        case FunctionArgumentType.dom_string:
-          genericType = 'string';
-          break;
-        case FunctionArgumentType.double:
-        case FunctionArgumentType.int:
-          genericType = 'number';
-          break;
-        case FunctionArgumentType.any:
-          genericType = 'any';
-          break;
-        case FunctionArgumentType.void:
-          genericType = 'void';
-          break;
-        case FunctionArgumentType.function:
-          genericType = 'Function';
-          break;
-        case FunctionArgumentType.promise:
-          genericType = 'Promise<any>';
-          break;
-        default:
-          genericType = typeName;
-      }
-    } else {
-      // For other type references, use the type name directly
-      genericType = typeName;
-    }
-  } else if (ts.isLiteralTypeNode(argument) && ts.isStringLiteral(argument.literal)) {
-    genericType = argument.literal.text;
-  } else {
-    // Handle basic types (boolean, string, number, etc.)
-    const basicType = BASIC_TYPE_MAP[argument.kind];
-    if (basicType !== undefined) {
-      switch (basicType) {
-        case FunctionArgumentType.boolean:
-          genericType = 'boolean';
-          break;
-        case FunctionArgumentType.dom_string:
-          genericType = 'string';
-          break;
-        case FunctionArgumentType.double:
-        case FunctionArgumentType.int:
-          genericType = 'number';
-          break;
-        case FunctionArgumentType.any:
-          genericType = 'any';
-          break;
-        case FunctionArgumentType.void:
-          genericType = 'void';
-          break;
-        case FunctionArgumentType.null:
-          genericType = 'null';
-          break;
-        case FunctionArgumentType.undefined:
-          genericType = 'undefined';
-          break;
-        default:
-          genericType = 'any';
-      }
-    } else {
-      // For truly complex types, fallback to 'any' to avoid errors
-      console.warn('Complex generic type in CustomEvent, using any');
-      genericType = 'any';
-    }
+  const genericType = stringifyCustomEventGenericTypeNode(argument);
+  if (!genericType) {
+    console.warn('Complex generic type in CustomEvent, using any');
+    return 'CustomEvent<any>';
   }
-  
   return `CustomEvent<${genericType}>`;
 }