expo-modules-core 0.4.8 → 0.6.1

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

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