brick-module 0.1.1

package/BrickModule.podspec

@@ -0,0 +1,56 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "BrickModule"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => '13.0' }
+  s.source       = { :git => "https://github.com/toss/brick.git", :tag => "#{s.version}" }
+  s.source_files  = "ios/**/*.{h,m,mm,swift}"
+  s.public_header_files = "ios/BrickModule/Public/*.h"
+  s.private_header_files = "ios/BrickModule/Internal/*.h"
+  
+  # Swift 설정
+  s.swift_version = "5.0"
+  s.requires_arc = true
+
+  # Base configuration
+  base_config = {
+    "DEFINES_MODULE" => "YES",
+    "SWIFT_VERSION" => "5.0",
+    "OTHER_SWIFT_FLAGS" => "-enable-experimental-feature AccessLevelOnImport"
+  }
+
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+    s.pod_target_xcconfig = base_config
+  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-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

package/android/brick_modules.gradle

@@ -0,0 +1,280 @@
+/*
+ * Brick Modules Gradle Configuration
+ * This file provides automatic configuration for brick modules in React Native projects.
+ * 
+ * Usage: Add to settings.gradle only:
+ * apply from: file("../node_modules/brick-module/android/brick_modules.gradle")
+ * applyBrickModules(settings)
+ */
+
+import groovy.json.JsonSlurper
+
+// =============================================================================
+// Utility Functions - Store as ext properties for global access
+// =============================================================================
+
+ext.brickLog = { message ->
+    println("🧱 BrickModules: $message")
+}
+
+ext.resolveModule = { workingDir, moduleName ->
+    try {
+        def proc = ['node', '-p', "require.resolve('${moduleName}/package.json')"].execute(null, workingDir)
+        proc.waitFor()
+        
+        if (proc.exitValue() == 0) {
+            def packageJsonPath = proc.text.trim()
+            if (packageJsonPath && !packageJsonPath.isEmpty()) {
+                return new File(packageJsonPath).parentFile
+            }
+        }
+    } catch (Exception e) {
+        // Silent fail - module not found
+    }
+    return null
+}
+
+ext.readPackageJson = { File packageJsonFile ->
+    if (!packageJsonFile.exists()) return null
+    try {
+        return new JsonSlurper().parse(packageJsonFile)
+    } catch (Exception e) {
+        return null
+    }
+}
+
+ext.getAllDependencies = { packageJson ->
+    def deps = []
+    deps.addAll(packageJson.dependencies?.keySet() ?: [])
+    deps.addAll(packageJson.devDependencies?.keySet() ?: [])
+    return deps
+}
+
+ext.isBrickModule = { packageJson ->
+    return packageJson?.brickModule != null
+}
+
+ext.runBrickCodegen = { workingDir ->
+    def brickModuleDir = resolveModule(workingDir, "brick-module")
+    if (brickModuleDir == null) {
+        brickLog("brick-module not found, skipping code generation")
+        return false
+    }
+    
+    def codegenPath = new File(brickModuleDir, "bin/brick-codegen.js")
+    if (!codegenPath.exists()) {
+        brickLog("brick-codegen not found at ${codegenPath}")
+        return false
+    }
+    
+    try {
+        def proc = ['node', codegenPath.absolutePath, '--platform', 'android'].execute(null, workingDir)
+        proc.waitFor()
+        return proc.exitValue() == 0
+    } catch (Exception e) {
+        brickLog("Failed to run brick-codegen: ${e.message}")
+        return false
+    }
+}
+
+// =============================================================================
+// Main Configuration
+// =============================================================================
+
+ext.applyBrickModules = { settings ->
+    def projectRoot = settings.rootDir.parentFile
+    def foundModules = []
+    def brickModulesData = [:]
+    
+    // Read app's package.json
+    def appPackageJson = readPackageJson(new File(projectRoot, "package.json"))
+    if (appPackageJson == null) {
+        throw new GradleException("Could not find or parse package.json at ${projectRoot}")
+    }
+    
+    // Store app package.json for later use
+    settings.ext.appPackageJson = appPackageJson
+    
+    // Get all dependencies
+    def allDeps = getAllDependencies(appPackageJson)
+    
+    // Always include brick-module if it exists
+    def brickModuleDir = resolveModule(projectRoot, "brick-module")
+    if (brickModuleDir != null) {
+        def androidDir = new File(brickModuleDir, "android")
+        if (androidDir.exists()) {
+            settings.include(":brick-module")
+            settings.project(":brick-module").projectDir = androidDir
+            foundModules.add("brick-module")
+        }
+    }
+    
+    // Scan and include other brick modules
+    allDeps.each { depName ->
+        if (depName == "brick-module") return // Already handled
+        
+        def moduleDir = resolveModule(projectRoot, depName)
+        if (moduleDir == null) return
+        
+        def packageJson = readPackageJson(new File(moduleDir, "package.json"))
+        if (!isBrickModule(packageJson)) return
+        
+        def androidDir = new File(moduleDir, "android")
+        if (androidDir.exists()) {
+            settings.include(":${depName}")
+            settings.project(":${depName}").projectDir = androidDir
+            foundModules.add(depName)
+            
+            // Store module data for project configuration
+            if (packageJson.brickModule.android?.package) {
+                brickModulesData[depName] = [
+                    moduleName: packageJson.brickModule.android.moduleName ?: depName,
+                    packageName: packageJson.brickModule.android.package
+                ]
+            }
+        }
+    }
+    
+    // Check if codegen is needed
+    def brickDir = new File(settings.rootDir, ".brick")
+    def needsCodegen = !brickDir.exists() || !new File(brickDir, "src/main/kotlin/BrickModule.kt").exists()
+    
+    if (needsCodegen) {
+        runBrickCodegen(projectRoot)
+    }
+    
+    // Include generated module
+    if (brickDir.exists()) {
+        settings.include(":brick-generated")
+        settings.project(":brick-generated").projectDir = brickDir
+    }
+    
+    if (!foundModules.isEmpty()) {
+        brickLog("Found modules: ${foundModules.join(', ')}")
+    }
+    
+    // Configure app project after all projects are loaded
+    settings.gradle.projectsLoaded {
+        // Transfer data to root project
+        gradle.rootProject.ext.brickModulesData = brickModulesData
+        gradle.rootProject.ext.brickModulesList = foundModules
+        gradle.rootProject.ext.brickProjectRoot = projectRoot
+        configureAppProject(gradle)
+    }
+}
+
+// Configure the app project
+def configureAppProject(gradle) {
+    gradle.rootProject.subprojects { project ->
+        if (project.name == 'app') {
+            project.afterEvaluate {
+                configureBrickModules(project)
+            }
+        }
+    }
+}
+
+// Configure brick modules for the app project
+def configureBrickModules(project) {
+    def rootProject = project.rootProject
+    def brickModulesData = rootProject.ext.brickModulesData
+    def projectRoot = project.rootDir.parentFile
+    
+    // Add source directory for generated code
+    project.android.sourceSets.main.java.srcDir "${project.buildDir}/generated/source/brick-provider"
+    
+    // Create provider generation task
+    project.tasks.create('generateBrickModuleProvider') {
+        description = 'Generates BrickModuleProvider class for automatic module registration'
+        group = 'brick-module'
+        
+        doLast {
+            generateProvider(project, brickModulesData)
+        }
+    }
+    
+    // Hook into build process
+    project.preBuild.dependsOn('generateBrickModuleProvider')
+    project.preBuild.doFirst {
+        def workingDir = projectRoot
+        
+        // Run codegen inline
+        try {
+            def proc = ['node', '-p', "require.resolve('brick-module/package.json')"].execute(null, workingDir)
+            proc.waitFor()
+            
+            if (proc.exitValue() == 0) {
+                def packageJsonPath = proc.text.trim()
+                if (packageJsonPath && !packageJsonPath.isEmpty()) {
+                    def brickModuleDir = new File(packageJsonPath).parentFile
+                    def codegenPath = new File(brickModuleDir, "bin/brick-codegen.js")
+                    
+                    if (codegenPath.exists()) {
+                        def codegenProc = ['node', codegenPath.absolutePath, '--platform', 'android'].execute(null, workingDir)
+                        codegenProc.waitFor()
+                    }
+                }
+            }
+        } catch (Exception e) {
+            println("🧱 BrickModules: Failed to run brick-codegen: ${e.message}")
+        }
+    }
+    
+    // Add dependencies
+    project.dependencies {
+        // Add brick module dependencies
+        rootProject.subprojects.each { subproject ->
+            if (subproject.name.startsWith('brick-') || brickModulesData.containsKey(subproject.name)) {
+                add('implementation', subproject)
+            }
+        }
+        
+        // Add required Kotlin dependencies
+        add('implementation', "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
+        add('implementation', "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4")
+        add('implementation', "com.google.code.gson:gson:2.8.9")
+    }
+}
+
+// Generate BrickModuleProvider.kt
+def generateProvider(project, brickModulesData) {
+    def modules = brickModulesData.collect { name, data ->
+        [
+            name: data.moduleName,
+            className: data.moduleName + "Module",
+            packageName: data.packageName
+        ]
+    }
+    
+    def outputDir = project.file("${project.buildDir}/generated/source/brick-provider/com/brickmodule")
+    outputDir.mkdirs()
+    
+    def imports = modules.collect { "import ${it.packageName}.${it.className}" }.join("\n")
+    def moduleInstances = modules.collect { "            ${it.name}Module()" }.join(",\n")
+    def moduleNames = modules.collect { "            \"${it.name}\"" }.join(",\n")
+    
+    new File(outputDir, "BrickModuleProvider.kt").text = """// Auto-generated by brick_modules.gradle
+package com.brickmodule
+
+import com.brickmodule.BrickModuleRegistry
+${imports}
+
+object BrickModuleProvider {
+    fun registerAll() {
+        val modules = listOf<Any>(
+${moduleInstances}
+        )
+        
+        if (modules.isNotEmpty()) {
+            BrickModuleRegistry.register(modules)
+            println("🧱 BrickModuleProvider: Registered \${modules.size} modules")
+        }
+    }
+    
+    fun getAvailableModules(): List<String> = listOf(
+${moduleNames}
+    )
+}
+"""
+}
+

package/android/build/generated/source/codegen/jni/CMakeLists.txt

@@ -0,0 +1,14 @@
+# Dummy CMakeLists.txt for React Native autolinking
+# This file is required by React Native's autolinking system
+# The actual TurboModule implementation is handled by brick-codegen in user projects
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+# Create a dummy source file
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp "// Dummy file for BrickModuleSpec\n")
+
+# Create an empty static library to satisfy React Native's build system
+add_library(react_codegen_BrickModuleSpec STATIC ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp)
+
+# Set necessary properties
+target_include_directories(react_codegen_BrickModuleSpec PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

package/android/build.gradle

@@ -0,0 +1,144 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["HotUpdater_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: "$projectDir/react-native-helpers.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["BrickModule_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["BrickModule_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.brickmodule"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifest.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  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"
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  if (project.ext.shouldConsumeReactNativeFromMavenCentral()) {
+    // noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-android:+'
+  } else {
+    // noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-native:+'
+  }
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
+}
+
+// Custom clean task that preserves CMakeLists.txt
+task cleanButPreserveCMakeLists {
+  doFirst {
+    def cmakeFile = file("$buildDir/generated/source/codegen/jni/CMakeLists.txt")
+    def cmakeContent = ""
+    
+    // Save CMakeLists.txt content if it exists
+    if (cmakeFile.exists()) {
+      cmakeContent = cmakeFile.text
+    }
+    
+    // Store in project property for restoration
+    project.ext.savedCMakeContent = cmakeContent
+  }
+}
+
+// Override the clean task to preserve CMakeLists.txt
+clean {
+  dependsOn cleanButPreserveCMakeLists
+  
+  doLast {
+    // Restore CMakeLists.txt after clean
+    if (project.hasProperty('savedCMakeContent') && project.savedCMakeContent) {
+      def cmakeFile = file("$buildDir/generated/source/codegen/jni/CMakeLists.txt")
+      cmakeFile.parentFile.mkdirs()
+      cmakeFile.text = project.savedCMakeContent
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+BrickModule_kotlinVersion=2.0.21
+BrickModule_minSdkVersion=24
+BrickModule_targetSdkVersion=34
+BrickModule_compileSdkVersion=35
+BrickModule_ndkVersion=27.1.12297006

package/android/react-native-helpers.gradle

@@ -0,0 +1,42 @@
+def safeAppExtGet(prop, fallback) {
+  def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+  appProject?.ext?.has(prop) ? appProject.ext.get(prop) : fallback
+}
+
+// Let's detect react-native's directory, it will be used to determine RN's version
+// https://github.com/software-mansion/react-native-reanimated/blob/36c291a15880c78a94dd125c51484630546ceb7c/packages/react-native-reanimated/android/build.gradle#L73
+def resolveReactNativeDirectory() {
+  def reactNativeLocation = safeAppExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+  if (reactNativeLocation != null) {
+    return file(reactNativeLocation)
+  }
+
+  // Fallback to node resolver for custom directory structures like monorepos.
+  def reactNativePackage = file(["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim())
+  if (reactNativePackage.exists()) {
+      return reactNativePackage.parentFile
+  }
+
+  throw new GradleException(
+    "${project.name}: unable to resolve react-native location in " +
+    "node_modules. You should project extension property (in app/build.gradle) " +
+    "`REACT_NATIVE_NODE_MODULES_DIR` with path to react-native."
+  )
+}
+
+// https://github.com/software-mansion/react-native-reanimated/blob/cda4627c3337c33674f05f755b7485165c6caca9/android/build.gradle#L199#L205
+def reactNativeRootDir = resolveReactNativeDirectory()
+
+def reactProperties = new Properties()
+file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
+
+def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
+def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
+
+project.ext.resolveReactNativeDirectory = { ->
+  return resolveReactNativeDirectory()
+}
+
+project.ext.shouldConsumeReactNativeFromMavenCentral = { ->
+  return REACT_NATIVE_MINOR_VERSION >= 71
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.brickmodule">
+</manifest>

package/android/src/main/java/com/brickmodule/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,23 @@
+package com.brickmodule
+
+/**
+ * Minimal interface that all Brick modules must implement
+ * Contains only essential properties for module identification
+ */
+interface BrickModuleBase {
+    /**
+     * The name of the module (required for registration)
+     */
+    val moduleName: String
+}
+
+/**
+ * Error types for Brick modules
+ */
+open class BrickModuleError(message: String, val errorCode: String) : Exception(message) {
+    class TypeMismatch(message: String) : BrickModuleError("Type mismatch: $message", "TYPE_ERROR")
+    class ExecutionError(message: String) : BrickModuleError("Execution error: $message", "EXECUTION_ERROR")
+    class InvalidDefinition(message: String) : BrickModuleError("Invalid definition: $message", "DEFINITION_ERROR")
+    class MethodNotFound(message: String) : BrickModuleError("Method not found: $message", "METHOD_NOT_FOUND")
+    class ModuleNotFound(message: String) : BrickModuleError("Module not found: $message", "MODULE_NOT_FOUND")
+}

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

@@ -0,0 +1,87 @@
+@file:Suppress("DEPRECATION")
+
+package com.brickmodule
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class BrickModulePackage : TurboReactPackage() {
+
+    init {
+        println("🔍 BrickModulePackage initialized")
+    }
+
+    override fun getModule(
+            name: String,
+            reactContext: ReactApplicationContext,
+    ): NativeModule? {
+        println("🔍 BrickModulePackage.getModule called with name: $name")
+        return if (name == "BrickModule") {
+            // Try to find the generated BrickModule class
+            try {
+                // Try with app's class loader first
+                val classLoader = reactContext.applicationContext.classLoader
+                val generatedClass =
+                        Class.forName("com.brickmodule.codegen.BrickModule", true, classLoader)
+                val constructor = generatedClass.getConstructor(ReactApplicationContext::class.java)
+                val instance = constructor.newInstance(reactContext) as NativeModule
+                println("✅ BrickModule successfully created: ${instance.javaClass.name}")
+                println("BrickModule ${instance.javaClass.methods.map { it.name }}")
+                instance
+            } catch (e: ClassNotFoundException) {
+                // Try with current thread class loader as fallback
+                try {
+                    val currentClassLoader = Thread.currentThread().contextClassLoader
+                    val generatedClass =
+                            Class.forName("com.brickmodule.BrickModule", true, currentClassLoader)
+                    val constructor =
+                            generatedClass.getConstructor(ReactApplicationContext::class.java)
+                    val instance = constructor.newInstance(reactContext) as NativeModule
+                    println(
+                            "✅ BrickModule successfully created with thread classloader: ${instance.javaClass.name}"
+                    )
+                    instance
+                } catch (e2: Exception) {
+                    e.printStackTrace()
+                    e2.printStackTrace()
+                    throw RuntimeException(
+                            "BrickModule not found in any classloader. Please run 'brick-codegen' to generate the bridge code. " +
+                                    "The generated BrickModule.kt should be in your app's source directory. " +
+                                    "Original error: ${e.message}, Fallback error: ${e2.message}"
+                    )
+                }
+            } catch (e: Exception) {
+                e.printStackTrace()
+                throw RuntimeException("Failed to create BrickModule instance: ${e.message}", e)
+            }
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+        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
+        moduleInfos["BrickModule"] =
+                ReactModuleInfo(
+                        "BrickModule",
+                        "com.brickmodule.codegen.BrickModule",
+                        false, // canOverrideExistingModule
+                        false, // needsEagerInit
+                        true, // hasConstants
+                        false, // isCxxModule
+                        isTurboModule, // isTurboModule
+                )
+        moduleInfos
+    }
+
+    companion object {
+        const val NAME = "BrickModulePackage"
+    }
+}