expo-modules-core 0.6.5 → 0.9.0

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

@@ -10,6 +10,7 @@
  * That's why we used typeOf. It solves all problems described above.
  */
 @file:OptIn(ExperimentalStdlibApi::class)
+@file:Suppress("FunctionName")
 
 package expo.modules.kotlin.modules
 
@@ -23,21 +24,24 @@ import expo.modules.kotlin.events.EventListenerWithSenderAndPayload
 import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.EventsDefinition
 import expo.modules.kotlin.events.OnActivityResultPayload
-import expo.modules.kotlin.methods.AnyMethod
-import expo.modules.kotlin.methods.Method
-import expo.modules.kotlin.methods.PromiseMethod
+import expo.modules.kotlin.functions.AnyFunction
+import expo.modules.kotlin.functions.AsyncFunction
+import expo.modules.kotlin.functions.AsyncFunctionWithPromise
+import expo.modules.kotlin.functions.AsyncFunctionBuilder
 import expo.modules.kotlin.types.toAnyType
 import expo.modules.kotlin.views.ViewManagerDefinition
 import expo.modules.kotlin.views.ViewManagerDefinitionBuilder
 import kotlin.reflect.typeOf
 
-class ModuleDefinitionBuilder {
+@DefinitionMarker
+class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null) {
   private var name: String? = null
   private var constantsProvider = { emptyMap<String, Any?>() }
   private var eventsDefinition: EventsDefinition? = null
+  private var functionBuilders = mutableListOf<AsyncFunctionBuilder>()
 
   @PublishedApi
-  internal var methods = mutableMapOf<String, AnyMethod>()
+  internal var methods = mutableMapOf<String, AnyFunction>()
 
   @PublishedApi
   internal var viewManagerDefinition: ViewManagerDefinition? = null
@@ -46,128 +50,416 @@ class ModuleDefinitionBuilder {
   internal val eventListeners = mutableMapOf<EventName, EventListener>()
 
   fun build(): ModuleDefinitionData {
+    val moduleName = name ?: module?.javaClass?.simpleName
+
     return ModuleDefinitionData(
-      requireNotNull(name),
+      requireNotNull(moduleName),
       constantsProvider,
-      methods,
+      methods + functionBuilders.associate { it.build() },
       viewManagerDefinition,
       eventListeners,
       eventsDefinition
     )
   }
 
-  fun name(name: String) {
+  @Deprecated(
+    message = "The 'name' component was renamed to 'Name'.",
+    replaceWith = ReplaceWith("Name(name)")
+  )
+  fun name(name: String) = Name(name)
+
+  /**
+   * Sets the name of the module that is exported to the JavaScript world.
+   */
+  fun Name(name: String) {
     this.name = name
   }
 
-  fun constants(constantsProvider: () -> Map<String, Any?>) {
+  @Deprecated(
+    message = "The 'constants' component was renamed to 'Constants'.",
+    replaceWith = ReplaceWith("Constants(constantsProvider)")
+  )
+  fun constants(constantsProvider: () -> Map<String, Any?>) = Constants(constantsProvider)
+
+  /**
+   * Definition function setting the module's constants to export.
+   */
+  fun Constants(constantsProvider: () -> Map<String, Any?>) {
     this.constantsProvider = constantsProvider
   }
 
-  @JvmName("methodWithoutArgs")
+  @Deprecated(
+    message = "The 'constants' component was renamed to 'Constants'.",
+    replaceWith = ReplaceWith("Constants(constants)")
+  )
+  fun constants(vararg constants: Pair<String, Any?>) = Constants(*constants)
+
+  /**
+   * Definition of the module's constants to export.
+   */
+  fun Constants(vararg constants: Pair<String, Any?>) {
+    constantsProvider = { constants.toMap() }
+  }
+
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  @JvmName("functionWithoutArgs")
   inline fun function(
     name: String,
     crossinline body: () -> Any?
   ) {
-    methods[name] = Method(name, arrayOf()) { body() }
+    methods[name] = AsyncFunction(name, arrayOf()) { body() }
   }
 
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
   inline fun <reified R> function(
     name: String,
     crossinline body: () -> R
   ) {
-    methods[name] = Method(name, arrayOf()) { body() }
+    methods[name] = AsyncFunction(name, arrayOf()) { body() }
   }
 
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
   inline fun <reified R, reified P0> function(
     name: String,
     crossinline body: (p0: P0) -> R
   ) {
     methods[name] = if (P0::class == Promise::class) {
-      PromiseMethod(name, arrayOf()) { _, promise -> body(promise as P0) }
+      AsyncFunctionWithPromise(name, arrayOf()) { _, promise -> body(promise as P0) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
     }
   }
 
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
   inline fun <reified R, reified P0, reified P1> function(
     name: String,
     crossinline body: (p0: P0, p1: P1) -> R
   ) {
     methods[name] = if (P1::class == Promise::class) {
-      PromiseMethod(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
     }
   }
 
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
   inline fun <reified R, reified P0, reified P1, reified P2> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2) -> R
   ) {
     methods[name] = if (P2::class == Promise::class) {
-      PromiseMethod(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
     }
   }
 
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
   ) {
     methods[name] = if (P3::class == Promise::class) {
-      PromiseMethod(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
     }
   }
 
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
   ) {
     methods[name] = if (P4::class == Promise::class) {
-      PromiseMethod(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
     }
   }
 
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
   ) {
     methods[name] = if (P5::class == Promise::class) {
-      PromiseMethod(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
     }
   }
 
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
   ) {
     methods[name] = if (P6::class == Promise::class) {
-      PromiseMethod(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
     }
   }
 
+  @Deprecated(
+    message = "The 'function' component was deprecated and will change its behavior in the future.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
   ) {
     methods[name] = if (P7::class == Promise::class) {
-      PromiseMethod(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
     }
   }
 
-  inline fun viewManager(body: ViewManagerDefinitionBuilder.() -> Unit) {
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  @JvmName("asyncFunctionWithoutArgs")
+  inline fun asyncFunction(
+    name: String,
+    crossinline body: () -> Any?
+  ) = AsyncFunction(name, body)
+
+  @JvmName("AsyncFunctionWithoutArgs")
+  inline fun AsyncFunction(
+    name: String,
+    crossinline body: () -> Any?
+  ) {
+    methods[name] = AsyncFunction(name, arrayOf()) { body() }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  inline fun <reified R> asyncFunction(
+    name: String,
+    crossinline body: () -> R
+  ) = AsyncFunction(name, body)
+
+  inline fun <reified R> AsyncFunction(
+    name: String,
+    crossinline body: () -> R
+  ) {
+    methods[name] = AsyncFunction(name, arrayOf()) { body() }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  inline fun <reified R, reified P0> asyncFunction(
+    name: String,
+    crossinline body: (p0: P0) -> R
+  ) = AsyncFunction(name, body)
+
+  inline fun <reified R, reified P0> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0) -> R
+  ) {
+    methods[name] = if (P0::class == Promise::class) {
+      AsyncFunctionWithPromise(name, arrayOf()) { _, promise -> body(promise as P0) }
+    } else {
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
+    }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  inline fun <reified R, reified P0, reified P1> asyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1) -> R
+  ) = AsyncFunction(name, body)
+
+  inline fun <reified R, reified P0, reified P1> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1) -> R
+  ) {
+    methods[name] = if (P1::class == Promise::class) {
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
+    } else {
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
+    }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  inline fun <reified R, reified P0, reified P1, reified P2> asyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2) -> R
+  ) = AsyncFunction(name, body)
+
+  inline fun <reified R, reified P0, reified P1, reified P2> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2) -> R
+  ) {
+    methods[name] = if (P2::class == Promise::class) {
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
+    } else {
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
+    }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3> asyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
+  ) = AsyncFunction(name, body)
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
+  ) {
+    methods[name] = if (P3::class == Promise::class) {
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
+    } else {
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
+    }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> asyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
+  ) = AsyncFunction(name, body)
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
+  ) {
+    methods[name] = if (P4::class == Promise::class) {
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
+    } else {
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
+    }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> asyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
+  ) = AsyncFunction(name, body)
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
+  ) {
+    methods[name] = if (P5::class == Promise::class) {
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
+    } else {
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
+    }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> asyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
+  ) = AsyncFunction(name, body)
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
+  ) {
+    methods[name] = if (P6::class == Promise::class) {
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
+    } else {
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
+    }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> asyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
+  ) = AsyncFunction(name, body)
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
+  ) {
+    methods[name] = if (P7::class == Promise::class) {
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
+    } else {
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
+    }
+  }
+
+  @Deprecated(
+    message = "The 'asyncFunction' component was renamed to 'AsyncFunction'.",
+    replaceWith = ReplaceWith("AsyncFunction(name, body)")
+  )
+  fun asyncFunction(
+    name: String
+  ) = AsyncFunction(name)
+
+  fun AsyncFunction(
+    name: String
+  ) = AsyncFunctionBuilder(name).also { functionBuilders.add(it) }
+
+  @Deprecated(
+    message = "The 'viewManager' component was renamed to 'ViewManager'.",
+    replaceWith = ReplaceWith("ViewManager(body)")
+  )
+  inline fun viewManager(body: ViewManagerDefinitionBuilder.() -> Unit) = ViewManager(body)
+
+  /**
+   * Creates the view manager definition that scopes other view-related definitions.
+   */
+  inline fun ViewManager(body: ViewManagerDefinitionBuilder.() -> Unit) {
     require(viewManagerDefinition == null) { "The module definition may have exported only one view manager." }
 
     val viewManagerDefinitionBuilder = ViewManagerDefinitionBuilder()
@@ -175,52 +467,133 @@ class ModuleDefinitionBuilder {
     viewManagerDefinition = viewManagerDefinitionBuilder.build()
   }
 
-  inline fun onCreate(crossinline body: () -> Unit) {
+  @Deprecated(
+    message = "The 'onCreate' component was renamed to 'OnCreate'.",
+    replaceWith = ReplaceWith("OnCreate(body)")
+  )
+  inline fun onCreate(crossinline body: () -> Unit) = OnCreate(body)
+
+  /**
+   * Creates module's lifecycle listener that is called right after the module initialization.
+   */
+  inline fun OnCreate(crossinline body: () -> Unit) {
     eventListeners[EventName.MODULE_CREATE] = BasicEventListener(EventName.MODULE_CREATE) { body() }
   }
 
-  inline fun onDestroy(crossinline body: () -> Unit) {
+  @Deprecated(
+    message = "The 'onDestroy' component was renamed to 'OnDestroy'.",
+    replaceWith = ReplaceWith("OnDestroy(body)")
+  )
+  inline fun onDestroy(crossinline body: () -> Unit) = OnDestroy(body)
+
+  /**
+   * Creates module's lifecycle listener that is called when the module is about to be deallocated.
+   */
+  inline fun OnDestroy(crossinline body: () -> Unit) {
     eventListeners[EventName.MODULE_DESTROY] = BasicEventListener(EventName.MODULE_DESTROY) { body() }
   }
 
-  inline fun onActivityEntersForeground(crossinline body: () -> Unit) {
+  @Deprecated(
+    message = "The 'onActivityEntersForeground' component was renamed to 'OnActivityEntersForeground'.",
+    replaceWith = ReplaceWith("OnActivityEntersForeground(body)")
+  )
+  inline fun onActivityEntersForeground(crossinline body: () -> Unit) = OnActivityEntersForeground(body)
+
+  /**
+   * Creates module's lifecycle listener that is called right after the activity is resumed.
+   */
+  inline fun OnActivityEntersForeground(crossinline body: () -> Unit) {
     eventListeners[EventName.ACTIVITY_ENTERS_FOREGROUND] = BasicEventListener(EventName.ACTIVITY_ENTERS_FOREGROUND) { body() }
   }
 
-  inline fun onActivityEntersBackground(crossinline body: () -> Unit) {
+  @Deprecated(
+    message = "The 'onActivityEntersBackground' component was renamed to 'OnActivityEntersBackground'.",
+    replaceWith = ReplaceWith("OnActivityEntersBackground(body)")
+  )
+  inline fun onActivityEntersBackground(crossinline body: () -> Unit) = OnActivityEntersBackground(body)
+
+  /**
+   * Creates module's lifecycle listener that is called right after the activity is paused.
+   */
+  inline fun OnActivityEntersBackground(crossinline body: () -> Unit) {
     eventListeners[EventName.ACTIVITY_ENTERS_BACKGROUND] = BasicEventListener(EventName.ACTIVITY_ENTERS_BACKGROUND) { body() }
   }
 
-  inline fun onActivityDestroys(crossinline body: () -> Unit) {
+  @Deprecated(
+    message = "The 'onActivityDestroys' component was renamed to 'OnActivityDestroys'.",
+    replaceWith = ReplaceWith("OnActivityDestroys(body)")
+  )
+  inline fun onActivityDestroys(crossinline body: () -> Unit) = OnActivityDestroys(body)
+
+  /**
+   * Creates module's lifecycle listener that is called right after the activity is destroyed.
+   */
+  inline fun OnActivityDestroys(crossinline body: () -> Unit) {
     eventListeners[EventName.ACTIVITY_DESTROYS] = BasicEventListener(EventName.ACTIVITY_DESTROYS) { body() }
   }
 
+  @Deprecated(
+    message = "The 'events' component was renamed to 'Events'.",
+    replaceWith = ReplaceWith("Events(events)")
+  )
+  fun events(vararg events: String) = Events(*events)
+
   /**
    * Defines event names that this module can send to JavaScript.
    */
-  fun events(vararg events: String) {
+  fun Events(vararg events: String) {
     eventsDefinition = EventsDefinition(events)
   }
 
+  @Deprecated(
+    message = "The 'onStartObserving' component was renamed to 'OnStartObserving'.",
+    replaceWith = ReplaceWith("OnStartObserving(body)")
+  )
+  inline fun onStartObserving(crossinline body: () -> Unit) = OnStartObserving(body)
+
   /**
-   * Method that is invoked when the first event listener is added.
+   * Creates module's lifecycle listener that is called right after the first event listener is added.
    */
-  inline fun onStartObserving(crossinline body: () -> Unit) {
-    function("startObserving", body)
+  inline fun OnStartObserving(crossinline body: () -> Unit) {
+    AsyncFunction("startObserving", body)
   }
 
+  @Deprecated(
+    message = "The 'onStopObserving' component was renamed to 'OnStopObserving'.",
+    replaceWith = ReplaceWith("OnStopObserving(body)")
+  )
+  inline fun onStopObserving(crossinline body: () -> Unit) = OnStopObserving(body)
+
   /**
-   * Method that is invoked when all event listeners are removed.
+   * Creates module's lifecycle listener that is called right after all event listeners are removed.
    */
-  inline fun onStopObserving(crossinline body: () -> Unit) {
-    function("stopObserving", body)
+  inline fun OnStopObserving(crossinline body: () -> Unit) {
+    AsyncFunction("stopObserving", body)
   }
 
-  inline fun onNewIntent(crossinline body: (Intent) -> Unit) {
+  @Deprecated(
+    message = "The 'onNewIntent' component was renamed to 'OnNewIntent'.",
+    replaceWith = ReplaceWith("OnNewIntent(body)")
+  )
+  inline fun onNewIntent(crossinline body: (Intent) -> Unit) = OnNewIntent(body)
+
+  /**
+   * Creates module's lifecycle listener that is called right after the new intent was received.
+   */
+  inline fun OnNewIntent(crossinline body: (Intent) -> Unit) {
     eventListeners[EventName.ON_NEW_INTENT] = EventListenerWithPayload<Intent>(EventName.ON_NEW_INTENT) { body(it) }
   }
 
-  inline fun onActivityResult(crossinline body: (Activity, OnActivityResultPayload) -> Unit) {
+  @Deprecated(
+    message = "The 'onActivityResult' component was renamed to 'OnActivityResult'.",
+    replaceWith = ReplaceWith("OnActivityResult(body)")
+  )
+  inline fun onActivityResult(crossinline body: (Activity, OnActivityResultPayload) -> Unit) = OnActivityResult(body)
+
+  /**
+   * Creates module's lifecycle listener that is called right after the activity has received a result.
+   */
+  inline fun OnActivityResult(crossinline body: (Activity, OnActivityResultPayload) -> Unit) {
     eventListeners[EventName.ON_ACTIVITY_RESULT] =
       EventListenerWithSenderAndPayload<Activity, OnActivityResultPayload>(EventName.ON_ACTIVITY_RESULT) { sender, payload -> body(sender, payload) }
   }

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

@@ -3,13 +3,13 @@ package expo.modules.kotlin.modules
 import expo.modules.kotlin.events.EventListener
 import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.EventsDefinition
-import expo.modules.kotlin.methods.AnyMethod
+import expo.modules.kotlin.functions.AnyFunction
 import expo.modules.kotlin.views.ViewManagerDefinition
 
 class ModuleDefinitionData(
   val name: String,
   val constantsProvider: () -> Map<String, Any?>,
-  val methods: Map<String, AnyMethod>,
+  val methods: Map<String, AnyFunction>,
   val viewManagerDefinition: ViewManagerDefinition? = null,
   val eventListeners: Map<EventName, EventListener> = emptyMap(),
   val eventsDefinition: EventsDefinition? = null