brick-module 0.1.1

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

@@ -0,0 +1,224 @@
+package com.brickmodule
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+/**
+ * Central registry for all Brick modules Manages module lifecycle and provides simple module
+ * storage
+ */
+object BrickModuleRegistry {
+    private val modules: MutableMap<String, Any> = mutableMapOf()
+    private var isRegistered: Boolean = false
+    private var reactContext: ReactApplicationContext? = null
+
+    /**
+     * Registers an array of Brick modules Each module must implement their respective TypeModule
+     * interface This should be called once during app initialization
+     */
+    fun register(modules: List<Any>) {
+        modules.forEach { module -> registerSingleModule(module) }
+        
+        if (!isRegistered) {
+            isRegistered = true
+        }
+        
+        println("✅ BrickModuleRegistry: Successfully registered ${modules.size} modules (total: ${this.modules.size})")
+    }
+    
+    /**
+     * Registers a single module (push-style registration)
+     * Useful for manual module registration or testing
+     */
+    fun push(module: Any) {
+        registerSingleModule(module)
+        println("✅ BrickModuleRegistry: Module pushed successfully (total: ${this.modules.size})")
+    }
+
+    private fun registerSingleModule(module: Any) {
+        // Use reflection to get moduleName
+        val moduleNameProperty =
+                try {
+                    module.javaClass.getMethod("getModuleName").invoke(module) as? String
+                } catch (e: Exception) {
+                    try {
+                        module.javaClass
+                                .getDeclaredField("moduleName")
+                                .apply { isAccessible = true }
+                                .get(module) as?
+                                String
+                    } catch (e: Exception) {
+                        null
+                    }
+                }
+
+        val moduleName =
+                moduleNameProperty
+                        ?: run {
+                            println(
+                                    "❌ BrickModuleRegistry: Module has no accessible moduleName property"
+                            )
+                            return
+                        }
+
+        // Validate module name
+        if (moduleName.isEmpty()) {
+            println("❌ BrickModuleRegistry: Module has empty moduleName")
+            return
+        }
+
+        // Check for module name conflicts
+        if (modules.containsKey(moduleName)) {
+            println("⚠️ BrickModuleRegistry: Module '$moduleName' is already registered. Skipping.")
+            return
+        }
+
+        // Get version using reflection
+        val version =
+                try {
+                    module.javaClass.getMethod("getVersion").invoke(module) as? String ?: "1.0.0"
+                } catch (e: Exception) {
+                    try {
+                        module.javaClass
+                                .getDeclaredField("version")
+                                .apply { isAccessible = true }
+                                .get(module) as?
+                                String
+                                ?: "1.0.0"
+                    } catch (e: Exception) {
+                        "1.0.0"
+                    }
+                }
+
+        // Register the module
+        modules[moduleName] = module
+        println("📦 BrickModuleRegistry: Registered module '$moduleName' (v$version)")
+    }
+
+    /**
+     * Returns the actual module instance for reflection-based method calls Used by BrickModuleImpl
+     * for direct protocol casting
+     */
+    fun getModuleInstance(moduleName: String): Any? {
+        return modules[moduleName]
+    }
+
+    /** Returns list of registered module names */
+    fun getRegisteredModules(): List<String> {
+        return modules.keys.toList().sorted()
+    }
+
+    /**
+     * Sets the React Native context for event emission This should be called during app
+     * initialization from the main BrickModule
+     */
+    fun setReactContext(context: ReactApplicationContext) {
+        reactContext = context
+        println("📡 BrickModuleRegistry: React context connected for event emission")
+    }
+
+    /** Sends an event to JavaScript Used by modules to emit events to JavaScript */
+    fun sendEvent(eventName: String, data: Any?) {
+        reactContext?.let { context ->
+            try {
+                // Convert data to React Native compatible format
+                val eventData =
+                        when (data) {
+                            is Map<*, *> -> {
+                                val writableMap = Arguments.createMap()
+                                data.forEach { (key, value) ->
+                                    when (value) {
+                                        is String -> writableMap.putString(key.toString(), value)
+                                        is Number ->
+                                                writableMap.putDouble(
+                                                        key.toString(),
+                                                        value.toDouble()
+                                                )
+                                        is Boolean -> writableMap.putBoolean(key.toString(), value)
+                                        is List<*> -> {
+                                            val writableArray = Arguments.createArray()
+                                            value.forEach { item ->
+                                                when (item) {
+                                                    is String -> writableArray.pushString(item)
+                                                    is Number ->
+                                                            writableArray.pushDouble(
+                                                                    item.toDouble()
+                                                            )
+                                                    is Boolean -> writableArray.pushBoolean(item)
+                                                    else ->
+                                                            writableArray.pushString(
+                                                                    item.toString()
+                                                            )
+                                                }
+                                            }
+                                            writableMap.putArray(key.toString(), writableArray)
+                                        }
+                                        null -> writableMap.putNull(key.toString())
+                                        else ->
+                                                writableMap.putString(
+                                                        key.toString(),
+                                                        value.toString()
+                                                )
+                                    }
+                                }
+                                writableMap
+                            }
+                            else -> data
+                        }
+
+                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()
+            }
+        }
+                ?: run {
+                    println(
+                            "⚠️ BrickModuleRegistry: No React context available for event: $eventName"
+                    )
+                }
+    }
+
+    /** Returns all constants from registered modules */
+    fun getAllConstants(): Map<String, Any> {
+        val allConstants = mutableMapOf<String, Any>()
+
+        modules.forEach { (moduleName, module) ->
+            // Use reflection to get constants from the module
+            val moduleConstants = mutableMapOf<String, Any>()
+            val moduleClass = module.javaClass
+
+            // Get all public fields that might be constants
+            moduleClass.declaredFields.forEach { field ->
+                try {
+                    field.isAccessible = true
+                    val fieldName = field.name
+                    // Skip internal fields
+                    if (!fieldName.startsWith("_") && !fieldName.contains("$")) {
+                        val value = field.get(module)
+                        if (value != null) {
+                            moduleConstants[fieldName] = value
+                        }
+                    }
+                } catch (e: Exception) {
+                    // Ignore reflection errors
+                }
+            }
+
+            allConstants[moduleName] = moduleConstants
+        }
+
+        return allConstants
+    }
+
+    /** Clears all registered modules (for testing purposes only) */
+    fun clearRegistry() {
+        modules.clear()
+        isRegistered = false
+        println("🧹 BrickModuleRegistry: Registry cleared")
+    }
+}

package/android/src/main/resources/META-INF/gradle-plugins/com.brickmodule.properties

@@ -0,0 +1 @@
+implementation-class=com.brickmodule.BrickModulePlugin

package/bin/brick-codegen.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+/**
+ * Brick Codegen CLI Entry Point
+ * This wrapper allows brick-module to provide the brick-codegen CLI
+ */
+
+import 'brick-codegen/cli';

package/dist/BrickModule.d.ts

@@ -0,0 +1,64 @@
+import { TurboModule } from "react-native";
+
+//#region src/BrickModule.d.ts
+
+/**
+ * Base interface that all Brick module specs must extend
+ */
+interface BrickModuleInterface extends TurboModule {
+  readonly moduleName: string;
+  readonly supportedEvents?: readonly string[];
+}
+/**
+ * Type alias for module specifications
+ * Use this as the base interface when defining your module specs
+ * @example
+ * export interface MyModuleSpec extends BrickModuleSpec {
+ *   readonly moduleName: "MyModule";
+ *   readonly supportedEvents: ["eventA", "eventB"];
+ *   myMethod(param: string): Promise<string>;
+ * }
+ */
+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;
+};
+/**
+ * Gets a typed module instance by name with explicit type parameter
+ * @param moduleName - The exact name of the module as defined in its spec
+ * @returns Typed module interface with all methods, constants, and event listeners
+ */
+declare function get<T extends BrickModuleInterface>(moduleName: string): BrickModuleWithEvents<T>;
+/**
+ * Gets list of all registered modules
+ * @returns Promise resolving to array of module names
+ */
+declare function getRegisteredModules(): string[];
+/**
+ * Clears the module cache (useful for testing or hot reloading)
+ * @internal
+ */
+declare function clearCache(): void;
+/**
+ * Main Brick Module API object
+ * Provides type-safe access to native modules
+ */
+declare const BrickModule: {
+  readonly get: typeof get;
+  readonly getRegisteredModules: typeof getRegisteredModules;
+  readonly clearCache: typeof clearCache;
+};
+/**
+ * Default export for convenience
+ */
+//#endregion
+export { BrickModule, BrickModuleInterface, BrickModuleSpec };

package/dist/BrickModule.js

@@ -0,0 +1,91 @@
+import { NativeEventEmitter, 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
+*/
+function getNativeModule() {
+	if (!nativeModule) nativeModule = TurboModuleRegistry.getEnforcing("BrickModule");
+	return nativeModule;
+}
+function getEventEmitter() {
+	if (!eventEmitter) {
+		const nativeModuleInstance = getNativeModule();
+		eventEmitter = new NativeEventEmitter(nativeModuleInstance);
+		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
+* @returns Typed module interface with all methods, constants, and event listeners
+*/
+function get(moduleName) {
+	const cacheKey = moduleName;
+	if (moduleCache.has(cacheKey)) return moduleCache.get(cacheKey);
+	const nativeModuleInstance = getNativeModule();
+	const moduleProxy = new Proxy({}, {
+		get: (_target, property) => {
+			if (typeof property !== "string") return void 0;
+			if (property === "addEventListener") return (eventName, listener) => {
+				const emitter = getEventEmitter();
+				const subscription = emitter.addListener(`${moduleName}_${eventName}`, listener);
+				return () => {
+					subscription.remove();
+				};
+			};
+			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);
+				throw new Error(`Method ${methodKey} not found`);
+			};
+		},
+		has: (_target, property) => {
+			return typeof property === "string";
+		},
+		ownKeys: (_target) => {
+			return [];
+		}
+	});
+	moduleCache.set(cacheKey, moduleProxy);
+	return moduleProxy;
+}
+/**
+* Gets list of all registered modules
+* @returns Promise resolving to array of module names
+*/
+function getRegisteredModules() {
+	const nativeModuleInstance = getNativeModule();
+	return nativeModuleInstance?.getRegisteredModules() ?? [];
+}
+/**
+* Clears the module cache (useful for testing or hot reloading)
+* @internal
+*/
+function clearCache() {
+	moduleCache.clear();
+}
+/**
+* Main Brick Module API object
+* Provides type-safe access to native modules
+*/
+const BrickModule = {
+	get,
+	getRegisteredModules,
+	clearCache
+};
+/**
+* Default export for convenience
+*/
+var BrickModule_default = BrickModule;
+
+//#endregion
+export { BrickModule_default as default };

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { BrickModule, BrickModuleInterface, BrickModuleSpec } from "./BrickModule.js";
+
+//#region src/index.d.ts
+
+/**
+ * Error types for Brick modules
+ */
+declare class BrickModuleError extends Error {
+  code: string;
+  moduleName?: string | undefined;
+  methodName?: string | undefined;
+  constructor(message: string, code?: string, moduleName?: string | undefined, methodName?: string | undefined);
+}
+/**
+ * Configuration interface for brick-codegen
+ */
+interface BrickCodegenConfig {
+  outputIos?: string;
+  outputAndroid?: string;
+  cacheDir?: string;
+  incremental?: boolean;
+  watch?: boolean;
+  excludeModules?: string[];
+  typeCheck?: boolean;
+  verbose?: boolean;
+  newArchOnly?: boolean;
+  oldArchOnly?: boolean;
+  dev?: boolean;
+}
+//#endregion
+export { BrickCodegenConfig, BrickModule, BrickModuleError, BrickModuleInterface, BrickModuleSpec };

package/dist/index.js

@@ -0,0 +1,18 @@
+import BrickModule_default from "./BrickModule.js";
+
+//#region src/index.ts
+/**
+* Error types for Brick modules
+*/
+var BrickModuleError = class extends Error {
+	constructor(message, code = "GRANITE_ERROR", moduleName, methodName) {
+		super(message);
+		this.code = code;
+		this.moduleName = moduleName;
+		this.methodName = methodName;
+		this.name = "BrickModuleError";
+	}
+};
+
+//#endregion
+export { BrickModule_default as BrickModule, BrickModuleError };

package/ios/BrickModule/Internal/BrickCoreModule.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+/**
+ * Minimal protocol that all Brick modules must implement
+ * Contains only essential properties for module identification
+ */
+public protocol BrickModuleBase {
+    /// The name of the module (required for registration)
+    var moduleName: String { get }
+}
+
+/**
+ * Error types for Brick modules
+ */
+public enum BrickModuleError: Error, LocalizedError {
+    case typeMismatch(String)
+    case executionError(String)
+    case invalidDefinition(String)
+    case methodNotFound(String)
+    case moduleNotFound(String)
+    
+    public var errorDescription: String? {
+        switch self {
+        case .typeMismatch(let message):
+            return "Type mismatch: \(message)"
+        case .executionError(let message):
+            return "Execution error: \(message)"
+        case .invalidDefinition(let message):
+            return "Invalid definition: \(message)"
+        case .methodNotFound(let message):
+            return "Method not found: \(message)"
+        case .moduleNotFound(let message):
+            return "Module not found: \(message)"
+        }
+    }
+    
+    public var errorCode: String {
+        switch self {
+        case .typeMismatch:
+            return "TYPE_ERROR"
+        case .executionError:
+            return "EXECUTION_ERROR"
+        case .invalidDefinition:
+            return "DEFINITION_ERROR"
+        case .methodNotFound:
+            return "METHOD_NOT_FOUND"
+        case .moduleNotFound:
+            return "MODULE_NOT_FOUND"
+        }
+    }
+}

package/ios/BrickModule/Internal/BrickModuleRegistry.swift

@@ -0,0 +1,138 @@
+import Foundation
+import React
+
+/**
+ * Central registry for all Brick modules
+ * Manages module lifecycle and provides simple module storage
+ */
+@objc public class BrickModuleRegistry: NSObject {
+    @objc public static let shared = BrickModuleRegistry()
+    
+    private var modules: [String: Any] = [:]
+    private var isRegistered: Bool = false
+    private weak var eventEmitter: RCTEventEmitter?
+    
+    private override init() {
+        super.init()
+    }
+    
+    // MARK: - Module Registration
+    
+    /**
+     * Registers an array of Brick modules (Swift API)
+     * Each module must implement BrickModuleBase and its respective TypeModule protocol
+     * This should be called once during app initialization
+     */
+    public func register(_ modules: [BrickModuleBase]) {
+        guard !isRegistered else {
+            print("⚠️ BrickModuleRegistry: Modules already registered. Skipping re-registration.")
+            return
+        }
+        
+        for module in modules {
+            registerSingleModule(module)
+        }
+        
+        isRegistered = true
+        print("✅ BrickModuleRegistry: Successfully registered \(self.modules.count) modules")
+        
+        if ProcessInfo.processInfo.environment["GRANITE_DEBUG"] == "1" {
+            debugPrintRegisteredModules()
+        }
+    }
+    
+    /**
+     * Registers an array of Brick modules (Objective-C API)
+     * Each module must implement BrickModuleBase protocol
+     * This should be called once during app initialization
+     */
+    @objc(registerModules:)
+    public func registerModules(_ modules: NSArray) {
+        let brickModules = modules.compactMap { $0 as? BrickModuleBase }
+        register(brickModules)
+        }
+    
+    private func registerSingleModule(_ module: BrickModuleBase) {
+        let moduleName = module.moduleName
+        
+        // Validate module name
+        guard !moduleName.isEmpty else {
+            print("❌ BrickModuleRegistry: Module has empty moduleName")
+            return
+        }
+        
+        // Check for module name conflicts
+        if modules.keys.contains(moduleName) {
+            print("⚠️ BrickModuleRegistry: Module '\(moduleName)' is already registered. Skipping.")
+            return
+        }
+        
+        // Register the module
+        modules[moduleName] = module
+        print("📦 BrickModuleRegistry: Registered module '\(moduleName)'")
+    }
+    
+    // MARK: - Module Information
+    
+    /**
+     * Returns the actual module instance for reflection-based method calls
+     * Used by BrickModuleImpl for direct protocol casting
+     */
+    public func getModuleInstance(_ moduleName: String) -> Any? {
+        return modules[moduleName]
+    }
+    
+    /**
+     * Returns list of registered module names
+     */
+    @objc public func getRegisteredModules() -> [String] {
+        return Array(modules.keys).sorted()
+    }
+    
+    // MARK: - Event Emitter Management
+    
+    /**
+     * Sets the React Native event emitter instance for event emission
+     * This should be called during app initialization from the main BrickModule
+     */
+    @objc public func setEventEmitter(_ eventEmitter: RCTEventEmitter) {
+        self.eventEmitter = eventEmitter
+        print("📡 BrickModuleRegistry: Event emitter connected for event emission")
+    }
+    
+    /**
+     * Returns the React Native event emitter instance for event emission
+     * Used by generated module code to emit events to JavaScript
+     */
+    @objc public func getEventEmitter() -> RCTEventEmitter? {
+        return eventEmitter
+    }
+    
+    // MARK: - Debug & Development
+    
+    private func debugPrintRegisteredModules() {
+        print("🔍 BrickModuleRegistry Debug Info:")
+        print("  Total Modules: \(modules.count)")
+        
+        for (moduleName, module) in modules.sorted(by: { $0.key < $1.key }) {
+            let moduleType = String(describing: type(of: module))
+            print("  📦 \(moduleName) (\(moduleType))")
+        }
+    }
+    
+    /**
+     * Clears all registered modules (for testing purposes only)
+     */
+    @objc public func clearRegistry() {
+        guard ProcessInfo.processInfo.environment["NODE_ENV"] == "test" ||
+              ProcessInfo.processInfo.environment["GRANITE_ALLOW_CLEAR"] == "1" else {
+            print("⚠️ BrickModuleRegistry: clearRegistry() is only allowed in test environment")
+            return
+        }
+        
+        modules.removeAll()
+        isRegistered = false
+        
+        print("🧹 BrickModuleRegistry: Registry cleared")
+    }
+}