expo-modules-core 0.6.1 → 0.7.0

package/ios/Swift/Modules/ModuleDefinitionComponents.swift

@@ -16,150 +16,6 @@ extension AnyModule {
     return ModuleNameDefinition(name: name)
   }
 
-  // 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 () -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [],
-      closure
-    )
-  }
-
-  /**
-   Function with one argument.
-   */
-  public func function<R, A0: AnyArgument>(
-    _ name: String,
-    _ closure: @escaping (A0) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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: - Module's lifecycle
 
   /**
@@ -212,50 +68,6 @@ extension AnyModule {
   public func viewManager(@ViewManagerDefinitionBuilder _ closure: @escaping () -> ViewManagerDefinition) -> AnyDefinition {
     return closure()
   }
-
-  // MARK: - Events
-
-  /**
-   Defines event names that this module 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 () -> ()) -> AnyFunction {
-    return ConcreteFunction("startObserving", argTypes: [], body)
-  }
-
-  /**
-   Function that is invoked when all event listeners are removed.
-   */
-  public func onStopObserving(_ body: @escaping () -> ()) -> AnyFunction {
-    return ConcreteFunction("stopObserving", argTypes: [], body)
-  }
-}
-
-/**
- Defines the factory creating a native view when the module is used as a view.
- */
-public func view(_ closure: @escaping () -> UIView) -> AnyDefinition {
-  return ViewFactory(closure)
-}
-
-/**
- Creates a view prop that defines its name and setter.
- */
-public func prop<ViewType: UIView, PropType: AnyArgument>(
-  _ name: String,
-  _ setter: @escaping (ViewType, PropType) -> Void
-) -> AnyDefinition {
-  return ConcreteViewProp(
-    name: name,
-    propType: ArgumentType(PropType.self),
-    setter: setter
-  )
 }
 
 // TODO: - Remove deprecated `method` component once SDK44 is out.

package/ios/Swift/ModulesProvider.swift

@@ -1,4 +1,3 @@
-
 import Foundation
 
 /**

package/ios/Swift/Objects/ObjectDefinition.swift

@@ -0,0 +1,30 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ Base class for other definitions representing an object, such as `ModuleDefinition`.
+ */
+public class ObjectDefinition: AnyDefinition {
+  /**
+   A dictionary of functions defined by the object.
+   */
+  let functions: [String: AnyFunction]
+
+  /**
+   An array of constants definitions.
+   */
+  let constants: [ConstantsDefinition]
+
+  /**
+   Default initializer receiving children definitions from the result builder.
+   */
+  init(definitions: [AnyDefinition]) {
+    self.functions = definitions
+      .compactMap { $0 as? AnyFunction }
+      .reduce(into: [String: AnyFunction]()) { dict, function in
+        dict[function.name] = function
+      }
+
+    self.constants = definitions
+      .compactMap { $0 as? ConstantsDefinition }
+  }
+}

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
 
   /**