expo-modules-core 0.4.8 → 0.5.0

package/ios/Swift/Arguments/Types/PromiseArgumentType.swift

@@ -0,0 +1,15 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type that represents the `Promise` argument.
+ */
+internal struct PromiseArgumentType: AnyArgumentType {
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    if let value = value as? Promise {
+      return value
+    }
+    throw Conversions.CastingError<Promise>(value: value)
+  }
+
+  var description: String = "Promise"
+}

package/ios/Swift/Arguments/Types/RawArgumentType.swift

@@ -0,0 +1,25 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type that can wrap any type, but it casts only type-compatible values using `as?` keyword.
+ The innermost type of other argument types like `ArrayArgumentType` and `OptionalArgumentType`.
+ */
+internal struct RawArgumentType<InnerType>: AnyArgumentType {
+  let innerType: InnerType.Type
+
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    if let value = value as? InnerType {
+      return value
+    }
+    // Raw arguments are always non-optional, but they may receive `nil` values.
+    // Let's throw more specific error in this case.
+    if Optional.isNil(value) {
+      throw Conversions.NullCastError<InnerType>()
+    }
+    throw Conversions.CastingError<InnerType>(value: value)
+  }
+
+  var description: String {
+    String(describing: innerType.self)
+  }
+}

package/ios/Swift/Conversions.swift

@@ -1,5 +1,5 @@
 
-internal class Conversions {
+internal final class Conversions {
   /**
    Converts an array to tuple. Because of tuples nature, it's not possible to convert an array of any size, so we can support only up to some fixed size.
    */
@@ -31,12 +31,204 @@ internal class Conversions {
       throw TooManyArgumentsError(count: array.count, limit: 10)
     }
   }
-}
 
-internal struct TooManyArgumentsError: CodedError {
-  let count: Int
-  let limit: Int
-  var description: String {
-    "A number of arguments `\(count)` exceeds the limit of `\(limit)`"
+  static func fromNSObject(_ object: Any) -> Any {
+    switch object {
+    case let object as NSArray:
+      return object.map { Conversions.fromNSObject($0) }
+    case let object as NSDictionary:
+      let keyValuePairs: [(String, Any)] = object.map { ($0 as! String, Conversions.fromNSObject($1)) }
+      return Dictionary(uniqueKeysWithValues: keyValuePairs)
+    case is NSNull:
+      return Optional<Any>.none as Any
+    default:
+      return object
+    }
+  }
+
+  /**
+   Picks values under given keys from the dictionary, casted to a specific type. Can throw errors when
+   - The dictionary is missing some of the given keys (`MissingKeysError`)
+   - Some of the values cannot be casted to specified type (`CastingValuesError`)
+   */
+  static func pickValues<ValueType>(from dict: [String: Any], byKeys keys: [String], as type: ValueType.Type) throws -> [ValueType] {
+    var result = (
+      values: [ValueType](),
+      missingKeys: [String](),
+      invalidKeys: [String]()
+    )
+
+    for key in keys {
+      if dict[key] == nil {
+        result.missingKeys.append(key)
+      }
+      if let value = dict[key] as? ValueType {
+        result.values.append(value)
+      } else {
+        result.invalidKeys.append(key)
+      }
+    }
+    if result.missingKeys.count > 0 {
+      throw MissingKeysError<ValueType>(keys: result.missingKeys)
+    }
+    if result.invalidKeys.count > 0 {
+      throw CastingValuesError<ValueType>(keys: result.invalidKeys)
+    }
+    return result.values
+  }
+
+  /**
+   Converts hex string to `UIColor` or throws an error if the string is corrupted.
+   */
+  static func toColor(hexString hex: String) throws -> UIColor {
+    var hexStr = hex
+      .trimmingCharacters(in: .whitespacesAndNewlines)
+      .replacingOccurrences(of: "#", with: "")
+
+    // If just RGB, set alpha to maximum
+    if hexStr.count == 6 { hexStr += "FF" }
+    if hexStr.count == 3 { hexStr += "F" }
+
+    // Expand short form (supported by Web)
+    if hexStr.count == 4 {
+      let chars = Array(hexStr)
+      hexStr = [
+        String(repeating: chars[0], count: 2),
+        String(repeating: chars[1], count: 2),
+        String(repeating: chars[2], count: 2),
+        String(repeating: chars[3], count: 2)
+      ].joined(separator: "")
+    }
+
+    var rgba: UInt64 = 0
+
+    guard hexStr.range(of: #"^[0-9a-fA-F]{8}$"#, options: .regularExpression) != nil,
+          Scanner(string: hexStr).scanHexInt64(&rgba) else {
+      throw InvalidHexColorError(hex: hex)
+    }
+    return try toColor(rgba: rgba)
+  }
+
+  /**
+   Converts an integer for ARGB color to `UIColor`. Since the alpha channel is represented by first 8 bits,
+   it's optional out of the box. React Native converts colors to such format.
+   */
+  static func toColor(argb: UInt64) throws -> UIColor {
+    guard argb <= UInt32.max else {
+      throw HexColorOverflowError(hex: argb)
+    }
+    let alpha = CGFloat((argb >> 24) & 0xff) / 255.0
+    let red   = CGFloat((argb >> 16) & 0xff) / 255.0
+    let green = CGFloat((argb >> 8) & 0xff) / 255.0
+    let blue  = CGFloat(argb & 0xff) / 255.0
+    return UIColor(red: red, green: green, blue: blue, alpha: alpha)
+  }
+
+  /**
+   Converts an integer for RGBA color to `UIColor`.
+   */
+  static func toColor(rgba: UInt64) throws -> UIColor {
+    guard rgba <= UInt32.max else {
+      throw HexColorOverflowError(hex: rgba)
+    }
+    let red   = CGFloat((rgba >> 24) & 0xff) / 255.0
+    let green = CGFloat((rgba >> 16) & 0xff) / 255.0
+    let blue  = CGFloat((rgba >> 8) & 0xff) / 255.0
+    let alpha = CGFloat(rgba & 0xff) / 255.0
+    return UIColor(red: red, green: green, blue: blue, alpha: alpha)
+  }
+
+  /**
+   Formats an array of keys to the string with keys in apostrophes separated by commas.
+   */
+  static func formatKeys(_ keys: [String]) -> String {
+    return keys.map { "`\($0)`" }.joined(separator: ", ")
+  }
+
+  // MARK: - Errors
+
+  /**
+   An error meaning that the number of arguments exceeds the limit.
+   */
+  internal struct TooManyArgumentsError: CodedError {
+    let count: Int
+    let limit: Int
+    var description: String {
+      "A number of arguments `\(count)` exceeds the limit of `\(limit)`"
+    }
+  }
+
+  /**
+   An error that can be thrown by convertible types, when given value cannot be converted.
+   */
+  internal struct ConvertingError<TargetType>: CodedError {
+    let value: Any?
+    var code: String = "ERR_CONVERTING_FAILED"
+    var description: String {
+      "Cannot convert `\(String(describing: value))` to `\(TargetType.self)`"
+    }
+  }
+
+  /**
+   An error that is thrown when given value cannot be casted.
+   */
+  internal struct CastingError<TargetType>: CodedError {
+    let value: Any
+    var code: String = "ERR_CASTING_FAILED"
+    var description: String {
+      "Cannot cast `\(String(describing: value))` to `\(TargetType.self)`"
+    }
+  }
+
+  /**
+   An error that can be thrown by convertible types,
+   when the values in given dictionary cannot be casted to specific type.
+   */
+  internal struct CastingValuesError<ValueType>: CodedError {
+    let keys: [String]
+    var code: String = "ERR_CASTING_VALUES_FAILED"
+    var description: String {
+      "Cannot cast keys \(formatKeys(keys)) to `\(ValueType.self)`"
+    }
+  }
+
+  /**
+   An error that can be throw by convertible types,
+   when given dictionary is missing some required keys.
+   */
+  internal struct MissingKeysError<ValueType>: CodedError {
+    let keys: [String]
+    var description: String {
+      "Missing keys \(formatKeys(keys)) of type `\(ValueType.self)`"
+    }
+  }
+
+  /**
+   An error that is thrown when null value is tried to be casted to non-optional type.
+   */
+  internal struct NullCastError<TargetType>: CodedError {
+    var description: String {
+      "Cannot cast null value to non-optional `\(TargetType.self)`"
+    }
+  }
+
+  /**
+   An error used when the hex color string is invalid (e.g. contains non-hex characters).
+   */
+  internal struct InvalidHexColorError: CodedError {
+    let hex: String
+    var description: String {
+      "Provided hex color `\(hex)` is invalid"
+    }
+  }
+
+  /**
+   An error used when the integer value of the color would result in an overflow of `UInt32`.
+   */
+  internal struct HexColorOverflowError: CodedError {
+    let hex: UInt64
+    var description: String {
+      "Provided hex color `\(hex)` would result in an overflow"
+    }
   }
 }

package/ios/Swift/EventListener.swift

@@ -3,20 +3,52 @@
  */
 internal struct EventListener: AnyDefinition {
   let name: EventName
-  let call: (Any?) -> Void
+  let call: (Any?, Any?) throws -> Void
 
+  /**
+   Listener initializer for events without sender and payload.
+   */
   init(_ name: EventName, _ listener: @escaping () -> Void) {
     self.name = name
-    self.call = { payload in listener() }
+    self.call = { (sender, payload) in listener() }
   }
 
-  init<PayloadType>(_ name: EventName, _ listener: @escaping (PayloadType?) -> Void) {
+  /**
+   Listener initializer for events with no payload.
+   */
+  init<Sender>(_ name: EventName, _ listener: @escaping (Sender) -> Void) {
     self.name = name
-    self.call = { payload in listener(payload as? PayloadType) }
+    self.call = { (sender, payload) in
+      guard let sender = sender as? Sender else {
+        throw InvalidSenderTypeError(eventName: name, senderType: Sender.self)
+      }
+      listener(sender)
+    }
+  }
+
+  /**
+   Listener initializer for events that specify the payload.
+   */
+  init<Sender, PayloadType>(_ name: EventName, _ listener: @escaping (Sender, PayloadType?) -> Void) {
+    self.name = name
+    self.call = { (sender, payload) in
+      guard let sender = sender as? Sender else {
+        throw InvalidSenderTypeError(eventName: name, senderType: Sender.self)
+      }
+      listener(sender, payload as? PayloadType)
+    }
+  }
+}
+
+struct InvalidSenderTypeError: CodedError {
+  var eventName: EventName
+  var senderType: Any.Type
+  var description: String {
+    "Sender for event `\(eventName)` must be of type `\(senderType)`."
   }
 }
 
-internal enum EventName: Equatable {
+public enum EventName: Equatable {
   case custom(_ name: String)
 
   // MARK: Module lifecycle

package/ios/Swift/Functions/AnyFunction.swift

@@ -0,0 +1,42 @@
+import Dispatch
+
+/**
+ A protocol for any type-erased function.
+ */
+public protocol AnyFunction: AnyDefinition {
+  /**
+   Name of the function. JavaScript refers to the function by this name.
+   */
+  var name: String { get }
+
+  /**
+   Bool value indicating whether the function takes promise as the last argument.
+   */
+  var takesPromise: Bool { get }
+
+  /**
+   A number of arguments the function takes. If the last argument is of type `Promise`, it is not counted.
+   */
+  var argumentsCount: Int { get }
+
+  /**
+   Dispatch queue on which each function's call is run.
+   */
+  var queue: DispatchQueue? { get }
+
+  /**
+   Calls the function on given module with arguments and a promise.
+   */
+  func call(args: [Any], promise: Promise) -> Void
+
+  /**
+   Synchronously calls the function with given arguments. If the function takes a promise,
+   the current thread will be locked until the promise rejects or resolves with the return value.
+   */
+  func callSync(args: [Any]) -> Any
+
+  /**
+   Specifies on which queue the function should run.
+   */
+  func runOnQueue(_ queue: DispatchQueue?) -> Self
+}

package/ios/Swift/{Methods/ConcreteMethod.swift → Functions/ConcreteFunction.swift}

@@ -1,12 +1,12 @@
 import Dispatch
 
-public class ConcreteMethod<Args, ReturnType>: AnyMethod {
+public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
   public typealias ClosureType = (Args) -> ReturnType
 
   public let name: String
 
   public var takesPromise: Bool {
-    return argTypes.last?.canCastToType(Promise.self) ?? false
+    return argTypes.last is PromiseArgumentType
   }
 
   public var argumentsCount: Int {
@@ -29,7 +29,7 @@ public class ConcreteMethod<Args, ReturnType>: AnyMethod {
     self.closure = closure
   }
 
-  public func call(args: [Any?], promise: Promise) {
+  public func call(args: [Any], promise: Promise) {
     let takesPromise = self.takesPromise
     let returnedValue: ReturnType?
 
@@ -54,6 +54,31 @@ public class ConcreteMethod<Args, ReturnType>: AnyMethod {
     }
   }
 
+  public func callSync(args: [Any]) -> Any {
+    if takesPromise {
+      var result: Any?
+      let semaphore = DispatchSemaphore(value: 0)
+
+      let promise = Promise {
+        result = $0
+        semaphore.signal()
+      } rejecter: { error in
+        semaphore.signal()
+      }
+      call(args: args, promise: promise)
+      semaphore.wait()
+      return result as Any
+    } else {
+      do {
+        let finalArgs = try castArguments(args)
+        let tuple = try Conversions.toTuple(finalArgs) as! Args
+        return closure(tuple)
+      } catch let error {
+        return error
+      }
+    }
+  }
+
   public func runOnQueue(_ queue: DispatchQueue?) -> Self {
     self.queue = queue
     return self
@@ -63,33 +88,15 @@ public class ConcreteMethod<Args, ReturnType>: AnyMethod {
     return (0..<argTypes.count).contains(index) ? argTypes[index] : nil
   }
 
-  private func castArguments(_ args: [Any?]) throws -> [AnyMethodArgument?] {
+  private func castArguments(_ args: [Any]) throws -> [Any] {
     if args.count != argumentsCount {
       throw InvalidArgsNumberError(received: args.count, expected: argumentsCount)
     }
     return try args.enumerated().map { (index, arg) in
-      guard let desiredType = argumentType(atIndex: index) else {
-        return nil
-      }
+      let expectedType = argumentType(atIndex: index)
 
-      // If the type of argument matches the desired type, just cast and return it.
-      // This usually covers all cases for primitive types or plain dicts and arrays.
-      if desiredType.canCast(arg) {
-        return desiredType.cast(arg)
-      }
-
-      // TODO: (@tsapeta) Handle structs convertible to dictionary
-      // If we get here, the argument can be converted (not casted!) to the desired type.
-      if let arg = arg as? Record.Dict, let dt = desiredType.castWrappedType(Record.Type.self) {
-        return try dt.init(from: arg)
-      }
-
-      // TODO: (@tsapeta) Handle convertible arrays
-      throw IncompatibleArgTypeError(
-        argument: arg,
-        atIndex: index,
-        desiredType: desiredType
-      )
+      // It's safe to unwrap since the arguments count matches.
+      return try expectedType!.cast(arg)
     }
   }
 }
@@ -101,12 +108,3 @@ internal struct InvalidArgsNumberError: CodedError {
     "Received \(received) arguments, but \(expected) was expected."
   }
 }
-
-internal struct IncompatibleArgTypeError<ArgumentType>: CodedError {
-  let argument: ArgumentType
-  let atIndex: Int
-  let desiredType: AnyArgumentType
-  var description: String {
-    "Type `\(type(of: argument))` of argument at index `\(atIndex)` is not compatible with expected type `\(desiredType.typeName)`."
-  }
-}

package/ios/Swift/ModuleHolder.swift

@@ -3,44 +3,78 @@ import Dispatch
 /**
  Holds a reference to the module instance and caches its definition.
  */
-public class ModuleHolder {
+public final class ModuleHolder {
+  /**
+   Instance of the module.
+   */
   private(set) var module: AnyModule
 
-  private(set) lazy var definition: ModuleDefinition = module.definition()
+  /**
+   A weak reference to the app context.
+   */
+  private(set) weak var appContext: AppContext?
 
+  /**
+   Caches the definition of the module type.
+   */
+  let definition: ModuleDefinition
+
+  /**
+   Returns `definition.name` if not empty, otherwise falls back to the module type name.
+   */
   var name: String {
-    return definition.name ?? String(describing: type(of: module))
+    return definition.name.isEmpty ? String(describing: type(of: module)) : definition.name
   }
 
-  init(module: AnyModule) {
-    self.module = module
+  /**
+   Number of JavaScript listeners attached to the module.
+   */
+  var listenersCount: Int = 0
 
+  init(appContext: AppContext, module: AnyModule) {
+    self.appContext = appContext
+    self.module = module
+    self.definition = module.definition()
     post(event: .moduleCreate)
   }
 
-  // MARK: Calling methods
+  // MARK: Calling functions
+
+  func call(function functionName: String, args: [Any], promise: Promise) {
+    do {
+      guard let function = definition.functions[functionName] else {
+        throw FunctionNotFoundError(functionName: functionName, moduleName: self.name)
+      }
+      let queue = function.queue ?? DispatchQueue.global(qos: .default)
 
-  func call(method methodName: String, args: [Any?], promise: Promise) {
-    if let method = definition.methods[methodName] {
-      let queue = method.queue ?? DispatchQueue.global(qos: .default)
       queue.async {
-        method.call(args: args, promise: promise)
+        function.call(args: args, promise: promise)
       }
-    } else {
-      promise.reject(MethodNotFoundError(methodName: methodName, moduleName: self.name))
+    } catch let error as CodedError {
+      promise.reject(error)
+    } catch {
+      promise.reject(UnexpectedError(error))
     }
   }
 
-  func call(method methodName: String, args: [Any?], _ callback: @escaping (Any?, CodedError?) -> Void = { _, _ in }) {
+  func call(function functionName: String, args: [Any], _ callback: @escaping (Any?, CodedError?) -> Void = { _, _ in }) {
     let promise = Promise {
       callback($0, nil)
     } rejecter: {
       callback(nil, $0)
     }
-    call(method: methodName, args: args, promise: promise)
+    call(function: functionName, args: args, promise: promise)
   }
 
-  // MARK: Listening to events
+  @discardableResult
+  func callSync(function functionName: String, args: [Any]) -> Any? {
+    if let function = definition.functions[functionName] {
+      return function.callSync(args: args)
+    }
+    return nil
+  }
+
+  // MARK: Listening to native events
 
   func listeners(forEvent event: EventName) -> [EventListener] {
     return definition.eventListeners.filter {
@@ -50,16 +84,30 @@ public class ModuleHolder {
 
   func post(event: EventName) {
     listeners(forEvent: event).forEach {
-      $0.call(nil)
+      try? $0.call(module, nil)
     }
   }
 
   func post<PayloadType>(event: EventName, payload: PayloadType?) {
     listeners(forEvent: event).forEach {
-      $0.call(payload)
+      try? $0.call(module, payload)
     }
   }
 
+  // MARK: JavaScript events
+
+  /**
+   Modifies module's listeners count and calls `onStartObserving` or `onStopObserving` accordingly.
+   */
+  func modifyListenersCount(_ count: Int) {
+    if count > 0 && listenersCount == 0 {
+      let _ = definition.functions["startObserving"]?.callSync(args: [])
+    } else if count < 0 && listenersCount + count <= 0 {
+      let _ = definition.functions["stopObserving"]?.callSync(args: [])
+    }
+    listenersCount = max(0, listenersCount + count)
+  }
+
   // MARK: Deallocation
 
   deinit {
@@ -68,11 +116,18 @@ public class ModuleHolder {
 
   // MARK: Errors
 
-  struct MethodNotFoundError: CodedError {
-    let methodName: String
+  struct ModuleNotFoundError: CodedError {
+    let moduleName: String
+    var description: String {
+      "Cannot find module `\(moduleName)`"
+    }
+  }
+
+  struct FunctionNotFoundError: CodedError {
+    let functionName: String
     let moduleName: String
     var description: String {
-      "Cannot find method `\(methodName)` in module `\(moduleName)`"
+      "Cannot find function `\(functionName)` in module `\(moduleName)`"
     }
   }
 }

package/ios/Swift/ModuleRegistry.swift

@@ -1,5 +1,5 @@
 
-public class ModuleRegistry: Sequence {
+public final class ModuleRegistry: Sequence {
   public typealias Element = ModuleHolder
 
   private weak var appContext: AppContext?
@@ -11,23 +11,30 @@ public class ModuleRegistry: Sequence {
   }
 
   /**
-   Registers a single module in the registry.
+   Registers an instance of module holder.
    */
-  public func register(module: AnyModule) {
-    let holder = ModuleHolder(module: module)
+  internal func register(holder: ModuleHolder) {
     registry[holder.name] = holder
   }
 
   /**
-   Registers modules exported by given modules provider.
+   Registers a module by its type.
    */
-  public func register(fromProvider provider: ModulesProviderProtocol) {
+  public func register(moduleType: AnyModule.Type) {
     guard let appContext = appContext else {
-      // TODO: (@tsapeta) App context is deallocated, throw an error?
       return
     }
+    let module = moduleType.init(appContext: appContext)
+    let holder = ModuleHolder(appContext: appContext, module: module)
+    register(holder: holder)
+  }
+
+  /**
+   Registers modules exported by given modules provider.
+   */
+  public func register(fromProvider provider: ModulesProviderProtocol) {
     provider.getModuleClasses().forEach { moduleType in
-      register(module: moduleType.init(appContext: appContext))
+      register(moduleType: moduleType)
     }
   }
 
@@ -40,6 +47,10 @@ public class ModuleRegistry: Sequence {
     }
   }
 
+  public func unregister(moduleName: String) {
+    registry[moduleName] = nil
+  }
+
   public func has(moduleWithName moduleName: String) -> Bool {
     return registry[moduleName] != nil
   }