react-native 0.74.0-nightly-20240128-cfc0ba04a → 1000.0.0

package/ReactCommon/react/renderer/graphics/platform/android/react/renderer/graphics/PlatformColorParser.h

@@ -8,23 +8,25 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
-#include <react/renderer/core/PropsParserContext.h>
-#include <react/renderer/core/RawProps.h>
+#include <react/debug/react_native_expect.h>
+#include <react/renderer/core/RawValue.h>
 #include <react/renderer/graphics/Color.h>
+#include <react/renderer/graphics/fromRawValueShared.h>
+#include <react/utils/ContextContainer.h>
 #include <unordered_map>
 
 namespace facebook::react {
 
 inline SharedColor parsePlatformColor(
-    const PropsParserContext& context,
+    const ContextContainer& contextContainer,
+    int32_t surfaceId,
     const RawValue& value) {
   ColorComponents colorComponents = {0, 0, 0, 0};
 
   if (value.hasType<
           std::unordered_map<std::string, std::vector<std::string>>>()) {
     const auto& fabricUIManager =
-        context.contextContainer.at<jni::global_ref<jobject>>(
-            "FabricUIManager");
+        contextContainer.at<jni::global_ref<jobject>>("FabricUIManager");
     static auto getColorFromJava =
         fabricUIManager->getClass()
             ->getMethod<jint(jint, jni::JArrayClass<jni::JString>)>("getColor");
@@ -37,8 +39,8 @@ inline SharedColor parsePlatformColor(
     for (int i = 0; i < resourcePaths.size(); i++) {
       javaResourcePaths->setElement(i, *jni::make_jstring(resourcePaths[i]));
     }
-    auto color = getColorFromJava(
-        fabricUIManager, context.surfaceId, *javaResourcePaths);
+    auto color =
+        getColorFromJava(fabricUIManager, surfaceId, *javaResourcePaths);
 
     auto argb = (int64_t)color;
     auto ratio = 255.f;
@@ -51,4 +53,13 @@ inline SharedColor parsePlatformColor(
   return {colorFromComponents(colorComponents)};
 }
 
+inline void fromRawValue(
+    const ContextContainer& contextContainer,
+    int32_t surfaceId,
+    const RawValue& value,
+    SharedColor& result) {
+  fromRawValueShared(
+      contextContainer, surfaceId, value, result, parsePlatformColor);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/graphics/platform/cxx/react/renderer/graphics/PlatformColorParser.h

@@ -7,15 +7,18 @@
 
 #pragma once
 
-#include <react/renderer/core/PropsParserContext.h>
-#include <react/renderer/core/RawProps.h>
+#include <react/debug/react_native_expect.h>
+#include <react/renderer/core/RawValue.h>
 #include <react/renderer/graphics/Color.h>
+#include <react/renderer/graphics/fromRawValueShared.h>
+#include <react/utils/ContextContainer.h>
 
 namespace facebook::react {
 
 inline SharedColor parsePlatformColor(
-    const PropsParserContext& context,
-    const RawValue& value) {
+    const ContextContainer& /*contextContainer*/,
+    int32_t /*surfaceId*/,
+    const RawValue& /*value*/) {
   float alpha = 0;
   float red = 0;
   float green = 0;
@@ -24,4 +27,13 @@ inline SharedColor parsePlatformColor(
   return {colorFromComponents({red, green, blue, alpha})};
 }
 
+inline void fromRawValue(
+    const ContextContainer& contextContainer,
+    int32_t surfaceId,
+    const RawValue& value,
+    SharedColor& result) {
+  fromRawValueShared(
+      contextContainer, surfaceId, value, result, parsePlatformColor);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/HostPlatformColor.h

@@ -8,32 +8,72 @@
 #pragma once
 
 #include <react/renderer/graphics/ColorComponents.h>
+#include <react/utils/hash_combine.h>
 #include <cmath>
 
 namespace facebook::react {
 
-using Color = int32_t;
+struct DynamicColor {
+  int32_t lightColor = 0;
+  int32_t darkColor = 0;
+  int32_t highContrastLightColor = 0;
+  int32_t highContrastDarkColor = 0;
+};
+
+struct Color {
+  Color(int32_t color);
+  Color(const DynamicColor& dynamicColor);
+  Color(const ColorComponents& components);
+  Color(std::shared_ptr<void> uiColor);
+  int32_t getColor() const;
+  std::shared_ptr<void> getUIColor() const {
+    return uiColor_;
+  }
+  ColorComponents getColorComponents() const {
+    float ratio = 255;
+    int32_t primitiveColor = getColor();
+    return ColorComponents{
+        (float)((primitiveColor >> 16) & 0xff) / ratio,
+        (float)((primitiveColor >> 8) & 0xff) / ratio,
+        (float)((primitiveColor >> 0) & 0xff) / ratio,
+        (float)((primitiveColor >> 24) & 0xff) / ratio};
+  }
+  bool operator==(const Color& other) const;
+  bool operator!=(const Color& other) const;
+  operator int32_t() const {
+    return getColor();
+  }
+
+ private:
+  std::shared_ptr<void> uiColor_;
+};
 
 namespace HostPlatformColor {
-static const facebook::react::Color UndefinedColor =
-    std::numeric_limits<facebook::react::Color>::max();
-}
+
+#if defined(__clang__)
+#define NO_DESTROY [[clang::no_destroy]]
+#else
+#define NO_DESTROY
+#endif
+
+NO_DESTROY static const facebook::react::Color UndefinedColor = Color(nullptr);
+} // namespace HostPlatformColor
 
 inline Color hostPlatformColorFromComponents(ColorComponents components) {
-  float ratio = 255;
-  return ((int)round(components.alpha * ratio) & 0xff) << 24 |
-      ((int)round(components.red * ratio) & 0xff) << 16 |
-      ((int)round(components.green * ratio) & 0xff) << 8 |
-      ((int)round(components.blue * ratio) & 0xff);
+  return Color(components);
 }
 
 inline ColorComponents colorComponentsFromHostPlatformColor(Color color) {
-  float ratio = 255;
-  return ColorComponents{
-      (float)((color >> 16) & 0xff) / ratio,
-      (float)((color >> 8) & 0xff) / ratio,
-      (float)((color >> 0) & 0xff) / ratio,
-      (float)((color >> 24) & 0xff) / ratio};
+  return color.getColorComponents();
 }
 
 } // namespace facebook::react
+
+template <>
+struct std::hash<facebook::react::Color> {
+  size_t operator()(const facebook::react::Color& color) const {
+    auto seed = size_t{0};
+    facebook::react::hash_combine(seed, color.getColor());
+    return seed;
+  }
+};

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/HostPlatformColor.mm

@@ -0,0 +1,132 @@
+/*
+ * 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 "HostPlatformColor.h"
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <react/utils/ManagedObjectWrapper.h>
+#import <string>
+
+using namespace facebook::react;
+
+NS_ASSUME_NONNULL_BEGIN
+
+namespace facebook::react {
+
+namespace {
+UIColor *_Nullable UIColorFromInt32(int32_t intColor)
+{
+  CGFloat a = CGFloat((intColor >> 24) & 0xFF) / 255.0;
+  CGFloat r = CGFloat((intColor >> 16) & 0xFF) / 255.0;
+  CGFloat g = CGFloat((intColor >> 8) & 0xFF) / 255.0;
+  CGFloat b = CGFloat(intColor & 0xFF) / 255.0;
+  return [UIColor colorWithRed:r green:g blue:b alpha:a];
+}
+
+UIColor *_Nullable UIColorFromDynamicColor(const facebook::react::DynamicColor &dynamicColor)
+{
+  int32_t light = dynamicColor.lightColor;
+  int32_t dark = dynamicColor.darkColor;
+  int32_t highContrastLight = dynamicColor.highContrastLightColor;
+  int32_t highContrastDark = dynamicColor.highContrastDarkColor;
+
+  UIColor *lightColor = UIColorFromInt32(light);
+  UIColor *darkColor = UIColorFromInt32(dark);
+  UIColor *highContrastLightColor = UIColorFromInt32(highContrastLight);
+  UIColor *highContrastDarkColor = UIColorFromInt32(highContrastDark);
+
+  if (lightColor != nil && darkColor != nil) {
+    UIColor *color = [UIColor colorWithDynamicProvider:^UIColor *_Nonnull(UITraitCollection *_Nonnull collection) {
+      if (collection.userInterfaceStyle == UIUserInterfaceStyleDark) {
+        if (collection.accessibilityContrast == UIAccessibilityContrastHigh && highContrastDarkColor != nil) {
+          return highContrastDarkColor;
+        } else {
+          return darkColor;
+        }
+      } else {
+        if (collection.accessibilityContrast == UIAccessibilityContrastHigh && highContrastLightColor != nil) {
+          return highContrastLightColor;
+        } else {
+          return lightColor;
+        }
+      }
+    }];
+    return color;
+  } else {
+    return nil;
+  }
+
+  return nil;
+}
+
+int32_t ColorFromUIColor(UIColor *color)
+{
+  float ratio = 255;
+  CGFloat rgba[4];
+  [color getRed:&rgba[0] green:&rgba[1] blue:&rgba[2] alpha:&rgba[3]];
+  return ((int32_t)round((float)rgba[3] * ratio) & 0xff) << 24 | ((int)round((float)rgba[0] * ratio) & 0xff) << 16 |
+      ((int)round((float)rgba[1] * ratio) & 0xff) << 8 | ((int)round((float)rgba[2] * ratio) & 0xff);
+}
+
+int32_t ColorFromUIColor(const std::shared_ptr<void> &uiColor)
+{
+  UIColor *color = (UIColor *)unwrapManagedObject(uiColor);
+  if (color) {
+    UITraitCollection *currentTraitCollection = [UITraitCollection currentTraitCollection];
+    color = [color resolvedColorWithTraitCollection:currentTraitCollection];
+    return ColorFromUIColor(color);
+  }
+
+  return 0;
+}
+
+UIColor *_Nullable UIColorFromComponentsColor(const facebook::react::ColorComponents &components)
+{
+  return [UIColor colorWithRed:components.red green:components.green blue:components.blue alpha:components.alpha];
+}
+} // anonymous namespace
+
+Color::Color(int32_t color)
+{
+  uiColor_ = wrapManagedObject(UIColorFromInt32(color));
+}
+
+Color::Color(const DynamicColor &dynamicColor)
+{
+  uiColor_ = wrapManagedObject(UIColorFromDynamicColor(dynamicColor));
+}
+
+Color::Color(const ColorComponents &components)
+{
+  uiColor_ = wrapManagedObject(UIColorFromComponentsColor(components));
+}
+
+Color::Color(std::shared_ptr<void> uiColor)
+{
+  uiColor_ = std::move(uiColor);
+}
+
+bool Color::operator==(const Color &other) const
+{
+  return (!uiColor_ && !other.uiColor_) ||
+      (uiColor_ && other.uiColor_ &&
+       [unwrapManagedObject(getUIColor()) isEqual:unwrapManagedObject(other.getUIColor())]);
+}
+
+bool Color::operator!=(const Color &other) const
+{
+  return !(*this == other);
+}
+
+int32_t Color::getColor() const
+{
+  return ColorFromUIColor(uiColor_);
+}
+} // namespace facebook::react
+
+NS_ASSUME_NONNULL_END

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/PlatformColorParser.h

@@ -7,28 +7,26 @@
 
 #pragma once
 
-#include <react/renderer/core/PropsParserContext.h>
-#include <react/renderer/core/RawProps.h>
+#include <react/debug/react_native_expect.h>
+#include <react/renderer/core/rawValue.h>
 #include <react/renderer/graphics/Color.h>
-#include <react/renderer/graphics/RCTPlatformColorUtils.h>
-#include <unordered_map>
+#include <react/renderer/graphics/fromRawValueShared.h>
+#include <react/utils/ContextContainer.h>
 
 namespace facebook::react {
 
-inline SharedColor parsePlatformColor(
-    const PropsParserContext& context,
-    const RawValue& value) {
-  if (value.hasType<std::unordered_map<std::string, RawValue>>()) {
-    auto items = (std::unordered_map<std::string, RawValue>)value;
-    if (items.find("semantic") != items.end() &&
-        items.at("semantic").hasType<std::vector<std::string>>()) {
-      auto semanticItems = (std::vector<std::string>)items.at("semantic");
-      return {colorFromComponents(
-          RCTPlatformColorComponentsFromSemanticItems(semanticItems))};
-    }
-  }
+SharedColor parsePlatformColor(
+    const ContextContainer& contextContainer,
+    int32_t surfaceId,
+    const RawValue& value);
 
-  return clearColor();
+inline void fromRawValue(
+    const ContextContainer& contextContainer,
+    int32_t surfaceId,
+    const RawValue& value,
+    SharedColor& result) {
+  fromRawValueShared(
+      contextContainer, surfaceId, value, result, parsePlatformColor);
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/PlatformColorParser.mm

@@ -0,0 +1,73 @@
+/*
+ * 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 "PlatformColorParser.h"
+
+#import <react/renderer/core/RawValue.h>
+#import <react/renderer/graphics/HostPlatformColor.h>
+#import <react/renderer/graphics/RCTPlatformColorUtils.h>
+#import <react/utils/ManagedObjectWrapper.h>
+#import <string>
+#import <unordered_map>
+
+using namespace facebook::react;
+
+NS_ASSUME_NONNULL_BEGIN
+
+namespace facebook::react {
+
+inline facebook::react::SharedColor RCTPlatformColorComponentsFromDynamicItems(
+    const facebook::react::ContextContainer &contextContainer,
+    int32_t surfaceId,
+    std::unordered_map<std::string, facebook::react::RawValue> &dynamicItems)
+{
+  SharedColor lightSharedColor{};
+  SharedColor darkSharedColor{};
+  SharedColor highContrastLightSharedColor{};
+  SharedColor highContrastDarkSharedColor{};
+  if (dynamicItems.count("light")) {
+    fromRawValue(contextContainer, surfaceId, dynamicItems.at("light"), lightSharedColor);
+  }
+  if (dynamicItems.count("dark")) {
+    fromRawValue(contextContainer, surfaceId, dynamicItems.at("dark"), darkSharedColor);
+  }
+  if (dynamicItems.count("highContrastLight")) {
+    fromRawValue(contextContainer, surfaceId, dynamicItems.at("highContrastLight"), highContrastLightSharedColor);
+  }
+  if (dynamicItems.count("highContrastDark")) {
+    fromRawValue(contextContainer, surfaceId, dynamicItems.at("highContrastDark"), highContrastDarkSharedColor);
+  }
+
+  Color color = Color(DynamicColor{
+      (*lightSharedColor).getColor(),
+      (*darkSharedColor).getColor(),
+      (*highContrastLightSharedColor).getColor(),
+      (*highContrastDarkSharedColor).getColor()});
+  return SharedColor(color);
+}
+
+SharedColor parsePlatformColor(const ContextContainer &contextContainer, int32_t surfaceId, const RawValue &value)
+{
+  if (value.hasType<std::unordered_map<std::string, RawValue>>()) {
+    auto items = (std::unordered_map<std::string, RawValue>)value;
+    if (items.find("semantic") != items.end() && items.at("semantic").hasType<std::vector<std::string>>()) {
+      auto semanticItems = (std::vector<std::string>)items.at("semantic");
+      return {wrapManagedObject(RCTPlatformColorFromSemanticItems(semanticItems))};
+    } else if (
+        items.find("dynamic") != items.end() &&
+        items.at("dynamic").hasType<std::unordered_map<std::string, RawValue>>()) {
+      auto dynamicItems = (std::unordered_map<std::string, RawValue>)items.at("dynamic");
+      return RCTPlatformColorComponentsFromDynamicItems(contextContainer, surfaceId, dynamicItems);
+    }
+  }
+
+  return clearColor();
+}
+
+} // namespace facebook::react
+
+NS_ASSUME_NONNULL_END

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/RCTPlatformColorUtils.h

@@ -5,8 +5,14 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <react/renderer/graphics/ColorComponents.h>
-#include <vector>
+#pragma once
+
+#import <UIKit/UIKit.h>
+#import <react/renderer/graphics/HostPlatformColor.h>
+#import <vector>
 
 facebook::react::ColorComponents RCTPlatformColorComponentsFromSemanticItems(
     std::vector<std::string>& semanticItems);
+UIColor* RCTPlatformColorFromSemanticItems(
+    std::vector<std::string>& semanticItems);
+UIColor* RCTPlatformColorFromColor(const facebook::react::Color& color);

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/RCTPlatformColorUtils.mm

@@ -9,6 +9,7 @@
 
 #import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
+#import <react/utils/ManagedObjectWrapper.h>
 
 #include <string>
 
@@ -184,20 +185,30 @@ static inline facebook::react::ColorComponents _ColorComponentsFromUIColor(UICol
 }
 
 facebook::react::ColorComponents RCTPlatformColorComponentsFromSemanticItems(std::vector<std::string> &semanticItems)
+{
+  return _ColorComponentsFromUIColor(RCTPlatformColorFromSemanticItems(semanticItems));
+}
+
+UIColor *RCTPlatformColorFromSemanticItems(std::vector<std::string> &semanticItems)
 {
   for (const auto &semanticCString : semanticItems) {
     NSString *semanticNSString = _NSStringFromCString(semanticCString);
     UIColor *uiColor = [UIColor colorNamed:semanticNSString];
     if (uiColor != nil) {
-      return _ColorComponentsFromUIColor(uiColor);
+      return uiColor;
     }
     uiColor = _UIColorFromSemanticString(semanticNSString);
     if (uiColor != nil) {
-      return _ColorComponentsFromUIColor(uiColor);
+      return uiColor;
     }
   }
 
-  return {0, 0, 0, 0};
+  return UIColor.clearColor;
+}
+
+UIColor *RCTPlatformColorFromColor(const facebook::react::Color &color)
+{
+  return (UIColor *)facebook::react::unwrapManagedObject(color.getUIColor());
 }
 
 NS_ASSUME_NONNULL_END

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextPrimitivesConversions.h

@@ -7,6 +7,7 @@
 
 #import <UIKit/UIKit.h>
 
+#include <react/renderer/graphics/RCTPlatformColorUtils.h>
 #include <react/renderer/textlayoutmanager/RCTFontProperties.h>
 #include <react/renderer/textlayoutmanager/RCTFontUtils.h>
 
@@ -94,24 +95,8 @@ inline static NSUnderlineStyle RCTNSUnderlineStyleFromTextDecorationStyle(
   }
 }
 
-inline static UIColor *RCTUIColorFromSharedColor(const facebook::react::SharedColor &sharedColor)
+// TODO: this file has some duplicates method, we can remove it
+inline static UIColor *_Nullable RCTUIColorFromSharedColor(const facebook::react::SharedColor &sharedColor)
 {
-  if (!sharedColor) {
-    return nil;
-  }
-
-  if (*facebook::react::clearColor() == *sharedColor) {
-    return [UIColor clearColor];
-  }
-
-  if (*facebook::react::blackColor() == *sharedColor) {
-    return [UIColor blackColor];
-  }
-
-  if (*facebook::react::whiteColor() == *sharedColor) {
-    return [UIColor whiteColor];
-  }
-
-  auto components = facebook::react::colorComponentsFromColor(sharedColor);
-  return [UIColor colorWithRed:components.red green:components.green blue:components.blue alpha:components.alpha];
+  return RCTPlatformColorFromColor(*sharedColor);
 }

package/ReactCommon/react/runtime/ReactInstance.cpp

@@ -29,12 +29,17 @@ ReactInstance::ReactInstance(
     std::unique_ptr<JSRuntime> runtime,
     std::shared_ptr<MessageQueueThread> jsMessageQueueThread,
     std::shared_ptr<TimerManager> timerManager,
-    JsErrorHandler::JsErrorHandlingFunc jsErrorHandlingFunc)
+    JsErrorHandler::JsErrorHandlingFunc jsErrorHandlingFunc,
+    jsinspector_modern::PageTarget* parentInspectorTarget)
     : runtime_(std::move(runtime)),
       jsMessageQueueThread_(jsMessageQueueThread),
       timerManager_(std::move(timerManager)),
       jsErrorHandler_(jsErrorHandlingFunc),
-      hasFatalJsError_(std::make_shared<bool>(false)) {
+      hasFatalJsError_(std::make_shared<bool>(false)),
+      parentInspectorTarget_(parentInspectorTarget) {
+  if (parentInspectorTarget_) {
+    inspectorTarget_ = &parentInspectorTarget_->registerInstance(*this);
+  }
   auto runtimeExecutor = [weakRuntime = std::weak_ptr<JSRuntime>(runtime_),
                           weakTimerManager =
                               std::weak_ptr<TimerManager>(timerManager_),
@@ -95,6 +100,14 @@ ReactInstance::ReactInstance(
       std::make_shared<BufferedRuntimeExecutor>(pipedRuntimeExecutor);
 }
 
+void ReactInstance::unregisterFromInspector() {
+  if (inspectorTarget_) {
+    assert(parentInspectorTarget_);
+    parentInspectorTarget_->unregisterInstance(*inspectorTarget_);
+    inspectorTarget_ = nullptr;
+  }
+}
+
 RuntimeExecutor ReactInstance::getUnbufferedRuntimeExecutor() noexcept {
   return [runtimeScheduler = runtimeScheduler_.get()](
              std::function<void(jsi::Runtime & runtime)>&& callback) {

package/ReactCommon/react/runtime/ReactInstance.h

@@ -11,6 +11,7 @@
 #include <cxxreact/MessageQueueThread.h>
 #include <jserrorhandler/JsErrorHandler.h>
 #include <jsi/jsi.h>
+#include <jsinspector-modern/ReactCdp.h>
 #include <jsireact/JSIExecutor.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #include <react/runtime/BufferedRuntimeExecutor.h>
@@ -25,7 +26,7 @@ struct CallableModule {
   jsi::Function factory;
 };
 
-class ReactInstance final {
+class ReactInstance final : private jsinspector_modern::InstanceTargetDelegate {
  public:
   using BindingsInstallFunc = std::function<void(jsi::Runtime& runtime)>;
 
@@ -33,7 +34,8 @@ class ReactInstance final {
       std::unique_ptr<JSRuntime> runtime,
       std::shared_ptr<MessageQueueThread> jsMessageQueueThread,
       std::shared_ptr<TimerManager> timerManager,
-      JsErrorHandler::JsErrorHandlingFunc JsErrorHandlingFunc);
+      JsErrorHandler::JsErrorHandlingFunc JsErrorHandlingFunc,
+      jsinspector_modern::PageTarget* parentInspectorTarget = nullptr);
 
   RuntimeExecutor getUnbufferedRuntimeExecutor() noexcept;
 
@@ -63,6 +65,12 @@ class ReactInstance final {
 
   void handleMemoryPressureJs(int pressureLevel);
 
+  /**
+   * Unregisters the instance from the inspector. This method must be called
+   * on the main (non-JS) thread.
+   */
+  void unregisterFromInspector();
+
  private:
   std::shared_ptr<JSRuntime> runtime_;
   std::shared_ptr<MessageQueueThread> jsMessageQueueThread_;
@@ -74,6 +82,9 @@ class ReactInstance final {
 
   // Whether there are errors caught during bundle loading
   std::shared_ptr<bool> hasFatalJsError_;
+
+  jsinspector_modern::InstanceTarget* inspectorTarget_{nullptr};
+  jsinspector_modern::PageTarget* parentInspectorTarget_{nullptr};
 };
 
 } // namespace facebook::react

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTHost.mm

@@ -198,7 +198,8 @@ class RCTHostPageTargetDelegate : public facebook::react::jsinspector_modern::Pa
                                       bundleManager:_bundleManager
                          turboModuleManagerDelegate:_turboModuleManagerDelegate
                                 onInitialBundleLoad:_onInitialBundleLoad
-                                     moduleRegistry:_moduleRegistry];
+                                     moduleRegistry:_moduleRegistry
+                              parentInspectorTarget:_inspectorTarget.get()];
   [_hostDelegate hostDidStart:self];
 }
 
@@ -265,7 +266,8 @@ class RCTHostPageTargetDelegate : public facebook::react::jsinspector_modern::Pa
                                       bundleManager:_bundleManager
                          turboModuleManagerDelegate:_turboModuleManagerDelegate
                                 onInitialBundleLoad:_onInitialBundleLoad
-                                     moduleRegistry:_moduleRegistry];
+                                     moduleRegistry:_moduleRegistry
+                              parentInspectorTarget:_inspectorTarget.get()];
   [_hostDelegate hostDidStart:self];
 
   for (RCTFabricSurface *surface in [self _getAttachedSurfaces]) {
@@ -275,12 +277,12 @@ class RCTHostPageTargetDelegate : public facebook::react::jsinspector_modern::Pa
 
 - (void)dealloc
 {
+  [_instance invalidate];
   if (_inspectorPageId.has_value()) {
     facebook::react::jsinspector_modern::getInspectorInstance().removePage(*_inspectorPageId);
     _inspectorPageId.reset();
     _inspectorTarget.reset();
   }
-  [_instance invalidate];
 }
 
 #pragma mark - RCTInstanceDelegate

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTInstance.h

@@ -8,6 +8,7 @@
 #import <UIKit/UIKit.h>
 
 #import <React/RCTDefines.h>
+#import <jsinspector-modern/ReactCdp.h>
 #import <react/renderer/mapbuffer/MapBuffer.h>
 #import <react/runtime/JSRuntimeFactory.h>
 #import <react/runtime/ReactInstance.h>
@@ -60,7 +61,8 @@ typedef void (^_Null_unspecified RCTInstanceInitialBundleLoadCompletionBlock)();
                    bundleManager:(RCTBundleManager *)bundleManager
       turboModuleManagerDelegate:(id<RCTTurboModuleManagerDelegate>)turboModuleManagerDelegate
              onInitialBundleLoad:(RCTInstanceInitialBundleLoadCompletionBlock)onInitialBundleLoad
-                  moduleRegistry:(RCTModuleRegistry *)moduleRegistry;
+                  moduleRegistry:(RCTModuleRegistry *)moduleRegistry
+           parentInspectorTarget:(facebook::react::jsinspector_modern::PageTarget *)parentInspectorTarget;
 
 - (void)callFunctionOnJSModule:(NSString *)moduleName method:(NSString *)method args:(NSArray *)args;