expo-modules-core 1.5.5 → 1.5.7

package/CHANGELOG.md

@@ -10,6 +10,20 @@
 
 ### 💡 Others
 
+## 1.5.7 — 2023-07-12
+
+### 🐛 Bug fixes
+
+- Fixed regressions and crashes in the dev client introduced by [#23405](https://github.com/expo/expo/pull/23405). ([#23491](https://github.com/expo/expo/pull/23491) by [@kudo](https://github.com/kudo))
+
+## 1.5.6 — 2023-07-10
+
+### 🐛 Bug fixes
+
+- Fixed the Network Inspector cannot preview response body for response without the `Content-Length` header. ([#23405](https://github.com/expo/expo/pull/23405) by [@kudo](https://github.com/kudo))
+- Fixed `SoLoader` does not work on Android. ([#23415](https://github.com/expo/expo/pull/23415) by [@kudo](https://github.com/kudo))
+- Fixed slower boot time on Android. ([#23345](https://github.com/expo/expo/pull/23345) by [@lukmccall](https://github.com/lukmccall))
+
 ## 1.5.5 — 2023-07-07
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -6,7 +6,7 @@ apply plugin: 'maven-publish'
 apply plugin: "de.undercouch.download"
 
 group = 'host.exp.exponent'
-version = '1.5.5'
+version = '1.5.7'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -160,7 +160,7 @@ android {
     targetSdkVersion safeExtGet("targetSdkVersion", 33)
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "1.5.5"
+    versionName "1.5.7"
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled.toString()
 
     testInstrumentationRunner "expo.modules.TestRunner"

package/android/src/main/AndroidManifest.xml

@@ -1,9 +1,14 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          xmlns:tools="http://schemas.android.com/tools">
 
     <application>
         <meta-data
             android:name="org.unimodules.core.AppLoader#react-native-headless"
             android:value="expo.modules.adapters.react.apploader.RNHeadlessAppLoader" />
+        <meta-data
+            android:name="com.facebook.soloader.enabled"
+            android:value="true"
+            tools:replace="android:value" />
     </application>
 
 </manifest>

package/android/src/main/java/expo/modules/kotlin/classcomponent/ClassComponentBuilder.kt

@@ -49,7 +49,7 @@ class ClassComponentBuilder<SharedObjectType : Any>(
   inline fun <reified P0> Constructor(
     crossinline body: (p0: P0) -> SharedObjectType
   ): SyncFunctionComponent {
-    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }.also {
+    return SyncFunctionComponent("constructor", arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { body(it[0] as P0) }.also {
       constructor = it
     }
   }
@@ -57,7 +57,7 @@ class ClassComponentBuilder<SharedObjectType : Any>(
   inline fun <reified P0, reified P1> Constructor(
     crossinline body: (p0: P0, p1: P1) -> SharedObjectType
   ): SyncFunctionComponent {
-    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }.also {
+    return SyncFunctionComponent("constructor", arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }.also {
       constructor = it
     }
   }
@@ -65,7 +65,7 @@ class ClassComponentBuilder<SharedObjectType : Any>(
   inline fun <reified P0, reified P1, reified P2> Constructor(
     crossinline body: (p0: P0, p1: P1, p2: P2) -> SharedObjectType
   ): SyncFunctionComponent {
-    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also {
+    return SyncFunctionComponent("constructor", arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also {
       constructor = it
     }
   }
@@ -73,7 +73,7 @@ class ClassComponentBuilder<SharedObjectType : Any>(
   inline fun <reified P0, reified P1, reified P2, reified P3> Constructor(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> SharedObjectType
   ): SyncFunctionComponent {
-    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also {
+    return SyncFunctionComponent("constructor", arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also {
       constructor = it
     }
   }
@@ -81,7 +81,7 @@ class ClassComponentBuilder<SharedObjectType : Any>(
   inline fun <reified P0, reified P1, reified P2, reified P3, reified P4> Constructor(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> SharedObjectType
   ): SyncFunctionComponent {
-    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also {
+    return SyncFunctionComponent("constructor", arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also {
       constructor = it
     }
   }
@@ -89,7 +89,7 @@ class ClassComponentBuilder<SharedObjectType : Any>(
   inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> Constructor(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> SharedObjectType
   ): SyncFunctionComponent {
-    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also {
+    return SyncFunctionComponent("constructor", arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also {
       constructor = it
     }
   }
@@ -97,7 +97,7 @@ class ClassComponentBuilder<SharedObjectType : Any>(
   inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> Constructor(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> SharedObjectType
   ): SyncFunctionComponent {
-    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also {
+    return SyncFunctionComponent("constructor", arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also {
       constructor = it
     }
   }
@@ -105,7 +105,7 @@ class ClassComponentBuilder<SharedObjectType : Any>(
   inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> Constructor(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> SharedObjectType
   ): SyncFunctionComponent {
-    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also {
+    return SyncFunctionComponent("constructor", arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>(), { typeOf<P7>() }.toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also {
       constructor = it
     }
   }

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

@@ -54,14 +54,13 @@ object ExpoRequestCdpInterceptor : ExpoNetworkInspectOkHttpInterceptorsDelegate
     val params = ResponseReceivedParams(now, requestId, request, response)
     dispatchEvent(Event("Network.responseReceived", params))
 
-    val params2 = LoadingFinishedParams(now, requestId, request, response)
-    dispatchEvent(Event("Network.loadingFinished", params2))
-
-    val contentLength = response.body?.contentLength() ?: 0
-    if (contentLength >= 0 && contentLength <= ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE) {
-      val params3 = ExpoReceivedResponseBodyParams(now, requestId, request, response)
-      dispatchEvent(Event("Expo(Network.receivedResponseBody)", params3))
+    if (response.peekBody(ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE + 1).contentLength() <= ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE) {
+      val params2 = ExpoReceivedResponseBodyParams(now, requestId, request, response)
+      dispatchEvent(Event("Expo(Network.receivedResponseBody)", params2))
     }
+
+    val params3 = LoadingFinishedParams(now, requestId, request, response)
+    dispatchEvent(Event("Network.loadingFinished", params3))
   }
 
   //endregion ExpoNetworkInspectOkHttpInterceptorsDelegate implementations

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

@@ -205,10 +205,10 @@ data class LoadingFinishedParams(
   val timestamp: MonotonicTime,
   val encodedDataLength: Long,
 ) : JsonSerializable {
-  constructor(now: BigDecimal, requestId: RequestId, request: okhttp3.Request, repsonse: okhttp3.Response) : this(
+  constructor(now: BigDecimal, requestId: RequestId, request: okhttp3.Request, response: okhttp3.Response) : this(
     requestId = requestId,
     timestamp = now,
-    encodedDataLength = repsonse.body?.contentLength() ?: 0,
+    encodedDataLength = response.body?.contentLength() ?: 0,
   )
 
   override fun toJSONObject(): JSONObject {
@@ -230,8 +230,6 @@ data class ExpoReceivedResponseBodyParams(
     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")

package/android/src/main/java/expo/modules/kotlin/functions/AnyFunction.kt

@@ -12,9 +12,8 @@ import expo.modules.kotlin.jni.JavaScriptModuleObject
 import expo.modules.kotlin.jni.JavaScriptObject
 import expo.modules.kotlin.recycle
 import expo.modules.kotlin.types.AnyType
+import kotlin.reflect.KClass
 import kotlin.reflect.KType
-import kotlin.reflect.full.isSubtypeOf
-import kotlin.reflect.typeOf
 
 /**
  * Base class of all exported functions
@@ -31,9 +30,21 @@ abstract class AnyFunction(
   internal var ownerType: KType? = null
 
   internal val takesOwner: Boolean
-    get() = canTakeOwner &&
-      desiredArgsTypes.firstOrNull()?.kType?.isSubtypeOf(typeOf<JavaScriptObject>()) == true ||
-      (ownerType != null && desiredArgsTypes.firstOrNull()?.kType?.isSubtypeOf(ownerType!!) == true)
+    get() {
+      if (canTakeOwner) {
+        val firstArgumentType = desiredArgsTypes.firstOrNull()?.kType?.classifier as? KClass<*>
+          ?: return false
+
+        if (firstArgumentType == JavaScriptObject::class) {
+          return true
+        }
+
+        val ownerClass = ownerType?.classifier as? KClass<*> ?: return false
+
+        return firstArgumentType == ownerClass
+      }
+      return false
+    }
 
   /**
    * A minimum number of arguments the functions needs which equals to `argumentsCount` reduced by the number of trailing optional arguments.

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunctionBuilder.kt

@@ -17,49 +17,49 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   }
 
   inline fun <reified R, reified P0> SuspendBody(crossinline block: suspend (p0: P0) -> R): SuspendFunctionComponent {
-    return SuspendFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0) }.also {
+    return SuspendFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { block(it[0] as P0) }.also {
       suspendFunctionComponent = it
     }
   }
 
   inline fun <reified R, reified P0, reified P1> SuspendBody(crossinline block: suspend (p0: P0, p1: P1) -> R): SuspendFunctionComponent {
-    return SuspendFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { block(it[0] as P0, it[1] as P1) }.also {
+    return SuspendFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { block(it[0] as P0, it[1] as P1) }.also {
       suspendFunctionComponent = it
     }
   }
 
   inline fun <reified R, reified P0, reified P1, reified P2> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2) -> R): SuspendFunctionComponent {
-    return SuspendFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2) }.also {
+    return SuspendFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { block(it[0] as P0, it[1] as P1, it[2] as P2) }.also {
       suspendFunctionComponent = it
     }
   }
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3) -> R): SuspendFunctionComponent {
-    return SuspendFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also {
+    return SuspendFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also {
       suspendFunctionComponent = it
     }
   }
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R): SuspendFunctionComponent {
-    return SuspendFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also {
+    return SuspendFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also {
       suspendFunctionComponent = it
     }
   }
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R): SuspendFunctionComponent {
-    return SuspendFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also {
+    return SuspendFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also {
       suspendFunctionComponent = it
     }
   }
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R): SuspendFunctionComponent {
-    return SuspendFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also {
+    return SuspendFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also {
       suspendFunctionComponent = it
     }
   }
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R): SuspendFunctionComponent {
-    return SuspendFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also {
+    return SuspendFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>(), { typeOf<P7>() }.toAnyType<P7>())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also {
       suspendFunctionComponent = it
     }
   }

package/android/src/main/java/expo/modules/kotlin/modules/ModuleDefinitionBuilder.kt

@@ -16,6 +16,7 @@ import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.OnActivityResultPayload
 import expo.modules.kotlin.objects.ObjectDefinitionBuilder
 import expo.modules.kotlin.sharedobjects.SharedObject
+import expo.modules.kotlin.types.LazyKType
 import expo.modules.kotlin.views.ViewDefinitionBuilder
 import expo.modules.kotlin.views.ViewManagerDefinition
 import kotlin.reflect.KClass
@@ -62,8 +63,7 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
    */
   inline fun <reified T : View> View(viewClass: KClass<T>, body: ViewDefinitionBuilder<T>.() -> Unit) {
     require(viewManagerDefinition == null) { "The module definition may have exported only one view manager." }
-
-    val viewDefinitionBuilder = ViewDefinitionBuilder(viewClass, typeOf<T>())
+    val viewDefinitionBuilder = ViewDefinitionBuilder(viewClass, LazyKType(classifier = T::class, kTypeProvider = { typeOf<T>() }))
     body.invoke(viewDefinitionBuilder)
     viewManagerDefinition = viewDefinitionBuilder.build()
   }

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

@@ -111,7 +111,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }.also {
+    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { body(it[0] as P0) }.also {
       syncFunctions[name] = it
     }
   }
@@ -120,7 +120,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }.also {
+    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }.also {
       syncFunctions[name] = it
     }
   }
@@ -129,7 +129,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also {
+    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also {
       syncFunctions[name] = it
     }
   }
@@ -138,7 +138,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also {
+    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also {
       syncFunctions[name] = it
     }
   }
@@ -147,7 +147,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also {
+    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also {
       syncFunctions[name] = it
     }
   }
@@ -156,7 +156,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also {
+    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also {
       syncFunctions[name] = it
     }
   }
@@ -165,7 +165,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also {
+    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also {
       syncFunctions[name] = it
     }
   }
@@ -174,7 +174,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also {
+    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>(), { typeOf<P7>() }.toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also {
       syncFunctions[name] = it
     }
   }
@@ -205,7 +205,7 @@ open class ObjectDefinitionBuilder {
     return if (P0::class == Promise::class) {
       AsyncFunctionWithPromiseComponent(name, arrayOf()) { _, promise -> body(promise as P0) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { body(it[0] as P0) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -216,9 +216,9 @@ open class ObjectDefinitionBuilder {
     crossinline body: (p0: P0, p1: P1) -> R
   ): AsyncFunction {
     return if (P1::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { args, promise -> body(args[0] as P0, promise as P1) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -229,9 +229,9 @@ open class ObjectDefinitionBuilder {
     crossinline body: (p0: P0, p1: P1, p2: P2) -> R
   ): AsyncFunction {
     return if (P2::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -242,9 +242,9 @@ open class ObjectDefinitionBuilder {
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
   ): AsyncFunction {
     return if (P3::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -255,9 +255,9 @@ open class ObjectDefinitionBuilder {
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
   ): AsyncFunction {
     return if (P4::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -268,9 +268,9 @@ open class ObjectDefinitionBuilder {
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
   ): AsyncFunction {
     return if (P5::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -281,9 +281,9 @@ open class ObjectDefinitionBuilder {
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
   ): AsyncFunction {
     return if (P6::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -294,9 +294,9 @@ open class ObjectDefinitionBuilder {
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
   ): AsyncFunction {
     return if (P7::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>(), { typeOf<P7>() }.toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
     }.also {
       asyncFunctions[name] = it
     }

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

@@ -23,7 +23,7 @@ class PropertyComponentBuilder(
    * Modifier that sets property setter that receives only the new value as an argument.
    */
   inline fun <reified T> set(crossinline body: (newValue: T) -> Unit) = apply {
-    setter = SyncFunctionComponent("set", arrayOf(typeOf<T>().toAnyType())) { body(it[0] as T) }
+    setter = SyncFunctionComponent("set", arrayOf({ typeOf<T>() }.toAnyType<T>())) { body(it[0] as T) }
   }
 
   fun build(): PropertyComponent {

package/android/src/main/java/expo/modules/kotlin/records/RecordTypeConverter.kt

@@ -27,7 +27,7 @@ class RecordTypeConverter<T : Record>(
   val type: KType,
 ) : DynamicAwareTypeConverters<T>(type.isMarkedNullable) {
   private val objectConstructorFactory = ObjectConstructorFactory()
-  private val propertyDescriptors: Map<KProperty1<out Any, *>, PropertyDescriptor> =
+  private val propertyDescriptors: Map<KProperty1<out Any, *>, PropertyDescriptor> by lazy {
     (type.classifier as KClass<*>)
       .memberProperties
       .map { property ->
@@ -43,6 +43,7 @@ class RecordTypeConverter<T : Record>(
       }
       .filterNotNull()
       .toMap()
+  }
 
   override fun convertFromDynamic(value: Dynamic): T = exceptionDecorator({ cause -> RecordCastException(type, cause) }) {
     val jsMap = value.asMap()

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

@@ -2,11 +2,59 @@ package expo.modules.kotlin.types
 
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.jni.ExpectedType
+import kotlin.reflect.KClass
 import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
 
-fun KType.toAnyType(): AnyType = AnyType(this)
+class LazyKType(
+  override val classifier: KClass<*>,
+  override val isMarkedNullable: Boolean = false,
+  val kTypeProvider: () -> KType
+) : KType {
+  private var _kType: KType? = null
+  private val kType: KType
+    get() {
+      if (_kType == null) {
+        _kType = kTypeProvider()
+      }
+      return _kType!!
+    }
+
+  override val annotations: List<Annotation>
+    get() = kType.annotations
+  override val arguments: List<KTypeProjection>
+    get() = kType.arguments
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is LazyKType) return this.kType == other
+
+    return classifier == other.classifier && isMarkedNullable == other.isMarkedNullable
+  }
+
+  override fun hashCode(): Int {
+    var result = classifier.hashCode()
+    result = 31 * result + isMarkedNullable.hashCode()
+    return result
+  }
+
+  override fun toString(): String {
+    return kType.toString()
+  }
+}
+
+inline fun <reified T> (() -> KType).toAnyType() = AnyType(
+  LazyKType(
+    classifier = T::class,
+    isMarkedNullable = null is T,
+    kTypeProvider = this
+  )
+)
+
+class AnyType(
+  val kType: KType,
+) {
 
-class AnyType(val kType: KType) {
   private val converter: TypeConverter<*> by lazy {
     TypeConverterProviderImpl.obtainTypeConverter(kType)
   }

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

@@ -44,7 +44,6 @@ import java.net.URL
 import java.nio.file.Path
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
-import kotlin.reflect.full.createType
 import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.typeOf
 
@@ -73,12 +72,22 @@ fun convert(value: Dynamic, type: KType): Any? {
 }
 
 object TypeConverterProviderImpl : TypeConverterProvider {
-  private val cachedConverters = createCashedConverters(false) + createCashedConverters(true)
+  private val cachedConverters = createCachedConverters(false)
+  private val nullableCachedConverters = createCachedConverters(true)
+
   private val cachedRecordConverters = mutableMapOf<KClass<*>, TypeConverter<*>>()
   private val cachedCustomConverters = mutableMapOf<KType, TypeConverter<*>>()
 
+  private fun getCachedConverter(inputType: KType): TypeConverter<*>? {
+    return if (inputType.isMarkedNullable) {
+      nullableCachedConverters[inputType.classifier]
+    } else {
+      cachedConverters[inputType.classifier]
+    }
+  }
+
   override fun obtainTypeConverter(type: KType): TypeConverter<*> {
-    cachedConverters[type]?.let {
+    getCachedConverter(type)?.let {
       return it
     }
 
@@ -175,7 +184,7 @@ object TypeConverterProviderImpl : TypeConverterProvider {
     }
   }
 
-  private fun createCashedConverters(isOptional: Boolean): Map<KType, TypeConverter<*>> {
+  private fun createCachedConverters(isOptional: Boolean): Map<KClass<*>, TypeConverter<*>> {
     val intTypeConverter = createTrivialTypeConverter(
       isOptional, ExpectedType(CppType.INT)
     ) { it.asDouble().toInt() }
@@ -193,33 +202,33 @@ object TypeConverterProviderImpl : TypeConverterProvider {
     ) { it.asBoolean() }
 
     val converters = mapOf(
-      Int::class.createType(nullable = isOptional) to intTypeConverter,
-      java.lang.Integer::class.createType(nullable = isOptional) to intTypeConverter,
+      Int::class to intTypeConverter,
+      java.lang.Integer::class to intTypeConverter,
 
-      Long::class.createType(nullable = isOptional) to longTypeConverter,
-      java.lang.Long::class.createType(nullable = isOptional) to longTypeConverter,
+      Long::class to longTypeConverter,
+      java.lang.Long::class to longTypeConverter,
 
-      Double::class.createType(nullable = isOptional) to doubleTypeConverter,
-      java.lang.Double::class.createType(nullable = isOptional) to doubleTypeConverter,
+      Double::class to doubleTypeConverter,
+      java.lang.Double::class to doubleTypeConverter,
 
-      Float::class.createType(nullable = isOptional) to floatTypeConverter,
-      java.lang.Float::class.createType(nullable = isOptional) to floatTypeConverter,
+      Float::class to floatTypeConverter,
+      java.lang.Float::class to floatTypeConverter,
 
-      Boolean::class.createType(nullable = isOptional) to boolTypeConverter,
-      java.lang.Boolean::class.createType(nullable = isOptional) to boolTypeConverter,
+      Boolean::class to boolTypeConverter,
+      java.lang.Boolean::class to boolTypeConverter,
 
-      String::class.createType(nullable = isOptional) to createTrivialTypeConverter(
+      String::class to createTrivialTypeConverter(
         isOptional, ExpectedType(CppType.STRING)
       ) { it.asString() },
 
-      ReadableArray::class.createType(nullable = isOptional) to createTrivialTypeConverter(
+      ReadableArray::class to createTrivialTypeConverter(
         isOptional, ExpectedType(CppType.READABLE_ARRAY)
       ) { it.asArray() },
-      ReadableMap::class.createType(nullable = isOptional) to createTrivialTypeConverter(
+      ReadableMap::class to createTrivialTypeConverter(
         isOptional, ExpectedType(CppType.READABLE_MAP)
       ) { it.asMap() },
 
-      IntArray::class.createType(nullable = isOptional) to createTrivialTypeConverter(
+      IntArray::class to createTrivialTypeConverter(
         isOptional, ExpectedType.forPrimitiveArray(CppType.INT)
       ) {
         val jsArray = it.asArray()
@@ -227,7 +236,7 @@ object TypeConverterProviderImpl : TypeConverterProvider {
           jsArray.getInt(index)
         }
       },
-      DoubleArray::class.createType(nullable = isOptional) to createTrivialTypeConverter(
+      DoubleArray::class to createTrivialTypeConverter(
         isOptional, ExpectedType.forPrimitiveArray(CppType.DOUBLE)
       ) {
         val jsArray = it.asArray()
@@ -235,7 +244,7 @@ object TypeConverterProviderImpl : TypeConverterProvider {
           jsArray.getDouble(index)
         }
       },
-      FloatArray::class.createType(nullable = isOptional) to createTrivialTypeConverter(
+      FloatArray::class to createTrivialTypeConverter(
         isOptional, ExpectedType.forPrimitiveArray(CppType.FLOAT)
       ) {
         val jsArray = it.asArray()
@@ -243,7 +252,7 @@ object TypeConverterProviderImpl : TypeConverterProvider {
           jsArray.getDouble(index).toFloat()
         }
       },
-      BooleanArray::class.createType(nullable = isOptional) to createTrivialTypeConverter(
+      BooleanArray::class to createTrivialTypeConverter(
         isOptional, ExpectedType.forPrimitiveArray(CppType.BOOLEAN)
       ) {
         val jsArray = it.asArray()
@@ -252,39 +261,39 @@ object TypeConverterProviderImpl : TypeConverterProvider {
         }
       },
 
-      JavaScriptValue::class.createType(nullable = isOptional) to createTrivialTypeConverter(
+      JavaScriptValue::class to createTrivialTypeConverter(
         isOptional, ExpectedType(CppType.JS_VALUE)
       ),
-      JavaScriptObject::class.createType(nullable = isOptional) to createTrivialTypeConverter(
+      JavaScriptObject::class to createTrivialTypeConverter(
         isOptional, ExpectedType(CppType.JS_OBJECT)
       ),
 
-      Int8Array::class.createType(nullable = isOptional) to Int8ArrayTypeConverter(isOptional),
-      Int16Array::class.createType(nullable = isOptional) to Int16ArrayTypeConverter(isOptional),
-      Int32Array::class.createType(nullable = isOptional) to Int32ArrayTypeConverter(isOptional),
-      Uint8Array::class.createType(nullable = isOptional) to Uint8ArrayTypeConverter(isOptional),
-      Uint8ClampedArray::class.createType(nullable = isOptional) to Uint8ClampedArrayTypeConverter(isOptional),
-      Uint16Array::class.createType(nullable = isOptional) to Uint16ArrayTypeConverter(isOptional),
-      Uint32Array::class.createType(nullable = isOptional) to Uint32ArrayTypeConverter(isOptional),
-      Float32Array::class.createType(nullable = isOptional) to Float32ArrayTypeConverter(isOptional),
-      Float64Array::class.createType(nullable = isOptional) to Float64ArrayTypeConverter(isOptional),
-      BigInt64Array::class.createType(nullable = isOptional) to BigInt64ArrayTypeConverter(isOptional),
-      BigUint64Array::class.createType(nullable = isOptional) to BigUint64ArrayTypeConverter(isOptional),
-      TypedArray::class.createType(nullable = isOptional) to TypedArrayTypeConverter(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),
-
-      File::class.createType(nullable = isOptional) to FileTypeConverter(isOptional),
-
-      Any::class.createType(nullable = isOptional) to AnyTypeConverter(isOptional),
+      Int8Array::class to Int8ArrayTypeConverter(isOptional),
+      Int16Array::class to Int16ArrayTypeConverter(isOptional),
+      Int32Array::class to Int32ArrayTypeConverter(isOptional),
+      Uint8Array::class to Uint8ArrayTypeConverter(isOptional),
+      Uint8ClampedArray::class to Uint8ClampedArrayTypeConverter(isOptional),
+      Uint16Array::class to Uint16ArrayTypeConverter(isOptional),
+      Uint32Array::class to Uint32ArrayTypeConverter(isOptional),
+      Float32Array::class to Float32ArrayTypeConverter(isOptional),
+      Float64Array::class to Float64ArrayTypeConverter(isOptional),
+      BigInt64Array::class to BigInt64ArrayTypeConverter(isOptional),
+      BigUint64Array::class to BigUint64ArrayTypeConverter(isOptional),
+      TypedArray::class to TypedArrayTypeConverter(isOptional),
+
+      URL::class to URLTypConverter(isOptional),
+      Uri::class to UriTypeConverter(isOptional),
+      URI::class to JavaURITypeConverter(isOptional),
+
+      File::class to FileTypeConverter(isOptional),
+
+      Any::class to AnyTypeConverter(isOptional),
     )
 
     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),
+        Path::class to PathTypeConverter(isOptional),
+        Color::class to ColorTypeConverter(isOptional),
       )
     }
 

package/android/src/main/java/expo/modules/kotlin/views/GroupViewManagerWrapper.kt

@@ -37,7 +37,7 @@ class GroupViewManagerWrapper(
   override fun getNativeProps(): MutableMap<String, String> {
     val props = super.getNativeProps()
     viewWrapperDelegate.props.forEach { (key, prop) ->
-      props[key] = prop.type.kType.toString()
+      props[key] = prop.type.kType.classifier.toString()
     }
     return props
   }

package/android/src/main/java/expo/modules/kotlin/views/SimpleViewManagerWrapper.kt

@@ -35,7 +35,7 @@ class SimpleViewManagerWrapper(
   override fun getNativeProps(): MutableMap<String, String> {
     val props = super.getNativeProps()
     viewWrapperDelegate.props.forEach { (key, prop) ->
-      props[key] = prop.type.kType.toString()
+      props[key] = prop.type.kType.classifier.toString()
     }
     return props
   }

package/android/src/main/java/expo/modules/kotlin/views/ViewDefinitionBuilder.kt

@@ -111,7 +111,7 @@ class ViewDefinitionBuilder<T : View>(
   ) {
     props[name] = ConcreteViewProp(
       name,
-      typeOf<PropType>().toAnyType(),
+      { typeOf<PropType>() }.toAnyType<PropType>(),
       body
     )
   }
@@ -126,7 +126,7 @@ class ViewDefinitionBuilder<T : View>(
   ) {
     props[name] = ConcreteViewProp(
       name,
-      typeOf<PropType>().toAnyType(),
+      { typeOf<PropType>() }.toAnyType<PropType>(),
       body
     )
   }
@@ -184,7 +184,7 @@ class ViewDefinitionBuilder<T : View>(
     return if (P0::class == Promise::class) {
       AsyncFunctionWithPromiseComponent(name, arrayOf()) { _, promise -> body(promise as P0) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { body(it[0] as P0) }
     }.also {
       it.ownerType = viewType
       asyncFunctions[name] = it
@@ -196,9 +196,9 @@ class ViewDefinitionBuilder<T : View>(
     crossinline body: (p0: P0, p1: P1) -> R
   ): AsyncFunction {
     return if (P1::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { args, promise -> body(args[0] as P0, promise as P1) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -209,9 +209,9 @@ class ViewDefinitionBuilder<T : View>(
     crossinline body: (p0: P0, p1: P1, p2: P2) -> R
   ): AsyncFunction {
     return if (P2::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -222,9 +222,9 @@ class ViewDefinitionBuilder<T : View>(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
   ): AsyncFunction {
     return if (P3::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -235,9 +235,9 @@ class ViewDefinitionBuilder<T : View>(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
   ): AsyncFunction {
     return if (P4::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -248,9 +248,9 @@ class ViewDefinitionBuilder<T : View>(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
   ): AsyncFunction {
     return if (P5::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -261,9 +261,9 @@ class ViewDefinitionBuilder<T : View>(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
   ): AsyncFunction {
     return if (P6::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
     }.also {
       asyncFunctions[name] = it
     }
@@ -274,9 +274,9 @@ class ViewDefinitionBuilder<T : View>(
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
   ): AsyncFunction {
     return if (P7::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
+      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
     } else {
-      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
+      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>(), { typeOf<P7>() }.toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
     }.also {
       asyncFunctions[name] = it
     }

package/ios/Swift/DevTools/CdpNetworkTypes.swift

@@ -62,7 +62,7 @@ struct CdpNetwork {
     let mimeType: String
     let encodedDataLength: Int64
 
-    init(_ response: HTTPURLResponse) {
+    init(_ response: HTTPURLResponse, encodedDataLength: Int64) {
       self.url = response.url?.absoluteString ?? ""
       self.status = response.statusCode
       self.statusText = ""
@@ -73,7 +73,7 @@ struct CdpNetwork {
       }
       self.headers = headers
       self.mimeType = response.value(forHTTPHeaderField: "Content-Type") ?? ""
-      self.encodedDataLength = response.expectedContentLength
+      self.encodedDataLength = encodedDataLength
     }
   }
 
@@ -94,13 +94,13 @@ struct CdpNetwork {
     var referrerPolicy = "no-referrer"
     let type: ResourceType
 
-    init(now: TimeInterval, requestId: RequestId, request: URLRequest, redirectResponse: HTTPURLResponse?) {
+    init(now: TimeInterval, requestId: RequestId, request: URLRequest, encodedDataLength: Int64, redirectResponse: HTTPURLResponse?) {
       self.requestId = requestId
       self.request = Request(request)
       self.timestamp = now
       self.wallTime = now
       if let redirectResponse = redirectResponse {
-        self.redirectResponse = Response(redirectResponse)
+        self.redirectResponse = Response(redirectResponse, encodedDataLength: encodedDataLength)
       } else {
         self.redirectResponse = nil
       }
@@ -129,10 +129,10 @@ struct CdpNetwork {
     let response: Response
     var hasExtraInfo = false
 
-    init(now: TimeInterval, requestId: RequestId, request: URLRequest, response: HTTPURLResponse) {
+    init(now: TimeInterval, requestId: RequestId, request: URLRequest, response: HTTPURLResponse, encodedDataLength: Int64) {
       self.requestId = requestId
       self.timestamp = now
-      self.response = Response(response)
+      self.response = Response(response, encodedDataLength: encodedDataLength)
       self.type = ResourceType.fromMimeType(self.response.mimeType)
     }
   }
@@ -142,10 +142,10 @@ struct CdpNetwork {
     let timestamp: MonotonicTime
     let encodedDataLength: Int64
 
-    init(now: TimeInterval, requestId: RequestId, request: URLRequest, response: HTTPURLResponse) {
+    init(now: TimeInterval, requestId: RequestId, encodedDataLength: Int64) {
       self.requestId = requestId
       self.timestamp = now
-      self.encodedDataLength = response.expectedContentLength
+      self.encodedDataLength = encodedDataLength
     }
   }
 

package/ios/Swift/DevTools/ExpoRequestCdpInterceptor.swift

@@ -34,30 +34,42 @@ public final class ExpoRequestCdpInterceptor: NSObject, ExpoRequestInterceptorPr
 
   // MARK: ExpoRequestInterceptorProtocolDelegate implementations
 
-  func willSendRequest(requestId: String, request: URLRequest, redirectResponse: HTTPURLResponse?) {
+  func willSendRequest(requestId: String, task: URLSessionTask, request: URLRequest, redirectResponse: HTTPURLResponse?) {
     let now = Date().timeIntervalSince1970
 
-    let params = CdpNetwork.RequestWillBeSentParams(now: now, requestId: requestId, request: request, redirectResponse: redirectResponse)
+    let params = CdpNetwork.RequestWillBeSentParams(
+      now: now,
+      requestId: requestId,
+      request: request,
+      encodedDataLength: task.countOfBytesReceived,
+      redirectResponse: redirectResponse)
     dispatchEvent(CdpNetwork.Event(method: "Network.requestWillBeSent", params: params))
 
     let params2 = CdpNetwork.RequestWillBeSentExtraInfoParams(now: now, requestId: requestId, request: request)
     dispatchEvent(CdpNetwork.Event(method: "Network.requestWillBeSentExtraInfo", params: params2))
   }
 
-  func didReceiveResponse(requestId: String, request: URLRequest, response: HTTPURLResponse) {
+  func didReceiveResponse(requestId: String, task: URLSessionTask, responseBody: Data, isText: Bool, responseBodyExceedsLimit: Bool) {
+    guard let request = task.currentRequest, let response = task.response as? HTTPURLResponse else {
+      return
+    }
     let now = Date().timeIntervalSince1970
 
-    let params = CdpNetwork.ResponseReceivedParams(now: now, requestId: requestId, request: request, response: response)
+    let params = CdpNetwork.ResponseReceivedParams(
+      now: now,
+      requestId: requestId,
+      request: request,
+      response: response,
+      encodedDataLength: task.countOfBytesReceived)
     dispatchEvent(CdpNetwork.Event(method: "Network.responseReceived", params: params))
 
-    let params2 = CdpNetwork.LoadingFinishedParams(now: now, requestId: requestId, request: request, response: response)
-    dispatchEvent(CdpNetwork.Event(method: "Network.loadingFinished", params: params2))
-  }
+    if !responseBodyExceedsLimit {
+      let params2 = CdpNetwork.ExpoReceivedResponseBodyParams(now: now, requestId: requestId, responseBody: responseBody, isText: isText)
+      dispatchEvent(CdpNetwork.Event(method: "Expo(Network.receivedResponseBody)", params: params2))
+    }
 
-  func didReceiveResponseBody(requestId: String, responseBody: Data, isText: Bool) {
-    let now = Date().timeIntervalSince1970
-    let params = CdpNetwork.ExpoReceivedResponseBodyParams(now: now, requestId: requestId, responseBody: responseBody, isText: isText)
-    dispatchEvent(CdpNetwork.Event(method: "Expo(Network.receivedResponseBody)", params: params))
+    let params3 = CdpNetwork.LoadingFinishedParams(now: now, requestId: requestId, encodedDataLength: task.countOfBytesReceived)
+    dispatchEvent(CdpNetwork.Event(method: "Network.loadingFinished", params: params3))
   }
 }
 

package/ios/Swift/DevTools/ExpoRequestInterceptorProtocol.swift

@@ -16,8 +16,7 @@ public final class ExpoRequestInterceptorProtocol: URLProtocol, URLSessionDataDe
   )
   private var dataTask_: URLSessionDataTask?
   private let responseBody = NSMutableData()
-  private var responseIsText = false
-  private var responseContentLength: Int64 = 0
+  private var responseBodyExceedsLimit = false
 
   static let MAX_BODY_SIZE = 1_048_576
 
@@ -55,12 +54,14 @@ public final class ExpoRequestInterceptorProtocol: URLProtocol, URLSessionDataDe
       forKey: Self.REQUEST_ID,
       in: mutableRequest
     )
+    let dataTask = urlSession.dataTask(with: mutableRequest as URLRequest)
     Self.delegate.willSendRequest(
       requestId: requestId,
+      task: dataTask,
       request: mutableRequest as URLRequest,
       redirectResponse: nil
     )
-    dataTask_ = urlSession.dataTask(with: mutableRequest as URLRequest)
+    dataTask_ = dataTask
   }
 
   public override class func canonicalRequest(for request: URLRequest) -> URLRequest {
@@ -81,47 +82,25 @@ public final class ExpoRequestInterceptorProtocol: URLProtocol, URLSessionDataDe
     client?.urlProtocol(self, didLoad: data)
     if responseBody.length + data.count <= Self.MAX_BODY_SIZE {
       responseBody.append(data)
+    } else {
+      responseBodyExceedsLimit = true
     }
   }
 
-  public func urlSession(
-    _: URLSession,
-    dataTask: URLSessionDataTask,
-    didReceive response: URLResponse,
-    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
-  ) {
-    if let resp = response as? HTTPURLResponse,
-      let currentRequest = dataTask.currentRequest,
-      let requestId = URLProtocol.property(
-        forKey: Self.REQUEST_ID,
-        in: currentRequest
-      ) as? String {
-      Self.delegate.didReceiveResponse(
-        requestId: requestId,
-        request: currentRequest,
-        response: resp
-      )
-
-      let contentType = resp.value(forHTTPHeaderField: "Content-Type")
-      responseIsText = (contentType?.starts(with: "text/") ?? false) || contentType == "application/json"
-      responseContentLength = resp.expectedContentLength
-    }
-    completionHandler(.allow)
-    client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .allowed)
-  }
-
   public func urlSession(_: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
     if let error = error {
       client?.urlProtocol(self, didFailWithError: error)
     } else {
-      if responseContentLength > 0 && responseContentLength <= Self.MAX_BODY_SIZE,
-        let currentRequest = task.currentRequest,
+      if let currentRequest = task.currentRequest,
+        let response = task.response as? HTTPURLResponse,
         let requestId = URLProtocol.property(
           forKey: Self.REQUEST_ID,
           in: currentRequest
         ) as? String {
-        Self.delegate.didReceiveResponseBody(
-          requestId: requestId, responseBody: responseBody as Data, isText: responseIsText)
+        let contentType = response.value(forHTTPHeaderField: "Content-Type")
+        let isText = (contentType?.starts(with: "text/") ?? false) || contentType == "application/json"
+        Self.delegate.didReceiveResponse(
+          requestId: requestId, task: task, responseBody: responseBody as Data, isText: isText, responseBodyExceedsLimit: responseBodyExceedsLimit)
       }
       client?.urlProtocolDidFinishLoading(self)
     }
@@ -129,7 +108,17 @@ public final class ExpoRequestInterceptorProtocol: URLProtocol, URLSessionDataDe
 
   public func urlSession(
     _: URLSession,
-    task _: URLSessionTask,
+    dataTask: URLSessionDataTask,
+    didReceive response: URLResponse,
+    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
+  ) {
+    completionHandler(.allow)
+    client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .allowed)
+  }
+
+  public func urlSession(
+    _: URLSession,
+    task: URLSessionTask,
     willPerformHTTPRedirection response: HTTPURLResponse,
     newRequest request: URLRequest,
     completionHandler: @escaping (URLRequest?) -> Void
@@ -137,6 +126,7 @@ public final class ExpoRequestInterceptorProtocol: URLProtocol, URLSessionDataDe
     if let requestId = URLProtocol.property(forKey: Self.REQUEST_ID, in: request) as? String {
       Self.delegate.willSendRequest(
         requestId: requestId,
+        task: task,
         request: request,
         redirectResponse: response
       )
@@ -173,11 +163,8 @@ public final class ExpoRequestInterceptorProtocol: URLProtocol, URLSessionDataDe
 @objc(EXRequestInterceptorProtocolDelegate)
 protocol ExpoRequestInterceptorProtocolDelegate {
   @objc
-  func willSendRequest(requestId: String, request: URLRequest, redirectResponse: HTTPURLResponse?)
-
-  @objc
-  func didReceiveResponse(requestId: String, request: URLRequest, response: HTTPURLResponse)
+  func willSendRequest(requestId: String, task: URLSessionTask, request: URLRequest, redirectResponse: HTTPURLResponse?)
 
   @objc
-  func didReceiveResponseBody(requestId: String, responseBody: Data, isText: Bool)
+  func didReceiveResponse(requestId: String, task: URLSessionTask, responseBody: Data, isText: Bool, responseBodyExceedsLimit: Bool)
 }

package/ios/Tests/ExpoRequestCdpInterceptorSpec.swift

@@ -77,22 +77,24 @@ final class ExpoRequestCdpInterceptorSpec: ExpoSpec {
             expect(params["requestId"] as? String).to(equal(requestId))
             expect(response["status"] as? Int).to(equal(200))
             expect((response["headers"] as! [String: Any]).count).to(beGreaterThan(0))
+            expect(response["encodedDataLength"] as? Int64).to(beGreaterThan(0))
 
-            // Network.loadingFinished
+            // Expo(Network.receivedResponseBody)
             json = self.parseJSON(data: self.mockDelegate.events[3])
             method = json["method"] as! String
             params = json["params"] as! [String: Any]
-            expect(method).to(equal("Network.loadingFinished"))
+            expect(method).to(equal("Expo(Network.receivedResponseBody)"))
             expect(params["requestId"] as? String).to(equal(requestId))
+            expect(params["body"] as? String).notTo(beEmpty())
+            expect(params["base64Encoded"] as? Bool).to(beFalse())
 
-            // Expo(Network.receivedResponseBody)
+            // Network.loadingFinished
             json = self.parseJSON(data: self.mockDelegate.events[4])
             method = json["method"] as! String
             params = json["params"] as! [String: Any]
-            expect(method).to(equal("Expo(Network.receivedResponseBody)"))
+            expect(method).to(equal("Network.loadingFinished"))
             expect(params["requestId"] as? String).to(equal(requestId))
-            expect(params["body"] as? String).notTo(beEmpty())
-            expect(params["base64Encoded"] as? Bool).to(beFalse())
+            expect(params["encodedDataLength"] as? Int64).to(beGreaterThan(0))
 
             done()
           }
@@ -145,10 +147,8 @@ final class ExpoRequestCdpInterceptorSpec: ExpoSpec {
             expect(response["mimeType"] as? String).to(equal("image/png"))
             expect((response["headers"] as! [String: Any]).count).to(beGreaterThan(0))
 
-            // Network.loadingFinished
-
             // Expo(Network.receivedResponseBody)
-            json = self.parseJSON(data: self.mockDelegate.events[6])
+            json = self.parseJSON(data: self.mockDelegate.events[5])
             method = json["method"] as! String
             params = json["params"] as! [String: Any]
             expect(method).to(equal("Expo(Network.receivedResponseBody)"))
@@ -156,13 +156,14 @@ final class ExpoRequestCdpInterceptorSpec: ExpoSpec {
             expect(params["body"] as? String).notTo(beEmpty())
             expect(params["base64Encoded"] as? Bool).to(beTrue())
 
+            // Network.loadingFinished
+
             done()
           }
         }.resume()
       }
     }
 
-
     it("respect image mimeType to CDP event") {
       waitUntil(timeout: .seconds(2)) { done in
         self.session.dataTask(with: URL(string: "https://avatars.githubusercontent.com/u/12504344")!) { (data, response, error) in
@@ -187,5 +188,29 @@ final class ExpoRequestCdpInterceptorSpec: ExpoSpec {
         }.resume()
       }
     }
+
+    it("skip `receivedResponseBody` when response size exceeding 1MB limit") {
+      waitUntil(timeout: .seconds(5)) { done in
+        self.session.dataTask(with: URL(string: "https://raw.githubusercontent.com/expo/expo/main/apps/native-component-list/assets/videos/ace.mp4")!) { (data, response, error) in
+          DispatchQueue.main.async {
+            expect(self.mockDelegate.events.count).to(equal(4))
+
+            var json = self.parseJSON(data: self.mockDelegate.events[0])
+            expect(json["method"] as! String).to(equal("Network.requestWillBeSent"))
+
+            json = self.parseJSON(data: self.mockDelegate.events[1])
+            expect(json["method"] as! String).to(equal("Network.requestWillBeSentExtraInfo"))
+
+            json = self.parseJSON(data: self.mockDelegate.events[2])
+            expect(json["method"] as! String).to(equal("Network.responseReceived"))
+
+            json = self.parseJSON(data: self.mockDelegate.events[3])
+            expect(json["method"] as! String).to(equal("Network.loadingFinished"))
+
+            done()
+          }
+        }.resume()
+      }
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "1.5.5",
+  "version": "1.5.7",
   "description": "The core of Expo Modules architecture",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -42,5 +42,5 @@
     "@testing-library/react-hooks": "^7.0.1",
     "expo-module-scripts": "^3.0.0"
   },
-  "gitHead": "877ace22b823159ff94d02bacfb27e523263967c"
+  "gitHead": "8fdc53c90c52242a80ea511ee3073d9ab950bc68"
 }