expo-modules-core 0.9.2 → 0.11.1

package/ios/Swift/AppContext.swift

@@ -1,8 +1,10 @@
 import UIKit
+
 /**
  The app context is an interface to a single Expo app.
  */
-public final class AppContext {
+@objc(EXAppContext)
+public final class AppContext: NSObject {
   internal static func create() -> AppContext {
     let appContext = AppContext()
 
@@ -13,28 +15,46 @@ public final class AppContext {
   /**
    The module registry for the app context.
    */
-  public private(set) lazy var moduleRegistry: ModuleRegistry = ModuleRegistry(appContext: self)
+  public private(set) lazy var moduleRegistry: ModuleRegistry = {
+    isModuleRegistryInitialized = true
+    return ModuleRegistry(appContext: self)
+  }()
+
+  /**
+   Whether the module registry for this app context has already been initialized.
+   */
+  private var isModuleRegistryInitialized: Bool = false
 
   /**
    The legacy module registry with modules written in the old-fashioned way.
    */
-  public private(set) weak var legacyModuleRegistry: EXModuleRegistry?
+  internal weak var legacyModuleRegistry: EXModuleRegistry?
+
+  internal weak var legacyModulesProxy: LegacyNativeModulesProxy?
 
   /**
-   React bridge of the context's app.
+   React bridge of the context's app. Can be `nil` when the bridge
+   hasn't been propagated to the bridge modules yet (see ``ExpoBridgeModule``),
+   or when the app context is "bridgeless" (for example in native unit tests).
    */
+  @objc
   public internal(set) weak var reactBridge: RCTBridge?
 
   /**
    JSI runtime of the running app.
    */
-  public internal(set) var runtime: JavaScriptRuntime? {
+  @objc
+  public var runtime: JavaScriptRuntime? {
     didSet {
-      // When the runtime is unpinned from the context (e.g. deallocated),
-      // we should make sure to release all JS objects from the memory.
-      // Otherwise the JSCRuntime asserts may fail on deallocation.
       if runtime == nil {
+        // When the runtime is unpinned from the context (e.g. deallocated),
+        // we should make sure to release all JS objects from the memory.
+        // Otherwise the JSCRuntime asserts may fail on deallocation.
         releaseRuntimeObjects()
+      } else if runtime != oldValue {
+        // Try to install ExpoModules host object automatically when the runtime changes.
+        // TODO: Should we uninstall in the old runtime? (@tsapeta)
+        try? installExpoModulesHostObject()
       }
     }
   }
@@ -42,17 +62,20 @@ public final class AppContext {
   /**
    Designated initializer without modules provider.
    */
-  public init() {
+  public override init() {
+    super.init()
     listenToClientAppNotifications()
   }
 
-  /**
-   Initializes the app context and registers provided modules in the module registry.
-   */
-  public convenience init(withModulesProvider provider: ModulesProviderProtocol, legacyModuleRegistry: EXModuleRegistry?) {
-    self.init()
-    self.legacyModuleRegistry = legacyModuleRegistry
+  @discardableResult
+  public func useModulesProvider(_ providerName: String) -> Self {
+    return useModulesProvider(Self.modulesProvider(withName: providerName))
+  }
+
+  @discardableResult
+  public func useModulesProvider(_ provider: ModulesProvider) -> Self {
     moduleRegistry.register(fromProvider: provider)
+    return self
   }
 
   /**
@@ -134,14 +157,139 @@ public final class AppContext {
     }
   }
 
+  // MARK: - Interop with NativeModulesProxy
+
+  /**
+   Returns view modules wrapped by the base `ViewModuleWrapper` class.
+   */
+  @objc
+  public func getViewManagers() -> [ViewModuleWrapper] {
+    return moduleRegistry.compactMap { holder in
+      if holder.definition.viewManager != nil {
+        return ViewModuleWrapper(holder)
+      } else {
+        return nil
+      }
+    }
+  }
+
+  /**
+   Returns a bool whether the module with given name is registered in this context.
+   */
+  @objc
+  public func hasModule(_ moduleName: String) -> Bool {
+    return moduleRegistry.has(moduleWithName: moduleName)
+  }
+
+  /**
+   Returns an array of names of the modules registered in the module registry.
+   */
+  @objc
+  public func getModuleNames() -> [String] {
+    return moduleRegistry.getModuleNames()
+  }
+
+  /**
+   Returns a JavaScript object that represents a module with given name.
+   When remote debugging is enabled, this will always return `nil`.
+   */
+  @objc
+  public func getNativeModuleObject(_ moduleName: String) -> JavaScriptObject? {
+    return moduleRegistry.get(moduleHolderForName: moduleName)?.javaScriptObject
+  }
+
+  /**
+   Returns an array of event names supported by all Swift modules.
+   */
+  @objc
+  public func getSupportedEvents() -> [String] {
+    return moduleRegistry.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) {
+    moduleRegistry
+      .get(moduleHolderForName: moduleName)?
+      .modifyListenersCount(count)
+  }
+
+  /**
+   Asynchronously calls module's function with given arguments.
+   */
+  @objc
+  public func callFunction(
+    _ functionName: String,
+    onModule moduleName: String,
+    withArgs args: [Any],
+    resolve: @escaping EXPromiseResolveBlock,
+    reject: @escaping EXPromiseRejectBlock
+  ) {
+    moduleRegistry
+      .get(moduleHolderForName: moduleName)?
+      .call(function: functionName, args: args) { result in
+        switch result {
+        case .failure(let error):
+          reject(error.code, error.description, error)
+        case .success(let value):
+          resolve(value)
+        }
+      }
+  }
+
+  @objc
+  public final lazy var expoModulesConfig = ModulesProxyConfig(constants: self.exportedModulesConstants(),
+                                                               methodNames: self.exportedFunctionNames(),
+                                                               viewManagers: self.viewManagersMetadata())
+
+  private func exportedFunctionNames() -> [String: [[String: Any]]] {
+    var constants = [String: [[String: Any]]]()
+
+    for holder in moduleRegistry {
+      constants[holder.name] = holder.definition.functions.map({ functionName, function in
+        return [
+          "name": functionName,
+          "argumentsCount": function.argumentsCount,
+          "key": functionName
+        ]
+      })
+    }
+    return constants
+  }
+
+  private func exportedModulesConstants() -> [String: Any] {
+    return moduleRegistry
+      // prevent infinite recursion - exclude NativeProxyModule constants
+      .filter { $0.name != NativeModulesProxyModule.moduleName }
+      .reduce(into: [String: Any]()) { acc, holder in
+        acc[holder.name] = holder.getConstants()
+      }
+  }
+
+  private func viewManagersMetadata() -> [String: Any] {
+    return moduleRegistry.reduce(into: [String: Any]()) { acc, holder in
+      if let viewManager = holder.definition.viewManager {
+        acc[holder.name] = [
+          "propsNames": viewManager.props.map { $0.name }
+        ]
+      }
+    }
+  }
+
   // MARK: - Runtime
 
-  internal func installExpoModulesHostObject(_ interopBridge: SwiftInteropBridge) throws {
-    guard let runtime = runtime else {
-      throw UndefinedRuntimeException()
+  internal func installExpoModulesHostObject() throws {
+    guard runtime != nil else {
+      throw RuntimeLostException()
     }
-    EXJavaScriptRuntimeManager.installExpoModules(to: runtime, withSwiftInterop: interopBridge)
+    EXJavaScriptRuntimeManager.installExpoModulesHostObject(self)
   }
+
   /**
    Unsets runtime objects that we hold for each module.
    */
@@ -158,20 +306,50 @@ public final class AppContext {
    */
   deinit {
     NotificationCenter.default.removeObserver(self)
-    moduleRegistry.post(event: .appContextDestroys)
+
+    // Post an event to the registry only if it was already created.
+    // If we let it to lazy-load here, that would crash since the module registry
+    // has a weak reference to the app context which is being deallocated.
+    if isModuleRegistryInitialized {
+      moduleRegistry.post(event: .appContextDestroys)
+    }
   }
 
-  // MARK: - Exceptions
+  // MARK: - Statics
 
-  class DeallocatedAppContextException: Exception {
-    override var reason: String {
-      "The AppContext has been deallocated"
+  /**
+   Returns an instance of the generated Expo modules provider.
+   The provider is usually generated in application's `ExpoModulesProviders` files group.
+   */
+  @objc
+  public static func modulesProvider(withName providerName: String = "ExpoModulesProvider") -> ModulesProvider {
+    // [0] When ExpoModulesCore is built as separated framework/module,
+    // we should explicitly load main bundle's `ExpoModulesProvider` class.
+    if let bundleName = Bundle.main.infoDictionary?["CFBundleName"],
+       let providerClass = NSClassFromString("\(bundleName).\(providerName)") as? ModulesProvider.Type {
+      return providerClass.init()
     }
-  }
 
-  class UndefinedRuntimeException: Exception {
-    override var reason: String {
-      "The AppContext has undefined runtime"
+    // [1] Fallback to `ExpoModulesProvider` class from the current module.
+    if let providerClass = NSClassFromString(providerName) as? ModulesProvider.Type {
+      return providerClass.init()
     }
+
+    // [2] Fallback to an empty `ModulesProvider` if `ExpoModulesProvider` was not generated
+    return ModulesProvider()
+  }
+}
+
+// MARK: - Public exceptions
+
+public final class AppContextLostException: Exception {
+  override public var reason: String {
+    "The app context has been lost"
+  }
+}
+
+public final class RuntimeLostException: Exception {
+  override public var reason: String {
+    "The JavaScript runtime has been lost"
   }
 }

package/ios/Swift/Arguments/AnyArgument.swift

@@ -5,10 +5,28 @@
  */
 public protocol AnyArgument {}
 
+// Extend the optional type - this is required to support optional arguments.
+extension Optional: AnyArgument where Wrapped: AnyArgument {}
+
 // Extend the primitive types — these may come from React Native bridge.
 extension Bool: AnyArgument {}
+
 extension Int: AnyArgument {}
+extension Int8: AnyArgument {}
+extension Int16: AnyArgument {}
+extension Int32: AnyArgument {}
+extension Int64: AnyArgument {}
+
+extension UInt: AnyArgument {}
+extension UInt8: AnyArgument {}
+extension UInt16: AnyArgument {}
+extension UInt32: AnyArgument {}
+extension UInt64: AnyArgument {}
+
+extension Float32: AnyArgument {}
 extension Double: AnyArgument {}
+
 extension String: AnyArgument {}
 extension Array: AnyArgument {}
 extension Dictionary: AnyArgument {}
+

package/ios/Swift/Arguments/{Types/EnumArgumentType.swift → EnumArgument.swift}

@@ -1,19 +1,4 @@
-// Copyright 2021-present 650 Industries. All rights reserved.
-
-/**
- An argument type representing an enum that conforms to `EnumArgument`.
- */
-internal struct EnumArgumentType: AnyArgumentType {
-  let innerType: EnumArgument.Type
-
-  func cast<ArgType>(_ value: ArgType) throws -> Any {
-    return try innerType.create(fromRawValue: value)
-  }
-
-  var description: String {
-    "Enum<\(innerType)>"
-  }
-}
+// Copyright 2022-present 650 Industries. All rights reserved.
 
 /**
  A protocol that allows converting raw values to enum cases.
@@ -23,7 +8,7 @@ public protocol EnumArgument: AnyArgument {
    Tries to create an enum case using given raw value.
    May throw errors, e.g. when the raw value doesn't match any case.
    */
-  static func create<ArgType>(fromRawValue rawValue: ArgType) throws -> Self
+  static func create<RawValueType>(fromRawValue rawValue: RawValueType) throws -> Self
 
   /**
    Returns an array of all raw values available in the enum.

package/ios/Swift/Classes/ClassComponent.swift

@@ -0,0 +1,95 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Represents a JavaScript class.
+ */
+public final class ClassComponent: ObjectDefinition {
+  /**
+   Name of the class.
+   */
+  let name: String
+
+  /**
+   A synchronous function that gets called when the object of this class is initializing.
+   */
+  let constructor: AnySyncFunctionComponent?
+
+  /**
+   A dynamic type for the associated object class.
+   */
+  let associatedType: AnyDynamicType?
+
+  init<AssociatedObject: ClassAssociatedObject>(
+    name: String,
+    associatedType: AssociatedObject.Type,
+    elements: [AnyClassComponentElement] = []
+  ) {
+    self.name = name
+    self.constructor = elements.first(where: isConstructor) as? AnySyncFunctionComponent
+    self.associatedType = ~AssociatedObject.self
+
+    // Constructors can't be passed down to the object component
+    // as we shouldn't override the default `<Class>.prototype.constructor`.
+    let elementsWithoutConstructors = elements.filter({ !isConstructor($0) })
+
+    super.init(definitions: elementsWithoutConstructors)
+  }
+
+  // MARK: - JavaScriptObjectBuilder
+
+  public override func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+    let klass = runtime.createClass(name) { [weak self, weak runtime] this, arguments in
+      guard let self = self, let runtime = runtime else {
+        // TODO: Throw an exception? (@tsapeta)
+        return
+      }
+      // The properties can't go into the prototype as they would be shared across all instances.
+      // Instead, we decorate the instance object on initialization.
+      self.decorateWithProperties(runtime: runtime, object: this)
+
+      // Call the native constructor when defined.
+      let result = try? self.constructor?.call(by: this, withArguments: arguments)
+
+      // Register the shared object if returned by the constructor.
+      if let result = result as? SharedObject {
+        SharedObjectRegistry.add(native: result, javaScript: this)
+      }
+    }
+    decorate(object: klass, inRuntime: runtime)
+    return klass
+  }
+
+  public override func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime) {
+    // Here we actually don't decorate the input object (constructor) but its prototype.
+    // Properties are intentionally skipped here — they have to decorate an instance instead of the prototype.
+    let prototype = object.getProperty("prototype").getObject()
+    decorateWithConstants(runtime: runtime, object: prototype)
+    decorateWithFunctions(runtime: runtime, object: prototype)
+    decorateWithClasses(runtime: runtime, object: prototype)
+  }
+}
+
+// MARK: - ClassAssociatedObject
+
+/**
+ A protocol for types that can be used an associated type of the `ClassComponent`.
+ */
+internal protocol ClassAssociatedObject {}
+
+// Basically we only need these two
+extension JavaScriptObject: ClassAssociatedObject {}
+extension SharedObject: ClassAssociatedObject {}
+
+// MARK: - Privates
+
+/**
+ Checks whether the definition item is a constructor — a synchronous function whose name is "constructor".
+
+ We do it that way for the following two reasons:
+ - It's easier to reuse existing `SyncFunctionComponent`.
+ - Redefining prototype's `constructor` is a bad idea so a function with this name
+   needs to be filtered out when decorating the prototype.
+ */
+fileprivate func isConstructor(_ item: AnyDefinition) -> Bool {
+  return (item as? AnySyncFunctionComponent)?.name == "constructor"
+}

package/ios/Swift/Classes/ClassComponentElement.swift

@@ -0,0 +1,33 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A type-erased protocol that must be implemented by the components passed as ``ClassComponent`` elements.
+ */
+public protocol AnyClassComponentElement: AnyDefinition {}
+
+/**
+ Class component element with an associated owner type. The `OwnerType` should refer to
+ the type that the parent `Class` component is associated with (e.g. the shared object type).
+ */
+public protocol ClassComponentElement: AnyClassComponentElement {
+  associatedtype OwnerType
+}
+
+// MARK: - Conformance
+// Allow some other components to be used as the class component elements.
+
+extension SyncFunctionComponent: ClassComponentElement {
+  public typealias OwnerType = FirstArgType
+}
+
+extension AsyncFunctionComponent: ClassComponentElement {
+  public typealias OwnerType = FirstArgType
+}
+
+extension PropertyComponent: ClassComponentElement {
+  public typealias OwnerType = Void
+}
+
+extension ConstantsDefinition: ClassComponentElement {
+  public typealias OwnerType = Void
+}

package/ios/Swift/Classes/ClassComponentElementsBuilder.swift

@@ -0,0 +1,34 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A result builder that captures the ``ClassComponent`` elements such as functions, constants and properties.
+ */
+@resultBuilder
+public struct ClassComponentElementsBuilder<OwnerType> {
+  public static func buildBlock(_ elements: AnyClassComponentElement...) -> [AnyClassComponentElement] {
+    return elements
+  }
+
+  /**
+   Default implementation without any constraints that just returns type-erased element.
+   */
+  static func buildExpression<ElementType: ClassComponentElement>(
+    _ element: ElementType
+  ) -> AnyClassComponentElement {
+    return element
+  }
+
+  /**
+   In case the element's owner type matches builder's generic type,
+   we need to instruct the function to pass `this` to the closure
+   as the first argument and deduct it from `argumentsCount`.
+   */
+  static func buildExpression<ElementType: ClassComponentElement>(
+    _ element: ElementType
+  ) -> AnyClassComponentElement where ElementType.OwnerType == OwnerType {
+    if var function = element as? AnyFunction {
+      function.takesOwner = true
+    }
+    return element
+  }
+}

package/ios/Swift/Classes/ClassComponentFactories.swift

@@ -0,0 +1,96 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Class constructor without arguments.
+ */
+public func Constructor<R>(
+  _ body: @escaping () throws -> R
+) -> SyncFunctionComponent<(), Void, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with one argument.
+ */
+public func Constructor<R, A0: AnyArgument>(
+  _ body: @escaping (A0) throws -> R
+) -> SyncFunctionComponent<(A0), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with two arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument>(
+  _ body: @escaping (A0, A1) throws -> R
+) -> SyncFunctionComponent<(A0, A1), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with three arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ body: @escaping (A0, A1, A2) throws -> R
+) -> SyncFunctionComponent<(A0, A1, A2), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with four arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ body: @escaping (A0, A1, A2, A3) throws -> R
+) -> SyncFunctionComponent<(A0, A1, A2, A3), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with five arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ body: @escaping (A0, A1, A2, A3, A4) throws -> R
+) -> SyncFunctionComponent<(A0, A1, A2, A3, A4), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Class constructor with six arguments.
+ */
+public func Constructor<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
+  _ body: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
+) -> SyncFunctionComponent<(A0, A1, A2, A3, A4, A5), A0, R> {
+  return Function("constructor", body)
+}
+
+/**
+ Creates the component describing a JavaScript class.
+ */
+public func Class(
+  _ name: String,
+  @ClassComponentElementsBuilder<JavaScriptObject> _ elements: () -> [AnyClassComponentElement]
+) -> ClassComponent {
+  return ClassComponent(name: name, associatedType: JavaScriptObject.self, elements: elements())
+}
+
+/**
+ Creates the component describing a JavaScript class with an associated native shared object class.
+ */
+public func Class<SharedObjectType: SharedObject>(
+  _ name: String = String(describing: SharedObjectType.self),
+  _ sharedObjectType: SharedObjectType.Type,
+  @ClassComponentElementsBuilder<SharedObjectType> _ elements: () -> [AnyClassComponentElement]
+) -> ClassComponent {
+  return ClassComponent(name: name, associatedType: SharedObjectType.self, elements: elements())
+}
+
+/**
+ Creates the component describing a JavaScript class with an associated native shared object class
+ and with the name that is inferred from the shared object type.
+ */
+public func Class<SharedObjectType: SharedObject>(
+  _ sharedObjectType: SharedObjectType.Type,
+  @ClassComponentElementsBuilder<SharedObjectType> _ elements: () -> [AnyClassComponentElement]
+) -> ClassComponent {
+  return ClassComponent(name: String(describing: SharedObjectType.self), associatedType: SharedObjectType.self, elements: elements())
+}

package/ios/Swift/DynamicTypes/AnyDynamicType.swift

@@ -0,0 +1,44 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+/**
+ A protocol whose intention is to wrap any type
+ to keep its real signature and not type-erase it by the compiler.
+ */
+public protocol AnyDynamicType: CustomStringConvertible {
+  /**
+   Checks whether the inner type is the same as the given type.
+   */
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool
+
+  /**
+   Checks whether the dynamic type is equal to another,
+   that is when the type of the dynamic types are equal and their inner types are equal.
+   */
+  func equals(_ type: AnyDynamicType) -> Bool
+
+  /**
+   Casts given any value to the wrapped type and returns as `Any`.
+   NOTE: It may not be just simple type-casting (e.g. when the wrapped type conforms to `ConvertibleArgument`).
+   */
+  func cast<ValueType>(_ value: ValueType) throws -> Any
+}
+
+// MARK: - Operators
+
+infix operator ~>
+public func ~> <T>(lhs: AnyDynamicType, rhs: T.Type) -> Bool {
+  return lhs.wraps(rhs)
+}
+
+infix operator !~>
+public func !~> <T>(lhs: AnyDynamicType, rhs: T.Type) -> Bool {
+  return !lhs.wraps(rhs)
+}
+
+public func == (lhs: AnyDynamicType, rhs: AnyDynamicType) -> Bool {
+  return lhs.equals(rhs)
+}
+
+public func != (lhs: AnyDynamicType, rhs: AnyDynamicType) -> Bool {
+  return !lhs.equals(rhs)
+}