expo-modules-core 0.9.2 → 0.11.1

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

@@ -3,58 +3,106 @@ package expo.modules.kotlin.types
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import expo.modules.kotlin.jni.CppType
+import expo.modules.kotlin.jni.JavaScriptObject
+import expo.modules.kotlin.jni.JavaScriptValue
 
-class IntTypeConverter(isOptional: Boolean) : TypeConverter<Int>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): Int = value.asInt()
+class IntTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<Int>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): Int = value.asInt()
+  override fun convertFromAny(value: Any): Int = when (value) {
+    is Number -> value.toInt()
+    else -> value as Int
+  }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.DOUBLE)
 }
 
-class DoubleTypeConverter(isOptional: Boolean) : TypeConverter<Double>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): Double = value.asDouble()
+class DoubleTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<Double>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): Double = value.asDouble()
+  override fun convertFromAny(value: Any): Double = when (value) {
+    is Number -> value.toDouble()
+    else -> value as Double
+  }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.DOUBLE)
 }
 
-class FloatTypeConverter(isOptional: Boolean) : TypeConverter<Float>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): Float = value.asDouble().toFloat()
+class FloatTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<Float>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): Float = value.asDouble().toFloat()
+  override fun convertFromAny(value: Any): Float = when (value) {
+    is Number -> value.toFloat()
+    else -> value as Float
+  }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.DOUBLE)
 }
 
-class BoolTypeConverter(isOptional: Boolean) : TypeConverter<Boolean>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): Boolean = value.asBoolean()
+class BoolTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<Boolean>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): Boolean = value.asBoolean()
+  override fun convertFromAny(value: Any): Boolean = value as Boolean
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.BOOLEAN)
 }
 
-class StringTypeConverter(isOptional: Boolean) : TypeConverter<String>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): String = value.asString()
+class StringTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<String>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): String = value.asString()
+  override fun convertFromAny(value: Any): String = value as String
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.STRING)
 }
 
-class ReadableArrayTypeConverter(isOptional: Boolean) : TypeConverter<ReadableArray>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): ReadableArray = value.asArray()
+class ReadableArrayTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<ReadableArray>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): ReadableArray = value.asArray()
+  override fun convertFromAny(value: Any): ReadableArray = value as ReadableArray
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_ARRAY)
 }
 
-class ReadableMapTypeConverter(isOptional: Boolean) : TypeConverter<ReadableMap>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): ReadableMap = value.asMap()
+class ReadableMapTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<ReadableMap>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): ReadableMap = value.asMap()
+  override fun convertFromAny(value: Any): ReadableMap = value as ReadableMap
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_MAP)
 }
 
-class PrimitiveIntArrayTypeConverter(isOptional: Boolean) : TypeConverter<IntArray>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): IntArray {
+class PrimitiveIntArrayTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<IntArray>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): IntArray {
     val jsArray = value.asArray()
     return IntArray(jsArray.size()) { index ->
       jsArray.getInt(index)
     }
   }
+
+  override fun convertFromAny(value: Any): IntArray = value as IntArray
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_ARRAY)
 }
 
-class PrimitiveDoubleArrayTypeConverter(isOptional: Boolean) : TypeConverter<DoubleArray>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): DoubleArray {
+class PrimitiveDoubleArrayTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<DoubleArray>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): DoubleArray {
     val jsArray = value.asArray()
     return DoubleArray(jsArray.size()) { index ->
       jsArray.getDouble(index)
     }
   }
+
+  override fun convertFromAny(value: Any): DoubleArray = value as DoubleArray
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_ARRAY)
 }
 
-class PrimitiveFloatArrayTypeConverter(isOptional: Boolean) : TypeConverter<FloatArray>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): FloatArray {
+class PrimitiveFloatArrayTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<FloatArray>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): FloatArray {
     val jsArray = value.asArray()
     return FloatArray(jsArray.size()) { index ->
       jsArray.getDouble(index).toFloat()
     }
   }
+
+  override fun convertFromAny(value: Any): FloatArray = value as FloatArray
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_ARRAY)
+}
+
+class JavaScriptValueTypeConvert(isOptional: Boolean) : TypeConverter<JavaScriptValue>(isOptional) {
+  override fun convertNonOptional(value: Any): JavaScriptValue = value as JavaScriptValue
+  override fun getCppRequiredTypes(): List<CppType> = CppType.values().toList()
+}
+
+class JavaScriptObjectTypeConverter(isOptional: Boolean) : TypeConverter<JavaScriptObject>(isOptional) {
+  override fun convertNonOptional(value: Any): JavaScriptObject = value as JavaScriptObject
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.JS_OBJECT)
 }

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

@@ -2,6 +2,7 @@ package expo.modules.kotlin.types
 
 import com.facebook.react.bridge.Dynamic
 import expo.modules.kotlin.exception.IncompatibleArgTypeException
+import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.toKType
 import kotlin.reflect.KClass
 import kotlin.reflect.full.createType
@@ -11,22 +12,24 @@ import kotlin.reflect.full.primaryConstructor
 class EnumTypeConverter(
   private val enumClass: KClass<Enum<*>>,
   isOptional: Boolean
-) : TypeConverter<Enum<*>>(isOptional) {
-  override fun convertNonOptional(value: Dynamic): Enum<*> {
-    @Suppress("UNCHECKED_CAST")
-    val enumConstants = requireNotNull(enumClass.java.enumConstants) {
-      "Passed type is not an enum type."
-    }
-    require(enumConstants.isNotEmpty()) {
-      "Passed enum type is empty."
+) : DynamicAwareTypeConverters<Enum<*>>(isOptional) {
+  private val enumConstants = requireNotNull(enumClass.java.enumConstants) {
+    "Passed type is not an enum type"
+  }.also {
+    require(it.isNotEmpty()) {
+      "Passed enum type is empty"
     }
+  }
 
-    val primaryConstructor = requireNotNull(enumClass.primaryConstructor) {
-      "Cannot convert js value to enum without the primary constructor."
-    }
+  private val primaryConstructor = requireNotNull(enumClass.primaryConstructor) {
+    "Cannot convert js value to enum without the primary constructor"
+  }
 
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_MAP)
+
+  override fun convertFromDynamic(value: Dynamic): Enum<*> {
     if (primaryConstructor.parameters.isEmpty()) {
-      return convertEnumWithoutParameter(value, enumConstants)
+      return convertEnumWithoutParameter(value.asString(), enumConstants)
     } else if (primaryConstructor.parameters.size == 1) {
       return convertEnumWithParameter(
         value,
@@ -38,18 +41,31 @@ class EnumTypeConverter(
     throw IncompatibleArgTypeException(value.type.toKType(), enumClass.createType())
   }
 
+  override fun convertFromAny(value: Any): Enum<*> {
+    if (primaryConstructor.parameters.isEmpty()) {
+      return convertEnumWithoutParameter(value as String, enumConstants)
+    } else if (primaryConstructor.parameters.size == 1) {
+      return convertEnumWithParameter(
+        value,
+        enumConstants,
+        primaryConstructor.parameters.first().name!!
+      )
+    }
+
+    throw IncompatibleArgTypeException(value::class.createType(), enumClass.createType())
+  }
+
   /**
    * If the primary constructor doesn't take any parameters, we treat the name of each enum as a value.
    * So the jsValue has to contain string.
    */
   private fun convertEnumWithoutParameter(
-    jsValue: Dynamic,
+    stringRepresentation: String,
     enumConstants: Array<out Enum<*>>
   ): Enum<*> {
-    val unwrappedJsValue = jsValue.asString()
     return requireNotNull(
-      enumConstants.find { it.name == unwrappedJsValue }
-    ) { "Couldn't convert ${jsValue.asString()} to ${enumClass.simpleName}." }
+      enumConstants.find { it.name == stringRepresentation }
+    ) { "Couldn't convert '$stringRepresentation' to ${enumClass.simpleName}" }
   }
 
   /**
@@ -57,7 +73,7 @@ class EnumTypeConverter(
    * In that case, we handles two different types: Int and String.
    */
   private fun convertEnumWithParameter(
-    jsValue: Dynamic,
+    jsValue: Any,
     enumConstants: Array<out Enum<*>>,
     parameterName: String
   ): Enum<*> {
@@ -66,19 +82,31 @@ class EnumTypeConverter(
     val parameterProperty = enumClass
       .declaredMemberProperties
       .find { it.name == parameterName }
-    requireNotNull(parameterProperty) { "Cannot find a property for $parameterName parameter." }
+    requireNotNull(parameterProperty) { "Cannot find a property for $parameterName parameter" }
 
     val parameterType = parameterProperty.returnType.classifier
-    val jsUnwrapValue = if (parameterType == String::class) {
-      jsValue.asString()
+    val jsUnwrapValue = if (jsValue is Dynamic) {
+      if (parameterType == String::class) {
+        jsValue.asString()
+      } else {
+        jsValue.asInt()
+      }
     } else {
-      jsValue.asInt()
+      if (parameterType == String::class) {
+        jsValue as String
+      } else {
+        if (jsValue is Double) {
+          jsValue.toInt()
+        } else {
+          jsValue as Int
+        }
+      }
     }
 
     return requireNotNull(
       enumConstants.find {
         parameterProperty.get(it) == jsUnwrapValue
       }
-    ) { "Couldn't convert ${jsValue.asString()} to ${enumClass.simpleName} where $parameterName is the enum parameter. " }
+    ) { "Couldn't convert '$jsValue' to ${enumClass.simpleName} where $parameterName is the enum parameter" }
   }
 }

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

@@ -1,23 +1,37 @@
 package expo.modules.kotlin.types
 
 import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
 import expo.modules.kotlin.exception.CollectionElementCastException
 import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.recycle
 import kotlin.reflect.KType
 
 class ListTypeConverter(
   converterProvider: TypeConverterProvider,
   private val listType: KType,
-) : TypeConverter<List<*>>(listType.isMarkedNullable) {
+) : DynamicAwareTypeConverters<List<*>>(listType.isMarkedNullable) {
   private val elementConverter = converterProvider.obtainTypeConverter(
     requireNotNull(listType.arguments.first().type) {
       "The list type should contain the type of elements."
     }
   )
 
-  override fun convertNonOptional(value: Dynamic): List<*> {
+  override fun convertFromDynamic(value: Dynamic): List<*> {
     val jsArray = value.asArray()
+    return convertFromReadableArray(jsArray)
+  }
+
+  override fun convertFromAny(value: Any): List<*> {
+    if (value is ReadableArray) {
+      return convertFromReadableArray(value)
+    }
+
+    return value as List<*>
+  }
+
+  private fun convertFromReadableArray(jsArray: ReadableArray): List<*> {
     return List(jsArray.size()) { index ->
       jsArray.getDynamic(index).recycle {
         exceptionDecorator({ cause ->
@@ -28,4 +42,6 @@ class ListTypeConverter(
       }
     }
   }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_ARRAY)
 }

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

@@ -4,8 +4,10 @@ package expo.modules.kotlin.types
 
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.DynamicFromObject
+import com.facebook.react.bridge.ReadableMap
 import expo.modules.kotlin.exception.CollectionElementCastException
 import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.recycle
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
@@ -13,7 +15,7 @@ import kotlin.reflect.typeOf
 class MapTypeConverter(
   converterProvider: TypeConverterProvider,
   private val mapType: KType
-) : TypeConverter<Map<*, *>>(mapType.isMarkedNullable) {
+) : DynamicAwareTypeConverters<Map<*, *>>(mapType.isMarkedNullable) {
   init {
     require(mapType.arguments.first().type == typeOf<String>()) {
       "The map key type should be String, but received ${mapType.arguments.first()}."
@@ -26,8 +28,20 @@ class MapTypeConverter(
     }
   )
 
-  override fun convertNonOptional(value: Dynamic): Map<*, *> {
+  override fun convertFromDynamic(value: Dynamic): Map<*, *> {
     val jsMap = value.asMap()
+    return convertFromReadableMap(jsMap)
+  }
+
+  override fun convertFromAny(value: Any): Map<*, *> {
+    if (value is ReadableMap) {
+      return convertFromReadableMap(value)
+    }
+
+    return value as Map<*, *>
+  }
+
+  private fun convertFromReadableMap(jsMap: ReadableMap): Map<*, *> {
     val result = mutableMapOf<String, Any?>()
 
     jsMap.entryIterator.forEach { (key, value) ->
@@ -42,4 +56,6 @@ class MapTypeConverter(
 
     return result
   }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_MAP)
 }

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

@@ -4,13 +4,14 @@ import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableArray
 import expo.modules.kotlin.exception.CollectionElementCastException
 import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.recycle
 import kotlin.reflect.KType
 
 class PairTypeConverter(
   converterProvider: TypeConverterProvider,
   private val pairType: KType,
-) : TypeConverter<Pair<*, *>>(pairType.isMarkedNullable) {
+) : DynamicAwareTypeConverters<Pair<*, *>>(pairType.isMarkedNullable) {
   private val converters = listOf(
     converterProvider.obtainTypeConverter(
       requireNotNull(pairType.arguments.getOrNull(0)?.type) {
@@ -24,8 +25,20 @@ class PairTypeConverter(
     )
   )
 
-  override fun convertNonOptional(value: Dynamic): Pair<*, *> {
+  override fun convertFromDynamic(value: Dynamic): Pair<*, *> {
     val jsArray = value.asArray()
+    return convertFromReadableArray(jsArray)
+  }
+
+  override fun convertFromAny(value: Any): Pair<*, *> {
+    if (value is ReadableArray) {
+      return convertFromReadableArray(value)
+    }
+
+    return value as Pair<*, *>
+  }
+
+  private fun convertFromReadableArray(jsArray: ReadableArray): Pair<*, *> {
     return Pair(
       convertElement(jsArray, 0),
       convertElement(jsArray, 1)
@@ -41,4 +54,6 @@ class PairTypeConverter(
       }
     }
   }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_ARRAY)
 }

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

@@ -2,12 +2,23 @@ package expo.modules.kotlin.types
 
 import com.facebook.react.bridge.Dynamic
 import expo.modules.kotlin.exception.NullArgumentException
+import expo.modules.kotlin.jni.CppType
 
+/**
+ * Basic type converter. It has to handle two different inputs - [Dynamic] and [Any].
+ * The first one is used in the bridge implementation. The second one is used in the JSI.
+ */
 abstract class TypeConverter<Type : Any>(
+  /**
+   * Whether `null` can be assigned to the desired type.
+   */
   private val isOptional: Boolean
 ) {
-  open fun convert(value: Dynamic): Type? {
-    if (value.isNull) {
+  /**
+   * Tries to convert from [Any]? (can be also [Dynamic]) to the desired type.
+   */
+  fun convert(value: Any?): Type? {
+    if (value == null || value is Dynamic && value.isNull) {
       if (isOptional) {
         return null
       }
@@ -16,5 +27,34 @@ abstract class TypeConverter<Type : Any>(
     return convertNonOptional(value)
   }
 
-  abstract fun convertNonOptional(value: Dynamic): Type
+  /**
+   * Tries to convert from [Any] to the desired type.
+   * We know in that place that we're not dealing with `null`.
+   */
+  abstract fun convertNonOptional(value: Any): Type
+
+  /**
+   * Returns a list of C++ types that can be converted to the desired type.
+   * Sometimes we have a choice between multiple representations of the same value.
+   * For instance js object can be pass as [Map] or [expo.modules.kotlin.jni.JavaScriptObject].
+   * This value tells us which one we should choose.
+   */
+  abstract fun getCppRequiredTypes(): List<CppType>
+}
+
+/**
+ * A helper class to make a clear separation between [Any] and [Dynamic].
+ * Right it is used as a default base class for all converters, but this will change when we
+ * stop using the bridge to pass data between JS and Kotlin.
+ */
+abstract class DynamicAwareTypeConverters<T : Any>(isOptional: Boolean) : TypeConverter<T>(isOptional) {
+  override fun convertNonOptional(value: Any): T =
+    if (value is Dynamic) {
+      convertFromDynamic(value)
+    } else {
+      convertFromAny(value)
+    }
+
+  abstract fun convertFromDynamic(value: Dynamic): T
+  abstract fun convertFromAny(value: Any): T
 }

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

@@ -6,6 +6,8 @@ import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import expo.modules.kotlin.exception.MissingTypeConverter
+import expo.modules.kotlin.jni.JavaScriptObject
+import expo.modules.kotlin.jni.JavaScriptValue
 import expo.modules.kotlin.records.Record
 import expo.modules.kotlin.records.RecordTypeConverter
 import kotlin.reflect.KClass
@@ -28,6 +30,11 @@ inline fun <reified T> convert(value: Dynamic): T {
   return converter.convert(value) as T
 }
 
+inline fun <reified T> convert(value: Any?): T {
+  val converter = TypeConverterProviderImpl.obtainTypeConverter(typeOf<T>())
+  return converter.convert(value) as T
+}
+
 fun convert(value: Dynamic, type: KType): Any? {
   val converter = TypeConverterProviderImpl.obtainTypeConverter(type)
   return converter.convert(value)
@@ -110,6 +117,11 @@ object TypeConverterProviderImpl : TypeConverterProvider {
       IntArray::class.createType(nullable = isOptional) to PrimitiveIntArrayTypeConverter(isOptional),
       DoubleArray::class.createType(nullable = isOptional) to PrimitiveDoubleArrayTypeConverter(isOptional),
       FloatArray::class.createType(nullable = isOptional) to PrimitiveFloatArrayTypeConverter(isOptional),
+
+      JavaScriptValue::class.createType(nullable = isOptional) to JavaScriptValueTypeConvert(isOptional),
+      JavaScriptObject::class.createType(nullable = isOptional) to JavaScriptObjectTypeConverter(isOptional),
+
+      Any::class.createType(nullable = isOptional) to AnyTypeConverter(isOptional),
     )
   }
 }

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

@@ -1,4 +1,3 @@
-@file:OptIn(ExperimentalStdlibApi::class)
 @file:Suppress("FunctionName")
 
 package expo.modules.kotlin.views
@@ -32,14 +31,6 @@ class ViewGroupDefinitionBuilder {
     removeViewAtAction
   )
 
-  @Deprecated(
-    message = "The 'addChildView' component was renamed to 'AddChildView'.",
-    replaceWith = ReplaceWith("AddChildView(body)")
-  )
-  inline fun <reified ParentViewType : ViewGroup, reified ChildViewType : View> addChildView(
-    noinline body: (parent: ParentViewType, child: ChildViewType, index: Int) -> Unit
-  ) = AddChildView(body)
-
   inline fun <reified ParentViewType : ViewGroup, reified ChildViewType : View> AddChildView(
     noinline body: (parent: ParentViewType, child: ChildViewType, index: Int) -> Unit
   ) {
@@ -48,14 +39,6 @@ class ViewGroupDefinitionBuilder {
     }
   }
 
-  @Deprecated(
-    message = "The 'getChildCount' component was renamed to 'GetChildCount'.",
-    replaceWith = ReplaceWith("GetChildCount(body)")
-  )
-  inline fun <reified ParentViewType : ViewGroup> getChildCount(
-    noinline body: (view: ParentViewType) -> Int
-  ) = GetChildCount(body)
-
   inline fun <reified ParentViewType : ViewGroup> GetChildCount(
     noinline body: (view: ParentViewType) -> Int
   ) {
@@ -64,14 +47,6 @@ class ViewGroupDefinitionBuilder {
     }
   }
 
-  @Deprecated(
-    message = "The 'getChildViewAt' component was renamed to 'GetChildViewAt'.",
-    replaceWith = ReplaceWith("GetChildViewAt(body)")
-  )
-  inline fun <reified ParentViewType : ViewGroup, reified ChildViewType : View> getChildViewAt(
-    noinline body: (view: ParentViewType, index: Int) -> ChildViewType?
-  ) = GetChildViewAt(body)
-
   inline fun <reified ParentViewType : ViewGroup, reified ChildViewType : View> GetChildViewAt(
     noinline body: (view: ParentViewType, index: Int) -> ChildViewType?
   ) {
@@ -80,14 +55,6 @@ class ViewGroupDefinitionBuilder {
     }
   }
 
-  @Deprecated(
-    message = "The 'removeChildViewAt' component was renamed to 'RemoveChildViewAt'.",
-    replaceWith = ReplaceWith("RemoveChildViewAt(body)")
-  )
-  inline fun <reified ParentViewType : ViewGroup> removeChildViewAt(
-    noinline body: (view: ParentViewType, index: Int) -> Unit
-  ) = RemoveChildViewAt(body)
-
   inline fun <reified ParentViewType : ViewGroup> RemoveChildViewAt(
     noinline body: (view: ParentViewType, index: Int) -> Unit
   ) {
@@ -96,14 +63,6 @@ class ViewGroupDefinitionBuilder {
     }
   }
 
-  @Deprecated(
-    message = "The 'removeChildView' component was renamed to 'RemoveChildView'.",
-    replaceWith = ReplaceWith("RemoveChildView(body)")
-  )
-  inline fun <reified ParentViewType : ViewGroup, reified ChildViewType : View> removeChildView(
-    noinline body: (parent: ParentViewType, child: ChildViewType) -> Unit
-  ) = RemoveChildView(body)
-
   inline fun <reified ParentViewType : ViewGroup, reified ChildViewType : View> RemoveChildView(
     noinline body: (parent: ParentViewType, child: ChildViewType) -> Unit
   ) {

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

@@ -37,12 +37,6 @@ class ViewManagerDefinitionBuilder {
       viewGroupDefinition
     )
 
-  @Deprecated(
-    message = "The 'view' component was renamed to 'View'.",
-    replaceWith = ReplaceWith("View(body)")
-  )
-  inline fun <reified ViewType : View> view(noinline body: (Context) -> ViewType) = View(body)
-
   /**
    * Defines the factory creating a native view when the module is used as a view.
    */
@@ -51,12 +45,6 @@ class ViewManagerDefinitionBuilder {
     viewFactory = body
   }
 
-  @Deprecated(
-    message = "The 'onViewDestroys' component was renamed to 'OnViewDestroys'.",
-    replaceWith = ReplaceWith("OnViewDestroys(body)")
-  )
-  inline fun <reified ViewType : View> onViewDestroys(noinline body: (view: ViewType) -> Unit) = OnViewDestroys(body)
-
   /**
    * Creates view's lifecycle listener that is called right after the view isn't longer used by React Native.
    */
@@ -64,15 +52,6 @@ class ViewManagerDefinitionBuilder {
     onViewDestroys = { body(it as ViewType) }
   }
 
-  @Deprecated(
-    message = "The 'prop' component was renamed to 'Prop'.",
-    replaceWith = ReplaceWith("Prop(body)")
-  )
-  inline fun <reified ViewType : View, reified PropType> prop(
-    name: String,
-    noinline body: (view: ViewType, prop: PropType) -> Unit
-  ) = Prop(name, body)
-
   /**
    * Creates a view prop that defines its name and setter.
    */
@@ -87,12 +66,6 @@ class ViewManagerDefinitionBuilder {
     )
   }
 
-  @Deprecated(
-    message = "The 'events' component was renamed to 'Events'.",
-    replaceWith = ReplaceWith("Events(callbacks)")
-  )
-  fun events(vararg callbacks: String) = Events(*callbacks)
-
   /**
    * Defines prop names that should be treated as callbacks.
    */
@@ -100,12 +73,6 @@ class ViewManagerDefinitionBuilder {
     callbacksDefinition = CallbacksDefinition(callbacks)
   }
 
-  @Deprecated(
-    message = "The 'groupView' component was renamed to 'GroupView'.",
-    replaceWith = ReplaceWith("GroupView(callbacks)")
-  )
-  inline fun groupView(body: ViewGroupDefinitionBuilder.() -> Unit) = GroupView(body)
-
   /**
    * Creates the group view definition that scopes group view-related definitions.
    */

package/build/NativeModulesProxy.native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeModulesProxy.native.d.ts","sourceRoot":"","sources":["../src/NativeModulesProxy.native.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAM/D,QAAA,MAAM,kBAAkB,EAAE;IAAE,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,CAAA;CAAO,CAAC;AAkD3E,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"NativeModulesProxy.native.d.ts","sourceRoot":"","sources":["../src/NativeModulesProxy.native.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAQ/D,QAAA,MAAM,kBAAkB,EAAE;IAAE,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,CAAA;CAAO,CAAC;AA0D3E,eAAe,kBAAkB,CAAC"}

package/build/NativeModulesProxy.native.js

@@ -1,18 +1,24 @@
 import { NativeModules } from 'react-native';
-const NativeProxy = NativeModules.NativeUnimoduleProxy;
+const ExpoNativeProxy = global.ExpoModules?.NativeModulesProxy;
+const LegacyNativeProxy = NativeModules.NativeUnimoduleProxy;
 const modulesConstantsKey = 'modulesConstants';
 const exportedMethodsKey = 'exportedMethods';
 const NativeModulesProxy = {};
-if (NativeProxy) {
+if (LegacyNativeProxy) {
+    // use JSI proxy if available, fallback to legacy RN proxy
+    const NativeProxy = ExpoNativeProxy ?? LegacyNativeProxy;
     Object.keys(NativeProxy[exportedMethodsKey]).forEach((moduleName) => {
+        // copy constants
         NativeModulesProxy[moduleName] = NativeProxy[modulesConstantsKey][moduleName] || {};
+        // copy methods
         NativeProxy[exportedMethodsKey][moduleName].forEach((methodInfo) => {
             NativeModulesProxy[moduleName][methodInfo.name] = (...args) => {
                 const { key, argumentsCount } = methodInfo;
                 if (argumentsCount !== args.length) {
                     return Promise.reject(new Error(`Native method ${moduleName}.${methodInfo.name} expects ${argumentsCount} ${argumentsCount === 1 ? 'argument' : 'arguments'} but received ${args.length}`));
                 }
-                return NativeProxy.callMethod(moduleName, key, args);
+                // We still want to call methods using the legacy proxy in SDK 46
+                return LegacyNativeProxy.callMethod(moduleName, key, args);
             };
         });
         // These are called by EventEmitter (which is a wrapper for NativeEventEmitter)