@openwebf/webf 0.24.2 → 0.24.3

package/README.md

@@ -100,6 +100,26 @@ This will:
 - 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`
 
+#### Module Events (Optional)
+
+If your module emits events via Dart `moduleManager.emitModuleEvent(...)`, you can optionally declare them in the same `*.module.d.ts` file using:
+
+```ts
+interface WebFMyModuleModuleEvents {
+  // Shorthand: only types the `event` parameter (extra defaults to `any`)
+  ready: Event;
+
+  // Tuple: [eventType, extraType] types both callback parameters
+  scanResult: [Event, { deviceId: string; rssi: number }];
+  click: [CustomEvent<string>, number[]];
+}
+```
+
+When present, `webf module-codegen` will generate:
+- `WebFMyModuleModuleEventListener` (typed listener with correlated `event.type` ↔ `extra`)
+- `WebFMyModule.addListener(eventType, listener)` (returns an unsubscribe function)
+- `WebFMyModule.removeListener()` (removes all listeners for this module)
+
 ### Interactive Mode
 
 If you don't provide all required options, the CLI will prompt you interactively:

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.2",
+  "version": "0.24.3",
   "description": "Command line tools for WebF",
   "main": "index.js",
   "bin": {

package/src/module.ts

@@ -12,10 +12,24 @@ interface ModuleMethodSpec {
   documentation?: string;
 }
 
+interface ModuleEventSpec {
+  name: string;
+  eventTypeText: string;
+  extraTypeText: string;
+  documentation?: string;
+}
+
 interface ModuleDefinition {
   interfaceName: string;
   moduleName: string;
   methods: ModuleMethodSpec[];
+  events?: {
+    interfaceName: string;
+    eventNameTypeName: string;
+    eventArgsTypeName: string;
+    listenerTypeName: string;
+    events: ModuleEventSpec[];
+  };
   supportingStatements: ts.Statement[];
   sourceFile: ts.SourceFile;
 }
@@ -32,13 +46,12 @@ function parseModuleDefinition(modulePath: string): ModuleDefinition {
 
   let interfaceDecl: ts.InterfaceDeclaration | undefined;
   const supporting: ts.Statement[] = [];
+  const webfInterfaceDecls: ts.InterfaceDeclaration[] = [];
 
   for (const stmt of sourceFile.statements) {
     if (ts.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 (
       ts.isTypeAliasDeclaration(stmt) ||
@@ -49,6 +62,17 @@ function parseModuleDefinition(modulePath: string): ModuleDefinition {
     }
   }
 
+  // Prefer the "main module interface": first WebF* interface that declares methods.
+  if (!interfaceDecl) {
+    interfaceDecl = webfInterfaceDecls.find(decl =>
+      decl.members.some(member => ts.isMethodSignature(member))
+    );
+  }
+
+  if (!interfaceDecl) {
+    interfaceDecl = webfInterfaceDecls[0];
+  }
+
   if (!interfaceDecl) {
     throw new Error(
       `No interface starting with "WebF" found in module interface file: ${modulePath}`
@@ -100,13 +124,93 @@ function parseModuleDefinition(modulePath: string): ModuleDefinition {
     });
   }
 
+  // Optional module events declaration:
+  // `interface WebF<ModuleName>ModuleEvents { scanResult: [Event, Payload]; }`
+  const eventsInterfaceName = `${interfaceName}ModuleEvents`;
+  const eventsDecl = sourceFile.statements.find(
+    stmt => ts.isInterfaceDeclaration(stmt) && stmt.name.text === eventsInterfaceName
+  ) as ts.InterfaceDeclaration | undefined;
+
+  let events:
+    | {
+        interfaceName: string;
+        eventNameTypeName: string;
+        eventArgsTypeName: string;
+        listenerTypeName: string;
+        events: ModuleEventSpec[];
+      }
+    | undefined;
+
+  if (eventsDecl) {
+    const eventSpecs: ModuleEventSpec[] = [];
+    for (const member of eventsDecl.members) {
+      if (!ts.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 (ts.isTupleTypeNode(member.type) && member.type.elements.length === 2) {
+          eventTypeText = printer.printNode(
+            ts.EmitHint.Unspecified,
+            member.type.elements[0],
+            sourceFile
+          );
+          extraTypeText = printer.printNode(
+            ts.EmitHint.Unspecified,
+            member.type.elements[1],
+            sourceFile
+          );
+        } else {
+          eventTypeText = printer.printNode(ts.EmitHint.Unspecified, member.type, sourceFile);
+        }
+      }
+
+      let documentation: string | undefined;
+      const jsDocs = (member as any).jsDoc as ts.JSDoc[] | undefined;
+      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: ModuleDefinition): string {
@@ -144,6 +248,24 @@ function buildTypesFile(def: ModuleDefinition): string {
   }
 
   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');
@@ -180,6 +302,10 @@ function buildIndexFile(def: ModuleDefinition): string {
       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(
@@ -200,6 +326,64 @@ function buildIndexFile(def: ModuleDefinition): string {
   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('  /**');
@@ -246,6 +430,11 @@ function buildIndexFile(def: ModuleDefinition): string {
       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(','));
@@ -359,6 +548,9 @@ function buildDartBindings(def: ModuleDefinition, command: string): string {
   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))
@@ -371,7 +563,11 @@ function buildDartBindings(def: ModuleDefinition, command: string): string {
   // Generate Dart classes for supporting TS interfaces (compound option types).
   const optionInterfaces: ts.InterfaceDeclaration[] = [];
   for (const stmt of def.supportingStatements) {
-    if (ts.isInterfaceDeclaration(stmt) && stmt.name.text !== def.interfaceName) {
+    if (
+      ts.isInterfaceDeclaration(stmt) &&
+      stmt.name.text !== def.interfaceName &&
+      stmt.name.text !== def.events?.interfaceName
+    ) {
       optionInterfaces.push(stmt);
     }
   }
@@ -477,6 +673,27 @@ function buildDartBindings(def: ModuleDefinition, command: string): string {
   lines.push(`  String get name => '${def.moduleName}';`);
   lines.push('');
 
+  if (def.events) {
+    for (const evt of def.events.events) {
+      const methodName = `emit${_.upperFirst(_.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 = _.camelCase(method.name);
     let dartReturnType = mapTsReturnTypeToDart(method.returnTypeText);

package/test/module-events.test.ts

@@ -0,0 +1,83 @@
+import fs from 'fs';
+import path from 'path';
+import { generateModuleArtifacts } from '../src/module';
+import { writeFileIfChanged } from '../src/generator';
+
+jest.mock('fs');
+jest.mock('../src/generator', () => ({
+  writeFileIfChanged: jest.fn(),
+}));
+
+const mockFs = fs as jest.Mocked<typeof fs>;
+const mockWriteFileIfChanged = writeFileIfChanged as jest.MockedFunction<typeof writeFileIfChanged>;
+
+describe('module-codegen events', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.mkdirSync.mockImplementation(() => undefined);
+  });
+
+  it('generates typed module event listener + Dart emit helpers', () => {
+    const moduleInterfacePath = '/tmp/demo.module.d.ts';
+    const npmTargetDir = '/out/npm';
+    const flutterPackageDir = '/out/flutter';
+
+    mockFs.readFileSync.mockReturnValue(`
+interface Payload {
+  id: string;
+}
+
+interface WebFDemoModuleEvents {
+  scanResult: [Event, Payload];
+  click: CustomEvent<string>;
+}
+
+interface WebFDemo {
+  ping(): Promise<boolean>;
+}
+`);
+
+    generateModuleArtifacts({
+      moduleInterfacePath,
+      npmTargetDir,
+      flutterPackageDir,
+      command: 'webf module-codegen',
+    });
+
+    const typesPath = path.join(npmTargetDir, 'src', 'types.ts');
+    const indexPath = path.join(npmTargetDir, 'src', 'index.ts');
+    const dartBindingsPath = path.join(
+      flutterPackageDir,
+      'lib',
+      'src',
+      'demo_module_bindings_generated.dart'
+    );
+
+    const writes = mockWriteFileIfChanged.mock.calls.reduce<Record<string, string>>(
+      (acc, [filePath, content]) => {
+        acc[filePath] = content;
+        return acc;
+      },
+      {}
+    );
+
+    expect(writes[typesPath]).toContain('export interface WebFDemoModuleEvents');
+    expect(writes[typesPath]).toContain(
+      'export type WebFDemoModuleEventName = Extract<keyof WebFDemoModuleEvents, string>;'
+    );
+    expect(writes[typesPath]).toContain('export type WebFDemoModuleEventListener');
+
+    expect(writes[indexPath]).toContain(
+      'static addListener<K extends WebFDemoModuleEventName>(type: K, listener: (...args: WebFDemoModuleEventArgs<K>) => any): () => void'
+    );
+    expect(writes[indexPath]).toContain('private static _moduleListenerInstalled = false;');
+    expect(writes[indexPath]).toContain("addWebfModuleListener('Demo'");
+    expect(writes[indexPath]).toContain('static removeListener(): void');
+
+    expect(writes[dartBindingsPath]).toContain("import 'package:webf/dom.dart';");
+    expect(writes[dartBindingsPath]).toContain('dynamic emitScanResult({Event? event, Payload? data})');
+    expect(writes[dartBindingsPath]).toContain('final mapped = data?.toMap();');
+    expect(writes[dartBindingsPath]).not.toContain('class WebFDemoModuleEvents');
+  });
+});