expo-modules-core 0.6.4 → 0.8.0

package/ios/Swift/Functions/ConcreteFunction.swift

@@ -1,7 +1,7 @@
 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
 
@@ -15,6 +15,8 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
 
   public var queue: DispatchQueue?
 
+  public var isAsync: Bool = true
+
   let closure: ClosureType
 
   let argTypes: [AnyArgumentType]
@@ -27,6 +29,11 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
     self.name = name
     self.argTypes = argTypes
     self.closure = closure
+
+    // 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")
   }
 
   public func call(args: [Any], promise: Promise) {
@@ -41,12 +48,12 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
       }
 
       let tuple = try Conversions.toTuple(finalArgs) as! Args
-      returnedValue = closure(tuple)
+      returnedValue = try closure(tuple)
     } 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 {
@@ -62,7 +69,7 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
       let promise = Promise {
         result = $0
         semaphore.signal()
-      } rejecter: { error in
+      } rejecter: { _ in
         semaphore.signal()
       }
       call(args: args, promise: promise)
@@ -72,7 +79,7 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
       do {
         let finalArgs = try castArguments(args)
         let tuple = try Conversions.toTuple(finalArgs) as! Args
-        return closure(tuple)
+        return try closure(tuple)
       } catch let error {
         return error
       }
@@ -84,27 +91,46 @@ public final class ConcreteFunction<Args, ReturnType>: AnyFunction {
     return self
   }
 
+  public func runSynchronously() -> Self {
+    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 InvalidArgsNumberError(received: args.count, expected: argumentsCount)
+      throw InvalidArgsNumberException((received: args.count, expected: argumentsCount))
     }
-    return try args.enumerated().map { (index, arg) in
+    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)
+      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 struct InvalidArgsNumberError: CodedError {
-  let received: Int
-  let expected: Int
-  var description: String {
-    "Received \(received) arguments, but \(expected) was expected."
+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> {
+  override var reason: String {
+    "Call to function '\(param)' has been rejected"
   }
 }

package/ios/Swift/JavaScriptUtils.swift

@@ -0,0 +1,54 @@
+// 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)
+  }
+}
+
+/**
+ If given argument is a JavaScriptValue, it's unpacked and converted to corresponding Foundation type.
+ Otherwise, the argument is returned as is.
+ */
+internal func unpackIfJavaScriptValue(_ value: Any) -> Any {
+  if let value = value as? JavaScriptValue {
+    return value.getRaw() as Any
+  }
+  return value
+}
+
+private class ModuleUnavailableException: GenericException<String> {
+  override var reason: String {
+    "Module '\(param)' is no longer available"
+  }
+}

package/ios/Swift/ModuleHolder.swift

@@ -14,6 +14,11 @@ public final class ModuleHolder {
    */
   private(set) weak var appContext: AppContext?
 
+  /**
+   JavaScript object that represents the module instance in the runtime.
+   */
+  public internal(set) lazy var javaScriptObject: JavaScriptObject? = createJavaScriptModuleObject()
+
   /**
    Caches the definition of the module type.
    */
@@ -26,6 +31,13 @@ public final class ModuleHolder {
     return definition.name.isEmpty ? String(describing: type(of: module)) : definition.name
   }
 
+  /**
+   Shortcut to get the underlying view manager definition.
+   */
+  var viewManager: ViewManagerDefinition? {
+    return definition.viewManager
+  }
+
   /**
    Number of JavaScript listeners attached to the module.
    */
@@ -54,17 +66,25 @@ public final class ModuleHolder {
   func call(function functionName: String, args: [Any], promise: Promise) {
     do {
       guard let function = definition.functions[functionName] else {
-        throw FunctionNotFoundError(functionName: functionName, moduleName: self.name)
+        throw FunctionNotFoundException((functionName: functionName, moduleName: self.name))
       }
       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 before the function call is scheduled on the queue.
+      // TODO: Move arguments conversion mechanism to JS thread and allow JS types as function arguments.
+      let unpackedArgs = args.map { arg in unpackIfJavaScriptValue(arg) }
+
       queue.async {
-        function.call(args: args, promise: promise)
+        function.call(args: unpackedArgs, promise: promise)
       }
     } catch let error as CodedError {
       promise.reject(error)
     } catch {
-      promise.reject(UnexpectedError(error))
+      promise.reject(UnexpectedException(error))
     }
   }
 
@@ -80,11 +100,44 @@ public final class ModuleHolder {
   @discardableResult
   func callSync(function functionName: String, args: [Any]) -> Any? {
     if let function = definition.functions[functionName] {
-      return function.callSync(args: args)
+      // The comment in `call(function:args:promise)` is partially applicable here as well.
+      // TODO: Move unpacking JS values to `callSync` in function's instance
+      let unpackedArgs = args.map { arg in unpackIfJavaScriptValue(arg) }
+      return function.callSync(args: unpackedArgs)
     }
     return nil
   }
 
+  // MARK: JavaScript Module Object
+
+  /**
+   Creates the JavaScript object that will be used to communicate with the native module.
+   The object is prefilled with module's constants and functions.
+   JavaScript can access it through `global.ExpoModules[moduleName]`.
+   - Note: The object will be `nil` when the runtime is unavailable (e.g. remote debugger is enabled).
+   */
+  private func createJavaScriptModuleObject() -> JavaScriptObject? {
+    // It might be impossible to create any object at the moment (e.g. remote debugging, app context destroyed)
+    guard let object = appContext?.runtime?.createObject() else {
+      return nil
+    }
+
+    // Fill in with constants
+    for (key, value) in getConstants() {
+      object.setProperty(key, value: value)
+    }
+
+    // Fill in with functions
+    for (_, fn) in definition.functions {
+      if fn.isAsync {
+        object.setAsyncFunction(fn.name, argsCount: fn.argumentsCount, block: createAsyncFunctionBlock(holder: self, name: fn.name))
+      } else {
+        object.setSyncFunction(fn.name, argsCount: fn.argumentsCount, block: createSyncFunctionBlock(holder: self, name: fn.name))
+      }
+    }
+    return object
+  }
+
   // MARK: Listening to native events
 
   func listeners(forEvent event: EventName) -> [EventListener] {
@@ -112,9 +165,9 @@ public final class ModuleHolder {
    */
   func modifyListenersCount(_ count: Int) {
     if count > 0 && listenersCount == 0 {
-      let _ = definition.functions["startObserving"]?.callSync(args: [])
+      _ = definition.functions["startObserving"]?.callSync(args: [])
     } else if count < 0 && listenersCount + count <= 0 {
-      let _ = definition.functions["stopObserving"]?.callSync(args: [])
+      _ = definition.functions["stopObserving"]?.callSync(args: [])
     }
     listenersCount = max(0, listenersCount + count)
   }
@@ -125,20 +178,17 @@ public final class ModuleHolder {
     post(event: .moduleDestroy)
   }
 
-  // MARK: Errors
+  // MARK: - Exceptions
 
-  struct ModuleNotFoundError: CodedError {
-    let moduleName: String
-    var description: String {
-      "Cannot find module `\(moduleName)`"
+  internal class ModuleNotFoundException: GenericException<String> {
+    override var reason: String {
+      "Module '\(param)' not found"
     }
   }
 
-  struct FunctionNotFoundError: CodedError {
-    let functionName: String
-    let moduleName: String
-    var description: String {
-      "Cannot find function `\(functionName)` in module `\(moduleName)`"
+  internal class FunctionNotFoundException: GenericException<(functionName: String, moduleName: String)> {
+    override var reason: String {
+      "Function '\(param.functionName)' not found in module '\(param.moduleName)'"
     }
   }
 }

package/ios/Swift/ModuleRegistry.swift

@@ -1,4 +1,3 @@
-
 public final class ModuleRegistry: Sequence {
   public typealias Element = ModuleHolder
 
@@ -63,6 +62,10 @@ public final class ModuleRegistry: Sequence {
     return registry[moduleName]?.module
   }
 
+  public func getModuleNames() -> [String] {
+    return Array(registry.keys)
+  }
+
   public func makeIterator() -> IndexingIterator<[ModuleHolder]> {
     return registry.map({ $1 }).makeIterator()
   }

package/ios/Swift/Modules/AnyModule.swift

@@ -1,4 +1,3 @@
-
 /**
  A protocol for any type-erased module that provides functions used by the core.
  */

package/ios/Swift/Modules/ModuleDefinition.swift

@@ -1,4 +1,3 @@
-
 /**
  A protocol that must be implemented to be a part of module's definition and the module definition itself.
  */
@@ -9,7 +8,7 @@ public protocol AnyDefinition {}
  of the module and what it exports to the JavaScript world.
  See `ModuleDefinitionBuilder` for more details on how to create it.
  */
-public final class ModuleDefinition: AnyDefinition {
+public final class ModuleDefinition: ObjectDefinition {
   /**
    The module's type associated with the definition. It's used to create the module instance.
    */
@@ -20,8 +19,6 @@ public final class ModuleDefinition: AnyDefinition {
    */
   var name: String
 
-  let functions: [String : AnyFunction]
-  let constants: [ConstantsDefinition]
   let eventListeners: [EventListener]
   let viewManager: ViewManagerDefinition?
 
@@ -33,20 +30,12 @@ public final class ModuleDefinition: AnyDefinition {
   /**
    Initializer that is called by the `ModuleDefinitionBuilder` results builder.
    */
-  init(definitions: [AnyDefinition]) {
+  override init(definitions: [AnyDefinition]) {
     self.name = definitions
       .compactMap { $0 as? ModuleNameDefinition }
       .last?
       .name ?? ""
 
-    self.functions = definitions
-      .compactMap { $0 as? AnyFunction }
-      .reduce(into: [String : AnyFunction]()) { dict, function in
-        dict[function.name] = function
-      }
-
-    self.constants = definitions.compactMap { $0 as? ConstantsDefinition }
-
     self.eventListeners = definitions.compactMap { $0 as? EventListener }
 
     self.viewManager = definitions
@@ -58,6 +47,8 @@ public final class ModuleDefinition: AnyDefinition {
         .compactMap { ($0 as? EventsDefinition)?.names }
         .joined()
     )
+
+    super.init(definitions: definitions)
   }
 
   /**

package/ios/Swift/Modules/ModuleDefinitionBuilder.swift

@@ -1,4 +1,3 @@
-
 #if swift(>=5.4)
 /**
  A function builder that provides DSL-like syntax. Thanks to this, the function doesn't need to explicitly return an array,

package/ios/Swift/Modules/ModuleDefinitionComponents.swift

@@ -16,150 +16,6 @@ extension AnyModule {
     return ModuleNameDefinition(name: name)
   }
 
-  // MARK: - Constants
-
-  /**
-   Definition function setting the module's constants to export.
-   */
-  public func constants(_ body: @escaping () -> [String: Any?]) -> AnyDefinition {
-    return ConstantsDefinition(body: body)
-  }
-
-  /**
-   Definition function setting the module's constants to export.
-   */
-  public func constants(_ body: @autoclosure @escaping () -> [String: Any?]) -> AnyDefinition {
-    return ConstantsDefinition(body: body)
-  }
-
-  // MARK: - Functions
-
-  /**
-   Function without arguments.
-   */
-  public func function<R>(
-    _ name: String,
-    _ closure: @escaping () -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [],
-      closure
-    )
-  }
-
-  /**
-   Function with one argument.
-   */
-  public func function<R, A0: AnyArgument>(
-    _ name: String,
-    _ closure: @escaping (A0) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [ArgumentType(A0.self)],
-      closure
-    )
-  }
-
-  /**
-   Function with two arguments.
-   */
-  public func function<R, A0: AnyArgument, A1: AnyArgument>(
-    _ name: String,
-    _ closure: @escaping (A0, A1) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
-      closure
-    )
-  }
-
-  /**
-   Function with three arguments.
-   */
-  public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
-    _ name: String,
-    _ closure: @escaping (A0, A1, A2) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self)],
-      closure
-    )
-  }
-
-  /**
-   Function with four arguments.
-   */
-  public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
-    _ name: String,
-    _ closure: @escaping (A0, A1, A2, A3) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self), ArgumentType(A3.self)],
-      closure
-    )
-  }
-
-  /**
-   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) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self), ArgumentType(A3.self), ArgumentType(A4.self)],
-      closure
-    )
-  }
-
-  /**
-   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) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self), ArgumentType(A3.self), ArgumentType(A4.self), ArgumentType(A5.self)],
-      closure
-    )
-  }
-
-  /**
-   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) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self), ArgumentType(A3.self), ArgumentType(A4.self), ArgumentType(A5.self), ArgumentType(A6.self)],
-      closure
-    )
-  }
-
-  /**
-   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) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      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
-    )
-  }
-
   // MARK: - Module's lifecycle
 
   /**
@@ -212,50 +68,6 @@ extension AnyModule {
   public func viewManager(@ViewManagerDefinitionBuilder _ closure: @escaping () -> ViewManagerDefinition) -> AnyDefinition {
     return closure()
   }
-
-  // MARK: - Events
-
-  /**
-   Defines event names that this module can send to JavaScript.
-   */
-  public func events(_ names: String...) -> AnyDefinition {
-    return EventsDefinition(names: names)
-  }
-
-  /**
-   Function that is invoked when the first event listener is added.
-   */
-  public func onStartObserving(_ body: @escaping () -> ()) -> AnyFunction {
-    return ConcreteFunction("startObserving", argTypes: [], body)
-  }
-
-  /**
-   Function that is invoked when all event listeners are removed.
-   */
-  public func onStopObserving(_ body: @escaping () -> ()) -> AnyFunction {
-    return ConcreteFunction("stopObserving", argTypes: [], body)
-  }
-}
-
-/**
- Defines the factory creating a native view when the module is used as a view.
- */
-public func view(_ closure: @escaping () -> UIView) -> AnyDefinition {
-  return ViewFactory(closure)
-}
-
-/**
- Creates a view prop that defines its name and setter.
- */
-public func prop<ViewType: UIView, PropType: AnyArgument>(
-  _ name: String,
-  _ setter: @escaping (ViewType, PropType) -> Void
-) -> AnyDefinition {
-  return ConcreteViewProp(
-    name: name,
-    propType: ArgumentType(PropType.self),
-    setter: setter
-  )
 }
 
 // TODO: - Remove deprecated `method` component once SDK44 is out.

package/ios/Swift/ModulesProvider.swift

@@ -1,17 +1,9 @@
-
 import Foundation
 
 /**
- An empty protocol that Objective-C can refer to as a type of the modules provider.
- In Objective-C code we do not do anything with it except passing it back to the Swift light side.
- */
-@objc
-public protocol ModulesProviderObjCProtocol {}
-
-/**
- Swift protocol defining the requirements for modules providers. Extends its Objective-C counterpart `ModulesProviderObjCProtocol`.
+ Swift protocol defining the requirements for modules providers.
  */
-public protocol ModulesProviderProtocol: ModulesProviderObjCProtocol {
+public protocol ModulesProviderProtocol {
   func getModuleClasses() -> [AnyModule.Type]
 
   /**
@@ -31,7 +23,7 @@ public protocol ModulesProviderProtocol: ModulesProviderObjCProtocol {
  The proper implementation is generated by autolinking as part of `pod install` command.
  */
 @objc
-open class ModulesProvider: NSObject, ModulesProviderProtocol, ModulesProviderObjCProtocol {
+open class ModulesProvider: NSObject, ModulesProviderProtocol {
   open func getModuleClasses() -> [AnyModule.Type] {
     return []
   }

package/ios/Swift/Objects/ObjectDefinition.swift

@@ -0,0 +1,30 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ Base class for other definitions representing an object, such as `ModuleDefinition`.
+ */
+public class ObjectDefinition: AnyDefinition {
+  /**
+   A dictionary of functions defined by the object.
+   */
+  let functions: [String: AnyFunction]
+
+  /**
+   An array of constants definitions.
+   */
+  let constants: [ConstantsDefinition]
+
+  /**
+   Default initializer receiving children definitions from the result builder.
+   */
+  init(definitions: [AnyDefinition]) {
+    self.functions = definitions
+      .compactMap { $0 as? AnyFunction }
+      .reduce(into: [String: AnyFunction]()) { dict, function in
+        dict[function.name] = function
+      }
+
+    self.constants = definitions
+      .compactMap { $0 as? ConstantsDefinition }
+  }
+}