expo-modules-core 2.3.8 → 2.3.10

package/CHANGELOG.md

@@ -10,11 +10,24 @@
 
 ### 💡 Others
 
+## 2.3.10 — 2025-04-28
+
+### 🐛 Bug fixes
+
+- [iOS] Fix concurrent functions on views. ([#36431](https://github.com/expo/expo/pull/36431) by [@alanjhughes](https://github.com/alanjhughes))
+
+## 2.3.9 — 2025-04-25
+
+### 💡 Others
+
+- Removes `Jetpack Compose` integration if not needed. ([#36353](https://github.com/expo/expo/pull/36353) by [@lukmccall](https://github.com/lukmccall))
+- Refined `Children` return type for SwiftUI integration. ([#36377](https://github.com/expo/expo/pull/36377) by [@kudo](https://github.com/kudo))
+
 ## 2.3.8 — 2025-04-23
 
 ### 💡 Others
 
-- Droped support for Kotlin < `2.0.0`.
+- Droped support for Kotlin < `2.0.0`. ([#36323](https://github.com/expo/expo/pull/36323) by [@lukmccall](https://github.com/lukmccall))
 
 ## 2.3.7 — 2025-04-22
 

package/android/build.gradle

@@ -2,25 +2,30 @@ import expo.modules.plugin.gradle.ExpoModuleExtension
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 buildscript {
+  // List of features that are required by linked modules
+  def coreFeatures = project.findProperty("coreFeatures") ?: []
+  ext.shouldIncludeCompose = coreFeatures.contains("compose")
+
   repositories {
     mavenCentral()
   }
 
   dependencies {
-    classpath("org.jetbrains.kotlin.plugin.compose:org.jetbrains.kotlin.plugin.compose.gradle.plugin:${kotlinVersion}")
+    if (shouldIncludeCompose) {
+      classpath("org.jetbrains.kotlin.plugin.compose:org.jetbrains.kotlin.plugin.compose.gradle.plugin:${kotlinVersion}")
+    }
   }
 }
 
 apply plugin: 'com.android.library'
 apply plugin: 'expo-module-gradle-plugin'
-apply plugin: 'org.jetbrains.kotlin.plugin.compose'
 
+if (shouldIncludeCompose) {
+  apply plugin: 'org.jetbrains.kotlin.plugin.compose'
+}
 
 group = 'host.exp.exponent'
-version = '2.3.8'
-
-// List of features that are required by linked modules
-def coreFeatures = project.findProperty("coreFeatures") ?: []
+version = '2.3.10'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -70,7 +75,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "2.3.8"
+    versionName "2.3.10"
     buildConfigField "String", "EXPO_MODULES_CORE_VERSION", "\"${versionName}\""
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled.toString()
 
@@ -98,7 +103,7 @@ android {
   buildFeatures {
     buildConfig true
     prefab true
-    compose true
+    compose shouldIncludeCompose
   }
 
   packagingOptions {
@@ -155,6 +160,12 @@ android {
           // TODO(kudo,20241112): Remove this when we drop react-native 0.76 support
           srcDirs += 'src/rn74'
         }
+
+        if (shouldIncludeCompose) {
+          srcDirs += 'src/compose'
+        } else {
+          srcDirs += 'src/withoutCompose'
+        }
       }
     }
   }
@@ -183,7 +194,9 @@ dependencies {
   api "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
   api "androidx.core:core-ktx:1.13.1"
 
-  implementation 'androidx.compose.foundation:foundation-android:1.7.6'
+  if (shouldIncludeCompose) {
+    implementation 'androidx.compose.foundation:foundation-android:1.7.6'
+  }
 
   implementation("androidx.tracing:tracing-ktx:1.2.0")
 

package/android/src/compose/expo/modules/kotlin/views/ModuleDefinitionBuilderComposeExtension.kt

@@ -0,0 +1,35 @@
+@file:Suppress("FunctionName")
+
+package expo.modules.kotlin.views
+
+import expo.modules.kotlin.modules.InternalModuleDefinitionBuilder
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.types.AnyType
+import expo.modules.kotlin.types.LazyKType
+import expo.modules.kotlin.views.decorators.UseCSSProps
+import kotlin.reflect.KClass
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.typeOf
+
+open class ModuleDefinitionBuilderWithCompose(
+  module: Module? = null
+) : InternalModuleDefinitionBuilder(module) {
+  /**
+   * Creates the view manager definition that scopes other view-related definitions.
+   * Also collects all compose view props and generates setters.
+   */
+  @JvmName("ComposeView")
+  inline fun <reified T : ExpoComposeView<P>, reified P : Any> View(viewClass: KClass<T>, body: ViewDefinitionBuilder<T>.() -> Unit = {}) {
+    val viewDefinitionBuilder = ViewDefinitionBuilder(viewClass, LazyKType(classifier = T::class, kTypeProvider = { typeOf<T>() }))
+    P::class.memberProperties.forEach { prop ->
+      val kType = prop.returnType.arguments.first().type
+      if (kType != null) {
+        viewDefinitionBuilder.props[prop.name] = ComposeViewProp(prop.name, AnyType(kType), prop)
+      }
+    }
+
+    viewDefinitionBuilder.UseCSSProps()
+    body.invoke(viewDefinitionBuilder)
+    registerViewDefinition(viewDefinitionBuilder.build())
+  }
+}

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

@@ -8,7 +8,7 @@ import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.exception.FunctionCallException
 import expo.modules.kotlin.exception.MethodNotFoundException
 import expo.modules.kotlin.exception.exceptionDecorator
-import expo.modules.kotlin.functions.AsyncFunction
+import expo.modules.kotlin.functions.AsyncFunctionComponent
 import expo.modules.kotlin.jni.JavaScriptModuleObject
 import expo.modules.kotlin.jni.decorators.JSDecoratorsBridgingObject
 import expo.modules.kotlin.modules.DEFAULT_MODULE_VIEW
@@ -131,7 +131,7 @@ class ModuleHolder<T : Module>(val module: T) {
     val method = definition.asyncFunctions[methodName]
       ?: throw MethodNotFoundException()
 
-    if (method is AsyncFunction) {
+    if (method is AsyncFunctionComponent) {
       method.callUserImplementation(args, promise, module.appContext)
       return@exceptionDecorator
     }

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

@@ -92,19 +92,19 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   }
 
   @JvmName("AsyncBodyWithoutArgs")
-  inline fun AsyncBody(crossinline body: () -> Any?): AsyncFunction {
+  inline fun AsyncBody(crossinline body: () -> Any?): AsyncFunctionComponent {
     return createAsyncFunctionComponent(name, emptyArray()) { body() }.also {
       asyncFunctionComponent = it
     }
   }
 
-  inline fun <reified R> AsyncBody(crossinline body: () -> R): AsyncFunction {
+  inline fun <reified R> AsyncBody(crossinline body: () -> R): AsyncFunctionComponent {
     return createAsyncFunctionComponent(name, emptyArray()) { body() }.also {
       asyncFunctionComponent = it
     }
   }
 
-  inline fun <reified R, reified P0> AsyncBody(crossinline body: (p0: P0) -> R): AsyncFunction {
+  inline fun <reified R, reified P0> AsyncBody(crossinline body: (p0: P0) -> R): AsyncFunctionComponent {
     return if (P0::class == Promise::class) {
       AsyncFunctionWithPromiseComponent(name, emptyArray()) { _, promise -> body(promise as P0) }
     } else {
@@ -117,7 +117,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
     }
   }
 
-  inline fun <reified R, reified P0, reified P1> AsyncBody(crossinline body: (p0: P0, p1: P1) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1> AsyncBody(crossinline body: (p0: P0, p1: P1) -> R): AsyncFunctionComponent {
     return createAsyncFunctionComponent(name, toArgsArray<P0, P1>()) { (p0, p1) ->
       enforceType<P0, P1>(p0, p1)
       body(p0, p1)
@@ -127,7 +127,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   }
 
   @JvmName("AsyncFunctionWithPromise")
-  inline fun <reified R, reified P0> AsyncBody(crossinline body: (p0: P0, p1: Promise) -> R): AsyncFunction {
+  inline fun <reified R, reified P0> AsyncBody(crossinline body: (p0: P0, p1: Promise) -> R): AsyncFunctionComponent {
     return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0>()) { (p0), promise ->
       enforceType<P0>(p0)
       body(p0, promise)
@@ -136,7 +136,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
     }
   }
 
-  inline fun <reified R, reified P0, reified P1, reified P2> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2) -> R): AsyncFunctionComponent {
     return createAsyncFunctionComponent(name, toArgsArray<P0, P1, P2>()) { (p0, p1, p2) ->
       enforceType<P0, P1, P2>(p0, p1, p2)
       body(p0, p1, p2)
@@ -146,7 +146,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   }
 
   @JvmName("AsyncFunctionWithPromise")
-  inline fun <reified R, reified P0, reified P1> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: Promise) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: Promise) -> R): AsyncFunctionComponent {
     return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0, P1>()) { (p0, p1), promise ->
       enforceType<P0, P1>(p0, p1)
       body(p0, p1, promise)
@@ -155,7 +155,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
     }
   }
 
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R): AsyncFunctionComponent {
     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)
@@ -165,7 +165,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   }
 
   @JvmName("AsyncFunctionWithPromise")
-  inline fun <reified R, reified P0, reified P1, reified P2> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: Promise) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: Promise) -> R): AsyncFunctionComponent {
     return AsyncFunctionWithPromiseComponent(name, toArgsArray<P0, P1, P2>()) { (p0, p1, p2), promise ->
       enforceType<P0, P1, P2>(p0, p1, p2)
       body(p0, p1, p2, promise)
@@ -174,7 +174,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
     }
   }
 
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R): AsyncFunctionComponent {
     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)
@@ -184,7 +184,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   }
 
   @JvmName("AsyncFunctionWithPromise")
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: Promise) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: Promise) -> R): AsyncFunctionComponent {
     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)
@@ -193,7 +193,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
     }
   }
 
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R): AsyncFunctionComponent {
     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)
@@ -203,7 +203,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   }
 
   @JvmName("AsyncFunctionWithPromise")
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: Promise) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: Promise) -> R): AsyncFunctionComponent {
     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)
@@ -212,7 +212,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
     }
   }
 
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R): AsyncFunctionComponent {
     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)
@@ -222,7 +222,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   }
 
   @JvmName("AsyncFunctionWithPromise")
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: Promise) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: Promise) -> R): AsyncFunctionComponent {
     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)
@@ -231,7 +231,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
     }
   }
 
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R): AsyncFunctionComponent {
     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)
@@ -241,7 +241,7 @@ class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   }
 
   @JvmName("AsyncFunctionWithPromise")
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: Promise) -> R): AsyncFunction {
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncBody(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: Promise) -> R): AsyncFunctionComponent {
     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)

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

@@ -1,84 +1,91 @@
 package expo.modules.kotlin.functions
 
+import android.view.View
+import expo.modules.BuildConfig
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.FunctionCallException
+import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.exception.toCodedException
+import expo.modules.kotlin.jni.decorators.JSDecoratorsBridgingObject
 import expo.modules.kotlin.types.AnyType
-import expo.modules.kotlin.types.enforceType
+import expo.modules.kotlin.weak
+import kotlinx.coroutines.launch
 
-inline fun <reified ReturnType> createAsyncFunctionComponent(
+/**
+ * Base class of async function components that require a promise to be called.
+ */
+abstract class AsyncFunctionComponent(
   name: String,
-  desiredArgsTypes: Array<AnyType>,
-  noinline body: (args: Array<out Any?>) -> ReturnType
-): AsyncFunction {
-  if (null is ReturnType) {
-    return AsyncFunctionComponent<Any?>(name, desiredArgsTypes, body)
-  }
-  return when (ReturnType::class.java) {
-    Int::class.java -> {
-      enforceType<(Array<out Any?>) -> Int>(body)
-      IntAsyncFunctionComponent(name, desiredArgsTypes, body)
-    }
-    Boolean::class.java -> {
-      enforceType<(Array<out Any?>) -> Boolean>(body)
-      BoolAsyncFunctionComponent(name, desiredArgsTypes, body)
-    }
-    Double::class.java -> {
-      enforceType<(Array<out Any?>) -> Double>(body)
-      DoubleAsyncFunctionComponent(name, desiredArgsTypes, body)
-    }
-    Float::class.java -> {
-      enforceType<(Array<out Any?>) -> Float>(body)
-      FloatAsyncFunctionComponent(name, desiredArgsTypes, body)
-    }
-    String::class.java -> {
-      enforceType<(Array<out Any?>) -> String>(body)
-      StringAsyncFunctionComponent(name, desiredArgsTypes, body)
-    }
-    else -> AsyncFunctionComponent<Any?>(name, desiredArgsTypes, body)
-  }
-}
+  desiredArgsTypes: Array<AnyType>
+) : BaseAsyncFunctionComponent(name, desiredArgsTypes) {
+  internal abstract fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext)
 
-class IntAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> Int) :
-  AsyncFunctionComponent<Int>(name, desiredArgsTypes, body) {
-  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
-    promise.resolve(body(convertArgs(args, appContext)))
-  }
-}
+  override fun attachToJSObject(appContext: AppContext, jsObject: JSDecoratorsBridgingObject, moduleName: String) {
+    val appContextHolder = appContext.weak()
+    jsObject.registerAsyncFunction(
+      name,
+      takesOwner,
+      isEnumerable,
+      desiredArgsTypes.map { it.getCppRequiredTypes() }.toTypedArray()
+    ) { args, promiseImpl ->
+      if (BuildConfig.DEBUG) {
+        promiseImpl.decorateWithDebugInformation(
+          appContextHolder,
+          moduleName,
+          name
+        )
+      }
 
-class BoolAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> Boolean) :
-  AsyncFunctionComponent<Boolean>(name, desiredArgsTypes, body) {
-  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
-    promise.resolve(body(convertArgs(args, appContext)))
-  }
-}
+      val functionBody = {
+        try {
+          exceptionDecorator({
+            FunctionCallException(name, moduleName, it)
+          }) {
+            callUserImplementation(args, promiseImpl, appContext)
+          }
+        } catch (e: Throwable) {
+          // The promise was resolved, so we should rethrow the error.
+          if (promiseImpl.wasSettled) {
+            throw e
+          }
+          promiseImpl.reject(e.toCodedException())
+        }
+      }
 
-class DoubleAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> Double) :
-  AsyncFunctionComponent<Double>(name, desiredArgsTypes, body) {
-  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
-    promise.resolve(body(convertArgs(args, appContext)))
+      dispatchOnQueue(appContext, functionBody)
+    }
   }
-}
 
-class FloatAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> Float) :
-  AsyncFunctionComponent<Float>(name, desiredArgsTypes, body) {
-  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
-    promise.resolve(body(convertArgs(args, appContext)))
-  }
-}
+  private fun dispatchOnQueue(appContext: AppContext, block: () -> Unit) {
+    when (val queue = queue) {
+      Queues.DEFAULT -> {
+        appContext.modulesQueue.launch {
+          block()
+        }
+      }
 
-class StringAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> String) :
-  AsyncFunctionComponent<String>(name, desiredArgsTypes, body) {
-  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
-    promise.resolve(body(convertArgs(args, appContext)))
-  }
-}
+      Queues.MAIN -> {
+        if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED && desiredArgsTypes.any { it.inheritFrom<View>() }) {
+          // On certain occasions, invoking a function on a view could lead to an error
+          // because of the asynchronous communication between the JavaScript and native components.
+          // In such cases, the native view may not have been mounted yet,
+          // but the JavaScript code has already received the future tag of the view.
+          // To avoid this issue, we have decided to temporarily utilize
+          // the UIManagerModule for dispatching functions on the main thread.
+          appContext.dispatchOnMainUsingUIManager(block)
+          return
+        }
 
-open class AsyncFunctionComponent<ReturnType>(
-  name: String,
-  desiredArgsTypes: Array<AnyType>,
-  protected val body: (args: Array<out Any?>) -> ReturnType
-) : AsyncFunction(name, desiredArgsTypes) {
-  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
-    promise.resolve(body(convertArgs(args, appContext)))
+        appContext.mainQueue.launch {
+          block()
+        }
+      }
+
+      is CustomQueue ->
+        queue.scope.launch {
+          block()
+        }
+    }
   }
 }

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

@@ -8,7 +8,7 @@ class AsyncFunctionWithPromiseComponent(
   name: String,
   desiredArgsTypes: Array<AnyType>,
   private val body: (args: Array<out Any?>, promise: Promise) -> Unit
-) : AsyncFunction(name, desiredArgsTypes) {
+) : AsyncFunctionComponent(name, desiredArgsTypes) {
   override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
     body(convertArgs(args, appContext), promise)
   }

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

@@ -0,0 +1,84 @@
+package expo.modules.kotlin.functions
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.types.AnyType
+import expo.modules.kotlin.types.enforceType
+
+inline fun <reified ReturnType> createAsyncFunctionComponent(
+  name: String,
+  desiredArgsTypes: Array<AnyType>,
+  noinline body: (args: Array<out Any?>) -> ReturnType
+): AsyncFunctionComponent {
+  if (null is ReturnType) {
+    return UntypedAsyncFunctionComponent<Any?>(name, desiredArgsTypes, body)
+  }
+  return when (ReturnType::class.java) {
+    Int::class.java -> {
+      enforceType<(Array<out Any?>) -> Int>(body)
+      IntAsyncFunctionComponent(name, desiredArgsTypes, body)
+    }
+    Boolean::class.java -> {
+      enforceType<(Array<out Any?>) -> Boolean>(body)
+      BoolAsyncFunctionComponent(name, desiredArgsTypes, body)
+    }
+    Double::class.java -> {
+      enforceType<(Array<out Any?>) -> Double>(body)
+      DoubleAsyncFunctionComponent(name, desiredArgsTypes, body)
+    }
+    Float::class.java -> {
+      enforceType<(Array<out Any?>) -> Float>(body)
+      FloatAsyncFunctionComponent(name, desiredArgsTypes, body)
+    }
+    String::class.java -> {
+      enforceType<(Array<out Any?>) -> String>(body)
+      StringAsyncFunctionComponent(name, desiredArgsTypes, body)
+    }
+    else -> UntypedAsyncFunctionComponent<Any?>(name, desiredArgsTypes, body)
+  }
+}
+
+class IntAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> Int) :
+  UntypedAsyncFunctionComponent<Int>(name, desiredArgsTypes, body) {
+  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
+    promise.resolve(body(convertArgs(args, appContext)))
+  }
+}
+
+class BoolAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> Boolean) :
+  UntypedAsyncFunctionComponent<Boolean>(name, desiredArgsTypes, body) {
+  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
+    promise.resolve(body(convertArgs(args, appContext)))
+  }
+}
+
+class DoubleAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> Double) :
+  UntypedAsyncFunctionComponent<Double>(name, desiredArgsTypes, body) {
+  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
+    promise.resolve(body(convertArgs(args, appContext)))
+  }
+}
+
+class FloatAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> Float) :
+  UntypedAsyncFunctionComponent<Float>(name, desiredArgsTypes, body) {
+  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
+    promise.resolve(body(convertArgs(args, appContext)))
+  }
+}
+
+class StringAsyncFunctionComponent(name: String, desiredArgsTypes: Array<AnyType>, body: (args: Array<out Any?>) -> String) :
+  UntypedAsyncFunctionComponent<String>(name, desiredArgsTypes, body) {
+  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
+    promise.resolve(body(convertArgs(args, appContext)))
+  }
+}
+
+open class UntypedAsyncFunctionComponent<ReturnType>(
+  name: String,
+  desiredArgsTypes: Array<AnyType>,
+  protected val body: (args: Array<out Any?>) -> ReturnType
+) : AsyncFunctionComponent(name, desiredArgsTypes) {
+  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
+    promise.resolve(body(convertArgs(args, appContext)))
+  }
+}

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

@@ -16,22 +16,23 @@ import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.OnActivityResultPayload
 import expo.modules.kotlin.objects.ObjectDefinitionBuilder
 import expo.modules.kotlin.sharedobjects.SharedObject
-import expo.modules.kotlin.types.AnyType
 import expo.modules.kotlin.types.LazyKType
 import expo.modules.kotlin.types.toAnyType
-import expo.modules.kotlin.views.ComposeViewProp
-import expo.modules.kotlin.views.ExpoComposeView
+import expo.modules.kotlin.views.ModuleDefinitionBuilderWithCompose
 import expo.modules.kotlin.views.ViewDefinitionBuilder
 import expo.modules.kotlin.views.ViewManagerDefinition
 import expo.modules.kotlin.views.decorators.UseCSSProps
 import kotlin.reflect.KClass
-import kotlin.reflect.full.memberProperties
 import kotlin.reflect.typeOf
 
 const val DEFAULT_MODULE_VIEW = "DEFAULT_MODULE_VIEW"
 
-@DefinitionMarker
 class ModuleDefinitionBuilder(
+  module: Module? = null
+) : ModuleDefinitionBuilderWithCompose(module)
+
+@DefinitionMarker
+open class InternalModuleDefinitionBuilder(
   @PublishedApi internal val module: Module? = null
 ) : ObjectDefinitionBuilder(
   module
@@ -72,7 +73,8 @@ class ModuleDefinitionBuilder(
     this.name = name
   }
 
-  fun registerViewDefinition(definition: ViewManagerDefinition) {
+  @PublishedApi
+  internal fun registerViewDefinition(definition: ViewManagerDefinition) {
     // For backwards compatibility, the first View is also added to viewManagerDefinitions under the `DEFAULT` key
     if (definition.name != null) {
       require(!viewManagerDefinitions.contains(definition.name)) { "The module definition defines more than one view with name ${definition.name}." }
@@ -95,25 +97,6 @@ class ModuleDefinitionBuilder(
     registerViewDefinition(viewDefinitionBuilder.build())
   }
 
-  /**
-   * Creates the view manager definition that scopes other view-related definitions.
-   * Also collects all compose view props and generates setters.
-   */
-  @JvmName("ComposeView")
-  inline fun <reified T : ExpoComposeView<P>, reified P : Any> View(viewClass: KClass<T>, body: ViewDefinitionBuilder<T>.() -> Unit = {}) {
-    val viewDefinitionBuilder = ViewDefinitionBuilder(viewClass, LazyKType(classifier = T::class, kTypeProvider = { typeOf<T>() }))
-    P::class.memberProperties.forEach { prop ->
-      val kType = prop.returnType.arguments.first().type
-      if (kType != null) {
-        viewDefinitionBuilder.props[prop.name] = ComposeViewProp(prop.name, AnyType(kType), prop)
-      }
-    }
-
-    viewDefinitionBuilder.UseCSSProps()
-    body.invoke(viewDefinitionBuilder)
-    registerViewDefinition(viewDefinitionBuilder.build())
-  }
-
   /**
    * Creates module's lifecycle listener that is called right after the module initialization.
    */