expo-modules-core 1.2.6 → 1.3.0

package/ios/Swift/Arguments/Convertible.swift

@@ -2,16 +2,16 @@
 
 /**
  A protocol that allows custom classes or structs to be used as function arguments.
- It requires static `convert(from:)` function that knows how to convert incoming
+ It requires static `convert(from:appContext:)` function that knows how to convert incoming
  value of `Any` type to the type implemented by this protocol. It should throw an error
  when the value is not recognized, is invalid or doesn't meet type requirements.
  */
 public protocol Convertible: AnyArgument {
   /**
-   Converts any value to the instance of its class (or struct).
+   Converts any value to the instance of its class (or struct) in the given app context.
    Throws an error when given value cannot be converted.
    */
-  static func convert(from value: Any?) throws -> Self
+  static func convert(from value: Any?, appContext: AppContext) throws -> Self
 }
 
 @available(*, deprecated, renamed: "Convertible")

package/ios/Swift/Arguments/Convertibles.swift

@@ -12,7 +12,7 @@ import CoreGraphics
 // MARK: - Foundation
 
 extension URL: Convertible {
-  public static func convert(from value: Any?) throws -> Self {
+  public static func convert(from value: Any?, appContext: AppContext) throws -> Self {
     guard let value = value as? String else {
       throw Conversions.ConvertingException<URL>(value)
     }
@@ -47,7 +47,7 @@ internal class UrlContainsInvalidCharactersException: Exception {
 // MARK: - CoreGraphics
 
 extension CGPoint: Convertible {
-  public static func convert(from value: Any?) throws -> CGPoint {
+  public static func convert(from value: Any?, appContext: AppContext) throws -> CGPoint {
     if let value = value as? [Double], value.count == 2 {
       return CGPoint(x: value[0], y: value[1])
     }
@@ -60,7 +60,7 @@ extension CGPoint: Convertible {
 }
 
 extension CGSize: Convertible {
-  public static func convert(from value: Any?) throws -> CGSize {
+  public static func convert(from value: Any?, appContext: AppContext) throws -> CGSize {
     if let value = value as? [Double], value.count == 2 {
       return CGSize(width: value[0], height: value[1])
     }
@@ -73,7 +73,7 @@ extension CGSize: Convertible {
 }
 
 extension CGVector: Convertible {
-  public static func convert(from value: Any?) throws -> CGVector {
+  public static func convert(from value: Any?, appContext: AppContext) throws -> CGVector {
     if let value = value as? [Double], value.count == 2 {
       return CGVector(dx: value[0], dy: value[1])
     }
@@ -86,7 +86,7 @@ extension CGVector: Convertible {
 }
 
 extension CGRect: Convertible {
-  public static func convert(from value: Any?) throws -> CGRect {
+  public static func convert(from value: Any?, appContext: AppContext) throws -> CGRect {
     if let value = value as? [Double], value.count == 4 {
       return CGRect(x: value[0], y: value[1], width: value[2], height: value[3])
     }

package/ios/Swift/Classes/ClassComponent.swift

@@ -37,35 +37,41 @@ public final class ClassComponent: ObjectDefinition {
 
   // MARK: - JavaScriptObjectBuilder
 
-  public override func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    let klass = runtime.createClass(name) { [weak self, weak runtime] this, arguments in
-      guard let self = self, let runtime = runtime else {
+  public override func build(appContext: AppContext) throws -> JavaScriptObject {
+    let klass = try appContext.runtime.createClass(name) { [weak self, weak appContext] this, arguments in
+      guard let self = self, let appContext else {
         // TODO: Throw an exception? (@tsapeta)
         return
       }
-      // The properties can't go into the prototype as they would be shared across all instances.
-      // Instead, we decorate the instance object on initialization.
-      self.decorateWithProperties(runtime: runtime, object: this)
 
       // Call the native constructor when defined.
-      let result = try? self.constructor?.call(by: this, withArguments: arguments)
+      let result = try? self.constructor?.call(by: this, withArguments: arguments, appContext: appContext)
 
       // Register the shared object if returned by the constructor.
       if let result = result as? SharedObject {
         SharedObjectRegistry.add(native: result, javaScript: this)
       }
     }
-    decorate(object: klass, inRuntime: runtime)
+
+    try decorate(object: klass, appContext: appContext)
+
+    // Register the JS class and its associated native type.
+    if let sharedObjectType = associatedType as? DynamicSharedObjectType {
+      appContext.classRegistry.register(nativeClassId: sharedObjectType.typeIdentifier, javaScriptClass: klass)
+    }
+
     return klass
   }
 
-  public override func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime) {
+  public override func decorate(object: JavaScriptObject, appContext: AppContext) throws {
     // Here we actually don't decorate the input object (constructor) but its prototype.
     // Properties are intentionally skipped here — they have to decorate an instance instead of the prototype.
     let prototype = object.getProperty("prototype").getObject()
-    decorateWithConstants(runtime: runtime, object: prototype)
-    decorateWithFunctions(runtime: runtime, object: prototype)
-    decorateWithClasses(runtime: runtime, object: prototype)
+
+    decorateWithConstants(object: prototype)
+    try decorateWithFunctions(object: prototype, appContext: appContext)
+    try decorateWithClasses(object: prototype, appContext: appContext)
+    try decorateWithProperties(object: prototype, appContext: appContext)
   }
 }
 

package/ios/Swift/Classes/ClassRegistry.swift

@@ -0,0 +1,31 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+internal final class ClassRegistry {
+  var nativeToJS = [ObjectIdentifier: JavaScriptWeakObject]()
+
+  // MARK: - Accessing
+
+  func getJavaScriptClass(nativeClassId: ObjectIdentifier) -> JavaScriptObject? {
+    return nativeToJS[nativeClassId]?.lock()
+  }
+
+  func getJavaScriptClass(nativeClass: SharedObject.Type) -> JavaScriptObject? {
+    let nativeClassId = ObjectIdentifier(nativeClass)
+    return getJavaScriptClass(nativeClassId: nativeClassId)
+  }
+
+  // MARK: - Registration
+
+  func register(nativeClassId: ObjectIdentifier, javaScriptClass: JavaScriptObject) {
+    nativeToJS[nativeClassId] = javaScriptClass.createWeak()
+  }
+
+  func register(nativeClass: SharedObject.Type, javaScriptClass: JavaScriptObject) {
+    let nativeClassId = ObjectIdentifier(nativeClass)
+    register(nativeClassId: nativeClassId, javaScriptClass: javaScriptClass)
+  }
+
+  internal func clear() {
+    nativeToJS.removeAll()
+  }
+}

package/ios/Swift/Conversions.swift

@@ -151,15 +151,31 @@ internal final class Conversions {
   /**
    Converts the function result to the type compatible with JavaScript.
    */
-  static func convertFunctionResult<ValueType>(_ value: ValueType?, runtime: JavaScriptRuntime? = nil) -> Any {
+  static func convertFunctionResult<ValueType>(
+    _ value: ValueType?,
+    appContext: AppContext? = nil,
+    dynamicType: AnyDynamicType? = nil
+  ) -> Any {
     if let value = value as? Record {
       return value.toDictionary()
     }
     if let value = value as? [Record] {
       return value.map { $0.toDictionary() }
     }
-    if let runtime = runtime, let value = value as? JavaScriptObjectBuilder {
-      return value.build(inRuntime: runtime)
+    if let appContext {
+      if let value = value as? JavaScriptObjectBuilder {
+        return try? value.build(appContext: appContext)
+      }
+
+      // If the returned value is a native shared object, create its JS representation and add the pair to the registry of shared objects.
+      if let value = value as? SharedObject, let dynamicType = dynamicType as? DynamicSharedObjectType {
+        guard let object = try? appContext.newObject(nativeClassId: dynamicType.typeIdentifier) else {
+          log.warn("Unable to create a JS object for \(dynamicType.description)")
+          return Optional<Any>.none
+        }
+        SharedObjectRegistry.add(native: value, javaScript: object)
+        return object
+      }
     }
     return value as Any
   }

package/ios/Swift/Convertibles/Convertibles+Color.swift

@@ -1,7 +1,7 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
 extension UIColor: Convertible {
-  public static func convert(from value: Any?) throws -> Self {
+  public static func convert(from value: Any?, appContext: AppContext) throws -> Self {
     // swiftlint:disable force_cast
     if let value = value as? String {
       if let namedColorComponents = namedColors[value] {
@@ -21,10 +21,10 @@ extension UIColor: Convertible {
 }
 
 extension CGColor: Convertible {
-  public static func convert(from value: Any?) throws -> Self {
+  public static func convert(from value: Any?, appContext: AppContext) throws -> Self {
     // swiftlint:disable force_cast
     do {
-      return try UIColor.convert(from: value).cgColor as! Self
+      return try UIColor.convert(from: value, appContext: appContext).cgColor as! Self
     } catch _ as Conversions.ConvertingException<UIColor> {
       // Rethrow `ConvertingError` with proper type
       throw Conversions.ConvertingException<CGColor>(value)

package/ios/Swift/Convertibles/Either.swift

@@ -50,14 +50,16 @@ open class Either<FirstType, SecondType>: Convertible {
 
   // MARK: - Convertible
 
-  public class func convert(from value: Any?) throws -> Self {
-    for type in dynamicTypes() {
+  public class func convert(from value: Any?, appContext: AppContext) throws -> Self {
+    let dynamicTypes = dynamicTypes()
+
+    for type in dynamicTypes {
       // Initialize the "either" when the current type can cast given value.
-      if let value = try? type.cast(value) {
+      if let value = try? type.cast(value, appContext: appContext) {
         return Self(value)
       }
     }
-    throw NeitherTypeException(Self.dynamicTypes())
+    throw NeitherTypeException(dynamicTypes)
   }
 }
 

package/ios/Swift/DynamicTypes/AnyDynamicType.swift

@@ -17,10 +17,26 @@ public protocol AnyDynamicType: CustomStringConvertible {
   func equals(_ type: AnyDynamicType) -> Bool
 
   /**
-   Casts given any value to the wrapped type and returns as `Any`.
+   Preliminarily casts the given JavaScriptValue to a non-JS value that the other `cast` function can handle.
+   It **must** be run on the thread used by the JavaScript runtime.
+   */
+  func cast(jsValue: JavaScriptValue, appContext: AppContext) throws -> Any
+
+  /**
+   Casts the given value to the wrapped type and returns it as `Any`.
    NOTE: It may not be just simple type-casting (e.g. when the wrapped type conforms to `Convertible`).
    */
-  func cast<ValueType>(_ value: ValueType) throws -> Any
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any
+}
+
+extension AnyDynamicType {
+  func cast(jsValue: JavaScriptValue, appContext: AppContext) throws -> Any {
+    return jsValue.getRaw()
+  }
+
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
+    return value
+  }
 }
 
 // MARK: - Operators

package/ios/Swift/DynamicTypes/DynamicArrayType.swift

@@ -21,13 +21,13 @@ internal struct DynamicArrayType: AnyDynamicType {
     return false
   }
 
-  func cast<ValueType>(_ value: ValueType) throws -> Any {
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
     if let value = value as? [Any] {
-      return try value.map { try elementType.cast($0) }
+      return try value.map { try elementType.cast($0, appContext: appContext) }
     }
     // We should probably throw an error if we get here. On the other side, the array type
     // requirement can be more loosen so we can try to arrayize values that are not arrays.
-    return [try elementType.cast(value)]
+    return [try elementType.cast(value, appContext: appContext)]
   }
 
   var description: String {

package/ios/Swift/DynamicTypes/DynamicConvertibleType.swift

@@ -17,8 +17,8 @@ internal struct DynamicConvertibleType: AnyDynamicType {
     return false
   }
 
-  func cast<ValueType>(_ value: ValueType) throws -> Any {
-    return try innerType.convert(from: value)
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
+    return try innerType.convert(from: value, appContext: appContext)
   }
 
   var description: String {

package/ios/Swift/DynamicTypes/DynamicEnumType.swift

@@ -17,7 +17,7 @@ internal struct DynamicEnumType: AnyDynamicType {
     return false
   }
 
-  func cast<ValueType>(_ value: ValueType) throws -> Any {
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
     return try innerType.create(fromRawValue: value)
   }
 

package/ios/Swift/DynamicTypes/DynamicJavaScriptType.swift

@@ -0,0 +1,27 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type representing various types of JavaScript values.
+ */
+internal struct DynamicJavaScriptType: AnyDynamicType {
+  let innerType: AnyJavaScriptValue.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let providedType = type as? Self {
+      return providedType.innerType == innerType
+    }
+    return false
+  }
+
+  func cast(jsValue: JavaScriptValue, appContext: AppContext) throws -> Any {
+    return try innerType.convert(from: jsValue, appContext: appContext)
+  }
+
+  var description: String {
+    return String(describing: innerType.self)
+  }
+}

package/ios/Swift/DynamicTypes/DynamicOptionalType.swift

@@ -21,11 +21,18 @@ internal struct DynamicOptionalType: AnyDynamicType {
     return false
   }
 
-  func cast<ValueType>(_ value: ValueType) throws -> Any {
+  func cast(jsValue: JavaScriptValue, appContext: AppContext) throws -> Any {
+    if jsValue.isUndefined() || jsValue.isNull() {
+      return Optional<Any>.none as Any
+    }
+    return try wrappedType.cast(jsValue: jsValue, appContext: appContext)
+  }
+
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
     if Optional.isNil(value) || value is NSNull {
       return Optional<Any>.none as Any
     }
-    return try wrappedType.cast(value)
+    return try wrappedType.cast(value, appContext: appContext)
   }
 
   var description: String {

package/ios/Swift/DynamicTypes/DynamicRawType.swift

@@ -15,7 +15,7 @@ internal struct DynamicRawType<InnerType>: AnyDynamicType {
     return type is Self
   }
 
-  func cast<ValueType>(_ value: ValueType) throws -> Any {
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
     if let value = value as? InnerType {
       return value
     }

package/ios/Swift/DynamicTypes/DynamicSharedObjectType.swift

@@ -6,6 +6,16 @@
 internal struct DynamicSharedObjectType: AnyDynamicType {
   let innerType: SharedObject.Type
 
+  /**
+   A unique identifier of the wrapped type.
+   */
+  let typeIdentifier: ObjectIdentifier
+
+  init<SharedObjectType: SharedObject>(innerType: SharedObjectType.Type) {
+    self.innerType = innerType
+    self.typeIdentifier = ObjectIdentifier(SharedObjectType.self)
+  }
+
   func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
     return innerType == InnerType.self
   }
@@ -17,12 +27,16 @@ internal struct DynamicSharedObjectType: AnyDynamicType {
     return false
   }
 
-  func cast<ValueType>(_ value: ValueType) throws -> Any {
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
     if let value = value as? SharedObject, type(of: value) == innerType {
       // Given value is a shared object already
       return value
     }
-    if let jsObject = try (value as? JavaScriptValue)?.asObject(),
+    throw NativeSharedObjectNotFoundException()
+  }
+
+  func cast(jsValue: JavaScriptValue, appContext: AppContext) throws -> Any {
+    if let jsObject = try? jsValue.asObject(),
        let nativeSharedObject = SharedObjectRegistry.toNativeObject(jsObject) {
       return nativeSharedObject
     }

package/ios/Swift/DynamicTypes/DynamicType.swift

@@ -21,12 +21,18 @@ internal func DynamicType<T>(_ type: T.Type) -> AnyDynamicType {
   if let EnumType = T.self as? any Enumerable.Type {
     return DynamicEnumType(innerType: EnumType)
   }
+  if let ViewType = T.self as? UIView.Type {
+    return DynamicViewType(innerType: ViewType)
+  }
   if let SharedObjectType = T.self as? SharedObject.Type {
     return DynamicSharedObjectType(innerType: SharedObjectType)
   }
   if let TypedArrayType = T.self as? AnyTypedArray.Type {
     return DynamicTypedArrayType(innerType: TypedArrayType)
   }
+  if let JavaScriptValueType = T.self as? any AnyJavaScriptValue.Type {
+    return DynamicJavaScriptType(innerType: JavaScriptValueType)
+  }
   return DynamicRawType(innerType: T.self)
 }
 

package/ios/Swift/DynamicTypes/DynamicTypedArrayType.swift

@@ -14,13 +14,24 @@ internal struct DynamicTypedArrayType: AnyDynamicType {
     return false
   }
 
-  func cast<ValueType>(_ value: ValueType) throws -> Any {
-    // It must be a JavaScript typed array.
-    guard let value = value as? JavaScriptValue, let jsTypedArray = value.getTypedArray() else {
+  /**
+   Converts JS typed array to its native representation.
+   */
+  func cast(jsValue: JavaScriptValue, appContext: AppContext) throws -> Any {
+    guard let jsTypedArray = jsValue.getTypedArray() else {
       throw NotTypedArrayException(innerType)
     }
-    let typedArray = TypedArray.create(from: jsTypedArray)
+    return TypedArray.create(from: jsTypedArray)
+  }
 
+  /**
+   Converts the given native `TypedArray` to a concrete typed array class wrapped by the dynamic type.
+   Throws `ArrayTypeMismatchException` otherwise.
+   */
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
+    guard let typedArray = value as? TypedArray else {
+      throw NotTypedArrayException(innerType)
+    }
     // Concrete typed arrays must be the same as the inner type.
     guard innerType == TypedArray.self || type(of: typedArray) == innerType else {
       throw ArrayTypeMismatchException((received: type(of: typedArray), expected: innerType))

package/ios/Swift/DynamicTypes/DynamicViewType.swift

@@ -0,0 +1,68 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+internal struct DynamicViewType: AnyDynamicType {
+  let innerType: UIView.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let viewType = type as? Self {
+      return viewType.innerType == innerType
+    }
+    return false
+  }
+
+  /**
+   Casts from the React component instance to the view tag (`Int`).
+   */
+  func cast(jsValue: JavaScriptValue, appContext: AppContext) throws -> Any {
+    guard let viewTag = findViewTag(jsValue) else {
+      throw InvalidViewTagException()
+    }
+    return viewTag
+  }
+
+  /**
+   Converts a value of type `Int` to a native view with that tag in the given app context.
+   */
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
+    guard let viewTag = value as? Int else {
+      throw InvalidViewTagException()
+    }
+    guard Thread.isMainThread else {
+      throw NonMainThreadException()
+    }
+    guard let view = appContext.findView(withTag: viewTag, ofType: innerType.self) else {
+      throw Exceptions.ViewNotFound((tag: viewTag, type: innerType.self))
+    }
+    return view
+  }
+
+  var description: String {
+    return "View<\(innerType)>"
+  }
+}
+
+private func findViewTag(_ value: JavaScriptValue) -> Int? {
+  if let viewTag = value as? Int {
+    return viewTag
+  }
+  if let value = value as? JavaScriptValue, value.isObject() {
+    return value.getObject().getProperty("nativeTag").getInt()
+  }
+  return nil
+}
+
+internal final class InvalidViewTagException: Exception {
+  override var reason: String {
+    "The view tag must be a number"
+  }
+}
+
+internal final class NonMainThreadException: Exception {
+  override var reason: String {
+    "All operations on the views must run from the main UI thread"
+  }
+}

package/ios/Swift/ExpoBridgeModule.swift

@@ -46,7 +46,7 @@ public final class ExpoBridgeModule: NSObject, RCTBridgeModule {
         guard let self = self, let bridge = self.appContext.reactBridge else {
           return
         }
-        self.appContext.runtime = EXJavaScriptRuntimeManager.runtime(fromBridge: bridge)
+        self.appContext._runtime = EXJavaScriptRuntimeManager.runtime(fromBridge: bridge)
       }
 
       if bridge.responds(to: Selector(("runtime"))) {

package/ios/Swift/Functions/AnyFunction.swift

@@ -41,9 +41,10 @@ internal protocol AnyFunction: AnyDefinition, JavaScriptObjectBuilder {
       - args: An array of arguments to pass to the function. They could be Swift primitives
       when invoked through the bridge and in unit tests or `JavaScriptValue`s
       when the function is called through the JSI.
+      - appContext: An app context where the function is being executed.
       - callback: A callback that receives a result of the function execution.
    */
-  func call(by owner: AnyObject?, withArguments args: [Any], callback: @escaping (FunctionCallResult) -> ())
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext, callback: @escaping (FunctionCallResult) -> ())
 }
 
 extension AnyFunction {
@@ -65,12 +66,12 @@ extension AnyFunction {
   }
 
   /**
-   Calls the function just like `call(by:withArguments:callback:)`, but without an owner
+   Calls the function just like `call(by:withArguments:appContext:callback:)`, but without an owner
    and with an empty callback. Might be useful when you only want to call the function,
    but don't care about the result.
    */
-  func call(withArguments args: [Any]) {
-    call(by: nil, withArguments: args, callback: { _ in })
+  func call(withArguments args: [Any], appContext: AppContext) {
+    call(by: nil, withArguments: args, appContext: appContext, callback: { _ in })
   }
 }
 

package/ios/Swift/Functions/AsyncFunctionComponent.swift

@@ -46,10 +46,8 @@ public final class AsyncFunctionComponent<Args, FirstArgType, ReturnType>: AnyAs
   ) {
     self.name = name
     self.takesPromise = dynamicArgumentTypes.last?.wraps(Promise.self) ?? false
+    self.dynamicArgumentTypes = dynamicArgumentTypes
     self.body = body
-
-    // Drop the last argument type if it's the `Promise`.
-    self.dynamicArgumentTypes = takesPromise ? dynamicArgumentTypes.dropLast(1) : dynamicArgumentTypes
   }
 
   // MARK: - AnyFunction
@@ -59,25 +57,30 @@ public final class AsyncFunctionComponent<Args, FirstArgType, ReturnType>: AnyAs
   let dynamicArgumentTypes: [AnyDynamicType]
 
   var argumentsCount: Int {
-    return dynamicArgumentTypes.count - (takesOwner ? 1 : 0)
+    return dynamicArgumentTypes.count - (takesOwner ? 1 : 0) - (takesPromise ? 1 : 0)
   }
 
   var takesOwner: Bool = false
 
-  func call(by owner: AnyObject?, withArguments args: [Any], callback: @escaping (FunctionCallResult) -> ()) {
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext, callback: @escaping (FunctionCallResult) -> ()) {
     let promise = Promise { value in
       callback(.success(Conversions.convertFunctionResult(value)))
     } rejecter: { exception in
       callback(.failure(exception))
     }
-    var arguments: [Any] = []
+    var arguments: [Any] = concat(
+      arguments: args,
+      withOwner: owner,
+      withPromise: takesPromise ? promise : nil,
+      forFunction: self,
+      appContext: appContext
+    )
 
     do {
-      arguments = concat(
-        arguments: try cast(arguments: args, forFunction: self),
-        withOwner: owner,
-        forFunction: self
-      )
+      try validateArgumentsNumber(function: self, received: args.count)
+
+      // All `JavaScriptValue` args must be preliminarly converted on the JS thread, so before we jump to the function's queue.
+      arguments = try cast(jsValues: arguments, forFunction: self, appContext: appContext)
     } catch let error as Exception {
       callback(.failure(error))
       return
@@ -86,18 +89,18 @@ public final class AsyncFunctionComponent<Args, FirstArgType, ReturnType>: AnyAs
       return
     }
 
-    // Add promise to the array of arguments if necessary.
-    if takesPromise {
-      arguments.append(promise)
-    }
-
     let queue = queue ?? defaultQueue
 
     queue.async { [body, name] in
       let returnedValue: ReturnType?
 
       do {
+        // Convert arguments to the types desired by the function.
+        arguments = try cast(arguments: arguments, forFunction: self, appContext: appContext)
+
+        // swiftlint:disable:next force_cast
         let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+
         returnedValue = try body(argumentsTuple)
       } catch let error as Exception {
         promise.reject(FunctionCallException(name).causedBy(error))
@@ -114,13 +117,13 @@ public final class AsyncFunctionComponent<Args, FirstArgType, ReturnType>: AnyAs
 
   // MARK: - JavaScriptObjectBuilder
 
-  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    return runtime.createAsyncFunction(name, argsCount: argumentsCount) { [weak self, name] this, args, resolve, reject in
+  func build(appContext: AppContext) throws -> JavaScriptObject {
+    return try appContext.runtime.createAsyncFunction(name, argsCount: argumentsCount) { [weak self, name] this, args, resolve, reject in
       guard let self = self else {
         let exception = NativeFunctionUnavailableException(name)
         return reject(exception.code, exception.description, nil)
       }
-      self.call(by: this, withArguments: args) { result in
+      self.call(by: this, withArguments: args, appContext: appContext) { result in
         switch result {
         case .failure(let error):
           reject(error.code, error.description, nil)