expo-modules-core 0.9.2 → 0.10.0

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,65 @@
+// 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().useModulesProvider("ExpoModulesProvider")
+    appContext.moduleRegistry.register(moduleType: NativeModulesProxyModule.self)
+    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
+    }
+  }
+
+  // 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"
+  }
 }

package/ios/Swift/Functions/AsyncFunctionComponent.swift

@@ -1,31 +1,160 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
+import Dispatch
+
 /**
- Represents a function that can only be called asynchronously, thus its JavaScript equivalent returns a Promise.
+ Type-erased protocol for asynchronous functions.
+ */
+internal protocol AnyAsyncFunctionComponent: AnyFunction {
+  /**
+   Specifies on which queue the function should run.
+   */
+  func runOnQueue(_ queue: DispatchQueue?) -> Self
+}
 
- - ToDo: Move some asynchronous logic from `ConcreteFunction` (like `call(args:promise:)`) to this class and drop the `isAsync` property.
+/**
+ Represents a function that can only be called asynchronously, thus its JavaScript equivalent returns a Promise.
  */
-internal final class AsyncFunctionComponent<Args, ReturnType>: ConcreteFunction<Args, ReturnType> {
-  override init(
+public final class AsyncFunctionComponent<Args, FirstArgType, ReturnType>: AnyAsyncFunctionComponent {
+  typealias ClosureType = (Args) throws -> ReturnType
+
+  /**
+   The underlying closure to run when the function is called.
+   */
+  let body: ClosureType
+
+  /**
+   Bool value indicating whether the function takes promise as the last argument.
+   */
+  let takesPromise: Bool
+
+  /**
+   Dispatch queue on which each function's call is run.
+   */
+  var queue: DispatchQueue?
+
+  init(
     _ name: String,
-    argTypes: [AnyArgumentType],
-    _ closure: @escaping ConcreteFunction<Args, ReturnType>.ClosureType
+    firstArgType: FirstArgType.Type,
+    dynamicArgumentTypes: [AnyDynamicType],
+    _ body: @escaping ClosureType
   ) {
-    super.init(name, argTypes: argTypes, closure)
-    self.isAsync = true
+    self.name = name
+    self.takesPromise = dynamicArgumentTypes.last?.wraps(Promise.self) ?? false
+    self.body = body
+
+    // Drop the last argument type if it's the `Promise`.
+    self.dynamicArgumentTypes = takesPromise ? dynamicArgumentTypes.dropLast(1) : dynamicArgumentTypes
+  }
+
+  // MARK: - AnyFunction
+
+  let name: String
+
+  let dynamicArgumentTypes: [AnyDynamicType]
+
+  var argumentsCount: Int {
+    return dynamicArgumentTypes.count - (takesOwner ? 1 : 0)
+  }
+
+  var takesOwner: Bool = false
+
+  func call(by owner: AnyObject?, withArguments args: [Any], callback: @escaping (FunctionCallResult) -> ()) {
+    let promise = Promise { value in
+      callback(.success(value as Any))
+    } rejecter: { exception in
+      callback(.failure(exception))
+    }
+    var arguments: [Any] = []
+
+    do {
+      arguments = concat(
+        arguments: try cast(arguments: args, forFunction: self),
+        withOwner: owner,
+        forFunction: self
+      )
+    } catch let error as Exception {
+      callback(.failure(error))
+      return
+    } catch {
+      callback(.failure(UnexpectedException(error)))
+      return
+    }
+
+    // Add promise to the array of arguments if necessary.
+    if takesPromise {
+      arguments.append(promise)
+    }
+
+    let queue = queue ?? DispatchQueue.global(qos: .default)
+
+    queue.async { [body, name] in
+      let returnedValue: ReturnType?
+
+      do {
+        let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+        returnedValue = try body(argumentsTuple)
+      } catch let error as Exception {
+        promise.reject(FunctionCallException(name).causedBy(error))
+        return
+      } catch {
+        promise.reject(UnexpectedException(error))
+        return
+      }
+      if !self.takesPromise {
+        promise.resolve(returnedValue)
+      }
+    }
+  }
+
+  // MARK: - JavaScriptObjectBuilder
+
+  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+    return runtime.createAsyncFunction(name, argsCount: argumentsCount) { [weak self, name] this, args, resolve, reject in
+      guard let self = self else {
+        let exception = NativeFunctionUnavailableException(name)
+        return reject(exception.code, exception.description, nil)
+      }
+      self.call(by: this, withArguments: args) { result in
+        switch result {
+        case .failure(let error):
+          reject(error.code, error.description, nil)
+        case .success(let value):
+          resolve(value)
+        }
+      }
+    }
+  }
+
+  // MARK: - AnyAsyncFunctionComponent
+
+  public func runOnQueue(_ queue: DispatchQueue?) -> Self {
+    self.queue = queue
+    return self
+  }
+}
+
+// MARK: - Exceptions
+
+internal final class NativeFunctionUnavailableException: GenericException<String> {
+  override var reason: String {
+    return "Native function '\(param)' is no longer available in memory"
   }
 }
 
+// MARK: - Factories
+
 /**
  Asynchronous function without arguments.
  */
 public func AsyncFunction<R>(
   _ name: String,
   _ closure: @escaping () throws -> R
-) -> AnyFunction {
+) -> AsyncFunctionComponent<(), Void, R> {
   return AsyncFunctionComponent(
     name,
-    argTypes: [],
+    firstArgType: Void.self,
+    dynamicArgumentTypes: [],
     closure
   )
 }
@@ -36,10 +165,11 @@ public func AsyncFunction<R>(
 public func AsyncFunction<R, A0: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0) throws -> R
-) -> AnyFunction {
+) -> AsyncFunctionComponent<(A0), A0, R> {
   return AsyncFunctionComponent(
     name,
-    argTypes: [ArgumentType(A0.self)],
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self],
     closure
   )
 }
@@ -50,10 +180,11 @@ public func AsyncFunction<R, A0: AnyArgument>(
 public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1) throws -> R
-) -> AnyFunction {
+) -> AsyncFunctionComponent<(A0, A1), A0, R> {
   return AsyncFunctionComponent(
     name,
-    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self, ~A1.self],
     closure
   )
 }
@@ -64,13 +195,14 @@ public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
 public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2) throws -> R
-) -> AnyFunction {
+) -> AsyncFunctionComponent<(A0, A1, A2), A0, R> {
   return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self
     ],
     closure
   )
@@ -82,14 +214,15 @@ public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
 public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2, A3) throws -> R
-) -> AnyFunction {
+) -> AsyncFunctionComponent<(A0, A1, A2, A3), A0, R> {
   return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self),
-      ArgumentType(A3.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self
     ],
     closure
   )
@@ -101,15 +234,16 @@ public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument,
 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 {
+) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4), A0, R> {
   return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self),
-      ArgumentType(A3.self),
-      ArgumentType(A4.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self
     ],
     closure
   )
@@ -121,16 +255,17 @@ public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument,
 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 {
+) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4, A5), A0, R> {
   return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self),
-      ArgumentType(A3.self),
-      ArgumentType(A4.self),
-      ArgumentType(A5.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self
     ],
     closure
   )
@@ -142,17 +277,18 @@ public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument,
 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 {
+) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4, A5, A6), A0, R> {
   return AsyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self),
-      ArgumentType(A3.self),
-      ArgumentType(A4.self),
-      ArgumentType(A5.self),
-      ArgumentType(A6.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self
     ],
     closure
   )
@@ -164,18 +300,19 @@ public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument,
 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 {
+) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4, A5, A6, A7), A0, R> {
   return AsyncFunctionComponent(
     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)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self,
+      ~A7.self
     ],
     closure
   )