expo-modules-core 1.11.13 → 1.12.1

package/ios/ExpoBridgeModule.swift

@@ -1,108 +0,0 @@
-// Copyright 2022-present 650 Industries. All rights reserved.
-
-import React
-import Foundation
-
-/**
- The classic bridge module that is responsible for:
- - Creating and owning the `AppContext` when the Expo modules architecture is automatically initialized
-   by React Native (as opposed to native unit tests, where React Native is not used at all).
- - Installing the host object to the runtime.
- */
-@objc(ExpoBridgeModule)
-public final class ExpoBridgeModule: NSObject, RCTBridgeModule {
-  @objc
-  public let appContext: AppContext
-
-  /**
-   The initializer that is used by React Native when it loads bridge modules.
-   In this scenario, we create an `AppContext` that manages the
-   architecture of Expo modules and the app itself.
-   */
-  override convenience init() {
-    self.init(appContext: AppContext())
-  }
-
-  public init(appContext: AppContext) {
-    self.appContext = appContext
-    super.init()
-  }
-
-  deinit {
-    NotificationCenter.default.removeObserver(self)
-  }
-
-  // MARK: - RCTBridgeModule
-
-  public static func moduleName() -> String! {
-    return "ExpoModulesCore"
-  }
-
-  public static func requiresMainQueueSetup() -> Bool {
-    return true
-  }
-
-  public var bridge: RCTBridge! {
-    didSet {
-      appContext.reactBridge = bridge
-
-      let attachRuntime = { [weak self] in
-        guard let self = self, let bridge = self.appContext.reactBridge else {
-          return
-        }
-        self.appContext._runtime = EXJavaScriptRuntimeManager.runtime(fromBridge: bridge)
-      }
-
-      if bridge.responds(to: Selector(("runtime"))) {
-        // Getting the `runtime` on a different thread than JS is considered to be dangerous.
-        // However, we just checking if it exists. We don't do anything with it.
-        let result = bridge.perform(Selector(("runtime")))
-        if result == nil {
-          // When exporting expo modules using `extraModulesForBridge` (e.g. in Expo Go),
-          // the runtime won't be initiated before the bridge didSet method is called.
-          // Therefore, we need to wait for the main thread to complete its initialization by dispatching on it first.
-          bridge.dispatchBlock({ [weak self] in
-            guard let self = self, let bridge = self.appContext.reactBridge else {
-              return
-            }
-            bridge.dispatchBlock(attachRuntime, queue: RCTJSThread)
-          }, queue: DispatchQueue.main)
-          return
-        }
-      }
-
-      bridge.dispatchBlock(attachRuntime, queue: RCTJSThread)
-    }
-  }
-  
-  /**
-   This should be called inside EXNativeModulesProxy.setBridge()
-   */
-  @objc
-  public func legacyProxyDidSetBridge(legacyModulesProxy: LegacyNativeModulesProxy,
-                                      legacyModuleRegistry: EXModuleRegistry) {
-    appContext.legacyModuleRegistry = legacyModuleRegistry
-    appContext.legacyModulesProxy = legacyModulesProxy
-    
-    // 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")
-    appContext.moduleRegistry.register(moduleType: NativeModulesProxyModule.self)
-  }
-
-  // MARK: - Exported methods
-
-  @objc
-  public func installModules() {
-    guard let bridge else {
-      log.error("Cannot install native modules because the bridge is no longer available")
-      return
-    }
-
-    // TODO: Keep this condition until we remove the other way of installing modules.
-    // See didSet on the `bridge` property above.
-    if appContext._runtime == nil {
-      appContext._runtime = EXJavaScriptRuntimeManager.runtime(fromBridge: bridge)
-    }
-  }
-}

package/ios/ExpoRuntime.swift

@@ -1,28 +0,0 @@
-/**
- Property name of the core object in the global scope of the Expo JS runtime.
- */
-private let coreObjectPropertyName = "expo"
-
-@objc(EXRuntime)
-public final class ExpoRuntime: JavaScriptRuntime {
-  /**
-   The core object of the Expo runtime that is used to scope native Expo-specific functionalities.
-   It gets installed into the runtime as the `global.expo` object.
-   */
-  @objc
-  public private(set) var coreObject: JavaScriptObject?
-
-  internal func initializeCoreObject(_ coreObject: JavaScriptObject) throws {
-    guard self.coreObject == nil else {
-      throw CoreObjectInitializedException()
-    }
-    self.coreObject = coreObject
-    global().defineProperty(coreObjectPropertyName, value: coreObject, options: .enumerable)
-  }
-}
-
-private final class CoreObjectInitializedException: Exception {
-  override var reason: String {
-    "The core Expo object was already initialized"
-  }
-}

package/ios/Functions/AsyncFunctionComponent.swift

@@ -1,327 +0,0 @@
-// Copyright 2022-present 650 Industries. All rights reserved.
-
-import Dispatch
-
-/**
- Type-erased protocol for asynchronous functions.
- */
-internal protocol AnyAsyncFunctionComponent: AnyFunction {
-  /**
-   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 AsyncFunctionComponent<Args, FirstArgType, ReturnType>: AnyAsyncFunctionComponent {
-  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 {
-    return try appContext.runtime.createAsyncFunction(name, argsCount: argumentsCount) { [weak self, name] this, args, resolve, reject in
-      guard let self = 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):
-          resolve(value)
-        }
-      }
-    }
-  }
-
-  // MARK: - AnyAsyncFunctionComponent
-
-  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"
-  }
-}
-
-// MARK: - Factories
-
-/**
- Asynchronous function without arguments.
- */
-public func AsyncFunction<R>(
-  _ name: String,
-  @_implicitSelfCapture _ closure: @escaping () throws -> R
-) -> AsyncFunctionComponent<(), Void, R> {
-  return AsyncFunctionComponent(
-    name,
-    firstArgType: Void.self,
-    dynamicArgumentTypes: [],
-    closure
-  )
-}
-
-/**
- Asynchronous function with one argument.
- */
-public func AsyncFunction<R, A0: AnyArgument>(
-  _ name: String,
-  @_implicitSelfCapture _ closure: @escaping (A0) throws -> R
-) -> AsyncFunctionComponent<(A0), A0, R> {
-  return AsyncFunctionComponent(
-    name,
-    firstArgType: A0.self,
-    dynamicArgumentTypes: [~A0.self],
-    closure
-  )
-}
-
-/**
- Asynchronous function with two arguments.
- */
-public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
-  _ name: String,
-  @_implicitSelfCapture _ closure: @escaping (A0, A1) throws -> R
-) -> AsyncFunctionComponent<(A0, A1), A0, R> {
-  return AsyncFunctionComponent(
-    name,
-    firstArgType: A0.self,
-    dynamicArgumentTypes: [~A0.self, ~A1.self],
-    closure
-  )
-}
-
-/**
- Asynchronous function with three arguments.
- */
-public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
-  _ name: String,
-  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2) throws -> R
-) -> AsyncFunctionComponent<(A0, A1, A2), A0, R> {
-  return AsyncFunctionComponent(
-    name,
-    firstArgType: A0.self,
-    dynamicArgumentTypes: [
-      ~A0.self,
-      ~A1.self,
-      ~A2.self
-    ],
-    closure
-  )
-}
-
-/**
- Asynchronous function with four arguments.
- */
-public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
-  _ name: String,
-  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3) throws -> R
-) -> AsyncFunctionComponent<(A0, A1, A2, A3), A0, R> {
-  return AsyncFunctionComponent(
-    name,
-    firstArgType: A0.self,
-    dynamicArgumentTypes: [
-      ~A0.self,
-      ~A1.self,
-      ~A2.self,
-      ~A3.self
-    ],
-    closure
-  )
-}
-
-/**
- Asynchronous function with five arguments.
- */
-public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
-  _ name: String,
-  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
-) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4), A0, R> {
-  return AsyncFunctionComponent(
-    name,
-    firstArgType: A0.self,
-    dynamicArgumentTypes: [
-      ~A0.self,
-      ~A1.self,
-      ~A2.self,
-      ~A3.self,
-      ~A4.self
-    ],
-    closure
-  )
-}
-
-/**
- Asynchronous function with six arguments.
- */
-public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
-  _ name: String,
-  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
-) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4, A5), A0, R> {
-  return AsyncFunctionComponent(
-    name,
-    firstArgType: A0.self,
-    dynamicArgumentTypes: [
-      ~A0.self,
-      ~A1.self,
-      ~A2.self,
-      ~A3.self,
-      ~A4.self,
-      ~A5.self
-    ],
-    closure
-  )
-}
-
-/**
- Asynchronous function with seven arguments.
- */
-public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument>(
-  _ name: String,
-  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) throws -> R
-) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4, A5, A6), A0, R> {
-  return AsyncFunctionComponent(
-    name,
-    firstArgType: A0.self,
-    dynamicArgumentTypes: [
-      ~A0.self,
-      ~A1.self,
-      ~A2.self,
-      ~A3.self,
-      ~A4.self,
-      ~A5.self,
-      ~A6.self
-    ],
-    closure
-  )
-}
-
-/**
- Asynchronous function with eight arguments.
- */
-public func AsyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument, A7: AnyArgument>(
-  _ name: String,
-  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) throws -> R
-) -> AsyncFunctionComponent<(A0, A1, A2, A3, A4, A5, A6, A7), A0, R> {
-  return AsyncFunctionComponent(
-    name,
-    firstArgType: A0.self,
-    dynamicArgumentTypes: [
-      ~A0.self,
-      ~A1.self,
-      ~A2.self,
-      ~A3.self,
-      ~A4.self,
-      ~A5.self,
-      ~A6.self,
-      ~A7.self
-    ],
-    closure
-  )
-}