expo-modules-core 0.6.4 → 0.8.0

package/ios/Swift/Objects/ObjectDefinitionComponents.swift

@@ -0,0 +1,384 @@
+/// 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.
+ */
+@available(*, deprecated, renamed: "asyncFunction")
+public func function<R>(
+  _ name: String,
+  _ closure: @escaping () throws -> R
+) -> AnyFunction {
+  return ConcreteFunction(
+    name,
+    argTypes: [],
+    closure
+  )
+}
+
+/**
+ Function with one argument.
+ */
+@available(*, deprecated, renamed: "asyncFunction")
+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.
+ */
+@available(*, deprecated, renamed: "asyncFunction")
+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.
+ */
+@available(*, deprecated, renamed: "asyncFunction")
+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.
+ */
+@available(*, deprecated, renamed: "asyncFunction")
+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.
+ */
+@available(*, deprecated, renamed: "asyncFunction")
+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.
+ */
+@available(*, deprecated, renamed: "asyncFunction")
+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.
+ */
+@available(*, deprecated, renamed: "asyncFunction")
+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.
+ */
+@available(*, deprecated, renamed: "asyncFunction")
+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: - Asynchronous functions
+
+/**
+ Asynchronous function without arguments.
+ */
+public func asyncFunction<R>(
+  _ name: String,
+  _ closure: @escaping () throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with one argument.
+ */
+public func asyncFunction<R, A0: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [ArgumentType(A0.self)],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with two arguments.
+ */
+public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with three arguments.
+ */
+public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with four arguments.
+ */
+public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with five arguments.
+ */
+public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
+) -> AnyFunction {
+  return AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with six arguments.
+ */
+public func asyncFunction<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 AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with seven arguments.
+ */
+public func asyncFunction<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 AsyncFunction(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self),
+      ArgumentType(A6.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with eight arguments.
+ */
+public func asyncFunction<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 AsyncFunction(
+    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 {
@@ -9,9 +11,14 @@ public final class SwiftInteropBridge: NSObject {
     appContext.moduleRegistry
   }
 
+  internal init(appContext: AppContext) {
+    self.appContext = appContext
+    super.init()
+  }
+
   @objc
-  public init(modulesProvider: ModulesProviderObjCProtocol, legacyModuleRegistry: EXModuleRegistry) {
-    self.appContext = AppContext(withModulesProvider: modulesProvider as! ModulesProviderProtocol, legacyModuleRegistry: legacyModuleRegistry)
+  public init(modulesProvider: ModulesProvider, legacyModuleRegistry: EXModuleRegistry) {
+    self.appContext = AppContext(withModulesProvider: modulesProvider, legacyModuleRegistry: legacyModuleRegistry)
     super.init()
   }
 
@@ -21,11 +28,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 +54,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 +69,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
         ]
       })
     }
@@ -72,9 +88,13 @@ public final class SwiftInteropBridge: NSObject {
   }
 
   @objc
-  public func exportedViewManagersNames() -> [String] {
-    return registry.compactMap { holder in
-      return holder.definition.viewManager != nil ? holder.name : nil
+  public func viewManagersMetadata() -> [String: Any] {
+    return registry.reduce(into: [String: Any]()) { acc, holder in
+      if let viewManager = holder.definition.viewManager {
+        acc[holder.name] = [
+          "propsNames": viewManager.props.map { $0.name }
+        ]
+      }
     }
   }
 
@@ -92,6 +112,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.
    */