react-native 0.73.0-rc.2 → 0.73.0-rc.4

package/ReactAndroid/src/main/java/com/facebook/react/runtime/BridgelessReactContext.java

@@ -22,6 +22,7 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactNoCrashBridgeNotAllowedSoftException;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.uimanager.events.EventDispatcher;
@@ -49,6 +50,9 @@ class BridgelessReactContext extends ReactApplicationContext implements EventDis
   BridgelessReactContext(Context context, ReactHostImpl host) {
     super(context);
     mReactHost = host;
+    if (ReactFeatureFlags.unstable_useFabricInterop) {
+      initializeInteropModules();
+    }
   }
 
   @Override
@@ -124,6 +128,10 @@ class BridgelessReactContext extends ReactApplicationContext implements EventDis
 
   @Override
   public <T extends JavaScriptModule> T getJSModule(Class<T> jsInterface) {
+    if (mInteropModuleRegistry != null
+        && mInteropModuleRegistry.shouldReturnInteropModule(jsInterface)) {
+      return mInteropModuleRegistry.getInteropModule(jsInterface);
+    }
     JavaScriptModule interfaceProxy =
         (JavaScriptModule)
             Proxy.newProxyInstance(

package/ReactAndroid/src/main/java/com/facebook/react/runtime/CoreReactPackage.java

@@ -19,6 +19,7 @@ import com.facebook.react.module.model.ReactModuleInfo;
 import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.modules.core.ExceptionsManagerModule;
 import com.facebook.react.modules.debug.DevSettingsModule;
 import com.facebook.react.modules.debug.SourceCodeModule;
 import com.facebook.react.modules.deviceinfo.DeviceInfoModule;
@@ -36,6 +37,7 @@ import java.util.Map;
       SourceCodeModule.class,
       LogBoxModule.class,
       DeviceEventManagerModule.class,
+      ExceptionsManagerModule.class,
     })
 class CoreReactPackage extends TurboReactPackage {
 
@@ -63,6 +65,8 @@ class CoreReactPackage extends TurboReactPackage {
         return new DeviceEventManagerModule(reactContext, mHardwareBackBtnHandler);
       case LogBoxModule.NAME:
         return new LogBoxModule(reactContext, mDevSupportManager);
+      case ExceptionsManagerModule.NAME:
+        return new ExceptionsManagerModule(mDevSupportManager);
       default:
         throw new IllegalArgumentException(
             "In BridgelessReactPackage, could not find Native module for " + name);
@@ -85,6 +89,7 @@ class CoreReactPackage extends TurboReactPackage {
             DevSettingsModule.class,
             DeviceEventManagerModule.class,
             LogBoxModule.class,
+            ExceptionsManagerModule.class,
           };
       final Map<String, ReactModuleInfo> reactModuleInfoMap = new HashMap<>();
       for (Class<? extends NativeModule> moduleClass : moduleList) {

package/ReactAndroid/src/main/java/com/facebook/react/runtime/JSTimerExecutor.java

@@ -9,13 +9,15 @@ package com.facebook.react.runtime;
 
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.jni.HybridData;
-import com.facebook.jni.annotations.DoNotStrip;
+import com.facebook.jni.annotations.DoNotStripAny;
+import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.modules.core.JavaScriptTimerExecutor;
 import com.facebook.soloader.SoLoader;
 
 @Nullsafe(Nullsafe.Mode.LOCAL)
+@DoNotStripAny
 class JSTimerExecutor implements JavaScriptTimerExecutor {
 
   static {
@@ -24,6 +26,7 @@ class JSTimerExecutor implements JavaScriptTimerExecutor {
 
   @DoNotStrip private final HybridData mHybridData;
 
+  @DoNotStrip
   public JSTimerExecutor(HybridData hybridData) {
     mHybridData = hybridData;
   }

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostImpl.java

@@ -25,6 +25,7 @@ import com.facebook.infer.annotation.ThreadConfined;
 import com.facebook.infer.annotation.ThreadSafe;
 import com.facebook.react.JSEngineResolutionAlgorithm;
 import com.facebook.react.MemoryPressureRouter;
+import com.facebook.react.ReactHost;
 import com.facebook.react.ReactInstanceEventListener;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.JSBundleLoader;
@@ -48,7 +49,6 @@ import com.facebook.react.devsupport.DisabledDevSupportManager;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.fabric.ComponentFactory;
 import com.facebook.react.fabric.FabricUIManager;
-import com.facebook.react.interfaces.ReactHost;
 import com.facebook.react.interfaces.TaskInterface;
 import com.facebook.react.interfaces.exceptionmanager.ReactJsExceptionHandler;
 import com.facebook.react.interfaces.fabric.ReactSurface;
@@ -638,6 +638,9 @@ public class ReactHostImpl implements ReactHost {
     final String method = "handleHostException(message = \"" + e.getMessage() + "\")";
     log(method);
 
+    if (DEV) {
+      mDevSupportManager.handleException(e);
+    }
     destroy(method, e);
     mReactHostDelegate.handleInstanceException(e);
   }
@@ -922,6 +925,7 @@ public class ReactHostImpl implements ReactHost {
                     final JSBundleLoader bundleLoader = task.getResult();
                     final BridgelessReactContext reactContext = getOrCreateReactContext();
                     final DevSupportManager devSupportManager = getDevSupportManager();
+                    reactContext.setJSExceptionHandler(devSupportManager);
 
                     log(method, "Creating ReactInstance");
                     final ReactInstance instance =
@@ -1036,6 +1040,7 @@ public class ReactHostImpl implements ReactHost {
 
           final BridgelessReactContext reactContext = getOrCreateReactContext();
           final DevSupportManager devSupportManager = getDevSupportManager();
+          reactContext.setJSExceptionHandler(devSupportManager);
 
           return getJsBundleLoader()
               .onSuccess(

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactInstance.java

@@ -71,6 +71,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import javax.annotation.Nullable;
 
 /**
@@ -93,6 +94,7 @@ final class ReactInstance {
   private final TurboModuleManager mTurboModuleManager;
   private final FabricUIManager mFabricUIManager;
   private final JavaTimerManager mJavaTimerManager;
+  private final Map<String, ViewManager> mViewManagers = new ConcurrentHashMap<>();
 
   @DoNotStrip @Nullable private ComponentNameResolverManager mComponentNameResolverManager;
   @DoNotStrip @Nullable private UIConstantsProviderManager mUIConstantsProviderManager;
@@ -489,8 +491,12 @@ final class ReactInstance {
   }
 
   private @Nullable ViewManager createViewManager(String viewManagerName) {
+    // Return cached view manager if available, no matter it's eagerly or lazily loaded
+    if (mViewManagers.containsKey(viewManagerName)) {
+      return mViewManagers.get(viewManagerName);
+    }
+    List<ReactPackage> packages = mReactPackages;
     if (mDelegate != null) {
-      List<ReactPackage> packages = mReactPackages;
       if (packages != null) {
         synchronized (packages) {
           for (ReactPackage reactPackage : packages) {
@@ -499,6 +505,7 @@ final class ReactInstance {
                   ((ViewManagerOnDemandReactPackage) reactPackage)
                       .createViewManager(mBridgelessReactContext, viewManagerName);
               if (viewManager != null) {
+                mViewManagers.put(viewManagerName, viewManager);
                 return viewManager;
               }
             }
@@ -507,7 +514,17 @@ final class ReactInstance {
       }
     }
 
-    return null;
+    // Once a view manager is not found in all react packages via lazy loading, fall back to default
+    // implementation: eagerly initialize all view managers
+    for (ReactPackage reactPackage : packages) {
+      List<ViewManager> viewManagersInPackage =
+          reactPackage.createViewManagers(mBridgelessReactContext);
+      for (ViewManager viewManager : viewManagersInPackage) {
+        mViewManagers.put(viewManager.getName(), viewManager);
+      }
+    }
+
+    return mViewManagers.get(viewManagerName);
   }
 
   private @NonNull Collection<String> getViewManagerNames() {
@@ -534,8 +551,28 @@ final class ReactInstance {
 
   private @NonNull NativeMap getUIManagerConstants() {
     List<ViewManager> viewManagers = new ArrayList<ViewManager>();
-    for (String viewManagerName : getViewManagerNames()) {
-      viewManagers.add(createViewManager(viewManagerName));
+    boolean canLoadViewManagersLazily = true;
+
+    List<ReactPackage> packages = mReactPackages;
+    for (ReactPackage reactPackage : packages) {
+      if (!(reactPackage instanceof ViewManagerOnDemandReactPackage)) {
+        canLoadViewManagersLazily = false;
+        break;
+      }
+    }
+    // 1, Retrive view managers via on demand loading
+    if (canLoadViewManagersLazily) {
+      for (String viewManagerName : getViewManagerNames()) {
+        viewManagers.add(createViewManager(viewManagerName));
+      }
+    } else {
+      // 2, There are packages that don't implement ViewManagerOnDemandReactPackage so we retrieve
+      // view managers via eager loading
+      for (ReactPackage reactPackage : packages) {
+        List<ViewManager> viewManagersInPackage =
+            reactPackage.createViewManagers(mBridgelessReactContext);
+        viewManagers.addAll(viewManagersInPackage);
+      }
     }
     Map<String, Object> constants =
         UIManagerModule.createConstants(viewManagers, new HashMap<>(), new HashMap<>());

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/FabricViewStateManager.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager;
+
+import androidx.annotation.Nullable;
+import com.facebook.common.logging.FLog;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+
+/**
+ * This is a helper base class for ViewGroups that use Fabric State.
+ *
+ * <p>Reason to use this: UpdateState calls from the View layer to the Fabric core can fail, and
+ * optionally Fabric will call a "failure callback" if that happens. This class abstracts that and
+ * makes it easier ensure that State in Fabric is always up-to-date.
+ *
+ * <p>1. Whenever ViewManager.updateState is called, call View.setStateWrapper. 2. Instead of
+ * calling StateWrapper.updateState directly, call View.setState and it will automatically keep
+ * retrying the UpdateState call until it succeeds; or you call setState again; or the View layer is
+ * updated with a newer StateWrapper.
+ */
+@Deprecated(
+    since =
+        "Deprecated class since v0.73.0, please use com.facebook.react.uimanager.StateWrapper instead.",
+    forRemoval = true)
+public class FabricViewStateManager {
+  private static final String TAG = "FabricViewStateManager";
+
+  @Deprecated
+  public interface HasFabricViewStateManager {
+    FabricViewStateManager getFabricViewStateManager();
+  }
+
+  @Deprecated
+  public interface StateUpdateCallback {
+    WritableMap getStateUpdate();
+  }
+
+  @Nullable private StateWrapper mStateWrapper = null;
+
+  @Deprecated
+  public void setStateWrapper(StateWrapper stateWrapper) {
+    mStateWrapper = stateWrapper;
+  }
+
+  @Deprecated
+  public boolean hasStateWrapper() {
+    return mStateWrapper != null;
+  }
+
+  private void setState(
+      @Nullable final StateWrapper stateWrapper,
+      final StateUpdateCallback stateUpdateCallback,
+      final int numTries) {
+    // The StateWrapper will change, breaking the async loop, whenever the UpdateState MountItem
+    // is executed.
+    // The caller is responsible for detecting if data is up-to-date, and doing nothing, or
+    // detecting if state is stale and calling setState again.
+    if (stateWrapper == null) {
+      FLog.e(TAG, "setState called without a StateWrapper");
+      return;
+    }
+    if (stateWrapper != mStateWrapper) {
+      return;
+    }
+    // We bail out after an arbitrary number of tries. In practice this should never go higher
+    // than 2 or 3, but there's nothing guaranteeing that.
+    if (numTries > 60) {
+      return;
+    }
+
+    @Nullable WritableMap stateUpdate = stateUpdateCallback.getStateUpdate();
+    if (stateUpdate == null) {
+      return;
+    }
+
+    // TODO: State update cannot fail; remove `failureRunnable` and custom retrying logic.
+    stateWrapper.updateState(stateUpdate);
+  }
+
+  @Deprecated
+  public void setState(final StateUpdateCallback stateUpdateCallback) {
+    setState(mStateWrapper, stateUpdateCallback, 0);
+  }
+
+  @Deprecated
+  public @Nullable ReadableMap getStateData() {
+    return mStateWrapper != null ? mStateWrapper.getStateData() : null;
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactShadowNode.java

@@ -123,9 +123,9 @@ public interface ReactShadowNode<T extends ReactShadowNode> {
    */
   void onCollectExtraUpdates(UIViewOperationQueue uiViewOperationQueue);
 
-  /** @return true if layout (position or dimensions) changed, false otherwise. */
+  /* package */ boolean dispatchUpdatesWillChangeLayout(float absoluteX, float absoluteY);
 
-  /* package */ boolean dispatchUpdates(
+  /* package */ void dispatchUpdates(
       float absoluteX,
       float absoluteY,
       UIViewOperationQueue uiViewOperationQueue,

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactShadowNodeImpl.java

@@ -337,9 +337,32 @@ public class ReactShadowNodeImpl implements ReactShadowNode<ReactShadowNodeImpl>
   @Override
   public void onCollectExtraUpdates(UIViewOperationQueue uiViewOperationQueue) {}
 
-  /** @return true if layout (position or dimensions) changed, false otherwise. */
   @Override
-  public boolean dispatchUpdates(
+  public boolean dispatchUpdatesWillChangeLayout(float absoluteX, float absoluteY) {
+    if (!hasNewLayout()) {
+      return false;
+    }
+
+    float layoutX = getLayoutX();
+    float layoutY = getLayoutY();
+    int newAbsoluteLeft = Math.round(absoluteX + layoutX);
+    int newAbsoluteTop = Math.round(absoluteY + layoutY);
+    int newAbsoluteRight = Math.round(absoluteX + layoutX + getLayoutWidth());
+    int newAbsoluteBottom = Math.round(absoluteY + layoutY + getLayoutHeight());
+
+    int newScreenX = Math.round(layoutX);
+    int newScreenY = Math.round(layoutY);
+    int newScreenWidth = newAbsoluteRight - newAbsoluteLeft;
+    int newScreenHeight = newAbsoluteBottom - newAbsoluteTop;
+
+    return newScreenX != mScreenX
+        || newScreenY != mScreenY
+        || newScreenWidth != mScreenWidth
+        || newScreenHeight != mScreenHeight;
+  }
+
+  @Override
+  public void dispatchUpdates(
       float absoluteX,
       float absoluteY,
       UIViewOperationQueue uiViewOperationQueue,
@@ -386,10 +409,6 @@ public class ReactShadowNodeImpl implements ReactShadowNode<ReactShadowNodeImpl>
               getScreenHeight());
         }
       }
-
-      return layoutHasChanged;
-    } else {
-      return false;
     }
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/UIImplementation.java

@@ -29,7 +29,9 @@ import com.facebook.systrace.Systrace;
 import com.facebook.systrace.SystraceMessage;
 import com.facebook.yoga.YogaConstants;
 import com.facebook.yoga.YogaDirection;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -665,7 +667,20 @@ public class UIImplementation {
               .arg("rootTag", cssRoot.getReactTag())
               .flush();
           try {
-            applyUpdatesRecursive(cssRoot, 0f, 0f);
+            List<ReactShadowNode> onLayoutNodes = new ArrayList<>();
+            applyUpdatesRecursive(cssRoot, 0f, 0f, onLayoutNodes);
+
+            for (ReactShadowNode node : onLayoutNodes) {
+              mEventDispatcher.dispatchEvent(
+                  OnLayoutEvent.obtain(
+                      -1, /* surfaceId not used in classic renderer */
+                      node.getReactTag(),
+                      node.getScreenX(),
+                      node.getScreenY(),
+                      node.getScreenWidth(),
+                      node.getScreenHeight()));
+            }
+
           } finally {
             Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
           }
@@ -951,39 +966,34 @@ public class UIImplementation {
     }
   }
 
-  protected void applyUpdatesRecursive(ReactShadowNode cssNode, float absoluteX, float absoluteY) {
+  protected void applyUpdatesRecursive(
+      ReactShadowNode cssNode,
+      float absoluteX,
+      float absoluteY,
+      List<ReactShadowNode> onLayoutNodes) {
     if (!cssNode.hasUpdates()) {
       return;
     }
 
+    if (cssNode.dispatchUpdatesWillChangeLayout(absoluteX, absoluteY)
+        && cssNode.shouldNotifyOnLayout()
+        && !mShadowNodeRegistry.isRootNode(cssNode.getReactTag())) {
+      onLayoutNodes.add(cssNode);
+    }
+
     Iterable<? extends ReactShadowNode> cssChildren = cssNode.calculateLayoutOnChildren();
     if (cssChildren != null) {
       for (ReactShadowNode cssChild : cssChildren) {
         applyUpdatesRecursive(
-            cssChild, absoluteX + cssNode.getLayoutX(), absoluteY + cssNode.getLayoutY());
+            cssChild,
+            absoluteX + cssNode.getLayoutX(),
+            absoluteY + cssNode.getLayoutY(),
+            onLayoutNodes);
       }
     }
 
-    int tag = cssNode.getReactTag();
-    if (!mShadowNodeRegistry.isRootNode(tag)) {
-      boolean frameDidChange =
-          cssNode.dispatchUpdates(
-              absoluteX, absoluteY, mOperationsQueue, mNativeViewHierarchyOptimizer);
-
-      // Notify JS about layout event if requested
-      // and if the position or dimensions actually changed
-      // (consistent with iOS).
-      if (frameDidChange && cssNode.shouldNotifyOnLayout()) {
-        mEventDispatcher.dispatchEvent(
-            OnLayoutEvent.obtain(
-                -1, /* surfaceId not used in classic renderer */
-                tag,
-                cssNode.getScreenX(),
-                cssNode.getScreenY(),
-                cssNode.getScreenWidth(),
-                cssNode.getScreenHeight()));
-      }
-    }
+    cssNode.dispatchUpdates(absoluteX, absoluteY, mOperationsQueue, mNativeViewHierarchyOptimizer);
+
     cssNode.markUpdateSeen();
     mNativeViewHierarchyOptimizer.onViewUpdatesCompleted(cssNode);
   }

package/ReactAndroid/src/main/java/com/facebook/react/views/text/TextAttributeProps.java

@@ -59,6 +59,7 @@ public class TextAttributeProps {
   public static final short TA_KEY_ACCESSIBILITY_ROLE = 24;
   public static final short TA_KEY_LINE_BREAK_STRATEGY = 25;
   public static final short TA_KEY_ROLE = 26;
+  public static final short TA_KEY_TEXT_TRANSFORM = 27;
 
   public static final int UNSET = -1;
 
@@ -219,6 +220,9 @@ public class TextAttributeProps {
         case TA_KEY_ROLE:
           result.setRole(Role.values()[entry.getIntValue()]);
           break;
+        case TA_KEY_TEXT_TRANSFORM:
+          result.setTextTransform(entry.getStringValue());
+          break;
       }
     }
 
@@ -226,7 +230,6 @@ public class TextAttributeProps {
     // setNumberOfLines
     // setColor
     // setIncludeFontPadding
-    // setTextTransform
     return result;
   }
 

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -18,7 +18,7 @@ constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 73;
   int32_t Patch = 0;
-  std::string_view Prerelease = "rc.2";
+  std::string_view Prerelease = "rc.4";
 } ReactNativeVersion;
 
 } // namespace facebook::react

package/ReactCommon/hermes/executor/HermesExecutorFactory.cpp

@@ -43,13 +43,16 @@ class HermesExecutorRuntimeAdapter
   }
 
   void tickleJs() override {
-    // The queue will ensure that runtime_ is still valid when this
-    // gets invoked.
-    thread_->runOnQueue([&runtime = runtime_]() {
-      auto func =
-          runtime->global().getPropertyAsFunction(*runtime, "__tickleJs");
-      func.call(*runtime);
-    });
+    thread_->runOnQueue(
+        [weakRuntime = std::weak_ptr<HermesRuntime>(runtime_)]() {
+          auto runtime = weakRuntime.lock();
+          if (!runtime) {
+            return;
+          }
+          jsi::Function func =
+              runtime->global().getPropertyAsFunction(*runtime, "__tickleJs");
+          func.call(*runtime);
+        });
   }
 
  private:

package/ReactCommon/react/bridging/Object.h

@@ -31,7 +31,7 @@ struct Bridging<
     std::shared_ptr<T>,
     std::enable_if_t<std::is_base_of_v<jsi::HostObject, T>>> {
   static std::shared_ptr<T> fromJs(jsi::Runtime& rt, const jsi::Object& value) {
-    return value.asHostObject<T>(rt);
+    return value.getHostObject<T>(rt);
   }
 
   static jsi::Object toJs(jsi::Runtime& rt, std::shared_ptr<T> value) {

package/ReactCommon/react/renderer/attributedstring/conversions.h

@@ -970,6 +970,7 @@ constexpr static MapBuffer::Key TA_KEY_LAYOUT_DIRECTION = 23;
 constexpr static MapBuffer::Key TA_KEY_ACCESSIBILITY_ROLE = 24;
 constexpr static MapBuffer::Key TA_KEY_LINE_BREAK_STRATEGY = 25;
 constexpr static MapBuffer::Key TA_KEY_ROLE = 26;
+constexpr static MapBuffer::Key TA_KEY_TEXT_TRANSFORM = 27;
 
 // constants for ParagraphAttributes serialization
 constexpr static MapBuffer::Key PA_KEY_MAX_NUMBER_OF_LINES = 0;
@@ -1077,6 +1078,11 @@ inline MapBuffer toMapBuffer(const TextAttributes& textAttributes) {
         TA_KEY_LINE_BREAK_STRATEGY,
         toString(*textAttributes.lineBreakStrategy));
   }
+  if (textAttributes.textTransform.has_value()) {
+    builder.putString(
+        TA_KEY_TEXT_TRANSFORM, toString(*textAttributes.textTransform));
+  }
+
   // Decoration
   if (textAttributes.textDecorationColor) {
     builder.putInt(

package/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropComponentDescriptor.mm

@@ -8,6 +8,7 @@
 #include "LegacyViewManagerInteropComponentDescriptor.h"
 #include <React/RCTBridge.h>
 #include <React/RCTBridgeModuleDecorator.h>
+#include <React/RCTBridgeProxy.h>
 #include <React/RCTComponentData.h>
 #include <React/RCTEventDispatcher.h>
 #include <React/RCTModuleData.h>
@@ -73,19 +74,45 @@ static Class getViewManagerFromComponentName(const std::string &componentName)
   return nil;
 }
 
+static Class getViewManagerClass(const std::string &componentName, RCTBridge *bridge, RCTBridgeProxy *bridgeProxy)
+{
+  Class viewManager = getViewManagerFromComponentName(componentName);
+  if (viewManager != nil) {
+    return viewManager;
+  }
+
+  // If all the heuristics fail, let's try to retrieve the view manager from the bridge/bridgeProxy
+  if (bridge != nil) {
+    return [[bridge moduleForName:RCTNSStringFromString(componentName)] class];
+  }
+
+  if (bridgeProxy != nil) {
+    return [[bridgeProxy moduleForName:RCTNSStringFromString(componentName) lazilyLoadIfNecessary:YES] class];
+  }
+
+  return nil;
+}
+
 static const std::shared_ptr<void> constructCoordinator(
     const ContextContainer::Shared &contextContainer,
     const ComponentDescriptor::Flavor &flavor)
 {
-  auto componentName = *std::static_pointer_cast<std::string const>(flavor);
-  Class viewManagerClass = getViewManagerFromComponentName(componentName);
-  assert(viewManagerClass);
   auto optionalBridge = contextContainer->find<std::shared_ptr<void>>("Bridge");
   RCTBridge *bridge;
   if (optionalBridge) {
     bridge = unwrapManagedObjectWeakly(optionalBridge.value());
   }
 
+  RCTBridgeProxy *bridgeProxy;
+  auto optionalBridgeProxy = contextContainer->find<std::shared_ptr<void>>("RCTBridgeProxy");
+  if (optionalBridgeProxy) {
+    bridgeProxy = unwrapManagedObjectWeakly(optionalBridgeProxy.value());
+  }
+
+  auto componentName = *std::static_pointer_cast<std::string const>(flavor);
+  Class viewManagerClass = getViewManagerClass(componentName, bridge, bridgeProxy);
+  assert(viewManagerClass);
+
   auto optionalEventDispatcher = contextContainer->find<std::shared_ptr<void>>("RCTEventDispatcher");
   RCTEventDispatcher *eventDispatcher;
   if (optionalEventDispatcher) {
@@ -104,6 +131,7 @@ static const std::shared_ptr<void> constructCoordinator(
   return wrapManagedObject([[RCTLegacyViewManagerInteropCoordinator alloc]
       initWithComponentData:componentData
                      bridge:bridge
+                bridgeProxy:bridgeProxy
       bridgelessInteropData:bridgeModuleDecorator]);
 }
 

package/ReactCommon/react/renderer/components/legacyviewmanagerinterop/RCTLegacyViewManagerInteropCoordinator.h

@@ -14,13 +14,15 @@ NS_ASSUME_NONNULL_BEGIN
 
 @class RCTComponentData;
 @class RCTBridge;
+@class RCTBridgeProxy;
 
 typedef void (^InterceptorBlock)(std::string eventName, folly::dynamic event);
 
 @interface RCTLegacyViewManagerInteropCoordinator : NSObject
 
 - (instancetype)initWithComponentData:(RCTComponentData *)componentData
-                               bridge:(RCTBridge *)bridge
+                               bridge:(nullable RCTBridge *)bridge
+                          bridgeProxy:(nullable RCTBridgeProxy *)bridgeProxy
                 bridgelessInteropData:(RCTBridgeModuleDecorator *)bridgelessInteropData;
 
 - (UIView *)createPaperViewWithTag:(NSInteger)tag;