expo-modules-core 1.11.13 → 1.12.1

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

@@ -1,11 +1,11 @@
 package expo.modules.kotlin.types
 
-import android.view.View
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.jni.ExpectedType
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.KTypeProjection
+import kotlin.reflect.typeOf
 
 class LazyKType(
   override val classifier: KClass<*>,
@@ -52,6 +52,138 @@ inline fun <reified T> (() -> KType).toAnyType() = AnyType(
   )
 )
 
+inline fun <reified T> toAnyType(): AnyType {
+  return { typeOf<T>() }.toAnyType<T>()
+}
+
+@Suppress("UNUSED_PARAMETER")
+inline fun <reified P0> toArgsArray(
+  p0: Class<P0> = P0::class.java
+): Array<AnyType> {
+  return arrayOf(
+    toAnyType<P0>()
+  )
+}
+
+@Suppress("UNUSED_PARAMETER")
+inline fun <reified P0, reified P1> toArgsArray(
+  p0: Class<P0> = P0::class.java,
+  p1: Class<P1> = P1::class.java
+): Array<AnyType> {
+  return arrayOf(
+    toAnyType<P0>(),
+    toAnyType<P1>()
+  )
+}
+
+@Suppress("UNUSED_PARAMETER")
+inline fun <reified P0, reified P1, reified P2> toArgsArray(
+  p0: Class<P0> = P0::class.java,
+  p1: Class<P1> = P1::class.java,
+  p2: Class<P2> = P2::class.java
+): Array<AnyType> {
+  return arrayOf(
+    toAnyType<P0>(),
+    toAnyType<P1>(),
+    toAnyType<P2>()
+  )
+}
+
+@Suppress("UNUSED_PARAMETER")
+inline fun <reified P0, reified P1, reified P2, reified P3> toArgsArray(
+  p0: Class<P0> = P0::class.java,
+  p1: Class<P1> = P1::class.java,
+  p2: Class<P2> = P2::class.java,
+  p3: Class<P3> = P3::class.java
+): Array<AnyType> {
+  return arrayOf(
+    toAnyType<P0>(),
+    toAnyType<P1>(),
+    toAnyType<P2>(),
+    toAnyType<P3>()
+  )
+}
+
+@Suppress("UNUSED_PARAMETER")
+inline fun <reified P0, reified P1, reified P2, reified P3, reified P4> toArgsArray(
+  p0: Class<P0> = P0::class.java,
+  p1: Class<P1> = P1::class.java,
+  p2: Class<P2> = P2::class.java,
+  p3: Class<P3> = P3::class.java,
+  p4: Class<P4> = P4::class.java
+): Array<AnyType> {
+  return arrayOf(
+    toAnyType<P0>(),
+    toAnyType<P1>(),
+    toAnyType<P2>(),
+    toAnyType<P3>(),
+    toAnyType<P4>()
+  )
+}
+
+@Suppress("UNUSED_PARAMETER")
+inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> toArgsArray(
+  p0: Class<P0> = P0::class.java,
+  p1: Class<P1> = P1::class.java,
+  p2: Class<P2> = P2::class.java,
+  p3: Class<P3> = P3::class.java,
+  p4: Class<P4> = P4::class.java,
+  p5: Class<P5> = P5::class.java
+): Array<AnyType> {
+  return arrayOf(
+    toAnyType<P0>(),
+    toAnyType<P1>(),
+    toAnyType<P2>(),
+    toAnyType<P3>(),
+    toAnyType<P4>(),
+    toAnyType<P5>()
+  )
+}
+
+@Suppress("UNUSED_PARAMETER")
+inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> toArgsArray(
+  p0: Class<P0> = P0::class.java,
+  p1: Class<P1> = P1::class.java,
+  p2: Class<P2> = P2::class.java,
+  p3: Class<P3> = P3::class.java,
+  p4: Class<P4> = P4::class.java,
+  p5: Class<P5> = P5::class.java,
+  p6: Class<P6> = P6::class.java
+): Array<AnyType> {
+  return arrayOf(
+    toAnyType<P0>(),
+    toAnyType<P1>(),
+    toAnyType<P2>(),
+    toAnyType<P3>(),
+    toAnyType<P4>(),
+    toAnyType<P5>(),
+    toAnyType<P6>()
+  )
+}
+
+@Suppress("UNUSED_PARAMETER")
+inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> toArgsArray(
+  p0: Class<P0> = P0::class.java,
+  p1: Class<P1> = P1::class.java,
+  p2: Class<P2> = P2::class.java,
+  p3: Class<P3> = P3::class.java,
+  p4: Class<P4> = P4::class.java,
+  p5: Class<P5> = P5::class.java,
+  p6: Class<P6> = P6::class.java,
+  p7: Class<P7> = P7::class.java
+): Array<AnyType> {
+  return arrayOf(
+    toAnyType<P0>(),
+    toAnyType<P1>(),
+    toAnyType<P2>(),
+    toAnyType<P3>(),
+    toAnyType<P4>(),
+    toAnyType<P5>(),
+    toAnyType<P6>(),
+    toAnyType<P7>()
+  )
+}
+
 class AnyType(
   val kType: KType
 ) {
@@ -68,6 +200,6 @@ class AnyType(
     val kClass = kType.classifier as? KClass<*> ?: return false
     val jClass = kClass.java
 
-    return View::class.java.isAssignableFrom(jClass)
+    return T::class.java.isAssignableFrom(jClass)
   }
 }

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

@@ -0,0 +1,60 @@
+package expo.modules.kotlin.types
+
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
+
+@OptIn(ExperimentalContracts::class)
+inline fun <reified P0> enforceType(p0: Any?) {
+  contract {
+    returns() implies (p0 is P0)
+  }
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun <reified P0, reified P1> enforceType(p0: Any?, p1: Any?) {
+  contract {
+    returns() implies (p0 is P0 && p1 is P1)
+  }
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun <reified P0, reified P1, reified P2> enforceType(p0: Any?, p1: Any?, p2: Any?) {
+  contract {
+    returns() implies (p0 is P0 && p1 is P1 && p2 is P2)
+  }
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun <reified P0, reified P1, reified P2, reified P3> enforceType(p0: Any?, p1: Any?, p2: Any?, p3: Any?) {
+  contract {
+    returns() implies (p0 is P0 && p1 is P1 && p2 is P2 && p3 is P3)
+  }
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun <reified P0, reified P1, reified P2, reified P3, reified P4> enforceType(p0: Any?, p1: Any?, p2: Any?, p3: Any?, p4: Any?) {
+  contract {
+    returns() implies (p0 is P0 && p1 is P1 && p2 is P2 && p3 is P3 && p4 is P4)
+  }
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> enforceType(p0: Any?, p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?) {
+  contract {
+    returns() implies (p0 is P0 && p1 is P1 && p2 is P2 && p3 is P3 && p4 is P4 && p5 is P5)
+  }
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> enforceType(p0: Any?, p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?) {
+  contract {
+    returns() implies (p0 is P0 && p1 is P1 && p2 is P2 && p3 is P3 && p4 is P4 && p5 is P5 && p6 is P6)
+  }
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> enforceType(p0: Any?, p1: Any?, p2: Any?, p3: Any?, p4: Any?, p5: Any?, p6: Any?, p7: Any?) {
+  contract {
+    returns() implies (p0 is P0 && p1 is P1 && p2 is P2 && p3 is P3 && p4 is P4 && p5 is P5 && p6 is P6 && p7 is P7)
+  }
+}

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

@@ -27,8 +27,8 @@ class EnumTypeConverter(
   }
 
   init {
-    if (Enumerable::class.java.isAssignableFrom(enumClass.java)) {
-      logger.warn("Enum '$enumClass' should inherit from ${Enumerable::class}.")
+    if (!Enumerable::class.java.isAssignableFrom(enumClass.java)) {
+      logger.error("Enum '$enumClass' should inherit from ${Enumerable::class}.")
     }
   }
 

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

@@ -81,8 +81,6 @@ inline fun <reified T : Any> createTrivialTypeConverter(
   return object : DynamicAwareTypeConverters<T>(isOptional) {
     override fun convertFromDynamic(value: Dynamic): T = dynamicFallback(value)
     override fun getCppRequiredTypes(): ExpectedType = cppRequireType
-
-    @Suppress("UNCHECKED_CAST")
     override fun convertFromAny(value: Any): T = value as T
   }
 }

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

@@ -6,7 +6,6 @@ import android.view.View
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
-import expo.modules.annotation.Config
 import expo.modules.core.arguments.ReadableArguments
 import expo.modules.kotlin.apifeatures.EitherType
 import expo.modules.kotlin.exception.MissingTypeConverter
@@ -75,7 +74,6 @@ object TypeConverterProviderImpl : TypeConverterProvider {
   private val nullableCachedConverters = createCachedConverters(true)
 
   private val cachedRecordConverters = mutableMapOf<KClass<*>, TypeConverter<*>>()
-  private val cachedCustomConverters = mutableMapOf<KType, TypeConverter<*>>()
 
   private fun getCachedConverter(inputType: KType): TypeConverter<*>? {
     return if (inputType.isMarkedNullable) {
@@ -142,7 +140,6 @@ object TypeConverterProviderImpl : TypeConverterProvider {
     }
 
     return handelEither(type, jClass)
-      ?: handelCustomConverter(type, kClass)
       ?: throw MissingTypeConverter(type)
   }
 
@@ -161,29 +158,6 @@ object TypeConverterProviderImpl : TypeConverterProvider {
     return null
   }
 
-  private fun handelCustomConverter(type: KType, kClass: KClass<*>): TypeConverter<*>? {
-    val cachedConverter = cachedCustomConverters[type]
-    if (cachedConverter != null) {
-      return cachedConverter
-    }
-
-    val typeName = kClass.java.canonicalName ?: return null
-
-    val converterProviderName = "${Config.packageNamePrefix}$typeName${Config.classNameSuffix}"
-    return try {
-      val converterClazz = Class.forName(converterProviderName)
-      val converterProvider = converterClazz.newInstance()
-      val method = converterProvider.javaClass.getMethod(Config.converterProviderFunctionName, KType::class.java)
-
-      (method.invoke(converterProvider, type) as TypeConverter<*>)
-        .also {
-          cachedCustomConverters[type] = it
-        }
-    } catch (e: Throwable) {
-      null
-    }
-  }
-
   private fun createCachedConverters(isOptional: Boolean): Map<KClass<*>, TypeConverter<*>> {
     val intTypeConverter = createTrivialTypeConverter(
       isOptional,
@@ -295,7 +269,9 @@ object TypeConverterProviderImpl : TypeConverterProvider {
 
       Any::class to AnyTypeConverter(isOptional),
 
-      Unit::class to UnitTypeConverter(isOptional),
+      // Unit converter doesn't care about nullability.
+      // It will always return Unit
+      Unit::class to UnitTypeConverter(),
 
       ReadableArguments::class to ReadableArgumentsTypeConverter(isOptional)
     )

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

@@ -1,15 +1,11 @@
 package expo.modules.kotlin.types
 
-import com.facebook.react.bridge.Dynamic
+import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.jni.ExpectedType
 
-class UnitTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<Any>(isOptional) {
-  override fun convertFromDynamic(value: Dynamic): Any {
-    return Unit
-  }
-
-  override fun convertFromAny(value: Any): Any = Unit
+class UnitTypeConverter : TypeConverter<Unit>() {
+  override fun convert(value: Any?, context: AppContext?) = Unit
 
   override fun getCppRequiredTypes(): ExpectedType = ExpectedType(CppType.ANY)
 }

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

@@ -1,5 +1,7 @@
 package expo.modules.kotlin.types.io
 
+import android.os.Build
+import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.Dynamic
 import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.jni.ExpectedType
@@ -7,6 +9,7 @@ import expo.modules.kotlin.types.DynamicAwareTypeConverters
 import java.nio.file.Path
 import java.nio.file.Paths
 
+@RequiresApi(Build.VERSION_CODES.O)
 class PathTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<Path>(isOptional) {
   override fun convertFromDynamic(value: Dynamic): Path {
     val stringPath = value.asString()

package/android/src/main/java/expo/modules/kotlin/viewevent/ViewEvent.kt

@@ -3,8 +3,8 @@ package expo.modules.kotlin.viewevent
 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.core.utilities.ifNull
+import expo.modules.kotlin.getUnimoduleProxy
 import expo.modules.kotlin.logger
 import expo.modules.kotlin.types.JSTypeConverter
 import expo.modules.kotlin.types.putGeneric
@@ -22,10 +22,7 @@ open class ViewEvent<T>(
 
   override operator fun invoke(arg: T) {
     val reactContext = view.context as ReactContext
-    val nativeModulesProxy = reactContext
-      .catalystInstance
-      ?.getNativeModule("NativeUnimoduleProxy") as? NativeModulesProxy
-      ?: return
+    val nativeModulesProxy = reactContext.getUnimoduleProxy() ?: return
     val appContext = nativeModulesProxy.kotlinInteropModuleRegistry.appContext
 
     if (!isValidated) {

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

@@ -12,16 +12,18 @@ import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.exception.UnexpectedException
 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.Queues
+import expo.modules.kotlin.functions.createAsyncFunctionComponent
 import expo.modules.kotlin.modules.DefinitionMarker
 import expo.modules.kotlin.types.toAnyType
 import kotlin.reflect.KClass
-import kotlin.reflect.KFunction
 import kotlin.reflect.KType
-import kotlin.reflect.full.primaryConstructor
-import kotlin.reflect.typeOf
+import expo.modules.kotlin.component6
+import expo.modules.kotlin.component7
+import expo.modules.kotlin.component8
+import expo.modules.kotlin.types.enforceType
+import expo.modules.kotlin.types.toArgsArray
 
 @DefinitionMarker
 class ViewDefinitionBuilder<T : View>(
@@ -111,7 +113,7 @@ class ViewDefinitionBuilder<T : View>(
   ) {
     props[name] = ConcreteViewProp(
       name,
-      { typeOf<PropType>() }.toAnyType<PropType>(),
+      toAnyType<PropType>(),
       body
     )
   }
@@ -126,11 +128,20 @@ class ViewDefinitionBuilder<T : View>(
   ) {
     props[name] = ConcreteViewProp(
       name,
-      { typeOf<PropType>() }.toAnyType<PropType>(),
+      toAnyType<PropType>(),
       body
     )
   }
 
+  inline fun <reified ViewType : View, reified PropType, reified CustomValueType> PropGroup(
+    vararg props: Pair<String, CustomValueType>,
+    noinline body: (view: ViewType, value: CustomValueType, prop: PropType) -> Unit
+  ) {
+    for ((name, value) in props) {
+      Prop<ViewType, PropType>(name) { view, prop -> body(view, value, prop) }
+    }
+  }
+
   /**
    * Defines prop names that should be treated as callbacks.
    */
@@ -163,7 +174,7 @@ class ViewDefinitionBuilder<T : View>(
     name: String,
     crossinline body: () -> Any?
   ): AsyncFunction {
-    return AsyncFunctionComponent(name, arrayOf()) { body() }.also {
+    return createAsyncFunctionComponent(name, emptyArray()) { body() }.also {
       asyncFunctions[name] = it
     }
   }
@@ -172,7 +183,7 @@ class ViewDefinitionBuilder<T : View>(
     name: String,
     crossinline body: () -> R
   ): AsyncFunction {
-    return AsyncFunctionComponent(name, arrayOf()) { body() }.also {
+    return createAsyncFunctionComponent(name, emptyArray()) { body() }.also {
       asyncFunctions[name] = it
     }
   }
@@ -181,10 +192,14 @@ class ViewDefinitionBuilder<T : View>(
     name: String,
     crossinline body: (p0: P0) -> R
   ): AsyncFunction {
+    // We can't split that function, because that introduces a ambiguity when creating DSL component without parameters.
     return if (P0::class == Promise::class) {
-      AsyncFunctionWithPromiseComponent(name, arrayOf()) { _, promise -> body(promise as P0) }
+      AsyncFunctionWithPromiseComponent(name, emptyArray()) { _, 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
     }
@@ -194,10 +209,22 @@ class ViewDefinitionBuilder<T : View>(
     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
     }
@@ -207,10 +234,22 @@ class ViewDefinitionBuilder<T : View>(
     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
     }
@@ -220,10 +259,22 @@ class ViewDefinitionBuilder<T : View>(
     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
     }
@@ -233,10 +284,22 @@ class ViewDefinitionBuilder<T : View>(
     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
     }
@@ -246,10 +309,22 @@ class ViewDefinitionBuilder<T : View>(
     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
     }
@@ -259,10 +334,22 @@ class ViewDefinitionBuilder<T : View>(
     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
     }
@@ -272,10 +359,22 @@ class ViewDefinitionBuilder<T : View>(
     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
     }
@@ -336,14 +435,4 @@ class ViewDefinitionBuilder<T : View>(
       ErrorView(context)
     }
   }
-
-  private fun getPrimaryConstructor(): KFunction<T>? {
-    val kotlinContractor = viewClass.primaryConstructor
-    if (kotlinContractor != null) {
-      return kotlinContractor
-    }
-
-    // Add compatibility with Java
-    return viewClass.constructors.firstOrNull()
-  }
 }