expo-modules-core 0.4.9 → 0.6.2

package/ios/Services/EXReactNativeEventEmitter.m

@@ -4,6 +4,7 @@
 #import <ExpoModulesCore/EXEventEmitter.h>
 #import <ExpoModulesCore/EXExportedModule.h>
 #import <ExpoModulesCore/EXModuleRegistry.h>
+#import <ExpoModulesCore/Swift.h>
 
 @interface EXReactNativeEventEmitter ()
 
@@ -42,6 +43,10 @@
 - (NSArray<NSString *> *)supportedEvents
 {
   NSMutableSet<NSString *> *eventsAccumulator = [NSMutableSet set];
+
+  if (_swiftInteropBridge) {
+    [eventsAccumulator addObjectsFromArray:[_swiftInteropBridge getSupportedEvents]];
+  }
   for (EXExportedModule *exportedModule in [_exModuleRegistry getAllExportedModules]) {
     if ([exportedModule conformsToProtocol:@protocol(EXEventEmitter)]) {
       id<EXEventEmitter> eventEmitter = (id<EXEventEmitter>)exportedModule;
@@ -54,6 +59,11 @@
 RCT_EXPORT_METHOD(addProxiedListener:(NSString *)moduleName eventName:(NSString *)eventName)
 {
   [self addListener:eventName];
+
+  if ([_swiftInteropBridge hasModule:moduleName]) {
+    [_swiftInteropBridge modifyEventListenersCount:moduleName count:1];
+    return;
+  }
   // Validate module
   EXExportedModule *module = [_exModuleRegistry getExportedModuleForName:moduleName];
 
@@ -90,6 +100,11 @@ RCT_EXPORT_METHOD(addProxiedListener:(NSString *)moduleName eventName:(NSString
 RCT_EXPORT_METHOD(removeProxiedListeners:(NSString *)moduleName count:(double)count)
 {
   [self removeListeners:count];
+
+  if ([_swiftInteropBridge hasModule:moduleName]) {
+    [_swiftInteropBridge modifyEventListenersCount:moduleName count:-count];
+    return;
+  }
   // Validate module
   EXExportedModule *module = [_exModuleRegistry getExportedModuleForName:moduleName];
 

package/ios/Swift/AppContext.swift

@@ -2,7 +2,7 @@ import UIKit
 /**
  The app context is an interface to a single Expo app.
  */
-public class AppContext {
+public final class AppContext {
   /**
    The module registry for the app context.
    */
@@ -71,6 +71,13 @@ public class AppContext {
     return legacyModule(implementing: EXUtilitiesInterface.self)
   }
 
+  /**
+   Provides access to the event emitter from legacy module registry.
+   */
+  public var eventEmitter: EXEventEmitterService? {
+    return legacyModule(implementing: EXEventEmitterService.self)
+  }
+
   /**
    Starts listening to `UIApplication` notifications.
    */
@@ -108,4 +115,10 @@ public class AppContext {
     NotificationCenter.default.removeObserver(self)
     moduleRegistry.post(event: .appContextDestroys)
   }
+
+  // MARK: Errors
+
+  struct DeallocatedAppContextError: CodedError {
+    var description: String = "The app context has been deallocated."
+  }
 }

package/ios/Swift/Arguments/AnyArgument.swift

@@ -0,0 +1,14 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A protocol for classes/structs accepted as an argument of functions.
+ */
+public protocol AnyArgument {}
+
+// Extend the primitive types — these may come from React Native bridge.
+extension Bool: AnyArgument {}
+extension Int: AnyArgument {}
+extension Double: AnyArgument {}
+extension String: AnyArgument {}
+extension Array: AnyArgument {}
+extension Dictionary: AnyArgument {}

package/ios/Swift/Arguments/AnyArgumentType.swift

@@ -0,0 +1,13 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A protocol whose intention is to wrap function's argument type
+ to keep its real signature and not type-erase it by the compiler.
+ */
+internal protocol AnyArgumentType: CustomStringConvertible {
+  /**
+   Casts given any value to the wrapped type and returns as `Any`.
+   NOTE: It may not be just simple type-casting (e.g. when the wrapped type conforms to `ConvertibleArgument`).
+   */
+  func cast<ArgType>(_ value: ArgType) throws -> Any
+}

package/ios/Swift/Arguments/ArgumentType.swift

@@ -0,0 +1,24 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ Factory creating an instance of the argument type wrapper conforming to `AnyArgumentType`.
+ Depending on the given type, it may return one of `ArrayArgumentType`, `OptionalArgumentType`, `ConvertibleArgumentType`, etc.
+ */
+internal func ArgumentType<T>(_ type: T.Type) -> AnyArgumentType {
+  if let ArrayType = T.self as? AnyArrayArgument.Type {
+    return ArrayArgumentType(elementType: ArrayType.getElementArgumentType())
+  }
+  if let OptionalType = T.self as? AnyOptionalArgument.Type {
+    return OptionalArgumentType(wrappedType: OptionalType.getWrappedArgumentType())
+  }
+  if let ConvertibleType = T.self as? ConvertibleArgument.Type {
+    return ConvertibleArgumentType(innerType: ConvertibleType)
+  }
+  if let EnumType = T.self as? EnumArgument.Type {
+    return EnumArgumentType(innerType: EnumType)
+  }
+  if T.self is Promise.Type {
+    return PromiseArgumentType()
+  }
+  return RawArgumentType(innerType: T.self)
+}

package/ios/Swift/Arguments/ConvertibleArgument.swift

@@ -0,0 +1,15 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+/**
+ A protocol that allows custom classes or structs to be used as function arguments.
+ It requires static `convert(from:)` function that knows how to convert incoming
+ value of `Any` type to the type implemented by this protocol. It should throw an error
+ when the value is not recognized, is invalid or doesn't meet type requirements.
+ */
+public protocol ConvertibleArgument: AnyArgument {
+  /**
+   Converts any value to the instance of its class (or struct).
+   Throws an error when given value cannot be converted.
+   */
+  static func convert(from value: Any?) throws -> Self
+}

package/ios/Swift/Arguments/Convertibles.swift

@@ -0,0 +1,107 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+import UIKit
+import CoreGraphics
+
+/// Here we extend some common iOS types to implement `ConvertibleArgument` protocol and
+/// describe how they can be converted from primitive types received from JavaScript runtime.
+/// This allows these types to be used as argument types of functions callable from JavaScript.
+/// As an example, when the `CGPoint` type is used as an argument type, its instance can be
+/// created from an array of two doubles or an object with `x` and `y` fields.
+
+// MARK: - Foundation
+
+extension URL: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> Self {
+    if let uri = value as? String, let url = URL(string: uri) {
+      // `URL(string:)` is an optional init but it doesn't imply it's a valid URL,
+      // so here we don't check for the correctness of the URL.
+      // If it has no scheme, we assume it was the file path.
+      return url.scheme != nil ? url : URL(fileURLWithPath: uri)
+    }
+    throw Conversions.ConvertingError<URL>(value: value)
+  }
+}
+
+// MARK: - UIKit
+
+extension UIColor: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> Self {
+    if let value = value as? String {
+      return try Conversions.toColor(hexString: value) as! Self
+    }
+    if let components = value as? [Double] {
+      let alpha = components.count > 3 ? components[3] : 1.0
+      return Self.init(red: CGFloat(components[0]), green: CGFloat(components[1]), blue: CGFloat(components[2]), alpha: CGFloat(alpha))
+    }
+    if let value = value as? Int {
+      return try Conversions.toColor(argb: UInt64(value)) as! Self
+    }
+    throw Conversions.ConvertingError<UIColor>(value: value)
+  }
+}
+
+// MARK: - CoreGraphics
+
+extension CGPoint: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> CGPoint {
+    if let value = value as? [Double], value.count == 2 {
+      return CGPoint(x: value[0], y: value[1])
+    }
+    if let value = value as? [String: Any] {
+      let args = try Conversions.pickValues(from: value, byKeys: ["x", "y"], as: Double.self)
+      return CGPoint(x: args[0], y: args[1])
+    }
+    throw Conversions.ConvertingError<CGPoint>(value: value)
+  }
+}
+
+extension CGSize: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> CGSize {
+    if let value = value as? [Double], value.count == 2 {
+      return CGSize(width: value[0], height: value[1])
+    }
+    if let value = value as? [String: Any] {
+      let args = try Conversions.pickValues(from: value, byKeys: ["width", "height"], as: Double.self)
+      return CGSize(width: args[0], height: args[1])
+    }
+    throw Conversions.ConvertingError<CGSize>(value: value)
+  }
+}
+
+extension CGVector: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> CGVector {
+    if let value = value as? [Double], value.count == 2 {
+      return CGVector(dx: value[0], dy: value[1])
+    }
+    if let value = value as? [String: Any] {
+      let args = try Conversions.pickValues(from: value, byKeys: ["dx", "dy"], as: Double.self)
+      return CGVector(dx: args[0], dy: args[1])
+    }
+    throw Conversions.ConvertingError<CGVector>(value: value)
+  }
+}
+
+extension CGRect: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> CGRect {
+    if let value = value as? [Double], value.count == 4 {
+      return CGRect(x: value[0], y: value[1], width: value[2], height: value[3])
+    }
+    if let value = value as? [String: Any] {
+      let args = try Conversions.pickValues(from: value, byKeys: ["x", "y", "width", "height"], as: Double.self)
+      return CGRect(x: args[0], y: args[1], width: args[2], height: args[3])
+    }
+    throw Conversions.ConvertingError<CGRect>(value: value)
+  }
+}
+
+extension CGColor: ConvertibleArgument {
+  public static func convert(from value: Any?) throws -> Self {
+    do {
+      return try UIColor.convert(from: value).cgColor as! Self
+    } catch _ as Conversions.ConvertingError<UIColor> {
+      // Rethrow `ConvertingError` with proper type
+      throw Conversions.ConvertingError<CGColor>(value: value)
+    }
+  }
+}

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

@@ -0,0 +1,42 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type representing array types. Requires the argument type for
+ array's element type as it delegates casting to that type for each element in the array.
+ */
+internal struct ArrayArgumentType: AnyArgumentType {
+  let elementType: AnyArgumentType
+
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    if let value = value as? [Any] {
+      return try value.map { try elementType.cast($0) }
+    }
+    // We should probably throw an error if we get here. On the other side, the array type
+    // requirement can be more loosen so we can try to arrayize values that are not arrays.
+    return [try elementType.cast(value)]
+  }
+
+  var description: String {
+    "[\(elementType.description)]"
+  }
+}
+
+/**
+ A type-erased protocol used to recognize arrays with elements of argument-compatible type.
+ `Array` is a generic type, so it's impossible to check the inheritance directly.
+ */
+internal protocol AnyArrayArgument: AnyArgument {
+  /**
+   Exposes the `Element` generic type wrapped by the argument type to preserve its metadata.
+   */
+  static func getElementArgumentType() -> AnyArgumentType
+}
+
+/**
+ Extends the `Array` type to expose its generic `Element` as an argument type.
+ */
+extension Array: AnyArrayArgument where Element: AnyArgument {
+  static func getElementArgumentType() -> AnyArgumentType {
+    return ArgumentType(Element.self)
+  }
+}

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

@@ -0,0 +1,16 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type that wraps any type conforming to `ConvertibleArgument` protocol.
+ */
+internal struct ConvertibleArgumentType: AnyArgumentType {
+  let innerType: ConvertibleArgument.Type
+
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    return try innerType.convert(from: value)
+  }
+
+  var description: String {
+    String(describing: innerType.self)
+  }
+}

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

@@ -0,0 +1,105 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type representing an enum that conforms to `EnumArgument`.
+ */
+internal struct EnumArgumentType: AnyArgumentType {
+  let innerType: EnumArgument.Type
+
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    return try innerType.create(fromRawValue: value)
+  }
+
+  var description: String {
+    "Enum<\(innerType)>"
+  }
+}
+
+/**
+ A protocol that allows converting raw values to enum cases.
+ */
+public protocol EnumArgument: AnyArgument {
+  /**
+   Tries to create an enum case using given raw value.
+   May throw errors, e.g. when the raw value doesn't match any case.
+   */
+  static func create<ArgType>(fromRawValue rawValue: ArgType) throws -> Self
+
+  /**
+   Returns an array of all raw values available in the enum.
+   */
+  static var allRawValues: [Any] { get }
+
+  /**
+   Type-erased enum's raw value.
+   */
+  var anyRawValue: Any { get }
+}
+
+/**
+ Extension for `EnumArgument` that also conforms to `RawRepresentable`.
+ This constraint allows us to reference the associated `RawValue` type.
+ */
+public extension EnumArgument where Self: RawRepresentable, Self: Hashable {
+  static func create<ArgType>(fromRawValue rawValue: ArgType) throws -> Self {
+    guard let rawValue = rawValue as? RawValue else {
+      throw EnumCastingError(type: RawValue.self, value: rawValue)
+    }
+    guard let enumCase = Self.init(rawValue: rawValue) else {
+      throw EnumNoSuchValueError(type: Self.self, value: rawValue)
+    }
+    return enumCase
+  }
+
+  var anyRawValue: Any {
+    rawValue
+  }
+
+  static var allRawValues: [Any] {
+    // Be careful — it operates on unsafe pointers!
+    let sequence = AnySequence { () -> AnyIterator<RawValue> in
+      var raw = 0
+      return AnyIterator {
+        let current: Self? = withUnsafePointer(to: &raw) { ptr in
+          ptr.withMemoryRebound(to: Self.self, capacity: 1) { $0.pointee }
+        }
+        guard let value = current?.rawValue else {
+          return nil
+        }
+        raw += 1
+        return value
+      }
+    }
+    return Array(sequence)
+  }
+}
+
+/**
+ An error that is thrown when the value cannot be casted to associated `RawValue`.
+ */
+internal struct EnumCastingError: CodedError {
+  let type: Any.Type
+  let value: Any
+
+  var description: String {
+    "Cannot cast value `\(value)` to expected type `\(type)`"
+  }
+}
+
+/**
+ An error that is thrown when the value doesn't match any available case.
+ */
+internal struct EnumNoSuchValueError: CodedError {
+  let type: EnumArgument.Type
+  let value: Any
+
+  var allRawValuesFormatted: String {
+    return type.allRawValues
+      .map { "`\($0)`" }
+      .joined(separator: ", ")
+  }
+
+  var description: String {
+    "Cannot create `\(type)` enum from value `\(value)`. It must be one of: \(allRawValuesFormatted)"
+  }
+}

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

@@ -0,0 +1,49 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ An argument type that represents an optional type, which allows `nil` to be passed when casting.
+ Requires the argument type for optional's unwrapped type as it delegates casting to that type for non-nil values.
+ */
+internal struct OptionalArgumentType: AnyArgumentType {
+  let wrappedType: AnyArgumentType
+
+  func cast<ArgType>(_ value: ArgType) throws -> Any {
+    if Optional.isNil(value) {
+      return Optional<Any>.none as Any
+    }
+    return try wrappedType.cast(value)
+  }
+
+  var description: String {
+    "\(wrappedType)?"
+  }
+}
+
+/**
+ A type-erased protocol used to recognize if the generic type is an optional type.
+ `Optional` is a generic enum, so it's impossible to check the inheritance directly.
+ */
+internal protocol AnyOptionalArgument: AnyArgument {
+  /**
+   Exposes the `Wrapped` generic type wrapped by the argument type to preserve its metadata.`
+   */
+  static func getWrappedArgumentType() -> AnyArgumentType
+}
+
+/**
+ Make generic `Optional` implement non-generic `AnyOptional` and add handy check against type-erased `nil`.
+ */
+extension Optional: AnyOptionalArgument {
+  static func getWrappedArgumentType() -> AnyArgumentType {
+    return ArgumentType(Wrapped.self)
+  }
+
+  static func isNil(_ object: Wrapped) -> Bool {
+    switch object as Any {
+    case Optional<Any>.none:
+      return true
+    default:
+      return false
+    }
+  }
+}

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)
+  }
+}