expo-modules-core 0.7.0 → 0.9.1

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,16 +1,14 @@
 import Dispatch
 
-public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
+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?
@@ -19,7 +17,7 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
 
   let closure: ClosureType
 
-  let argTypes: [AnyArgumentType]
+  public let argumentTypes: [AnyArgumentType]
 
   init(
     _ name: String,
@@ -27,23 +25,33 @@ 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 = try closure(tuple)
+      let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+      returnedValue = try closure(argumentsTuple)
     } catch let error as CodedError {
       promise.reject(FunctionCallException(name).causedBy(error))
       return
@@ -56,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: { _ 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 try 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
     }
   }
 
@@ -90,38 +94,6 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
     self.isAsync = false
     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 InvalidArgsNumberException((received: args.count, expected: argumentsCount))
-    }
-    return try args.enumerated().map { index, arg in
-      let expectedType = argumentType(atIndex: index)
-
-      do {
-        // It's safe to unwrap since the arguments count matches.
-        return try expectedType!.cast(arg)
-      } catch {
-        throw ArgumentCastException((index: index, type: expectedType!)).causedBy(error)
-      }
-    }
-  }
-}
-
-internal class InvalidArgsNumberException: GenericException<(received: Int, expected: Int)> {
-  override var reason: String {
-    "Received \(param.received) arguments, but \(param.expected) was expected"
-  }
-}
-
-internal class ArgumentCastException: GenericException<(index: Int, type: AnyArgumentType)> {
-  override var reason: String {
-    "Argument at index '\(param.index)' couldn't be cast to type \(param.type.description)"
-  }
 }
 
 internal class FunctionCallException: GenericException<String> {

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

package/ios/Swift/JavaScriptUtils.swift

@@ -36,6 +36,62 @@ internal func createSyncFunctionBlock(holder: ModuleHolder, name functionName: S
   }
 }
 
+// MARK: - Arguments
+
+/**
+ Tries to cast given argument to the type that is wrapped by the argument type.
+ - Parameters:
+  - argument: A value to be cast. If it's a ``JavaScriptValue``, it's first unpacked to the raw value.
+  - argumentType: Something that implements ``AnyArgumentType`` and knows how to cast the argument.
+ - Returns: A new value converted according to the argument type.
+ - Throws: Rethrows various exceptions that could be thrown by the argument type wrappers.
+ */
+internal func castArgument(_ argument: Any, toType argumentType: AnyArgumentType) throws -> Any {
+  // TODO: Accept JavaScriptValue and JavaScriptObject as argument types.
+  if let argument = argument as? JavaScriptValue {
+    return try argumentType.cast(argument.getRaw())
+  }
+  return try argumentType.cast(argument)
+}
+
+/**
+ Same as ``castArgument(_:argumentType:)`` but for an array of arguments.
+ - Parameters:
+   - arguments: An array of arguments to be cast.
+   - argumentTypes: An array of argument types in the same order as the array of arguments.
+ - Returns: An array of arguments after casting. Its size is the same as the input arrays.
+ - Throws: ``InvalidArgsNumberException`` when the sizes of arrays passed as parameters are not equal.
+   Rethrows exceptions thrown by ``castArgument(_:argumentType:)``.
+ */
+internal func castArguments(_ arguments: [Any], toTypes argumentTypes: [AnyArgumentType]) throws -> [Any] {
+  if arguments.count != argumentTypes.count {
+    throw InvalidArgsNumberException((received: arguments.count, expected: argumentTypes.count))
+  }
+  return try arguments.enumerated().map { index, argument in
+    let argumentType = argumentTypes[index]
+
+    do {
+      return try castArgument(argument, toType: argumentType)
+    } catch {
+      throw ArgumentCastException((index: index, type: argumentType)).causedBy(error)
+    }
+  }
+}
+
+internal class InvalidArgsNumberException: GenericException<(received: Int, expected: Int)> {
+  override var reason: String {
+    "Received \(param.received) arguments, but \(param.expected) was expected"
+  }
+}
+
+internal class ArgumentCastException: GenericException<(index: Int, type: AnyArgumentType)> {
+  override var reason: String {
+    "Argument at index '\(param.index)' couldn't be cast to type \(param.type.description)"
+  }
+}
+
+// MARK: - Exceptions
+
 private class ModuleUnavailableException: GenericException<String> {
   override var reason: String {
     "Module '\(param)' is no longer available"

package/ios/Swift/ModuleHolder.swift

@@ -70,8 +70,15 @@ public final class ModuleHolder {
       }
       let queue = function.queue ?? DispatchQueue.global(qos: .default)
 
+      // Given arguments can be:
+      // - Swift primitives when invoked through the bridge and in unit tests
+      // - `JavaScriptValue`s when the function is called through the JSI
+      // The latter need to be unpacked to Swift primitives on the JS thread,
+      // so we do the casting before the function call is scheduled on the queue.
+      let arguments = try castArguments(args, toTypes: function.argumentTypes)
+
       queue.async {
-        function.call(args: args, promise: promise)
+        function.call(args: arguments, promise: promise)
       }
     } catch let error as CodedError {
       promise.reject(error)
@@ -91,10 +98,15 @@ public final class ModuleHolder {
 
   @discardableResult
   func callSync(function functionName: String, args: [Any]) -> Any? {
-    if let function = definition.functions[functionName] {
-      return function.callSync(args: args)
+    guard let function = definition.functions[functionName] else {
+      return nil
+    }
+    do {
+      let arguments = try castArguments(args, toTypes: function.argumentTypes)
+      return function.callSync(args: arguments)
+    } catch {
+      return error
     }
-    return nil
   }
 
   // MARK: JavaScript Module Object
@@ -113,7 +125,7 @@ public final class ModuleHolder {
 
     // Fill in with constants
     for (key, value) in getConstants() {
-      object[key] = value
+      object.setProperty(key, value: value)
     }
 
     // Fill in with functions