expo-modules-core 0.4.9 → 0.6.2

package/ios/JSI/JSIConversions.mm

@@ -0,0 +1,164 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ReactCommon/TurboModuleUtils.h>
+#import <ExpoModulesCore/JSIConversions.h>
+
+namespace expo {
+
+/**
+ * All static helper functions are ObjC++ specific.
+ */
+jsi::Value convertNSNumberToJSIBoolean(jsi::Runtime &runtime, NSNumber *value)
+{
+  return jsi::Value((bool)[value boolValue]);
+}
+
+jsi::Value convertNSNumberToJSINumber(jsi::Runtime &runtime, NSNumber *value)
+{
+  return jsi::Value([value doubleValue]);
+}
+
+jsi::String convertNSStringToJSIString(jsi::Runtime &runtime, NSString *value)
+{
+  return jsi::String::createFromUtf8(runtime, [value UTF8String] ?: "");
+}
+
+jsi::Object convertNSDictionaryToJSIObject(jsi::Runtime &runtime, NSDictionary *value)
+{
+  jsi::Object result = jsi::Object(runtime);
+  for (NSString *k in value) {
+    result.setProperty(runtime, [k UTF8String], convertObjCObjectToJSIValue(runtime, value[k]));
+  }
+  return result;
+}
+
+jsi::Array convertNSArrayToJSIArray(jsi::Runtime &runtime, NSArray *value)
+{
+  jsi::Array result = jsi::Array(runtime, value.count);
+  for (size_t i = 0; i < value.count; i++) {
+    result.setValueAtIndex(runtime, i, convertObjCObjectToJSIValue(runtime, value[i]));
+  }
+  return result;
+}
+
+std::vector<jsi::Value> convertNSArrayToStdVector(jsi::Runtime &runtime, NSArray *value)
+{
+  std::vector<jsi::Value> result;
+  for (size_t i = 0; i < value.count; i++) {
+    result.emplace_back(convertObjCObjectToJSIValue(runtime, value[i]));
+  }
+  return result;
+}
+
+jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
+{
+  if ([value isKindOfClass:[NSString class]]) {
+    return convertNSStringToJSIString(runtime, (NSString *)value);
+  } else if ([value isKindOfClass:[NSNumber class]]) {
+    if ([value isKindOfClass:[@YES class]]) {
+      return convertNSNumberToJSIBoolean(runtime, (NSNumber *)value);
+    }
+    return convertNSNumberToJSINumber(runtime, (NSNumber *)value);
+  } else if ([value isKindOfClass:[NSDictionary class]]) {
+    return convertNSDictionaryToJSIObject(runtime, (NSDictionary *)value);
+  } else if ([value isKindOfClass:[NSArray class]]) {
+    return convertNSArrayToJSIArray(runtime, (NSArray *)value);
+  } else if (value == (id)kCFNull) {
+    return jsi::Value::null();
+  }
+  return jsi::Value::undefined();
+}
+
+NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::String &value)
+{
+  return [NSString stringWithUTF8String:value.utf8(runtime).c_str()];
+}
+
+NSArray *convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  size_t size = value.size(runtime);
+  NSMutableArray *result = [NSMutableArray new];
+  for (size_t i = 0; i < size; i++) {
+    // Insert kCFNull when it's `undefined` value to preserve the indices.
+    [result
+        addObject:convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i), jsInvoker) ?: (id)kCFNull];
+  }
+  return [result copy];
+}
+
+NSDictionary *convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  jsi::Array propertyNames = value.getPropertyNames(runtime);
+  size_t size = propertyNames.size(runtime);
+  NSMutableDictionary *result = [NSMutableDictionary new];
+  for (size_t i = 0; i < size; i++) {
+    jsi::String name = propertyNames.getValueAtIndex(runtime, i).getString(runtime);
+    NSString *k = convertJSIStringToNSString(runtime, name);
+    id v = convertJSIValueToObjCObject(runtime, value.getProperty(runtime, name), jsInvoker);
+    if (v) {
+      result[k] = v;
+    }
+  }
+  return [result copy];
+}
+
+id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  if (value.isUndefined() || value.isNull()) {
+    return nil;
+  }
+  if (value.isBool()) {
+    return @(value.getBool());
+  }
+  if (value.isNumber()) {
+    return @(value.getNumber());
+  }
+  if (value.isString()) {
+    return convertJSIStringToNSString(runtime, value.getString(runtime));
+  }
+  if (value.isObject()) {
+    jsi::Object o = value.getObject(runtime);
+    if (o.isArray(runtime)) {
+      return convertJSIArrayToNSArray(runtime, o.getArray(runtime), jsInvoker);
+    }
+    if (o.isFunction(runtime)) {
+      return convertJSIFunctionToCallback(runtime, std::move(o.getFunction(runtime)), jsInvoker);
+    }
+    return convertJSIObjectToNSDictionary(runtime, o, jsInvoker);
+  }
+
+  throw std::runtime_error("Unsupported jsi::jsi::Value kind");
+}
+
+RCTResponseSenderBlock convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto weakWrapper = CallbackWrapper::createWeak(value.getFunction(runtime), runtime, jsInvoker);
+  BOOL __block wrapperWasCalled = NO;
+  RCTResponseSenderBlock callback = ^(NSArray *responses) {
+    if (wrapperWasCalled) {
+      throw std::runtime_error("callback arg cannot be called more than once");
+    }
+
+    auto strongWrapper = weakWrapper.lock();
+    if (!strongWrapper) {
+      return;
+    }
+
+    strongWrapper->jsInvoker().invokeAsync([weakWrapper, responses]() {
+      auto strongWrapper2 = weakWrapper.lock();
+      if (!strongWrapper2) {
+        return;
+      }
+
+      std::vector<jsi::Value> args = convertNSArrayToStdVector(strongWrapper2->runtime(), responses);
+      strongWrapper2->callback().call(strongWrapper2->runtime(), (const jsi::Value *)args.data(), args.size());
+      strongWrapper2->destroy();
+    });
+
+    wrapperWasCalled = YES;
+  };
+
+  return callback;
+}
+
+} // namespace expo

package/ios/JSI/JSIInstaller.h

@@ -0,0 +1,19 @@
+// 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 {
+
+void installRuntimeObjects(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy);
+
+} // namespace expo
+
+#endif

package/ios/JSI/JSIInstaller.mm

@@ -0,0 +1,22 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/JSIInstaller.h>
+#import <ExpoModulesCore/ExpoModulesProxySpec.h>
+
+using namespace facebook;
+using namespace react;
+
+//using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper);
+
+namespace expo {
+
+void installRuntimeObjects(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy)
+{
+  auto expoModulesProxyModule = std::make_shared<ExpoModulesProxySpec>(callInvoker, nativeModulesProxy);
+
+  runtime
+    .global()
+    .setProperty(runtime, "ExpoModulesProxy", jsi::Object::createFromHostObject(runtime, expoModulesProxyModule));
+}
+
+} // namespace expo

package/ios/ModuleRegistryAdapter/EXModuleRegistryAdapter.m

@@ -7,12 +7,7 @@
 #import <ExpoModulesCore/EXViewManagerAdapterClassesRegistry.h>
 #import <ExpoModulesCore/EXModuleRegistryHolderReactModule.h>
 #import <ExpoModulesCore/EXReactNativeEventEmitter.h>
-#if __has_include(<ExpoModulesCore/ExpoModulesCore-Swift.h>)
-// For cocoapods framework, the generated swift header will be inside ExpoModulesCore module
-#import <ExpoModulesCore/ExpoModulesCore-Swift.h>
-#else
-#import "ExpoModulesCore-Swift.h"
-#endif
+#import <ExpoModulesCore/Swift.h>
 
 @interface EXModuleRegistryAdapter ()
 

package/ios/NativeModulesProxy/EXNativeModulesProxy.h

@@ -12,6 +12,7 @@
 // Swift compatibility headers (e.g. `ExpoModulesCore-Swift.h`) are not available in headers,
 // so we use class forward declaration here. Swift header must be imported in the `.m` file.
 @class SwiftInteropBridge;
+@protocol ModulesProviderObjCProtocol;
 
 NS_SWIFT_NAME(NativeModulesProxy)
 @interface EXNativeModulesProxy : NSObject <RCTBridgeModule>
@@ -21,4 +22,9 @@ NS_SWIFT_NAME(NativeModulesProxy)
 - (nonnull instancetype)init;
 - (nonnull instancetype)initWithModuleRegistry:(nullable EXModuleRegistry *)moduleRegistry;
 
+- (void)callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNameOrKey arguments:(NSArray *)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
+- (id)callMethodSync:(NSString *)moduleName methodName:(NSString *)methodName arguments:(NSArray *)arguments;
+
++ (id<ModulesProviderObjCProtocol>)getExpoModulesProvider;
+
 @end

package/ios/NativeModulesProxy/{EXNativeModulesProxy.m → EXNativeModulesProxy.mm}

@@ -8,6 +8,8 @@
 #import <React/RCTModuleData.h>
 #import <React/RCTEventDispatcherProtocol.h>
 
+#import <jsi/jsi.h>
+
 #import <ExpoModulesCore/EXNativeModulesProxy.h>
 #import <ExpoModulesCore/EXEventEmitter.h>
 #import <ExpoModulesCore/EXViewManager.h>
@@ -15,12 +17,8 @@
 #import <ExpoModulesCore/EXViewManagerAdapterClassesRegistry.h>
 #import <ExpoModulesCore/EXModuleRegistryProvider.h>
 #import <ExpoModulesCore/EXReactNativeEventEmitter.h>
-#if __has_include(<ExpoModulesCore/ExpoModulesCore-Swift.h>)
-// For cocoapods framework, the generated swift header will be inside ExpoModulesCore module
-#import <ExpoModulesCore/ExpoModulesCore-Swift.h>
-#else
-#import "ExpoModulesCore-Swift.h"
-#endif
+#import <ExpoModulesCore/JSIInstaller.h>
+#import <ExpoModulesCore/Swift.h>
 
 static const NSString *exportedMethodsNamesKeyPath = @"exportedMethods";
 static const NSString *viewManagersNamesKeyPath = @"viewManagersNames";
@@ -37,6 +35,12 @@ static const NSString *methodInfoArgumentsCountKey = @"argumentsCount";
 
 @end
 
+@interface RCTBridge (JSIRuntime)
+
+- (void *)runtime;
+
+@end
+
 @interface RCTComponentData (EXNativeModulesProxy)
 
 - (instancetype)initWithManagerClass:(Class)managerClass bridge:(RCTBridge *)bridge eventDispatcher:(id<RCTEventDispatcherProtocol>) eventDispatcher; // available in RN 0.65+
@@ -68,7 +72,7 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
 {
   if (self = [super init]) {
     _exModuleRegistry = moduleRegistry != nil ? moduleRegistry : [[EXModuleRegistryProvider new] moduleRegistry];
-    _swiftInteropBridge = [[SwiftInteropBridge alloc] initWithModulesProvider:[self getExpoModulesProvider] legacyModuleRegistry:_exModuleRegistry];
+    _swiftInteropBridge = [[SwiftInteropBridge alloc] initWithModulesProvider:[EXNativeModulesProxy getExpoModulesProvider] legacyModuleRegistry:_exModuleRegistry];
     _exportedMethodsKeys = [NSMutableDictionary dictionary];
     _exportedMethodsReverseKeys = [NSMutableDictionary dictionary];
     _ownsModuleRegistry = moduleRegistry == nil;
@@ -93,6 +97,9 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
 
 - (NSDictionary *)constantsToExport
 {
+  // Install the TurboModule implementation of the proxy.
+  [self installExpoTurboModules];
+
   NSMutableDictionary <NSString *, id> *exportedModulesConstants = [NSMutableDictionary dictionary];
   // Grab all the constants exported by modules
   for (EXExportedModule *exportedModule in [_exModuleRegistry getAllExportedModules]) {
@@ -121,7 +128,7 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
   }
 
   // Add entries from Swift modules
-  [exportedMethodsNamesAccumulator addEntriesFromDictionary:[_swiftInteropBridge exportedMethodNames]];
+  [exportedMethodsNamesAccumulator addEntriesFromDictionary:[_swiftInteropBridge exportedFunctionNames]];
 
   // Also, add `viewManagersNames` for sanity check and testing purposes -- with names we know what managers to mock on UIManager
   NSArray<EXViewManager *> *viewManagers = [_exModuleRegistry getAllViewManagers];
@@ -151,7 +158,7 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
 RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNameOrKey arguments:(NSArray *)arguments resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
   if ([_swiftInteropBridge hasModule:moduleName]) {
-    [_swiftInteropBridge callMethod:methodNameOrKey onModule:moduleName withArgs:arguments resolve:resolve reject:reject];
+    [_swiftInteropBridge callFunction:methodNameOrKey onModule:moduleName withArgs:arguments resolve:resolve reject:reject];
     return;
   }
   EXExportedModule *module = [_exModuleRegistry getExportedModuleForName:moduleName];
@@ -186,19 +193,44 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
   });
 }
 
-#pragma mark - Privates
+- (id)callMethodSync:(NSString *)moduleName methodName:(NSString *)methodName arguments:(NSArray *)arguments
+{
+  if ([_swiftInteropBridge hasModule:moduleName]) {
+    return [_swiftInteropBridge callFunctionSync:methodName onModule:moduleName withArgs:arguments];
+  }
+  return (id)kCFNull;
+}
+
+#pragma mark - Statics
 
-- (id<ModulesProviderObjCProtocol>)getExpoModulesProvider
++ (id<ModulesProviderObjCProtocol>)getExpoModulesProvider
 {
-  Class generatedExpoModulesProvider = NSClassFromString(@"ExpoModulesProvider");
-  // Checks if `ExpoModulesProvider` was generated
-  if (generatedExpoModulesProvider) {
+  // Dynamically gets the modules provider class.
+  // NOTE: This needs to be versioned in Expo Go.
+  Class generatedExpoModulesProvider;
+
+  // [0] When ExpoModulesCore is built as separated framework/module,
+  // we should explicitly load main bundle's `ExpoModulesProvider` class.
+  NSString *bundleName = NSBundle.mainBundle.infoDictionary[@"CFBundleName"];
+  if (bundleName != nil) {
+    generatedExpoModulesProvider = NSClassFromString([NSString stringWithFormat:@"%@.ExpoModulesProvider", bundleName]);
+    if (generatedExpoModulesProvider != nil) {
+      return [generatedExpoModulesProvider new];
+    }
+  }
+
+  // [1] Fallback to load `ExpoModulesProvider` class from the current module.
+  generatedExpoModulesProvider = NSClassFromString(@"ExpoModulesProvider");
+  if (generatedExpoModulesProvider != nil) {
     return [generatedExpoModulesProvider new];
-  } else {
-    return [ModulesProvider new];
   }
+
+  // [2] Fallback to load `ModulesProvider` if `ExpoModulesProvider` was not generated
+  return [ModulesProvider new];
 }
 
+#pragma mark - Privates
+
 - (void)registerExpoModulesInBridge:(RCTBridge *)bridge
 {
   // Registering expo modules in bridge is needed only when the proxy module owns the registry
@@ -255,8 +287,10 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
   // components in UIManager — we need to register them on our own.
   [self registerComponentDataForModuleClasses:additionalModuleClasses inBridge:bridge];
 
-  // Get the newly created instance of `EXReactEventEmitter` bridge module and register it in expo modules registry.
+  // Get the newly created instance of `EXReactEventEmitter` bridge module,
+  // pass event names supported by Swift modules and register it in legacy modules registry.
   EXReactNativeEventEmitter *eventEmitter = [bridge moduleForClass:[EXReactNativeEventEmitter class]];
+  [eventEmitter setSwiftInteropBridge:_swiftInteropBridge];
   [_exModuleRegistry registerInternalModule:eventEmitter];
 
   // Let the modules consume the registry :)
@@ -345,4 +379,16 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
   }
 }
 
+/**
+ Installs expo modules in JSI runtime.
+ */
+- (void)installExpoTurboModules
+{
+  facebook::jsi::Runtime *runtime = [_bridge respondsToSelector:@selector(runtime)] ? reinterpret_cast<facebook::jsi::Runtime *>(_bridge.runtime) : NULL;
+
+  if (runtime) {
+    expo::installRuntimeObjects(*runtime, _bridge.jsCallInvoker, self);
+  }
+}
+
 @end

package/ios/ReactDelegates/EXRCTBridgeDelegateInterceptor.h

@@ -0,0 +1,16 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <React/RCTBridgeDelegate.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface EXRCTBridgeDelegateInterceptor : NSObject<RCTBridgeDelegate>
+
+@property (nonatomic, weak) id<RCTBridgeDelegate> bridgeDelegate;
+@property (nonatomic, weak) id<RCTBridgeDelegate> interceptor;
+
+- (instancetype)initWithBridgeDelegate:(id<RCTBridgeDelegate>)bridgeDelegate interceptor:(id<RCTBridgeDelegate>)interceptor;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/ReactDelegates/EXRCTBridgeDelegateInterceptor.m

@@ -0,0 +1,49 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXRCTBridgeDelegateInterceptor.h>
+
+@implementation EXRCTBridgeDelegateInterceptor
+
+- (instancetype)initWithBridgeDelegate:(id<RCTBridgeDelegate>)bridgeDelegate interceptor:(id<RCTBridgeDelegate>)interceptor
+{
+  if (self = [super init]) {
+    self.bridgeDelegate = bridgeDelegate;
+    self.interceptor = interceptor;
+  }
+  return self;
+}
+
+- (BOOL)conformsToProtocol:(Protocol *)protocol
+{
+  return [self.bridgeDelegate conformsToProtocol:protocol];
+}
+
+- (id)forwardingTargetForSelector:(SEL)selector
+{
+  if ([self isInterceptedSelector:selector]) {
+    return self;
+  }
+  return self.bridgeDelegate;
+}
+
+- (BOOL)respondsToSelector:(SEL)selector
+{
+  if ([self isInterceptedSelector:selector]) {
+    return YES;
+  }
+  return [self.bridgeDelegate respondsToSelector:selector];
+}
+
+- (BOOL)isInterceptedSelector:(SEL)selector
+{
+  if ([self.interceptor respondsToSelector:selector]) {
+    return YES;
+  }
+  return NO;
+}
+
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge {
+  return [self.interceptor sourceURLForBridge:bridge];
+}
+
+@end

package/ios/ReactDelegates/EXReactDelegateWrapper+Private.h

@@ -0,0 +1,18 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/Swift.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ Internal `EXReactDelegateWrapper` interface for the designated initializer with `ExpoReactDelegate`.
+ Since `ExpoReactDelegate` implements in swift and requires the generated `ExpoModulesCore-Swift.h` header,
+ this header file should ONLY be imported from *.m or *.mm files.
+ */
+@interface EXReactDelegateWrapper(Private)
+
+- (instancetype)initWithExpoReactDelegate:(ExpoReactDelegate *)expoReactDelegate;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/ReactDelegates/EXReactDelegateWrapper.h

@@ -0,0 +1,25 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <UIKit/UIKit.h>
+#import <React/RCTBridge.h>
+#import <React/RCTRootView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ A wrapper of `ExpoReactDelegate` for Objective-C bindings.
+ */
+@interface EXReactDelegateWrapper : NSObject
+
+- (RCTBridge *)createBridgeWithDelegate:(id<RCTBridgeDelegate>)delegate
+                          launchOptions:(nullable NSDictionary *)launchOptions;
+
+- (RCTRootView *)createRootViewWithBridge:(RCTBridge *)bridge
+                               moduleName:(NSString *)moduleName
+                        initialProperties:(nullable NSDictionary *)initialProperties;
+
+- (UIViewController *)createRootViewController;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/ReactDelegates/EXReactDelegateWrapper.m

@@ -0,0 +1,40 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXReactDelegateWrapper.h>
+#import <ExpoModulesCore/EXReactDelegateWrapper+Private.h>
+
+@interface EXReactDelegateWrapper()
+
+@property (nonatomic, weak) ExpoReactDelegate *expoReactDelegate;
+
+@end
+
+@implementation EXReactDelegateWrapper
+
+- (instancetype)initWithExpoReactDelegate:(ExpoReactDelegate *)expoReactDelegate
+{
+  if (self = [super init]) {
+    _expoReactDelegate = expoReactDelegate;
+  }
+  return self;
+}
+
+- (RCTBridge *)createBridgeWithDelegate:(id<RCTBridgeDelegate>)delegate
+                          launchOptions:(nullable NSDictionary *)launchOptions
+{
+  return [_expoReactDelegate createBridgeWithDelegate:delegate launchOptions:launchOptions];
+}
+
+- (RCTRootView *)createRootViewWithBridge:(RCTBridge *)bridge
+                               moduleName:(NSString *)moduleName
+                        initialProperties:(nullable NSDictionary *)initialProperties
+{
+  return [_expoReactDelegate createRootViewWithBridge:bridge moduleName:moduleName initialProperties:initialProperties];
+}
+
+- (UIViewController *)createRootViewController
+{
+  return [_expoReactDelegate createRootViewController];
+}
+
+@end

package/ios/ReactDelegates/ExpoReactDelegate.swift

@@ -0,0 +1,37 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+/**
+ An extensible react instance creation delegate. This class will loop through each `ExpoReactDelegateHandler` to determine the winner to create the instance.
+ */
+@objc
+public class ExpoReactDelegate: NSObject {
+  private let handlers: [ExpoReactDelegateHandler]
+
+  public init(handlers: [ExpoReactDelegateHandler]) {
+    self.handlers = handlers
+  }
+
+  @objc
+  public func createBridge(delegate: RCTBridgeDelegate, launchOptions: [AnyHashable : Any]?) -> RCTBridge {
+    self.handlers.forEach { $0.bridgeWillCreate() }
+    let result = self.handlers.lazy
+      .compactMap { $0.createBridge(reactDelegate: self, bridgeDelegate: delegate, launchOptions: launchOptions) }
+      .first(where: { _ in true }) ?? RCTBridge(delegate: delegate, launchOptions: launchOptions)!
+    self.handlers.forEach { $0.bridgeDidCreate(bridge: result) }
+    return result
+  }
+
+  @objc
+  public func createRootView(bridge: RCTBridge, moduleName: String, initialProperties: [AnyHashable : Any]?) -> RCTRootView {
+    return self.handlers.lazy
+      .compactMap { $0.createRootView(reactDelegate: self, bridge: bridge, moduleName: moduleName, initialProperties: initialProperties) }
+      .first(where: { _ in true }) ?? RCTRootView(bridge: bridge, moduleName: moduleName, initialProperties: initialProperties)
+  }
+
+  @objc
+  public func createRootViewController() -> UIViewController {
+    return self.handlers.lazy
+      .compactMap { $0.createRootViewController(reactDelegate: self) }
+      .first(where: { _ in true }) ?? UIViewController()
+  }
+}

package/ios/ReactDelegates/ExpoReactDelegateHandler.swift

@@ -0,0 +1,52 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+import Foundation
+
+/**
+ The handler for `ExpoReactDelegate`. A module can implement a handler to process react instance creation.
+ */
+@objc
+open class ExpoReactDelegateHandler: NSObject {
+  public override required init() {}
+
+  /**
+   If this module wants to handle `RCTBridge` creation, it can return the instance.
+   Otherwise return nil.
+   */
+  @objc
+  open func createBridge(reactDelegate: ExpoReactDelegate, bridgeDelegate: RCTBridgeDelegate, launchOptions: [AnyHashable : Any]?) -> RCTBridge? {
+    return nil
+  }
+
+  /**
+   If this module wants to handle `RCTRootView` creation, it can return the instance.
+   Otherwise return nil.
+   */
+  @objc
+  open func createRootView(reactDelegate: ExpoReactDelegate, bridge: RCTBridge, moduleName: String, initialProperties: [AnyHashable : Any]?) -> RCTRootView? {
+    return nil
+  }
+
+  /**
+   If this module wants to handle `UIViewController` creation for `RCTRootView`, it can return the instance.
+   Otherwise return nil.
+   */
+  @objc
+  open func createRootViewController(reactDelegate: ExpoReactDelegate) -> UIViewController? {
+    return nil
+  }
+
+  // MARK - event callbacks
+
+  /**
+   Callback before bridge creation
+   */
+  @objc
+  open func bridgeWillCreate() {}
+
+  /**
+   Callback after bridge creation
+   */
+  @objc
+  open func bridgeDidCreate(bridge: RCTBridge) {}
+}

package/ios/ReactDelegates/ModulePriorities.swift

@@ -0,0 +1,20 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+/**
+ This class determines the order of `ExpoReactDelegateHandler`.
+
+ The priority is only for internal use and we maintain a pre-defined `SUPPORTED_MODULE` map.
+ */
+internal struct ModulePriorities {
+  static let SUPPORTED_MODULE = [
+    // {key}: {value}
+    // key: node package name
+    // value: priority value, the higher value takes precedence
+    "expo-screen-orientation": 10,
+    "expo-updates": 5,
+  ]
+
+  static func get(_ packageName: String) -> Int {
+    return SUPPORTED_MODULE[packageName] ?? 0
+  }
+}

package/ios/Services/EXReactNativeEventEmitter.h

@@ -7,6 +7,12 @@
 #import <ExpoModulesCore/EXModuleRegistryConsumer.h>
 #import <ExpoModulesCore/EXBridgeModule.h>
 
+// Swift compatibility headers (e.g. `ExpoModulesCore-Swift.h`) are not available in headers,
+// so we use class forward declaration here. Swift header must be imported in the `.m` file.
+@class SwiftInteropBridge;
+
 @interface EXReactNativeEventEmitter : RCTEventEmitter <EXInternalModule, EXBridgeModule, EXModuleRegistryConsumer, EXEventEmitterService>
 
+@property (nonatomic, strong) SwiftInteropBridge *swiftInteropBridge;
+
 @end