expo-modules-core 0.4.8 → 0.5.0

package/ios/Swift/Modules/AnyModule.swift

@@ -1,8 +1,8 @@
 
 /**
- A protocol for any type-erased module that provides methods used by the core.
+ A protocol for any type-erased module that provides functions used by the core.
  */
-public protocol AnyModule: AnyObject {
+public protocol AnyModule: AnyObject, AnyArgument {
   /**
    The default initializer. Must be public, but the module class does *not* need to
    define it as it is implemented in protocol composition, see `BaseModule` class.
@@ -10,7 +10,7 @@ public protocol AnyModule: AnyObject {
   init(appContext: AppContext)
 
   /**
-   A DSL-like function that returns a `ModuleDefinition` which can be built up from module's name, constants or methods.
+   A DSL-like function that returns a `ModuleDefinition` which can be built up from module's name, constants or functions.
    The `@ModuleDefinitionBuilder` wrapper is *not* required in the implementation — it is implicitly taken from the protocol.
 
    # Example
@@ -18,7 +18,7 @@ public protocol AnyModule: AnyObject {
    ```
    public func definition() -> ModuleDefinition {
      name("MyModule")
-     method("myMethod") { (a: String, b: String) in
+     function("myFunction") { (a: String, b: String) in
        "\(a) \(b)"
      }
    }
@@ -29,16 +29,16 @@ public protocol AnyModule: AnyObject {
    ```javascript
    import { NativeModulesProxy } from 'expo-modules-core';
 
-   await NativeModulesProxy.MyModule.myMethod('Hello', 'World!'); // -> 'Hello World!'
+   await NativeModulesProxy.MyModule.myFunction('Hello', 'World!'); // -> 'Hello World!'
    ```
 
-   # Method's result obtained asynchronously
+   # Function's result obtained asynchronously
 
    If you need to run some async code to get the proper value that you want to return to JavaScript,
-   just specify an argument of type `Promise` as the last one and use its `resolve` or `reject` methods.
+   just specify an argument of type `Promise` as the last one and use its `resolve` or `reject` functions.
 
    ```
-   method("myMethod") { (promise: Promise) in
+   function("myFunction") { (promise: Promise) in
      DispatchQueue.main.async {
        promise.resolve("return value obtained in async callback")
      }

package/ios/Swift/Modules/Module.swift

@@ -10,6 +10,13 @@ open class BaseModule {
   required public init(appContext: AppContext) {
     self.appContext = appContext
   }
+
+  /**
+   Sends an event with given name and body to JavaScript.
+   */
+  public func sendEvent(_ eventName: String, _ body: [String: Any?] = [:]) {
+    appContext?.eventEmitter?.sendEvent(withName: eventName, body: body)
+  }
 }
 
 /**

package/ios/Swift/Modules/ModuleDefinition.swift

@@ -9,23 +9,40 @@ 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 struct ModuleDefinition: AnyDefinition {
-  let name: String?
-  let methods: [String : AnyMethod]
+public final class ModuleDefinition: AnyDefinition {
+  /**
+   The module's type associated with the definition. It's used to create the module instance.
+   */
+  var type: AnyModule.Type?
+
+  /**
+   Name of the defined module. Falls back to the type name if not provided in the definition.
+   */
+  var name: String
+
+  let functions: [String : AnyFunction]
   let constants: [String : Any?]
   let eventListeners: [EventListener]
   let viewManager: ViewManagerDefinition?
 
+  /**
+   Names of the events that the module can send to JavaScript.
+   */
+  let eventNames: [String]
+
+  /**
+   Initializer that is called by the `ModuleDefinitionBuilder` results builder.
+   */
   init(definitions: [AnyDefinition]) {
     self.name = definitions
       .compactMap { $0 as? ModuleNameDefinition }
       .last?
-      .name
+      .name ?? ""
 
-    self.methods = definitions
-      .compactMap { $0 as? AnyMethod }
-      .reduce(into: [String : AnyMethod]()) { dict, method in
-        dict[method.name] = method
+    self.functions = definitions
+      .compactMap { $0 as? AnyFunction }
+      .reduce(into: [String : AnyFunction]()) { dict, function in
+        dict[function.name] = function
       }
 
     self.constants = definitions
@@ -39,6 +56,26 @@ public struct ModuleDefinition: AnyDefinition {
     self.viewManager = definitions
       .compactMap { $0 as? ViewManagerDefinition }
       .last
+
+    self.eventNames = Array(
+      definitions
+        .compactMap { ($0 as? EventsDefinition)?.names }
+        .joined()
+    )
+  }
+
+  /**
+   Sets the module type that the definition is associated with. We can't pass this in the initializer
+   as it's called by the results builder that doesn't have access to the type.
+   */
+  func withType(_ type: AnyModule.Type) -> Self {
+    self.type = type
+
+    // Use the type name if the name is not in the definition or was defined empty.
+    if name.isEmpty {
+      name = String(describing: type)
+    }
+    return self
   }
 }
 
@@ -55,3 +92,10 @@ internal struct ModuleNameDefinition: AnyDefinition {
 internal struct ConstantsDefinition: AnyDefinition {
   let constants: [String : Any?]
 }
+
+/**
+ A definition for module's events that can be sent to JavaScript.
+ */
+internal struct EventsDefinition: AnyDefinition {
+  let names: [String]
+}

package/ios/Swift/Modules/ModuleDefinitionBuilder.swift

@@ -2,7 +2,7 @@
 #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,
- but can just return multiple methods one after another. This works similarly to SwiftUI's `body` block.
+ but can just return multiple components one after another. This works similarly to SwiftUI's `body` block.
  */
 @resultBuilder
 public struct ModuleDefinitionBuilder {

package/ios/Swift/Modules/ModuleDefinitionComponents.swift

@@ -7,6 +7,8 @@ import UIKit
  will be implemented in the future.
  */
 extension AnyModule {
+  // MARK: - Module name
+
   /**
    Sets the name of the module that is exported to the JavaScript world.
    */
@@ -14,6 +16,8 @@ extension AnyModule {
     return ModuleNameDefinition(name: name)
   }
 
+  // MARK: - Constants
+
   /**
    Definition function setting the module's constants to export.
    */
@@ -21,14 +25,16 @@ extension AnyModule {
     return ConstantsDefinition(constants: closure())
   }
 
+  // MARK: - Functions
+
   /**
-   Factory function for methods without arguments.
+   Function without arguments.
    */
-  public func method<R>(
+  public func function<R>(
     _ name: String,
     _ closure: @escaping () -> R
-  ) -> AnyMethod {
-    return ConcreteMethod(
+  ) -> AnyFunction {
+    return ConcreteFunction(
       name,
       argTypes: [],
       closure
@@ -36,117 +42,119 @@ extension AnyModule {
   }
 
   /**
-   Factory function for methods with one argument.
+   Function with one argument.
    */
-  public func method<R, A0: AnyMethodArgument>(
+  public func function<R, A0: AnyArgument>(
     _ name: String,
     _ closure: @escaping (A0) -> R
-  ) -> AnyMethod {
-    return ConcreteMethod(
+  ) -> AnyFunction {
+    return ConcreteFunction(
       name,
-      argTypes: [AnyArgumentType(A0.self)],
+      argTypes: [ArgumentType(A0.self)],
       closure
     )
   }
 
   /**
-   Factory function for methods with 2 arguments.
+   Function with two arguments.
    */
-  public func method<R, A0: AnyMethodArgument, A1: AnyMethodArgument>(
+  public func function<R, A0: AnyArgument, A1: AnyArgument>(
     _ name: String,
     _ closure: @escaping (A0, A1) -> R
-  ) -> AnyMethod {
-    return ConcreteMethod(
+  ) -> AnyFunction {
+    return ConcreteFunction(
       name,
-      argTypes: [AnyArgumentType(A0.self), AnyArgumentType(A1.self)],
+      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
       closure
     )
   }
 
   /**
-   Factory function for methods with 3 arguments.
+   Function with three arguments.
    */
-  public func method<R, A0: AnyMethodArgument, A1: AnyMethodArgument, A2: AnyMethodArgument>(
+  public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
     _ name: String,
     _ closure: @escaping (A0, A1, A2) -> R
-  ) -> AnyMethod {
-    return ConcreteMethod(
+  ) -> AnyFunction {
+    return ConcreteFunction(
       name,
-      argTypes: [AnyArgumentType(A0.self), AnyArgumentType(A1.self), AnyArgumentType(A2.self)],
+      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self)],
       closure
     )
   }
 
   /**
-   Factory function for methods with 4 arguments.
+   Function with four arguments.
    */
-  public func method<R, A0: AnyMethodArgument, A1: AnyMethodArgument, A2: AnyMethodArgument, A3: AnyMethodArgument>(
+  public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
     _ name: String,
     _ closure: @escaping (A0, A1, A2, A3) -> R
-  ) -> AnyMethod {
-    return ConcreteMethod(
+  ) -> AnyFunction {
+    return ConcreteFunction(
       name,
-      argTypes: [AnyArgumentType(A0.self), AnyArgumentType(A1.self), AnyArgumentType(A2.self), AnyArgumentType(A3.self)],
+      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self), ArgumentType(A3.self)],
       closure
     )
   }
 
   /**
-   Factory function for methods with 5 arguments.
+   Function with five arguments.
    */
-  public func method<R, A0: AnyMethodArgument, A1: AnyMethodArgument, A2: AnyMethodArgument, A3: AnyMethodArgument, A4: AnyMethodArgument>(
+  public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
     _ name: String,
     _ closure: @escaping (A0, A1, A2, A3, A4) -> R
-  ) -> AnyMethod {
-    return ConcreteMethod(
+  ) -> AnyFunction {
+    return ConcreteFunction(
       name,
-      argTypes: [AnyArgumentType(A0.self), AnyArgumentType(A1.self), AnyArgumentType(A2.self), AnyArgumentType(A3.self), AnyArgumentType(A4.self)],
+      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self), ArgumentType(A3.self), ArgumentType(A4.self)],
       closure
     )
   }
 
   /**
-   Factory function for methods with 6 arguments.
+   Function with six arguments.
    */
-  public func method<R, A0: AnyMethodArgument, A1: AnyMethodArgument, A2: AnyMethodArgument, A3: AnyMethodArgument, A4: AnyMethodArgument, A5: AnyMethodArgument>(
+  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
-  ) -> AnyMethod {
-    return ConcreteMethod(
+  ) -> AnyFunction {
+    return ConcreteFunction(
       name,
-      argTypes: [AnyArgumentType(A0.self), AnyArgumentType(A1.self), AnyArgumentType(A2.self), AnyArgumentType(A3.self), AnyArgumentType(A4.self), AnyArgumentType(A5.self)],
+      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self), ArgumentType(A3.self), ArgumentType(A4.self), ArgumentType(A5.self)],
       closure
     )
   }
 
   /**
-   Factory function for methods with 7 arguments.
+   Function with seven arguments.
    */
-  public func method<R, A0: AnyMethodArgument, A1: AnyMethodArgument, A2: AnyMethodArgument, A3: AnyMethodArgument, A4: AnyMethodArgument, A5: AnyMethodArgument, A6: AnyMethodArgument>(
+  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
-  ) -> AnyMethod {
-    return ConcreteMethod(
+  ) -> AnyFunction {
+    return ConcreteFunction(
       name,
-      argTypes: [AnyArgumentType(A0.self), AnyArgumentType(A1.self), AnyArgumentType(A2.self), AnyArgumentType(A3.self), AnyArgumentType(A4.self), AnyArgumentType(A5.self), AnyArgumentType(A6.self)],
+      argTypes: [ArgumentType(A0.self), ArgumentType(A1.self), ArgumentType(A2.self), ArgumentType(A3.self), ArgumentType(A4.self), ArgumentType(A5.self), ArgumentType(A6.self)],
       closure
     )
   }
 
   /**
-   Factory function for methods with 8 arguments.
+   Function with eight arguments.
    */
-  public func method<R, A0: AnyMethodArgument, A1: AnyMethodArgument, A2: AnyMethodArgument, A3: AnyMethodArgument, A4: AnyMethodArgument, A5: AnyMethodArgument, A6: AnyMethodArgument, A7: AnyMethodArgument>(
+  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
-  ) -> AnyMethod {
-    return ConcreteMethod(
+  ) -> AnyFunction {
+    return ConcreteFunction(
       name,
-      argTypes: [AnyArgumentType(A0.self), AnyArgumentType(A1.self), AnyArgumentType(A2.self), AnyArgumentType(A3.self), AnyArgumentType(A4.self), AnyArgumentType(A5.self), AnyArgumentType(A6.self), AnyArgumentType(A7.self)],
+      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.
    */
@@ -188,13 +196,38 @@ extension AnyModule {
   public func onAppEntersBackground(_ closure: @escaping () -> Void) -> AnyDefinition {
     return EventListener(.appEntersBackground, closure)
   }
-}
 
-/**
- Creates the view manager definition that scopes other view-related definitions.
- */
-public func viewManager(@ViewManagerDefinitionBuilder _ closure: @escaping () -> ViewManagerDefinition) -> AnyDefinition {
-  return 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()
+  }
+
+  // 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)
+  }
 }
 
 /**
@@ -207,6 +240,61 @@ public func view(_ closure: @escaping () -> UIView) -> AnyDefinition {
 /**
  Creates a view prop that defines its name and setter.
  */
-public func prop<ViewType: UIView, PropType>(_ name: String, _ setter: @escaping (ViewType, PropType) -> Void) -> AnyDefinition {
-  return ConcreteViewProp(name, 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.
+public extension AnyModule {
+  /**
+   Function without arguments.
+   */
+  @available(*, deprecated, renamed: "function")
+  func method<R>(
+    _ name: String,
+    _ closure: @escaping () -> R
+  ) -> AnyFunction {
+    return ConcreteFunction(
+      name,
+      argTypes: [],
+      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
+    )
+  }
+
+  /**
+   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
+    )
+  }
 }

package/ios/Swift/ModulesProvider.swift

@@ -13,6 +13,11 @@ public protocol ModulesProviderObjCProtocol {}
  */
 public protocol ModulesProviderProtocol: ModulesProviderObjCProtocol {
   func getModuleClasses() -> [AnyModule.Type]
+
+  /**
+   Returns an array of classes that hooks into `ExpoAppDelegate` to receive app delegate events.
+   */
+  func getAppDelegateSubscribers() -> [ExpoAppDelegateSubscriber.Type]
 }
 
 /**
@@ -24,4 +29,8 @@ open class ModulesProvider: NSObject, ModulesProviderProtocol, ModulesProviderOb
   open func getModuleClasses() -> [AnyModule.Type] {
     return []
   }
+
+  open func getAppDelegateSubscribers() -> [ExpoAppDelegateSubscriber.Type] {
+    return []
+  }
 }

package/ios/Swift/Promise.swift

@@ -1,5 +1,5 @@
 
-public struct Promise: AnyMethodArgument {
+public struct Promise: AnyArgument {
   public typealias ResolveClosure = (Any?) -> Void
   public typealias RejectClosure = (CodedError) -> Void
 

package/ios/Swift/Records/Field.swift

@@ -2,7 +2,7 @@
  Property wrapper for `Record`'s data members that takes part in the process of serialization to and deserialization from the dictionary.
  */
 @propertyWrapper
-public class Field<Type>: AnyFieldInternal {
+public final class Field<Type>: AnyFieldInternal {
   /**
    The wrapped value.
    */

package/ios/Swift/Records/Record.swift

@@ -1,7 +1,7 @@
 /**
  A protocol that allows initializing the object with a dictionary.
  */
-public protocol Record: AnyMethodArgument {
+public protocol Record: ConvertibleArgument {
   /**
    The dictionary type that the record can be created from or converted back.
    */
@@ -27,6 +27,13 @@ public protocol Record: AnyMethodArgument {
  Provides the default implementation of `Record` protocol.
  */
 public extension Record {
+  static func convert(from value: Any?) throws -> Self {
+    if let value = value as? Dict {
+      return try Self(from: value)
+    }
+    throw Conversions.ConvertingError<Self>(value: value)
+  }
+
   init(from dict: Dict) throws {
     self.init()
 

package/ios/Swift/SwiftInteropBridge.swift

@@ -2,7 +2,7 @@
 import Foundation
 
 @objc
-public class SwiftInteropBridge: NSObject {
+public final class SwiftInteropBridge: NSObject {
   let appContext: AppContext
 
   var registry: ModuleRegistry {
@@ -21,15 +21,15 @@ public class SwiftInteropBridge: NSObject {
   }
 
   @objc
-  public func callMethod(_ methodName: String,
-                         onModule moduleName: String,
-                         withArgs args: [Any],
-                         resolve: @escaping EXPromiseResolveBlock,
-                         reject: @escaping EXPromiseRejectBlock) {
+  public func callFunction(_ functionName: String,
+                           onModule moduleName: String,
+                           withArgs args: [Any],
+                           resolve: @escaping EXPromiseResolveBlock,
+                           reject: @escaping EXPromiseRejectBlock) {
     registry
       .get(moduleHolderForName: moduleName)?
-      .call(method: methodName, args: args) { value, error in
-        if let error = error as? CodedError {
+      .call(function: functionName, args: args) { value, error in
+        if let error = error {
           reject(error.code, error.description, error)
         } else if let error = error {
           reject("ERR_UNKNOWN_ERROR", error.localizedDescription, error)
@@ -40,18 +40,24 @@ public class SwiftInteropBridge: NSObject {
   }
 
   @objc
-  public func exportedMethodNames() -> [String: [[String: Any]]] {
+  public func callFunctionSync(_ functionName: String,
+                               onModule moduleName: String,
+                               withArgs args: [Any]) -> Any? {
+    return registry
+      .get(moduleHolderForName: moduleName)?
+      .callSync(function: functionName, args: args)
+  }
+
+  @objc
+  public func exportedFunctionNames() -> [String: [[String: Any]]] {
     var constants = [String: [[String: Any]]]()
 
     for holder in registry {
-      var index = -1
-
-      constants[holder.name] = holder.definition.methods.map({ (methodName, method) in
-        index += 1
+      constants[holder.name] = holder.definition.functions.map({ (functionName, function) in
         return [
-          "name": methodName,
-          "argumentsCount": method.argumentsCount,
-          "key": methodName,
+          "name": functionName,
+          "argumentsCount": function.argumentsCount,
+          "key": functionName,
         ]
       })
     }
@@ -85,4 +91,27 @@ public class SwiftInteropBridge: NSObject {
       }
     }
   }
+
+  // MARK: - Events
+
+  /**
+   Returns an array of event names supported by all Swift modules.
+   */
+  @objc
+  public func getSupportedEvents() -> [String] {
+    return registry.reduce(into: [String]()) { events, holder in
+      events.append(contentsOf: holder.definition.eventNames)
+    }
+  }
+
+  /**
+   Modifies listeners count for module with given name. Depending on the listeners count,
+   `onStartObserving` and `onStopObserving` are called.
+   */
+  @objc
+  public func modifyEventListenersCount(_ moduleName: String, count: Int) {
+    registry
+      .get(moduleHolderForName: moduleName)?
+      .modifyListenersCount(count)
+  }
 }

package/ios/Swift/Views/AnyViewProp.swift

@@ -5,12 +5,12 @@ import UIKit
  */
 public protocol AnyViewProp: AnyDefinition {
   /**
-   Name of the prop.
+   Name of the view prop that JavaScript refers to.
    */
   var name: String { get }
 
   /**
    Function that sets the underlying prop value for given view.
    */
-  func set(value: Any?, onView: UIView)
+  func set(value: Any, onView: UIView) throws
 }