expo-modules-core 1.11.13 → 1.12.1

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

@@ -4,21 +4,24 @@ package expo.modules.kotlin.objects
 
 import com.facebook.react.bridge.Arguments
 import expo.modules.kotlin.Promise
+import expo.modules.kotlin.component6
+import expo.modules.kotlin.component7
+import expo.modules.kotlin.component8
 import expo.modules.kotlin.events.EventsDefinition
 import expo.modules.kotlin.functions.AsyncFunction
 import expo.modules.kotlin.functions.AsyncFunctionBuilder
-import expo.modules.kotlin.functions.AsyncFunctionComponent
 import expo.modules.kotlin.functions.AsyncFunctionWithPromiseComponent
 import expo.modules.kotlin.functions.FunctionBuilder
 import expo.modules.kotlin.functions.SyncFunctionComponent
+import expo.modules.kotlin.functions.createAsyncFunctionComponent
 import expo.modules.kotlin.jni.JavaScriptModuleObject
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinitionBuilder
 import expo.modules.kotlin.types.Enumerable
-import expo.modules.kotlin.types.toAnyType
+import expo.modules.kotlin.types.enforceType
+import expo.modules.kotlin.types.toArgsArray
 import kotlin.reflect.full.declaredMemberProperties
 import kotlin.reflect.full.primaryConstructor
-import kotlin.reflect.typeOf
 
 /**
  * Base class for other definitions representing an object, such as `ModuleDefinition`.
@@ -44,18 +47,6 @@ open class ObjectDefinitionBuilder {
   internal var properties = mutableMapOf<String, PropertyComponentBuilder>()
 
   fun buildObject(): ObjectDefinitionData {
-    // Register stub functions to bypass react-native `NativeEventEmitter` warnings
-    // WARN  `new NativeEventEmitter()` was called with a non-null argument without the required `addListener` method.
-    // WARN  `new NativeEventEmitter()` was called with a non-null argument without the required `removeListeners` method.
-    eventsDefinition?.run {
-      if (!containsFunction("addListener")) {
-        Function("addListener") { _: String -> { } }
-      }
-      if (!containsFunction("removeListeners")) {
-        Function("removeListeners") { _: Int -> { } }
-      }
-    }
-
     return ObjectDefinitionData(
       constantsProvider,
       syncFunctions + syncFunctionBuilder.mapValues { (_, value) -> value.build() },
@@ -65,12 +56,6 @@ open class ObjectDefinitionBuilder {
     )
   }
 
-  private fun containsFunction(functionName: String): Boolean {
-    return syncFunctions.containsKey(functionName) ||
-      asyncFunctions.containsKey(functionName) ||
-      asyncFunctionBuilders.containsKey(functionName)
-  }
-
   /**
    * Definition function setting the module's constants to export.
    */
@@ -94,7 +79,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: () -> Any?
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf()) { body() }.also {
+    return SyncFunctionComponent(name, emptyArray()) { body() }.also {
       syncFunctions[name] = it
     }
   }
@@ -103,7 +88,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: () -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf()) { body() }.also {
+    return SyncFunctionComponent(name, emptyArray()) { body() }.also {
       syncFunctions[name] = it
     }
   }
@@ -112,7 +97,10 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { body(it[0] as P0) }.also {
+    return SyncFunctionComponent(name, toArgsArray<P0>()) { (p0) ->
+      enforceType<P0>(p0)
+      body(p0)
+    }.also {
       syncFunctions[name] = it
     }
   }
@@ -121,7 +109,10 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }.also {
+    return SyncFunctionComponent(name, toArgsArray<P0, P1>()) { (p0, p1) ->
+      enforceType<P0, P1>(p0, p1)
+      body(p0, p1)
+    }.also {
       syncFunctions[name] = it
     }
   }
@@ -130,7 +121,10 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also {
+    return SyncFunctionComponent(name, toArgsArray<P0, P1, P2>()) { (p0, p1, p2) ->
+      enforceType<P0, P1, P2>(p0, p1, p2)
+      body(p0, p1, p2)
+    }.also {
       syncFunctions[name] = it
     }
   }
@@ -139,7 +133,10 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also {
+    return SyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3>()) { (p0, p1, p2, p3) ->
+      enforceType<P0, P1, P2, P3>(p0, p1, p2, p3)
+      body(p0, p1, p2, p3)
+    }.also {
       syncFunctions[name] = it
     }
   }
@@ -148,7 +145,10 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also {
+    return SyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3, P4>()) { (p0, p1, p2, p3, p4) ->
+      enforceType<P0, P1, P2, P3, P4>(p0, p1, p2, p3, p4)
+      body(p0, p1, p2, p3, p4)
+    }.also {
       syncFunctions[name] = it
     }
   }
@@ -157,7 +157,10 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also {
+    return SyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3, P4, P5>()) { (p0, p1, p2, p3, p4, p5) ->
+      enforceType<P0, P1, P2, P3, P4, P5>(p0, p1, p2, p3, p4, p5)
+      body(p0, p1, p2, p3, p4, p5)
+    }.also {
       syncFunctions[name] = it
     }
   }
@@ -166,7 +169,10 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also {
+    return SyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3, P4, P5, P6>()) { (p0, p1, p2, p3, p4, p5, p6) ->
+      enforceType<P0, P1, P2, P3, P4, P5, P6>(p0, p1, p2, p3, p4, p5, p6)
+      body(p0, p1, p2, p3, p4, p5, p6)
+    }.also {
       syncFunctions[name] = it
     }
   }
@@ -175,7 +181,10 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
   ): SyncFunctionComponent {
-    return SyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>(), { typeOf<P7>() }.toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also {
+    return SyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3, P4, P5, P6, P7>()) { (p0, p1, p2, p3, p4, p5, p6, p7) ->
+      enforceType<P0, P1, P2, P3, P4, P5, P6, P7>(p0, p1, p2, p3, p4, p5, p6, p7)
+      body(p0, p1, p2, p3, p4, p5, p6, p7)
+    }.also {
       syncFunctions[name] = it
     }
   }
@@ -185,7 +194,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: () -> Any?
   ): AsyncFunction {
-    return AsyncFunctionComponent(name, arrayOf()) { body() }.also {
+    return createAsyncFunctionComponent(name, emptyArray()) { body() }.also {
       asyncFunctions[name] = it
     }
   }
@@ -194,7 +203,7 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: () -> R
   ): AsyncFunction {
-    return AsyncFunctionComponent(name, arrayOf()) { body() }.also {
+    return createAsyncFunctionComponent(name, emptyArray()) { body() }.also {
       asyncFunctions[name] = it
     }
   }
@@ -203,10 +212,14 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0) -> R
   ): AsyncFunction {
-    return if (P0::class == Promise::class) {
+    // We can't split that function, because that introduces a ambiguity when creating DSL component without parameters.
+    return if (P0::class.java == Promise::class.java) {
       AsyncFunctionWithPromiseComponent(name, arrayOf()) { _, promise -> body(promise as P0) }
     } else {
-      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { body(it[0] as P0) }
+      createAsyncFunctionComponent(name, toArgsArray<P0>()) { (p0) ->
+        enforceType<P0>(p0)
+        body(p0)
+      }
     }.also {
       asyncFunctions[name] = it
     }
@@ -216,10 +229,22 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1) -> R
   ): AsyncFunction {
-    return if (P1::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>())) { args, promise -> body(args[0] as P0, promise as P1) }
-    } else {
-      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }
+    return createAsyncFunctionComponent(name, toArgsArray<P0, P1>()) { (p0, p1) ->
+      enforceType<P0, P1>(p0, p1)
+      body(p0, p1)
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  @JvmName("AsyncFunctionWithPromise")
+  inline fun <reified R, reified P0> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: Promise) -> R
+  ): AsyncFunction {
+    return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0>()) { (p0), promise ->
+      enforceType<P0>(p0)
+      body(p0, promise)
     }.also {
       asyncFunctions[name] = it
     }
@@ -229,10 +254,22 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2) -> R
   ): AsyncFunction {
-    return if (P2::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
-    } else {
-      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
+    return createAsyncFunctionComponent(name, toArgsArray<P0, P1, P2>()) { (p0, p1, p2) ->
+      enforceType<P0, P1, P2>(p0, p1, p2)
+      body(p0, p1, p2)
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  @JvmName("AsyncFunctionWithPromise")
+  inline fun <reified R, reified P0, reified P1> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: Promise) -> R
+  ): AsyncFunction {
+    return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0, P1>()) { (p0, p1), promise ->
+      enforceType<P0, P1>(p0, p1)
+      body(p0, p1, promise)
     }.also {
       asyncFunctions[name] = it
     }
@@ -242,10 +279,22 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
   ): AsyncFunction {
-    return if (P3::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
-    } else {
-      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
+    return createAsyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3>()) { (p0, p1, p2, p3) ->
+      enforceType<P0, P1, P2, P3>(p0, p1, p2, p3)
+      body(p0, p1, p2, p3)
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  @JvmName("AsyncFunctionWithPromise")
+  inline fun <reified R, reified P0, reified P1, reified P2> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: Promise) -> R
+  ): AsyncFunction {
+    return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0, P1, P2>()) { (p0, p1, p2), promise ->
+      enforceType<P0, P1, P2>(p0, p1, p2)
+      body(p0, p1, p2, promise)
     }.also {
       asyncFunctions[name] = it
     }
@@ -255,10 +304,22 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
   ): AsyncFunction {
-    return if (P4::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
-    } else {
-      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
+    return createAsyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3, P4>()) { (p0, p1, p2, p3, p4) ->
+      enforceType<P0, P1, P2, P3, P4>(p0, p1, p2, p3, p4)
+      body(p0, p1, p2, p3, p4)
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  @JvmName("AsyncFunctionWithPromise")
+  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, p4: Promise) -> R
+  ): AsyncFunction {
+    return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0, P1, P2, P3>()) { (p0, p1, p2, p3), promise ->
+      enforceType<P0, P1, P2, P3>(p0, p1, p2, p3)
+      body(p0, p1, p2, p3, promise)
     }.also {
       asyncFunctions[name] = it
     }
@@ -268,10 +329,22 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
   ): AsyncFunction {
-    return if (P5::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
-    } else {
-      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
+    return createAsyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3, P4, P5>()) { (p0, p1, p2, p3, p4, p5) ->
+      enforceType<P0, P1, P2, P3, P4, P5>(p0, p1, p2, p3, p4, p5)
+      body(p0, p1, p2, p3, p4, p5)
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  @JvmName("AsyncFunctionWithPromise")
+  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, p5: Promise) -> R
+  ): AsyncFunction {
+    return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0, P1, P2, P3, P4>()) { (p0, p1, p2, p3, p4), promise ->
+      enforceType<P0, P1, P2, P3, P4>(p0, p1, p2, p3, p4)
+      body(p0, p1, p2, p3, p4, promise)
     }.also {
       asyncFunctions[name] = it
     }
@@ -281,10 +354,22 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
   ): AsyncFunction {
-    return if (P6::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
-    } else {
-      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
+    return createAsyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3, P4, P5, P6>()) { (p0, p1, p2, p3, p4, p5, p6) ->
+      enforceType<P0, P1, P2, P3, P4, P5, P6>(p0, p1, p2, p3, p4, p5, p6)
+      body(p0, p1, p2, p3, p4, p5, p6)
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  @JvmName("AsyncFunctionWithPromise")
+  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, p6: Promise) -> R
+  ): AsyncFunction {
+    return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0, P1, P2, P3, P4, P5>()) { (p0, p1, p2, p3, p4, p5), promise ->
+      enforceType<P0, P1, P2, P3, P4, P5>(p0, p1, p2, p3, p4, p5)
+      body(p0, p1, p2, p3, p4, p5, promise)
     }.also {
       asyncFunctions[name] = it
     }
@@ -294,10 +379,22 @@ open class ObjectDefinitionBuilder {
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
   ): AsyncFunction {
-    return if (P7::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
-    } else {
-      AsyncFunctionComponent(name, arrayOf({ typeOf<P0>() }.toAnyType<P0>(), { typeOf<P1>() }.toAnyType<P1>(), { typeOf<P2>() }.toAnyType<P2>(), { typeOf<P3>() }.toAnyType<P3>(), { typeOf<P4>() }.toAnyType<P4>(), { typeOf<P5>() }.toAnyType<P5>(), { typeOf<P6>() }.toAnyType<P6>(), { typeOf<P7>() }.toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
+    return createAsyncFunctionComponent(name, toArgsArray<P0, P1, P2, P3, P4, P5, P6, P7>()) { (p0, p1, p2, p3, p4, p5, p6, p7) ->
+      enforceType<P0, P1, P2, P3, P4, P5, P6, P7>(p0, p1, p2, p3, p4, p5, p6, p7)
+      body(p0, p1, p2, p3, p4, p5, p6, p7)
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  @JvmName("AsyncFunctionWithPromise")
+  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, p7: Promise) -> R
+  ): AsyncFunction {
+    return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0, P1, P2, P3, P4, P5, P6>()) { (p0, p1, p2, p3, p4, p5, p6), promise ->
+      enforceType<P0, P1, P2, P3, P4, P5, P6>(p0, p1, p2, p3, p4, p5, p6)
+      body(p0, p1, p2, p3, p4, p5, p6, promise)
     }.also {
       asyncFunctions[name] = it
     }
@@ -348,14 +445,16 @@ open class ObjectDefinitionBuilder {
    * Creates module's lifecycle listener that is called right after the first event listener is added.
    */
   inline fun OnStartObserving(crossinline body: () -> Unit) {
-    AsyncFunction("startObserving", body)
+    @Suppress("UNUSED_ANONYMOUS_PARAMETER")
+    AsyncFunction("startObserving") { eventName: String? -> body() }
   }
 
   /**
    * Creates module's lifecycle listener that is called right after all event listeners are removed.
    */
   inline fun OnStopObserving(crossinline body: () -> Unit) {
-    AsyncFunction("stopObserving", body)
+    @Suppress("UNUSED_ANONYMOUS_PARAMETER")
+    AsyncFunction("stopObserving") { eventName: String? -> body() }
   }
 
   /**

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

@@ -4,7 +4,6 @@ import expo.modules.kotlin.functions.SyncFunctionComponent
 import expo.modules.kotlin.types.AnyType
 import expo.modules.kotlin.types.toAnyType
 import kotlin.reflect.KType
-import kotlin.reflect.typeOf
 
 open class PropertyComponentBuilder(
   val name: String
@@ -16,14 +15,14 @@ open class PropertyComponentBuilder(
    * Modifier that sets property getter that has no arguments (the caller is not used).
    */
   inline fun <T> get(crossinline body: () -> T) = apply {
-    getter = SyncFunctionComponent("get", arrayOf()) { body() }
+    getter = SyncFunctionComponent("get", emptyArray()) { body() }
   }
 
   /**
    * Modifier that sets property setter that receives only the new value as an argument.
    */
   inline fun <reified T> set(crossinline body: (newValue: T) -> Unit) = apply {
-    setter = SyncFunctionComponent("set", arrayOf({ typeOf<T>() }.toAnyType<T>())) { body(it[0] as T) }
+    setter = SyncFunctionComponent("set", arrayOf(toAnyType<T>())) { body(it[0] as T) }
   }
 
   fun build(): PropertyComponent {
@@ -53,7 +52,7 @@ class PropertyComponentBuilderWithThis<ThisType>(
    * Modifier that sets property setter that receives only the new value as an argument.
    */
   inline fun <reified T> set(crossinline body: (self: ThisType, newValue: T) -> Unit) = apply {
-    setter = SyncFunctionComponent("set", arrayOf(AnyType(thisType), { typeOf<T>() }.toAnyType<T>())) {
+    setter = SyncFunctionComponent("set", arrayOf(AnyType(thisType), toAnyType<T>())) {
       @Suppress("UNCHECKED_CAST")
       body(it[0] as ThisType, it[1] as T)
     }.also {

package/android/src/main/java/expo/modules/kotlin/sharedobjects/ClassRegistry.kt

@@ -0,0 +1,21 @@
+package expo.modules.kotlin.sharedobjects
+
+import expo.modules.kotlin.jni.JavaScriptObject
+
+class ClassRegistry {
+  internal var pairs = mutableMapOf<Class<*>, JavaScriptObject>()
+
+  internal fun add(native: Class<*>, js: JavaScriptObject) {
+    js.defineDeallocator {
+      delete(native)
+    }
+    pairs[native] = js
+  }
+
+  private fun delete(native: Class<*>) {
+    pairs.remove(native)
+  }
+  internal fun toJavaScriptObject(native: Class<*>): JavaScriptObject? {
+    return pairs[native]
+  }
+}

package/android/src/main/java/expo/modules/kotlin/sharedobjects/SharedObject.kt

@@ -1,15 +1,48 @@
 package expo.modules.kotlin.sharedobjects
 
 import expo.modules.core.interfaces.DoNotStrip
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.jni.JavaScriptObject
+import expo.modules.kotlin.logger
+import java.lang.ref.WeakReference
 
 @DoNotStrip
-open class SharedObject {
+open class SharedObject(appContext: AppContext? = null) {
   /**
    * An identifier of the native shared object that maps to the JavaScript object.
    * When the object is not linked with any JavaScript object, its value is 0.
    */
   internal var sharedObjectId: SharedObjectId = SharedObjectId(0)
 
+  internal var appContextHolder = WeakReference<AppContext>(appContext)
+
+  val appContext: AppContext?
+    get() = appContextHolder.get()
+
+  private fun getJavaScriptObject(): JavaScriptObject? {
+    return SharedObjectId(sharedObjectId.value)
+      .toJavaScriptObject(
+        appContext ?: return null
+      )
+  }
+
+  fun sendEvent(eventName: String, vararg args: Any?) {
+    val jsThis = getJavaScriptObject() ?: return
+
+    try {
+      jsThis.getProperty("emit")
+        .getFunction<Unit?>()
+        .invoke(
+          eventName,
+          *args,
+          thisValue = jsThis,
+          appContext = appContext
+        )
+    } catch (e: Throwable) {
+      logger.error("Unable to send event '$eventName' by shared object of type ${this::class.java.simpleName}", e)
+    }
+  }
+
   /**
    * Called when the shared object being deallocated.
    */

package/android/src/main/java/expo/modules/kotlin/sharedobjects/SharedObjectRegistry.kt

@@ -1,11 +1,14 @@
 package expo.modules.kotlin.sharedobjects
 
 import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.jni.JavaScriptObject
 import expo.modules.kotlin.jni.JavaScriptWeakObject
+import java.lang.ref.WeakReference
 
 @JvmInline
 value class SharedObjectId(val value: Int) {
+
   fun toNativeObject(appContext: AppContext): SharedObject? {
     return appContext.sharedObjectRegistry.toNativeObject(this)
   }
@@ -20,7 +23,9 @@ typealias SharedObjectPair = Pair<SharedObject, JavaScriptWeakObject>
 
 const val sharedObjectIdPropertyName = "__expo_shared_object_id__"
 
-class SharedObjectRegistry {
+class SharedObjectRegistry(appContext: AppContext) {
+  private val appContextHolder = WeakReference(appContext)
+
   private var currentId: SharedObjectId = SharedObjectId(1)
 
   internal var pairs = mutableMapOf<SharedObjectId, SharedObjectPair>()
@@ -34,24 +39,34 @@ class SharedObjectRegistry {
   internal fun add(native: SharedObject, js: JavaScriptObject): SharedObjectId {
     val id = pullNextId()
     native.sharedObjectId = id
+
+    // This property should be deprecated, but it's still used when passing as a view prop.
+    // It's already defined in the JS base SharedObject class prototype,
+    // but with the current implementation it's possible to use a raw object for registration.
     js.defineProperty(sharedObjectIdPropertyName, id.value)
 
-    js.defineDeallocator {
-      delete(id)
-    }
+    val appContext = appContextHolder.get() ?: throw Exceptions.AppContextLost()
+
+    appContext
+      .jsiInterop
+      .setNativeStateForSharedObject(id.value, js)
 
     val jsWeakObject = js.createWeak()
     synchronized(this) {
       pairs[id] = native to jsWeakObject
     }
+
+    if (native.appContextHolder.get() == null) {
+      native.appContextHolder = WeakReference(appContext)
+    }
+
     return id
   }
 
   internal fun delete(id: SharedObjectId) {
-    val removedObject: SharedObjectPair? = synchronized(this) {
-      return@synchronized pairs.remove(id)
-    }
-    removedObject?.let { (native, js) ->
+    synchronized(this) {
+      pairs.remove(id)
+    }?.let { (native, _) ->
       native.sharedObjectId = SharedObjectId(0)
       native.deallocate()
     }

package/android/src/main/java/expo/modules/kotlin/sharedobjects/SharedRef.kt

@@ -1,7 +1,13 @@
 package expo.modules.kotlin.sharedobjects
 
+import expo.modules.core.interfaces.DoNotStrip
+import expo.modules.kotlin.AppContext
+
 /**
  * Shared object (ref) that holds a strong reference to any native object. Allows passing references
  * to native instances among different independent libraries.
  */
-open class SharedRef<RefType>(val ref: RefType) : SharedObject()
+@Suppress("KotlinJniMissingFunction")
+@DoNotStrip
+open class SharedRef<RefType>(val ref: RefType, appContext: AppContext? = null) :
+  SharedObject(appContext)

package/android/src/main/java/expo/modules/kotlin/tracing/ExpoTrace.kt

@@ -30,6 +30,7 @@ inline fun <T> trace(tag: String, blockName: String, crossinline block: () -> T)
  * <p>This call must be followed by a corresponding call to {@link #endTraceBlock()} on the same
  * thread.
  */
+@Suppress("NOTHING_TO_INLINE")
 inline fun beginTraceBlock(tag: String, blockName: String) {
   Trace.beginSection("[$tag] $blockName")
 }
@@ -37,6 +38,7 @@ inline fun beginTraceBlock(tag: String, blockName: String) {
 /**
  * Writes a trace message to indicate that a given section of code has ended.
  */
+@Suppress("NOTHING_TO_INLINE")
 inline fun endTraceBlock() {
   Trace.endSection()
 }
@@ -47,11 +49,13 @@ inline fun endTraceBlock() {
  * <p>Must be followed by a call to {@link #endAsyncTraceBlock(String, String, int)} with the same
  * tag, blockName and cookie.
  */
+@Suppress("NOTHING_TO_INLINE")
 inline fun beginAsyncTraceBlock(tag: String, blockName: String, cookie: Int = 0) =
   Trace.beginAsyncSection("[$tag] $blockName", cookie)
 
 /**
  * Writes a trace message to indicate that the current method has ended.
  */
+@Suppress("NOTHING_TO_INLINE")
 inline fun endAsyncTraceBlock(tag: String, blockName: String, cookie: Int = 0) =
   Trace.endAsyncSection("[$tag] $blockName", cookie)