brick-module 0.1.5 → 0.1.7

package/BrickModule.podspec

@@ -25,6 +25,9 @@ Pod::Spec.new do |s|
   base_config = {
     "DEFINES_MODULE" => "YES",
     "SWIFT_VERSION" => "5.0",
+    "SWIFT_COMPILATION_MODE" => "wholemodule",
+    "SWIFT_INSTALL_OBJC_HEADER" => "YES",
+    "SWIFT_OBJC_INTERFACE_HEADER_NAME" => "BrickModule-Swift.h",
     "OTHER_SWIFT_FLAGS" => "-enable-experimental-feature AccessLevelOnImport"
   }
 
@@ -36,22 +39,17 @@ Pod::Spec.new do |s|
   else
     s.dependency "React-Core"
 
-    # Don't install the dependencies when we run `pod install` in the old architecture.
-    if ENV["RCT_NEW_ARCH_ENABLED"] == "1" then
       s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
       s.pod_target_xcconfig = base_config.merge({
           "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
           "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
           "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
       })
-      s.dependency 'React' 
+      
       s.dependency "React-Codegen"
       s.dependency "RCT-Folly"
       s.dependency "RCTRequired"
       s.dependency "RCTTypeSafety"
       s.dependency "ReactCommon/turbomodule/core"
-    else
-      s.pod_target_xcconfig = base_config
-    end
-  end    
-end
+  end
+end

package/android/brick_modules.gradle

@@ -43,6 +43,89 @@ ext.readPackageJson = { File packageJsonFile ->
     }
 }
 
+ext.findBrickJson = { startDir ->
+    // Walk up the directory tree looking for brick.json
+    if (!startDir) {
+        return null
+    }
+    
+    try {
+        // startDir can be either a File or String, handle both
+        def current = startDir instanceof File ? startDir.canonicalFile : new File(startDir).canonicalFile
+        def root = new File('/').canonicalFile
+        
+        while (current != root && current != null) {
+            def brickJsonFile = new File(current, 'brick.json')
+            if (brickJsonFile.exists()) {
+                return brickJsonFile
+            }
+            def parent = current.parentFile
+            if (parent == current || parent == null) break  // Reached filesystem root
+            current = parent
+        }
+    } catch (Exception e) {
+        // Failed to process directory, return null
+    }
+    
+    return null
+}
+
+ext.resolveProjectRoot = { projectRootPath, configDir ->
+    // Handle both absolute and relative paths
+    if (!projectRootPath || !configDir) {
+        return null
+    }
+    
+    try {
+        def projectRootFile = new File(projectRootPath)
+        if (projectRootFile.isAbsolute()) {
+            return projectRootFile.exists() ? projectRootFile : null
+        } else {
+            // Relative to brick.json location
+            def resolvedFile = new File(configDir, projectRootPath).canonicalFile
+            return resolvedFile.exists() ? resolvedFile : null
+        }
+    } catch (Exception e) {
+        return null
+    }
+}
+
+ext.getBrickAndroidPath = { searchRoot ->
+    // Walk up directory tree to find brick.json
+    def brickConfigFile = findBrickJson(searchRoot)
+    
+    if (brickConfigFile && brickConfigFile.exists()) {
+        try {
+            def config = new JsonSlurper().parse(brickConfigFile)
+            
+            // Get the effective project root
+            def effectiveRoot = brickConfigFile.parentFile
+            if (config.projectRoot) {
+                def resolvedRoot = resolveProjectRoot(config.projectRoot, brickConfigFile.parentFile)
+                if (resolvedRoot) {
+                    effectiveRoot = resolvedRoot
+                }
+            }
+            
+            def androidPath = config?.output?.android
+            if (androidPath && !androidPath.isEmpty()) {
+                // Handle absolute paths (though not recommended)
+                if (new File(androidPath).isAbsolute()) {
+                    println("[Brick] Warning: Using absolute path for Android output is not recommended: ${androidPath}")
+                    return androidPath
+                }
+                // Otherwise, treat as relative to effective project root
+                return new File(effectiveRoot, androidPath).canonicalPath
+            }
+        } catch (Exception e) {
+            println("[Brick] Warning: Failed to parse brick.json: ${e.message}")
+        }
+    }
+    
+    // Default: .brick directory in the Android project root
+    return new File(searchRoot, '.brick').canonicalPath
+}
+
 ext.getAllDependencies = { packageJson ->
     def deps = []
     deps.addAll(packageJson.dependencies?.keySet() ?: [])
@@ -54,6 +137,44 @@ ext.isBrickModule = { packageJson ->
     return packageJson?.brickModule != null
 }
 
+ext.findProjectRoot = { androidDir ->
+    // 1. Walk up directory tree to find brick.json
+    def brickConfigFile = findBrickJson(androidDir)
+    if (brickConfigFile) {
+        brickLog("Found brick.json at: ${brickConfigFile.canonicalPath}")
+        try {
+            def config = new JsonSlurper().parse(brickConfigFile)
+            if (config.projectRoot) {
+                def projectRoot = resolveProjectRoot(config.projectRoot, brickConfigFile.parentFile)
+                if (projectRoot) {
+                    brickLog("Using projectRoot from brick.json: ${projectRoot.canonicalPath}")
+                    return projectRoot
+                }
+            }
+            // If brick.json exists but has no projectRoot, use its directory as project root
+            return brickConfigFile.parentFile
+        } catch (Exception e) {
+            println("[Brick] Warning: Failed to parse brick.json: ${e.message}")
+        }
+    }
+    
+    // 2. Walk up to find package.json with node_modules
+    def current = androidDir
+    while (current != null && current != new File('/')) {
+        if (new File(current, 'package.json').exists() && new File(current, 'node_modules').exists()) {
+            brickLog("Found project root via package.json: ${current.canonicalPath}")
+            return current
+        }
+        def parent = current.parentFile
+        if (parent == current) break
+        current = parent
+    }
+    
+    // If no project root found, use default fallback
+    brickLog("Warning: Failed to find project root via brick.json or package.json. Using default: ${androidDir.parentFile.canonicalPath}")
+    return androidDir.parentFile
+}
+
 ext.runBrickCodegen = { workingDir ->
     def brickModuleDir = resolveModule(workingDir, "brick-module")
     if (brickModuleDir == null) {
@@ -82,7 +203,7 @@ ext.runBrickCodegen = { workingDir ->
 // =============================================================================
 
 ext.applyBrickModules = { settings ->
-    def projectRoot = settings.rootDir.parentFile
+    def projectRoot = findProjectRoot(settings.rootDir)
     def foundModules = []
     def brickModulesData = [:]
     
@@ -144,15 +265,16 @@ ext.applyBrickModules = { settings ->
         }
     }
     
-    // Check if codegen is needed
-    def brickDir = new File(settings.rootDir, ".brick")
+    // Check if codegen is needed (use configured path)
+    def androidBrickPath = getBrickAndroidPath(settings.rootDir)
+    def brickDir = new File(androidBrickPath)
     def needsCodegen = !brickDir.exists() || !new File(brickDir, "src/main/kotlin/BrickModule.kt").exists()
     
     if (needsCodegen) {
         runBrickCodegen(projectRoot)
     }
     
-    // Include generated module
+    // Include generated module (use configured path)
     if (brickDir.exists()) {
         settings.include(":brick-codegen")
         settings.project(":brick-codegen").projectDir = brickDir

package/android/build.gradle

@@ -65,7 +65,6 @@ android {
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
     consumerProguardFiles 'proguard-rules.pro'
     buildConfigField "long", "BUILD_TIMESTAMP", "${System.currentTimeMillis()}L"
   }

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

@@ -39,8 +39,7 @@ class BrickModulePackage : TurboReactPackage() {
                     val currentClassLoader = Thread.currentThread().contextClassLoader
                     val generatedClass =
                             Class.forName("com.brickmodule.BrickModule", true, currentClassLoader)
-                    val constructor =
-                            generatedClass.getConstructor(ReactContext::class.java)
+                    val constructor = generatedClass.getConstructor(ReactContext::class.java)
                     val instance = constructor.newInstance(reactContext) as NativeModule
                     println(
                             "✅ BrickModule successfully created with thread classloader: ${instance.javaClass.name}"
@@ -68,7 +67,7 @@ class BrickModulePackage : TurboReactPackage() {
         println("🔍 BrickModulePackage.getReactModuleInfoProvider called")
         val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
         // Force TurboModule to true since we're using NativeBrickModuleSpec
-        val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+        val isTurboModule: Boolean = true
         moduleInfos["BrickModule"] =
                 ReactModuleInfo(
                         "BrickModule",

package/dist/BrickModule.js

@@ -82,6 +82,10 @@ const BrickModule = {
 	getRegisteredModules,
 	clearCache
 };
+/**
+* Default export for convenience
+*/
+var BrickModule_default = BrickModule;
 
 //#endregion
-export { BrickModule as default };
+export { BrickModule_default as default };

package/dist/index.js

@@ -1,11 +1,11 @@
-import BrickModule from "./BrickModule.js";
+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) {
+	constructor(message, code = "BRICK_ERROR", moduleName, methodName) {
 		super(message);
 		this.code = code;
 		this.moduleName = moduleName;
@@ -15,4 +15,4 @@ var BrickModuleError = class extends Error {
 };
 
 //#endregion
-export { BrickModule, BrickModuleError };
+export { BrickModule_default as BrickModule, BrickModuleError };

package/ios/BrickModule/{Internal/BrickCoreModule.swift → BrickCoreModule.swift}

@@ -1,18 +1,39 @@
 import Foundation
+import React
 
-@objc public protocol BrickModuleRegistableViewControllerType {
-    @objc var moduleRegistry: BrickModuleRegistry? { get }
-}
 /**
- * Minimal protocol that all Brick modules must implement
- * Contains only essential properties for module identification
+ * Base class for all Brick modules
+ * Provides common functionality including event emission
  */
-public protocol BrickModuleBase {
+open class BrickModuleBase: NSObject {
     /// The name of the module (required for registration)
-    var moduleName: String { get }
-    var controller: BrickModuleRegistableViewControllerType { get set }
+    public let moduleName: String
+    
+    public weak var eventEmitter: RCTEventEmitter?
+    public weak var bridgeProxy: RCTBridgeProxy?
+    
+    /// Initialize with module name
+    public init(moduleName: String) {
+        self.moduleName = moduleName
+        super.init()
+    }
     
-    init (controller: BrickModuleRegistableViewControllerType)
+    /// 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: [String: 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)")
+        }
+    }
 }
 
 /**

package/ios/BrickModule/BrickModuleRegistrable.swift

@@ -0,0 +1,26 @@
+//
+//  BrickModuleRegistrable.swift
+//  BrickModule
+//
+//  Protocol for BrickModule registration - Swift-style naming convention
+//
+
+import UIKit
+import React
+
+/// Protocol for BrickModule registration and management
+/// This matches Android's BrickModuleRegistrar interface with Swift naming conventions
+public protocol BrickModuleRegistrable {
+    
+    // MARK: - Module Registry Management
+    
+    /// Module registry - property instead of getter method
+    /// This registry manages all registered BrickModules
+    var moduleRegistry: BrickModuleRegistry { get }
+
+    /// Register modules when bridge is ready - using 'on' parameter label
+    /// Called after didInitializeBridge to register BrickModules
+    func registerModules()
+
+    
+}

package/ios/BrickModule/BrickModuleRegistrableViewControllerType.swift

@@ -0,0 +1,5 @@
+import UIKit
+
+public protocol BrickModuleRegistrableViewController: AnyObject {
+    var moduleRegistry: BrickModuleRegistry { get }
+}

package/ios/BrickModule/{Internal/BrickModuleRegistry.swift → BrickModuleRegistry.swift}

@@ -1,15 +1,17 @@
 import Foundation
 import React
 
+
 /**
  * Central registry for all Brick modules
  * Manages module lifecycle and provides simple module storage
  */
 @objc public class BrickModuleRegistry: NSObject {
     
-    private var modules: [String: Any] = [:]
+    private var modules: [String: BrickModuleBase] = [:]
     private var isRegistered: Bool = false
-    public weak var eventEmitter: RCTEventEmitter?
+    private weak var eventEmitter: RCTEventEmitter?
+    private weak var bridgeProxy: RCTBridgeProxy?;
     
     public override init() {
         super.init()
@@ -23,9 +25,8 @@ import React
      * 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
+        if isRegistered {
+            print("♻️ BrickModuleRegistry: Re-registering modules. Existing modules may be overwritten.")
         }
         
         for module in modules {
@@ -34,10 +35,6 @@ import React
         
         isRegistered = true
         print("✅ BrickModuleRegistry: Successfully registered \(self.modules.count) modules")
-
-        if ProcessInfo.processInfo.environment["GRANITE_DEBUG"] == "1" {
-            debugPrintRegisteredModules()
-        }
     }
     
     /**
@@ -49,7 +46,7 @@ import React
     public func registerModules(_ modules: NSArray) {
         let brickModules = modules.compactMap { $0 as? BrickModuleBase }
         register(brickModules)
-        }
+    }
     
     private func registerSingleModule(_ module: BrickModuleBase) {
         let moduleName = module.moduleName
@@ -60,14 +57,10 @@ import React
             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
+        modules[moduleName]?.eventEmitter = self.eventEmitter;
+        modules[moduleName]?.bridgeProxy = self.bridgeProxy;
         print("📦 BrickModuleRegistry: Registered module '\(moduleName)'")
     }
     
@@ -81,6 +74,14 @@ import React
         return modules[moduleName]
     }
     
+    
+    public func setBridge(_ bridge: Any) {
+        self.bridgeProxy = bridge as? RCTBridgeProxy;
+        for module in modules {
+            module.value.bridgeProxy = self.bridgeProxy;
+        }
+    }
+    
     /**
      * Returns list of registered module names
      */
@@ -92,11 +93,13 @@ import React
     
     /**
      * Sets the React Native event emitter instance for event emission
-     * This should be called during app initialization from the main BrickModule
+     * This should be called during app initialization frBrickModuleom the main BrickModule
      */
-    @objc public func setEventEmitter(_ eventEmitter: RCTEventEmitter) {
-        self.eventEmitter = eventEmitter
-        print("📡 BrickModuleRegistry: Event emitter connected for event emission")
+    public func setEventEmitter(_ eventEmitter: Any) {
+        self.eventEmitter = eventEmitter as? RCTEventEmitter
+        for module in modules {
+            module.value.eventEmitter = self.eventEmitter
+        }
     }
     
     /**
@@ -106,36 +109,24 @@ import React
     @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))")
-        }
+    /**
+     * Unregisters all modules and clears their registry references
+     */
+    @objc public func unregister() {
+        modules.removeAll()
+        isRegistered = false
     }
     
     /**
      * 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")
+        unregister()
     }
 }
 
 public class ModuleRegistry {
     
 }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brick-module",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Better React Native native module development",
   "type": "module",
   "main": "dist/index.js",
@@ -16,8 +16,19 @@
   },
   "files": [
     "dist/",
-    "ios/",
-    "android/",
+    "ios",
+    "android",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*",
     "src/",
     "bin/",
     "BrickModule.podspec",
@@ -51,7 +62,7 @@
     "brick-codegen": "./bin/brick-codegen.js"
   },
   "dependencies": {
-    "brick-codegen": "0.1.5"
+    "brick-codegen": "0.1.7"
   },
   "peerDependencies": {
     "react": ">=18.2.0",

package/podfile_helper.rb

@@ -6,14 +6,82 @@
 require 'json'
 require 'pathname'
 
+def find_brick_json(start_dir)
+  # Walk up the directory tree looking for brick.json
+  current = File.expand_path(start_dir)
+  root = File.expand_path('/')
+  
+  while current != root
+    brick_json_path = File.join(current, 'brick.json')
+    if File.exist?(brick_json_path)
+      return brick_json_path
+    end
+    parent = File.dirname(current)
+    break if parent == current  # Reached filesystem root
+    current = parent
+  end
+  
+  return nil
+end
+
+def find_project_root
+  ios_root = Pod::Config.instance.installation_root
+  
+  # 1. Walk up directory tree to find brick.json
+  brick_json_path = find_brick_json(ios_root)
+  if brick_json_path
+    Pod::UI.puts "[Brick] Found brick.json at: #{brick_json_path}"
+    begin
+      config = JSON.parse(File.read(brick_json_path))
+      if config['projectRoot']
+        project_root = resolve_project_root(config['projectRoot'], File.dirname(brick_json_path))
+        if project_root
+          Pod::UI.puts "[Brick] Using projectRoot from brick.json: #{project_root}"
+          return project_root
+        end
+      end
+      # If brick.json exists but has no projectRoot, use its directory as project root
+      return File.dirname(brick_json_path)
+    rescue => e
+      Pod::UI.warn "[Brick] Failed to parse brick.json: #{e.message}"
+    end
+  end
+  
+  # 2. Walk up to find package.json with node_modules
+  current = ios_root
+  while current != '/'
+    if File.exist?(File.join(current, 'package.json')) && File.exist?(File.join(current, 'node_modules'))
+      Pod::UI.puts "[Brick] Found project root via package.json: #{current}"
+      return current
+    end
+    parent = File.dirname(current)
+    break if parent == current
+    current = parent
+  end
+  
+  # If no project root found, use default fallback
+  default_root = File.expand_path(File.join(ios_root, '..'))
+  Pod::UI.warn "[Brick] Warning: Failed to find project root via brick.json or package.json. Using default: #{default_root}"
+  return default_root
+end
+
+def resolve_project_root(project_root_path, config_dir)
+  # Handle both absolute and relative paths
+  if Pathname.new(project_root_path).absolute?
+    return project_root_path if File.exist?(project_root_path)
+  else
+    # Relative to brick.json location
+    resolved_path = File.expand_path(File.join(config_dir, project_root_path))
+    return resolved_path if File.exist?(resolved_path)
+  end
+  return nil
+end
+
 def use_brick_modules!
-  brick_root = "#{Pod::Config.instance.installation_root}/.."
+  brick_root = find_project_root
   discovered_modules = []
   
   begin
-    # Discover Brick modules before running codegen
-    discovered_modules = discover_brick_modules(brick_root)
-    
     # Run brick-codegen with real-time output and colors (iOS only)
     exit_status = system("cd #{brick_root} && FORCE_COLOR=1 npx brick-codegen --platform ios")
     
@@ -21,9 +89,18 @@ def use_brick_modules!
       # Generate BrickModuleProvider.swift for auto-registration
       generate_brick_module_provider(brick_root, discovered_modules)
       
+      # Get iOS output path from brick.json if it exists
+      ios_brick_path = get_brick_ios_path(brick_root)
+      
+      # Handle relative vs absolute paths
+      if Pathname.new(ios_brick_path).absolute?
+        brick_codegen_pod_path = ios_brick_path
+      else
+        brick_codegen_pod_path = File.expand_path(File.join(brick_root, ios_brick_path))
+      end
+      
       # Add generated BrickCodegen pod if it exists
-      brick_codegen_podspec_path = "#{brick_root}/ios/.brick/BrickCodegen.podspec"
-      brick_codegen_pod_path = "#{brick_root}/ios/.brick"
+      brick_codegen_podspec_path = File.join(brick_codegen_pod_path, "BrickCodegen.podspec")
       
       if File.exist?(brick_codegen_podspec_path)
         begin
@@ -98,11 +175,48 @@ def discover_brick_modules(project_root)
   modules
 end
 
+def get_brick_ios_path(project_root)
+  # Walk up from project_root to find brick.json
+  brick_config_path = find_brick_json(project_root)
+  
+  if brick_config_path && File.exist?(brick_config_path)
+    begin
+      config = JSON.parse(File.read(brick_config_path))
+      
+      ios_path = config.dig('output', 'ios')
+      if ios_path && !ios_path.empty?
+        # Handle absolute paths (though not recommended)
+        if Pathname.new(ios_path).absolute?
+          Pod::UI.warn "[Brick] Using absolute path for iOS output is not recommended: #{ios_path}"
+          return ios_path
+        else
+          # Relative to brick.json location, not project root
+          return File.expand_path(File.join(File.dirname(brick_config_path), ios_path))
+        end
+      end
+    rescue => e
+      Pod::UI.warn "[Brick] Failed to parse brick.json: #{e.message}"
+    end
+  end
+  
+  # Return default path - just the relative path, caller will resolve it
+  return 'ios/.brick'
+end
+
 def generate_brick_module_provider(project_root, modules)
   return if modules.empty?
   
-  # Create the .brick directory if it doesn't exist
-  brick_dir = File.join(project_root, 'ios', '.brick')
+  # Get iOS output path from brick.json
+  ios_brick_path = get_brick_ios_path(project_root)
+  
+  # Handle relative vs absolute paths
+  if Pathname.new(ios_brick_path).absolute?
+    brick_dir = ios_brick_path
+  else
+    brick_dir = File.expand_path(File.join(project_root, ios_brick_path))
+  end
+  
+  # Create the brick directory if it doesn't exist
   FileUtils.mkdir_p(brick_dir) unless File.exist?(brick_dir)
   
   # Generate imports and module instances