expo-modules-core 1.3.2 → 1.4.0

package/android/src/main/java/expo/modules/kotlin/devtools/cdp/CdpNetworkTypes.kt

@@ -0,0 +1,257 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.kotlin.devtools.cdp
+
+import expo.modules.kotlin.devtools.ExpoNetworkInspectOkHttpNetworkInterceptor
+import expo.modules.kotlin.devtools.toSingleMap
+import okio.Buffer
+import org.json.JSONObject
+import java.math.BigDecimal
+
+//region Types
+
+typealias Headers = Map<String, String>
+typealias MonotonicTime = BigDecimal
+typealias RequestId = String
+typealias TimeSinceEpoch = BigDecimal
+
+enum class ResourceType(val value: String) {
+  IMAGE("Image"),
+  MEDIA("Media"),
+  FONT("Font"),
+  SCRIPT("Script"),
+  FETCH("Fetch"),
+  OTHER("Other")
+}
+
+interface JsonSerializable {
+  fun toJSONObject(): JSONObject
+}
+
+data class ConnectTiming(val requestTime: MonotonicTime) : JsonSerializable {
+  override fun toJSONObject(): JSONObject {
+    return JSONObject().apply {
+      put("requestTime", requestTime)
+    }
+  }
+}
+
+data class Request(
+  val url: String,
+  val method: String,
+  val headers: Headers,
+  val postData: String?
+) : JsonSerializable {
+  constructor(request: okhttp3.Request) : this(
+    url = request.url.toString(),
+    method = request.method,
+    headers = request.headers.toSingleMap(),
+    postData = request.body?.let {
+      if (it.contentLength() < ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE) {
+        val buffer = Buffer()
+        it.writeTo(buffer)
+        return@let buffer.readUtf8(buffer.size.coerceAtMost(ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE))
+      } else return@let null
+    }
+  )
+
+  override fun toJSONObject(): JSONObject {
+    return JSONObject().apply {
+      put("url", url)
+      put("method", method)
+      put("headers", JSONObject(headers))
+      postData?.let {
+        put("postData", postData)
+      }
+    }
+  }
+}
+
+data class Response(
+  val url: String,
+  val status: Int,
+  val statusText: String,
+  val headers: Headers,
+  val mimeType: String,
+  val encodedDataLength: Long
+) : JsonSerializable {
+  constructor(response: okhttp3.Response) : this(
+    url = response.request.url.toString(),
+    status = response.code,
+    statusText = response.message,
+    headers = response.headers.toSingleMap(),
+    mimeType = response.header("Content-Type", "") ?: "",
+    encodedDataLength = response.body?.contentLength() ?: 0,
+  )
+
+  override fun toJSONObject(): JSONObject {
+    return JSONObject().apply {
+      put("url", url)
+      put("status", status)
+      put("statusText", statusText)
+      put("headers", JSONObject(headers))
+      put("mimeType", mimeType)
+      put("encodedDataLength", encodedDataLength)
+    }
+  }
+}
+
+//endregion Types
+
+//region Events
+
+data class RequestWillBeSentParams(
+  val requestId: RequestId,
+  val loaderId: String = "",
+  val documentURL: String = "mobile",
+  val request: Request,
+  val timestamp: MonotonicTime,
+  val wallTime: TimeSinceEpoch,
+  val initiator: Map<String, String> = mapOf("type" to "script"),
+  val redirectHasExtraInfo: Boolean,
+  val redirectResponse: Response?,
+  val referrerPolicy: String = "no-referrer",
+  val type: ResourceType,
+) : JsonSerializable {
+  constructor(now: BigDecimal, requestId: RequestId, request: okhttp3.Request, redirectResponse: okhttp3.Response?) : this(
+    requestId = requestId,
+    request = Request(request),
+    timestamp = now,
+    wallTime = now,
+    redirectHasExtraInfo = redirectResponse != null,
+    redirectResponse = redirectResponse?.let { Response(it) },
+    type = ResourceType.FETCH,
+  )
+
+  override fun toJSONObject(): JSONObject {
+    return JSONObject().apply {
+      put("requestId", requestId)
+      put("loaderId", loaderId)
+      put("documentURL", documentURL)
+      put("request", request.toJSONObject())
+      put("timestamp", timestamp)
+      put("wallTime", wallTime)
+      put("initiator", JSONObject(initiator))
+      put("redirectHasExtraInfo", redirectHasExtraInfo)
+      redirectResponse?.let {
+        put("redirectResponse", it.toJSONObject())
+      }
+      put("referrerPolicy", referrerPolicy)
+      put("type", type.value)
+    }
+  }
+}
+
+data class RequestWillBeSentExtraInfoParams(
+  val requestId: RequestId,
+  val associatedCookies: Map<String, String> = emptyMap(),
+  val headers: Headers,
+  val connectTiming: ConnectTiming,
+) : JsonSerializable {
+  constructor(now: BigDecimal, requestId: RequestId, request: okhttp3.Request) : this(
+    requestId = requestId,
+    headers = request.headers.toSingleMap(),
+    connectTiming = ConnectTiming(now),
+  )
+
+  override fun toJSONObject(): JSONObject {
+    return JSONObject().apply {
+      put("requestId", requestId)
+      put("associatedCookies", JSONObject(associatedCookies))
+      put("headers", JSONObject(headers))
+      put("connectTiming", connectTiming.toJSONObject())
+    }
+  }
+}
+
+data class ResponseReceivedParams(
+  val requestId: RequestId,
+  val loaderId: String = "",
+  val timestamp: MonotonicTime,
+  val type: ResourceType,
+  val response: Response,
+  val hasExtraInfo: Boolean = false,
+) : JsonSerializable {
+  constructor(now: BigDecimal, requestId: RequestId, request: okhttp3.Request, repsonse: okhttp3.Response) : this(
+    requestId = requestId,
+    timestamp = now,
+    type = ResourceType.FETCH,
+    response = Response(repsonse),
+  )
+
+  override fun toJSONObject(): JSONObject {
+    return JSONObject().apply {
+      put("requestId", requestId)
+      put("loaderId", loaderId)
+      put("timestamp", timestamp)
+      put("type", type.value)
+      put("response", response.toJSONObject())
+      put("hasExtraInfo", hasExtraInfo)
+    }
+  }
+}
+
+data class LoadingFinishedParams(
+  val requestId: RequestId,
+  val timestamp: MonotonicTime,
+  val encodedDataLength: Long,
+) : JsonSerializable {
+  constructor(now: BigDecimal, requestId: RequestId, request: okhttp3.Request, repsonse: okhttp3.Response) : this(
+    requestId = requestId,
+    timestamp = now,
+    encodedDataLength = repsonse.body?.contentLength() ?: 0,
+  )
+
+  override fun toJSONObject(): JSONObject {
+    return JSONObject().apply {
+      put("requestId", requestId)
+      put("timestamp", timestamp)
+      put("encodedDataLength", encodedDataLength)
+    }
+  }
+}
+
+data class ExpoReceivedResponseBodyParams(
+  val requestId: RequestId,
+  var body: String,
+  var base64Encoded: Boolean,
+) : JsonSerializable {
+  constructor(now: BigDecimal, requestId: RequestId, request: okhttp3.Request, response: okhttp3.Response) : this(
+    requestId = requestId,
+    body = "",
+    base64Encoded = false,
+  ) {
+    val contentLength = response.body?.contentLength() ?: 0
+    check(contentLength >= 0 && contentLength <= ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE)
+    val rawBody = response.peekBody(ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE)
+    val contentType = rawBody.contentType()
+    val isText = contentType?.type == "text" || (contentType?.type == "application" && contentType.subtype == "json")
+    val bodyString = if (isText) rawBody.string() else rawBody.source().readByteString().base64()
+
+    this.body = bodyString
+    this.base64Encoded = !isText
+  }
+  override fun toJSONObject(): JSONObject {
+    return JSONObject().apply {
+      put("requestId", requestId)
+      put("body", body)
+      put("base64Encoded", base64Encoded)
+    }
+  }
+}
+
+//endregion Events
+
+typealias EventParams = JsonSerializable
+
+data class Event(
+  val method: String,
+  val params: EventParams
+) {
+  fun toJson(): String {
+    return JSONObject().apply {
+      put("method", method)
+      put("params", params.toJSONObject())
+    }.toString()
+  }
+}

package/android/src/main/java/expo/modules/kotlin/jni/JNIDeallocator.kt

@@ -1,14 +1,17 @@
 package expo.modules.kotlin.jni
 
+import expo.modules.core.interfaces.DoNotStrip
 import java.lang.ref.PhantomReference
 import java.lang.ref.ReferenceQueue
 import java.lang.ref.WeakReference
 
+@DoNotStrip
 interface Destructible {
   fun deallocate()
 }
 
-object JNIDeallocator {
+@DoNotStrip
+class JNIDeallocator(private val shouldCreateDestructorThread: Boolean = true) {
   /**
    * A [PhantomReference] queue managed by JVM
    */
@@ -23,23 +26,27 @@ object JNIDeallocator {
    * A thread that clears your registry when an object has been garbage collected
    * to not store invalid references to every created object.
    */
-  private val destructorThread = object : Thread("Expo JNI deallocator") {
-    override fun run() {
-      while (true) {
-        try {
-          // Referent of PhantomReference were garbage collected so we can remove it from our registry.
-          // Note that we don't have to call `deallocate` method - it was called [com.facebook.jni.HybridData].
-          val current = referenceQueue.remove()
-          synchronized(this) {
-            destructorMap.remove(current)
+  private val destructorThread = if (shouldCreateDestructorThread) {
+    object : Thread("Expo JNI deallocator") {
+      override fun run() {
+        while (!isInterrupted) {
+          try {
+            // Referent of PhantomReference were garbage collected so we can remove it from our registry.
+            // Note that we don't have to call `deallocate` method - it was called [com.facebook.jni.HybridData].
+            val current = referenceQueue.remove()
+            synchronized(this) {
+              destructorMap.remove(current)
+            }
+          } catch (e: InterruptedException) {
+            return
           }
-        } catch (e: InterruptedException) {
-          // Continue. This thread should never be terminated.
         }
       }
+    }.also {
+      it.start()
     }
-  }.also {
-    it.start()
+  } else {
+    null
   }
 
   /**
@@ -47,7 +54,8 @@ object JNIDeallocator {
    * That reference will be deallocated when [JNIDeallocator.deallocate] is called or
    * when the reference won't be reachable by the GC.
    */
-  internal fun addReference(destructible: Destructible) = synchronized(this) {
+  @DoNotStrip
+  fun addReference(destructible: Destructible): Unit = synchronized(this) {
     val weakRef = WeakReference(destructible)
     val phantomRef = PhantomReference(destructible, referenceQueue)
     destructorMap[phantomRef] = weakRef
@@ -61,6 +69,7 @@ object JNIDeallocator {
       it.get()?.deallocate()
     }
     destructorMap.clear()
+    destructorThread?.interrupt()
   }
 
   /**

package/android/src/main/java/expo/modules/kotlin/jni/JSIInteropModuleRegistry.kt

@@ -31,6 +31,7 @@ class JSIInteropModuleRegistry(appContext: AppContext) : Destructible {
    */
   external fun installJSI(
     jsRuntimePointer: Long,
+    jniDeallocator: JNIDeallocator,
     jsInvokerHolder: CallInvokerHolderImpl,
     nativeInvokerHolder: CallInvokerHolderImpl
   )
@@ -38,7 +39,13 @@ class JSIInteropModuleRegistry(appContext: AppContext) : Destructible {
   /**
    * Initializes the test runtime. Shouldn't be used in the production.
    */
-  external fun installJSIForTests()
+  external fun installJSIForTests(
+    jniDeallocator: JNIDeallocator,
+  )
+
+  fun installJSIForTests() = installJSIForTests(
+    JNIDeallocator(shouldCreateDestructorThread = false)
+  )
 
   /**
    * Evaluates given JavaScript source code.

package/android/src/main/java/expo/modules/kotlin/jni/JavaCallback.kt

@@ -9,10 +9,6 @@ import expo.modules.kotlin.exception.UnexpectedException
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
 class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
-  init {
-    JNIDeallocator.addReference(this)
-  }
-
   operator fun invoke(result: Any?) {
     if (result == null) {
       invoke()

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptFunction.kt

@@ -11,10 +11,6 @@ import kotlin.reflect.typeOf
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
 class JavaScriptFunction<ReturnType : Any?> @DoNotStrip private constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
-  init {
-    JNIDeallocator.addReference(this)
-  }
-
   @PublishedApi
   internal var returnType: KType? = null
 

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptModuleObject.kt

@@ -16,7 +16,10 @@ import expo.modules.kotlin.objects.ObjectDefinitionData
  */
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
-class JavaScriptModuleObject(val name: String) : Destructible {
+class JavaScriptModuleObject(
+  jniDeallocator: JNIDeallocator,
+  val name: String
+) : Destructible {
   // Has to be called "mHybridData" - fbjni uses it via reflection
   @DoNotStrip
   private val mHybridData = initHybrid()
@@ -24,7 +27,7 @@ class JavaScriptModuleObject(val name: String) : Destructible {
   private external fun initHybrid(): HybridData
 
   init {
-    JNIDeallocator.addReference(this)
+    jniDeallocator.addReference(this)
   }
 
   fun initUsingObjectDefinition(appContext: AppContext, definition: ObjectDefinitionData) = apply {

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptObject.kt

@@ -10,11 +10,6 @@ import expo.modules.core.interfaces.DoNotStrip
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
 open class JavaScriptObject @DoNotStrip internal constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
-  init {
-    @Suppress("LeakingThis")
-    JNIDeallocator.addReference(this)
-  }
-
   /**
    * The property descriptor options for the property being defined or modified.
    */

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptValue.kt

@@ -11,10 +11,6 @@ import kotlin.reflect.typeOf
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
 class JavaScriptValue @DoNotStrip private constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
-  init {
-    JNIDeallocator.addReference(this)
-  }
-
   fun isValid() = mHybridData.isValid
   external fun kind(): String
 

package/android/src/main/java/expo/modules/kotlin/objects/ObjectDefinitionBuilder.kt

@@ -361,7 +361,7 @@ inline fun ModuleDefinitionBuilder.Object(block: ObjectDefinitionBuilder.() -> U
 
 inline fun Module.Object(block: ObjectDefinitionBuilder.() -> Unit): JavaScriptModuleObject {
   val objectData = ObjectDefinitionBuilder().also(block).buildObject()
-  return JavaScriptModuleObject("[Anonymous Object]")
+  return JavaScriptModuleObject(appContext.jniDeallocator, "[Anonymous Object]")
     .apply {
       val constants = objectData.constantsProvider()
       val convertedConstants = Arguments.makeNativeMap(constants)

package/android/src/main/java/expo/modules/kotlin/types/ColorTypeConverter.kt

@@ -1,6 +1,8 @@
 package expo.modules.kotlin.types
 
 import android.graphics.Color
+import android.os.Build
+import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableType
 import expo.modules.kotlin.exception.UnexpectedException
@@ -166,6 +168,7 @@ private val namedColors = mapOf(
   value.map { it.toFloat() / 255f }
 }
 
+@RequiresApi(Build.VERSION_CODES.O)
 class ColorTypeConverter(
   isOptional: Boolean
 ) : DynamicAwareTypeConverters<Color>(isOptional) {

package/android/src/main/java/expo/modules/kotlin/types/TypeConverterProvider.kt

@@ -272,8 +272,6 @@ object TypeConverterProviderImpl : TypeConverterProvider {
       BigUint64Array::class.createType(nullable = isOptional) to BigUint64ArrayTypeConverter(isOptional),
       TypedArray::class.createType(nullable = isOptional) to TypedArrayTypeConverter(isOptional),
 
-      Color::class.createType(nullable = isOptional) to ColorTypeConverter(isOptional),
-
       URL::class.createType(nullable = isOptional) to URLTypConverter(isOptional),
       Uri::class.createType(nullable = isOptional) to UriTypeConverter(isOptional),
       URI::class.createType(nullable = isOptional) to JavaURITypeConverter(isOptional),
@@ -286,6 +284,7 @@ object TypeConverterProviderImpl : TypeConverterProvider {
     if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
       return converters + mapOf(
         Path::class.createType(nullable = isOptional) to PathTypeConverter(isOptional),
+        Color::class.createType(nullable = isOptional) to ColorTypeConverter(isOptional),
       )
     }
 

package/android-annotation/build.gradle

@@ -36,8 +36,8 @@ buildscript {
 }
 
 java {
-  sourceCompatibility = JavaVersion.VERSION_1_8
-  targetCompatibility = JavaVersion.VERSION_1_8
+  sourceCompatibility = JavaVersion.VERSION_11
+  targetCompatibility = JavaVersion.VERSION_11
 }
 
 dependencies {

package/android-annotation-processor/build.gradle

@@ -36,8 +36,8 @@ buildscript {
 }
 
 java {
-  sourceCompatibility = JavaVersion.VERSION_1_8
-  targetCompatibility = JavaVersion.VERSION_1_8
+  sourceCompatibility = JavaVersion.VERSION_11
+  targetCompatibility = JavaVersion.VERSION_11
 }
 
 dependencies {

package/ios/JSI/EXJSIInstaller.h

@@ -4,7 +4,7 @@
 
 // Swift classes need forward-declaration in the headers.
 @class EXAppContext;
-@class EXJavaScriptRuntime;
+@class ExpoRuntime;
 
 @interface EXJavaScriptRuntimeManager : NSObject
 
@@ -12,7 +12,7 @@
  Gets the JS runtime from the given bridge. May return `nil` when
  the runtime is not available yet or the remote debugging is enabled.
  */
-+ (nullable EXJavaScriptRuntime *)runtimeFromBridge:(nonnull RCTBridge *)bridge NS_SWIFT_NAME(runtime(fromBridge:));
++ (nullable ExpoRuntime *)runtimeFromBridge:(nonnull RCTBridge *)bridge NS_SWIFT_NAME(runtime(fromBridge:));
 
 /**
  Installs ExpoModules host object in the runtime of the given app context.

package/ios/JSI/EXJSIInstaller.mm

@@ -27,15 +27,15 @@ static NSString *modulesHostObjectLegacyPropertyName = @"ExpoModules";
 
 @implementation EXJavaScriptRuntimeManager
 
-+ (nullable EXJavaScriptRuntime *)runtimeFromBridge:(nonnull RCTBridge *)bridge
++ (nullable ExpoRuntime *)runtimeFromBridge:(nonnull RCTBridge *)bridge
 {
   jsi::Runtime *jsiRuntime = [bridge respondsToSelector:@selector(runtime)] ? reinterpret_cast<jsi::Runtime *>(bridge.runtime) : nullptr;
-  return jsiRuntime ? [[EXJavaScriptRuntime alloc] initWithRuntime:jsiRuntime callInvoker:bridge.jsCallInvoker] : nil;
+  return jsiRuntime ? [[ExpoRuntime alloc] initWithRuntime:jsiRuntime callInvoker:bridge.jsCallInvoker] : nil;
 }
 
 + (BOOL)installExpoModulesHostObject:(nonnull EXAppContext *)appContext
 {
-  EXJavaScriptRuntime *runtime = [appContext _runtime];
+  ExpoRuntime *runtime = [appContext _runtime];
 
   // The runtime may be unavailable, e.g. remote debugger is enabled or it hasn't been set yet.
   if (!runtime) {
@@ -43,9 +43,9 @@ static NSString *modulesHostObjectLegacyPropertyName = @"ExpoModules";
   }
 
   EXJavaScriptObject *global = [runtime global];
-  EXJavaScriptObject *mainObject = [runtime mainObject];
+  EXJavaScriptObject *coreObject = [runtime coreObject];
 
-  if ([mainObject hasProperty:modulesHostObjectPropertyName]) {
+  if ([coreObject hasProperty:modulesHostObjectPropertyName]) {
     return false;
   }
 
@@ -53,7 +53,7 @@ static NSString *modulesHostObjectLegacyPropertyName = @"ExpoModules";
   EXJavaScriptObject *modulesHostObject = [runtime createHostObject:modulesHostObjectPtr];
 
   // Define the `global.expo.modules` object as a non-configurable, read-only and enumerable property.
-  [mainObject defineProperty:modulesHostObjectPropertyName
+  [coreObject defineProperty:modulesHostObjectPropertyName
                        value:modulesHostObject
                      options:EXJavaScriptObjectPropertyDescriptorEnumerable];
 

package/ios/JSI/EXJavaScriptRuntime.h

@@ -66,12 +66,6 @@ NS_SWIFT_NAME(JavaScriptRuntime)
  */
 - (nonnull EXJavaScriptObject *)global;
 
-/**
- The main object of the Expo runtime that is used to scope native Expo-specific functionalities.
- It gets installed into the runtime as the `global.expo` object.
- */
-- (nonnull EXJavaScriptObject *)mainObject;
-
 /**
  Creates a new object for use in Swift.
  */

package/ios/JSI/EXJavaScriptRuntime.mm

@@ -20,16 +20,9 @@
 #import <ExpoModulesCore/EXJSIConversions.h>
 #import <ExpoModulesCore/Swift.h>
 
-
-/**
- Property name of the main object in the Expo JS runtime.
- */
-static NSString *mainObjectPropertyName = @"expo";
-
 @implementation EXJavaScriptRuntime {
   std::shared_ptr<jsi::Runtime> _runtime;
   std::shared_ptr<react::CallInvoker> _jsCallInvoker;
-  EXJavaScriptObject *_mainObject;
 }
 
 /**
@@ -46,7 +39,6 @@ static NSString *mainObjectPropertyName = @"expo";
     _runtime = jsc::makeJSCRuntime();
 #endif
     _jsCallInvoker = nil;
-    [self initializeMainObject];
   }
   return self;
 }
@@ -60,7 +52,6 @@ static NSString *mainObjectPropertyName = @"expo";
     // See explanation for constructor (8): https://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr
     _runtime = std::shared_ptr<jsi::Runtime>(std::shared_ptr<jsi::Runtime>(), runtime);
     _jsCallInvoker = callInvoker;
-    [self initializeMainObject];
   }
   return self;
 }
@@ -93,11 +84,6 @@ static NSString *mainObjectPropertyName = @"expo";
   return [[EXJavaScriptObject alloc] initWith:jsGlobalPtr runtime:self];
 }
 
-- (nonnull EXJavaScriptObject *)mainObject
-{
-  return _mainObject;
-}
-
 - (nonnull EXJavaScriptObject *)createSyncFunction:(nonnull NSString *)name
                                          argsCount:(NSInteger)argsCount
                                              block:(nonnull JSSyncFunctionBlock)block
@@ -195,15 +181,6 @@ static NSString *mainObjectPropertyName = @"expo";
 
 #pragma mark - Private
 
-- (void)initializeMainObject
-{
-  if (!_mainObject) {
-    // Add the main object to the runtime (`global.expo`).
-    _mainObject = [self createObject];
-    [[self global] defineProperty:mainObjectPropertyName value:_mainObject options:EXJavaScriptObjectPropertyDescriptorEnumerable];
-  }
-}
-
 - (nonnull EXJavaScriptObject *)createHostFunction:(nonnull NSString *)name
                                          argsCount:(NSInteger)argsCount
                                              block:(nonnull JSHostFunctionBlock)block

package/ios/RCTComponentData+Privates.h

@@ -10,3 +10,20 @@ typedef void (^RCTPropBlockAlias)(id<RCTComponent> _Nonnull view, id _Nullable j
 - (nonnull RCTPropBlockAlias)createPropBlock:(nonnull NSString *)name isShadowView:(BOOL)isShadowView;
 
 @end
+
+/**
+ This is a compatible adapter for Swift `ComponentData` to access react-native's `RCTComponentData`.
+ When running in react-native new architecture mode, the `eventDispatcher` is actually null.
+ however the`RCTComponentData` still expects it's nonnull because of the `NS_ASSUME_NONNULL_BEGIN`
+ https://github.com/facebook/react-native/blob/ea4724b37c9f78bd33daab547d6cc4f8b7f7dd81/packages/react-native/React/Views/RCTComponentData.h#L19-L35.
+ Swift will have a runtime exception from the implicitly unwrapping.
+ This compatible adapter basically allows the `eventDispatcher` to be nullable.
+ TODO: We should propose the fix to upstream and remove this adapter when dropping SDK 49.
+ */
+@interface RCTComponentDataSwiftAdapter : RCTComponentData
+
+- (nonnull instancetype)initWithManagerClass:(nonnull Class)managerClass
+                                      bridge:(nonnull RCTBridge *)bridge
+                             eventDispatcher:(nullable id<RCTEventDispatcherProtocol>)eventDispatcher;
+
+@end

package/ios/RCTComponentData+Privates.m

@@ -0,0 +1,15 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/RCTComponentData+Privates.h>
+#import <React/RCTComponentData.h>
+
+@implementation RCTComponentDataSwiftAdapter
+
+- (nonnull instancetype)initWithManagerClass:(nonnull Class)managerClass
+                                      bridge:(nonnull RCTBridge *)bridge
+                             eventDispatcher:(nullable id<RCTEventDispatcherProtocol>)eventDispatcher
+{
+  return [super initWithManagerClass:managerClass bridge:bridge eventDispatcher:nil];
+}
+
+@end