expo-modules-core 0.9.2 → 0.11.1

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
   )

package/ios/Swift/Functions/SyncFunctionComponent.swift

@@ -1,17 +1,92 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
+/**
+ Type-erased protocol for synchronous functions.
+ */
+internal protocol AnySyncFunctionComponent: AnyFunction {
+  /**
+   Calls the function synchronously with given arguments.
+   - 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. The arguments must be of the same type as in the underlying closure.
+   - Returns: A value returned by the called function when succeeded or an error when it failed.
+   */
+  func call(by owner: AnyObject?, withArguments args: [Any]) throws -> Any
+}
+
 /**
  Represents a function that can only be called synchronously.
- - ToDo: Move some synchronous logic from `ConcreteFunction` (like `call(args:)`) to this class and drop the `isAsync` property.
  */
-internal final class SyncFunctionComponent<Args, ReturnType>: ConcreteFunction<Args, ReturnType> {
-  override init(
+public final class SyncFunctionComponent<Args, FirstArgType, ReturnType>: AnySyncFunctionComponent {
+  typealias ClosureType = (Args) throws -> ReturnType
+
+  /**
+   The underlying closure to run when the function is called.
+   */
+  let body: ClosureType
+
+  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 = false
+    self.name = name
+    self.dynamicArgumentTypes = dynamicArgumentTypes
+    self.body = body
+  }
+
+  // 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) -> ()) {
+    do {
+      let result = try call(by: owner, withArguments: args)
+      callback(.success(result))
+    } catch let error as Exception {
+      callback(.failure(error))
+    } catch {
+      callback(.failure(UnexpectedException(error)))
+    }
+  }
+
+  // MARK: - AnySyncFunctionComponent
+
+  func call(by owner: AnyObject?, withArguments args: [Any]) throws -> Any {
+    do {
+      let arguments = concat(
+        arguments: try cast(arguments: args, forFunction: self),
+        withOwner: owner,
+        forFunction: self
+      )
+      let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+      return try body(argumentsTuple)
+    } catch let error as Exception {
+      throw FunctionCallException(name).causedBy(error)
+    } catch {
+      throw UnexpectedException(error)
+    }
+  }
+
+  // MARK: - JavaScriptObjectBuilder
+
+  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+    return runtime.createSyncFunction(name, argsCount: argumentsCount) { [weak self, name] this, args in
+      guard let self = self else {
+        throw NativeFunctionUnavailableException(name)
+      }
+      return try self.call(by: this, withArguments: args)
+    }
   }
 }
 
@@ -21,10 +96,11 @@ internal final class SyncFunctionComponent<Args, ReturnType>: ConcreteFunction<A
 public func Function<R>(
   _ name: String,
   _ closure: @escaping () throws -> R
-) -> AnyFunction {
+) -> SyncFunctionComponent<(), Void, R> {
   return SyncFunctionComponent(
     name,
-    argTypes: [],
+    firstArgType: Void.self,
+    dynamicArgumentTypes: [],
     closure
   )
 }
@@ -35,10 +111,11 @@ public func Function<R>(
 public func Function<R, A0: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0) throws -> R
-) -> AnyFunction {
+) -> SyncFunctionComponent<(A0), A0, R> {
   return SyncFunctionComponent(
     name,
-    argTypes: [ArgumentType(A0.self)],
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self],
     closure
   )
 }
@@ -49,10 +126,11 @@ public func Function<R, A0: AnyArgument>(
 public func Function<R, A0: AnyArgument, A1: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1) throws -> R
-) -> AnyFunction {
+) -> SyncFunctionComponent<(A0, A1), A0, R> {
   return SyncFunctionComponent(
     name,
-    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self, ~A1.self],
     closure
   )
 }
@@ -63,13 +141,14 @@ public func Function<R, A0: AnyArgument, A1: AnyArgument>(
 public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2) throws -> R
-) -> AnyFunction {
+) -> SyncFunctionComponent<(A0, A1, A2), A0, R> {
   return SyncFunctionComponent(
     name,
-    argTypes: [
-      ArgumentType(A0.self),
-      ArgumentType(A1.self),
-      ArgumentType(A2.self)
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self
     ],
     closure
   )
@@ -81,14 +160,15 @@ public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
 public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
   _ name: String,
   _ closure: @escaping (A0, A1, A2, A3) throws -> R
-) -> AnyFunction {
+) -> SyncFunctionComponent<(A0, A1, A2, A3), A0, R> {
   return SyncFunctionComponent(
     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
   )
@@ -100,15 +180,16 @@ public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 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 {
+) -> SyncFunctionComponent<(A0, A1, A2, A3, A4), A0, R> {
   return SyncFunctionComponent(
     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
   )
@@ -120,16 +201,17 @@ public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 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 {
+) -> SyncFunctionComponent<(A0, A1, A2, A3, A4, A5), A0, R> {
   return SyncFunctionComponent(
     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
   )
@@ -141,17 +223,18 @@ public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 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 {
+) -> SyncFunctionComponent<(A0, A1, A2, A3, A4, A5, A6), A0, R> {
   return SyncFunctionComponent(
     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
   )
@@ -163,18 +246,19 @@ public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: A
 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 {
+) -> SyncFunctionComponent<(A0, A1, A2, A3, A4, A5, A6, A7), A0, R> {
   return SyncFunctionComponent(
     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
   )