brick-module 0.1.7 → 0.1.9

package/android/brick_modules.gradle

@@ -43,87 +43,29 @@ 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
-}
+// Removed discovery helpers; explicit appPath is required
 
-ext.resolveProjectRoot = { projectRootPath, configDir ->
-    // Handle both absolute and relative paths
-    if (!projectRootPath || !configDir) {
-        return null
-    }
-    
+ext.getBrickAndroidPath = { projectRoot ->
+    // Read brick.json from explicit project root
     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 brickConfigFile = new File(projectRoot, 'brick.json')
+        if (brickConfigFile.exists()) {
             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
+                return new File(projectRoot, androidPath).canonicalPath
             }
-        } catch (Exception e) {
-            println("[Brick] Warning: Failed to parse brick.json: ${e.message}")
         }
+    } catch (Exception e) {
+        println("[Brick] Warning: Failed to read brick.json from ${projectRoot}: ${e.message}")
     }
     
-    // Default: .brick directory in the Android project root
-    return new File(searchRoot, '.brick').canonicalPath
+    // Default: android/.brick in project root
+    return new File(projectRoot, 'android/.brick').canonicalPath
 }
 
 ext.getAllDependencies = { packageJson ->
@@ -137,44 +79,6 @@ 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) {
@@ -189,7 +93,8 @@ ext.runBrickCodegen = { workingDir ->
     }
     
     try {
-        def proc = ['node', codegenPath.absolutePath, '--platform', 'android'].execute(null, workingDir)
+        def wdPath = (workingDir instanceof File) ? workingDir.absolutePath : workingDir
+        def proc = ['node', codegenPath.absolutePath, '--platform', 'android', '--projectRoot', wdPath].execute(null, workingDir)
         proc.waitFor()
         return proc.exitValue() == 0
     } catch (Exception e) {
@@ -202,13 +107,26 @@ ext.runBrickCodegen = { workingDir ->
 // Main Configuration
 // =============================================================================
 
-ext.applyBrickModules = { settings ->
-    def projectRoot = findProjectRoot(settings.rootDir)
+ext.applyBrickModules = { settings, args = [:] ->
+    def appPath = (args instanceof Map) ? args.appPath : args
+    if (!appPath) {
+        throw new GradleException("Brick: appPath is required. Call applyBrickModules(settings, [appPath: '/absolute/path/to/app'])")
+    }
+    // Support relative appPath (relative to settings.rootDir)
+    def appPathFile = new File(appPath.toString())
+    def projectRoot = (appPathFile.isAbsolute() ? appPathFile : new File(settings.rootDir, appPathFile.path)).canonicalFile
+
+    // Validate package.json exists in appPath
+    def packageJsonFile = new File(projectRoot, 'package.json')
+    if (!packageJsonFile.exists()) {
+        throw new GradleException("Brick: package.json not found at ${projectRoot}. Please pass a valid appPath.")
+    }
+
     def foundModules = []
     def brickModulesData = [:]
     
     // Read app's package.json
-    def appPackageJson = readPackageJson(new File(projectRoot, "package.json"))
+    def appPackageJson = readPackageJson(packageJsonFile)
     if (appPackageJson == null) {
         throw new GradleException("Could not find or parse package.json at ${projectRoot}")
     }
@@ -266,7 +184,7 @@ ext.applyBrickModules = { settings ->
     }
     
     // Check if codegen is needed (use configured path)
-    def androidBrickPath = getBrickAndroidPath(settings.rootDir)
+    def androidBrickPath = getBrickAndroidPath(projectRoot)
     def brickDir = new File(androidBrickPath)
     def needsCodegen = !brickDir.exists() || !new File(brickDir, "src/main/kotlin/BrickModule.kt").exists()
     
@@ -309,7 +227,7 @@ def configureAppProject(gradle) {
 def configureBrickModules(project) {
     def rootProject = project.rootProject
     def brickModulesData = rootProject.ext.brickModulesData
-    def projectRoot = project.rootDir.parentFile
+    def projectRoot = rootProject.ext.brickProjectRoot
     
     // Add source directory for generated code
     project.android.sourceSets.main.java.srcDir "${project.buildDir}/generated/source/brick-provider"
@@ -341,7 +259,7 @@ def configureBrickModules(project) {
                     def codegenPath = new File(brickModuleDir, "bin/brick-codegen.js")
                     
                     if (codegenPath.exists()) {
-                        def codegenProc = ['node', codegenPath.absolutePath, '--platform', 'android'].execute(null, workingDir)
+                        def codegenProc = ['node', codegenPath.absolutePath, '--platform', 'android', '--projectRoot', workingDir.absolutePath].execute(null, workingDir)
                         codegenProc.waitFor()
                     }
                 }

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

@@ -14,7 +14,7 @@ class BrickModuleRegistry {
     private var isRegistered: Boolean = false
 
     /**
-     * Registers an array of Brick modules Each module must implement their respective TypeModule
+     * Registers an array of Brick modules Each module must implement their respective Spec
      * interface
      *
      * @param modules List of module instances to register
@@ -50,7 +50,7 @@ class BrickModuleRegistry {
         // Register or update the module
         val isUpdate = modules.containsKey(moduleName)
         modules[moduleName] = module
-        
+
         if (isUpdate) {
             println("🔄 BrickModuleRegistry: Module '$moduleName' updated (replaced existing)")
         } else {

package/ios/BrickModule/BrickModuleRegistry.swift

@@ -21,7 +21,7 @@ import React
     
     /**
      * Registers an array of Brick modules (Swift API)
-     * Each module must implement BrickModuleBase and its respective TypeModule protocol
+     * Each module must implement BrickModuleBase and its respective Spec protocol
      * This should be called once during app initialization
      */
     public func register(_ modules: [BrickModuleBase]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brick-module",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Better React Native native module development",
   "type": "module",
   "main": "dist/index.js",
@@ -62,7 +62,7 @@
     "brick-codegen": "./bin/brick-codegen.js"
   },
   "dependencies": {
-    "brick-codegen": "0.1.7"
+    "brick-codegen": "0.1.9"
   },
   "peerDependencies": {
     "react": ">=18.2.0",
@@ -71,7 +71,7 @@
   "devDependencies": {
     "@types/react": "^18.2.0",
     "@types/react-native": "^0.72.0",
-    "tsdown": "^0.14.0",
+    "tsdown": "^0.14.2",
     "typescript": "^5.9.2"
   },
   "codegenConfig": {

package/podfile_helper.rb

@@ -6,89 +6,24 @@
 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
+def use_brick_modules!(app_path: nil)
+  if app_path.nil? || app_path.empty?
+    raise "[Brick] app_path is required. Call use_brick_modules!(app_path: '<path to your app root>')"
   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
+  brick_root = app_path
 
-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)
+  # Validate package.json exists in app_path
+  package_json_path = File.join(brick_root, 'package.json')
+  unless File.exist?(package_json_path)
+    raise "[Brick] package.json not found at #{brick_root}. Please pass a valid app_path."
   end
-  return nil
-end
-
-def use_brick_modules!
-  brick_root = find_project_root
-  discovered_modules = []
   
   begin
     # 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")
+    exit_status = system("cd #{brick_root} && FORCE_COLOR=1 npx brick-codegen --platform ios --projectRoot \"#{brick_root}\"")
     
     if exit_status
-      # 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)
       
@@ -117,81 +52,21 @@ def use_brick_modules!
   end
 end
 
-def discover_brick_modules(project_root)
-  modules = []
-  node_modules_path = File.join(project_root, 'node_modules')
-  
-  return modules unless File.exist?(node_modules_path)
-  
-  # Read the main package.json to get dependencies
-  package_json_path = File.join(project_root, 'package.json')
-  return modules unless File.exist?(package_json_path)
-  
-  begin
-    package_json = JSON.parse(File.read(package_json_path))
-    dependencies = (package_json['dependencies'] || {}).merge(package_json['devDependencies'] || {})
-    
-    dependencies.each do |dep_name, _version|
-      dep_path = File.join(node_modules_path, dep_name)
-      dep_package_json_path = File.join(dep_path, 'package.json')
-      
-      next unless File.exist?(dep_package_json_path)
-      
-      begin
-        dep_package_json = JSON.parse(File.read(dep_package_json_path))
-        
-        # Check if this is a Brick module
-        if dep_package_json['brickModule']
-          brick_config = dep_package_json['brickModule']
-          ios_config = brick_config['ios'] || {}
-          
-          # Check if autoRegister is enabled (default: true)
-          auto_register = brick_config['autoRegister'] != false
-          
-          if auto_register
-            # Extract the iOS module name and class name
-            module_name = ios_config['moduleName']
-            class_name = ios_config['className']
-            
-            modules << {
-              'name' => dep_name,
-              'moduleName' => module_name,
-              'className' => class_name,
-            }
-            
-            Pod::UI.puts "[Brick] Found module: #{dep_name} (#{module_name})"
-          else
-            Pod::UI.puts "[Brick] Skipping module (autoRegister=false): #{dep_name}"
-          end
-        end
-      rescue => e
-        Pod::UI.warn "[Brick] Failed to parse #{dep_package_json_path}: #{e.message}"
-      end
-    end
-  rescue => e
-    Pod::UI.warn "[Brick] Failed to discover modules: #{e.message}"
-  end
-  
-  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)
+  # Read brick.json from the explicit project root
+  brick_config_path = File.join(project_root, 'brick.json')
   
-  if brick_config_path && File.exist?(brick_config_path)
+  if 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))
+          return File.expand_path(File.join(project_root, ios_path))
         end
       end
     rescue => e
@@ -199,99 +74,5 @@ def get_brick_ios_path(project_root)
     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?
-  
-  # 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
-  imports = modules.map { |m| "import #{m['moduleName']}" }.join("\n")
-  module_instances = modules.map { |m| "            #{m['className']}()" }.join(",\n")
-  module_names = modules.map { |m| "            \"#{m['moduleName']}\"" }.join(",\n")
-  
-  # Generate the Swift file content
-  swift_content = <<-SWIFT
-// Auto-generated by brick-module podfile_helper.rb
-// Do not edit manually - this file is regenerated on each pod install
-
-import Foundation
-import BrickModule
-#{imports}
-
-@objcMembers
-public class BrickModuleProvider: NSObject {
-    @objc public static func registerAll() {
-        let modules: [BrickModuleBase] = [
-#{module_instances}
-        ]
-        
-        if !modules.isEmpty {
-            BrickModuleRegistry.shared.register(modules)
-            print("🧱 BrickModuleProvider: Registered \\(modules.count) modules")
-        }
-    }
-    
-    @objc public static func getAvailableModules() -> [String] {
-        return [
-#{module_names}
-        ]
-    }
-}
-SWIFT
-  
-  # Write the Swift file
-  provider_path = File.join(brick_dir, 'BrickModuleProvider.swift')
-  File.write(provider_path, swift_content)
-  
-  # Generate simple Objective-C wrapper with clean name
-  objc_header_content = <<-OBJC
-// Auto-generated by brick-module podfile_helper.rb
-// Simple Objective-C wrapper for auto-linking
-
-#import <Foundation/Foundation.h>
-
-@interface BrickModuleProviderObjC : NSObject
-+ (void)registerAll;
-@end
-OBJC
-
-  objc_impl_content = <<-OBJC
-// Auto-generated by brick-module podfile_helper.rb
-// Simple Objective-C wrapper implementation
-
-#import "BrickModuleProviderObjC.h"
-#import "BrickCodegen-Swift.h"
-
-@implementation BrickModuleProviderObjC
-
-+ (void)registerAll {
-    [BrickModuleProvider registerAll];
-}
-
-@end
-OBJC
-  
-  # Write Objective-C wrapper files
-  objc_header_path = File.join(brick_dir, 'BrickModuleProviderObjC.h')
-  objc_impl_path = File.join(brick_dir, 'BrickModuleProviderObjC.m')
-  File.write(objc_header_path, objc_header_content)
-  File.write(objc_impl_path, objc_impl_content)
-  
-  Pod::UI.puts "[Brick] Generated BrickModuleProvider.swift with #{modules.size} modules"
-  Pod::UI.puts "[Brick] Generated BrickModuleProviderObjC wrapper for clean Objective-C integration"
+  return File.expand_path(File.join(project_root, 'ios/.brick'))
 end