first commit

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/CMakeLists.txt

@@ -0,0 +1,26 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+
+file(GLOB rrc_legacyviewmanagerinterop_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(rrc_legacyviewmanagerinterop OBJECT ${rrc_legacyviewmanagerinterop_SRC})
+
+target_include_directories(rrc_legacyviewmanagerinterop PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(rrc_legacyviewmanagerinterop
+        glog
+        glog_init
+        folly_runtime
+        jsi
+        react_renderer_core
+        rrc_view
+        yoga
+)
+target_compile_reactnative_options(rrc_legacyviewmanagerinterop PRIVATE)
+target_compile_options(rrc_legacyviewmanagerinterop PRIVATE -Wpedantic)

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropComponentDescriptor.h

@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropShadowNode.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+class LegacyViewManagerInteropComponentDescriptor final
+    : public ConcreteComponentDescriptor<LegacyViewManagerInteropShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  LegacyViewManagerInteropComponentDescriptor(const ComponentDescriptorParameters &parameters);
+  /*
+   * Returns `name` and `handle` based on a `flavor`, not on static data from
+   * `LegacyViewManagerInteropShadowNode`.
+   */
+  ComponentHandle getComponentHandle() const override;
+  ComponentName getComponentName() const override;
+
+ protected:
+  void adopt(ShadowNode &shadowNode) const override;
+
+ private:
+  const std::shared_ptr<void> _coordinator;
+};
+
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropComponentDescriptor.mm

@@ -0,0 +1,177 @@
+/*
+ * 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.
+ */
+
+#include "LegacyViewManagerInteropComponentDescriptor.h"
+#include <React/RCTBridge+Private.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>
+#import <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/utils/ContextContainer.h>
+#include <react/utils/ManagedObjectWrapper.h>
+#include "LegacyViewManagerInteropState.h"
+#include "RCTLegacyViewManagerInteropCoordinator.h"
+
+namespace facebook::react {
+
+static std::string moduleNameFromComponentNameNoRCTPrefix(const std::string &componentName)
+{
+  // TODO: remove FB specific code (T56174424)
+  if (componentName == "StickerInputView") {
+    return "FBStickerInputViewManager";
+  }
+
+  if (componentName == "FDSTooltipView") {
+    return "FBReactFDSTooltipViewManager";
+  }
+
+  std::string fbPrefix("FB");
+  if (std::mismatch(fbPrefix.begin(), fbPrefix.end(), componentName.begin()).first == fbPrefix.end()) {
+    // If `moduleName` has "FB" prefix.
+    return componentName + "Manager";
+  }
+
+  std::string artPrefix("ART");
+  if (std::mismatch(artPrefix.begin(), artPrefix.end(), componentName.begin()).first == artPrefix.end()) {
+    return componentName + "Manager";
+  }
+
+  std::string rnPrefix("RN");
+  if (std::mismatch(rnPrefix.begin(), rnPrefix.end(), componentName.begin()).first == rnPrefix.end()) {
+    return componentName + "Manager";
+  }
+
+  return componentName + "Manager";
+}
+
+inline NSString *RCTNSStringFromString(const std::string &string)
+{
+  return [NSString stringWithUTF8String:string.c_str()];
+}
+
+static Class getViewManagerFromComponentName(const std::string &componentName)
+{
+  auto viewManagerName = moduleNameFromComponentNameNoRCTPrefix(componentName);
+
+  // 1. Try to get the manager with the RCT prefix.
+  auto rctViewManagerName = "RCT" + viewManagerName;
+  Class viewManagerClass = NSClassFromString(RCTNSStringFromString(rctViewManagerName));
+  if (viewManagerClass != nullptr) {
+    return viewManagerClass;
+  }
+
+  // 2. Try to get the manager without the prefix.
+  viewManagerClass = NSClassFromString(RCTNSStringFromString(viewManagerName));
+  if (viewManagerClass != nullptr) {
+    return viewManagerClass;
+  }
+
+  return nil;
+}
+
+static Class getViewManagerClass(const std::string &componentName, RCTBridge *bridge, RCTBridgeProxy *bridgeProxy)
+{
+  Class viewManager = getViewManagerFromComponentName(componentName);
+  if (viewManager != nil) {
+    return viewManager;
+  }
+
+  if (ReactNativeFeatureFlags::enableInteropViewManagerClassLookUpOptimizationIOS()) {
+    NSArray<Class> *modulesClasses = RCTGetModuleClasses();
+    for (Class moduleClass in modulesClasses) {
+      if ([RCTBridgeModuleNameForClass(moduleClass) isEqualToString:RCTNSStringFromString(componentName)]) {
+        return moduleClass;
+      }
+    }
+  } else {
+    // 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 std::shared_ptr<void> constructCoordinator(
+    const std::shared_ptr<const ContextContainer> &contextContainer,
+    const ComponentDescriptor::Flavor &flavor)
+{
+  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<const std::string>(flavor);
+  Class viewManagerClass = getViewManagerClass(componentName, bridge, bridgeProxy);
+  assert(viewManagerClass);
+
+  auto optionalEventDispatcher = contextContainer->find<std::shared_ptr<void>>("RCTEventDispatcher");
+  RCTEventDispatcher *eventDispatcher;
+  if (optionalEventDispatcher) {
+    eventDispatcher = unwrapManagedObject(optionalEventDispatcher.value());
+  }
+
+  auto optionalModuleDecorator = contextContainer->find<std::shared_ptr<void>>("RCTBridgeModuleDecorator");
+  RCTBridgeModuleDecorator *bridgeModuleDecorator;
+  if (optionalModuleDecorator) {
+    bridgeModuleDecorator = unwrapManagedObject(optionalModuleDecorator.value());
+  }
+
+  RCTComponentData *componentData =
+      [[RCTComponentData alloc] initWithManagerClass:viewManagerClass
+                                              bridge:bridge != nil ? bridge : (RCTBridge *)bridgeProxy
+                                     eventDispatcher:eventDispatcher];
+  return wrapManagedObject([[RCTLegacyViewManagerInteropCoordinator alloc]
+      initWithComponentData:componentData
+                     bridge:bridge
+                bridgeProxy:bridgeProxy
+      bridgelessInteropData:bridgeModuleDecorator]);
+}
+
+LegacyViewManagerInteropComponentDescriptor::LegacyViewManagerInteropComponentDescriptor(
+    const ComponentDescriptorParameters &parameters)
+    : ConcreteComponentDescriptor(parameters), _coordinator(constructCoordinator(contextContainer_, flavor_))
+{
+}
+
+ComponentHandle LegacyViewManagerInteropComponentDescriptor::getComponentHandle() const
+{
+  return reinterpret_cast<ComponentHandle>(getComponentName());
+}
+
+ComponentName LegacyViewManagerInteropComponentDescriptor::getComponentName() const
+{
+  return static_cast<const std::string *>(flavor_.get())->c_str();
+}
+
+void LegacyViewManagerInteropComponentDescriptor::adopt(ShadowNode &shadowNode) const
+{
+  ConcreteComponentDescriptor::adopt(shadowNode);
+
+  auto &legacyViewManagerInteropShadowNode = static_cast<LegacyViewManagerInteropShadowNode &>(shadowNode);
+
+  auto state = LegacyViewManagerInteropState{};
+  state.coordinator = _coordinator;
+
+  legacyViewManagerInteropShadowNode.setStateData(std::move(state));
+}
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropShadowNode.cpp

@@ -0,0 +1,13 @@
+/*
+ * 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.
+ */
+
+namespace facebook::react {
+
+extern const char LegacyViewManagerInteropComponentName[] =
+    "LegacyViewManagerInterop";
+
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropShadowNode.h

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropState.h>
+#include <react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropViewProps.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook::react {
+
+extern const char LegacyViewManagerInteropComponentName[];
+
+using LegacyViewManagerInteropShadowNode = ConcreteViewShadowNode<
+    LegacyViewManagerInteropComponentName,
+    LegacyViewManagerInteropViewProps,
+    ViewEventEmitter,
+    LegacyViewManagerInteropState>;
+
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropState.h

@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#import <memory>
+
+namespace facebook::react {
+
+/*
+ * State for <LegacyViewManagerInterop> component.
+ */
+class LegacyViewManagerInteropState final {
+ public:
+  std::shared_ptr<void> coordinator;
+};
+
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropState.mm

@@ -0,0 +1,11 @@
+/*
+ * 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.
+ */
+
+#include "LegacyViewManagerInteropState.h"
+
+namespace facebook::react {
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropViewProps.cpp

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+
+#include "LegacyViewManagerInteropViewProps.h"
+#include <react/renderer/core/DynamicPropsUtilities.h>
+
+namespace facebook::react {
+
+LegacyViewManagerInteropViewProps::LegacyViewManagerInteropViewProps(
+    const PropsParserContext& context,
+    const LegacyViewManagerInteropViewProps& sourceProps,
+    const RawProps& rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      otherProps(mergeDynamicProps(
+          sourceProps.otherProps,
+          (folly::dynamic)rawProps,
+          NullValueStrategy::Override)) {}
+
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropViewProps.h

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#include <folly/dynamic.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <unordered_map>
+
+namespace facebook::react {
+
+class LegacyViewManagerInteropViewProps final : public ViewProps {
+ public:
+  LegacyViewManagerInteropViewProps() = default;
+  LegacyViewManagerInteropViewProps(
+      const PropsParserContext &context,
+      const LegacyViewManagerInteropViewProps &sourceProps,
+      const RawProps &rawProps);
+
+#pragma mark - Props
+
+  const folly::dynamic otherProps;
+};
+
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/RCTLegacyViewManagerInteropCoordinator.h

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModuleDecorator.h>
+#import <UIKit/UIKit.h>
+#include <folly/dynamic.h>
+
+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:(nullable RCTBridge *)bridge
+                          bridgeProxy:(nullable RCTBridgeProxy *)bridgeProxy
+                bridgelessInteropData:(RCTBridgeModuleDecorator *)bridgelessInteropData;
+
+- (UIView *)createPaperViewWithTag:(NSInteger)tag;
+
+- (void)addObserveForTag:(NSInteger)tag usingBlock:(InterceptorBlock)block;
+
+- (void)removeObserveForTag:(NSInteger)tag;
+
+- (void)setProps:(NSDictionary<NSString *, id> *)props forView:(UIView *)view;
+
+- (NSString *)componentViewName;
+
+- (void)handleCommand:(NSString *)commandName
+                 args:(NSArray *)args
+             reactTag:(NSInteger)tag
+            paperView:(UIView *)paperView;
+@end
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/RCTLegacyViewManagerInteropCoordinator.mm

@@ -0,0 +1,222 @@
+/*
+ * 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.
+ */
+
+#include "RCTLegacyViewManagerInteropCoordinator.h"
+#include <React/RCTBridge+Private.h>
+#include <React/RCTBridgeMethod.h>
+#include <React/RCTBridgeProxy.h>
+#include <React/RCTComponentData.h>
+#include <React/RCTEventDispatcherProtocol.h>
+#include <React/RCTModuleData.h>
+#include <React/RCTModuleMethod.h>
+#include <React/RCTUIManager.h>
+#include <React/RCTUIManagerUtils.h>
+#include <React/RCTUtils.h>
+#include <React/RCTViewManager.h>
+#include <folly/json.h>
+#include <objc/runtime.h>
+#include <react/utils/FollyConvert.h>
+
+using namespace facebook::react;
+
+@implementation RCTLegacyViewManagerInteropCoordinator {
+  RCTComponentData *_componentData;
+  __weak RCTBridge *_bridge;
+  __weak RCTBridgeModuleDecorator *_bridgelessInteropData;
+  __weak RCTBridgeProxy *_bridgeProxy;
+
+  /*
+   Each instance of `RCTLegacyViewManagerInteropComponentView` registers a block to which events are dispatched.
+   This is the container that maps unretained UIView pointer to a block to which the event is dispatched.
+   */
+  NSMutableDictionary<NSNumber *, InterceptorBlock> *_eventInterceptors;
+
+  /*
+   * In bridgeless mode, instead of using the bridge to look up RCTModuleData,
+   * store that information locally.
+   */
+  NSMutableArray<id<RCTBridgeMethod>> *_moduleMethods;
+  NSMutableDictionary<NSString *, id<RCTBridgeMethod>> *_moduleMethodsByName;
+}
+
+- (instancetype)initWithComponentData:(RCTComponentData *)componentData
+                               bridge:(nullable RCTBridge *)bridge
+                          bridgeProxy:(nullable RCTBridgeProxy *)bridgeProxy
+                bridgelessInteropData:(RCTBridgeModuleDecorator *)bridgelessInteropData
+{
+  if (self = [super init]) {
+    _componentData = componentData;
+    _bridge = bridge;
+    _bridgelessInteropData = bridgelessInteropData;
+    _bridgeProxy = bridgeProxy;
+
+    if (bridgelessInteropData) {
+      //  During bridge mode, RCTBridgeModules will be decorated with these APIs by the bridge.
+      RCTAssert(
+          _bridge == nil,
+          @"RCTLegacyViewManagerInteropCoordinator should not be initialized with RCTBridgeModuleDecorator in bridge mode.");
+    }
+
+    _eventInterceptors = [NSMutableDictionary new];
+
+    __weak __typeof(self) weakSelf = self;
+    _componentData.eventInterceptor = ^(NSString *eventName, NSDictionary *event, NSNumber *reactTag) {
+      __typeof(self) strongSelf = weakSelf;
+      if (strongSelf) {
+        InterceptorBlock block = [strongSelf->_eventInterceptors objectForKey:reactTag];
+        if (block) {
+          block(
+              std::string([RCTNormalizeInputEventName(eventName) UTF8String]),
+              convertIdToFollyDynamic(event ? event : @{}));
+        }
+      }
+    };
+  }
+  return self;
+}
+
+- (void)addObserveForTag:(NSInteger)tag usingBlock:(InterceptorBlock)block
+{
+  [_eventInterceptors setObject:block forKey:[NSNumber numberWithInteger:tag]];
+}
+
+- (void)removeObserveForTag:(NSInteger)tag
+{
+  [_eventInterceptors removeObjectForKey:[NSNumber numberWithInteger:tag]];
+}
+
+- (UIView *)createPaperViewWithTag:(NSInteger)tag
+{
+  [_bridgelessInteropData attachInteropAPIsToModule:(id<RCTBridgeModule>)_componentData.manager];
+  return [_componentData createViewWithTag:[NSNumber numberWithInteger:tag] rootTag:NULL];
+}
+
+- (void)setProps:(NSDictionary<NSString *, id> *)props forView:(UIView *)view
+{
+  [_componentData setProps:props forView:view];
+
+  if ([view respondsToSelector:@selector(didSetProps:)]) {
+    [view performSelector:@selector(didSetProps:) withObject:[props allKeys]];
+  }
+}
+
+- (NSString *)componentViewName
+{
+  return RCTDropReactPrefixes(_componentData.name);
+}
+
+- (void)handleCommand:(NSString *)commandName
+                 args:(NSArray *)args
+             reactTag:(NSInteger)tag
+            paperView:(nonnull UIView *)paperView
+{
+  Class managerClass = _componentData.managerClass;
+  [self _lookupModuleMethodsIfNecessary];
+  RCTModuleData *moduleData = [_bridge.batchedBridge moduleDataForName:RCTBridgeModuleNameForClass(managerClass)];
+  id<RCTBridgeMethod> method;
+
+  // We can't use `[NSString intValue]` as "0" is a valid command,
+  // but also a falsy value. [NSNumberFormatter numberFromString] returns a
+  // `NSNumber *` which is NULL when it's to be NULL
+  // and it points to 0 when the string is @"0" (not a falsy value).
+  NSNumberFormatter *formatter = [[NSNumberFormatter alloc] init];
+
+  if ([commandName isKindOfClass:[NSNumber class]] || [formatter numberFromString:commandName] != NULL) {
+    method = moduleData ? moduleData.methods[[commandName intValue]] : _moduleMethods[[commandName intValue]];
+  } else if ([commandName isKindOfClass:[NSString class]]) {
+    method = moduleData ? moduleData.methodsByName[commandName] : _moduleMethodsByName[commandName];
+    if (method == nil) {
+      RCTLogError(@"No command found with name \"%@\"", commandName);
+    }
+  } else {
+    RCTLogError(@"dispatchViewManagerCommand must be called with a string or integer command");
+    return;
+  }
+
+  NSArray *newArgs = [@[ [NSNumber numberWithInteger:tag] ] arrayByAddingObjectsFromArray:args];
+
+  if (_bridge) {
+    [self _handleCommandsOnBridge:method withArgs:newArgs];
+  } else {
+    [self _handleCommandsOnBridgeless:method withArgs:newArgs];
+  }
+}
+
+#pragma mark - Private
+- (void)_handleCommandsOnBridge:(id<RCTBridgeMethod>)method withArgs:(NSArray *)newArgs
+{
+  [_bridge.batchedBridge
+      dispatchBlock:^{
+        [method invokeWithBridge:self->_bridge module:self->_componentData.manager arguments:newArgs];
+        [self->_bridge.uiManager setNeedsLayout];
+      }
+              queue:RCTGetUIManagerQueue()];
+}
+
+- (void)_handleCommandsOnBridgeless:(id<RCTBridgeMethod>)method withArgs:(NSArray *)newArgs
+{
+  RCTViewManager *componentViewManager = self->_componentData.manager;
+  [componentViewManager setValue:_bridgeProxy forKey:@"bridge"];
+
+  [self->_bridgeProxy.uiManager
+      addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        [method invokeWithBridge:nil module:componentViewManager arguments:newArgs];
+      }];
+}
+
+- (void)_addUIBlock:(RCTViewManagerUIBlock)block
+{
+  if (_bridge) {
+    [self _addUIBlockOnBridge:block];
+  } else {
+    [self->_bridgeProxy.uiManager addUIBlock:block];
+  }
+}
+
+- (void)_addUIBlockOnBridge:(RCTViewManagerUIBlock)block
+{
+  __weak __typeof__(self) weakSelf = self;
+  [_bridge.batchedBridge
+      dispatchBlock:^{
+        __typeof__(self) strongSelf = weakSelf;
+        [strongSelf->_bridge.uiManager addUIBlock:block];
+      }
+              queue:RCTGetUIManagerQueue()];
+}
+
+// This is copy-pasta from RCTModuleData.
+- (void)_lookupModuleMethodsIfNecessary
+{
+  if (!_bridge && !_moduleMethods) {
+    _moduleMethods = [NSMutableArray new];
+    _moduleMethodsByName = [NSMutableDictionary new];
+
+    unsigned int methodCount;
+    Class cls = _componentData.managerClass;
+    while (cls && cls != [NSObject class] && cls != [NSProxy class]) {
+      Method *methods = class_copyMethodList(object_getClass(cls), &methodCount);
+
+      for (unsigned int i = 0; i < methodCount; i++) {
+        Method method = methods[i];
+        SEL selector = method_getName(method);
+        if ([NSStringFromSelector(selector) hasPrefix:@"__rct_export__"]) {
+          IMP imp = method_getImplementation(method);
+          auto exportedMethod = ((const RCTMethodInfo *(*)(id, SEL))imp)(_componentData.managerClass, selector);
+          id<RCTBridgeMethod> moduleMethod =
+              [[RCTModuleMethod alloc] initWithExportedMethod:exportedMethod moduleClass:_componentData.managerClass];
+          [_moduleMethodsByName setValue:moduleMethod forKey:[NSString stringWithUTF8String:moduleMethod.JSMethodName]];
+          [_moduleMethods addObject:moduleMethod];
+        }
+      }
+
+      free(methods);
+      cls = class_getSuperclass(cls);
+    }
+  }
+}
+
+@end

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticComponentDescriptor.cpp

@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+
+#include "UnstableLegacyViewManagerAutomaticComponentDescriptor.h"
+#include <react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticShadowNode.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <string>
+
+namespace facebook::react {
+ComponentName
+UnstableLegacyViewManagerAutomaticComponentDescriptor::getComponentName()
+    const {
+  return legacyComponentName_.c_str();
+}
+
+ComponentHandle
+UnstableLegacyViewManagerAutomaticComponentDescriptor::getComponentHandle()
+    const {
+  return reinterpret_cast<ComponentHandle>(getComponentName());
+}
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticComponentDescriptor.h

@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticShadowNode.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <string>
+
+namespace facebook::react {
+
+class UnstableLegacyViewManagerAutomaticComponentDescriptor final
+    : public ConcreteComponentDescriptor<LegacyViewManagerAndroidInteropShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  UnstableLegacyViewManagerAutomaticComponentDescriptor(
+      const ComponentDescriptorParameters &parameters,
+      std::string legacyComponentName)
+      : ConcreteComponentDescriptor(parameters), legacyComponentName_(std::move(legacyComponentName))
+  {
+  }
+
+  ComponentHandle getComponentHandle() const override;
+  ComponentName getComponentName() const override;
+
+ private:
+  std::string legacyComponentName_;
+};
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticShadowNode.cpp

@@ -0,0 +1,13 @@
+/*
+ * 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.
+ */
+
+namespace facebook::react {
+
+extern const char LegacyViewManagerAndroidInteropComponentName[] =
+    "LegacyViewManagerInterop";
+
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticShadowNode.h

@@ -0,0 +1,20 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropViewProps.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook::react {
+
+extern const char LegacyViewManagerAndroidInteropComponentName[];
+
+using LegacyViewManagerAndroidInteropShadowNode =
+    ConcreteViewShadowNode<LegacyViewManagerAndroidInteropComponentName, LegacyViewManagerInteropViewProps>;
+
+} // namespace facebook::react

node_modules/react-native/ReactCommon/react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerInteropComponentDescriptor.h

@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+/*
+ * Descriptor for <UnstableReactLegacyComponent> component.
+ *
+ * This component is part of the Fabric Interop Layer and is subject to future
+ * changes (hence the "Unstable" prefix).
+ */
+template <const char *concreteComponentName>
+class UnstableLegacyViewManagerInteropComponentDescriptor
+    : public ConcreteComponentDescriptor<ConcreteViewShadowNode<concreteComponentName, ViewProps>> {
+ public:
+  UnstableLegacyViewManagerInteropComponentDescriptor<concreteComponentName>(
+      const ComponentDescriptorParameters &parameters)
+      : ConcreteComponentDescriptor<ConcreteViewShadowNode<concreteComponentName, ViewProps>>(parameters)
+  {
+  }
+
+ private:
+};
+
+} // namespace facebook::react