expo-modules-core 1.2.7 → 1.3.0

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)

package/ios/Swift/Functions/ConcurrentFunctionDefinition.swift

@@ -28,15 +28,22 @@ public final class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>:
 
   var takesOwner: Bool = false
 
-  func call(by owner: AnyObject?, withArguments args: [Any], callback: @escaping (FunctionCallResult) -> Void) {
-    let arguments: [Any]
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext, callback: @escaping (FunctionCallResult) -> Void) {
+    var arguments: [Any]
 
     do {
+      try validateArgumentsNumber(function: self, received: args.count)
+
       arguments = concat(
-        arguments: try cast(arguments: args, forFunction: self),
+        arguments: args,
         withOwner: owner,
-        forFunction: self
+        withPromise: nil,
+        forFunction: self,
+        appContext: appContext
       )
+
+      // All `JavaScriptValue` args must be preliminarly converted on the JS thread, before we jump to the function's queue.
+      arguments = try cast(jsValues: args, forFunction: self, appContext: appContext)
     } catch let error as Exception {
       callback(.failure(error))
       return
@@ -50,9 +57,12 @@ public final class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>:
       let result: Result<Any, Exception>
 
       do {
+        // Convert arguments to the types desired by the function.
+        let finalArguments = try cast(arguments: arguments, forFunction: self, appContext: appContext)
+
         // TODO: Right now we force cast the tuple in all types of functions, but we should throw another exception here.
         // swiftlint:disable force_cast
-        let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+        let argumentsTuple = try Conversions.toTuple(finalArguments) as! Args
         let returnValue = try await body(argumentsTuple)
 
         result = .success(returnValue)
@@ -68,18 +78,24 @@ public final class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>:
 
   // MARK: - JavaScriptObjectBuilder
 
-  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    return runtime.createAsyncFunction(name, argsCount: argumentsCount) { [weak self, name] this, args, resolve, reject in
-      guard let self = self else {
+  func build(appContext: AppContext) throws -> JavaScriptObject {
+    return try appContext.runtime.createAsyncFunction(name, argsCount: argumentsCount) {
+      [weak appContext, weak self, name] this, args, resolve, reject in
+
+      guard let appContext else {
+        let exception = Exceptions.AppContextLost()
+        return reject(exception.code, exception.description, nil)
+      }
+      guard let 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)
-        case .success(let value):
-          resolve(value)
+          case .failure(let error):
+            reject(error.code, error.description, nil)
+          case .success(let value):
+            resolve(value)
         }
       }
     }

package/ios/Swift/Functions/SyncFunctionComponent.swift

@@ -10,9 +10,10 @@ internal protocol AnySyncFunctionComponent: AnyFunction {
      - owner: An object that calls this function. If the `takesOwner` property is true
        and type of the first argument matches the owner type, it's being passed as the argument.
      - args: An array of arguments to pass to the function. The arguments must be of the same type as in the underlying closure.
+     - appContext: An app context where the function is executed.
    - Returns: A value returned by the called function when succeeded or an error when it failed.
    */
-  func call(by owner: AnyObject?, withArguments args: [Any]) throws -> Any
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext) throws -> Any
 }
 
 /**
@@ -49,9 +50,9 @@ public final class SyncFunctionComponent<Args, FirstArgType, ReturnType>: AnySyn
 
   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) -> ()) {
     do {
-      let result = try call(by: owner, withArguments: args)
+      let result = try call(by: owner, withArguments: args, appContext: appContext)
       callback(.success(Conversions.convertFunctionResult(result)))
     } catch let error as Exception {
       callback(.failure(error))
@@ -62,16 +63,26 @@ public final class SyncFunctionComponent<Args, FirstArgType, ReturnType>: AnySyn
 
   // MARK: - AnySyncFunctionComponent
 
-  func call(by owner: AnyObject?, withArguments args: [Any]) throws -> Any {
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext) throws -> Any {
     do {
-      let arguments = concat(
-        arguments: try cast(arguments: args, forFunction: self),
+      try validateArgumentsNumber(function: self, received: args.count)
+
+      var arguments = concat(
+        arguments: args,
         withOwner: owner,
-        forFunction: self
+        withPromise: nil,
+        forFunction: self,
+        appContext: appContext
       )
+
+      // Convert JS values to non-JS native types.
+      arguments = try cast(jsValues: arguments, forFunction: self, appContext: appContext)
+
+      // Convert arguments to the types desired by the function.
+      arguments = try cast(arguments: arguments, forFunction: self, appContext: appContext)
+
       let argumentsTuple = try Conversions.toTuple(arguments) as! Args
-      let result = try body(argumentsTuple)
-      return Conversions.convertFunctionResult(result)
+      return try body(argumentsTuple)
     } catch let error as Exception {
       throw FunctionCallException(name).causedBy(error)
     } catch {
@@ -81,17 +92,17 @@ public final class SyncFunctionComponent<Args, FirstArgType, ReturnType>: AnySyn
 
   // MARK: - JavaScriptObjectBuilder
 
-  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+  func build(appContext: AppContext) throws -> JavaScriptObject {
     // We intentionally capture a strong reference to `self`, otherwise the "detached" objects would
     // immediately lose the reference to the definition and thus the underlying native function.
     // It may potentially cause memory leaks, but at the time of writing this comment,
     // the native definition instance deallocates correctly when the JS VM triggers the garbage collector.
-    return runtime.createSyncFunction(name, argsCount: argumentsCount) { [weak runtime, self] this, args in
-      guard let runtime = runtime else {
-        throw Exceptions.RuntimeLost()
+    return try appContext.runtime.createSyncFunction(name, argsCount: argumentsCount) { [weak appContext, self] this, args in
+      guard let appContext else {
+        throw Exceptions.AppContextLost()
       }
-      let result = try self.call(by: this, withArguments: args)
-      return Conversions.convertFunctionResult(result, runtime: runtime)
+      let result = try self.call(by: this, withArguments: args, appContext: appContext)
+      return Conversions.convertFunctionResult(result, appContext: appContext, dynamicType: ~ReturnType.self)
     }
   }
 }