expo-modules-core 0.7.0 → 0.9.1

package/ios/JSI/EXJavaScriptValue.h

@@ -0,0 +1,57 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
+
+#ifdef __cplusplus
+#import <jsi/jsi.h>
+namespace jsi = facebook::jsi;
+#endif // __cplusplus
+
+@class EXJavaScriptRuntime;
+
+/**
+ Represents any JavaScript value. Its purpose is to exposes `facebook::jsi::Value` API back to Swift.
+ */
+NS_SWIFT_NAME(JavaScriptValue)
+@interface EXJavaScriptValue : NSObject
+
+#ifdef __cplusplus
+- (nonnull instancetype)initWithRuntime:(nonnull EXJavaScriptRuntime *)runtime
+                                  value:(std::shared_ptr<jsi::Value>)value;
+
+/**
+ \return the underlying `jsi::Value`.
+ */
+- (nonnull jsi::Value *)get;
+#endif // __cplusplus
+
+#pragma mark - Type checking
+
+- (BOOL)isUndefined;
+- (BOOL)isNull;
+- (BOOL)isBool;
+- (BOOL)isNumber;
+- (BOOL)isString;
+- (BOOL)isSymbol;
+- (BOOL)isObject;
+- (BOOL)isFunction;
+
++ (nonnull NSString *)kindOf:(nonnull EXJavaScriptValue *)value;
+
+#pragma mark - Type casting
+
+- (nullable id)getRaw;
+- (BOOL)getBool;
+- (NSInteger)getInt;
+- (double)getDouble;
+- (nonnull NSString *)getString;
+- (nonnull NSArray<EXJavaScriptValue *> *)getArray;
+- (nonnull NSDictionary<NSString *, id> *)getDictionary;
+- (nonnull EXJavaScriptObject *)getObject;
+
+#pragma mark - Helpers
+
+- (nonnull NSString *)toString;
+
+@end

package/ios/JSI/EXJavaScriptValue.mm

@@ -0,0 +1,166 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXJSIConversions.h>
+#import <ExpoModulesCore/EXJavaScriptValue.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
+
+@implementation EXJavaScriptValue {
+  __weak EXJavaScriptRuntime *_runtime;
+  std::shared_ptr<jsi::Value> _value;
+}
+
+- (nonnull instancetype)initWithRuntime:(nonnull EXJavaScriptRuntime *)runtime
+                                  value:(std::shared_ptr<jsi::Value>)value
+{
+  if (self = [super init]) {
+    _runtime = runtime;
+    _value = value;
+  }
+  return self;
+}
+
+- (nonnull jsi::Value *)get
+{
+  return _value.get();
+}
+
+#pragma mark - Type checking
+
+- (BOOL)isUndefined
+{
+  return _value->isUndefined();
+}
+
+- (BOOL)isNull
+{
+  return _value->isNull();
+}
+
+- (BOOL)isBool
+{
+  return _value->isBool();
+}
+
+- (BOOL)isNumber
+{
+  return _value->isNumber();
+}
+
+- (BOOL)isString
+{
+  return _value->isString();
+}
+
+- (BOOL)isSymbol
+{
+  return _value->isSymbol();
+}
+
+- (BOOL)isObject
+{
+  return _value->isObject();
+}
+
+- (BOOL)isFunction
+{
+  if (_value->isObject()) {
+    jsi::Runtime *runtime = [_runtime get];
+    return _value->getObject(*runtime).isFunction(*runtime);
+  }
+  return false;
+}
+
++ (nonnull NSString *)kindOf:(nonnull EXJavaScriptValue *)value
+{
+  if ([value isUndefined]) {
+    return @"undefined";
+  }
+  if ([value isNull]) {
+    return @"null";
+  }
+  if ([value isBool]) {
+    return @"boolean";
+  }
+  if ([value isNumber]) {
+    return @"number";
+  }
+  if ([value isString]) {
+    return @"string";
+  }
+  if ([value isFunction]) {
+    return @"function";
+  }
+  assert([value isObject] && "Expecting object.");
+  return @"object";
+}
+
+#pragma mark - Type casting
+
+- (nullable id)getRaw
+{
+  return expo::convertJSIValueToObjCObject(*[_runtime get], *_value, [_runtime callInvoker]);
+}
+
+- (BOOL)getBool
+{
+  return _value->getBool();
+}
+
+- (NSInteger)getInt
+{
+  return _value->getNumber();
+}
+
+- (double)getDouble
+{
+  return _value->getNumber();
+}
+
+- (nonnull NSString *)getString
+{
+  jsi::Runtime *runtime = [_runtime get];
+  return expo::convertJSIStringToNSString(*runtime, _value->getString(*runtime));
+}
+
+- (nonnull NSArray<EXJavaScriptValue *> *)getArray
+{
+  jsi::Runtime *runtime = [_runtime get];
+  jsi::Array jsiArray = _value->getObject(*runtime).getArray(*runtime);
+  size_t arraySize = jsiArray.size(*runtime);
+  NSMutableArray *result = [NSMutableArray arrayWithCapacity:arraySize];
+
+  for (size_t i = 0; i < arraySize; i++) {
+    jsi::Value item = jsiArray.getValueAtIndex(*runtime, i);
+
+    if (item.isUndefined() || item.isNull()) {
+      [result addObject:(id)kCFNull];
+    } else {
+      std::shared_ptr<jsi::Value> valuePtr = std::make_shared<jsi::Value>(*runtime, item);
+      [result addObject:[[EXJavaScriptValue alloc] initWithRuntime:_runtime value:valuePtr]];
+    }
+  }
+  return result;
+}
+
+- (nonnull NSDictionary<NSString *, id> *)getDictionary
+{
+  jsi::Runtime *runtime = [_runtime get];
+  return expo::convertJSIObjectToNSDictionary(*runtime, _value->getObject(*runtime), [_runtime callInvoker]);
+}
+
+- (nonnull EXJavaScriptObject *)getObject
+{
+  jsi::Runtime *runtime = [_runtime get];
+  std::shared_ptr<jsi::Object> objectPtr = std::make_shared<jsi::Object>(_value->asObject(*runtime));
+  return [[EXJavaScriptObject alloc] initWith:objectPtr runtime:_runtime];
+}
+
+#pragma mark - Helpers
+
+- (nonnull NSString *)toString
+{
+  jsi::Runtime *runtime = [_runtime get];
+  return expo::convertJSIStringToNSString(*runtime, _value->toString(*runtime));
+}
+
+@end

package/ios/JSI/ExpoModulesHostObject.mm

@@ -1,6 +1,7 @@
 // Copyright 2022-present 650 Industries. All rights reserved.
 
 #import <ExpoModulesCore/ExpoModulesHostObject.h>
+#import <ExpoModulesCore/EXJavaScriptObject.h>
 #import <ExpoModulesCore/Swift.h>
 
 namespace expo {
@@ -13,7 +14,7 @@ ExpoModulesHostObject::~ExpoModulesHostObject() {
 
 jsi::Value ExpoModulesHostObject::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
   NSString *moduleName = [NSString stringWithUTF8String:name.utf8(runtime).c_str()];
-  JavaScriptObject *nativeObject = [swiftInterop getNativeModuleObject:moduleName];
+  EXJavaScriptObject *nativeObject = [swiftInterop getNativeModuleObject:moduleName];
 
   return nativeObject ? jsi::Value(runtime, *[nativeObject get]) : jsi::Value::undefined();
 }

package/ios/JSI/JavaScriptRuntime.swift

@@ -0,0 +1,32 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+public extension JavaScriptRuntime {
+  /**
+   Evaluates JavaScript code represented as a string.
+
+   - Parameter source: A string representing a JavaScript expression, statement, or sequence of statements.
+                       The expression can include variables and properties of existing objects.
+   - Returns: The completion value of evaluating the given code represented as `JavaScriptValue`.
+              If the completion value is empty, `undefined` is returned.
+   - Throws: `JavaScriptEvalException` when evaluated code has invalid syntax or throws an error.
+   - Note: It wraps the original `evaluateScript` to better handle and rethrow exceptions.
+   */
+  func eval(_ source: String) throws -> JavaScriptValue {
+    do {
+      var result: JavaScriptValue?
+      try EXUtilities.catchException {
+        result = self.evaluateScript(source)
+      }
+      // There is no risk to force unwrapping as long as the `evaluateScript` returns nonnull value.
+      return result!
+    } catch {
+      throw JavaScriptEvalException(error as NSError)
+    }
+  }
+}
+
+internal final class JavaScriptEvalException: GenericException<NSError> {
+  override var reason: String {
+    return param.userInfo["message"] as? String ?? "unknown reason"
+  }
+}

package/ios/JSI/JavaScriptValue.swift

@@ -0,0 +1,94 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+/**
+ Enum with available kinds of values. It's almost the same as a result of "typeof"
+ in JavaScript, however `null` has its own kind (typeof null == "object").
+ */
+public enum JavaScriptValueKind: String {
+  case undefined
+  case null
+  case bool
+  case number
+  case symbol
+  case string
+  case function
+  case object
+}
+
+public extension JavaScriptValue {
+  var kind: JavaScriptValueKind {
+    switch true {
+    case isUndefined():
+      return .undefined
+    case isNull():
+      return .null
+    case isBool():
+      return .bool
+    case isNumber():
+      return .number
+    case isSymbol():
+      return .symbol
+    case isString():
+      return .string
+    case isFunction():
+      return .function
+    default:
+      return .object
+    }
+  }
+
+  func asBool() throws -> Bool {
+    if isBool() {
+      return getBool()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Bool"))
+  }
+
+  func asInt() throws -> Int {
+    if isNumber() {
+      return getInt()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Int"))
+  }
+
+  func asDouble() throws -> Double {
+    if isNumber() {
+      return getDouble()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Double"))
+  }
+
+  func asString() throws -> String {
+    if isString() {
+      return getString()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "String"))
+  }
+
+  func asArray() throws -> [JavaScriptValue?] {
+    if isObject() {
+      return getArray()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Array"))
+  }
+
+  func asDict() throws -> [String: Any] {
+    if isObject() {
+      return getDictionary()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Dict"))
+  }
+
+  func asObject() throws -> JavaScriptObject {
+    if isObject() {
+      return getObject()
+    }
+    throw JavaScriptValueConversionException((kind: kind, target: "Object"))
+  }
+}
+
+internal final class JavaScriptValueConversionException: GenericException<(kind: JavaScriptValueKind, target: String)> {
+  override var reason: String {
+    "Cannot represent a value of kind '\(param.kind)' as \(param.target)"
+  }
+}

package/ios/ModuleRegistryAdapter/EXModuleRegistryAdapter.m

@@ -13,7 +13,7 @@
 
 @property (nonatomic, strong) EXModuleRegistryProvider *moduleRegistryProvider;
 @property (nonatomic, strong) EXViewManagerAdapterClassesRegistry *viewManagersClassesRegistry;
-@property (nonatomic, strong, nullable) id<ModulesProviderObjCProtocol> swiftModulesProvider;
+@property (nonatomic, strong, nullable) ModulesProvider *swiftModulesProvider;
 
 @end
 
@@ -28,16 +28,6 @@
   return self;
 }
 
-- (instancetype)initWithModuleRegistryProvider:(EXModuleRegistryProvider *)moduleRegistryProvider swiftModulesProviderClass:(nullable Class)swiftModulesProviderClass
-{
-  if (self = [self initWithModuleRegistryProvider:moduleRegistryProvider]) {
-    if ([swiftModulesProviderClass conformsToProtocol:@protocol(ModulesProviderObjCProtocol)]) {
-      _swiftModulesProvider = [swiftModulesProviderClass new];
-    }
-  }
-  return self;
-}
-
 - (NSArray<id<RCTBridgeModule>> *)extraModulesForBridge:(RCTBridge *)bridge
 {
   return [self extraModulesForModuleRegistry:[_moduleRegistryProvider moduleRegistry]];

package/ios/NativeModulesProxy/EXNativeModulesProxy.h

@@ -12,7 +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;
+@class ModulesProvider;
 
 NS_SWIFT_NAME(NativeModulesProxy)
 @interface EXNativeModulesProxy : NSObject <RCTBridgeModule>
@@ -25,6 +25,6 @@ NS_SWIFT_NAME(NativeModulesProxy)
 - (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;
++ (ModulesProvider *)getExpoModulesProvider;
 
 @end

package/ios/NativeModulesProxy/EXNativeModulesProxy.mm

@@ -10,7 +10,6 @@
 
 #import <jsi/jsi.h>
 
-#import <ExpoModulesCore/EXComponentDataCompatibleWrapper.h>
 #import <ExpoModulesCore/EXNativeModulesProxy.h>
 #import <ExpoModulesCore/EXEventEmitter.h>
 #import <ExpoModulesCore/EXViewManager.h>
@@ -18,11 +17,11 @@
 #import <ExpoModulesCore/EXViewManagerAdapterClassesRegistry.h>
 #import <ExpoModulesCore/EXModuleRegistryProvider.h>
 #import <ExpoModulesCore/EXReactNativeEventEmitter.h>
-#import <ExpoModulesCore/JSIInstaller.h>
+#import <ExpoModulesCore/EXJSIInstaller.h>
 #import <ExpoModulesCore/Swift.h>
 
 static const NSString *exportedMethodsNamesKeyPath = @"exportedMethods";
-static const NSString *viewManagersNamesKeyPath = @"viewManagersNames";
+static const NSString *viewManagersMetadataKeyPath = @"viewManagersMetadata";
 static const NSString *exportedConstantsKeyPath = @"modulesConstants";
 
 static const NSString *methodInfoKeyKey = @"key";
@@ -91,8 +90,9 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
 
 - (NSDictionary *)constantsToExport
 {
-  // Install the TurboModule implementation of the proxy.
-  [self installExpoTurboModules];
+  // Install ExpoModules host object in the runtime. It's probably not the right place,
+  // but it's the earliest moment in bridge's lifecycle when we have access to the runtime.
+  [self installExpoModulesHostObject];
 
   NSMutableDictionary <NSString *, id> *exportedModulesConstants = [NSMutableDictionary dictionary];
   // Grab all the constants exported by modules
@@ -124,17 +124,21 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
   // Add entries from Swift modules
   [exportedMethodsNamesAccumulator addEntriesFromDictionary:[_swiftInteropBridge exportedFunctionNames]];
 
-  // Also, add `viewManagersNames` for sanity check and testing purposes -- with names we know what managers to mock on UIManager
+  // Also, add `viewManagersMetadata` for sanity check and testing purposes -- with names we know what managers to mock on UIManager
   NSArray<EXViewManager *> *viewManagers = [_exModuleRegistry getAllViewManagers];
-  NSMutableArray<NSString *> *viewManagersNames = [NSMutableArray arrayWithCapacity:[viewManagers count]];
+  NSMutableDictionary<NSString *, NSDictionary *> *viewManagersMetadata = [[NSMutableDictionary alloc] initWithCapacity:[viewManagers count]];
+
   for (EXViewManager *viewManager in viewManagers) {
-    [viewManagersNames addObject:[viewManager viewName]];
+    viewManagersMetadata[viewManager.viewName] = @{
+      @"propsNames": [[viewManager getPropsNames] allKeys]
+    };
   }
 
-  [viewManagersNames addObjectsFromArray:[_swiftInteropBridge exportedViewManagersNames]];
+  // Add entries from Swift view managers
+  [viewManagersMetadata addEntriesFromDictionary:[_swiftInteropBridge viewManagersMetadata]];
 
   NSMutableDictionary <NSString *, id> *constantsAccumulator = [NSMutableDictionary dictionary];
-  constantsAccumulator[viewManagersNamesKeyPath] = viewManagersNames;
+  constantsAccumulator[viewManagersMetadataKeyPath] = viewManagersMetadata;
   constantsAccumulator[exportedConstantsKeyPath] = exportedModulesConstants;
   constantsAccumulator[exportedMethodsNamesKeyPath] = exportedMethodsNamesAccumulator;
 
@@ -207,7 +211,7 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
 
 #pragma mark - Statics
 
-+ (id<ModulesProviderObjCProtocol>)getExpoModulesProvider
++ (ModulesProvider *)getExpoModulesProvider
 {
   // Dynamically gets the modules provider class.
   // NOTE: This needs to be versioned in Expo Go.
@@ -291,13 +295,13 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
   // Register the view managers as additional modules.
   [self registerAdditionalModuleClasses:additionalModuleClasses inBridge:bridge];
 
+  // Get the instance of `EXReactEventEmitter` bridge module and give it access to the interop bridge.
+  EXReactNativeEventEmitter *eventEmitter = [bridge moduleForClass:[EXReactNativeEventEmitter class]];
+  [eventEmitter setSwiftInteropBridge:_swiftInteropBridge];
+
   // As the last step, when the registry is owned,
   // register the event emitter and initialize the registry.
   if (ownsModuleRegistry) {
-    // 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 :)
@@ -362,7 +366,7 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
   NSString *className = NSStringFromClass(moduleClass);
 
   if ([moduleClass isSubclassOfClass:[RCTViewManager class]] && !componentDataByName[className]) {
-    RCTComponentData *componentData = [[EXComponentDataCompatibleWrapper alloc] initWithManagerClass:moduleClass bridge:bridge eventDispatcher:bridge.eventDispatcher];
+    RCTComponentData *componentData = [[RCTComponentData alloc] initWithManagerClass:moduleClass bridge:bridge eventDispatcher:bridge.eventDispatcher];
     componentDataByName[className] = componentData;
   }
 }
@@ -399,19 +403,17 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
 }
 
 /**
- Installs expo modules in JSI runtime.
+ Installs ExpoModules host object in the runtime that the current bridge operates on.
  */
-- (void)installExpoTurboModules
+- (void)installExpoModulesHostObject
 {
   facebook::jsi::Runtime *jsiRuntime = [_bridge respondsToSelector:@selector(runtime)] ? reinterpret_cast<facebook::jsi::Runtime *>(_bridge.runtime) : nullptr;
 
   if (jsiRuntime) {
-    JavaScriptRuntime *runtime = [[JavaScriptRuntime alloc] initWithRuntime:*jsiRuntime callInvoker:_bridge.jsCallInvoker];
+    EXJavaScriptRuntime *runtime = [[EXJavaScriptRuntime alloc] initWithRuntime:jsiRuntime callInvoker:_bridge.jsCallInvoker];
 
-    [JavaScriptRuntimeManager installExpoModulesToRuntime:runtime withSwiftInterop:_swiftInteropBridge];
+    [EXJavaScriptRuntimeManager installExpoModulesToRuntime:runtime withSwiftInterop:_swiftInteropBridge];
     [_swiftInteropBridge setRuntime:runtime];
-
-    expo::installRuntimeObjects(*jsiRuntime, _bridge.jsCallInvoker, self);
   }
 }
 

package/ios/ReactDelegates/EXReactCompatibleHelpers.h

@@ -0,0 +1,18 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <UIKit/UIKit.h>
+
+#import <ExpoModulesCore/EXDefines.h>
+#import <React/RCTBridge.h>
+
+
+EX_EXTERN_C_BEGIN
+
+/**
+ * Backward compatible version of `RCTAppSetupDefaultRootView`.
+ *
+ * `RCTAppSetupDefaultRootView` is introduced in react-native 0.68. To make `expo-modules-core` compatible with older react-native,  introduces this compatible helper.
+ */
+UIView *EXAppSetupDefaultRootView(RCTBridge *bridge, NSString *moduleName, NSDictionary *initialProperties);
+
+EX_EXTERN_C_END

package/ios/ReactDelegates/EXReactCompatibleHelpers.m

@@ -0,0 +1,19 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXReactCompatibleHelpers.h>
+
+#import <React/RCTRootView.h>
+
+#if __has_include(<React/RCTAppSetupUtils.h>)
+#import <React/RCTAppSetupUtils.h>
+#endif
+
+UIView *EXAppSetupDefaultRootView(RCTBridge *bridge, NSString *moduleName, NSDictionary *initialProperties)
+{
+#if __has_include(<React/RCTAppSetupUtils.h>)
+  return RCTAppSetupDefaultRootView(bridge, moduleName, initialProperties);
+#else
+  return [[RCTRootView alloc] initWithBridge:bridge moduleName:moduleName initialProperties:initialProperties];
+#endif
+}
+

package/ios/ReactDelegates/ExpoReactDelegate.swift

@@ -22,10 +22,10 @@ public class ExpoReactDelegate: NSObject {
   }
 
   @objc
-  public func createRootView(bridge: RCTBridge, moduleName: String, initialProperties: [AnyHashable: Any]?) -> RCTRootView {
+  public func createRootView(bridge: RCTBridge, moduleName: String, initialProperties: [AnyHashable: Any]?) -> UIView {
     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)
+      .first(where: { _ in true }) ?? EXAppSetupDefaultRootView(bridge, moduleName, initialProperties)
   }
 
   @objc

package/ios/ReactDelegates/ExpoReactDelegateHandler.swift

@@ -1,6 +1,6 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
-import Foundation
+import React
 
 /**
  The handler for `ExpoReactDelegate`. A module can implement a handler to process react instance creation.

package/ios/Swift/AppContext.swift

@@ -3,6 +3,13 @@ import UIKit
  The app context is an interface to a single Expo app.
  */
 public final class AppContext {
+  internal static func create() -> AppContext {
+    let appContext = AppContext()
+
+    appContext.runtime = JavaScriptRuntime()
+    return appContext
+  }
+
   /**
    The module registry for the app context.
    */
@@ -11,7 +18,7 @@ public final class AppContext {
   /**
    The legacy module registry with modules written in the old-fashioned way.
    */
-  public private(set) var legacyModuleRegistry: EXModuleRegistry?
+  public private(set) weak var legacyModuleRegistry: EXModuleRegistry?
 
   /**
    React bridge of the context's app.
@@ -129,6 +136,12 @@ public final class AppContext {
 
   // MARK: - Runtime
 
+  internal func installExpoModulesHostObject(_ interopBridge: SwiftInteropBridge) throws {
+    guard let runtime = runtime else {
+      throw UndefinedRuntimeException()
+    }
+    EXJavaScriptRuntimeManager.installExpoModules(to: runtime, withSwiftInterop: interopBridge)
+  }
   /**
    Unsets runtime objects that we hold for each module.
    */
@@ -152,7 +165,13 @@ public final class AppContext {
 
   class DeallocatedAppContextException: Exception {
     override var reason: String {
-      "The app context has been deallocated"
+      "The AppContext has been deallocated"
+    }
+  }
+
+  class UndefinedRuntimeException: Exception {
+    override var reason: String {
+      "The AppContext has undefined runtime"
     }
   }
 }

package/ios/Swift/Arguments/AnyArgumentType.swift

@@ -4,7 +4,7 @@
  A protocol whose intention is to wrap function's argument type
  to keep its real signature and not type-erase it by the compiler.
  */
-internal protocol AnyArgumentType: CustomStringConvertible {
+public protocol AnyArgumentType: CustomStringConvertible {
   /**
    Casts given any value to the wrapped type and returns as `Any`.
    NOTE: It may not be just simple type-casting (e.g. when the wrapped type conforms to `ConvertibleArgument`).

package/ios/Swift/Functions/AnyFunction.swift

@@ -14,6 +14,11 @@ public protocol AnyFunction: AnyDefinition {
    */
   var takesPromise: Bool { get }
 
+  /**
+   An array of argument types that the function takes. If the last type is `Promise`, it's not included.
+   */
+  var argumentTypes: [AnyArgumentType] { get }
+
   /**
    A number of arguments the function takes. If the last argument is of type `Promise`, it is not counted.
    */