brick-module 0.1.25 → 0.3.1

package/android/brick_modules.gradle

@@ -396,7 +396,18 @@ ${moduleNames}
     project.preBuild.doFirst {
         def workingDir = projectRoot
         
-        // Run codegen inline
+        // Skip codegen if already generated to prevent deleting Gradle build outputs
+        // The codegen is already run during settings.gradle phase (applyBrickModules -> runBrickCodegen)
+        // Re-running here with --clean would delete .brick_android/build/ directory
+        // which contains package-aware-r.txt needed by dependent modules
+        def brickOutputDir = getBrickAndroidPath(workingDir)
+        def generatedMarker = new File(brickOutputDir, "src/main/kotlin/BrickModule.kt")
+        if (generatedMarker.exists()) {
+            // Already generated, skip to preserve build outputs
+            return
+        }
+
+        // Run codegen only if not yet generated
         try {
             def proc = ['node', '-p', "require.resolve('brick-module/package.json')"].execute(null, workingDir)
             proc.waitFor()

package/android/src/main/java/com/brickmodule/BrickModuleBase.kt

@@ -9,13 +9,22 @@ import com.facebook.react.bridge.ReactContext
 interface BrickModuleBase {
     /** The name of the module (required for registration) */
     val moduleName: String
-    
+
     /**
      * Returns the constants exposed by this module
      * Override this method to provide module-specific constants
      * @return Map of constant name to value
      */
     fun getConstants(): Map<String, Any> = emptyMap()
+
+    /**
+     * Emits an event to JavaScript using React Native's auto-generated event emitters
+     * This method should be implemented by the bridge layer to call the appropriate
+     * auto-generated emitModuleName_onEventName method from React Native Codegen
+     * @param eventName The name of the event (e.g., "onCalculationCompleted")
+     * @param payload The event data as a Map
+     */
+    fun emitEvent(eventName: String, payload: Map<String, Any>)
 }
 
 /**
@@ -31,33 +40,21 @@ abstract class BrickModuleSpec(private val reactContext: ReactContext) : BrickMo
     protected fun getReactContext(): ReactContext = reactContext
 
     /**
-     * Send an event to JavaScript This method handles event validation and routing through the
-     * BrickHost
-     *
-     * @param eventName The name of the event (without module prefix)
-     * @param data The event data to send
+     * Event emitter callback set by the bridge layer
+     * This allows the bridge to provide access to auto-generated event emitter methods
      */
-    protected fun sendEvent(eventName: String, data: Any?) {
-        val context = getReactContext()
+    var eventEmitterCallback: ((String, Map<String, Any>) -> Unit)? = null
 
-        // Format event name with module prefix
-        val fullEventName = "${moduleName}_$eventName"
-
-        // Get the BrickHost from ReactContext
-        val activity = context.currentActivity
-        if (activity !is BrickModuleRegistrar) {
-            println(
-                    "❌ $moduleName: Current activity does not implement BrickHost, cannot send event"
+    /**
+     * Emits an event to JavaScript using React Native's auto-generated event emitters
+     * Delegates to the bridge layer which has access to the generated emitModuleName_onEventName methods
+     */
+    override fun emitEvent(eventName: String, payload: Map<String, Any>) {
+        eventEmitterCallback?.invoke(eventName, payload)
+            ?: throw IllegalStateException(
+                "Event emitter callback not set for module $moduleName. " +
+                "Events cannot be emitted until the module is registered with the bridge."
             )
-            return
-        }
-
-        // Send event via BrickHost's moduleRegistry
-        try {
-            activity.getModuleRegistry().sendEvent(context, fullEventName, data)
-        } catch (e: Exception) {
-            println("❌ $moduleName: Failed to send event $fullEventName: ${e.message}")
-        }
     }
 }
 

package/android/src/main/java/com/brickmodule/BrickModuleRegistry.kt

@@ -1,7 +1,6 @@
 package com.brickmodule
 
 import com.facebook.react.bridge.ReactContext
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import java.util.concurrent.ConcurrentHashMap
 
 /**
@@ -73,37 +72,7 @@ class BrickModuleRegistry {
         return modules.keys.toList().sorted()
     }
 
-    /**
-     * Sends an event to JavaScript Used by modules to emit events to JavaScript
-     *
-     * @param context The ReactContext to send the event to
-     * @param eventName The name of the event to send
-     * @param data The event data
-     */
-    fun sendEvent(context: ReactContext, eventName: String, data: Any?) {
-        try {
-            // Ensure modules are registered
-            if (!isRegistered) {
-                println(
-                        "⚠️ BrickModuleRegistry: Modules not registered, skipping event: $eventName"
-                )
-                return
-            }
-
-            // Convert data to React Native compatible format using helper
-            val eventData = EventDataConverter.convert(data)
-
-            println("[BrickModule] sendEvent Context: $context")
-
-            context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                    .emit(eventName, eventData)
-
-            println("📡 BrickModuleRegistry: Event sent successfully: $eventName")
-        } catch (e: Exception) {
-            println("❌ BrickModuleRegistry: Failed to send event $eventName: ${e.message}")
-            e.printStackTrace()
-        }
-    }
+    // No DeviceEventEmitter-based event path; events handled via RN Codegen EventEmitter
 
     /** Returns all constants from registered modules */
     fun getAllConstants(): Map<String, Any> {

package/dist/BrickModule.d.ts

@@ -7,7 +7,6 @@ import { TurboModule } from "react-native";
  */
 interface BrickModuleInterface extends TurboModule {
   readonly moduleName: string;
-  readonly supportedEvents?: readonly string[];
 }
 /**
  * Type alias for module specifications
@@ -23,15 +22,7 @@ type BrickModuleSpec = BrickModuleInterface;
 /**
  * Enhanced typed module interface with event listeners
  */
-type BrickModuleWithEvents<T extends BrickModuleInterface> = T & {
-  /**
-   * Adds a type-safe event listener for this module
-   * @param eventName - One of the supported events defined in the module spec
-   * @param listener - Callback function to handle the event
-   * @returns Unsubscription function to remove the listener
-   */
-  addEventListener<TEvent = unknown>(eventName: T["supportedEvents"] extends readonly (infer U)[] ? U : never, listener: (event: TEvent) => void): () => void;
-};
+type BrickModuleWithEvents<T extends BrickModuleInterface> = T;
 /**
  * Gets a typed module instance by name with explicit type parameter
  * @param moduleName - The exact name of the module as defined in its spec

package/dist/BrickModule.js

@@ -1,9 +1,8 @@
-import { NativeEventEmitter, TurboModuleRegistry } from "react-native";
+import { TurboModuleRegistry } from "react-native";
 
 //#region src/BrickModule.ts
 const moduleCache = /* @__PURE__ */ new Map();
 let nativeModule = null;
-let eventEmitter = null;
 /**
 * Gets the native TurboModule instance
 * @private
@@ -12,13 +11,6 @@ function getNativeModule() {
 	if (!nativeModule) nativeModule = TurboModuleRegistry.getEnforcing("BrickModule");
 	return nativeModule;
 }
-function getEventEmitter() {
-	if (!eventEmitter) {
-		eventEmitter = new NativeEventEmitter(getNativeModule());
-		console.log("eventEmitter", eventEmitter);
-	}
-	return eventEmitter;
-}
 /**
 * Gets a typed module instance by name with explicit type parameter
 * @param moduleName - The exact name of the module as defined in its spec
@@ -28,33 +20,42 @@ function get(moduleName) {
 	const cacheKey = moduleName;
 	if (moduleCache.has(cacheKey)) return moduleCache.get(cacheKey);
 	const nativeModuleInstance = getNativeModule();
+	let constantsCache = null;
 	const moduleProxy = new Proxy({}, {
 		get: (_target, property) => {
 			if (typeof property !== "string") return;
-			if (property === "addEventListener") return (eventName, listener) => {
-				const emitter = getEventEmitter();
-				try {
-					const native = getNativeModule();
-					const moduleAddName = `${moduleName}_onEventListenerAdded`;
-					if (typeof native[moduleAddName] === "function") native[moduleAddName](eventName);
-				} catch {}
-				const subscription = emitter.addListener(`${moduleName}_${eventName}`, listener);
-				return () => {
-					const native = getNativeModule();
-					const moduleRemoveName = `${moduleName}_onEventListenerRemoved`;
-					try {
-						if (typeof native[moduleRemoveName] === "function") native[moduleRemoveName](eventName);
-					} catch {} finally {
-						subscription.remove();
-					}
-				};
+			if (property.startsWith("on") && property.length > 2 && property[2] === property[2].toUpperCase()) return (listener) => {
+				const nativeEventMethod = `${moduleName}_${property}`;
+				const nativeFn = nativeModuleInstance[nativeEventMethod];
+				if (typeof nativeFn === "function") return nativeFn(listener);
+				throw new Error(`${nativeEventMethod} is not available. Did you run RN codegen?`);
+			};
+			if (property === "getConstants") return () => {
+				if (constantsCache !== null) return constantsCache;
+				const allConstants = nativeModuleInstance?.getConstants?.() ?? {};
+				const moduleConstants = {};
+				const constantPrefix = `${moduleName}_`;
+				for (const key in allConstants) if (key.startsWith(constantPrefix)) {
+					const propName = key.substring(constantPrefix.length);
+					moduleConstants[propName] = allConstants[key];
+				}
+				constantsCache = moduleConstants;
+				return moduleConstants;
 			};
-			const allConstants = nativeModuleInstance?.getConstants?.() ?? {};
-			const constantKey = `${moduleName}_${property}`;
-			if (constantKey in allConstants) return allConstants[constantKey];
 			return (...args) => {
 				const methodKey = `${moduleName}_${property}`;
-				if (typeof nativeModuleInstance[methodKey] === "function") return nativeModuleInstance[methodKey](...args);
+				if (typeof nativeModuleInstance[methodKey] === "function") {
+					const result = nativeModuleInstance[methodKey](...args);
+					if (result && typeof result === "object" && result["~sync"] === true) if (result.success === true) return result.value;
+					else {
+						const errorInfo = result.error || {};
+						const error = new Error(errorInfo.message || "Unknown error");
+						error.name = errorInfo.code || "BRICK_ERROR";
+						if (errorInfo.details) error.details = errorInfo.details;
+						throw error;
+					}
+					return result;
+				}
 				throw new Error(`Method ${methodKey} not found`);
 			};
 		},

package/ios/BrickModule/BrickCoreModule.swift

@@ -9,7 +9,9 @@ open class BrickModuleBase: NSObject {
     /// The name of the module (required for registration)
     public let moduleName: String
     
-    public weak var eventEmitter: RCTEventEmitter?
+    /// The registry that manages this module (assigned during registration)
+    public weak var registry: BrickModuleRegistry?
+    
     public weak var bridgeProxy: RCTBridgeProxy?
     
     /// Initialize with module name
@@ -18,21 +20,13 @@ open class BrickModuleBase: NSObject {
         super.init()
     }
     
-    /// Sends an event with the given name and data
-    /// Automatically prefixes with module name and uses the registry's event emitter
-    public func sendEvent(_ eventName: String, data: Any?) {
-        // Format event name with module prefix
-        let fullEventName = "\(moduleName)_\(eventName)"
-        
-        // Get the shared event emitter instance and send event
-        if let eventEmitter = self.eventEmitter {
-            eventEmitter.sendEvent(withName: fullEventName, body: data)
-        } else {
-            let error = NSError(domain: "BrickModule", code: 500, userInfo: [
-                NSLocalizedDescriptionKey: "Event emitter not available, cannot send event: \(fullEventName)"
-            ])
-            print("Error: \(error.localizedDescription)")
+    // Emit via Registry event map (ObjC++ injects typed handlers per event)
+    public func emit(_ eventName: String, payload: [String: Any]) {
+        guard let registry = registry else {
+            print("⚠️ BrickModuleBase: registry not attached; cannot emit \(moduleName).\(eventName)")
+            return
         }
+        registry.emitEvent(module: moduleName, event: eventName, payload: payload)
     }
 }
 

package/ios/BrickModule/BrickModuleRegistry.swift

@@ -10,8 +10,11 @@ import React
     
     private var modules: [String: BrickModuleBase] = [:]
     private var isRegistered: Bool = false
-    private weak var eventEmitter: RCTEventEmitter?
+    public weak var brickTurboModule: NSObject?
     private weak var bridgeProxy: RCTBridgeProxy?;
+    // Event map injected from BrickModuleImpl (already converted to Swift types)
+    // Nested structure: [ModuleName: [EventName: Handler]]
+    private var eventMap: [String: [String: ([String: Any]) -> Void]] = [:]
     
     public override init() {
         super.init()
@@ -59,8 +62,8 @@ import React
         
         // Register the module
         modules[moduleName] = module
-        modules[moduleName]?.eventEmitter = self.eventEmitter;
         modules[moduleName]?.bridgeProxy = self.bridgeProxy;
+        modules[moduleName]?.registry = self
         print("📦 BrickModuleRegistry: Registered module '\(moduleName)'")
     }
     
@@ -82,33 +85,30 @@ import React
         }
     }
     
-    /**
-     * Returns list of registered module names
-     */
-    @objc public func getRegisteredModules() -> [String] {
-        return Array(modules.keys).sorted()
+    // Receives event map from BrickModuleImpl (already converted to Swift types)
+    public func setEventMap(_ map: [String: [String: ([String: Any]) -> Void]]) {
+        self.eventMap = map
     }
-    
-    // MARK: - Event Emitter Management
-    
-    /**
-     * Sets the React Native event emitter instance for event emission
-     * This should be called during app initialization frBrickModuleom the main BrickModule
-     */
-    public func setEventEmitter(_ eventEmitter: Any) {
-        self.eventEmitter = eventEmitter as? RCTEventEmitter
-        for module in modules {
-            module.value.eventEmitter = self.eventEmitter
+
+    // Emit event by module+event via typed block
+    @objc public func emitEvent(module: String, event: String, payload: [String: Any]) {
+        // Direct lookup without string manipulation
+        if let moduleEvents = eventMap[module],
+           let handler = moduleEvents[event] {
+            handler(payload)
+        } else {
+            print("⚠️ BrickModuleRegistry: No handler for module '\(module)' event '\(event)'")
         }
     }
     
     /**
-     * Returns the React Native event emitter instance for event emission
-     * Used by generated module code to emit events to JavaScript
+     * Returns list of registered module names
      */
-    @objc public func getEventEmitter() -> RCTEventEmitter? {
-        return eventEmitter
+    @objc public func getRegisteredModules() -> [String] {
+        return Array(modules.keys).sorted()
     }
+    
+    // MARK: - Event Emitter Management removed (CodegenTypes.EventEmitter is used)
         
     /**
      * Unregisters all modules and clears their registry references
@@ -125,8 +125,3 @@ import React
         unregister()
     }
 }
-
-public class ModuleRegistry {
-    
-}
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brick-module",
-  "version": "0.1.25",
+  "version": "0.3.1",
   "description": "Better React Native native module development",
   "type": "module",
   "main": "dist/index.js",
@@ -34,10 +34,6 @@
     "BrickModule.podspec",
     "podfile_helper.rb"
   ],
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public"
-  },
   "keywords": [
     "react-native",
     "native-module",
@@ -62,7 +58,7 @@
     "brick-codegen": "./bin/brick-codegen.js"
   },
   "dependencies": {
-    "brick-codegen": "0.1.25"
+    "brick-codegen": "0.3.1"
   },
   "peerDependencies": {
     "react": ">=18.2.0",

package/src/BrickModule.ts

@@ -4,14 +4,13 @@
  */
 
 import type { TurboModule } from "react-native";
-import { TurboModuleRegistry, NativeEventEmitter } from "react-native";
+import { TurboModuleRegistry } from "react-native";
 
 /**
  * Base interface that all Brick module specs must extend
  */
 export interface BrickModuleInterface extends TurboModule {
   readonly moduleName: string;
-  readonly supportedEvents?: readonly string[];
 }
 
 /**
@@ -29,7 +28,6 @@ export type BrickModuleSpec = BrickModuleInterface;
 // Module-level state (previously static class members)
 const moduleCache = new Map<string, any>();
 let nativeModule: any = null;
-let eventEmitter: NativeEventEmitter | null = null;
 
 /**
  * Gets the native TurboModule instance
@@ -42,30 +40,10 @@ function getNativeModule() {
   return nativeModule;
 }
 
-function getEventEmitter() {
-  if (!eventEmitter) {
-    const nativeModuleInstance = getNativeModule();
-    eventEmitter = new NativeEventEmitter(nativeModuleInstance);
-    console.log("eventEmitter", eventEmitter);
-  }
-  return eventEmitter;
-}
-
 /**
  * Enhanced typed module interface with event listeners
  */
-export type BrickModuleWithEvents<T extends BrickModuleInterface> = T & {
-  /**
-   * Adds a type-safe event listener for this module
-   * @param eventName - One of the supported events defined in the module spec
-   * @param listener - Callback function to handle the event
-   * @returns Unsubscription function to remove the listener
-   */
-  addEventListener<TEvent = unknown>(
-    eventName: T["supportedEvents"] extends readonly (infer U)[] ? U : never,
-    listener: (event: TEvent) => void
-  ): () => void;
-};
+export type BrickModuleWithEvents<T extends BrickModuleInterface> = T;
 
 /**
  * Gets a typed module instance by name with explicit type parameter
@@ -83,6 +61,9 @@ function get<T extends BrickModuleInterface>(
 
   const nativeModuleInstance = getNativeModule();
 
+  // Cache constants for this module (computed once, reused)
+  let constantsCache: Record<string, any> | null = null;
+
   // Create a proxy that intercepts method calls and forwards them to the native module
   const moduleProxy = new Proxy({} as BrickModuleWithEvents<T>, {
     get: (_target, property: string | symbol) => {
@@ -90,57 +71,81 @@ function get<T extends BrickModuleInterface>(
         return undefined;
       }
 
-      // Handle event listener methods
-      if (property === "addEventListener") {
-        return (eventName: string, listener: (event: unknown) => void) => {
-          const emitter = getEventEmitter();
-          // Inform native module about listener addition (module-specific)
-          try {
-            const native = getNativeModule();
-            const moduleAddName = `${moduleName}_onEventListenerAdded`;
-            if (typeof native[moduleAddName] === "function") {
-              native[moduleAddName](eventName);
-            }
-          } catch {
-            // ignore
+      // New-style event subscription: onXxx((event) => void) → EventSubscription
+      if (
+        property.startsWith("on") &&
+        property.length > 2 &&
+        property[2] === property[2].toUpperCase()
+      ) {
+        return (listener: (event: unknown) => void) => {
+          // Respect RN CodegenTypes.EventEmitter: call `${moduleName}_onXxx` and return as-is
+          const nativeEventMethod = `${moduleName}_${property}`;
+          const nativeFn = (nativeModuleInstance as any)[nativeEventMethod];
+          if (typeof nativeFn === "function") {
+            return nativeFn(listener);
           }
-
-          const subscription = emitter.addListener(
-            `${moduleName}_${eventName}`,
-            listener
+          throw new Error(
+            `${nativeEventMethod} is not available. Did you run RN codegen?`
           );
-
-          return () => {
-            const native = getNativeModule();
-            const moduleRemoveName = `${moduleName}_onEventListenerRemoved`;
-            try {
-              // Prefer module-specific native removal for precise cleanup
-              if (typeof native[moduleRemoveName] === "function") {
-                native[moduleRemoveName](eventName);
-              }
-            } catch {
-              // ignore
-            } finally {
-              subscription.remove();
-            }
-          };
         };
       }
 
-      // Handle individual constants - check if this property exists as a constant
-      const allConstants = nativeModuleInstance?.getConstants?.() ?? {};
-      const constantKey = `${moduleName}_${property}`;
-      if (constantKey in allConstants) {
-        return allConstants[constantKey];
+      // Special handling for getConstants method (with caching)
+      if (property === "getConstants") {
+        return () => {
+          if (constantsCache !== null) {
+            return constantsCache;
+          }
+
+          const allConstants = nativeModuleInstance?.getConstants?.() ?? {};
+          const moduleConstants: Record<string, any> = {};
+          const constantPrefix = `${moduleName}_`;
+
+          for (const key in allConstants) {
+            if (key.startsWith(constantPrefix)) {
+              const propName = key.substring(constantPrefix.length);
+              moduleConstants[propName] = allConstants[key];
+            }
+          }
+
+          constantsCache = moduleConstants;
+          return moduleConstants;
+        };
       }
 
       // Handle method calls
       return (...args: any[]) => {
         const methodKey = `${moduleName}_${property}`;
 
-        // Try direct method call first (generated by codegen)
+        // Try direct method call (generated by codegen)
         if (typeof nativeModuleInstance[methodKey] === "function") {
-          return nativeModuleInstance[methodKey](...args);
+          const result = nativeModuleInstance[methodKey](...args);
+
+          // Check if result is a wrapped sync method result
+          // Sync methods have explicit "~sync": true marker for reliable detection
+          // Format: { "~sync": true, success: true, value: T } | { "~sync": true, success: false, error: {...} }
+          if (
+            result &&
+            typeof result === "object" &&
+            result["~sync"] === true
+          ) {
+            if (result.success === true) {
+              // Success: return the unwrapped value
+              return result.value;
+            } else {
+              // Failure: throw an Error with details from error object
+              const errorInfo = result.error || {};
+              const error = new Error(errorInfo.message || "Unknown error");
+              error.name = errorInfo.code || "BRICK_ERROR";
+              if (errorInfo.details) {
+                (error as any).details = errorInfo.details;
+              }
+              throw error;
+            }
+          }
+
+          // Not wrapped (async method or other): return as-is
+          return result;
         }
 
         throw new Error(`Method ${methodKey} not found`);