not-react-native-macos 0.83.0-rc.1 → 0.87.1-rc.2

package/ReactAndroid/src/main/java/com/facebook/react/bridge/BridgeReactContext.kt

@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+import android.content.Context
+import com.facebook.common.logging.FLog
+import com.facebook.infer.annotation.Assertions
+import com.facebook.infer.annotation.ThreadConfined
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.queue.ReactQueueConfiguration
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.common.annotations.VisibleForTesting
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogLevel
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
+
+/**
+ * This is the bridge-specific concrete subclass of ReactContext. ReactContext has many methods that
+ * delegate to the react instance. This subclass implements those methods, by delegating to the
+ * CatalystInstance. If you need to create a ReactContext within an "bridge context", please create
+ * BridgeReactContext.
+ *
+ * @deprecated This class is deprecated in the New Architecture and will be replaced by
+ *   [com.facebook.react.runtime.BridgelessReactContext]
+ */
+@VisibleForTesting
+@LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
+@Deprecated(
+    "This class is part of Legacy Architecture and will be removed in a future release",
+    replaceWith = ReplaceWith("BridgelessReactContext"),
+)
+@Suppress("DEPRECATION")
+public open class BridgeReactContext(context: Context) : ReactApplicationContext(context) {
+
+  /** Interface for emitting device events to JavaScript. */
+  @DoNotStrip
+  public interface RCTDeviceEventEmitter : JavaScriptModule {
+    /** Emits an event with the given name and data to JavaScript. */
+    public fun emit(eventName: String, data: Any?)
+  }
+
+  @Volatile private var mDestroyed: Boolean = false
+  private var mCatalystInstance: CatalystInstance? = null
+
+  /** Set and initialize CatalystInstance for this Context. This should be called exactly once. */
+  public fun initializeWithInstance(catalystInstance: CatalystInstance) {
+    requireNotNull(catalystInstance) { "CatalystInstance cannot be null." }
+    if (mCatalystInstance != null) {
+      throw IllegalStateException("ReactContext has been already initialized")
+    }
+    if (mDestroyed) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          IllegalStateException("Cannot initialize ReactContext after it has been destroyed."),
+      )
+    }
+
+    mCatalystInstance = catalystInstance
+
+    val queueConfig: ReactQueueConfiguration = catalystInstance.reactQueueConfiguration
+    initializeMessageQueueThreads(queueConfig)
+    initializeInteropModules()
+  }
+
+  private fun raiseCatalystInstanceMissingException() {
+    throw IllegalStateException(
+        if (mDestroyed) LATE_NATIVE_MODULE_EXCEPTION_MESSAGE
+        else EARLY_NATIVE_MODULE_EXCEPTION_MESSAGE
+    )
+  }
+
+  /**
+   * Returns a handle to the specified JS module for the CatalystInstance associated with this
+   * Context.
+   */
+  override fun <T : JavaScriptModule> getJSModule(jsInterface: Class<T>): T? {
+    if (mCatalystInstance == null) {
+      if (mDestroyed) {
+        throw IllegalStateException(LATE_JS_ACCESS_EXCEPTION_MESSAGE)
+      }
+      throw IllegalStateException(EARLY_JS_ACCESS_EXCEPTION_MESSAGE)
+    }
+    mInteropModuleRegistry?.let { registry ->
+      val jsModule = registry.getInteropModule(jsInterface)
+      if (jsModule != null) {
+        return jsModule
+      }
+    }
+    return checkNotNull(mCatalystInstance).getJSModule(jsInterface)
+  }
+
+  override fun <T : NativeModule> hasNativeModule(nativeModuleInterface: Class<T>): Boolean {
+    val catalystInstance =
+        mCatalystInstance
+            ?: run {
+              raiseCatalystInstanceMissingException()
+              error("unreachable")
+            }
+    return catalystInstance.hasNativeModule(nativeModuleInterface)
+  }
+
+  override fun getNativeModules(): Collection<NativeModule> {
+    val catalystInstance =
+        mCatalystInstance
+            ?: run {
+              raiseCatalystInstanceMissingException()
+              error("unreachable")
+            }
+    return catalystInstance.nativeModules
+  }
+
+  /** Returns the instance of the specified module interface associated with this ReactContext. */
+  override fun <T : NativeModule> getNativeModule(nativeModuleInterface: Class<T>): T? {
+    val catalystInstance =
+        mCatalystInstance
+            ?: run {
+              raiseCatalystInstanceMissingException()
+              error("unreachable")
+            }
+    return catalystInstance.getNativeModule(nativeModuleInterface)
+  }
+
+  override fun getNativeModule(moduleName: String): NativeModule? {
+    val catalystInstance =
+        mCatalystInstance
+            ?: run {
+              raiseCatalystInstanceMissingException()
+              error("unreachable")
+            }
+    return catalystInstance.getNativeModule(moduleName)
+  }
+
+  override fun getCatalystInstance(): CatalystInstance {
+    return Assertions.assertNotNull(mCatalystInstance)
+  }
+
+  /**
+   * This API has been deprecated due to naming consideration, please use [hasActiveReactInstance]
+   * instead.
+   */
+  @Deprecated("Use hasActiveReactInstance() instead")
+  override fun hasActiveCatalystInstance(): Boolean {
+    return hasActiveReactInstance()
+  }
+
+  /** Returns true if there is a non-null, alive react native instance. */
+  override fun hasActiveReactInstance(): Boolean {
+    return mCatalystInstance?.isDestroyed == false
+  }
+
+  /**
+   * This API has been deprecated due to naming consideration, please use [hasReactInstance]
+   * instead.
+   */
+  @Deprecated("Use hasReactInstance() instead")
+  override fun hasCatalystInstance(): Boolean {
+    return mCatalystInstance != null
+  }
+
+  override fun hasReactInstance(): Boolean {
+    return mCatalystInstance != null
+  }
+
+  /** Destroy this instance, making it unusable. */
+  @ThreadConfined(ThreadConfined.UI)
+  override fun destroy() {
+    UiThreadUtil.assertOnUiThread()
+
+    mDestroyed = true
+    mCatalystInstance?.destroy()
+  }
+
+  /**
+   * Passes the given exception to the current [JSExceptionHandler] if one exists, rethrowing
+   * otherwise.
+   */
+  override fun handleException(e: Exception) {
+    val catalystInstanceVariableExists = mCatalystInstance != null
+    val isCatalystInstanceAlive = mCatalystInstance?.isDestroyed == false
+    val jsExceptionHandler = getJSExceptionHandler()
+
+    if (isCatalystInstanceAlive && jsExceptionHandler != null) {
+      jsExceptionHandler.handleException(e)
+    } else {
+      FLog.e(
+          ReactConstants.TAG,
+          "Unable to handle Exception - catalystInstanceVariableExists: " +
+              catalystInstanceVariableExists +
+              " - isCatalystInstanceAlive: " +
+              isCatalystInstanceAlive +
+              " - hasExceptionHandler: " +
+              (jsExceptionHandler != null),
+          e,
+      )
+      throw IllegalStateException(e)
+    }
+  }
+
+  /** @deprecated DO NOT USE, this method will be removed in the near future. */
+  @Deprecated("DO NOT USE, this method will be removed in the near future.")
+  override fun isBridgeless(): Boolean {
+    return false
+  }
+
+  /**
+   * Get the C pointer (as a long) to the JavaScriptCore context associated with this instance. Use
+   * the following pattern to ensure that the JS context is not cleared while you are using it:
+   * JavaScriptContextHolder jsContext = reactContext.getJavaScriptContextHolder()
+   * synchronized(jsContext) { nativeThingNeedingJsContext(jsContext.get()); }
+   */
+  @FrameworkAPI
+  @UnstableReactNativeAPI
+  override fun getJavaScriptContextHolder(): JavaScriptContextHolder? {
+    return mCatalystInstance?.javaScriptContextHolder
+  }
+
+  /**
+   * Returns a hybrid object that contains a pointer to a JS CallInvoker, which is used to schedule
+   * work on the JS Thread.
+   */
+  override fun getJSCallInvokerHolder(): CallInvokerHolder? {
+    return mCatalystInstance?.jsCallInvokerHolder
+  }
+
+  /**
+   * Get the UIManager for Fabric from the CatalystInstance.
+   *
+   * @return The UIManager when CatalystInstance is active.
+   * @deprecated Do not use this method. Instead use [com.facebook.react.uimanager.UIManagerHelper]
+   *   method [getUIManager] to get the UIManager instance from the current ReactContext.
+   */
+  @Deprecated("Use UIManagerHelper.getUIManager() instead")
+  override fun getFabricUIManager(): UIManager? {
+    return checkNotNull(mCatalystInstance).getFabricUIManager()
+  }
+
+  /**
+   * Get the sourceURL for the JS bundle from the CatalystInstance. This method is needed for
+   * compatibility with bridgeless mode, which has no CatalystInstance.
+   *
+   * @return The JS bundle URL set when the bundle was loaded
+   */
+  override fun getSourceURL(): String? {
+    return mCatalystInstance?.sourceURL
+  }
+
+  /**
+   * Register a JS segment after loading it from cache or server, make sure mCatalystInstance is
+   * properly initialised and not null before calling.
+   */
+  override fun registerSegment(segmentId: Int, path: String, callback: Callback) {
+    Assertions.assertNotNull(mCatalystInstance).registerSegment(segmentId, path)
+    Assertions.assertNotNull(callback).invoke()
+  }
+
+  private companion object {
+    init {
+      LegacyArchitectureLogger.assertLegacyArchitecture(
+          "BridgeReactContext",
+          LegacyArchitectureLogLevel.ERROR,
+      )
+    }
+
+    private const val TAG: String = "BridgeReactContext"
+
+    private const val EARLY_JS_ACCESS_EXCEPTION_MESSAGE: String =
+        "Tried to access a JS module before the React instance was fully set up. Calls to " +
+            "ReactContext#getJSModule should only happen once initialize() has been called on your " +
+            "native module."
+    private const val LATE_JS_ACCESS_EXCEPTION_MESSAGE: String =
+        "Tried to access a JS module after the React instance was destroyed."
+    private const val EARLY_NATIVE_MODULE_EXCEPTION_MESSAGE: String =
+        "Trying to call native module before CatalystInstance has been set!"
+    private const val LATE_NATIVE_MODULE_EXCEPTION_MESSAGE: String =
+        "Trying to call native module after CatalystInstance has been destroyed!"
+  }
+
+  override fun getRuntimeExecutor(): RuntimeExecutor? = mCatalystInstance?.runtimeExecutor
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.kt

@@ -75,24 +75,6 @@ public interface CatalystInstance : MemoryPressureListener, JSInstance, JSBundle
    */
   public fun extendNativeModules(modules: NativeModuleRegistry)
 
-  /**
-   * Adds a idle listener for this Catalyst instance. The listener will receive notifications
-   * whenever the bridge transitions from idle to busy and vice-versa, where the busy state is
-   * defined as there being some non-zero number of calls to JS that haven't resolved via a
-   * onBatchCompleted call. The listener should be purely passive and not affect application logic.
-   */
-  public fun addBridgeIdleDebugListener(
-      @Suppress("DEPRECATION") listener: NotThreadSafeBridgeIdleDebugListener
-  )
-
-  /**
-   * Removes a NotThreadSafeBridgeIdleDebugListener previously added with
-   * [addBridgeIdleDebugListener]
-   */
-  public fun removeBridgeIdleDebugListener(
-      @Suppress("DEPRECATION") listener: NotThreadSafeBridgeIdleDebugListener
-  )
-
   /** This method registers the file path of an additional JS segment by its ID. */
   public fun registerSegment(segmentId: Int, path: String)
 

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ColorPropConverter.kt

@@ -30,6 +30,7 @@ public object ColorPropConverter {
   private const val ATTR = "attr"
   private const val ATTR_SEGMENT = "attr/"
 
+  @Throws(JSApplicationCausedNativeException::class)
   private fun getColorInteger(value: Any?, context: Context): Int? {
     if (value == null) {
       return null
@@ -64,6 +65,12 @@ public object ColorPropConverter {
         }
       }
 
+      val attemptedPaths = (0 until resourcePaths.size()).map { resourcePaths.getString(it) }
+      FLog.w(
+          ReactConstants.TAG,
+          "ColorValue: Failed to resolve resource paths: ${attemptedPaths.joinToString(", ")}",
+      )
+
       throw JSApplicationCausedNativeException(
           "ColorValue: None of the paths in the `$JSON_KEY` array resolved to a color resource."
       )
@@ -73,6 +80,7 @@ public object ColorPropConverter {
   }
 
   @JvmStatic
+  @Throws(JSApplicationCausedNativeException::class)
   public fun getColorInstance(value: Any?, context: Context): Color? {
     if (value == null) {
       return null
@@ -113,6 +121,12 @@ public object ColorPropConverter {
         }
       }
 
+      val attemptedPaths = (0 until resourcePaths.size()).map { resourcePaths.getString(it) }
+      FLog.w(
+          ReactConstants.TAG,
+          "ColorValue: Failed to resolve resource paths: ${attemptedPaths.joinToString(", ")}",
+      )
+
       throw JSApplicationCausedNativeException(
           "ColorValue: None of the paths in the `$JSON_KEY` array resolved to a color resource."
       )
@@ -122,6 +136,7 @@ public object ColorPropConverter {
   }
 
   @JvmStatic
+  @Throws(JSApplicationCausedNativeException::class)
   public fun getColor(value: Any?, context: Context): Int? {
     try {
       if (supportWideGamut()) {
@@ -188,6 +203,7 @@ public object ColorPropConverter {
     return ResourcesCompat.getColor(context.resources, resourceId, context.theme)
   }
 
+  @Throws(Resources.NotFoundException::class)
   private fun resolveThemeAttribute(context: Context, resourcePath: String): Int {
     val path = resourcePath.replace(ATTR_SEGMENT, "")
     val pathTokens = path.split(PACKAGE_DELIMITER)

package/ReactAndroid/src/main/java/com/facebook/react/bridge/DynamicFromArray.kt

@@ -7,7 +7,7 @@
 
 package com.facebook.react.bridge
 
-import androidx.core.util.Pools
+import androidx.core.util.Pools.SimplePool
 
 /** Implementation of Dynamic wrapping a ReadableArray. */
 internal class DynamicFromArray private constructor() : Dynamic {
@@ -17,7 +17,7 @@ internal class DynamicFromArray private constructor() : Dynamic {
   override fun recycle() {
     array = null
     index = -1
-    pool.release(this)
+    pool.get()?.release(this)
   }
 
   override val type: ReadableType
@@ -48,11 +48,16 @@ internal class DynamicFromArray private constructor() : Dynamic {
       array?.getString(index) ?: throw IllegalStateException("This dynamic value has been recycled")
 
   companion object {
-    private val pool = Pools.SimplePool<DynamicFromArray>(10)
+    private val pool: ThreadLocal<SimplePool<DynamicFromArray>> =
+        object : ThreadLocal<SimplePool<DynamicFromArray>>() {
+          override fun initialValue(): SimplePool<DynamicFromArray> {
+            return SimplePool(10)
+          }
+        }
 
     @JvmStatic
     fun create(array: ReadableArray, index: Int): DynamicFromArray {
-      val dynamic = pool.acquire() ?: DynamicFromArray()
+      val dynamic = pool.get()?.acquire() ?: DynamicFromArray()
       dynamic.array = array
       dynamic.index = index
       return dynamic

package/ReactAndroid/src/main/java/com/facebook/react/bridge/JavaModuleWrapper.kt

@@ -25,15 +25,9 @@ import java.lang.reflect.Method
 @DoNotStrip
 @InteropLegacyArchitecture
 internal class JavaModuleWrapper(
-    @Suppress("DEPRECATION") private val jsInstance: JSInstance,
+    @Suppress("DEPRECATION", "unused") private val jsInstance: JSInstance,
     private val moduleHolder: ModuleHolder,
 ) {
-  interface NativeMethod {
-    @Suppress("DEPRECATION") fun invoke(jsInstance: JSInstance, parameters: ReadableArray)
-
-    val type: String
-  }
-
   @DoNotStrip
   class MethodDescriptor {
     @DoNotStrip var method: Method? = null
@@ -45,7 +39,6 @@ internal class JavaModuleWrapper(
     @DoNotStrip var type: String? = null
   }
 
-  private val methods = ArrayList<NativeMethod>()
   private val descs = ArrayList<MethodDescriptor>()
 
   @get:DoNotStrip
@@ -63,26 +56,26 @@ internal class JavaModuleWrapper(
     var classForMethods: Class<*> = moduleHolder.module.javaClass
     val superClass = classForMethods.superclass
     if (superClass != null && TurboModule::class.java.isAssignableFrom(superClass)) {
-      // For java module that is based on generated flow-type spec, inspect the
-      // spec abstract class instead, which is the super class of the given Java
-      // module.
       classForMethods = superClass
     }
 
     val targetMethods = classForMethods.declaredMethods
     for (targetMethod in targetMethods) {
       targetMethod.getAnnotation(ReactMethod::class.java)?.let { annotation ->
-        val methodName = targetMethod.name
         val md = MethodDescriptor()
-        @Suppress("DEPRECATION")
-        val method = JavaMethodWrapper(this, targetMethod, annotation.isBlockingSynchronousMethod)
-        md.name = methodName
-        md.type = method.type
+        md.name = targetMethod.name
+        md.type =
+            when {
+              annotation.isBlockingSynchronousMethod -> BaseJavaModule.METHOD_TYPE_SYNC
+              targetMethod.parameterTypes.let { params ->
+                params.isNotEmpty() && params.last() == Promise::class.java
+              } -> BaseJavaModule.METHOD_TYPE_PROMISE
+              else -> BaseJavaModule.METHOD_TYPE_ASYNC
+            }
         if (BaseJavaModule.METHOD_TYPE_SYNC == md.type) {
-          md.signature = method.signature
+          md.signature = ""
           md.method = targetMethod
         }
-        methods.add(method)
         descs.add(md)
       }
     }
@@ -128,11 +121,10 @@ internal class JavaModuleWrapper(
 
   @DoNotStrip
   fun invoke(methodId: Int, parameters: ReadableNativeArray) {
-    if (methodId >= methods.size) {
-      return
-    }
-
-    methods[methodId].invoke(jsInstance, parameters)
+    throw UnsupportedOperationException(
+        "JavaModuleWrapper.invoke() is no longer supported. " +
+            "Use TurboModule interop instead (ReactNativeFeatureFlags.useTurboModuleInterop)."
+    )
   }
 
   private companion object {

package/ReactAndroid/src/main/java/com/facebook/react/bridge/JavaOnlyMap.kt

@@ -168,13 +168,15 @@ public class JavaOnlyMap() : ReadableMap, WritableMap {
   override fun toString(): String = backingMap.toString()
 
   override fun equals(other: Any?): Boolean {
-    return if (this === other) {
-      true
-    } else if (other == null || javaClass != other.javaClass) {
-      false
-    } else {
-      backingMap == (other as JavaOnlyMap).backingMap
+    if (this === other) {
+      return true
     }
+    if (other !is JavaOnlyMap) {
+      return false
+    }
+    val thisBackingMap = backingMap
+    val otherBackingMap = other.backingMap
+    return thisBackingMap == otherBackingMap
   }
 
   override fun hashCode(): Int = backingMap.hashCode()

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ModuleHolder.kt

@@ -60,7 +60,7 @@ public class ModuleHolder {
             nativeModule.javaClass.simpleName,
             nativeModule.canOverrideExistingModule(),
             true,
-            CxxModuleWrapper::class.java.isAssignableFrom(nativeModule.javaClass),
+            false,
             ReactModuleInfo.classIsTurboModule(nativeModule.javaClass),
         )
 
@@ -108,7 +108,7 @@ public class ModuleHolder {
     get() = reactModuleInfo.isTurboModule
 
   public val isCxxModule: Boolean
-    get() = reactModuleInfo.isCxxModule
+    get() = false
 
   public val className: String
     get() = reactModuleInfo.className

package/ReactAndroid/src/main/java/com/facebook/react/bridge/NativeModuleRegistry.kt

@@ -36,32 +36,19 @@ public class NativeModuleRegistry(
   @JvmName("getJavaModules") // This is needed because this method is accessed by JNI
   internal fun getJavaModules(jsInstance: JSInstance): List<JavaModuleWrapper> = buildList {
     for ((_, value) in modules) {
-      if (!value.isCxxModule) {
-        add(JavaModuleWrapper(jsInstance, value))
-      }
+      add(JavaModuleWrapper(jsInstance, value))
     }
   }
 
-  @get:JvmName(
-      "getCxxModules"
-  ) // This is needed till there are Java Consumer of this API inside React
-  // Native
-  internal val cxxModules: List<ModuleHolder>
-    get() = buildList {
-      for ((_, value) in modules) {
-        if (value.isCxxModule) {
-          add(value)
-        }
-      }
-    }
-
   /** Adds any new modules to the current module registry */
   @JvmName(
       "registerModules"
   ) // This is needed till there are Java Consumer of this API inside React
   // Native
   internal fun registerModules(newRegister: NativeModuleRegistry) {
-    check(reactApplicationContext == newRegister.reactApplicationContext) {
+    val ownContext = reactApplicationContext
+    val otherContext = newRegister.reactApplicationContext
+    check(ownContext == otherContext) {
       "Extending native modules with non-matching application contexts."
     }
 
@@ -109,23 +96,6 @@ public class NativeModuleRegistry(
     }
   }
 
-  public fun onBatchComplete() {
-    // The only native module that uses the onBatchComplete is the UI Manager. Hence, instead of
-    // iterating over all the modules for find this one instance, and then calling it, we
-    // short-circuit
-    // the search, and simply call OnBatchComplete on the UI Manager.
-    // With Fabric, UIManager would no longer be a NativeModule, so this call would simply go away
-    assertLegacyArchitecture(
-        "NativeModuleRegistry.onBatchComplete()",
-        LegacyArchitectureLogLevel.WARNING,
-    )
-    modules["UIManager"]?.let {
-      if (it.hasInstance()) {
-        (it.module as OnBatchCompleteListener).onBatchComplete()
-      }
-    }
-  }
-
   public fun <T : NativeModule> hasModule(moduleInterface: Class<T>): Boolean {
     val annotation = moduleInterface.getAnnotation(ReactModule::class.java)
     requireNotNull(annotation) {

package/ReactAndroid/src/main/java/com/facebook/react/bridge/Promise.kt

@@ -28,7 +28,7 @@ public interface Promise {
    * @param code String
    * @param message String
    */
-  public fun reject(code: String, message: String?)
+  public fun reject(code: String?, message: String?)
 
   /**
    * Report an exception with a custom code.
@@ -36,7 +36,7 @@ public interface Promise {
    * @param code String
    * @param throwable Throwable
    */
-  public fun reject(code: String, throwable: Throwable?)
+  public fun reject(code: String?, throwable: Throwable?)
 
   /**
    * Report an exception with a custom code and error message.
@@ -45,7 +45,7 @@ public interface Promise {
    * @param message String
    * @param throwable Throwable
    */
-  public fun reject(code: String, message: String?, throwable: Throwable?)
+  public fun reject(code: String?, message: String?, throwable: Throwable?)
 
   /**
    * Report an exception, with default error code. Useful in catch-all scenarios where it's unclear
@@ -73,7 +73,7 @@ public interface Promise {
    * @param code String
    * @param userInfo WritableMap
    */
-  public fun reject(code: String, userInfo: WritableMap)
+  public fun reject(code: String?, userInfo: WritableMap)
 
   /**
    * Report an exception with a custom code and userInfo.
@@ -82,7 +82,7 @@ public interface Promise {
    * @param throwable Throwable
    * @param userInfo WritableMap
    */
-  public fun reject(code: String, throwable: Throwable?, userInfo: WritableMap)
+  public fun reject(code: String?, throwable: Throwable?, userInfo: WritableMap)
 
   /**
    * Report an error with a custom code, error message and userInfo, an error not caused by an
@@ -92,7 +92,7 @@ public interface Promise {
    * @param message String
    * @param userInfo WritableMap
    */
-  public fun reject(code: String, message: String?, userInfo: WritableMap)
+  public fun reject(code: String?, message: String?, userInfo: WritableMap)
 
   /**
    * Report an exception with a custom code, error message and userInfo.