expo-modules-core 0.6.5 → 0.9.0

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

@@ -8,6 +8,6 @@ interface Promise {
   fun reject(code: String, message: String?, cause: Throwable?)
 
   fun reject(exception: CodedException) {
-    reject(exception.code, exception.message, exception.cause)
+    reject(exception.code, exception.localizedMessage, exception.cause)
   }
 }

package/android/src/main/java/expo/modules/kotlin/callbacks/Callback.kt

@@ -0,0 +1,5 @@
+package expo.modules.kotlin.callbacks
+
+fun interface Callback<T> {
+  operator fun invoke(arg: T)
+}

package/android/src/main/java/expo/modules/kotlin/callbacks/ViewCallback.kt

@@ -0,0 +1,39 @@
+package expo.modules.kotlin.callbacks
+
+import android.view.View
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import expo.modules.adapters.react.NativeModulesProxy
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.types.JSTypeConverter
+import expo.modules.kotlin.types.putGeneric
+import kotlin.reflect.KType
+
+class ViewCallback<T>(
+  private val name: String,
+  private val type: KType,
+  private val view: View
+) : Callback<T> {
+  internal lateinit var module: Module
+
+  override operator fun invoke(arg: T) {
+    val reactContext = view.context as ReactContext
+    val nativeModulesProxy = reactContext
+      .catalystInstance
+      ?.getNativeModule("NativeUnimoduleProxy") as? NativeModulesProxy
+      ?: return
+    val appContext = nativeModulesProxy.kotlinInteropModuleRegistry.appContext
+
+    appContext.callbackInvoker?.emit(view.id, name, convertEventBody(arg))
+  }
+
+  private fun convertEventBody(arg: T): WritableMap? {
+    return when (val converted = JSTypeConverter.convertToJSValue(arg)) {
+      is Unit, null -> null
+      is WritableMap -> converted
+      else -> JSTypeConverter.DefaultContainerProvider.createMap().apply {
+        putGeneric("payload", converted)
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/callbacks/ViewCallbackDelegate.kt

@@ -0,0 +1,27 @@
+@file:OptIn(ExperimentalStdlibApi::class)
+
+package expo.modules.kotlin.callbacks
+
+import android.view.View
+import java.lang.ref.WeakReference
+import kotlin.reflect.KProperty
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+class ViewCallbackDelegate<T>(private val type: KType, view: View) {
+  private val viewHolder = WeakReference(view)
+  internal var isValidated = false
+
+  operator fun getValue(thisRef: View, property: KProperty<*>): Callback<T> {
+    if (!isValidated) {
+      throw IllegalStateException("You have to export this property as a callback in the `ViewManager`.")
+    }
+
+    val view = viewHolder.get() ?: throw IllegalStateException("Can't send an event from the view that is deallocated.")
+    return ViewCallback(property.name, type, view)
+  }
+}
+
+inline fun <reified T> View.callback(): ViewCallbackDelegate<T> {
+  return ViewCallbackDelegate(typeOf<T>(), this)
+}

package/android/src/main/java/expo/modules/kotlin/defaultmodules/ErrorManagerModule.kt

@@ -0,0 +1,25 @@
+package expo.modules.kotlin.defaultmodules
+
+import android.os.Bundle
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+private const val onNewException = "ExpoModulesCoreErrorManager.onNewException"
+
+class ErrorManagerModule : Module() {
+  override fun definition() = ModuleDefinition {
+    name("ExpoModulesCoreErrorManager")
+    events(onNewException)
+  }
+
+  fun reportExceptionToLogBox(codedException: CodedException) {
+    val eventEmitter = appContext.eventEmitter(this) ?: return
+    eventEmitter.emit(
+      onNewException,
+      Bundle().apply {
+        putString("message", codedException.message ?: codedException.toString())
+      }
+    )
+  }
+}

package/android/src/main/java/expo/modules/kotlin/events/EventEmitter.kt

@@ -0,0 +1,13 @@
+package expo.modules.kotlin.events
+
+import com.facebook.react.bridge.WritableMap
+import expo.modules.kotlin.records.Record
+
+// We want to decorate a legacy event emitter interface to support advanced conversion between types in events.
+// For instance, users will be able to create `Callback<Record>` that will be converted to the `WritableMap`.
+interface EventEmitter : expo.modules.core.interfaces.services.EventEmitter {
+  fun emit(eventName: String, eventBody: WritableMap?)
+  fun emit(eventName: String, eventBody: Record?)
+  fun emit(eventName: String, eventBody: Map<*, *>?)
+  fun emit(viewId: Int, eventName: String, eventBody: WritableMap?)
+}

package/android/src/main/java/expo/modules/kotlin/events/KModuleEventEmitterWrapper.kt

@@ -0,0 +1,102 @@
+package expo.modules.kotlin.events
+
+import android.os.Bundle
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import com.facebook.react.uimanager.UIManagerModule
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.types.JSTypeConverter
+import java.lang.ref.WeakReference
+
+/**
+ * In Swift, we check if the event is supported. Otherwise, we can't send such event through the bridge.
+ * However, in Kotlin this is unnecessary, but to make our API consistent, we added similar check.
+ * But because of that, we had to create a wrapper for EventEmitter.
+ */
+class KModuleEventEmitterWrapper(
+  private val moduleHolder: ModuleHolder,
+  legacyEventEmitter: expo.modules.core.interfaces.services.EventEmitter,
+  reactContextHolder: WeakReference<ReactApplicationContext>
+) : KEventEmitterWrapper(legacyEventEmitter, reactContextHolder) {
+  override fun emit(eventName: String, eventBody: Bundle?) {
+    checkIfEventWasExported(eventName)
+    super.emit(eventName, eventBody)
+  }
+
+  override fun emit(eventName: String, eventBody: WritableMap?) {
+    checkIfEventWasExported(eventName)
+    super.emit(eventName, eventBody)
+  }
+
+  override fun emit(eventName: String, eventBody: Record?) {
+    checkIfEventWasExported(eventName)
+    super.emit(eventName, eventBody)
+  }
+
+  override fun emit(eventName: String, eventBody: Map<*, *>?) {
+    checkIfEventWasExported(eventName)
+    super.emit(eventName, eventBody)
+  }
+
+  private fun checkIfEventWasExported(eventName: String) {
+    require(
+      moduleHolder
+        .definition
+        .eventsDefinition
+        ?.names
+        ?.contains(eventName) == true
+    ) { "Unsupported event: $eventName." }
+  }
+}
+
+open class KEventEmitterWrapper(
+  private val legacyEventEmitter: expo.modules.core.interfaces.services.EventEmitter,
+  private val reactContextHolder: WeakReference<ReactApplicationContext>
+) : EventEmitter, expo.modules.core.interfaces.services.EventEmitter by legacyEventEmitter {
+  private val deviceEventEmitter: RCTDeviceEventEmitter?
+    get() = reactContextHolder
+      .get()
+      ?.getJSModule(RCTDeviceEventEmitter::class.java)
+
+  private val uiEventDispatcher: EventDispatcher?
+    get() = reactContextHolder
+      .get()
+      ?.getNativeModule(UIManagerModule::class.java)
+      ?.eventDispatcher
+
+  override fun emit(eventName: String, eventBody: WritableMap?) {
+    deviceEventEmitter
+      ?.emit(eventName, eventBody)
+  }
+  override fun emit(eventName: String, eventBody: Record?) {
+    deviceEventEmitter
+      ?.emit(eventName, JSTypeConverter.convertToJSValue(eventBody))
+  }
+
+  override fun emit(eventName: String, eventBody: Map<*, *>?) {
+    deviceEventEmitter
+      ?.emit(eventName, JSTypeConverter.convertToJSValue(eventBody))
+  }
+
+  override fun emit(viewId: Int, eventName: String, eventBody: WritableMap?) {
+    uiEventDispatcher
+      ?.dispatchEvent(UIEvent(viewId, eventName, eventBody))
+  }
+
+  private class UIEvent(
+    private val viewId: Int,
+    private val eventName: String,
+    private val eventBody: WritableMap?
+  ) : com.facebook.react.uimanager.events.Event<UIEvent>(viewId) {
+    override fun getEventName(): String = eventName
+    override fun canCoalesce(): Boolean = false
+    override fun getCoalescingKey(): Short = 0
+    override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+      rctEventEmitter.receiveEvent(viewId, eventName, eventBody)
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/exception/CodedException.kt

@@ -1,6 +1,8 @@
 package expo.modules.kotlin.exception
 
+import com.facebook.react.bridge.ReadableType
 import java.util.*
+import kotlin.reflect.KProperty1
 import kotlin.reflect.KType
 
 /**
@@ -17,7 +19,7 @@ open class CodedException(
   val code
     get() = providedCode ?: inferCode(javaClass)
 
-  constructor(code: String, message: String, cause: Throwable?) : this(message, cause) {
+  constructor(code: String, message: String?, cause: Throwable?) : this(message, cause) {
     providedCode = code
   }
 
@@ -31,9 +33,11 @@ open class CodedException(
     /**
      * The code is inferred from the class name — e.g. the code of `ModuleNotFoundException` becomes `ERR_MODULE_NOT_FOUND`.
      */
-    private fun inferCode(clazz: Class<*>): String {
+    @PublishedApi
+    internal fun inferCode(clazz: Class<*>): String {
       val name = requireNotNull(clazz.simpleName) { "Cannot infer code name from class name. We don't support anonymous classes." }
 
+      @Suppress("Deprecation")
       return "ERR_" + name
         .replace("(Exception)$".toRegex(), "")
         .replace("(.)([A-Z])".toRegex(), "$1_$2")
@@ -42,29 +46,109 @@ open class CodedException(
   }
 }
 
+/**
+ * Infers error code from the exception class name -
+ * e.g. the code of `ModuleNotFoundException` becomes `ERR_MODULE_NOT_FOUND`.
+ *
+ * Example:
+ * ```kt
+ * class NoPermissionException : CodedException()
+ * val errorCode = errorCodeOf<NoPermissionException>() // ERR_NO_PERMISSION
+ * ```
+ *
+ * **Note**: This works only if the exception class didn't overwrite the error code manually.
+ */
+inline fun <reified T : CodedException> errorCodeOf(): String =
+  CodedException.inferCode(T::class.java)
+
 internal class IncompatibleArgTypeException(
   argumentType: KType,
   desiredType: KType,
   cause: Throwable? = null
 ) : CodedException(
-  message = "Argument type $argumentType is not compatible with expected type $desiredType.",
+  message = "Argument type '$argumentType' is not compatible with expected type '$desiredType'.",
   cause = cause
 )
 
 internal class MissingTypeConverter(
   forType: KType
 ) : CodedException(
-  message = "Cannot find type converter for $forType.",
+  message = "Cannot find type converter for '$forType'.",
 )
 
 internal class InvalidArgsNumberException(received: Int, expected: Int) :
   CodedException(message = "Received $received arguments, but $expected was expected.")
 
-internal class MethodNotFoundException(methodName: String, moduleName: String) :
-  CodedException(message = "Cannot fund method $methodName in module $moduleName")
+internal class MethodNotFoundException :
+  CodedException(message = "Method does not exist.")
 
-internal class NullArgumentException(desiredType: KType) :
-  CodedException(message = "Cannot assigned null to not nullable type $desiredType")
+internal class NullArgumentException :
+  CodedException(message = "Cannot assigned null to not nullable type.")
+
+internal class FieldRequiredException(property: KProperty1<*, *>) :
+  CodedException(message = "Value for field '$property' is required, got nil")
 
 internal class UnexpectedException(val throwable: Throwable) :
-  CodedException(throwable)
+  CodedException(message = throwable.toString(), throwable)
+
+internal class ValidationException(message: String) :
+  CodedException(message = message)
+
+/**
+ * A base class for all exceptions used in `exceptionDecorator` function.
+ */
+internal open class DecoratedException(
+  message: String,
+  cause: CodedException,
+) : CodedException(
+  cause.code,
+  message = "$message${System.lineSeparator()}→ Caused by: ${cause.localizedMessage ?: cause}",
+  cause
+)
+
+internal class FunctionCallException(
+  methodName: String,
+  moduleName: String,
+  cause: CodedException
+) : DecoratedException(
+  message = "Call to function '$moduleName.$methodName' has been rejected.",
+  cause,
+)
+
+internal class ArgumentCastException(
+  argDesiredType: KType,
+  argIndex: Int,
+  providedType: ReadableType,
+  cause: CodedException,
+) : DecoratedException(
+  message = "Argument at index '$argIndex' couldn't be casted to type '$argDesiredType' (received '$providedType').",
+  cause,
+)
+
+internal class FieldCastException(
+  fieldName: String,
+  fieldType: KType,
+  providedType: ReadableType,
+  cause: CodedException
+) : DecoratedException(
+  message = "Cannot cast '${providedType.name}' for field '$fieldName' ('$fieldType').",
+  cause
+)
+
+internal class RecordCastException(
+  recordType: KType,
+  cause: CodedException
+) : DecoratedException(
+  message = "Cannot create a record of the type: '$recordType'.",
+  cause
+)
+
+internal class CollectionElementCastException(
+  collectionType: KType,
+  elementType: KType,
+  providedType: ReadableType,
+  cause: CodedException
+) : DecoratedException(
+  message = "Cannot cast '${providedType.name}' to '$elementType' required by the collection of type: '$collectionType'.",
+  cause
+)

package/android/src/main/java/expo/modules/kotlin/exception/ExceptionDecorator.kt

@@ -0,0 +1,11 @@
+package expo.modules.kotlin.exception
+
+internal inline fun <T> exceptionDecorator(decoratorBlock: (e: CodedException) -> Throwable, block: () -> T): T {
+  return try {
+    block()
+  } catch (e: CodedException) {
+    throw decoratorBlock(e)
+  } catch (e: Throwable) {
+    throw decoratorBlock(UnexpectedException(e))
+  }
+}

package/android/src/main/java/expo/modules/kotlin/{methods/AnyMethod.kt → functions/AnyFunction.kt}

@@ -1,36 +1,32 @@
-package expo.modules.kotlin.methods
+package expo.modules.kotlin.functions
 
 import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.ModuleHolder
 import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.ArgumentCastException
 import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.exception.InvalidArgsNumberException
-import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.iterator
 import expo.modules.kotlin.recycle
 import expo.modules.kotlin.types.AnyType
-import kotlin.jvm.Throws
 
-abstract class AnyMethod(
+abstract class AnyFunction(
   protected val name: String,
   private val desiredArgsTypes: Array<AnyType>
 ) {
-  fun call(args: ReadableArray, promise: Promise) {
+  @Throws(CodedException::class)
+  fun call(module: ModuleHolder, args: ReadableArray, promise: Promise) {
     if (desiredArgsTypes.size != args.size()) {
-      promise.reject(InvalidArgsNumberException(args.size(), desiredArgsTypes.size))
-      return
-    }
-    try {
-      val convertedArgs = convertArgs(args)
-      callImplementation(convertedArgs, promise)
-    } catch (codedError: CodedException) {
-      promise.reject(codedError)
-    } catch (e: Throwable) {
-      promise.reject(UnexpectedException(e))
+      throw InvalidArgsNumberException(args.size(), desiredArgsTypes.size)
     }
+
+    val convertedArgs = convertArgs(args)
+    callImplementation(module, convertedArgs, promise)
   }
 
   @Throws(CodedException::class)
-  internal abstract fun callImplementation(args: Array<out Any?>, promise: Promise)
+  internal abstract fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise)
 
   val argsCount get() = desiredArgsTypes.size
 
@@ -40,9 +36,13 @@ abstract class AnyMethod(
     val argIterator = args.iterator()
     desiredArgsTypes
       .withIndex()
-      .forEach { (index, type) ->
+      .forEach { (index, desiredType) ->
         argIterator.next().recycle {
-          finalArgs[index] = type.convert(this)
+          exceptionDecorator({ cause ->
+            ArgumentCastException(desiredType.kType, index, type, cause)
+          }) {
+            finalArgs[index] = desiredType.convert(this)
+          }
         }
       }
     return finalArgs

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

@@ -0,0 +1,15 @@
+package expo.modules.kotlin.functions
+
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.types.AnyType
+
+class AsyncFunction(
+  name: String,
+  argsType: Array<AnyType>,
+  private val body: (args: Array<out Any?>) -> Any?
+) : AnyFunction(name, argsType) {
+  override fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise) {
+    promise.resolve(body(args))
+  }
+}

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

@@ -0,0 +1,170 @@
+@file:OptIn(ExperimentalStdlibApi::class)
+@file:Suppress("FunctionName")
+
+package expo.modules.kotlin.functions
+
+import expo.modules.kotlin.types.toAnyType
+import kotlin.reflect.typeOf
+
+class AsyncFunctionBuilder(val name: String) {
+  @PublishedApi
+  internal var function: AnyFunction? = null
+
+  @Deprecated(
+    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
+    replaceWith = ReplaceWith("SuspendBody(block)")
+  )
+  inline fun <reified R> suspendBody(crossinline block: suspend () -> R) = SuspendBody(block)
+
+  inline fun <reified R> SuspendBody(crossinline block: suspend () -> R) {
+    function = AsyncSuspendFunction(name, arrayOf()) { block() }
+  }
+
+  @Deprecated(
+    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
+    replaceWith = ReplaceWith("SuspendBody(block)")
+  )
+  inline fun <reified R, reified P0> suspendBody(crossinline block: suspend (p0: P0) -> R) = SuspendBody(block)
+
+  inline fun <reified R, reified P0> SuspendBody(crossinline block: suspend (p0: P0) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0) }
+  }
+
+  @Deprecated(
+    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
+    replaceWith = ReplaceWith("SuspendBody(block)")
+  )
+  inline fun <reified R, reified P0, reified P1> suspendBody(crossinline block: suspend (p0: P0, p1: P1) -> R) = SuspendBody(block)
+
+  inline fun <reified R, reified P0, reified P1> SuspendBody(crossinline block: suspend (p0: P0, p1: P1) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[0] as P1) }
+  }
+
+  @Deprecated(
+    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
+    replaceWith = ReplaceWith("SuspendBody(block)")
+  )
+  inline fun <reified R, reified P0, reified P1, reified P2> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2) -> R) = SuspendBody(block)
+
+  inline fun <reified R, reified P0, reified P1, reified P2> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2) }
+  }
+
+  @Deprecated(
+    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
+    replaceWith = ReplaceWith("SuspendBody(block)")
+  )
+  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) = SuspendBody(block)
+
+  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) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
+  }
+
+  @Deprecated(
+    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
+    replaceWith = ReplaceWith("SuspendBody(block)")
+  )
+  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) = SuspendBody(block)
+
+  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) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
+  }
+
+  @Deprecated(
+    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
+    replaceWith = ReplaceWith("SuspendBody(block)")
+  )
+  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) = SuspendBody(block)
+
+  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) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().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) }
+  }
+
+  @Deprecated(
+    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
+    replaceWith = ReplaceWith("SuspendBody(block)")
+  )
+  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) = SuspendBody(block)
+
+  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) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().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) }
+  }
+
+  @Deprecated(
+    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
+    replaceWith = ReplaceWith("SuspendBody(block)")
+  )
+  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) = SuspendBody(block)
+
+  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) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().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) }
+  }
+
+  internal fun build(): Pair<String, AnyFunction> {
+    return name to requireNotNull(function)
+  }
+}
+
+@Deprecated(
+  message = "The 'coroutine' component was renamed to 'Coroutine'.",
+  replaceWith = ReplaceWith("Coroutine(block)")
+)
+inline infix fun <reified R> AsyncFunctionBuilder.coroutine(crossinline block: suspend () -> R) = Coroutine(block)
+
+@Deprecated(
+  message = "The 'coroutine' component was renamed to 'Coroutine'.",
+  replaceWith = ReplaceWith("Coroutine(block)")
+)
+inline infix fun <reified R, reified P0> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0) -> R) = Coroutine(block)
+
+@Deprecated(
+  message = "The 'coroutine' component was renamed to 'Coroutine'.",
+  replaceWith = ReplaceWith("Coroutine(block)")
+)
+inline infix fun <reified R, reified P0, reified P1> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1) -> R) = Coroutine(block)
+
+@Deprecated(
+  message = "The 'coroutine' component was renamed to 'Coroutine'.",
+  replaceWith = ReplaceWith("Coroutine(block)")
+)
+inline infix fun <reified R, reified P0, reified P1, reified P2> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2) -> R) = Coroutine(block)
+
+@Deprecated(
+  message = "The 'coroutine' component was renamed to 'Coroutine'.",
+  replaceWith = ReplaceWith("Coroutine(block)")
+)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3) -> R) = Coroutine(block)
+
+@Deprecated(
+  message = "The 'coroutine' component was renamed to 'Coroutine'.",
+  replaceWith = ReplaceWith("Coroutine(block)")
+)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4) -> R) = Coroutine(block)
+
+@Deprecated(
+  message = "The 'coroutine' component was renamed to 'Coroutine'.",
+  replaceWith = ReplaceWith("Coroutine(block)")
+)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5) -> R) = Coroutine(block)
+
+@Deprecated(
+  message = "The 'coroutine' component was renamed to 'Coroutine'.",
+  replaceWith = ReplaceWith("Coroutine(block)")
+)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5, P6) -> R) = Coroutine(block)
+
+@Deprecated(
+  message = "The 'coroutine' component was renamed to 'Coroutine'.",
+  replaceWith = ReplaceWith("Coroutine(block)")
+)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5, P6, P7) -> R) = Coroutine(block)
+
+inline infix fun <reified R> AsyncFunctionBuilder.Coroutine(crossinline block: suspend () -> R) = SuspendBody(block)
+inline infix fun <reified R, reified P0> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0) -> R) = SuspendBody(block)
+inline infix fun <reified R, reified P0, reified P1> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0, P1) -> R) = SuspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0, P1, P2) -> R) = SuspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0, P1, P2, P3) -> R) = SuspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0, P1, P2, P3, P4) -> R) = SuspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5) -> R) = SuspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5, P6) -> R) = SuspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5, P6, P7) -> R) = SuspendBody(block)

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

@@ -0,0 +1,15 @@
+package expo.modules.kotlin.functions
+
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.types.AnyType
+
+class AsyncFunctionWithPromise(
+  name: String,
+  argsType: Array<AnyType>,
+  private val body: (args: Array<out Any?>, promise: Promise) -> Unit
+) : AnyFunction(name, argsType) {
+  override fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise) {
+    body(args, promise)
+  }
+}