expo-modules-core 1.11.13 → 1.12.1

package/ios/Tests/SharedObjectRegistrySpec.swift

@@ -8,51 +8,57 @@ final class SharedObjectRegistrySpec: ExpoSpec {
   override class func spec() {
     let appContext = AppContext.create()
     let runtime = try! appContext.runtime
+    let sharedObjectRegistry = appContext.sharedObjectRegistry
 
     describe("pullNextId") {
       it("returns nextId") {
-        let id = SharedObjectRegistry.nextId
-        expect(SharedObjectRegistry.pullNextId()) == id
+        let id = sharedObjectRegistry.nextId
+        expect(sharedObjectRegistry.pullNextId()) == id
       }
       it("increments nextId") {
-        let id = SharedObjectRegistry.nextId
-        SharedObjectRegistry.pullNextId()
-        expect(SharedObjectRegistry.nextId) == id + 1
+        let id = sharedObjectRegistry.nextId
+        sharedObjectRegistry.pullNextId()
+        expect(sharedObjectRegistry.nextId) == id + 1
       }
       it("is not increasing size") {
-        let size = SharedObjectRegistry.size
-        SharedObjectRegistry.pullNextId()
-        expect(SharedObjectRegistry.size) == size
+        let size = sharedObjectRegistry.size
+        sharedObjectRegistry.pullNextId()
+        expect(sharedObjectRegistry.size) == size
       }
     }
 
     describe("add") {
       it("adds using nextId") {
-        let nextId = SharedObjectRegistry.nextId
-        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime.createObject())
+        let nextId = sharedObjectRegistry.nextId
+        let id = sharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime.createObject())
         expect(nextId) == id
       }
       it("is increasing size") {
-        let size = SharedObjectRegistry.size
-        SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime.createObject())
-        expect(SharedObjectRegistry.size) == size + 1
+        let size = sharedObjectRegistry.size
+        sharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime.createObject())
+        expect(sharedObjectRegistry.size) == size + 1
       }
       it("assigns id on native object") {
         let nativeObject = TestSharedObject()
-        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: runtime.createObject())
+        let id = sharedObjectRegistry.add(native: nativeObject, javaScript: runtime.createObject())
         expect(nativeObject.sharedObjectId) == id
       }
+      it("assigns the app context on native object") {
+        let nativeObject = TestSharedObject()
+        sharedObjectRegistry.add(native: nativeObject, javaScript: runtime.createObject())
+        expect(nativeObject.appContext) == appContext
+      }
       it("assigns id on JS object") {
         let jsObject = runtime.createObject()
-        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: jsObject)
+        let id = sharedObjectRegistry.add(native: TestSharedObject(), javaScript: jsObject)
         expect(jsObject.hasProperty(sharedObjectIdPropertyName)) == true
         expect(try! jsObject.getProperty(sharedObjectIdPropertyName).asInt()) == id
       }
       it("saves objects pair") {
         let nativeObject = TestSharedObject()
         let jsObject = runtime.createObject()
-        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
-        let pair = SharedObjectRegistry.get(id)
+        let id = sharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
+        let pair = sharedObjectRegistry.get(id)
         expect(pair?.native) === nativeObject
         expect(pair?.javaScript.lock()) == jsObject
       }
@@ -60,14 +66,14 @@ final class SharedObjectRegistrySpec: ExpoSpec {
 
     describe("delete") {
       it("deletes objects pair") {
-        let id = SharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime.createObject())
-        SharedObjectRegistry.delete(id)
-        expect(SharedObjectRegistry.get(id)).to(beNil())
+        let id = sharedObjectRegistry.add(native: TestSharedObject(), javaScript: runtime.createObject())
+        sharedObjectRegistry.delete(id)
+        expect(sharedObjectRegistry.get(id)).to(beNil())
       }
       it("resets id on native object") {
         let nativeObject = TestSharedObject()
-        let id = SharedObjectRegistry.add(native: nativeObject, javaScript: runtime.createObject())
-        SharedObjectRegistry.delete(id)
+        let id = sharedObjectRegistry.add(native: nativeObject, javaScript: runtime.createObject())
+        sharedObjectRegistry.delete(id)
         expect(nativeObject.sharedObjectId).toEventually(equal(0))
       }
     }
@@ -76,12 +82,12 @@ final class SharedObjectRegistrySpec: ExpoSpec {
       it("returns native object") {
         let nativeObject = TestSharedObject()
         let jsObject = runtime.createObject()
-        SharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
-        expect(SharedObjectRegistry.toNativeObject(jsObject)) === nativeObject
+        sharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
+        expect(sharedObjectRegistry.toNativeObject(jsObject)) === nativeObject
       }
       it("returns nil") {
         let jsObject = runtime.createObject()
-        expect(SharedObjectRegistry.toNativeObject(jsObject)).to(beNil())
+        expect(sharedObjectRegistry.toNativeObject(jsObject)).to(beNil())
       }
     }
 
@@ -89,12 +95,12 @@ final class SharedObjectRegistrySpec: ExpoSpec {
       it("returns JS object") {
         let nativeObject = TestSharedObject()
         let jsObject = runtime.createObject()
-        SharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
-        expect(SharedObjectRegistry.toJavaScriptObject(nativeObject)) == jsObject
+        sharedObjectRegistry.add(native: nativeObject, javaScript: jsObject)
+        expect(sharedObjectRegistry.toJavaScriptObject(nativeObject)) == jsObject
       }
       it("returns nil") {
         let nativeObject = TestSharedObject()
-        expect(SharedObjectRegistry.toJavaScriptObject(nativeObject)).to(beNil())
+        expect(sharedObjectRegistry.toJavaScriptObject(nativeObject)).to(beNil())
       }
     }
   }

package/ios/Tests/SharedObjectSpec.swift

@@ -0,0 +1,141 @@
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class SharedObjectSpec: ExpoSpec {
+  override class func spec() {
+    let appContext = AppContext.create()
+    let runtime = try! appContext.runtime
+
+    beforeSuite {
+      appContext.moduleRegistry.register(moduleType: SharedObjectModule.self)
+    }
+
+    describe("Base JS class") {
+      it("exists") {
+        let baseSharedObjectClass = try runtime.eval("expo.SharedObject")
+        expect(baseSharedObjectClass.kind) == .function
+      }
+
+      it("has release function in prototype") {
+        let releaseFunction = try runtime.eval("expo.SharedObject.prototype.release")
+        expect(releaseFunction.kind) == .function
+      }
+
+      it("initializes") {
+        let sharedObject = try runtime.eval("new expo.SharedObject()")
+        expect(sharedObject.kind) == .object
+      }
+
+      it("does not register") {
+        let registrySizeBefore = appContext.sharedObjectRegistry.size
+        try runtime.eval("new expo.SharedObject()")
+        expect(appContext.sharedObjectRegistry.size) == registrySizeBefore
+      }
+
+      it("inherits from EventEmitter") {
+        let isEventEmitter = try runtime.eval("new expo.SharedObject() instanceof expo.EventEmitter")
+        expect(isEventEmitter.kind) == .bool
+        expect(try isEventEmitter.asBool()) == true
+      }
+    }
+
+    describe("Concrete JS class") {
+      it("exists") {
+        let sharedObjectClass = try runtime.eval("expo.modules.SharedObjectModule.SharedObjectExample")
+        expect(sharedObjectClass.kind) == .function
+      }
+
+      it("has base class prototype") {
+        let hasBaseClassPrototype = try runtime.eval("expo.modules.SharedObjectModule.SharedObjectExample.prototype instanceof expo.SharedObject")
+        expect(hasBaseClassPrototype.kind) == .bool
+        expect(try hasBaseClassPrototype.asBool()) == true
+      }
+
+      it("creates new instance") {
+        let sharedObject = try runtime.eval("new expo.modules.SharedObjectModule.SharedObjectExample()")
+        expect(sharedObject.kind) == .object
+      }
+
+      it("registers") {
+        let registrySizeBefore = appContext.sharedObjectRegistry.size
+        try runtime.eval("new expo.modules.SharedObjectModule.SharedObjectExample()")
+        expect(appContext.sharedObjectRegistry.size) == registrySizeBefore + 1
+      }
+
+      it("is instance of") {
+        let isInstanceOf = try runtime.eval([
+          "sharedObject = new expo.modules.SharedObjectModule.SharedObjectExample()",
+          "sharedObject instanceof expo.modules.SharedObjectModule.SharedObjectExample"
+        ])
+        expect(isInstanceOf.kind) == .bool
+        expect(try isInstanceOf.asBool()) == true
+      }
+
+      it("is instance of base class") {
+        let isInstanceOfBaseClass = try runtime.eval([
+          "sharedObject = new expo.modules.SharedObjectModule.SharedObjectExample()",
+          "sharedObject instanceof expo.SharedObject"
+        ])
+        expect(isInstanceOfBaseClass.kind) == .bool
+        expect(try isInstanceOfBaseClass.asBool()) == true
+      }
+
+      it("has function from base class") {
+        let releaseFunction = try runtime.eval([
+          "sharedObject = new expo.modules.SharedObjectModule.SharedObjectExample()",
+          "sharedObject.release"
+        ])
+        expect(releaseFunction.kind) == .function
+      }
+    }
+
+    describe("Native object") {
+      // Event emitting requires Xcode 15.0, but we're still using Xcode 14
+      // to run these tests on GitHub Actions due to some performance issues.
+      #if swift(>=5.9)
+      it("emits events") {
+        // Create the shared object
+        let jsObject = try runtime
+          .eval("sharedObject = new expo.modules.SharedObjectModule.SharedObjectExample()")
+          .asObject()
+
+        // Add a listener that adds three arguments
+        try runtime.eval([
+          "result = null",
+          "sharedObject.addListener('test event', (number, string, record) => { result = { number, string, record } })"
+        ])
+
+        // Get the native instance
+        let nativeObject = appContext.sharedObjectRegistry.toNativeObject(jsObject)
+
+        struct EventRecord: Record {
+          @Field var boolean: Bool = true
+        }
+
+        // Emit an event from the native object to JS
+        nativeObject?.emit(event: "test event", arguments: 123, "test", EventRecord())
+
+        // Check the value that is set by the listener
+        let result = try runtime.eval("result").asObject()
+
+        expect(try result.getProperty("number").asInt()) == 123
+        expect(try result.getProperty("string").asString()) == "test"
+        expect(try result.getProperty("record").asObject().getProperty("boolean").asBool()) == true
+      }
+      #endif // swift(>=5.9)
+    }
+  }
+}
+
+private class SharedObjectModule: Module {
+  public func definition() -> ModuleDefinition {
+    Class(SharedObjectExample.self) {
+      Constructor {
+        return SharedObjectExample()
+      }
+    }
+  }
+}
+
+private final class SharedObjectExample: SharedObject {}

package/ios/Tests/ViewDefinitionSpec.swift

@@ -33,7 +33,7 @@ final class ViewDefinitionSpec: ExpoSpec {
         let textView = UITextView()
         let content = "hello"
         let definition = View(UITextView.self) {
-          // The type of `view` is inferred and equals to the type passed to `View` component.
+          // The type of `view` is inferred and equals to the type passed to `View`.
           Prop("content") { (view, _: String) in
             expect(view).to(beAKindOf(UITextView.self))
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "1.11.13",
+  "version": "1.12.1",
   "description": "The core of Expo Modules architecture",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -44,5 +44,5 @@
     "@testing-library/react-hooks": "^7.0.1",
     "expo-module-scripts": "^3.0.0"
   },
-  "gitHead": "2ad93407e82a11504d6cc2412cf3d76858782619"
+  "gitHead": "0897aeadb926491a457bcd67d83360956994ee82"
 }

package/src/EventEmitter.ts

@@ -1,5 +1,5 @@
 import invariant from 'invariant';
-import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
+import { NativeEventEmitter, Platform } from 'react-native';
 
 const nativeEmitterSubscriptionKey = '@@nativeEmitterSubscription@@';
 
@@ -7,8 +7,11 @@ type NativeModule = {
   __expo_module_name__?: string;
   startObserving?: () => void;
   stopObserving?: () => void;
-  addListener: (eventName: string) => void;
-  removeListeners: (count: number) => void;
+
+  // Erase these types as they would conflict with the new NativeModule type.
+  // This EventEmitter is deprecated anyway.
+  addListener?: any;
+  removeListeners?: any;
 };
 
 // @needsAudit
@@ -21,25 +24,19 @@ export type Subscription = {
 
 export class EventEmitter {
   _listenerCount = 0;
+
+  // @ts-expect-error
   _nativeModule: NativeModule;
+
+  // @ts-expect-error
   _eventEmitter: NativeEventEmitter;
 
   constructor(nativeModule: NativeModule) {
-    // Expo modules installed through the JSI don't have `addListener` and `removeListeners` set,
-    // so if someone wants to use them with `EventEmitter`, make sure to provide these functions
-    // as they are required by `NativeEventEmitter`. This is only temporary — in the future
-    // JSI modules will have event emitter built in.
-    if (nativeModule.__expo_module_name__ && NativeModules.EXReactNativeEventEmitter) {
-      nativeModule.addListener = (...args) =>
-        NativeModules.EXReactNativeEventEmitter.addProxiedListener(
-          nativeModule.__expo_module_name__,
-          ...args
-        );
-      nativeModule.removeListeners = (...args) =>
-        NativeModules.EXReactNativeEventEmitter.removeProxiedListeners(
-          nativeModule.__expo_module_name__,
-          ...args
-        );
+    // If the native module is a new module, just return it back as it's already an event emitter.
+    // This is for backwards compatibility until we stop using this legacy class in other packages.
+    if (nativeModule.__expo_module_name__) {
+      // @ts-expect-error
+      return nativeModule;
     }
     this._nativeModule = nativeModule;
     this._eventEmitter = new NativeEventEmitter(nativeModule as any);

package/src/NativeModule.ts

@@ -0,0 +1,6 @@
+import { ensureNativeModulesAreInstalled } from './ensureNativeModulesAreInstalled';
+import type { NativeModule } from './ts-declarations/NativeModule';
+
+ensureNativeModulesAreInstalled();
+
+export default globalThis.expo.NativeModule as typeof NativeModule;

package/src/NativeModulesProxy.native.ts

@@ -1,3 +1,8 @@
+// Copyright © 2024 650 Industries.
+// NOTE: Forcing this to be a client boundary so the errors are a bit clearer. In the future we can
+// make this a shim on the server by ignoring the globals that are missing in React Server contexts (Node.js).
+'use client';
+
 import { NativeModules } from 'react-native';
 
 import { ProxyNativeModule } from './NativeModulesProxy.types';

package/src/NativeModulesProxy.types.ts

@@ -1,5 +1,5 @@
 export type ProxyNativeModule = {
   [propertyName: string]: any;
-  addListener: (eventName: string) => void;
-  removeListeners: (count: number) => void;
+  addListener?: (eventName: string) => void;
+  removeListeners?: (count: number) => void;
 };

package/src/NativeViewManagerAdapter.native.tsx

@@ -1,5 +1,10 @@
+// Copyright © 2024 650 Industries.
+
+'use client';
+
 import React from 'react';
-import { findNodeHandle, NativeModules, requireNativeComponent, HostComponent } from 'react-native';
+import { findNodeHandle, NativeModules, HostComponent } from 'react-native';
+import * as NativeComponentRegistry from 'react-native/Libraries/NativeComponent/NativeComponentRegistry';
 
 import { requireNativeModule } from './requireNativeModule';
 
@@ -17,6 +22,25 @@ import { requireNativeModule } from './requireNativeModule';
  */
 const nativeComponentsCache = new Map<string, HostComponent<any>>();
 
+/**
+ * Requires a React Native component using the static view config from an Expo module.
+ */
+function requireNativeComponent<Props>(viewName: string): HostComponent<Props> {
+  return NativeComponentRegistry.get<Props>(viewName, () => {
+    const viewModuleName = viewName.replace('ViewManagerAdapter_', '');
+    const expoViewConfig = globalThis.expo?.getViewConfig(viewModuleName);
+
+    if (!expoViewConfig) {
+      console.warn('Unable to get the view config for %s', viewModuleName);
+    }
+
+    return {
+      uiViewClassName: viewName,
+      ...expoViewConfig,
+    };
+  });
+}
+
 /**
  * Requires a React Native component from cache if possible. This prevents
  * "Tried to register two views with the same name" errors on fast refresh, but

package/src/PermissionsHook.ts

@@ -1,3 +1,7 @@
+// Copyright © 2024 650 Industries.
+
+'use client';
+
 import { useCallback, useEffect, useRef, useState } from 'react';
 
 import { PermissionResponse } from './PermissionsInterface';

package/src/Refs.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+
+/**
+ * Create a React ref object that is friendly for snapshots.
+ * It will be represented as `[React.ref]` in snapshots.
+ * @returns a React ref object.
+ */
+export function createSnapshotFriendlyRef<T>(): React.RefObject<T> {
+  return React.createRef<T>();
+}

package/src/SharedObject.ts

@@ -0,0 +1,6 @@
+import { ensureNativeModulesAreInstalled } from './ensureNativeModulesAreInstalled';
+import type { SharedObject } from './ts-declarations/SharedObject';
+
+ensureNativeModulesAreInstalled();
+
+export default globalThis.expo.SharedObject as typeof SharedObject;

package/src/createWebModule.ts

@@ -0,0 +1,5 @@
+// It is a no-op function that returns the module implementation without importing CoreModule.
+// Actual implementation is located in `createWebModule.web.ts`.
+export function createWebModule<ModuleType = any>(moduleImplementation: ModuleType): ModuleType {
+  return moduleImplementation;
+}

package/src/createWebModule.web.ts

@@ -0,0 +1,6 @@
+import { NativeModule } from './web/CoreModule';
+
+export function createWebModule<ModuleType = any>(moduleImplementation: ModuleType): ModuleType {
+  const module = new NativeModule();
+  return Object.assign(module, moduleImplementation);
+}

package/src/ensureNativeModulesAreInstalled.ts

@@ -0,0 +1,24 @@
+import { NativeModules, Platform } from 'react-native';
+
+/**
+ * Ensures that the native modules are installed in the current runtime.
+ * Otherwise, it synchronously calls a native function that installs them.
+ */
+export function ensureNativeModulesAreInstalled(): void {
+  if (globalThis.expo) {
+    return;
+  }
+  try {
+    if (Platform.OS === 'web') {
+      // Requiring web folder sets up the `globalThis.expo` object.
+      require('./web');
+    } else {
+      // TODO: ExpoModulesCore shouldn't be optional here,
+      // but to keep backwards compatibility let's just ignore it in SDK 50.
+      // In most cases the modules were already installed from the native side.
+      NativeModules.ExpoModulesCore?.installModules();
+    }
+  } catch (error) {
+    console.error(`Unable to install Expo modules: ${error}`);
+  }
+}

package/src/hooks/useReleasingSharedObject.ts

@@ -0,0 +1,51 @@
+import { DependencyList, useRef, useMemo, useEffect } from 'react';
+
+import type { SharedObject } from '../ts-declarations/SharedObject';
+
+/**
+ * Returns a shared object, which is automatically cleaned up when the component is unmounted.
+ */
+export function useReleasingSharedObject<TSharedObject extends SharedObject>(
+  factory: () => TSharedObject,
+  dependencies: DependencyList
+): TSharedObject {
+  const objectRef = useRef<TSharedObject | null>(null);
+  const isFastRefresh = useRef(false);
+  const previousDependencies = useRef<DependencyList>(dependencies);
+
+  if (objectRef.current == null) {
+    objectRef.current = factory();
+  }
+
+  const object = useMemo(() => {
+    let newObject = objectRef.current;
+    const dependenciesAreEqual =
+      previousDependencies.current?.length === dependencies.length &&
+      dependencies.every((value, index) => value === previousDependencies.current[index]);
+
+    // If the dependencies have changed, release the previous object and create a new one, otherwise this has been called
+    // because of a fast refresh, and we don't want to release the object.
+    if (!newObject || !dependenciesAreEqual) {
+      objectRef.current?.release();
+      newObject = factory();
+      objectRef.current = newObject;
+      previousDependencies.current = dependencies;
+    } else {
+      isFastRefresh.current = true;
+    }
+    return newObject;
+  }, dependencies);
+
+  useEffect(() => {
+    isFastRefresh.current = false;
+
+    return () => {
+      // This will be called on every fast refresh and on unmount, but we only want to release the object on unmount.
+      if (!isFastRefresh.current && objectRef.current) {
+        objectRef.current.release();
+      }
+    };
+  }, []);
+
+  return object;
+}

package/src/index.ts

@@ -1,14 +1,19 @@
 import { DeviceEventEmitter } from 'react-native';
 
 import { EventEmitter, Subscription } from './EventEmitter';
+import NativeModule from './NativeModule';
 import NativeModulesProxy from './NativeModulesProxy';
 import { ProxyNativeModule } from './NativeModulesProxy.types';
 import { requireNativeViewManager } from './NativeViewManagerAdapter';
 import Platform from './Platform';
+import SharedObject from './SharedObject';
 import { CodedError } from './errors/CodedError';
 import { UnavailabilityError } from './errors/UnavailabilityError';
 
 import './sweet/setUpErrorManager.fx';
+import './web/index';
+
+export type * from './ts-declarations/global';
 
 export { default as uuid } from './uuid';
 
@@ -20,12 +25,16 @@ export {
   Platform,
   Subscription,
   requireNativeViewManager,
+  // Globals
+  SharedObject,
+  NativeModule,
   // Errors
   CodedError,
   UnavailabilityError,
 };
 
 export * from './requireNativeModule';
+export * from './createWebModule';
 export * from './TypedArrays.types';
 
 /**
@@ -35,3 +44,7 @@ export const SyntheticPlatformEmitter = DeviceEventEmitter;
 
 export * from './PermissionsInterface';
 export * from './PermissionsHook';
+
+export * from './Refs';
+
+export * from './hooks/useReleasingSharedObject';

package/src/requireNativeModule.ts

@@ -1,31 +1,5 @@
-import { NativeModules } from 'react-native';
-
 import NativeModulesProxy from './NativeModulesProxy';
-
-type ExpoObject = {
-  modules:
-    | undefined
-    | {
-        [key: string]: any;
-      };
-  uuidv4: () => string;
-  uuidv5: (name: string, namespace: string) => string;
-};
-
-declare global {
-  // eslint-disable-next-line no-var
-  var expo: ExpoObject | undefined;
-
-  /**
-   * @deprecated `global.ExpoModules` is deprecated, use `global.expo.modules` instead.
-   */
-  // eslint-disable-next-line no-var
-  var ExpoModules:
-    | undefined
-    | {
-        [key: string]: any;
-      };
-}
+import { ensureNativeModulesAreInstalled } from './ensureNativeModulesAreInstalled';
 
 /**
  * Imports the native module registered with given name. In the first place it tries to load
@@ -57,28 +31,5 @@ export function requireOptionalNativeModule<ModuleType = any>(
 ): ModuleType | null {
   ensureNativeModulesAreInstalled();
 
-  return (
-    globalThis.expo?.modules?.[moduleName] ??
-    globalThis.ExpoModules?.[moduleName] ??
-    NativeModulesProxy[moduleName] ??
-    null
-  );
-}
-
-/**
- * Ensures that the native modules are installed in the current runtime.
- * Otherwise, it synchronously calls a native function that installs them.
- */
-function ensureNativeModulesAreInstalled(): void {
-  if (globalThis.expo) {
-    return;
-  }
-  try {
-    // TODO: ExpoModulesCore shouldn't be optional here,
-    // but to keep backwards compatibility let's just ignore it in SDK 50.
-    // In most cases the modules were already installed from the native side.
-    NativeModules.ExpoModulesCore?.installModules();
-  } catch (error) {
-    console.error(`Unable to install Expo modules: ${error}`);
-  }
+  return globalThis.expo?.modules?.[moduleName] ?? NativeModulesProxy[moduleName] ?? null;
 }