expo-modules-core 0.9.2 → 0.10.0

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
   )

package/ios/Swift/JavaScriptUtils.swift

@@ -1,97 +1,72 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
-// FIXME: Calling module's functions needs solid refactoring to not reference the module holder.
-// Instead, it should be possible to directly call the function instance from here. (added by @tsapeta)
-
-/**
- Creates a block that is executed when the module's async function is called.
- */
-internal func createAsyncFunctionBlock(holder: ModuleHolder, name functionName: String) -> JSAsyncFunctionBlock {
-  let moduleName = holder.name
-  return { [weak holder, moduleName] args, resolve, reject in
-    guard let holder = holder else {
-      let exception = ModuleUnavailableException(moduleName)
-      reject(exception.code, exception.description, exception)
-      return
-    }
-    holder.call(function: functionName, args: args) { result, error in
-      if let error = error {
-        reject(error.code, error.description, error)
-      } else {
-        resolve(result)
-      }
-    }
-  }
-}
-
-/**
- Creates a block that is executed when the module's sync function is called.
- */
-internal func createSyncFunctionBlock(holder: ModuleHolder, name functionName: String) -> JSSyncFunctionBlock {
-  return { [weak holder] args in
-    guard let holder = holder else {
-      return nil
-    }
-    return holder.callSync(function: functionName, args: args)
-  }
-}
-
 // MARK: - Arguments
 
 /**
- Tries to cast given argument to the type that is wrapped by the argument type.
+ Tries to cast a given value to the type that is wrapped by the dynamic 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.
+  - value: A value to be cast. If it's a ``JavaScriptValue``, it's first unpacked to the raw value.
+  - type: Something that implements ``AnyDynamicType`` and knows how to cast the argument.
+ - Returns: A new value converted according to the dynamic type.
+ - Throws: Rethrows various exceptions that could be thrown by the dynamic types.
  */
-internal func castArgument(_ argument: Any, toType argumentType: AnyArgumentType) throws -> Any {
+internal func cast(_ value: Any, toType type: AnyDynamicType) throws -> Any {
   // TODO: Accept JavaScriptValue and JavaScriptObject as argument types.
-  if let argument = argument as? JavaScriptValue {
-    return try argumentType.cast(argument.getRaw())
+  if !(type is DynamicTypedArrayType), let value = value as? JavaScriptValue {
+    return try type.cast(value.getRaw())
   }
-  return try argumentType.cast(argument)
+  return try type.cast(value)
 }
 
 /**
- Same as ``castArgument(_:argumentType:)`` but for an array of arguments.
+ Tries to cast the given arguments to the types expected by the function.
  - Parameters:
    - arguments: An array of arguments to be cast.
-   - argumentTypes: An array of argument types in the same order as the array of arguments.
+   - function: A function for which to cast the 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:)``.
+ - Throws: `InvalidArgsNumberException` when the number of arguments is not equal to the actual number
+ of function's arguments (without an owner and promise). Rethrows exceptions thrown by `cast(_:toType:)`.
  */
-internal func castArguments(_ arguments: [Any], toTypes argumentTypes: [AnyArgumentType]) throws -> [Any] {
-  if arguments.count != argumentTypes.count {
-    throw InvalidArgsNumberException((received: arguments.count, expected: argumentTypes.count))
+internal func cast(arguments: [Any], forFunction function: AnyFunction) throws -> [Any] {
+  if arguments.count != function.argumentsCount {
+    throw InvalidArgsNumberException((received: arguments.count, expected: function.argumentsCount))
   }
+  let argumentTypeOffset = function.takesOwner ? 1 : 0
   return try arguments.enumerated().map { index, argument in
-    let argumentType = argumentTypes[index]
+    let argumentType = function.dynamicArgumentTypes[index + argumentTypeOffset]
 
     do {
-      return try castArgument(argument, toType: argumentType)
+      return try cast(argument, toType: argumentType)
     } catch {
       throw ArgumentCastException((index: index, type: argumentType)).causedBy(error)
     }
   }
 }
 
+/**
+ Prepends the owner to the array of arguments if the given function can take it.
+ */
+internal func concat(arguments: [Any], withOwner owner: AnyObject?, forFunction function: AnyFunction) -> [Any] {
+  if function.takesOwner, let owner = try? function.dynamicArgumentTypes.first?.cast(owner) {
+    return [owner] + arguments
+  }
+  return arguments
+}
+
+// MARK: - Exceptions
+
 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)> {
+internal class ArgumentCastException: GenericException<(index: Int, type: AnyDynamicType)> {
   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/Logging/LogHandlers.swift

@@ -0,0 +1,39 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import os.log
+
+/**
+ The protocol that needs to be implemented by log handlers.
+ */
+internal protocol LogHandler {
+  init(category: String)
+
+  func log(type: LogType, _ message: String)
+}
+
+/**
+ The log handler that uses the new `os.Logger` API.
+ */
+@available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
+internal class OSLogHandler: LogHandler {
+  private let osLogger: os.Logger
+
+  required init(category: String) {
+    osLogger = os.Logger(subsystem: "dev.expo.modules", category: category)
+  }
+
+  func log(type: LogType, _ message: String) {
+    osLogger.log(level: type.toOSLogType(), "\(message)")
+  }
+}
+
+/**
+ Simple log handler that forwards all logs to `print` function.
+ */
+internal class PrintLogHandler: LogHandler {
+  required init(category: String) {}
+
+  func log(type: LogType, _ message: String) {
+    print(message)
+  }
+}

package/ios/Swift/Logging/LogType.swift

@@ -0,0 +1,62 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import os.log
+
+/**
+ An enum with available log types.
+ */
+public enum LogType: Int {
+  case trace = 0
+  case timer = 1
+  case stacktrace = 2
+  case debug = 3
+  case info = 4
+  case warn = 5
+  case error = 6
+  case fatal = 7
+
+  /**
+   The string that is used to prefix the messages of this log type.
+   Logs in Xcode and Console apps are always with the white text,
+   so we use colored circle emojis to distinguish different types of logs.
+   */
+  var prefix: String {
+    switch self {
+    case .trace:
+      return "⚪️"
+    case .timer:
+      return "🟤"
+    case .stacktrace:
+      return "🟣"
+    case .debug:
+      return "🔵"
+    case .info:
+      return "🟢"
+    case .warn:
+      return "🟡"
+    case .error:
+      return "🟠"
+    case .fatal:
+      return "🔴"
+    }
+  }
+
+  /**
+   Maps the log types to the log types used by the `os.log` logger.
+   */
+  @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
+  func toOSLogType() -> OSLogType {
+    switch self {
+    case .trace, .timer, .stacktrace, .debug:
+      return .debug
+    case .info:
+      return .info
+    case .warn:
+      return .default
+    case .error:
+      return .error
+    case .fatal:
+      return .fault
+    }
+  }
+}