expo-modules-core 0.4.9 → 0.6.2

package/ios/AppDelegates/ExpoAppDelegate.swift

@@ -0,0 +1,282 @@
+import UIKit
+import Dispatch
+import Foundation
+
+var subscribers = [ExpoAppDelegateSubscriberProtocol]()
+var reactDelegateHandlers = [ExpoReactDelegateHandler]()
+
+/**
+ Allows classes extending `ExpoAppDelegateSubscriber` to hook into project's app delegate
+ by forwarding `UIApplicationDelegate` events to the subscribers.
+
+ Keep functions and markers in sync with https://developer.apple.com/documentation/uikit/uiapplicationdelegate
+ */
+@objc(EXExpoAppDelegate)
+open class ExpoAppDelegate: UIResponder, UIApplicationDelegate {
+  open var window: UIWindow?
+
+  @objc
+  public let reactDelegate = ExpoReactDelegate(handlers: reactDelegateHandlers)
+
+  // MARK: - Initializing the App
+
+  open func application(_ application: UIApplication, willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
+    return subscribers.reduce(false) { result, subscriber in
+      return subscriber.application?(application, willFinishLaunchingWithOptions: launchOptions) ?? false || result
+    }
+  }
+
+  open func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
+    return subscribers.reduce(false) { result, subscriber in
+      return subscriber.application?(application, didFinishLaunchingWithOptions: launchOptions) ?? false || result
+    }
+  }
+
+  // TODO: - Configuring and Discarding Scenes
+
+  // MARK: - Responding to App Life-Cycle Events
+
+  @objc
+  open func applicationDidBecomeActive(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationDidBecomeActive?(application) }
+  }
+
+  @objc
+  open func applicationWillResignActive(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationWillResignActive?(application) }
+  }
+
+  @objc
+  open func applicationDidEnterBackground(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationDidEnterBackground?(application) }
+  }
+
+  open func applicationWillEnterForeground(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationWillEnterForeground?(application) }
+  }
+
+  open func applicationWillTerminate(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationWillTerminate?(application) }
+  }
+
+  // TODO: - Responding to Environment Changes
+
+  // TODO: - Managing App State Restoration
+
+  // MARK: - Downloading Data in the Background
+
+  open func application(_ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) {
+    let selector = #selector(application(_:handleEventsForBackgroundURLSession:completionHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    let dispatchQueue = DispatchQueue(label: "expo.application.handleBackgroundEvents")
+
+    let handler = {
+      dispatchQueue.sync {
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          completionHandler()
+        }
+      }
+    }
+
+    subs.forEach {
+      $0.application?(application, handleEventsForBackgroundURLSession: identifier, completionHandler: handler)
+    }
+  }
+
+  // MARK: - Handling Remote Notification Registration
+
+  open func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+    subscribers.forEach { $0.application?(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken) }
+  }
+
+  open func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
+    subscribers.forEach { $0.application?(application, didFailToRegisterForRemoteNotificationsWithError: error) }
+  }
+
+  open func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+    let selector = #selector(application(_:didReceiveRemoteNotification:fetchCompletionHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    var fetchResult: UIBackgroundFetchResult = .noData
+    let dispatchQueue = DispatchQueue(label: "expo.application.remoteNotification", qos: .userInteractive)
+
+    let handler = { (result: UIBackgroundFetchResult) in
+      dispatchQueue.sync {
+        if result == .failed {
+          fetchResult = .failed
+        } else if fetchResult != .failed && result == .newData {
+          fetchResult = .newData
+        }
+
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          completionHandler(fetchResult)
+        }
+      }
+    }
+
+    subs.forEach { subscriber in
+      subscriber.application?(application, didReceiveRemoteNotification: userInfo, fetchCompletionHandler: handler)
+    }
+  }
+
+  // MARK: - Continuing User Activity and Handling Quick Actions
+
+  open func application(_ application: UIApplication, willContinueUserActivityWithType userActivityType: String) -> Bool {
+    return subscribers.reduce(false) { result, subscriber in
+      return subscriber.application?(application, willContinueUserActivityWithType: userActivityType) ?? false || result
+    }
+  }
+
+  open func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
+    let selector = #selector(application(_:continue:restorationHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    let dispatchQueue = DispatchQueue(label: "expo.application.continueUserActivity", qos: .userInteractive)
+    var allRestorableObjects = [UIUserActivityRestoring]()
+
+    let handler = { (restorableObjects: [UIUserActivityRestoring]?) in
+      dispatchQueue.sync {
+        if let restorableObjects = restorableObjects {
+          allRestorableObjects.append(contentsOf: restorableObjects)
+        }
+
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          restorationHandler(allRestorableObjects)
+        }
+      }
+    }
+
+    return subs.reduce(false) { result, subscriber in
+      return subscriber.application?(application, continue: userActivity, restorationHandler: handler) ?? false || result
+    }
+  }
+
+  open func application(_ application: UIApplication, didUpdate userActivity: NSUserActivity) {
+    return subscribers.forEach { $0.application?(application, didUpdate: userActivity) }
+  }
+
+  open func application(_ application: UIApplication, didFailToContinueUserActivityWithType userActivityType: String, error: Error) {
+    return subscribers.forEach {
+      $0.application?(application, didFailToContinueUserActivityWithType: userActivityType, error: error)
+    }
+  }
+
+  open func application(_ application: UIApplication, performActionFor shortcutItem: UIApplicationShortcutItem, completionHandler: @escaping (Bool) -> Void) {
+    let selector = #selector(application(_:performActionFor:completionHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    var result: Bool = false
+    let dispatchQueue = DispatchQueue(label: "expo.application.performAction", qos: .userInteractive)
+
+    let handler = { (succeeded: Bool) in
+      dispatchQueue.sync {
+        result = result || succeeded
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          completionHandler(result)
+        }
+      }
+    }
+
+    subs.forEach { subscriber in
+      subscriber.application?(application, performActionFor: shortcutItem, completionHandler: handler)
+    }
+  }
+
+  // MARK: - Background Fetch
+
+  open func application(_ application: UIApplication, performFetchWithCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+    let selector = #selector(application(_:performFetchWithCompletionHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    var fetchResult: UIBackgroundFetchResult = .noData
+    let dispatchQueue = DispatchQueue(label: "expo.application.performFetch", qos: .userInteractive)
+
+    let handler = { (result: UIBackgroundFetchResult) in
+      dispatchQueue.sync {
+        if result == .failed {
+          fetchResult = .failed
+        } else if fetchResult != .failed && result == .newData {
+          fetchResult = .newData
+        }
+
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          completionHandler(fetchResult)
+        }
+      }
+    }
+
+    subs.forEach { subscriber in
+      subscriber.application?(application, performFetchWithCompletionHandler: handler)
+    }
+  }
+
+  // TODO: - Interacting With WatchKit
+
+  // TODO: - Interacting With HealthKit
+
+  // MARK: - Opening a URL-Specified Resource
+
+  open func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
+    return subscribers.contains { subscriber in
+      return subscriber.application?(app, open: url, options: options) ?? false
+    }
+  }
+
+  // TODO: - Disallowing Specified App Extension Types
+
+  // TODO: - Handling SiriKit Intents
+
+  // TODO: - Handling CloudKit Invitations
+
+  // TODO: - Managing Interface Geometry
+
+  // MARK: - Statics
+
+  @objc
+  public static func registerSubscribersFrom(modulesProvider: ModulesProviderObjCProtocol) {
+    guard let provider = modulesProvider as? ModulesProviderProtocol else {
+      fatalError("Expo modules provider must implement `ModulesProviderProtocol`.")
+    }
+    provider.getAppDelegateSubscribers().forEach { subscriberType in
+      registerSubscriber(subscriberType.init())
+    }
+  }
+
+  @objc
+  public static func registerSubscriber(_ subscriber: ExpoAppDelegateSubscriberProtocol) {
+    if subscribers.contains(where: { $0 === subscriber }) {
+      fatalError("Given app delegate subscriber `\(String(describing: subscriber))` is already registered.")
+    }
+    subscribers.append(subscriber)
+  }
+
+  @objc
+  public static func getSubscriber(_ name: String) -> ExpoAppDelegateSubscriberProtocol? {
+    return subscribers.first { String(describing: $0) == name }
+  }
+
+  @objc
+  public static func registerReactDelegateHandlersFrom(modulesProvider: ModulesProviderObjCProtocol) {
+    guard let provider = modulesProvider as? ModulesProviderProtocol else {
+      fatalError("Expo modules provider must implement `ModulesProviderProtocol`.")
+    }
+    provider.getReactDelegateHandlers()
+      .sorted { (tuple1, tuple2) -> Bool in
+        return ModulePriorities.get(tuple1.packageName) > ModulePriorities.get(tuple2.packageName)
+      }
+      .forEach { handlerTuple in
+        reactDelegateHandlers.append(handlerTuple.handler.init())
+      }
+  }
+}

package/ios/AppDelegates/ExpoAppDelegateSubscriber.swift

@@ -0,0 +1,24 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+import UIKit
+
+/**
+ Base class for app delegate subscribers. Ensures the class
+ inherits from `UIResponder` and has `required init()` initializer.
+ */
+@objc(EXBaseAppDelegateSubscriber)
+open class BaseExpoAppDelegateSubscriber: UIResponder {
+  public override required init() {}
+}
+
+/**
+ Typealias to `UIApplicationDelegate` protocol.
+ Might be useful for compatibility reasons if we decide to add more things here.
+ */
+@objc(EXAppDelegateSubscriberProtocol)
+public protocol ExpoAppDelegateSubscriberProtocol: UIApplicationDelegate {}
+
+/**
+ Typealias merging the base class for app delegate subscribers and protocol inheritance to `UIApplicationDelegate`.
+ */
+public typealias ExpoAppDelegateSubscriber = BaseExpoAppDelegateSubscriber & ExpoAppDelegateSubscriberProtocol

package/ios/EXAppDefines.h

@@ -0,0 +1,26 @@
+// Copyright 2016-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ For expo modules to get app build time preprocessor values.
+ We ship some modules in [prebuilt binaries](https://expo.fyi/prebuilt-modules),
+ classic defines like `DEBUG` or `RCT_DEV` may not work as expected
+ because the prebuilt modules are always built with Release configuration.
+ This class acts as a supporter to get app build time preprocessor values.
+ */
+@interface EXAppDefines : NSObject
+
+@property (class, nonatomic, assign, readonly) BOOL APP_DEBUG NS_SWIFT_NAME(APP_DEBUG);
+@property (class, nonatomic, assign, readonly) BOOL APP_RCT_DEBUG NS_SWIFT_NAME(APP_RCT_DEBUG);
+@property (class, nonatomic, assign, readonly) BOOL APP_RCT_DEV NS_SWIFT_NAME(APP_RCT_DEV);
+
++ (NSDictionary *)getAllDefines;
+
++ (void)load:(NSDictionary *)defines;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/EXAppDefines.m

@@ -0,0 +1,61 @@
+// Copyright 2016-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXAppDefines.h>
+#import <React/RCTDefines.h>
+
+@implementation EXAppDefines
+
+static NSDictionary *_storage;
+static BOOL _loaded = NO;
+
++ (BOOL)APP_DEBUG
+{
+  [self throwIfNotLoaded];
+  return [_storage[@"APP_DEBUG"] boolValue];
+}
+
++ (BOOL)APP_RCT_DEBUG
+{
+  [self throwIfNotLoaded];
+  return [_storage[@"APP_RCT_DEBUG"] boolValue];
+}
+
++ (BOOL)APP_RCT_DEV
+{
+  [self throwIfNotLoaded];
+  return [_storage[@"APP_RCT_DEV"] boolValue];
+}
+
++ (NSDictionary *)getAllDefines
+{
+  return _storage;
+}
+
++ (void)load:(NSDictionary *)defines
+{
+  NSAssert([NSThread isMainThread], @"This function must be called on main thread");
+  NSAssert(!_loaded, @"EXAppDefines is already loaded");
+  if (!_loaded) {
+    _storage = defines;
+    _loaded = YES;
+  }
+}
+
+// Private function for EXAppDefinesTest to unload the current state.
++ (void)_unload
+{
+  _storage = nil;
+  _loaded = NO;
+}
+
++ (void)throwIfNotLoaded
+{
+  if (!_loaded) {
+    @throw [NSException exceptionWithName:NSInternalInconsistencyException
+                                   reason:@"EXAppDefines is not loaded."
+                                 userInfo:nil];
+  }
+}
+
+
+@end

package/ios/ExpoModulesCore.podspec

@@ -18,24 +18,29 @@ Pod::Spec.new do |s|
 
   # Swift/Objective-C compatibility
   s.pod_target_xcconfig = {
-    'DEFINES_MODULE' => 'YES'
+    'USE_HEADERMAP' => 'YES',
+    'DEFINES_MODULE' => 'YES',
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++14',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule',
   }
 
   s.dependency 'React-Core'
+  s.dependency 'ReactCommon/turbomodule/core'
 
   if !$ExpoUseSources&.include?(package['name']) && ENV['EXPO_USE_SOURCE'].to_i == 0 && File.exist?("#{s.name}.xcframework") && Gem::Version.new(Pod::VERSION) >= Gem::Version.new('1.10.0')
     s.source_files = '**/*.h'
     s.vendored_frameworks = "#{s.name}.xcframework"
   else
-    s.source_files = '**/*.{h,m,swift}'
+    s.source_files = '**/*.{h,m,mm,swift}'
   end
 
   s.exclude_files = 'Tests/'
+  s.private_header_files = ['**/*+Private.h', '**/Swift.h']
 
   s.test_spec 'Tests' do |test_spec|
     test_spec.dependency 'Quick'
     test_spec.dependency 'Nimble'
 
-    test_spec.source_files = 'Tests/**/*.swift'
+    test_spec.source_files = 'Tests/**/*.{m,swift}'
   end
 end

package/ios/JSI/ExpoModulesProxySpec.h

@@ -0,0 +1,24 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#ifdef __cplusplus
+
+#import <jsi/jsi.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+#import <ExpoModulesCore/EXNativeModulesProxy.h>
+
+using namespace facebook;
+using namespace react;
+
+namespace expo {
+
+class JSI_EXPORT ExpoModulesProxySpec : public TurboModule {
+public:
+  ExpoModulesProxySpec(std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy);
+
+  EXNativeModulesProxy *nativeModulesProxy;
+};
+
+} // namespace expo
+
+#endif

package/ios/JSI/ExpoModulesProxySpec.mm

@@ -0,0 +1,135 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <React/RCTUtils.h>
+
+#import <ExpoModulesCore/JSIConversions.h>
+#import <ExpoModulesCore/ExpoModulesProxySpec.h>
+
+namespace expo {
+
+using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper);
+
+static void callPromiseSetupWithBlock(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker, std::shared_ptr<Promise> promise, PromiseInvocationBlock setupBlock)
+{
+  auto weakResolveWrapper = CallbackWrapper::createWeak(promise->resolve_.getFunction(runtime), runtime, jsInvoker);
+  auto weakRejectWrapper = CallbackWrapper::createWeak(promise->reject_.getFunction(runtime), runtime, jsInvoker);
+
+  __block BOOL resolveWasCalled = NO;
+  __block BOOL rejectWasCalled = NO;
+
+  RCTPromiseResolveBlock resolveBlock = ^(id result) {
+    if (rejectWasCalled) {
+      throw std::runtime_error("Tried to resolve a promise after it's already been rejected.");
+    }
+
+    if (resolveWasCalled) {
+      throw std::runtime_error("Tried to resolve a promise more than once.");
+    }
+
+    auto strongResolveWrapper = weakResolveWrapper.lock();
+    auto strongRejectWrapper = weakRejectWrapper.lock();
+    if (!strongResolveWrapper || !strongRejectWrapper) {
+      return;
+    }
+
+    strongResolveWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, result]() {
+      auto strongResolveWrapper2 = weakResolveWrapper.lock();
+      auto strongRejectWrapper2 = weakRejectWrapper.lock();
+      if (!strongResolveWrapper2 || !strongRejectWrapper2) {
+        return;
+      }
+
+      jsi::Runtime &rt = strongResolveWrapper2->runtime();
+      jsi::Value arg = convertObjCObjectToJSIValue(rt, result);
+      strongResolveWrapper2->callback().call(rt, arg);
+
+      strongResolveWrapper2->destroy();
+      strongRejectWrapper2->destroy();
+    });
+
+    resolveWasCalled = YES;
+  };
+
+  RCTPromiseRejectBlock rejectBlock = ^(NSString *code, NSString *message, NSError *error) {
+    if (resolveWasCalled) {
+      throw std::runtime_error("Tried to reject a promise after it's already been resolved.");
+    }
+
+    if (rejectWasCalled) {
+      throw std::runtime_error("Tried to reject a promise more than once.");
+    }
+
+    auto strongResolveWrapper = weakResolveWrapper.lock();
+    auto strongRejectWrapper = weakRejectWrapper.lock();
+    if (!strongResolveWrapper || !strongRejectWrapper) {
+      return;
+    }
+
+    NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(code, message, error);
+    strongRejectWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, jsError]() {
+      auto strongResolveWrapper2 = weakResolveWrapper.lock();
+      auto strongRejectWrapper2 = weakRejectWrapper.lock();
+      if (!strongResolveWrapper2 || !strongRejectWrapper2) {
+        return;
+      }
+
+      jsi::Runtime &rt = strongRejectWrapper2->runtime();
+      jsi::Value arg = convertNSDictionaryToJSIObject(rt, jsError);
+      strongRejectWrapper2->callback().call(rt, arg);
+
+      strongResolveWrapper2->destroy();
+      strongRejectWrapper2->destroy();
+    });
+
+    rejectWasCalled = YES;
+  };
+
+  setupBlock(resolveBlock, rejectBlock);
+}
+
+static jsi::Value __hostFunction_ExpoModulesProxySpec_callMethodAsync(jsi::Runtime &runtime, TurboModule &turboModule, const jsi::Value *args, size_t count)
+{
+  auto expoModulesProxy = static_cast<ExpoModulesProxySpec *>(&turboModule);
+
+  // The function that is invoked as a setup of the JS `Promise`.
+  auto promiseSetupFunc = [expoModulesProxy, args](jsi::Runtime &runtime, std::shared_ptr<Promise> promise) {
+    callPromiseSetupWithBlock(runtime, expoModulesProxy->jsInvoker_, promise, ^(RCTPromiseResolveBlock resolver, RCTPromiseRejectBlock rejecter) {
+      NSString *moduleName = convertJSIStringToNSString(runtime, args[0].getString(runtime));
+      NSString *methodName = convertJSIStringToNSString(runtime, args[1].getString(runtime));
+      NSArray *arguments = convertJSIArrayToNSArray(runtime, args[2].getObject(runtime).asArray(runtime), expoModulesProxy->jsInvoker_);
+
+      [expoModulesProxy->nativeModulesProxy callMethod:moduleName
+                                       methodNameOrKey:methodName
+                                             arguments:arguments
+                                              resolver:resolver
+                                              rejecter:rejecter];
+    });
+  };
+
+  return createPromiseAsJSIValue(runtime, promiseSetupFunc);
+}
+
+static jsi::Value __hostFunction_ExpoModulesProxySpec_callMethodSync(jsi::Runtime &runtime, TurboModule &turboModule, const jsi::Value *args, size_t count)
+{
+  auto expoModulesProxy = static_cast<ExpoModulesProxySpec *>(&turboModule);
+  NSString *moduleName = convertJSIStringToNSString(runtime, args[0].getString(runtime));
+  NSString *methodName = convertJSIStringToNSString(runtime, args[1].getString(runtime));
+  NSArray *arguments = convertJSIArrayToNSArray(runtime, args[2].getObject(runtime).asArray(runtime), expoModulesProxy->jsInvoker_);
+
+  id result = [expoModulesProxy->nativeModulesProxy callMethodSync:moduleName
+                                                        methodName:methodName
+                                                         arguments:arguments];
+
+  return convertObjCObjectToJSIValue(runtime, result);
+}
+
+ExpoModulesProxySpec::ExpoModulesProxySpec(std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy) :
+  TurboModule("ExpoModulesProxy", callInvoker),
+  nativeModulesProxy(nativeModulesProxy)
+{
+  methodMap_["callMethodAsync"] = MethodMetadata {3, __hostFunction_ExpoModulesProxySpec_callMethodAsync};
+
+  methodMap_["callMethodSync"] = MethodMetadata {3, __hostFunction_ExpoModulesProxySpec_callMethodSync};
+}
+
+} // namespace expo

package/ios/JSI/JSIConversions.h

@@ -0,0 +1,42 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#ifdef __cplusplus
+
+#import <Foundation/Foundation.h>
+
+#import <jsi/jsi.h>
+#import <React/RCTBridgeModule.h>
+#import <ReactCommon/CallInvoker.h>
+
+using namespace facebook;
+using namespace react;
+
+namespace expo {
+
+jsi::Value convertNSNumberToJSIBoolean(jsi::Runtime &runtime, NSNumber *value);
+
+jsi::Value convertNSNumberToJSINumber(jsi::Runtime &runtime, NSNumber *value);
+
+jsi::String convertNSStringToJSIString(jsi::Runtime &runtime, NSString *value);
+
+jsi::Object convertNSDictionaryToJSIObject(jsi::Runtime &runtime, NSDictionary *value);
+
+jsi::Array convertNSArrayToJSIArray(jsi::Runtime &runtime, NSArray *value);
+
+std::vector<jsi::Value> convertNSArrayToStdVector(jsi::Runtime &runtime, NSArray *value);
+
+jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value);
+
+NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::String &value);
+
+NSArray *convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker);
+
+NSDictionary *convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker);
+
+id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker);
+
+RCTResponseSenderBlock convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value, std::shared_ptr<CallInvoker> jsInvoker);
+
+} // namespace expo
+
+#endif