expo-modules-core 0.9.2 → 0.11.1

package/ios/Swift/DynamicTypes/DynamicArrayType.swift

@@ -0,0 +1,56 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type representing array types. Requires the array's element type
+ for the initialization as it delegates casting to that type for each element in the array.
+ */
+internal struct DynamicArrayType: AnyDynamicType {
+  let elementType: AnyDynamicType
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    if let ArrayType = InnerType.self as? AnyArray.Type {
+      return elementType.equals(ArrayType.getElementDynamicType())
+    }
+    return false
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let arrayType = type as? Self {
+      return arrayType.elementType.equals(elementType)
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) 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 if the generic type is an array type.
+ `Array` is a generic type, so it's impossible to check the inheritance directly.
+ */
+internal protocol AnyArray {
+  /**
+   Exposes the `Element` generic type wrapped by the dynamic type to preserve its metadata.
+   */
+  static func getElementDynamicType() -> AnyDynamicType
+}
+
+/**
+ Extends the `Array` type to expose its generic `Element` as a dynamic type.
+ */
+extension Array: AnyArray {
+  static func getElementDynamicType() -> AnyDynamicType {
+    return DynamicType(Element.self)
+  }
+}

package/ios/Swift/DynamicTypes/DynamicConvertibleType.swift

@@ -0,0 +1,27 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type that wraps any type conforming to `ConvertibleArgument` protocol.
+ */
+internal struct DynamicConvertibleType: AnyDynamicType {
+  let innerType: ConvertibleArgument.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let convertibleType = type as? Self {
+      return convertibleType.innerType == innerType
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    return try innerType.convert(from: value)
+  }
+
+  var description: String {
+    String(describing: innerType.self)
+  }
+}

package/ios/Swift/DynamicTypes/DynamicEnumType.swift

@@ -0,0 +1,27 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type representing an enum that conforms to `EnumArgument`.
+ */
+internal struct DynamicEnumType: AnyDynamicType {
+  let innerType: EnumArgument.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let enumType = type as? Self {
+      return enumType.innerType == innerType
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    return try innerType.create(fromRawValue: value)
+  }
+
+  var description: String {
+    "Enum<\(innerType)>"
+  }
+}

package/ios/Swift/DynamicTypes/DynamicOptionalType.swift

@@ -0,0 +1,63 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type that represents an optional type, which allows `nil` to be passed when casting.
+ Requires the optional's wrapped type as it delegates casting to that type for non-nil values.
+ */
+internal struct DynamicOptionalType: AnyDynamicType {
+  let wrappedType: AnyDynamicType
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    if let OptionalType = InnerType.self as? AnyOptional.Type {
+      return wrappedType.equals(OptionalType.getWrappedDynamicType())
+    }
+    return false
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let optionalType = type as? Self {
+      return optionalType.wrappedType.equals(wrappedType)
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    if Optional.isNil(value) || value is NSNull {
+      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 AnyOptional {
+  /**
+   Exposes the `Wrapped` generic type wrapped by the dynamic type to preserve its metadata.`
+   */
+  static func getWrappedDynamicType() -> AnyDynamicType
+}
+
+/**
+ Make generic `Optional` implement non-generic `AnyOptional` and add handy check against type-erased `nil`.
+ */
+extension Optional: AnyOptional {
+  static func getWrappedDynamicType() -> AnyDynamicType {
+    return DynamicType(Wrapped.self)
+  }
+
+  static func isNil(_ object: Wrapped) -> Bool {
+    switch object as Any {
+    case Optional<Any>.none:
+      return true
+    default:
+      return false
+    }
+  }
+}

package/ios/Swift/DynamicTypes/DynamicRawType.swift

@@ -0,0 +1,33 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type that can wrap any type, but it casts only type-compatible values using `as?` keyword.
+ The innermost type of the other dynamic types like `ArrayArgumentType` and `OptionalArgumentType`.
+ */
+internal struct DynamicRawType<InnerType>: AnyDynamicType {
+  let innerType: InnerType.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return type == innerType
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    return type is Self
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    if let value = value as? InnerType {
+      return value
+    }
+    // Raw types 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.NullCastException<InnerType>()
+    }
+    throw Conversions.CastingException<InnerType>(value)
+  }
+
+  var description: String {
+    String(describing: innerType.self)
+  }
+}

package/ios/Swift/DynamicTypes/DynamicSharedObjectType.swift

@@ -0,0 +1,37 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A dynamic type representing the `SharedObject` type and its subclasses.
+ */
+internal struct DynamicSharedObjectType: AnyDynamicType {
+  let innerType: SharedObject.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let sharedObjectType = type as? Self {
+      return sharedObjectType.innerType == innerType
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    if let jsObject = try (value as? JavaScriptValue)?.asObject(),
+       let nativeSharedObject = SharedObjectRegistry.toNativeObject(jsObject) {
+      return nativeSharedObject
+    }
+    throw NativeSharedObjectNotFoundException()
+  }
+
+  var description: String {
+    return "SharedObject<\(innerType)>"
+  }
+}
+
+internal final class NativeSharedObjectNotFoundException: Exception {
+  override var reason: String {
+    "Unable to find the native shared object associated with given JavaScript object"
+  }
+}

package/ios/Swift/DynamicTypes/DynamicType.swift

@@ -0,0 +1,39 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+// Function names should start with a lowercase character, but in this one case
+// we want it to be uppercase as we treat it more like a generic class.
+// swiftlint:disable identifier_name
+
+/**
+ Factory creating an instance of the dynamic type wrapper conforming to `AnyDynamicType`.
+ Depending on the given type, it may return one of `DynamicArrayType`, `DynamicOptionalType`, `DynamicConvertibleType`, etc.
+ */
+internal func DynamicType<T>(_ type: T.Type) -> AnyDynamicType {
+  if let ArrayType = T.self as? AnyArray.Type {
+    return DynamicArrayType(elementType: ArrayType.getElementDynamicType())
+  }
+  if let OptionalType = T.self as? AnyOptional.Type {
+    return DynamicOptionalType(wrappedType: OptionalType.getWrappedDynamicType())
+  }
+  if let ConvertibleType = T.self as? ConvertibleArgument.Type {
+    return DynamicConvertibleType(innerType: ConvertibleType)
+  }
+  if let EnumType = T.self as? EnumArgument.Type {
+    return DynamicEnumType(innerType: EnumType)
+  }
+  if let SharedObjectType = T.self as? SharedObject.Type {
+    return DynamicSharedObjectType(innerType: SharedObjectType)
+  }
+  if let TypedArrayType = T.self as? AnyTypedArray.Type {
+    return DynamicTypedArrayType(innerType: TypedArrayType)
+  }
+  return DynamicRawType(innerType: T.self)
+}
+
+/**
+ Handy prefix operator that makes the dynamic type from the static type.
+ */
+prefix operator ~
+public prefix func ~ <T>(type: T.Type) -> AnyDynamicType {
+  return DynamicType(type)
+}

package/ios/Swift/DynamicTypes/DynamicTypedArrayType.swift

@@ -0,0 +1,46 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+internal struct DynamicTypedArrayType: AnyDynamicType {
+  let innerType: AnyTypedArray.Type
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return innerType == InnerType.self
+  }
+
+  func equals(_ type: AnyDynamicType) -> Bool {
+    if let typedArrayType = type as? Self {
+      return typedArrayType.innerType == innerType
+    }
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType) throws -> Any {
+    // It must be a JavaScript typed array.
+    guard let value = value as? JavaScriptValue, let jsTypedArray = value.getTypedArray() else {
+      throw NotTypedArrayException(innerType)
+    }
+    let typedArray = TypedArray.create(from: jsTypedArray)
+
+    // Concrete typed arrays must be the same as the inner type.
+    guard innerType == TypedArray.self || type(of: typedArray) == innerType else {
+      throw ArrayTypeMismatchException((received: type(of: typedArray), expected: innerType))
+    }
+    return typedArray
+  }
+
+  var description: String {
+    return String(describing: innerType)
+  }
+}
+
+internal final class ArrayTypeMismatchException: GenericException<(received: Any.Type, expected: Any.Type)> {
+  override var reason: String {
+    "Received a typed array of type \(param.received), expected \(param.expected)"
+  }
+}
+
+internal final class NotTypedArrayException: GenericException<AnyTypedArray.Type> {
+  override var reason: String {
+    "Given argument is not an instance of \(param)"
+  }
+}

package/ios/Swift/Exceptions/ChainableException.swift

@@ -17,7 +17,7 @@ public protocol ChainableException: Error, AnyObject {
   /**
    Sets the direct cause of the exception and returns itself.
    */
-  func causedBy(_ error: Error) -> Self
+  func causedBy(_ error: Error?) -> Self
 
   /**
    Tells whether any of the cause in chain is of given type.
@@ -34,8 +34,8 @@ public extension ChainableException {
   }
 
   @discardableResult
-  func causedBy(_ error: Error) -> Self {
-    cause = error
+  func causedBy(_ error: Error?) -> Self {
+    cause = error ?? cause
     return self
   }
 

package/ios/Swift/Exceptions/CodedError.swift

@@ -3,7 +3,7 @@ import Foundation
 /**
  A protocol for errors specyfing its `code` and providing the `description`.
  */
-public protocol CodedError: Error {
+public protocol CodedError: Error, CustomStringConvertible {
   var code: String { get }
   var description: String { get }
 }

package/ios/Swift/Exceptions/Exception.swift

@@ -1,9 +1,7 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
 open class Exception: CodedError, ChainableException, CustomStringConvertible, CustomDebugStringConvertible {
-  open var name: String {
-    return String(describing: Self.self)
-  }
+  open lazy var name: String = String(describing: Self.self)
 
   /**
    String describing the reason of the exception.
@@ -25,15 +23,19 @@ open class Exception: CodedError, ChainableException, CustomStringConvertible, C
     self.origin = ExceptionOrigin(file: file, line: line, function: function)
   }
 
+  public init(name: String, description: String, file: String = #fileID, line: UInt = #line, function: String = #function) {
+    self.origin = ExceptionOrigin(file: file, line: line, function: function)
+    self.name = name
+    self.description = description
+  }
+
   // MARK: ChainableException
 
   open var cause: Error?
 
   // MARK: CustomStringConvertible
 
-  open var description: String {
-    return concatDescription(reason, withCause: cause, debug: false)
-  }
+  open lazy var description: String = concatDescription(reason, withCause: cause, debug: false)
 
   // MARK: CustomDebugStringConvertible
 

package/ios/Swift/Exceptions/UnexpectedException.swift

@@ -6,8 +6,9 @@
 public class UnexpectedException: Exception {
   private let errorDescription: String
 
-  public init(_ error: Error) {
+  public init(_ error: Error, file: String = #fileID, line: UInt = #line, function: String = #function) {
     self.errorDescription = error.localizedDescription
+    super.init(file: file, line: line, function: function)
   }
 
   public override var reason: String {

package/ios/Swift/ExpoBridgeModule.m

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(ExpoBridgeModule, NSObject)
+
+@end

package/ios/Swift/ExpoBridgeModule.swift

@@ -0,0 +1,79 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import React
+import Foundation
+
+/**
+ The classic bridge module that is responsible for:
+ - Creating and owning the `AppContext` when the Expo modules architecture is automatically initialized
+   by React Native (as opposed to native unit tests, where React Native is not used at all).
+ - Installing the host object to the runtime.
+ */
+@objc(ExpoBridgeModule)
+public final class ExpoBridgeModule: NSObject, RCTBridgeModule {
+  @objc
+  public let appContext: AppContext
+
+  /**
+   The initializer that is used by React Native when it loads bridge modules.
+   In this scenario, we create an `AppContext` that manages the
+   architecture of Expo modules and the app itself.
+   */
+  override init() {
+    appContext = AppContext()
+    super.init()
+
+    // Listen to React Native notifications posted just before the JS is executed.
+    NotificationCenter.default.addObserver(self,
+                                           selector: #selector(javaScriptWillStartExecutingNotification(_:)),
+                                           name: NSNotification.Name.RCTJavaScriptWillStartExecuting,
+                                           object: nil)
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  // MARK: - RCTBridgeModule
+
+  public static func moduleName() -> String! {
+    return "Expo"
+  }
+
+  public static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  public var bridge: RCTBridge! {
+    didSet {
+      appContext.reactBridge = bridge
+    }
+  }
+  
+  /**
+   This should be called inside EXNativeModulesProxy.setBridge()
+   */
+  @objc
+  public func legacyProxyDidSetBridge(legacyModulesProxy: LegacyNativeModulesProxy,
+                                      legacyModuleRegistry: EXModuleRegistry) {
+    appContext.legacyModuleRegistry = legacyModuleRegistry
+    appContext.legacyModulesProxy = legacyModulesProxy
+    
+    // we need to register all the modules after the legacy module registry is set
+    // otherwise legacy modules (e.g. permissions) won't be available in OnCreate { }
+    appContext.useModulesProvider("ExpoModulesProvider")
+    appContext.moduleRegistry.register(moduleType: NativeModulesProxyModule.self)
+  }
+
+  // MARK: - Notifications
+
+  @objc
+  public func javaScriptWillStartExecutingNotification(_ notification: Notification) {
+    if (notification.object as? RCTBridge)?.batched == bridge {
+      // The JavaScript bundle will start executing in a moment,
+      // so the runtime is already initialized and we can get it from the bridge.
+      // This should automatically install the ExpoModules host object.
+      appContext.runtime = EXJavaScriptRuntimeManager.runtime(fromBridge: bridge)
+    }
+  }
+}

package/ios/Swift/Functions/AnyFunction.swift

@@ -1,57 +1,59 @@
-import Dispatch
+/**
+ An alias to `Result<Any, Exception>` which can be passed to the function callback.
+ */
+public typealias FunctionCallResult = Result<Any, Exception>
 
 /**
  A protocol for any type-erased function.
  */
-public protocol AnyFunction: AnyDefinition {
+internal protocol AnyFunction: AnyDefinition, JavaScriptObjectBuilder {
   /**
    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 }
-
-  /**
-   An array of argument types that the function takes. If the last type is `Promise`, it's not included.
+   An array of the dynamic types that the function takes. If the last type is `Promise`, it's not included.
    */
-  var argumentTypes: [AnyArgumentType] { get }
+  var dynamicArgumentTypes: [AnyDynamicType] { get }
 
   /**
-   A number of arguments the function takes. If the last argument is of type `Promise`, it is not counted.
+   A number of arguments the function takes. If the function expects to receive an owner (`this`) as the first argument, it's not counted.
+   Similarly, 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 }
-
-  /**
-   Whether the function needs to be called asynchronously from JavaScript.
+   Indicates whether the function's arguments starts from the owner that calls this function.
    */
-  var isAsync: Bool { get }
+  var takesOwner: Bool { get set }
 
   /**
-   Calls the function on given module with arguments and a promise.
+   Calls the function with a given owner and arguments and returns a result through the callback block.
+   - Parameters:
+      - owner: An object that calls this function. If the `takesOwner` property is true
+      and type of the first argument matches the owner type, it's being passed as the argument.
+      - args: An array of arguments to pass to the function. They could be Swift primitives
+      when invoked through the bridge and in unit tests or `JavaScriptValue`s
+      when the function is called through the JSI.
+      - callback: A callback that receives a result of the function execution.
    */
-  func call(args: [Any], promise: Promise)
-
-  /**
-   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
+  func call(by owner: AnyObject?, withArguments args: [Any], callback: @escaping (FunctionCallResult) -> ())
+}
 
+extension AnyFunction {
   /**
-   Specifies on which queue the function should run.
+   Calls the function just like `call(by:withArguments:callback:)`, but without an owner
+   and with an empty callback. Might be useful when you only want to call the function,
+   but don't care about the result.
    */
-  func runOnQueue(_ queue: DispatchQueue?) -> Self
+  func call(withArguments args: [Any]) {
+    call(by: nil, withArguments: args, callback: { _ in })
+  }
+}
 
-  /**
-   Makes the JavaScript function synchronous.
-   */
-  func runSynchronously() -> Self
+internal class FunctionCallException: GenericException<String> {
+  override var reason: String {
+    "Calling the '\(param)' function has failed"
+  }
 }