expo-modules-core 0.6.5 → 0.9.0

package/ios/Swift/Exceptions/ExceptionOrigin.swift

@@ -0,0 +1,28 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Represents the place in code where the exception was created.
+ */
+public struct ExceptionOrigin: CustomStringConvertible {
+  /**
+   The path to the file in which the exception was created.
+   */
+  let file: String
+
+  /**
+   The line number on which the exception was created.
+   */
+  let line: UInt
+
+  /**
+   The name (selector) of the declaration in which the exception was created.
+   */
+  let function: String
+
+  /**
+   Stringified representation of the exception origin.
+   */
+  public var description: String {
+    "at \(file):\(line) in \(function)"
+  }
+}

package/ios/Swift/Exceptions/GenericException.swift

@@ -0,0 +1,20 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ The exception that needs some additional parameters to be best described.
+ */
+open class GenericException<ParamType>: Exception {
+  /**
+   The additional parameter passed to the initializer.
+   */
+  public let param: ParamType
+
+  /**
+   The default initializer that takes a param and captures the place in the code where the exception was created.
+   - Warning: Call it only with one argument! If you need to pass more parameters, use a tuple instead.
+   */
+  public init(_ param: ParamType, file: String = #fileID, line: UInt = #line, function: String = #function) {
+    self.param = param
+    super.init(file: file, line: line, function: function)
+  }
+}

package/ios/Swift/Exceptions/UnexpectedException.swift

@@ -0,0 +1,16 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Exception wrapper used to handle unexpected internal native errors.
+ */
+public class UnexpectedException: Exception {
+  private let errorDescription: String
+
+  public init(_ error: Error) {
+    self.errorDescription = error.localizedDescription
+  }
+
+  public override var reason: String {
+    return errorDescription
+  }
+}

package/ios/Swift/Functions/AnyFunction.swift

@@ -14,6 +14,11 @@ public protocol AnyFunction: AnyDefinition {
    */
   var takesPromise: Bool { get }
 
+  /**
+   An array of argument types that the function takes. If the last type is `Promise`, it's not included.
+   */
+  var argumentTypes: [AnyArgumentType] { get }
+
   /**
    A number of arguments the function takes. If the last argument is of type `Promise`, it is not counted.
    */
@@ -24,10 +29,15 @@ public protocol AnyFunction: AnyDefinition {
    */
   var queue: DispatchQueue? { get }
 
+  /**
+   Whether the function needs to be called asynchronously from JavaScript.
+   */
+  var isAsync: Bool { get }
+
   /**
    Calls the function on given module with arguments and a promise.
    */
-  func call(args: [Any], promise: Promise) -> Void
+  func call(args: [Any], promise: Promise)
 
   /**
    Synchronously calls the function with given arguments. If the function takes a promise,
@@ -39,4 +49,9 @@ public protocol AnyFunction: AnyDefinition {
    Specifies on which queue the function should run.
    */
   func runOnQueue(_ queue: DispatchQueue?) -> Self
+
+  /**
+   Makes the JavaScript function synchronous.
+   */
+  func runSynchronously() -> Self
 }

package/ios/Swift/Functions/AsyncFunctionComponent.swift

@@ -0,0 +1,182 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Represents a function that can only be called asynchronously, thus its JavaScript equivalent returns a Promise.
+
+ - ToDo: Move some asynchronous logic from `ConcreteFunction` (like `call(args:promise:)`) to this class and drop the `isAsync` property.
+ */
+internal final class AsyncFunctionComponent<Args, ReturnType>: ConcreteFunction<Args, ReturnType> {
+  override init(
+    _ name: String,
+    argTypes: [AnyArgumentType],
+    _ closure: @escaping ConcreteFunction<Args, ReturnType>.ClosureType
+  ) {
+    super.init(name, argTypes: argTypes, closure)
+    self.isAsync = true
+  }
+}
+
+/**
+ Asynchronous function without arguments.
+ */
+public func AsyncFunction<R>(
+  _ name: String,
+  _ closure: @escaping () throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with one argument.
+ */
+public func AsyncFunction<R, A0: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [ArgumentType(A0.self)],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with two arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with three arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with four arguments.
+ */
+public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3) throws -> R
+) -> AnyFunction {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with five arguments.
+ */
+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 {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with six arguments.
+ */
+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 {
+  return AsyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with seven arguments.
+ */
+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 {
+  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)
+    ],
+    closure
+  )
+}
+
+/**
+ Asynchronous function with eight arguments.
+ */
+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 {
+  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)
+    ],
+    closure
+  )
+}

package/ios/Swift/Functions/ConcreteFunction.swift

@@ -1,23 +1,23 @@
 import Dispatch
 
-public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
-  public typealias ClosureType = (Args) -> ReturnType
+public class ConcreteFunction<Args, ReturnType>: AnyFunction {
+  public typealias ClosureType = (Args) throws -> ReturnType
 
   public let name: String
 
-  public var takesPromise: Bool {
-    return argTypes.last is PromiseArgumentType
-  }
+  public var takesPromise: Bool
 
   public var argumentsCount: Int {
-    return argTypes.count - (takesPromise ? 1 : 0)
+    return argumentTypes.count
   }
 
   public var queue: DispatchQueue?
 
+  public var isAsync: Bool = true
+
   let closure: ClosureType
 
-  let argTypes: [AnyArgumentType]
+  public let argumentTypes: [AnyArgumentType]
 
   init(
     _ name: String,
@@ -25,28 +25,38 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
     _ closure: @escaping ClosureType
   ) {
     self.name = name
-    self.argTypes = argTypes
+    self.takesPromise = argTypes.last is PromiseArgumentType
     self.closure = closure
+
+    // Drop the last argument type if it's the `Promise`.
+    self.argumentTypes = takesPromise ? argTypes.dropLast(1) : argTypes
+
+    // This is temporary solution to keep backwards compatibility for existing functions — they all end with "Async".
+    // `function` component that we've used so far was async by default, but we decided to replace it with `asyncFunction`
+    // and make `function`s synchronous. Introduced in SDK45, can be removed in SDK46 after migrating all modules.
+    self.isAsync = name.hasSuffix("Async")
   }
 
+  /**
+   Calls the function with given arguments.
+   - Parameters:
+     - args: An array of arguments to pass to the function. The arguments must be of the same type as in the underlying ``closure``.
+     - promise: A promise to resolve or reject by the async ``closure`` when it finishes execution.
+   - ToDo: Make it internal.
+   */
   public func call(args: [Any], promise: Promise) {
-    let takesPromise = self.takesPromise
+    // Add promise to the array of arguments if necessary.
+    let arguments = takesPromise ? args + [promise] : args
     let returnedValue: ReturnType?
 
     do {
-      var finalArgs = try castArguments(args)
-
-      if takesPromise {
-        finalArgs.append(promise)
-      }
-
-      let tuple = try Conversions.toTuple(finalArgs) as! Args
-      returnedValue = closure(tuple)
+      let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+      returnedValue = try closure(argumentsTuple)
     } catch let error as CodedError {
-      promise.reject(error)
+      promise.reject(FunctionCallException(name).causedBy(error))
       return
-    } catch let error {
-      promise.reject(UnexpectedError(error))
+    } catch {
+      promise.reject(UnexpectedException(error))
       return
     }
     if !takesPromise {
@@ -54,28 +64,24 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
     }
   }
 
+  /**
+   Calls the function synchronously with given arguments.
+   - Parameters:
+     - 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.
+   - ToDo: Make it internal.
+   */
   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
-      }
+      // Using `Promise` in the synchronous function is prohibited. Probably should throw an exception here,
+      // but for now let's return nil until we split async and sync functions.
+      return Optional<Any>.none as Any
+    }
+    do {
+      let argumentsTuple = try Conversions.toTuple(args) as! Args
+      return try closure(argumentsTuple)
+    } catch let error {
+      return error
     }
   }
 
@@ -84,27 +90,14 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
     return self
   }
 
-  private func argumentType(atIndex index: Int) -> AnyArgumentType? {
-    return (0..<argTypes.count).contains(index) ? argTypes[index] : nil
-  }
-
-  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
-      let expectedType = argumentType(atIndex: index)
-
-      // It's safe to unwrap since the arguments count matches.
-      return try expectedType!.cast(arg)
-    }
+  public func runSynchronously() -> Self {
+    self.isAsync = false
+    return self
   }
 }
 
-internal struct InvalidArgsNumberError: CodedError {
-  let received: Int
-  let expected: Int
-  var description: String {
-    "Received \(received) arguments, but \(expected) was expected."
+internal class FunctionCallException: GenericException<String> {
+  override var reason: String {
+    "Call to function '\(param)' has been rejected"
   }
 }

package/ios/Swift/Functions/SyncFunctionComponent.swift

@@ -0,0 +1,181 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ 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(
+    _ name: String,
+    argTypes: [AnyArgumentType],
+    _ closure: @escaping ConcreteFunction<Args, ReturnType>.ClosureType
+  ) {
+    super.init(name, argTypes: argTypes, closure)
+    self.isAsync = false
+  }
+}
+
+/**
+ Synchronous function without arguments.
+ */
+public func Function<R>(
+  _ name: String,
+  _ closure: @escaping () throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [],
+    closure
+  )
+}
+
+/**
+ Synchronous function with one argument.
+ */
+public func Function<R, A0: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [ArgumentType(A0.self)],
+    closure
+  )
+}
+
+/**
+ Synchronous function with two arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
+    closure
+  )
+}
+
+/**
+ Synchronous function with three arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with four arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  _ closure: @escaping (A0, A1, A2, A3) throws -> R
+) -> AnyFunction {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with five arguments.
+ */
+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 {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with six arguments.
+ */
+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 {
+  return SyncFunctionComponent(
+    name,
+    argTypes: [
+      ArgumentType(A0.self),
+      ArgumentType(A1.self),
+      ArgumentType(A2.self),
+      ArgumentType(A3.self),
+      ArgumentType(A4.self),
+      ArgumentType(A5.self)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with seven arguments.
+ */
+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 {
+  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)
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with eight arguments.
+ */
+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 {
+  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)
+    ],
+    closure
+  )
+}