expo-modules-core 0.6.4 → 0.7.0

package/ios/Swift/Objects/ObjectDefinitionComponents.swift

@@ -0,0 +1,208 @@
+/// This file implements definition components that are allowed in any object-based definition — `ObjectDefinition`.
+/// So far only constants and functions belong to plain object.
+
+// MARK: - Constants
+
+/**
+ Definition function setting the module's constants to export.
+ */
+public func constants(_ body: @escaping () -> [String: Any?]) -> AnyDefinition {
+  return ConstantsDefinition(body: body)
+}
+
+/**
+ Definition function setting the module's constants to export.
+ */
+public func constants(_ body: @autoclosure @escaping () -> [String: Any?]) -> AnyDefinition {
+  return ConstantsDefinition(body: body)
+}
+
+// MARK: - Functions
+
+/**
+ Function without arguments.
+ */
+public func function<R>(
+  _ name: String,
+  _ closure: @escaping () throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [],
+    closure
+  )
+}
+
+/**
+ Function with one argument.
+ */
+public func function<R, A0: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0) throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [ArgumentType(A0.self)],
+    closure
+  )
+}
+
+/**
+ Function with two arguments.
+ */
+public func function<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1) throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    closure
+  )
+}
+
+/**
+ Function with three arguments.
+ */
+public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2) throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Function with four arguments.
+ */
+public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3) throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Function with five arguments.
+ */
+public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Function with six arguments.
+ */
+public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Function with seven arguments.
+ */
+public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self),
+      ArgumentType(A6.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Function with eight arguments.
+ */
+public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument, A7: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self),
+      ArgumentType(A6.self),
+      ArgumentType(A7.self)
+    ],
+    closure
+  )
+}
+
+// MARK: - Events
+
+/**
+ Defines event names that the object can send to JavaScript.
+ */
+public func events(_ names: String...) -> AnyDefinition {
+  return EventsDefinition(names: names)
+}
+
+/**
+ Function that is invoked when the first event listener is added.
+ */
+public func onStartObserving(_ body: @escaping () -> Void) -> AnyFunction {
+  return ConcreteFunction("startObserving", argTypes: [], body)
+}
+
+/**
+ Function that is invoked when all event listeners are removed.
+ */
+public func onStopObserving(_ body: @escaping () -> Void) -> AnyFunction {
+  return ConcreteFunction("stopObserving", argTypes: [], body)
+}

package/ios/Swift/Promise.swift

@@ -1,3 +1,4 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
 
 public struct Promise: AnyArgument {
   public typealias ResolveClosure = (Any?) -> Void
@@ -11,20 +12,24 @@ public struct Promise: AnyArgument {
    Necessary in some places not converted to Swift, such as `EXPermissionsMethodsDelegate`.
    */
   public var legacyRejecter: EXPromiseRejectBlock {
-    return { code, description, error in
+    return { code, description, _ in
       reject(code ?? "", description ?? "")
     }
   }
 
-  public func resolve(_ value: Any? = nil) -> Void {
+  public func resolve(_ value: Any? = nil) {
     resolver(value)
   }
 
+  public func reject(_ error: Error) {
+    rejecter(UnexpectedException(error))
+  }
+
   public func reject(_ error: CodedError) {
     rejecter(error)
   }
 
-  public func reject(_ code: String, _ description: String) -> Void {
+  public func reject(_ code: String, _ description: String) {
     rejecter(SimpleCodedError(code, description))
   }
 }

package/ios/Swift/Records/AnyField.swift

@@ -12,5 +12,12 @@ internal protocol AnyFieldInternal: AnyField {
   var key: String? { get }
   var options: Set<FieldOption> { get set }
 
+  /**
+   Whether the value for this field must be explicitly provided.
+   The record throws an error when the source dictionary is missing a required value.
+   Note that it's NOT the opposite to `isOptional`.
+   */
+  var isRequired: Bool { get }
+
   func set(_ newValue: Any?) throws
 }

package/ios/Swift/Records/Field.swift

@@ -8,6 +8,8 @@ public final class Field<Type>: AnyFieldInternal {
    */
   public var wrappedValue: Type
 
+  private let fieldType: AnyArgumentType = ArgumentType(Type.self)
+
   /**
    Field's key in the dictionary, which by default is a label of the wrapped property.
    Sadly, property wrappers don't receive properties' label, so we must wait until it's assigned by `Record`.
@@ -23,11 +25,13 @@ public final class Field<Type>: AnyFieldInternal {
 
   /**
    Whether the generic field type accepts `nil` values.
-   We can't check it directly with `Optional` because it has associated type,
-   but all optionals implement non-generic `ExpressibleByNilLiteral` protocol.
    */
   internal var isOptional: Bool {
-    return Type.self is ExpressibleByNilLiteral.Type
+    return fieldType is OptionalArgumentType
+  }
+
+  internal var isRequired: Bool {
+    options.contains(.required)
   }
 
   /**
@@ -71,29 +75,30 @@ public final class Field<Type>: AnyFieldInternal {
    Sets the wrapped value with a value of `Any` type.
    */
   internal func set(_ newValue: Any?) throws {
-    if newValue == nil && (!isOptional || options.contains(.required)) {
-      throw FieldRequiredError(fieldKey: key!)
+    if newValue == nil && (!isOptional || isRequired) {
+      throw FieldRequiredException(key!)
     }
-    if let value = newValue as? Type {
-      wrappedValue = value
-      return
+    do {
+      if let value = try fieldType.cast(newValue) as? Type {
+        wrappedValue = value
+      }
+    } catch {
+      throw FieldInvalidTypeException((fieldKey: key!, value: newValue, desiredType: Type.self)).causedBy(error)
     }
-    throw FieldInvalidTypeError(fieldKey: key!, value: newValue, desiredType: Type.self)
   }
 }
 
-internal struct FieldRequiredError: CodedError {
-  let fieldKey: String
-  var description: String {
-    "Value for field `\(fieldKey)` is required, got `nil`"
+internal class FieldRequiredException: GenericException<String> {
+  override var reason: String {
+    "Value for field '\(param)' is required, got nil"
   }
 }
 
-internal struct FieldInvalidTypeError: CodedError {
-  let fieldKey: String
-  let value: Any?
-  let desiredType: Any.Type
-  var description: String {
-    "Cannot cast value `\(String(describing: value!))` (\(type(of: value!))) for field `\(fieldKey)` (\(String(describing: desiredType)))"
+internal class FieldInvalidTypeException: GenericException<(fieldKey: String, value: Any?, desiredType: Any.Type)> {
+  override var reason: String {
+    let value = String(describing: param.value ?? "null")
+    let desiredType = String(describing: param.desiredType)
+
+    return "Cannot cast '\(value)' for field '\(param.fieldKey)' of type \(desiredType)"
   }
 }

package/ios/Swift/Records/FieldOption.swift

@@ -15,7 +15,7 @@ public struct FieldOption: Equatable, Hashable, ExpressibleByIntegerLiteral, Exp
   /**
    Field options are equal when their raw values and parameters are equal.
    */
-  public static func ==(lhs: Self, rhs: Self) -> Bool {
+  public static func == (lhs: Self, rhs: Self) -> Bool {
     return lhs.rawValue == rhs.rawValue && lhs.key == rhs.key
   }
 

package/ios/Swift/Records/Record.swift

@@ -31,14 +31,22 @@ public extension Record {
     if let value = value as? Dict {
       return try Self(from: value)
     }
-    throw Conversions.ConvertingError<Self>(value: value)
+    throw Conversions.ConvertingException<Self>(value)
   }
 
   init(from dict: Dict) throws {
     self.init()
 
+    let dictKeys = dict.keys
+
     try fieldsOf(self).forEach { field in
-      try field.set(dict[field.key!])
+      guard let key = field.key else {
+        // This should never happen, but just in case skip fields without the key.
+        return
+      }
+      if dictKeys.contains(key) || field.isRequired {
+        try field.set(dict[key])
+      }
     }
   }
 
@@ -53,7 +61,7 @@ public extension Record {
  Returns an array of fields found in record's mirror. If the field is missing the `key`,
  it gets assigned to the property label, so after all it's safe to enforce unwrapping it (using `key!`).
  */
-fileprivate func fieldsOf(_ record: Record) -> [AnyFieldInternal] {
+private func fieldsOf(_ record: Record) -> [AnyFieldInternal] {
   return Mirror(reflecting: record).children.compactMap { (label: String?, value: Any) in
     guard var field = value as? AnyFieldInternal, let key = field.key ?? convertLabelToKey(label) else {
       return nil
@@ -66,6 +74,6 @@ fileprivate func fieldsOf(_ record: Record) -> [AnyFieldInternal] {
 /**
  Converts mirror's label to field's key by dropping the "_" prefix from wrapped property label.
  */
-fileprivate func convertLabelToKey(_ label: String?) -> String? {
+private func convertLabelToKey(_ label: String?) -> String? {
   return (label != nil && label!.starts(with: "_")) ? String(label!.dropFirst()) : label
 }

package/ios/Swift/SwiftInteropBridge.swift

@@ -1,5 +1,7 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
 
 import Foundation
+import React
 
 @objc
 public final class SwiftInteropBridge: NSObject {
@@ -21,11 +23,18 @@ public final class SwiftInteropBridge: NSObject {
   }
 
   @objc
-  public func callFunction(_ functionName: String,
-                           onModule moduleName: String,
-                           withArgs args: [Any],
-                           resolve: @escaping EXPromiseResolveBlock,
-                           reject: @escaping EXPromiseRejectBlock) {
+  public func setReactBridge(_ reactBridge: RCTBridge) {
+    appContext.reactBridge = reactBridge
+  }
+
+  @objc
+  public func callFunction(
+    _ functionName: String,
+    onModule moduleName: String,
+    withArgs args: [Any],
+    resolve: @escaping EXPromiseResolveBlock,
+    reject: @escaping EXPromiseRejectBlock
+  ) {
     registry
       .get(moduleHolderForName: moduleName)?
       .call(function: functionName, args: args) { value, error in
@@ -40,9 +49,11 @@ public final class SwiftInteropBridge: NSObject {
   }
 
   @objc
-  public func callFunctionSync(_ functionName: String,
-                               onModule moduleName: String,
-                               withArgs args: [Any]) -> Any? {
+  public func callFunctionSync(
+    _ functionName: String,
+    onModule moduleName: String,
+    withArgs args: [Any]
+  ) -> Any? {
     return registry
       .get(moduleHolderForName: moduleName)?
       .callSync(function: functionName, args: args)
@@ -53,11 +64,11 @@ public final class SwiftInteropBridge: NSObject {
     var constants = [String: [[String: Any]]]()
 
     for holder in registry {
-      constants[holder.name] = holder.definition.functions.map({ (functionName, function) in
+      constants[holder.name] = holder.definition.functions.map({ functionName, function in
         return [
           "name": functionName,
           "argumentsCount": function.argumentsCount,
-          "key": functionName,
+          "key": functionName
         ]
       })
     }
@@ -92,6 +103,24 @@ public final class SwiftInteropBridge: NSObject {
     }
   }
 
+  /**
+   Sets the JSI runtime on the operating `AppContext`.
+   */
+  @objc
+  public func setRuntime(_ runtime: JavaScriptRuntime?) {
+    appContext.runtime = runtime
+  }
+
+  @objc
+  public func getModuleNames() -> [String] {
+    return registry.getModuleNames()
+  }
+
+  @objc
+  public func getNativeModuleObject(_ moduleName: String) -> JavaScriptObject? {
+    return registry.get(moduleHolderForName: moduleName)?.javaScriptObject
+  }
+
   // MARK: - Events
 
   /**

package/ios/Swift/Views/AnyViewProp.swift

@@ -3,7 +3,7 @@ import UIKit
 /**
  Type-erased protocol for view props classes.
  */
-public protocol AnyViewProp: AnyDefinition {
+public protocol AnyViewProp: ViewManagerDefinitionComponent {
   /**
    Name of the view prop that JavaScript refers to.
    */

package/ios/Swift/Views/ComponentData.swift

@@ -0,0 +1,95 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+
+/**
+ Custom component data extending `RCTComponentData`. Its main purpose is to handle event-based props (callbacks),
+ but it also simplifies capturing the view config so we can omit some reflections that React Native executes.
+ */
+@objc(EXComponentData)
+public final class ComponentData: EXComponentDataCompatibleWrapper {
+  /**
+   Weak pointer to the holder of a module that the component data was created for.
+   */
+  weak var moduleHolder: ModuleHolder?
+
+  /**
+   Initializer that additionally takes the original view module to have access to its definition.
+   */
+  @objc
+  public init(viewModule: ViewModuleWrapper, managerClass: ViewModuleWrapper.Type, bridge: RCTBridge) {
+    self.moduleHolder = viewModule.wrappedModuleHolder
+    super.init(managerClass: managerClass, bridge: bridge, eventDispatcher: bridge.eventDispatcher())
+  }
+
+  // MARK: RCTComponentData
+
+  /**
+   Creates a setter for the specific prop. For non-event props we just let React Native do its job.
+   Events are handled differently to conveniently use them in Swift.
+   */
+  public override func createPropBlock(_ propName: String, isShadowView: Bool) -> RCTPropBlockAlias {
+    // Expo Modules Core doesn't support shadow views yet, so fall back to the default implementation.
+    if isShadowView {
+      return super.createPropBlock(propName, isShadowView: isShadowView)
+    }
+
+    // If the prop is defined as an event, create our own event setter.
+    if moduleHolder?.viewManager?.eventNames.contains(propName) == true {
+      return createEventSetter(eventName: propName, bridge: self.manager?.bridge)
+    }
+
+    // Otherwise also fall back to the default implementation.
+    return super.createPropBlock(propName, isShadowView: isShadowView)
+  }
+
+  /**
+   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.
+   */
+  public override func viewConfig() -> [String: Any] {
+    var propTypes: [String: Any] = [:]
+    var directEvents: [String] = []
+    let superClass: AnyClass? = managerClass.superclass()
+
+    if let eventNames = moduleHolder?.viewManager?.eventNames {
+      for eventName in eventNames {
+        directEvents.append(RCTNormalizeInputEventName(eventName))
+        propTypes[eventName] = "BOOL"
+      }
+    }
+
+    return [
+      "propTypes": propTypes,
+      "directEvents": directEvents,
+      "bubblingEvents": [String](),
+      "baseModuleName": superClass?.moduleName() as Any
+    ]
+  }
+}
+
+/**
+ Creates a setter for the event prop.
+ */
+private func createEventSetter(eventName: String, bridge: RCTBridge?) -> RCTPropBlockAlias {
+  return { [weak bridge] (target: RCTComponent, value: Any) in
+    // Find view's property that is named as the prop and is wrapped by `Event`.
+    let child = Mirror(reflecting: target).children.first {
+      $0.label == "_\(eventName)"
+    }
+    guard let event = child?.value as? AnyEventInternal else {
+      return
+    }
+
+    // For callbacks React Native passes a bool value whether the prop is specified or not.
+    if value as? Bool == true {
+      event.settle { [weak target] (body: Any) in
+        if let target = target {
+          let componentEvent = RCTComponentEvent(name: eventName, viewTag: target.reactTag, body: ["payload": body])
+          bridge?.eventDispatcher().send(componentEvent)
+        }
+      }
+    } else {
+      event.invalidate()
+    }
+  }
+}

package/ios/Swift/Views/ConcreteViewProp.swift

@@ -36,22 +36,20 @@ public final class ConcreteViewProp<ViewType: UIView, PropType: AnyArgument>: An
     // 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 IncompatibleViewError(propName: name, viewType: ViewType.self)
+      throw IncompatibleViewException((propName: name, viewType: ViewType.self))
     }
     guard let value = try propType.cast(value) as? PropType else {
-      throw Conversions.CastingError<PropType>(value: value)
+      throw Conversions.CastingException<PropType>(value)
     }
     setter(view, value)
   }
 }
 
 /**
- An error that is thrown when the view passed to prop's setter doesn't match the type in setter's definition.
+ An exception that is thrown when the view passed to prop's setter doesn't match the type in setter's definition.
  */
-internal struct IncompatibleViewError: CodedError {
-  let propName: String
-  let viewType: UIView.Type
-  var description: String {
-    "Tried to set prop `\(propName)` on the view that isn't `\(viewType)`"
+internal class IncompatibleViewException: GenericException<(propName: String, viewType: UIView.Type)> {
+  override var reason: String {
+    "Tried to set prop '\(param.propName)' on the view that isn't \(param.viewType)"
   }
 }

package/ios/Swift/Views/ViewFactory.swift

@@ -3,7 +3,7 @@ import UIKit
 /**
  A definition of the view factory that creates views.
  */
-internal struct ViewFactory: AnyDefinition {
+internal struct ViewFactory: ViewManagerDefinitionComponent {
   typealias FactoryClosureType = () -> UIView
 
   let factory: FactoryClosureType

package/ios/Swift/Views/ViewManagerDefinition.swift

@@ -3,7 +3,7 @@ import UIKit
 /**
  The definition of the view manager. It's part of the module definition to scope only view-related definitions.
  */
-public struct ViewManagerDefinition: AnyDefinition {
+public final class ViewManagerDefinition: ObjectDefinition {
   /**
    The view factory that lets us create views.
    */
@@ -14,13 +14,29 @@ public struct ViewManagerDefinition: AnyDefinition {
    */
   let props: [AnyViewProp]
 
-  init(definitions: [AnyDefinition]) {
+  /**
+   Names of the events that the view can send to JavaScript.
+   */
+  let eventNames: [String]
+
+  /**
+   Default initializer receiving children definitions from the result builder.
+   */
+  override init(definitions: [AnyDefinition]) {
     self.factory = definitions
       .compactMap { $0 as? ViewFactory }
       .last
 
     self.props = definitions
       .compactMap { $0 as? AnyViewProp }
+
+    self.eventNames = Array(
+      definitions
+        .compactMap { ($0 as? EventsDefinition)?.names }
+        .joined()
+    )
+
+    super.init(definitions: definitions)
   }
 
   /**
@@ -39,3 +55,8 @@ public struct ViewManagerDefinition: AnyDefinition {
     }
   }
 }
+
+/**
+ The protocol for definition components that can only be handled by the view manager builder.
+ */
+public protocol ViewManagerDefinitionComponent: AnyDefinition {}

package/ios/Swift/Views/ViewManagerDefinitionBuilder.swift

@@ -1,4 +1,3 @@
-
 #if swift(>=5.4)
 /**
  A result builder that captures scoped definitions specific for view managers, such as `ViewFactory` and `ConcreteViewProp`.