expo-modules-core 1.11.13 → 1.12.1

package/ios/Core/Classes/AnyClassDefinitionElement.swift

@@ -0,0 +1,37 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ A type-erased protocol that must be implemented by the definitions passed as ``ClassDefinition`` elements.
+ */
+public protocol AnyClassDefinitionElement: AnyDefinition {}
+
+/**
+ Class definition element with an associated owner type. The `OwnerType` should refer to
+ the type that the parent `Class` definition is associated with (e.g. the shared object type).
+ */
+public protocol ClassDefinitionElement: AnyClassDefinitionElement {
+  associatedtype OwnerType
+}
+
+// MARK: - Conformance
+// Allow some other definitions to be used as the class definition elements.
+
+extension SyncFunctionDefinition: ClassDefinitionElement {
+  public typealias OwnerType = FirstArgType
+}
+
+extension AsyncFunctionDefinition: ClassDefinitionElement {
+  public typealias OwnerType = FirstArgType
+}
+
+extension ConcurrentFunctionDefinition: ClassDefinitionElement {
+  public typealias OwnerType = FirstArgType
+}
+
+extension PropertyDefinition: ClassDefinitionElement {
+  // It already has the `OwnerType`
+}
+
+extension ConstantsDefinition: ClassDefinitionElement {
+  public typealias OwnerType = Void
+}

package/ios/{Classes/ClassComponent.swift → Core/Classes/ClassDefinition.swift}

@@ -3,7 +3,7 @@
 /**
  Represents a JavaScript class.
  */
-public final class ClassComponent: ObjectDefinition {
+public final class ClassDefinition: ObjectDefinition {
   /**
    Name of the class.
    */
@@ -12,7 +12,7 @@ public final class ClassComponent: ObjectDefinition {
   /**
    A synchronous function that gets called when the object of this class is initializing.
    */
-  let constructor: AnySyncFunctionComponent?
+  let constructor: AnySyncFunctionDefinition?
 
   /**
    A dynamic type for the associated object class.
@@ -22,13 +22,13 @@ public final class ClassComponent: ObjectDefinition {
   init<AssociatedObject: ClassAssociatedObject>(
     name: String,
     associatedType: AssociatedObject.Type,
-    elements: [AnyClassComponentElement] = []
+    elements: [AnyClassDefinitionElement] = []
   ) {
     self.name = name
-    self.constructor = elements.first(where: isConstructor) as? AnySyncFunctionComponent
+    self.constructor = elements.first(where: isConstructor) as? AnySyncFunctionDefinition
     self.associatedType = ~AssociatedObject.self
 
-    // Constructors can't be passed down to the object component
+    // Constructors can't be passed down to the object definition
     // as we shouldn't override the default `<Class>.prototype.constructor`.
     let elementsWithoutConstructors = elements.filter({ !isConstructor($0) })
 
@@ -38,7 +38,7 @@ public final class ClassComponent: ObjectDefinition {
   // MARK: - JavaScriptObjectBuilder
 
   public override func build(appContext: AppContext) throws -> JavaScriptObject {
-    let klass = try appContext.runtime.createClass(name) { [weak self, weak appContext] this, arguments in
+    let klass = try appContext.runtime.createSharedObjectClass(name) { [weak self, weak appContext] this, arguments in
       guard let self = self, let appContext else {
         // TODO: Throw an exception? (@tsapeta)
         return
@@ -49,7 +49,7 @@ public final class ClassComponent: ObjectDefinition {
 
       // Register the shared object if returned by the constructor.
       if let result = result as? SharedObject {
-        SharedObjectRegistry.add(native: result, javaScript: this)
+        appContext.sharedObjectRegistry.add(native: result, javaScript: this)
       }
     }
 
@@ -78,7 +78,7 @@ public final class ClassComponent: ObjectDefinition {
 // MARK: - ClassAssociatedObject
 
 /**
- A protocol for types that can be used an associated type of the `ClassComponent`.
+ A protocol for types that can be used an associated type of the ``ClassDefinition``.
  */
 internal protocol ClassAssociatedObject {}
 
@@ -99,10 +99,10 @@ extension SharedObject: ClassAssociatedObject {}
  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`.
+ - It's easier to reuse existing `SyncFunctionDefinition`.
  - 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"
+  return (item as? AnySyncFunctionDefinition)?.name == "constructor"
 }

package/ios/{Conversions.swift → Core/Conversions.swift}

@@ -173,7 +173,7 @@ internal final class Conversions {
           log.warn("Unable to create a JS object for \(dynamicType.description)")
           return Optional<Any>.none
         }
-        SharedObjectRegistry.add(native: value, javaScript: object)
+        appContext.sharedObjectRegistry.add(native: value, javaScript: object)
         return object
       }
     }

package/ios/{DynamicTypes → Core/DynamicTypes}/DynamicSharedObjectType.swift

@@ -36,7 +36,7 @@ internal struct DynamicSharedObjectType: AnyDynamicType {
 
     // If the given value is a shared object id, search the registry for its native representation
     if let sharedObjectId = value as? SharedObjectId,
-       let nativeSharedObject = SharedObjectRegistry.get(sharedObjectId)?.native {
+      let nativeSharedObject = appContext.sharedObjectRegistry.get(sharedObjectId)?.native {
       return nativeSharedObject
     }
     throw NativeSharedObjectNotFoundException()
@@ -46,13 +46,13 @@ internal struct DynamicSharedObjectType: AnyDynamicType {
     if jsValue.kind == .number {
       let sharedObjectId = jsValue.getInt() as SharedObjectId
 
-      guard let nativeSharedObject = SharedObjectRegistry.get(sharedObjectId)?.native else {
+      guard let nativeSharedObject = appContext.sharedObjectRegistry.get(sharedObjectId)?.native else {
         throw NativeSharedObjectNotFoundException()
       }
       return nativeSharedObject
     }
     if let jsObject = try? jsValue.asObject(),
-       let nativeSharedObject = SharedObjectRegistry.toNativeObject(jsObject) {
+      let nativeSharedObject = appContext.sharedObjectRegistry.toNativeObject(jsObject) {
       return nativeSharedObject
     }
     throw NativeSharedObjectNotFoundException()

package/ios/Core/Events/EventObservingDefinition.swift

@@ -0,0 +1,79 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+internal enum EventObservingType: String {
+  case startObserving
+  case stopObserving
+}
+
+internal protocol AnyEventObservingDefinition: AnyDefinition {
+  var event: String? { get }
+
+  var type: EventObservingType { get }
+
+  func call()
+}
+
+public final class EventObservingDefinition: AnyEventObservingDefinition {
+  public typealias ClosureType = () -> Void
+
+  let type: EventObservingType
+
+  let event: String?
+
+  let closure: ClosureType
+
+  init(type: EventObservingType, event: String?, _ closure: @escaping ClosureType) {
+    self.type = type
+    self.event = event
+    self.closure = closure
+  }
+
+  func call() {
+    closure()
+  }
+}
+
+public struct EventObservingDecorator: JavaScriptObjectDecorator {
+  let definitions: [any AnyEventObservingDefinition]
+
+  /**
+   Decorates the given object with `startObserving` and `stopObserving` functions.
+   These functions are automatically called by the `EventEmitter` implementation.
+   */
+  func decorate(object: JavaScriptObject, appContext: AppContext) throws {
+    // We need to keep track the number of observed events
+    // so we can call observers not attached to any event in the right moment.
+    var observingEvents: Int = 0
+
+    let startObserving = AsyncFunctionDefinition(
+      EventObservingType.startObserving.rawValue,
+      firstArgType: String.self,
+      dynamicArgumentTypes: [~String.self]
+    ) { (event: String) in
+      observingEvents += 1
+
+      for definition in definitions where definition.type == .startObserving {
+        if definition.event == event || (observingEvents == 1 && definition.event == nil) {
+          definition.call()
+        }
+      }
+    }
+
+    let stopObserving = AsyncFunctionDefinition(
+      EventObservingType.stopObserving.rawValue,
+      firstArgType: String.self,
+      dynamicArgumentTypes: [~String.self]
+    ) { (event: String) in
+      observingEvents -= 1
+
+      for definition in definitions where definition.type == .stopObserving {
+        if definition.event == event || (observingEvents == 0 && definition.event == nil) {
+          definition.call()
+        }
+      }
+    }
+
+    object.setProperty(startObserving.name, value: try startObserving.build(appContext: appContext))
+    object.setProperty(stopObserving.name, value: try stopObserving.build(appContext: appContext))
+  }
+}

package/ios/Core/Events/LegacyEventEmitterCompat.swift

@@ -0,0 +1,32 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+public final class LegacyEventEmitterCompat: EXEventEmitterService {
+  internal weak var appContext: AppContext?
+
+  init(appContext: AppContext) {
+    self.appContext = appContext
+  }
+
+  // Objective-C protocol doesn't specify nullability
+  // swiftlint:disable:next implicitly_unwrapped_optional
+  public func sendEvent(withName name: String!, body: Any!) {
+    guard let appContext, let runtime = try? appContext.runtime else {
+      log.warn("Unable to send an event '\(name)' because the runtime is not available")
+      return
+    }
+
+    // Send the event to all modules that declare support for this particular event.
+    // That's how it works in the device event emitter provided by React Native.
+    let moduleHoldersWithEvent = appContext.moduleRegistry.filter { holder in
+      return holder.definition.eventNames.contains(name)
+    }
+
+    runtime.schedule {
+      for holder in moduleHoldersWithEvent {
+        if let jsObject = holder.javaScriptObject {
+          JSIUtils.emitEvent(name, to: jsObject, withArguments: [body], in: runtime)
+        }
+      }
+    }
+  }
+}

package/ios/Core/ExpoBridgeModule.h

@@ -0,0 +1,18 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+#import <React/RCTBridgeModule.h>
+#import <ExpoModulesCore/EXNativeModulesProxy.h>
+#import <ExpoModulesCore/EXModuleRegistry.h>
+
+@class EXAppContext;
+
+@interface ExpoBridgeModule : NSObject <RCTBridgeModule>
+
+@property (nonatomic, nullable, strong) EXAppContext *appContext;
+
+- (nonnull instancetype)initWithAppContext:(nonnull EXAppContext *) appContext; 
+
+- (void)legacyProxyDidSetBridge:(nonnull EXNativeModulesProxy *)moduleProxy
+           legacyModuleRegistry:(nonnull EXModuleRegistry *)moduleRegistry;
+
+@end

package/ios/Core/ExpoBridgeModule.mm

@@ -0,0 +1,88 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+#import <ReactCommon/RCTTurboModule.h>
+#import <ExpoModulesCore/ExpoBridgeModule.h>
+#import <ExpoModulesCore/Swift.h>
+
+// The runtime executor is included as of React Native 0.74 in bridgeless mode.
+#if __has_include(<ReactCommon/RCTRuntimeExecutor.h>)
+#import <ReactCommon/RCTRuntimeExecutor.h>
+#endif // React Native >=0.74
+
+@implementation ExpoBridgeModule
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE(ExpoModulesCore);
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _appContext = [[EXAppContext alloc] init];
+  }
+  return self;
+}
+
+- (instancetype)initWithAppContext:(EXAppContext *) appContext
+{
+  if (self = [super init]) {
+    _appContext = appContext;
+  }
+  return self;
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  // We do want to run the initialization (`setBridge`) on the JS thread.
+  return NO;
+}
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  // As of React Native 0.74 with the New Architecture enabled,
+  // it's actually an instance of `RCTBridgeProxy` that provides backwards compatibility.
+  // Also, hold on with initializing the runtime until `setRuntimeExecutor` is called.
+  _bridge = bridge;
+  _appContext.reactBridge = bridge;
+
+#if !__has_include(<ReactCommon/RCTRuntimeExecutor.h>)
+  _appContext._runtime = [EXJavaScriptRuntimeManager runtimeFromBridge:bridge];
+#endif // React Native <0.74
+}
+
+#if __has_include(<ReactCommon/RCTRuntimeExecutor.h>)
+- (void)setRuntimeExecutor:(RCTRuntimeExecutor *)runtimeExecutor
+{
+  _appContext._runtime = [EXJavaScriptRuntimeManager runtimeFromBridge:_bridge withExecutor:runtimeExecutor];
+}
+#endif // React Native >=0.74
+
+/**
+ This should be called inside `[EXNativeModulesProxy setBridge:]`.
+ */
+- (void)legacyProxyDidSetBridge:(nonnull EXNativeModulesProxy *)moduleProxy
+           legacyModuleRegistry:(nonnull EXModuleRegistry *)moduleRegistry
+{
+  _appContext.legacyModulesProxy = moduleProxy;
+  _appContext.legacyModuleRegistry = moduleRegistry;
+
+  // We need to register all the modules after the legacy module registry is set
+  // otherwise legacy modules (e.g. permissions) won't be available in OnCreate { }
+  [_appContext useModulesProvider:@"ExpoModulesProvider"];
+}
+
+/**
+ A synchronous method that is called from JS before requiring
+ any module to ensure that all necessary bindings are installed.
+ */
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(installModules)
+{
+  if (_bridge && !_appContext._runtime) {
+    // TODO: Keep this condition until we remove the other way of installing modules.
+    // See `setBridge` method above.
+    _appContext._runtime = [EXJavaScriptRuntimeManager runtimeFromBridge:_bridge];
+  }
+  return nil;
+}
+
+@end

package/ios/Core/ExpoRuntime.swift

@@ -0,0 +1,6 @@
+@objc(EXRuntime)
+public final class ExpoRuntime: JavaScriptRuntime {
+  internal func initializeCoreObject(_ coreObject: JavaScriptObject) throws {
+    global().defineProperty(EXGlobalCoreObjectPropertyName, value: coreObject, options: .enumerable)
+  }
+}

package/ios/{Functions/AnyFunction.swift → Core/Functions/AnyFunctionDefinition.swift}

@@ -6,7 +6,7 @@ public typealias FunctionCallResult = Result<Any, Exception>
 /**
  A protocol for any type-erased function.
  */
-internal protocol AnyFunction: AnyDefinition, JavaScriptObjectBuilder {
+internal protocol AnyFunctionDefinition: AnyDefinition, JavaScriptObjectBuilder {
   /**
    Name of the function. JavaScript refers to the function by this name.
    */
@@ -47,7 +47,7 @@ internal protocol AnyFunction: AnyDefinition, JavaScriptObjectBuilder {
   func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext, callback: @escaping (FunctionCallResult) -> ())
 }
 
-extension AnyFunction {
+extension AnyFunctionDefinition {
   var requiredArgumentsCount: Int {
     var trailingOptionalArgumentsCount: Int = 0
 
@@ -79,4 +79,11 @@ internal class FunctionCallException: GenericException<String> {
   override var reason: String {
     "Calling the '\(param)' function has failed"
   }
+
+  override var code: String {
+    guard let cause = cause as? Exception else {
+      return super.code
+    }
+    return cause.code
+  }
 }

package/ios/Core/Functions/AsyncFunctionDefinition.swift

@@ -0,0 +1,150 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import Dispatch
+
+/**
+ Type-erased protocol for asynchronous functions.
+ */
+internal protocol AnyAsyncFunctionDefinition: AnyFunctionDefinition {
+  /**
+   Specifies on which queue the function should run.
+   */
+  func runOnQueue(_ queue: DispatchQueue?) -> Self
+}
+
+/**
+ The default queue used for module's async function calls.
+ */
+private let defaultQueue = DispatchQueue(label: "expo.modules.AsyncFunctionQueue", qos: .userInitiated)
+
+/**
+ Represents a function that can only be called asynchronously, thus its JavaScript equivalent returns a Promise.
+ */
+public final class AsyncFunctionDefinition<Args, FirstArgType, ReturnType>: AnyAsyncFunctionDefinition {
+  typealias ClosureType = (Args) throws -> ReturnType
+
+  /**
+   The underlying closure to run when the function is called.
+   */
+  let body: ClosureType
+
+  /**
+   Bool value indicating whether the function takes promise as the last argument.
+   */
+  let takesPromise: Bool
+
+  /**
+   Dispatch queue on which each function's call is run.
+   */
+  var queue: DispatchQueue?
+
+  init(
+    _ name: String,
+    firstArgType: FirstArgType.Type,
+    dynamicArgumentTypes: [AnyDynamicType],
+    _ body: @escaping ClosureType
+  ) {
+    self.name = name
+    self.takesPromise = dynamicArgumentTypes.last?.wraps(Promise.self) ?? false
+    self.dynamicArgumentTypes = dynamicArgumentTypes
+    self.body = body
+  }
+
+  // MARK: - AnyFunction
+
+  let name: String
+
+  let dynamicArgumentTypes: [AnyDynamicType]
+
+  var argumentsCount: Int {
+    return dynamicArgumentTypes.count - (takesOwner ? 1 : 0) - (takesPromise ? 1 : 0)
+  }
+
+  var takesOwner: Bool = false
+
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext, callback: @escaping (FunctionCallResult) -> ()) {
+    let promise = Promise { value in
+      callback(.success(Conversions.convertFunctionResult(value)))
+    } rejecter: { exception in
+      callback(.failure(exception))
+    }
+    var arguments: [Any] = concat(
+      arguments: args,
+      withOwner: owner,
+      withPromise: takesPromise ? promise : nil,
+      forFunction: self,
+      appContext: appContext
+    )
+
+    do {
+      try validateArgumentsNumber(function: self, received: args.count)
+
+      // All `JavaScriptValue` args must be preliminarly converted on the JS thread, so before we jump to the function's queue.
+      arguments = try cast(jsValues: arguments, forFunction: self, appContext: appContext)
+    } catch let error as Exception {
+      callback(.failure(error))
+      return
+    } catch {
+      callback(.failure(UnexpectedException(error)))
+      return
+    }
+
+    let queue = queue ?? defaultQueue
+
+    queue.async { [body, name] in
+      let returnedValue: ReturnType?
+
+      do {
+        // Convert arguments to the types desired by the function.
+        arguments = try cast(arguments: arguments, forFunction: self, appContext: appContext)
+
+        // swiftlint:disable:next force_cast
+        let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+
+        returnedValue = try body(argumentsTuple)
+      } catch let error as Exception {
+        promise.reject(FunctionCallException(name).causedBy(error))
+        return
+      } catch {
+        promise.reject(UnexpectedException(error))
+        return
+      }
+      if !self.takesPromise {
+        promise.resolve(returnedValue)
+      }
+    }
+  }
+
+  // MARK: - JavaScriptObjectBuilder
+
+  func build(appContext: AppContext) throws -> JavaScriptObject {
+    // It seems to be safe to capture a strong reference to `self` here. This is needed for detached functions, that are not part of the module definition.
+    // Module definitions are held in memory anyway, but detached definitions (returned by other functions) are not, so we need to capture them here.
+    // It will be deallocated when that JS host function is garbage-collected by the JS VM.
+    return try appContext.runtime.createAsyncFunction(name, argsCount: argumentsCount) { [self] this, args, resolve, reject in
+      self.call(by: this, withArguments: args, appContext: appContext) { result in
+        switch result {
+        case .failure(let error):
+          reject(error.code, error.description, nil)
+        case .success(let value):
+          resolve(value)
+        }
+      }
+    }
+  }
+
+  // MARK: - AnyAsyncFunctionDefinition
+
+  public func runOnQueue(_ queue: DispatchQueue?) -> Self {
+    self.queue = queue
+    return self
+  }
+}
+
+// MARK: - Exceptions
+
+internal final class NativeFunctionUnavailableException: GenericException<String> {
+  override var reason: String {
+    return "Native function '\(param)' is no longer available in memory"
+  }
+}

package/ios/Core/Functions/ConcurrentFunctionDefinition.swift

@@ -0,0 +1,112 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Represents a concurrent function that can only be called asynchronously, thus its JavaScript equivalent returns a Promise.
+ As opposed to `AsyncFunctionDefinition`, it can leverage the new Swift's concurrency model and take the async/await closure.
+ */
+public final class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>: AnyFunctionDefinition {
+  typealias ClosureType = (Args) async throws -> ReturnType
+
+  let body: ClosureType
+
+  init(
+    _ name: String,
+    firstArgType: FirstArgType.Type,
+    dynamicArgumentTypes: [AnyDynamicType],
+    _ body: @escaping ClosureType
+  ) {
+    self.name = name
+    self.body = body
+    self.dynamicArgumentTypes = dynamicArgumentTypes
+  }
+
+  // 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], appContext: AppContext, callback: @escaping (FunctionCallResult) -> Void) {
+    var arguments: [Any]
+
+    do {
+      try validateArgumentsNumber(function: self, received: args.count)
+
+      arguments = concat(
+        arguments: args,
+        withOwner: owner,
+        withPromise: nil,
+        forFunction: self,
+        appContext: appContext
+      )
+
+      // All `JavaScriptValue` args must be preliminarly converted on the JS thread, before we jump to the function's queue.
+      arguments = try cast(jsValues: arguments, forFunction: self, appContext: appContext)
+    } catch let error as Exception {
+      callback(.failure(error))
+      return
+    } catch {
+      callback(.failure(UnexpectedException(error)))
+      return
+    }
+
+    // Switch from the synchronous context to asynchronous
+    Task { [arguments] in
+      let result: Result<Any, Exception>
+
+      do {
+        // Convert arguments to the types desired by the function.
+        let finalArguments = try cast(arguments: arguments, forFunction: self, appContext: appContext)
+
+        // TODO: Right now we force cast the tuple in all types of functions, but we should throw another exception here.
+        // swiftlint:disable force_cast
+        let argumentsTuple = try Conversions.toTuple(finalArguments) as! Args
+        let returnValue = try await body(argumentsTuple)
+
+        result = .success(returnValue)
+      } catch let error as Exception {
+        result = .failure(FunctionCallException(name).causedBy(error))
+      } catch {
+        result = .failure(UnexpectedException(error))
+      }
+
+      // Go back to the JS thread to execute the callback
+      appContext.executeOnJavaScriptThread {
+        callback(result)
+      }
+    }
+  }
+
+  // MARK: - JavaScriptObjectBuilder
+
+  func build(appContext: AppContext) throws -> JavaScriptObject {
+    return try appContext.runtime.createAsyncFunction(name, argsCount: argumentsCount) {
+      [weak appContext, weak self, name] this, args, resolve, reject in
+
+      guard let appContext else {
+        let exception = Exceptions.AppContextLost()
+        return reject(exception.code, exception.description, nil)
+      }
+      guard let self else {
+        let exception = NativeFunctionUnavailableException(name)
+        return reject(exception.code, exception.description, nil)
+      }
+      self.call(by: this, withArguments: args, appContext: appContext) { result in
+        switch result {
+        case .failure(let error):
+          reject(error.code, error.description, nil)
+        case .success(let value):
+          // Convert some results to primitive types (e.g. records) or JS values (e.g. shared objects)
+          let convertedResult = Conversions.convertFunctionResult(value, appContext: appContext, dynamicType: ~ReturnType.self)
+          resolve(convertedResult)
+        }
+      }
+    }
+  }
+}