expo-modules-core 0.9.0 → 0.10.0

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

@@ -1,13 +1,16 @@
 package expo.modules.kotlin.records
 
 import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableMap
 import expo.modules.kotlin.allocators.ObjectConstructor
 import expo.modules.kotlin.allocators.ObjectConstructorFactory
 import expo.modules.kotlin.exception.FieldCastException
 import expo.modules.kotlin.exception.FieldRequiredException
 import expo.modules.kotlin.exception.RecordCastException
 import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.recycle
+import expo.modules.kotlin.types.DynamicAwareTypeConverters
 import expo.modules.kotlin.types.TypeConverter
 import expo.modules.kotlin.types.TypeConverterProvider
 import kotlin.reflect.KClass
@@ -21,7 +24,7 @@ import kotlin.reflect.jvm.javaField
 class RecordTypeConverter<T : Record>(
   private val converterProvider: TypeConverterProvider,
   val type: KType,
-) : TypeConverter<T>(type.isMarkedNullable) {
+) : DynamicAwareTypeConverters<T>(type.isMarkedNullable) {
   private val objectConstructorFactory = ObjectConstructorFactory()
   private val propertyDescriptors: Map<KProperty1<out Any, *>, PropertyDescriptor> =
     (type.classifier as KClass<*>)
@@ -40,9 +43,23 @@ class RecordTypeConverter<T : Record>(
       .filterNotNull()
       .toMap()
 
-  override fun convertNonOptional(value: Dynamic): T = exceptionDecorator({ cause -> RecordCastException(type, cause) }) {
+  override fun convertFromDynamic(value: Dynamic): T = exceptionDecorator({ cause -> RecordCastException(type, cause) }) {
     val jsMap = value.asMap()
+    return convertFromReadableMap(jsMap)
+  }
+
+  override fun convertFromAny(value: Any): T {
+    if (value is ReadableMap) {
+      return convertFromReadableMap(value)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    return value as T
+  }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_MAP)
 
+  private fun convertFromReadableMap(jsMap: ReadableMap): T {
     val kClass = type.classifier as KClass<*>
     val instance = getObjectConstructor(kClass.java).construct()
 

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

@@ -1,6 +1,5 @@
 package expo.modules.kotlin.types
 
-import com.facebook.react.bridge.Dynamic
 import kotlin.reflect.KType
 
 fun KType.toAnyType(): AnyType = AnyType(this)
@@ -10,5 +9,7 @@ class AnyType(val kType: KType) {
     TypeConverterProviderImpl.obtainTypeConverter(kType)
   }
 
-  fun convert(value: Dynamic): Any? = converter.convert(value)
+  fun convert(value: Any?): Any? = converter.convert(value)
+
+  fun getCppRequiredTypes(): Int = converter.getCppRequiredTypes().fold(0) { acc, current -> acc or current.value }
 }

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

@@ -3,6 +3,7 @@ package expo.modules.kotlin.types
 import com.facebook.react.bridge.Dynamic
 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.KClass
 import kotlin.reflect.KType
@@ -10,14 +11,14 @@ import kotlin.reflect.KType
 class ArrayTypeConverter(
   converterProvider: TypeConverterProvider,
   private val arrayType: KType,
-) : TypeConverter<Array<*>>(arrayType.isMarkedNullable) {
+) : DynamicAwareTypeConverters<Array<*>>(arrayType.isMarkedNullable) {
   private val arrayElementConverter = converterProvider.obtainTypeConverter(
     requireNotNull(arrayType.arguments.first().type) {
       "The array type should contain the type of the elements."
     }
   )
 
-  override fun convertNonOptional(value: Dynamic): Array<*> {
+  override fun convertFromDynamic(value: Dynamic): Array<*> {
     val jsArray = value.asArray()
     val array = createTypedArray(jsArray.size())
     for (i in 0 until jsArray.size()) {
@@ -34,6 +35,8 @@ class ArrayTypeConverter(
     return array
   }
 
+  override fun convertFromAny(value: Any): Array<*> = value as Array<*>
+
   /**
    * We can't use a Array<Any?> here. We have to create a typed array.
    * Otherwise, cast which is done before calling lambda provided by the user will always fail.
@@ -47,4 +50,6 @@ class ArrayTypeConverter(
       size
     ) as Array<Any?>
   }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_ARRAY)
 }

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
@@ -110,6 +112,9 @@ 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),
     )
   }
 }

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)

package/build/NativeModulesProxy.native.js.map

@@ -1 +1 @@
-{"version":3,"file":"NativeModulesProxy.native.js","sourceRoot":"","sources":["../src/NativeModulesProxy.native.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAI7C,MAAM,WAAW,GAAG,aAAa,CAAC,oBAAoB,CAAC;AACvD,MAAM,mBAAmB,GAAG,kBAAkB,CAAC;AAC/C,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;AAE7C,MAAM,kBAAkB,GAAgD,EAAE,CAAC;AAE3E,IAAI,WAAW,EAAE;IACf,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;QAClE,kBAAkB,CAAC,UAAU,CAAC,GAAG,WAAW,CAAC,mBAAmB,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QACpF,WAAW,CAAC,kBAAkB,CAAC,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;YACjE,kBAAkB,CAAC,UAAU,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAe,EAAgB,EAAE;gBACrF,MAAM,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,UAAU,CAAC;gBAC3C,IAAI,cAAc,KAAK,IAAI,CAAC,MAAM,EAAE;oBAClC,OAAO,OAAO,CAAC,MAAM,CACnB,IAAI,KAAK,CACP,iBAAiB,UAAU,IAAI,UAAU,CAAC,IAAI,YAAY,cAAc,IACtE,cAAc,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,WACtC,iBAAiB,IAAI,CAAC,MAAM,EAAE,CAC/B,CACF,CAAC;iBACH;gBACD,OAAO,WAAW,CAAC,UAAU,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;YACvD,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,+EAA+E;QAC/E,kFAAkF;QAClF,EAAE;QACF,wEAAwE;QACxE,gDAAgD;QAChD,EAAE;QACF,6GAA6G;QAC7G,gGAAgG;QAChG,4HAA4H;QAC5H,qCAAqC;QACrC,IAAI,aAAa,CAAC,yBAAyB,EAAE;YAC3C,kBAAkB,CAAC,UAAU,CAAC,CAAC,WAAW,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE,CACvD,aAAa,CAAC,yBAAyB,CAAC,kBAAkB,CAAC,UAAU,EAAE,GAAG,IAAI,CAAC,CAAC;YAClF,kBAAkB,CAAC,UAAU,CAAC,CAAC,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE,CAC3D,aAAa,CAAC,yBAAyB,CAAC,sBAAsB,CAAC,UAAU,EAAE,GAAG,IAAI,CAAC,CAAC;SACvF;aAAM;YACL,oBAAoB;YACpB,kHAAkH;YAClH,sHAAsH;YACtH,kBAAkB,CAAC,UAAU,CAAC,CAAC,WAAW,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;YACtD,kBAAkB,CAAC,UAAU,CAAC,CAAC,eAAe,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;SAC3D;IACH,CAAC,CAAC,CAAC;CACJ;KAAM;IACL,OAAO,CAAC,IAAI,CACV,gJAAgJ,CACjJ,CAAC;CACH;AAED,eAAe,kBAAkB,CAAC","sourcesContent":["import { NativeModules } from 'react-native';\n\nimport { ProxyNativeModule } from './NativeModulesProxy.types';\n\nconst NativeProxy = NativeModules.NativeUnimoduleProxy;\nconst modulesConstantsKey = 'modulesConstants';\nconst exportedMethodsKey = 'exportedMethods';\n\nconst NativeModulesProxy: { [moduleName: string]: ProxyNativeModule } = {};\n\nif (NativeProxy) {\n  Object.keys(NativeProxy[exportedMethodsKey]).forEach((moduleName) => {\n    NativeModulesProxy[moduleName] = NativeProxy[modulesConstantsKey][moduleName] || {};\n    NativeProxy[exportedMethodsKey][moduleName].forEach((methodInfo) => {\n      NativeModulesProxy[moduleName][methodInfo.name] = (...args: unknown[]): Promise<any> => {\n        const { key, argumentsCount } = methodInfo;\n        if (argumentsCount !== args.length) {\n          return Promise.reject(\n            new Error(\n              `Native method ${moduleName}.${methodInfo.name} expects ${argumentsCount} ${\n                argumentsCount === 1 ? 'argument' : 'arguments'\n              } but received ${args.length}`\n            )\n          );\n        }\n        return NativeProxy.callMethod(moduleName, key, args);\n      };\n    });\n\n    // These are called by EventEmitter (which is a wrapper for NativeEventEmitter)\n    // only on iOS and they use iOS-specific native module, EXReactNativeEventEmitter.\n    //\n    // On Android only {start,stop}Observing are called on the native module\n    // and these should be exported as Expo methods.\n    //\n    // Before the RN 65, addListener/removeListeners weren't called on Android. However, it no longer stays true.\n    // See https://github.com/facebook/react-native/commit/f5502fbda9fe271ff6e1d0da773a3a8ee206a453.\n    // That's why, we check if the `EXReactNativeEventEmitter` exists and only if yes, we use it in the listener implementation.\n    // Otherwise, those methods are NOOP.\n    if (NativeModules.EXReactNativeEventEmitter) {\n      NativeModulesProxy[moduleName].addListener = (...args) =>\n        NativeModules.EXReactNativeEventEmitter.addProxiedListener(moduleName, ...args);\n      NativeModulesProxy[moduleName].removeListeners = (...args) =>\n        NativeModules.EXReactNativeEventEmitter.removeProxiedListeners(moduleName, ...args);\n    } else {\n      // Fixes on Android:\n      // WARN  `new NativeEventEmitter()` was called with a non-null argument without the required `addListener` method.\n      // WARN  `new NativeEventEmitter()` was called with a non-null argument without the required `removeListeners` method.\n      NativeModulesProxy[moduleName].addListener = () => {};\n      NativeModulesProxy[moduleName].removeListeners = () => {};\n    }\n  });\n} else {\n  console.warn(\n    `The \"EXNativeModulesProxy\" native module is not exported through NativeModules; verify that expo-modules-core's native code is linked properly`\n  );\n}\n\nexport default NativeModulesProxy;\n"]}
+{"version":3,"file":"NativeModulesProxy.native.js","sourceRoot":"","sources":["../src/NativeModulesProxy.native.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAI7C,MAAM,eAAe,GAAG,MAAM,CAAC,WAAW,EAAE,kBAAkB,CAAC;AAC/D,MAAM,iBAAiB,GAAG,aAAa,CAAC,oBAAoB,CAAC;AAE7D,MAAM,mBAAmB,GAAG,kBAAkB,CAAC;AAC/C,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;AAE7C,MAAM,kBAAkB,GAAgD,EAAE,CAAC;AAE3E,IAAI,iBAAiB,EAAE;IACrB,0DAA0D;IAC1D,MAAM,WAAW,GAAG,eAAe,IAAI,iBAAiB,CAAC;IAEzD,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;QAClE,iBAAiB;QACjB,kBAAkB,CAAC,UAAU,CAAC,GAAG,WAAW,CAAC,mBAAmB,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QAEpF,eAAe;QACf,WAAW,CAAC,kBAAkB,CAAC,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;YACjE,kBAAkB,CAAC,UAAU,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAe,EAAgB,EAAE;gBACrF,MAAM,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,UAAU,CAAC;gBAC3C,IAAI,cAAc,KAAK,IAAI,CAAC,MAAM,EAAE;oBAClC,OAAO,OAAO,CAAC,MAAM,CACnB,IAAI,KAAK,CACP,iBAAiB,UAAU,IAAI,UAAU,CAAC,IAAI,YAAY,cAAc,IACtE,cAAc,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,WACtC,iBAAiB,IAAI,CAAC,MAAM,EAAE,CAC/B,CACF,CAAC;iBACH;gBAED,iEAAiE;gBACjE,OAAO,iBAAiB,CAAC,UAAU,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;YAC7D,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,+EAA+E;QAC/E,kFAAkF;QAClF,EAAE;QACF,wEAAwE;QACxE,gDAAgD;QAChD,EAAE;QACF,6GAA6G;QAC7G,gGAAgG;QAChG,4HAA4H;QAC5H,qCAAqC;QACrC,IAAI,aAAa,CAAC,yBAAyB,EAAE;YAC3C,kBAAkB,CAAC,UAAU,CAAC,CAAC,WAAW,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE,CACvD,aAAa,CAAC,yBAAyB,CAAC,kBAAkB,CAAC,UAAU,EAAE,GAAG,IAAI,CAAC,CAAC;YAClF,kBAAkB,CAAC,UAAU,CAAC,CAAC,eAAe,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE,CAC3D,aAAa,CAAC,yBAAyB,CAAC,sBAAsB,CAAC,UAAU,EAAE,GAAG,IAAI,CAAC,CAAC;SACvF;aAAM;YACL,oBAAoB;YACpB,kHAAkH;YAClH,sHAAsH;YACtH,kBAAkB,CAAC,UAAU,CAAC,CAAC,WAAW,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;YACtD,kBAAkB,CAAC,UAAU,CAAC,CAAC,eAAe,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;SAC3D;IACH,CAAC,CAAC,CAAC;CACJ;KAAM;IACL,OAAO,CAAC,IAAI,CACV,gJAAgJ,CACjJ,CAAC;CACH;AAED,eAAe,kBAAkB,CAAC","sourcesContent":["import { NativeModules } from 'react-native';\n\nimport { ProxyNativeModule } from './NativeModulesProxy.types';\n\nconst ExpoNativeProxy = global.ExpoModules?.NativeModulesProxy;\nconst LegacyNativeProxy = NativeModules.NativeUnimoduleProxy;\n\nconst modulesConstantsKey = 'modulesConstants';\nconst exportedMethodsKey = 'exportedMethods';\n\nconst NativeModulesProxy: { [moduleName: string]: ProxyNativeModule } = {};\n\nif (LegacyNativeProxy) {\n  // use JSI proxy if available, fallback to legacy RN proxy\n  const NativeProxy = ExpoNativeProxy ?? LegacyNativeProxy;\n\n  Object.keys(NativeProxy[exportedMethodsKey]).forEach((moduleName) => {\n    // copy constants\n    NativeModulesProxy[moduleName] = NativeProxy[modulesConstantsKey][moduleName] || {};\n\n    // copy methods\n    NativeProxy[exportedMethodsKey][moduleName].forEach((methodInfo) => {\n      NativeModulesProxy[moduleName][methodInfo.name] = (...args: unknown[]): Promise<any> => {\n        const { key, argumentsCount } = methodInfo;\n        if (argumentsCount !== args.length) {\n          return Promise.reject(\n            new Error(\n              `Native method ${moduleName}.${methodInfo.name} expects ${argumentsCount} ${\n                argumentsCount === 1 ? 'argument' : 'arguments'\n              } but received ${args.length}`\n            )\n          );\n        }\n\n        // We still want to call methods using the legacy proxy in SDK 46\n        return LegacyNativeProxy.callMethod(moduleName, key, args);\n      };\n    });\n\n    // These are called by EventEmitter (which is a wrapper for NativeEventEmitter)\n    // only on iOS and they use iOS-specific native module, EXReactNativeEventEmitter.\n    //\n    // On Android only {start,stop}Observing are called on the native module\n    // and these should be exported as Expo methods.\n    //\n    // Before the RN 65, addListener/removeListeners weren't called on Android. However, it no longer stays true.\n    // See https://github.com/facebook/react-native/commit/f5502fbda9fe271ff6e1d0da773a3a8ee206a453.\n    // That's why, we check if the `EXReactNativeEventEmitter` exists and only if yes, we use it in the listener implementation.\n    // Otherwise, those methods are NOOP.\n    if (NativeModules.EXReactNativeEventEmitter) {\n      NativeModulesProxy[moduleName].addListener = (...args) =>\n        NativeModules.EXReactNativeEventEmitter.addProxiedListener(moduleName, ...args);\n      NativeModulesProxy[moduleName].removeListeners = (...args) =>\n        NativeModules.EXReactNativeEventEmitter.removeProxiedListeners(moduleName, ...args);\n    } else {\n      // Fixes on Android:\n      // WARN  `new NativeEventEmitter()` was called with a non-null argument without the required `addListener` method.\n      // WARN  `new NativeEventEmitter()` was called with a non-null argument without the required `removeListeners` method.\n      NativeModulesProxy[moduleName].addListener = () => {};\n      NativeModulesProxy[moduleName].removeListeners = () => {};\n    }\n  });\n} else {\n  console.warn(\n    `The \"EXNativeModulesProxy\" native module is not exported through NativeModules; verify that expo-modules-core's native code is linked properly`\n  );\n}\n\nexport default NativeModulesProxy;\n"]}

package/ios/AppDelegates/EXAppDelegatesLoader.m

@@ -3,7 +3,6 @@
 #import <ExpoModulesCore/EXLegacyAppDelegateWrapper.h>
 
 #import <ExpoModulesCore/EXAppDelegatesLoader.h>
-#import <ExpoModulesCore/EXNativeModulesProxy.h>
 #import <ExpoModulesCore/Swift.h>
 
 // Make the legacy wrapper conform to the protocol for subscribers.
@@ -17,7 +16,7 @@
 // and before any code is executed, so we switch back to Objective-C just to do this one thing.
 + (void)load
 {
-  ModulesProvider *modulesProvider = [EXNativeModulesProxy getExpoModulesProvider];
+  ModulesProvider *modulesProvider = [EXAppContext modulesProviderWithName:@"ExpoModulesProvider"];
   [EXExpoAppDelegate registerSubscriber:[[EXLegacyAppDelegateWrapper alloc] init]];
   [EXExpoAppDelegate registerSubscribersFromModulesProvider:modulesProvider];
   [EXExpoAppDelegate registerReactDelegateHandlersFromModulesProvider:modulesProvider];