expo-modules-core 1.11.13 → 1.12.1

package/ios/{Functions/ConcurrentFunctionDefinition.swift → Api/Factories/ConcurrentFunctionFactories.swift}

@@ -1,116 +1,3 @@
-// Copyright 2022-present 650 Industries. All rights reserved.
-
-/**
- Represents a concurrent function that can only be called asynchronously, thus its JavaScript equivalent returns a Promise.
- As opposed to `AsyncFunctionComponent`, it can leverage the new Swift's concurrency model and take the async/await closure.
- */
-public final class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>: AnyFunction {
-  typealias ClosureType = (Args) async throws -> ReturnType
-
-  let body: ClosureType
-
-  init(
-    _ name: String,
-    firstArgType: FirstArgType.Type,
-    dynamicArgumentTypes: [AnyDynamicType],
-    _ body: @escaping ClosureType
-  ) {
-    self.name = name
-    self.body = body
-    self.dynamicArgumentTypes = dynamicArgumentTypes
-  }
-
-  // MARK: - AnyFunction
-
-  let name: String
-
-  let dynamicArgumentTypes: [AnyDynamicType]
-
-  var argumentsCount: Int {
-    return dynamicArgumentTypes.count - (takesOwner ? 1 : 0)
-  }
-
-  var takesOwner: Bool = false
-
-  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext, callback: @escaping (FunctionCallResult) -> Void) {
-    var arguments: [Any]
-
-    do {
-      try validateArgumentsNumber(function: self, received: args.count)
-
-      arguments = concat(
-        arguments: args,
-        withOwner: owner,
-        withPromise: nil,
-        forFunction: self,
-        appContext: appContext
-      )
-
-      // All `JavaScriptValue` args must be preliminarly converted on the JS thread, before we jump to the function's queue.
-      arguments = try cast(jsValues: arguments, forFunction: self, appContext: appContext)
-    } catch let error as Exception {
-      callback(.failure(error))
-      return
-    } catch {
-      callback(.failure(UnexpectedException(error)))
-      return
-    }
-
-    // Switch from the synchronous context to asynchronous
-    Task { [arguments] in
-      let result: Result<Any, Exception>
-
-      do {
-        // Convert arguments to the types desired by the function.
-        let finalArguments = try cast(arguments: arguments, forFunction: self, appContext: appContext)
-
-        // TODO: Right now we force cast the tuple in all types of functions, but we should throw another exception here.
-        // swiftlint:disable force_cast
-        let argumentsTuple = try Conversions.toTuple(finalArguments) as! Args
-        let returnValue = try await body(argumentsTuple)
-
-        result = .success(returnValue)
-      } catch let error as Exception {
-        result = .failure(FunctionCallException(name).causedBy(error))
-      } catch {
-        result = .failure(UnexpectedException(error))
-      }
-
-      // Go back to the JS thread to execute the callback
-      appContext.executeOnJavaScriptThread {
-        callback(result)
-      }
-    }
-  }
-
-  // MARK: - JavaScriptObjectBuilder
-
-  func build(appContext: AppContext) throws -> JavaScriptObject {
-    return try appContext.runtime.createAsyncFunction(name, argsCount: argumentsCount) {
-      [weak appContext, weak self, name] this, args, resolve, reject in
-
-      guard let appContext else {
-        let exception = Exceptions.AppContextLost()
-        return reject(exception.code, exception.description, nil)
-      }
-      guard let self else {
-        let exception = NativeFunctionUnavailableException(name)
-        return reject(exception.code, exception.description, nil)
-      }
-      self.call(by: this, withArguments: args, appContext: appContext) { result in
-        switch result {
-        case .failure(let error):
-          reject(error.code, error.description, nil)
-        case .success(let value):
-          // Convert some results to primitive types (e.g. records) or JS values (e.g. shared objects)
-          let convertedResult = Conversions.convertFunctionResult(value, appContext: appContext, dynamicType: ~ReturnType.self)
-          resolve(convertedResult)
-        }
-      }
-    }
-  }
-}
-
 /**
  Concurrently-executing asynchronous function without arguments.
  */

package/ios/{Modules/ModuleDefinitionComponents.swift → Api/Factories/EventListenersFactories.swift}

@@ -1,14 +1,3 @@
-// MARK: - Module name
-
-/**
- Sets the name of the module that is exported to the JavaScript world.
- */
-public func Name(_ name: String) -> AnyDefinition {
-  return ModuleNameDefinition(name: name)
-}
-
-// MARK: - Module's lifecycle
-
 /**
  Creates module's lifecycle listener that is called right after module initialization.
  */
@@ -50,12 +39,3 @@ public func OnAppBecomesActive(@_implicitSelfCapture _ closure: @escaping () ->
 public func OnAppEntersBackground(@_implicitSelfCapture _ closure: @escaping () -> Void) -> AnyDefinition {
   return EventListener(.appEntersBackground, closure)
 }
-
-// MARK: - View Manager
-
-/**
- Creates the view manager definition that scopes other view-related definitions.
- */
-public func ViewManager(@ViewManagerDefinitionBuilder _ closure: @escaping () -> ViewManagerDefinition) -> AnyDefinition {
-  return closure()
-}

package/ios/Api/Factories/ModuleFactories.swift

@@ -0,0 +1,6 @@
+/**
+ Sets the name of the module that is exported to the JavaScript world.
+ */
+public func Name(_ name: String) -> AnyDefinition {
+  return ModuleNameDefinition(name: name)
+}

package/ios/{Objects/ObjectDefinitionComponents.swift → Api/Factories/ObjectFactories.swift}

@@ -1,4 +1,4 @@
-/// This file implements definition components that are allowed in any object-based definition — `ObjectDefinition`.
+/// This file implements factories for definitions that are allowed in any object-based definition — `ObjectDefinition`.
 /// So far only constants and functions belong to plain object.
 
 // MARK: - Object
@@ -42,13 +42,13 @@ public func Events(_ names: [String]) -> EventsDefinition {
 /**
  Function that is invoked when the first event listener is added.
  */
-public func OnStartObserving(@_implicitSelfCapture _ body: @escaping () -> Void) -> AsyncFunctionComponent<(), Void, Void> {
-  return AsyncFunctionComponent("startObserving", firstArgType: Void.self, dynamicArgumentTypes: [], body)
+public func OnStartObserving(_ event: String? = nil, @_implicitSelfCapture _ closure: @escaping () -> Void) -> EventObservingDefinition {
+  return EventObservingDefinition(type: .startObserving, event: event, closure)
 }
 
 /**
  Function that is invoked when all event listeners are removed.
  */
-public func OnStopObserving(@_implicitSelfCapture _ body: @escaping () -> Void) -> AsyncFunctionComponent<(), Void, Void> {
-  return AsyncFunctionComponent("stopObserving", firstArgType: Void.self, dynamicArgumentTypes: [], body)
+public func OnStopObserving(_ event: String? = nil, @_implicitSelfCapture _ closure: @escaping () -> Void) -> EventObservingDefinition {
+  return EventObservingDefinition(type: .stopObserving, event: event, closure)
 }

package/ios/Api/Factories/PropertyFactories.swift

@@ -0,0 +1,50 @@
+/**
+ Creates the property with given name. The definition is basically no-op if you don't call `.get(_:)` or `.set(_:)` on it.
+ */
+public func Property(_ name: String) -> PropertyDefinition<Void> {
+  return PropertyDefinition(name: name)
+}
+
+/**
+ Creates the read-only property whose getter doesn't take the owner as an argument.
+ */
+public func Property<Value: AnyArgument>(_ name: String, @_implicitSelfCapture get: @escaping () -> Value) -> PropertyDefinition<Void> {
+  return PropertyDefinition(name: name, getter: get)
+}
+
+/**
+ Creates the read-only property whose getter takes the owner as an argument.
+ */
+public func Property<Value: AnyArgument, OwnerType>(
+  _ name: String,
+  @_implicitSelfCapture get: @escaping (_ this: OwnerType) -> Value
+) -> PropertyDefinition<OwnerType> {
+  return PropertyDefinition<OwnerType>(name: name, getter: get)
+}
+
+/**
+ Creates the property that references to an immutable property of the owner object using the key path.
+ */
+public func Property<Value: AnyArgument, OwnerType>(
+  _ name: String,
+  _ keyPath: KeyPath<OwnerType, Value>
+) -> PropertyDefinition<OwnerType> {
+  return PropertyDefinition<OwnerType>(name: name) { owner in
+    return owner[keyPath: keyPath]
+  }
+}
+
+/**
+ Creates the property that references to a mutable property of the owner object using the key path.
+ */
+public func Property<Value: AnyArgument, OwnerType>(
+  _ name: String,
+  _ keyPath: ReferenceWritableKeyPath<OwnerType, Value>
+) -> PropertyDefinition<OwnerType> {
+  return PropertyDefinition<OwnerType>(name: name) { owner in
+    return owner[keyPath: keyPath]
+  }
+  .set { owner, newValue in
+    owner[keyPath: keyPath] = newValue
+  }
+}

package/ios/Api/Factories/SyncFunctionFactories.swift

@@ -0,0 +1,173 @@
+/**
+ Synchronous function without arguments.
+ */
+public func Function<R>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping () throws -> R
+) -> SyncFunctionDefinition<(), Void, R> {
+  return SyncFunctionDefinition(
+    name,
+    firstArgType: Void.self,
+    dynamicArgumentTypes: [],
+    closure
+  )
+}
+
+/**
+ Synchronous function with one argument.
+ */
+public func Function<R, A0: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0) throws -> R
+) -> SyncFunctionDefinition<(A0), A0, R> {
+  return SyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self],
+    closure
+  )
+}
+
+/**
+ Synchronous function with two arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1) throws -> R
+) -> SyncFunctionDefinition<(A0, A1), A0, R> {
+  return SyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [~A0.self, ~A1.self],
+    closure
+  )
+}
+
+/**
+ Synchronous function with three arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2) throws -> R
+) -> SyncFunctionDefinition<(A0, A1, A2), A0, R> {
+  return SyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with four arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3) throws -> R
+) -> SyncFunctionDefinition<(A0, A1, A2, A3), A0, R> {
+  return SyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with five arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
+) -> SyncFunctionDefinition<(A0, A1, A2, A3, A4), A0, R> {
+  return SyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with six arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
+) -> SyncFunctionDefinition<(A0, A1, A2, A3, A4, A5), A0, R> {
+  return SyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with seven arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) throws -> R
+) -> SyncFunctionDefinition<(A0, A1, A2, A3, A4, A5, A6), A0, R> {
+  return SyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self
+    ],
+    closure
+  )
+}
+
+/**
+ Synchronous function with eight arguments.
+ */
+public func Function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument, A7: AnyArgument>(
+  _ name: String,
+  @_implicitSelfCapture _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) throws -> R
+) -> SyncFunctionDefinition<(A0, A1, A2, A3, A4, A5, A6, A7), A0, R> {
+  return SyncFunctionDefinition(
+    name,
+    firstArgType: A0.self,
+    dynamicArgumentTypes: [
+      ~A0.self,
+      ~A1.self,
+      ~A2.self,
+      ~A3.self,
+      ~A4.self,
+      ~A5.self,
+      ~A6.self,
+      ~A7.self
+    ],
+    closure
+  )
+}

package/ios/{Views/ViewManagerDefinitionComponents.swift → Api/Factories/ViewFactories.swift}

@@ -1,12 +1,13 @@
-/// Here we implement the components exclusive for view managers.
-
-// MARK: View factory
+/// Here we implement factories for the definitions exclusive for native views.
 
 /**
- Defines the factory creating a native view when the module is used as a view.
+ Creates a view definition describing the native view exported to React.
  */
-public func View<ViewType: UIView>(_ closure: @escaping () -> ViewType) -> ViewManagerDefinitionComponent {
-  return ViewFactory(closure)
+public func View<ViewType: UIView>(
+  _ viewType: ViewType.Type,
+  @ViewDefinitionBuilder<ViewType> _ elements: @escaping () -> [AnyViewDefinitionElement]
+) -> ViewDefinition<ViewType> {
+  return ViewDefinition(viewType, elements: elements())
 }
 
 // MARK: Props

package/ios/AppDelegates/EXAppDelegateWrapper.h

@@ -1,9 +1,6 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
 #import <ExpoModulesCore/Platform.h>
-
-#if __cplusplus
-
 #import <ExpoModulesCore/EXReactDelegateWrapper.h>
 
 #if __has_include(<React-RCTAppDelegate/RCTAppDelegate.h>)
@@ -15,28 +12,10 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-/**
- Provides backwards compatibility for existing projects with `AppDelegate`
- written in Objective-C and that forwards all messages to the new `ExpoAppDelegate`.
- If your `AppDelegate` is in Swift, it should inherit from `ExpoAppDelegate` class instead.
- */
-#if __has_include(<React-RCTAppDelegate/RCTAppDelegate.h>) || __has_include(<React_RCTAppDelegate/RCTAppDelegate.h>)
 @interface EXAppDelegateWrapper : RCTAppDelegate
-#else
-@interface EXAppDelegateWrapper : UIResponder <UIApplicationDelegate>
-#endif
 
 @property (nonatomic, strong, readonly) EXReactDelegateWrapper *reactDelegate;
 
 @end
 
 NS_ASSUME_NONNULL_END
-
-#else
-
-// Workaround the main.m build error when running with new architecture mode
-// Context: https://github.com/facebook/react-native/pull/35661
-@interface EXAppDelegateWrapper : UIResponder
-@end
-
-#endif

package/ios/AppDelegates/EXAppDelegateWrapper.mm

@@ -2,8 +2,21 @@
 
 #import <ExpoModulesCore/EXAppDelegateWrapper.h>
 #import <ExpoModulesCore/EXReactDelegateWrapper+Private.h>
+#import <ExpoModulesCore/EXReactRootViewFactory.h>
 #import <ExpoModulesCore/Swift.h>
 
+#if __has_include(<React-RCTAppDelegate/RCTRootViewFactory.h>)
+#import <React-RCTAppDelegate/RCTRootViewFactory.h>
+#elif __has_include(<React_RCTAppDelegate/RCTRootViewFactory.h>)
+// for importing the header from framework, the dash will be transformed to underscore
+#import <React_RCTAppDelegate/RCTRootViewFactory.h>
+#endif
+
+#import <ReactCommon/RCTTurboModuleManager.h>
+
+@interface RCTAppDelegate () <RCTTurboModuleManagerDelegate>
+@end
+
 @interface EXAppDelegateWrapper()
 
 @property (nonatomic, strong) EXReactDelegateWrapper *reactDelegate;
@@ -41,48 +54,43 @@
   return _expoAppDelegate;
 }
 
-#if __has_include(<React-RCTAppDelegate/RCTAppDelegate.h>) || __has_include(<React_RCTAppDelegate/RCTAppDelegate.h>)
-
 #if !TARGET_OS_OSX
 - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
 {
   [super application:application didFinishLaunchingWithOptions:launchOptions];
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-result"
   [_expoAppDelegate application:application didFinishLaunchingWithOptions:launchOptions];
+#pragma clang diagnostic pop
   return YES;
 }
 #endif // !TARGET_OS_OSX
 
-- (RCTBridge *)createBridgeWithDelegate:(id<RCTBridgeDelegate>)delegate launchOptions:(NSDictionary *)launchOptions
-{
-  return [self.reactDelegate createBridgeWithDelegate:delegate launchOptions:launchOptions];
-}
-
-- (UIView *)createRootViewWithBridge:(RCTBridge *)bridge
-                          moduleName:(NSString *)moduleName
-                           initProps:(NSDictionary *)initProps
+- (UIViewController *)createRootViewController
 {
-  BOOL enableFabric = NO;
-#if RN_FABRIC_ENABLED
-  enableFabric = self.fabricEnabled;
-#endif
-
-  UIView *rootView = [self.reactDelegate createRootViewWithBridge:bridge
-                                                       moduleName:moduleName
-                                                initialProperties:initProps
-                                                    fabricEnabled:enableFabric];
-#if TARGET_OS_IOS
-  rootView.backgroundColor = UIColor.systemBackgroundColor;
-#elif TARGET_OS_OSX
-  rootView.wantsLayer = YES;
-  rootView.layer.backgroundColor = NSColor.windowBackgroundColor.CGColor;
-#endif
-  return rootView;
+  return [self.reactDelegate createRootViewController];
 }
 
-- (UIViewController *)createRootViewController
+- (RCTRootViewFactory *)createRCTRootViewFactory
 {
-  return [self.reactDelegate createRootViewController];
+  RCTRootViewFactoryConfiguration *configuration =
+      [[RCTRootViewFactoryConfiguration alloc] initWithBundleURL:self.bundleURL
+                                                  newArchEnabled:self.fabricEnabled
+                                              turboModuleEnabled:self.turboModuleEnabled
+                                               bridgelessEnabled:self.bridgelessEnabled];
+
+  __weak __typeof(self) weakSelf = self;
+  configuration.createRootViewWithBridge = ^UIView *(RCTBridge *bridge, NSString *moduleName, NSDictionary *initProps)
+  {
+    return [weakSelf createRootViewWithBridge:bridge moduleName:moduleName initProps:initProps];
+  };
+
+  configuration.createBridgeWithDelegate = ^RCTBridge *(id<RCTBridgeDelegate> delegate, NSDictionary *launchOptions)
+  {
+    return [weakSelf createBridgeWithDelegate:delegate launchOptions:launchOptions];
+  };
+
+  return [[EXReactRootViewFactory alloc] initWithReactDelegate:self.reactDelegate configuration:configuration turboModuleManagerDelegate:self];
 }
-#endif // __has_include(<React-RCTAppDelegate/RCTAppDelegate.h>)
 
 @end

package/ios/{AppContext.swift → Core/AppContext.swift}

@@ -1,3 +1,5 @@
+import React
+
 /**
  The app context is an interface to a single Expo app.
  */
@@ -31,9 +33,11 @@ public final class AppContext: NSObject {
   /**
    The legacy module registry with modules written in the old-fashioned way.
    */
+  @objc
   public weak var legacyModuleRegistry: EXModuleRegistry?
 
-  internal weak var legacyModulesProxy: LegacyNativeModulesProxy?
+  @objc
+  public weak var legacyModulesProxy: LegacyNativeModulesProxy?
 
   /**
    React bridge of the context's app. Can be `nil` when the bridge
@@ -41,7 +45,7 @@ public final class AppContext: NSObject {
    or when the app context is "bridgeless" (for example in native unit tests).
    */
   @objc
-  public internal(set) weak var reactBridge: RCTBridge?
+  public weak var reactBridge: RCTBridge?
 
   /**
    Underlying JSI runtime of the running app.
@@ -99,6 +103,12 @@ public final class AppContext: NSObject {
     self.legacyModuleRegistry = legacyModuleRegistry as? EXModuleRegistry
   }
 
+  @objc
+  public convenience override init() {
+    self.init(config: .default)
+  }
+
+  @objc
   @discardableResult
   public func useModulesProvider(_ providerName: String) -> Self {
     return useModulesProvider(Self.modulesProvider(withName: providerName))
@@ -134,6 +144,8 @@ public final class AppContext: NSObject {
 
   // MARK: - Classes
 
+  internal lazy var sharedObjectRegistry = SharedObjectRegistry(appContext: self)
+
   /**
    A registry containing references to JavaScript classes.
    - ToDo: Make one registry per module, not the entire app context.
@@ -201,10 +213,10 @@ public final class AppContext: NSObject {
   }
 
   /**
-   Provides access to the event emitter from legacy module registry.
+   Provides an event emitter that is compatible with the legacy interface.
    */
   public var eventEmitter: EXEventEmitterService? {
-    return legacyModule(implementing: EXEventEmitterService.self)
+    return LegacyEventEmitterCompat(appContext: self)
   }
 
   /**
@@ -264,7 +276,7 @@ public final class AppContext: NSObject {
   @objc
   public func getViewManagers() -> [ViewModuleWrapper] {
     return moduleRegistry.compactMap { holder in
-      if holder.definition.viewManager != nil {
+      if holder.definition.view != nil {
         return ViewModuleWrapper(holder)
       } else {
         return nil
@@ -372,9 +384,9 @@ public final class AppContext: NSObject {
 
   private func viewManagersMetadata() -> [String: Any] {
     return moduleRegistry.reduce(into: [String: Any]()) { acc, holder in
-      if let viewManager = holder.definition.viewManager {
+      if let viewDefinition = holder.definition.view {
         acc[holder.name] = [
-          "propsNames": viewManager.props.map { $0.name }
+          "propsNames": viewDefinition.props.map { $0.name }
         ]
       }
     }
@@ -384,11 +396,24 @@ public final class AppContext: NSObject {
 
   internal func prepareRuntime() throws {
     let runtime = try runtime
-    let coreObject = try coreModuleHolder.definition.build(appContext: self)
+    let coreObject = runtime.createObject()
+
+    try coreModuleHolder.definition.decorate(object: coreObject, appContext: self)
 
     // Initialize `global.expo`.
     try runtime.initializeCoreObject(coreObject)
 
+    // Install `global.expo.EventEmitter`.
+    EXJavaScriptRuntimeManager.installEventEmitterClass(runtime)
+
+    // Install `global.expo.SharedObject`.
+    EXJavaScriptRuntimeManager.installSharedObjectClass(runtime) { [weak sharedObjectRegistry] objectId in
+      sharedObjectRegistry?.delete(objectId)
+    }
+
+    // Install `global.expo.NativeModule`.
+    EXJavaScriptRuntimeManager.installNativeModuleClass(runtime)
+
     // Install the modules host object as the `global.expo.modules`.
     EXJavaScriptRuntimeManager.installExpoModulesHostObject(self)
   }
@@ -397,9 +422,7 @@ public final class AppContext: NSObject {
    Unsets runtime objects that we hold for each module.
    */
   private func releaseRuntimeObjects() {
-    // FIXME: Release objects only from the current context.
-    // Making the registry non-global (similarly to the class registry) would fix it.
-    SharedObjectRegistry.clear()
+    sharedObjectRegistry.clear()
     classRegistry.clear()
 
     for module in moduleRegistry {