brick-module 0.4.0 → 0.5.0

package/android/brick_modules.gradle

@@ -102,7 +102,7 @@ ext.isBrickModule = { packageJson ->
     return packageJson?.brickModule != null
 }
 
-ext.runBrickCodegen = { workingDir ->
+ext.runBrickCodegen = { workingDir, options = [:] ->
     def brickModuleDir = resolveModule(workingDir, "brick-module")
     if (brickModuleDir == null) {
         brickLog("brick-module not found, skipping code generation")
@@ -117,7 +117,18 @@ ext.runBrickCodegen = { workingDir ->
     
     try {
         def wdPath = (workingDir instanceof File) ? workingDir.absolutePath : workingDir
-        def proc = ['node', codegenPath.absolutePath, '--platform', 'android', '--projectRoot', wdPath].execute(null, workingDir)
+        def codegenArgs = [
+            'node',
+            codegenPath.absolutePath,
+            '--platform',
+            'android',
+            '--projectRoot',
+            wdPath
+        ]
+        if (options.noClean == true) {
+            codegenArgs.add('--no-clean')
+        }
+        def proc = codegenArgs.execute(null, workingDir)
         proc.waitFor()
         return proc.exitValue() == 0
     } catch (Exception e) {
@@ -217,10 +228,12 @@ ext.applyBrickModules = { settings, args ->
     def androidBrickPath = getBrickAndroidPath(projectRoot)
     def brickDir = new File(androidBrickPath)
     def needsCodegen = !brickDir.exists() || !new File(brickDir, "src/main/kotlin/BrickModule.kt").exists()
-    
+    def codegenAttempted = false
     if (needsCodegen) {
-        runBrickCodegen(projectRoot)
+        codegenAttempted = true
+        runBrickCodegen(projectRoot, [noClean: true])
     }
+    settings.ext.brickCodegenRan = codegenAttempted
     
     // Include generated module (use configured path)
     if (brickDir.exists()) {
@@ -239,6 +252,8 @@ ext.applyBrickModules = { settings, args ->
         gradle.rootProject.ext.brickModulesList = foundModules
         gradle.rootProject.ext.brickProjectRoot = projectRoot
         gradle.rootProject.ext.brickAppProjectName = appProjectName
+        gradle.rootProject.ext.brickCodegenRanInBuild =
+            settings.ext.has("brickCodegenRan") ? settings.ext.brickCodegenRan : false
         configureAppProject(gradle)
         // Inline: ensure RN autolinking doesn't fail due to missing codegen/jni for brick-module
         gradle.rootProject.subprojects { subproj ->
@@ -418,24 +433,16 @@ ${moduleNames}
     project.preBuild.dependsOn('generateBrickModulesList')
     project.preBuild.doFirst {
         def workingDir = projectRoot
-        
-        // Skip codegen if already generated to prevent deleting Gradle build outputs
-        // The codegen is already run during settings.gradle phase (applyBrickModules -> runBrickCodegen)
-        // Re-running here with --clean would delete .brick_android/build/ directory
-        // which contains package-aware-r.txt needed by dependent modules
-        def brickOutputDir = getBrickAndroidPath(workingDir)
-        def generatedMarker = new File(brickOutputDir, "src/main/kotlin/BrickModule.kt")
-        def androidAppPath = getBrickAndroidAppPath(workingDir)
-        def jniDir = new File(androidAppPath, "build/generated/autolinking/src/main/jni")
-        def hasJniOutputs = new File(jniDir, "BrickModuleSpec-generated.cpp").exists() &&
-            new File(jniDir, "BrickModuleSpec.h").exists() &&
-            new File(jniDir, "CMakeLists.txt").exists()
-        if (generatedMarker.exists() && hasJniOutputs) {
-            // Already generated, skip to preserve build outputs
+
+        def alreadyRan = rootProject.ext.has("brickCodegenRanInBuild") ?
+            rootProject.ext.brickCodegenRanInBuild : false
+        if (alreadyRan) {
+            // Avoid double-running if settings already executed codegen.
             return
         }
+        rootProject.ext.brickCodegenRanInBuild = true
 
-        // Run codegen only if not yet generated
+        // Run codegen once per build without cleaning outputs.
         try {
             def proc = ['node', '-p', "require.resolve('brick-module/package.json')"].execute(null, workingDir)
             proc.waitFor()
@@ -447,10 +454,15 @@ ${moduleNames}
                     def codegenPath = new File(brickModuleDir, "bin/brick-codegen.js")
                     
                     if (codegenPath.exists()) {
-                        def codegenArgs = ['node', codegenPath.absolutePath, '--platform', 'android', '--projectRoot', workingDir.absolutePath]
-                        if (generatedMarker.exists()) {
-                            codegenArgs.add('--no-clean')
-                        }
+                        def codegenArgs = [
+                            'node',
+                            codegenPath.absolutePath,
+                            '--platform',
+                            'android',
+                            '--projectRoot',
+                            workingDir.absolutePath,
+                            '--no-clean'
+                        ]
                         def codegenProc = codegenArgs.execute(null, workingDir)
                         codegenProc.waitFor()
                     }

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

@@ -3,33 +3,45 @@ package com.brickmodule
 import com.facebook.react.bridge.*
 
 /**
- * Helper class for converting data to React Native compatible formats
- * Ensures type safety when sending events to JavaScript
+ * Helper class for converting data to React Native compatible formats Ensures type safety when
+ * sending events to JavaScript
  */
 object EventDataConverter {
-    
+
+    private fun isNullSentinel(value: Any?): Boolean {
+        return value is Null ||
+                (value != null && value.javaClass.name == "com.brickmodule.Null") ||
+                (value is String && value.startsWith("com.brickmodule.Null@"))
+    }
+
     /**
      * Convert any data to React Native compatible format
-     * 
+     *
      * @param data The data to convert
      * @return React Native compatible data or null if conversion fails
      */
     fun convert(data: Any?): Any? {
         return try {
-            when (data) {
-                null -> null
-                is String -> data
-                is Boolean -> data
-                is Int -> data
-                is Double -> data
-                is Float -> data.toDouble()
-                is Long -> data.toDouble()
-                is Map<*, *> -> convertMap(data)
-                is List<*> -> convertList(data)
-                is Array<*> -> convertList(data.toList())
-                else -> {
-                    println("⚠️ EventDataConverter: Unsupported data type ${data.javaClass.simpleName}, converting to string")
-                    data.toString()
+            if (isNullSentinel(data)) {
+                null
+            } else {
+                when (data) {
+                    null -> null
+                    is String -> data
+                    is Boolean -> data
+                    is Int -> data
+                    is Double -> data
+                    is Float -> data.toDouble()
+                    is Long -> data.toDouble()
+                    is Map<*, *> -> convertMap(data)
+                    is List<*> -> convertList(data)
+                    is Array<*> -> convertList(data.toList())
+                    else -> {
+                        println(
+                                "⚠️ EventDataConverter: Unsupported data type ${data.javaClass.simpleName}, converting to string"
+                        )
+                        data.toString()
+                    }
                 }
             }
         } catch (e: Exception) {
@@ -37,17 +49,17 @@ object EventDataConverter {
             null
         }
     }
-    
+
     /**
      * Convert a map to WritableMap for React Native
-     * 
+     *
      * @param map The map to convert
      * @return WritableMap or null if conversion fails
      */
     private fun convertMap(map: Map<*, *>): WritableMap? {
         return try {
             val writableMap = Arguments.createMap()
-            
+
             map.forEach { (key, value) ->
                 val keyString = key?.toString()
                 if (keyString != null) {
@@ -63,24 +75,24 @@ object EventDataConverter {
                     }
                 }
             }
-            
+
             writableMap
         } catch (e: Exception) {
             println("❌ EventDataConverter: Failed to convert map: ${e.message}")
             null
         }
     }
-    
+
     /**
      * Convert a list to WritableArray for React Native
-     * 
+     *
      * @param list The list to convert
      * @return WritableArray or null if conversion fails
      */
     private fun convertList(list: List<*>): WritableArray? {
         return try {
             val writableArray = Arguments.createArray()
-            
+
             list.forEach { item ->
                 when (val convertedValue = convert(item)) {
                     null -> writableArray.pushNull()
@@ -93,30 +105,31 @@ object EventDataConverter {
                     else -> writableArray.pushString(convertedValue.toString())
                 }
             }
-            
+
             writableArray
         } catch (e: Exception) {
             println("❌ EventDataConverter: Failed to convert list: ${e.message}")
             null
         }
     }
-    
+
     /**
      * Validate if data can be safely converted to React Native format
-     * 
+     *
      * @param data The data to validate
      * @return true if data can be safely converted, false otherwise
      */
     fun isConvertible(data: Any?): Boolean {
+        if (isNullSentinel(data)) {
+            return true
+        }
         return when (data) {
             null -> true
             is String, is Boolean, is Number -> true
-            is Map<*, *> -> data.all { (key, value) -> 
-                key is String && isConvertible(value) 
-            }
+            is Map<*, *> -> data.all { (key, value) -> key is String && isConvertible(value) }
             is List<*> -> data.all { isConvertible(it) }
             is Array<*> -> data.all { isConvertible(it) }
             else -> false
         }
     }
-}
+}

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

@@ -0,0 +1,7 @@
+
+package com.brickmodule
+
+/**
+ * Sentinel value used to represent null for Any conversions.
+ */
+object Null

package/dist/index.d.ts

@@ -4,6 +4,16 @@ import { Any, AnyObject } from "./types.js";
 
 //#region src/index.d.ts
 
+/**
+ * Error types for Brick modules
+ * @deprecated Use BrickError instead
+ */
+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
  */
@@ -21,4 +31,4 @@ interface BrickCodegenConfig {
   dev?: boolean;
 }
 //#endregion
-export { Any, AnyObject, BrickCodegenConfig, BrickError, BrickModule, type BrickModuleInterface, type BrickModuleSpec };
+export { Any, AnyObject, BrickCodegenConfig, BrickError, BrickModule, BrickModuleError, type BrickModuleInterface, type BrickModuleSpec };

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brick-module",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Better React Native native module development",
   "type": "module",
   "main": "dist/index.js",
@@ -58,7 +58,7 @@
     "brick-codegen": "./bin/brick-codegen.js"
   },
   "dependencies": {
-    "brick-codegen": "0.4.0"
+    "brick-codegen": "0.5.0"
   },
   "peerDependencies": {
     "react": ">=18.2.0",

package/src/index.ts

@@ -6,6 +6,22 @@ export type { BrickModuleInterface, BrickModuleSpec } from "./BrickModule";
 export { default as BrickModule } from "./BrickModule";
 export { BrickError } from "./BrickError";
 
+/**
+ * Error types for Brick modules
+ * @deprecated Use BrickError instead
+ */
+export class BrickModuleError extends Error {
+  constructor(
+    message: string,
+    public code: string = "BRICK_ERROR",
+    public moduleName?: string,
+    public methodName?: string
+  ) {
+    super(message);
+    this.name = "BrickModuleError";
+  }
+}
+
 /**
  * Configuration interface for brick-codegen
  */