expo-modules-core 0.6.5 → 0.9.0

package/ios/Swift/JavaScriptUtils.swift

@@ -0,0 +1,99 @@
+// 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.
+ - 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

@@ -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,24 @@ 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 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)
     } catch {
-      promise.reject(UnexpectedError(error))
+      promise.reject(UnexpectedException(error))
     }
   }
 
@@ -79,10 +98,45 @@ 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
+    }
+  }
+
+  // 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 nil
+    return object
   }
 
   // MARK: Listening to native events
@@ -112,9 +166,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 +179,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

@@ -12,159 +12,17 @@ extension AnyModule {
   /**
    Sets the name of the module that is exported to the JavaScript world.
    */
+  @available(*, deprecated, renamed: "Name")
   public func name(_ name: String) -> AnyDefinition {
     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
 
   /**
    Creates module's lifecycle listener that is called right after module initialization.
    */
+  @available(*, deprecated, renamed: "OnCreate")
   public func onCreate(_ closure: @escaping () -> Void) -> AnyDefinition {
     return EventListener(.moduleCreate, closure)
   }
@@ -172,6 +30,7 @@ extension AnyModule {
   /**
    Creates module's lifecycle listener that is called when the module is about to be deallocated.
    */
+  @available(*, deprecated, renamed: "OnDestroy")
   public func onDestroy(_ closure: @escaping () -> Void) -> AnyDefinition {
     return EventListener(.moduleDestroy, closure)
   }
@@ -179,6 +38,7 @@ extension AnyModule {
   /**
    Creates module's lifecycle listener that is called when the app context owning the module is about to be deallocated.
    */
+  @available(*, deprecated, renamed: "OnAppContextDestroys")
   public func onAppContextDestroys(_ closure: @escaping () -> Void) -> AnyDefinition {
     return EventListener(.appContextDestroys, closure)
   }
@@ -186,6 +46,7 @@ extension AnyModule {
   /**
    Creates a listener that is called when the app is about to enter the foreground mode.
    */
+  @available(*, deprecated, renamed: "OnAppEntersBackground")
   public func onAppEntersForeground(_ closure: @escaping () -> Void) -> AnyDefinition {
     return EventListener(.appEntersForeground, closure)
   }
@@ -193,6 +54,7 @@ extension AnyModule {
   /**
    Creates a listener that is called when the app becomes active again.
    */
+  @available(*, deprecated, renamed: "OnAppBecomesActive")
   public func onAppBecomesActive(_ closure: @escaping () -> Void) -> AnyDefinition {
     return EventListener(.appBecomesActive, closure)
   }
@@ -200,6 +62,7 @@ extension AnyModule {
   /**
    Creates a listener that is called when the app enters the background mode.
    */
+  @available(*, deprecated, renamed: "OnAppEntersBackground")
   public func onAppEntersBackground(_ closure: @escaping () -> Void) -> AnyDefinition {
     return EventListener(.appEntersBackground, closure)
   }
@@ -209,99 +72,70 @@ extension AnyModule {
   /**
    Creates the view manager definition that scopes other view-related definitions.
    */
+  @available(*, deprecated, renamed: "ViewManager")
   public func viewManager(@ViewManagerDefinitionBuilder _ closure: @escaping () -> ViewManagerDefinition) -> AnyDefinition {
     return closure()
   }
+}
 
-  // MARK: - Events
+// MARK: - Module name
 
-  /**
-   Defines event names that this module can send to JavaScript.
-   */
-  public func events(_ names: String...) -> AnyDefinition {
-    return EventsDefinition(names: names)
-  }
+/**
+ Sets the name of the module that is exported to the JavaScript world.
+ */
+public func Name(_ name: String) -> AnyDefinition {
+  return ModuleNameDefinition(name: name)
+}
 
-  /**
-   Function that is invoked when the first event listener is added.
-   */
-  public func onStartObserving(_ body: @escaping () -> ()) -> AnyFunction {
-    return ConcreteFunction("startObserving", argTypes: [], body)
-  }
+// MARK: - Module's lifecycle
 
-  /**
-   Function that is invoked when all event listeners are removed.
-   */
-  public func onStopObserving(_ body: @escaping () -> ()) -> AnyFunction {
-    return ConcreteFunction("stopObserving", argTypes: [], body)
-  }
+/**
+ Creates module's lifecycle listener that is called right after module initialization.
+ */
+public func OnCreate(_ closure: @escaping () -> Void) -> AnyDefinition {
+  return EventListener(.moduleCreate, closure)
 }
 
 /**
- Defines the factory creating a native view when the module is used as a view.
+ Creates module's lifecycle listener that is called when the module is about to be deallocated.
  */
-public func view(_ closure: @escaping () -> UIView) -> AnyDefinition {
-  return ViewFactory(closure)
+public func OnDestroy(_ closure: @escaping () -> Void) -> AnyDefinition {
+  return EventListener(.moduleDestroy, closure)
 }
 
 /**
- Creates a view prop that defines its name and setter.
+ Creates module's lifecycle listener that is called when the app context owning the module is about to be deallocated.
  */
-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
-  )
+public func OnAppContextDestroys(_ closure: @escaping () -> Void) -> AnyDefinition {
+  return EventListener(.appContextDestroys, closure)
 }
 
-// TODO: - Remove deprecated `method` component once SDK44 is out.
-public extension AnyModule {
-  /**
-   Function without arguments.
-   */
-  @available(*, deprecated, renamed: "function")
-  func method<R>(
-    _ name: String,
-    _ closure: @escaping () -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [],
-      closure
-    )
-  }
+/**
+ Creates a listener that is called when the app is about to enter the foreground mode.
+ */
+public func OnAppEntersForeground(_ closure: @escaping () -> Void) -> AnyDefinition {
+  return EventListener(.appEntersForeground, closure)
+}
 
-  /**
-   Function with one argument.
-   */
-  @available(*, deprecated, renamed: "function")
-  func method<R, A0: AnyArgument>(
-    _ name: String,
-    _ closure: @escaping (A0) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [ArgumentType(A0.self)],
-      closure
-    )
-  }
+/**
+ Creates a listener that is called when the app becomes active again.
+ */
+public func OnAppBecomesActive(_ closure: @escaping () -> Void) -> AnyDefinition {
+  return EventListener(.appBecomesActive, closure)
+}
 
-  /**
-   Function with two arguments.
-   */
-  @available(*, deprecated, renamed: "function")
-  func method<R, A0: AnyArgument, A1: AnyArgument>(
-    _ name: String,
-    _ closure: @escaping (A0, A1) -> R
-  ) -> AnyFunction {
-    return ConcreteFunction(
-      name,
-      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
-      closure
-    )
-  }
+/**
+ Creates a listener that is called when the app enters the background mode.
+ */
+public func OnAppEntersBackground(_ closure: @escaping () -> Void) -> AnyDefinition {
+  return EventListener(.appEntersBackground, closure)
+}
+
+// MARK: - View Manager
+
+/**
+ Creates the view manager definition that scopes other view-related definitions.
+ */
+public func ViewManager(@ViewManagerDefinitionBuilder _ closure: @escaping () -> ViewManagerDefinition) -> AnyDefinition {
+  return closure()
 }