expo-modules-core 1.2.7 → 1.3.0

package/ios/Swift/JavaScriptFunction.swift

@@ -0,0 +1,68 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+/**
+ Represents a JavaScript function that can be called by the native code and that must return the given generic `ReturnType`.
+ */
+public final class JavaScriptFunction<ReturnType>: AnyArgument, AnyJavaScriptValue {
+  /**
+   Raw representation of the JavaScript function that doesn't impose any restrictions on the returned type.
+   */
+  private let rawFunction: RawJavaScriptFunction
+
+  /**
+   Weak reference to the app context that is necessary to convert some arguments associated with the context (e.g. shared objects).
+   */
+  private weak var appContext: AppContext?
+
+  init(rawFunction: RawJavaScriptFunction, appContext: AppContext) {
+    self.rawFunction = rawFunction
+    self.appContext = appContext
+  }
+
+  // MARK: - Calling
+
+  /**
+   Calls the function with the given `this` object and arguments.
+   */
+  public func call(_ arguments: Any..., usingThis this: JavaScriptObject? = nil) throws -> ReturnType {
+    return try call(withArguments: arguments, asConstructor: false, usingThis: this)
+  }
+
+  /**
+   Calls the function as a constructor with the given arguments. It's like calling a function with the `new` keyword.
+   */
+  public func callAsConstructor(_ arguments: Any...) throws -> ReturnType {
+    return try call(withArguments: arguments, asConstructor: true, usingThis: nil)
+  }
+
+  /**
+   Universal function that calls the function with given arguments, this object and whether to call it as a constructor.
+   */
+  private func call(withArguments arguments: [Any] = [], asConstructor: Bool = false, usingThis this: JavaScriptObject? = nil) throws -> ReturnType {
+    guard let appContext else {
+      throw AppContextLostException()
+    }
+    let value = rawFunction.call(withArguments: arguments, thisObject: this, asConstructor: false)
+    let dynamicType = ~ReturnType.self
+
+    guard let result = try dynamicType.cast(jsValue: value, appContext: appContext) as? ReturnType else {
+      throw UnexpectedReturnType(dynamicType.description)
+    }
+    return result
+  }
+
+  // MARK: - AnyJavaScriptValue
+
+  internal static func convert(from value: JavaScriptValue, appContext: AppContext) throws -> Self {
+    guard value.kind == .function else {
+      throw Conversions.ConvertingException<JavaScriptFunction<ReturnType>>(value)
+    }
+    return Self(rawFunction: value.getFunction(), appContext: appContext)
+  }
+}
+
+private final class UnexpectedReturnType: GenericException<String> {
+  override var reason: String {
+    return "The function returned a value that cannot be converted to \(param)"
+  }
+}

package/ios/Swift/JavaScriptUtils.swift

@@ -10,12 +10,12 @@
  - Returns: A new value converted according to the dynamic type.
  - Throws: Rethrows various exceptions that could be thrown by the dynamic types.
  */
-internal func cast(_ value: Any, toType type: AnyDynamicType) throws -> Any {
+internal func cast(_ value: Any, toType type: AnyDynamicType, appContext: AppContext) throws -> Any {
   // TODO: Accept JavaScriptValue and JavaScriptObject as argument types.
   if !(type is DynamicTypedArrayType), let value = value as? JavaScriptValue {
-    return try type.cast(value.getRaw())
+    return try type.cast(value.getRaw(), appContext: appContext)
   }
-  return try type.cast(value)
+  return try type.cast(value, appContext: appContext)
 }
 
 /**
@@ -23,46 +23,85 @@ internal func cast(_ value: Any, toType type: AnyDynamicType) throws -> Any {
  - Parameters:
    - arguments: An array of arguments to be cast.
    - function: A function for which to cast the arguments.
+   - appContext: A context of the app.
  - Returns: An array of arguments after casting. Its size is the same as the input arrays.
  - Throws: `InvalidArgsNumberException` when the number of arguments is not equal to the actual number
  of function's arguments (without an owner and promise). Rethrows exceptions thrown by `cast(_:toType:)`.
  */
-internal func cast(arguments: [Any], forFunction function: AnyFunction) throws -> [Any] {
-  let requiredArgumentsCount = function.requiredArgumentsCount
-  let argumentTypeOffset = function.takesOwner ? 1 : 0
-
-  if arguments.count < requiredArgumentsCount || arguments.count > function.argumentsCount {
-    throw InvalidArgsNumberException((
-      received: arguments.count,
-      expected: function.argumentsCount,
-      required: requiredArgumentsCount
-    ))
-  }
+internal func cast(arguments: [Any], forFunction function: AnyFunction, appContext: AppContext) throws -> [Any] {
   return try arguments.enumerated().map { index, argument in
-    let argumentType = function.dynamicArgumentTypes[index + argumentTypeOffset]
+    let argumentType = function.dynamicArgumentTypes[index]
 
     do {
-      return try cast(argument, toType: argumentType)
+      return try cast(argument, toType: argumentType, appContext: appContext)
     } catch {
       throw ArgumentCastException((index: index, type: argumentType)).causedBy(error)
     }
   }
 }
 
+/**
+ Casts an array of JavaScript values to non-JavaScript types.
+ */
+internal func cast(jsValues: [Any], forFunction function: AnyFunction, appContext: AppContext) throws -> [Any] {
+  // TODO: Replace `[Any]` with `[JavaScriptValue]` once we make sure only JS values are passed here
+  return try jsValues.enumerated().map { index, jsValue in
+    let type = function.dynamicArgumentTypes[index]
+
+    do {
+      // Temporarily some values might already be cast to primitive types, so make sure we cast only `JavaScriptValue` and leave the others as they are.
+      if let jsValue = jsValue as? JavaScriptValue {
+        return try type.cast(jsValue: jsValue, appContext: appContext)
+      } else {
+        return jsValue
+      }
+    } catch {
+      throw ArgumentCastException((index: index, type: type)).causedBy(error)
+    }
+  }
+}
+
+/**
+ Validates whether the number of received arguments is enough to call the given function.
+ Throws `InvalidArgsNumberException` otherwise.
+ */
+internal func validateArgumentsNumber(function: AnyFunction, received: Int) throws {
+  let argumentsCount = function.argumentsCount
+  let requiredArgumentsCount = function.requiredArgumentsCount
+
+  if received < requiredArgumentsCount || received > argumentsCount {
+    throw InvalidArgsNumberException((
+      received: received,
+      expected: argumentsCount,
+      required: requiredArgumentsCount
+    ))
+  }
+}
+
 /**
  Ensures the provided array of arguments matches the number of arguments expected by the function.
  - If the function takes the owner, it's added to the beginning.
  - If the array is still too small, missing arguments are very likely to be optional so it puts `nil` in their place.
  */
-internal func concat(arguments: [Any], withOwner owner: AnyObject?, forFunction function: AnyFunction) -> [Any] {
+internal func concat(
+  arguments: [Any],
+  withOwner owner: AnyObject?,
+  withPromise promise: Promise?,
+  forFunction function: AnyFunction,
+  appContext: AppContext
+) -> [Any] {
   var result = arguments
 
-  if function.takesOwner, let owner = try? function.dynamicArgumentTypes.first?.cast(owner) {
+  if function.takesOwner {
     result = [owner] + arguments
   }
   if arguments.count < function.argumentsCount {
     result += Array(repeating: Any?.none as Any, count: function.argumentsCount - arguments.count)
   }
+  // Add promise to the array of arguments if necessary.
+  if let promise {
+    result += [promise]
+  }
   return result
 }
 

package/ios/Swift/ModuleHolder.swift

@@ -62,24 +62,28 @@ public final class ModuleHolder {
   // MARK: Calling functions
 
   func call(function functionName: String, args: [Any], _ callback: @escaping (FunctionCallResult) -> () = { _ in }) {
+    guard let appContext else {
+      callback(.failure(Exceptions.AppContextLost()))
+      return
+    }
     guard let function = definition.functions[functionName] else {
       callback(.failure(FunctionNotFoundException((functionName: functionName, moduleName: self.name))))
       return
     }
-    function.call(by: self, withArguments: args, callback: callback)
+    function.call(by: self, withArguments: args, appContext: appContext, callback: callback)
   }
 
   @discardableResult
   func callSync(function functionName: String, args: [Any]) -> Any? {
-    guard let function = definition.functions[functionName] as? AnySyncFunctionComponent else {
+    guard let appContext, let function = definition.functions[functionName] as? AnySyncFunctionComponent else {
       return nil
     }
     do {
-      let arguments = try cast(arguments: args, forFunction: function)
-      let result = try function.call(by: self, withArguments: arguments)
+      let arguments = try cast(arguments: args, forFunction: function, appContext: appContext)
+      let result = try function.call(by: self, withArguments: arguments, appContext: appContext)
 
       if let result = result as? SharedObject {
-        let jsObject = SharedObjectRegistry.ensureSharedJavaScriptObject(runtime: appContext!.runtime!, nativeObject: result)
+        let jsObject = SharedObjectRegistry.ensureSharedJavaScriptObject(runtime: try appContext.runtime, nativeObject: result)
         return jsObject
       }
       return result
@@ -98,11 +102,16 @@ public final class ModuleHolder {
    */
   private func createJavaScriptModuleObject() -> JavaScriptObject? {
     // It might be impossible to create any object at the moment (e.g. remote debugging, app context destroyed)
-    guard let runtime = appContext?.runtime else {
+    guard let appContext else {
+      return nil
+    }
+    do {
+      log.info("Creating JS object for module '\(name)'")
+      return try definition.build(appContext: appContext)
+    } catch {
+      log.error("Building the module object failed: \(error)")
       return nil
     }
-    log.info("Creating JS object for module '\(name)'")
-    return definition.build(inRuntime: runtime)
   }
 
   // MARK: Listening to native events
@@ -131,10 +140,13 @@ public final class ModuleHolder {
    Modifies module's listeners count and calls `onStartObserving` or `onStopObserving` accordingly.
    */
   func modifyListenersCount(_ count: Int) {
+    guard let appContext else {
+      return
+    }
     if count > 0 && listenersCount == 0 {
-      definition.functions["startObserving"]?.call(withArguments: [])
+      definition.functions["startObserving"]?.call(withArguments: [], appContext: appContext)
     } else if count < 0 && listenersCount + count <= 0 {
-      definition.functions["stopObserving"]?.call(withArguments: [])
+      definition.functions["stopObserving"]?.call(withArguments: [], appContext: appContext)
     }
     listenersCount = max(0, listenersCount + count)
   }

package/ios/Swift/Modules/ModuleDefinition.swift

@@ -65,8 +65,14 @@ public final class ModuleDefinition: ObjectDefinition {
     return self
   }
 
-  public override func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    let object = super.build(inRuntime: runtime)
+  public override func build(appContext: AppContext) throws -> JavaScriptObject {
+    let object = try super.build(appContext: appContext)
+
+    if let viewManager {
+      let reactComponentPrototype = try appContext.runtime.createObject()
+      try viewManager.decorateWithFunctions(object: reactComponentPrototype, appContext: appContext)
+      object.setProperty("ViewPrototype", value: reactComponentPrototype)
+    }
 
     // Give the module object a name. It's used for compatibility reasons, see `EventEmitter.ts`.
     object.defineProperty("__expo_module_name__", value: name, options: [])

package/ios/Swift/Objects/JavaScriptObjectBuilder.swift

@@ -7,7 +7,7 @@ internal protocol JavaScriptObjectDecorator {
   /**
    Decorates an existing `JavaScriptObject`.
    */
-  func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime)
+  func decorate(object: JavaScriptObject, appContext: AppContext) throws
 }
 
 /**
@@ -15,23 +15,23 @@ internal protocol JavaScriptObjectDecorator {
  */
 internal protocol JavaScriptObjectBuilder: JavaScriptObjectDecorator {
   /**
-   Creates a decorated `JavaScriptObject` in the given runtime.
+   Creates a decorated `JavaScriptObject` in the given app context.
    */
-  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject
+  func build(appContext: AppContext) throws -> JavaScriptObject
 }
 
 /**
  Provides the default behavior of `JavaScriptObjectBuilder`.
- The `build(inRuntime:)` creates a plain object and uses `decorate(object:)` for decoration.
+ The `build(appContext:)` creates a plain object and uses `decorate(object:appContext:)` for decoration.
  */
 extension JavaScriptObjectBuilder {
-  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    let object = runtime.createObject()
-    decorate(object: object, inRuntime: runtime)
+  func build(appContext: AppContext) throws -> JavaScriptObject {
+    let object = try appContext.runtime.createObject()
+    try decorate(object: object, appContext: appContext)
     return object
   }
 
-  func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime) {
+  func decorate(object: JavaScriptObject, appContext: AppContext) throws {
     // no-op by default
   }
 }

package/ios/Swift/Objects/ObjectDefinition.swift

@@ -61,43 +61,45 @@ public class ObjectDefinition: AnyDefinition, JavaScriptObjectBuilder {
 
   // MARK: - JavaScriptObjectBuilder
 
-  public func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    let object = runtime.createObject()
-    decorate(object: object, inRuntime: runtime)
+  public func build(appContext: AppContext) throws -> JavaScriptObject {
+    let object = try appContext.runtime.createObject()
+    try decorate(object: object, appContext: appContext)
     return object
   }
 
-  public func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime) {
-    decorateWithConstants(runtime: runtime, object: object)
-    decorateWithFunctions(runtime: runtime, object: object)
-    decorateWithProperties(runtime: runtime, object: object)
-    decorateWithClasses(runtime: runtime, object: object)
+  public func decorate(object: JavaScriptObject, appContext: AppContext) throws {
+    let runtime = try appContext.runtime
+
+    decorateWithConstants(object: object)
+    try decorateWithFunctions(object: object, appContext: appContext)
+    try decorateWithProperties(object: object, appContext: appContext)
+    try decorateWithClasses(object: object, appContext: appContext)
   }
 
   // MARK: - Internals
 
-  internal func decorateWithConstants(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+  internal func decorateWithConstants(object: JavaScriptObject) {
     for (key, value) in getConstants() {
       object.setProperty(key, value: value)
     }
   }
 
-  internal func decorateWithFunctions(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+  internal func decorateWithFunctions(object: JavaScriptObject, appContext: AppContext) throws {
     for fn in functions.values {
-      object.setProperty(fn.name, value: fn.build(inRuntime: runtime))
+      object.setProperty(fn.name, value: try fn.build(appContext: appContext))
     }
   }
 
-  internal func decorateWithProperties(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+  internal func decorateWithProperties(object: JavaScriptObject, appContext: AppContext) throws {
     for property in properties.values {
-      let descriptor = property.buildDescriptor(inRuntime: runtime)
+      let descriptor = try property.buildDescriptor(appContext: appContext)
       object.defineProperty(property.name, descriptor: descriptor)
     }
   }
 
-  internal func decorateWithClasses(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+  internal func decorateWithClasses(object: JavaScriptObject, appContext: AppContext) throws {
     for klass in classes.values {
-      object.setProperty(klass.name, value: klass.build(inRuntime: runtime))
+      object.setProperty(klass.name, value: try klass.build(appContext: appContext))
     }
   }
 }

package/ios/Swift/Objects/PropertyComponent.swift

@@ -9,7 +9,7 @@ protocol AnyPropertyComponent {
   /**
    Creates the JavaScript object representing the property descriptor.
    */
-  func buildDescriptor(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject
+  func buildDescriptor(appContext: AppContext) throws -> JavaScriptObject
 }
 
 public final class PropertyComponent<OwnerType>: AnyDefinition, AnyPropertyComponent {
@@ -119,60 +119,66 @@ public final class PropertyComponent<OwnerType>: AnyDefinition, AnyPropertyCompo
 
   // MARK: - Internals
 
-  internal func getValue<ValueType>(owner: OwnerType? = nil) throws -> ValueType? {
+  internal func getValue<ValueType>(owner: OwnerType? = nil, appContext: AppContext) throws -> ValueType? {
     let owner = owner as? AnyObject
-    let value = try getter?.call(by: owner, withArguments: [])
+    let value = try getter?.call(by: owner, withArguments: [], appContext: appContext)
     return value as? ValueType
   }
 
-  internal func setValue(_ value: Any, owner: OwnerType? = nil) {
+  internal func setValue(_ value: Any, owner: OwnerType? = nil, appContext: AppContext) {
     let owner = owner as? AnyObject
-    _ = try? setter?.call(by: owner, withArguments: [value])
+    _ = try? setter?.call(by: owner, withArguments: [value], appContext: appContext)
   }
 
   /**
    Creates the JavaScript function that will be used as a getter of the property.
    */
-  internal func buildGetter(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    return runtime.createSyncFunction(name, argsCount: 0) { [weak self, name] this, args in
-      guard let self = self else {
+  internal func buildGetter(appContext: AppContext) throws -> JavaScriptObject {
+    return try appContext.runtime.createSyncFunction(name, argsCount: 0) { [weak appContext, weak self, name] this, args in
+      guard let appContext else {
+        throw Exceptions.AppContextLost()
+      }
+      guard let self else {
         throw NativePropertyUnavailableException(name)
       }
       guard let getter = self.getter else {
         return
       }
-      return try getter.call(by: this, withArguments: args)
+      return try getter.call(by: this, withArguments: args, appContext: appContext)
     }
   }
 
   /**
    Creates the JavaScript function that will be used as a setter of the property.
    */
-  internal func buildSetter(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    return runtime.createSyncFunction(name, argsCount: 1) { [weak self, name] this, args in
-      guard let self = self else {
+  internal func buildSetter(appContext: AppContext) throws -> JavaScriptObject {
+    return try appContext.runtime.createSyncFunction(name, argsCount: 1) { [weak appContext, weak self, name] this, args in
+      guard let appContext else {
+        throw Exceptions.AppContextLost()
+      }
+      guard let self else {
         throw NativePropertyUnavailableException(name)
       }
       guard let setter = self.setter else {
         return
       }
-      return try setter.call(by: this, withArguments: args)
+      return try setter.call(by: this, withArguments: args, appContext: appContext)
     }
   }
 
   /**
    Creates the JavaScript object representing the property descriptor.
    */
-  internal func buildDescriptor(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    let descriptor = runtime.createObject()
+  internal func buildDescriptor(appContext: AppContext) throws -> JavaScriptObject {
+    let descriptor = try appContext.runtime.createObject()
 
     descriptor.setProperty("enumerable", value: true)
 
     if getter != nil {
-      descriptor.setProperty("get", value: buildGetter(inRuntime: runtime))
+      descriptor.setProperty("get", value: try buildGetter(appContext: appContext))
     }
     if setter != nil {
-      descriptor.setProperty("set", value: buildSetter(inRuntime: runtime))
+      descriptor.setProperty("set", value: try buildSetter(appContext: appContext))
     }
     return descriptor
   }

package/ios/Swift/Records/AnyField.swift

@@ -19,5 +19,5 @@ internal protocol AnyFieldInternal: AnyField {
    */
   var isRequired: Bool { get }
 
-  func set(_ newValue: Any?) throws
+  func set(_ newValue: Any?, appContext: AppContext) throws
 }

package/ios/Swift/Records/Field.swift

@@ -74,12 +74,12 @@ public final class Field<Type>: AnyFieldInternal {
   /**
    Sets the wrapped value with a value of `Any` type.
    */
-  internal func set(_ newValue: Any?) throws {
+  internal func set(_ newValue: Any?, appContext: AppContext) throws {
     if newValue == nil && (!isOptional || isRequired) {
       throw FieldRequiredException(key!)
     }
     do {
-      if let value = try fieldType.cast(newValue) as? Type {
+      if let value = try fieldType.cast(newValue, appContext: appContext) as? Type {
         wrappedValue = value
       }
     } catch {

package/ios/Swift/Records/Record.swift

@@ -15,7 +15,7 @@ public protocol Record: Convertible {
   /**
    Initializes a record from given dictionary. Only members wrapped by `@Field` will be set in the object.
    */
-  init(from: Dict) throws
+  init(from: Dict, appContext: AppContext) throws
 
   /**
    Converts the record back to the dictionary. Only members wrapped by `@Field` will be set in the dictionary.
@@ -27,14 +27,14 @@ public protocol Record: Convertible {
  Provides the default implementation of `Record` protocol.
  */
 public extension Record {
-  static func convert(from value: Any?) throws -> Self {
+  static func convert(from value: Any?, appContext: AppContext) throws -> Self {
     if let value = value as? Dict {
-      return try Self(from: value)
+      return try Self(from: value, appContext: appContext)
     }
     throw Conversions.ConvertingException<Self>(value)
   }
 
-  init(from dict: Dict) throws {
+  init(from dict: Dict, appContext: AppContext) throws {
     self.init()
 
     let dictKeys = dict.keys
@@ -45,7 +45,7 @@ public extension Record {
         return
       }
       if dictKeys.contains(key) || field.isRequired {
-        try field.set(dict[key])
+        try field.set(dict[key], appContext: appContext)
       }
     }
   }

package/ios/Swift/SharedObjects/SharedObjectRegistry.swift

@@ -126,4 +126,8 @@ public final class SharedObjectRegistry {
     }
     return createSharedJavaScriptObject(runtime: runtime, nativeObject: nativeObject)
   }
+
+  internal static func clear() {
+    pairs.removeAll()
+  }
 }

package/ios/Swift/Views/AnyViewProp.swift

@@ -12,5 +12,5 @@ public protocol AnyViewProp: ViewManagerDefinitionComponent {
   /**
    Function that sets the underlying prop value for given view.
    */
-  func set(value: Any, onView: UIView) throws
+  func set(value: Any, onView: UIView, appContext: AppContext) throws
 }

package/ios/Swift/Views/ComponentData.swift

@@ -43,6 +43,37 @@ public final class ComponentData: RCTComponentData {
     return super.createPropBlock(propName, isShadowView: isShadowView)
   }
 
+  public override func setProps(_ props: [String: Any], forView view: RCTComponent) {
+    guard let view = view as? UIView else {
+      log.warn("Given view is not an UIView")
+      return
+    }
+    guard let viewManager = moduleHolder?.viewManager else {
+      log.warn("View manager '\(self.name)' not found")
+      return
+    }
+    guard let appContext = moduleHolder?.appContext else {
+      log.warn("App context has been lost")
+      return
+    }
+    let propsDict = viewManager.propsDict()
+    var remainingProps = props
+
+    for (key, prop) in propsDict {
+      let newValue = props[key] as Any
+
+      // TODO: @tsapeta: Figure out better way to rethrow errors from here.
+      try? prop.set(value: Conversions.fromNSObject(newValue), onView: view, appContext: appContext)
+
+      remainingProps.removeValue(forKey: key)
+    }
+
+    // Let the base class `RCTComponentData` handle all remaining props.
+    super.setProps(remainingProps, forView: view)
+
+    viewManager.callLifecycleMethods(withType: .didUpdateProps, forView: view)
+  }
+
   /**
    The base `RCTComponentData` class does some Objective-C dynamic calls in this function, but we don't
    need to do these slow operations since the Sweet API gives us necessary details without reflections.
@@ -52,8 +83,12 @@ public final class ComponentData: RCTComponentData {
     var directEvents: [String] = []
     let superClass: AnyClass? = managerClass.superclass()
 
-    if let eventNames = moduleHolder?.viewManager?.eventNames {
-      for eventName in eventNames {
+    if let viewManager = moduleHolder?.viewManager {
+      for prop in viewManager.props {
+        // `id` allows every type to be passed in
+        propTypes[prop.name] = "id"
+      }
+      for eventName in viewManager.eventNames {
         directEvents.append(RCTNormalizeInputEventName(eventName))
         propTypes[eventName] = "BOOL"
       }

package/ios/Swift/Views/ConcreteViewProp.swift

@@ -32,13 +32,13 @@ public final class ConcreteViewProp<ViewType: UIView, PropType: AnyArgument>: An
   /**
    Function that sets the underlying prop value for given view.
    */
-  public func set(value: Any, onView view: UIView) throws {
+  public func set(value: Any, onView view: UIView, appContext: AppContext) throws {
     // Method's signature must be type-erased to conform to `AnyViewProp` protocol.
     // Given view must be castable to the generic `ViewType` type.
     guard let view = view as? ViewType else {
       throw IncompatibleViewException((propName: name, viewType: ViewType.self))
     }
-    guard let value = try propType.cast(value) as? PropType else {
+    guard let value = try propType.cast(value, appContext: appContext) as? PropType else {
       throw Conversions.CastingException<PropType>(value)
     }
     setter(view, value)