react-native-tvos 0.78.0-0rc3 → 0.79.0-0

package/ReactCommon/react/renderer/components/view/platform/android/react/renderer/components/view/HostPlatformViewProps.h

@@ -62,6 +62,12 @@ class HostPlatformViewProps : public BaseViewProps {
 #if RN_DEBUG_STRING_CONVERTIBLE
   SharedDebugStringConvertibleList getDebugProps() const override;
 #endif
+
+#ifdef ANDROID
+
+  folly::dynamic getDiffProps(const Props* prevProps) const override;
+
+#endif
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/view/tests/ConversionsTest.cpp

@@ -0,0 +1,239 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include <react/renderer/components/view/BoxShadowPropsConversions.h>
+#include <react/renderer/components/view/FilterPropsConversions.h>
+
+namespace facebook::react {
+
+TEST(ConversionsTest, unprocessed_box_shadow_string) {
+  RawValue value{
+      folly::dynamic("10px 2px 0 5px #fff, inset 20px 10px 5px 0 #000")};
+
+  std::vector<BoxShadow> boxShadows;
+  parseUnprocessedBoxShadow(
+      PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
+
+  EXPECT_EQ(boxShadows.size(), 2);
+  EXPECT_EQ(boxShadows[0].offsetX, 10);
+  EXPECT_EQ(boxShadows[0].offsetY, 2);
+  EXPECT_EQ(boxShadows[0].blurRadius, 0);
+  EXPECT_EQ(boxShadows[0].spreadDistance, 5);
+  EXPECT_EQ(boxShadows[0].color, colorFromRGBA(255, 255, 255, 255));
+  EXPECT_FALSE(boxShadows[0].inset);
+
+  EXPECT_EQ(boxShadows[1].offsetX, 20);
+  EXPECT_EQ(boxShadows[1].offsetY, 10);
+  EXPECT_EQ(boxShadows[1].blurRadius, 5);
+  EXPECT_EQ(boxShadows[1].spreadDistance, 0);
+  EXPECT_EQ(boxShadows[1].color, colorFromRGBA(0, 0, 0, 255));
+  EXPECT_TRUE(boxShadows[1].inset);
+}
+
+TEST(ConversionsTest, unprocessed_box_shadow_objects) {
+  RawValue value{folly::dynamic::array(
+      folly::dynamic::object("offsetX", 10)("offsetY", 2)("blurRadius", 3)(
+          "spreadDistance", 5),
+      folly::dynamic::object("offsetX", 20)("offsetY", 10)("spreadDistance", 2)(
+          "color", "#fff")("inset", true))};
+
+  std::vector<BoxShadow> boxShadows;
+  parseUnprocessedBoxShadow(
+      PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
+
+  EXPECT_EQ(boxShadows.size(), 2);
+  EXPECT_EQ(boxShadows[0].offsetX, 10);
+  EXPECT_EQ(boxShadows[0].offsetY, 2);
+  EXPECT_EQ(boxShadows[0].blurRadius, 3);
+  EXPECT_EQ(boxShadows[0].spreadDistance, 5);
+  EXPECT_EQ(boxShadows[0].color, SharedColor{});
+  EXPECT_FALSE(boxShadows[0].inset);
+
+  EXPECT_EQ(boxShadows[1].offsetX, 20);
+  EXPECT_EQ(boxShadows[1].offsetY, 10);
+  EXPECT_EQ(boxShadows[1].blurRadius, 0);
+  EXPECT_EQ(boxShadows[1].spreadDistance, 2);
+  EXPECT_EQ(boxShadows[1].color, colorFromRGBA(255, 255, 255, 255));
+  EXPECT_TRUE(boxShadows[1].inset);
+}
+
+TEST(ConversionsTest, unprocessed_box_object_invalid_color) {
+  RawValue value{folly::dynamic::array(folly::dynamic::object("offsetX", 10)(
+      "offsetY", 2)("blurRadius", 3)("spreadDistance", 5)("color", "hello"))};
+
+  std::vector<BoxShadow> boxShadows;
+  parseUnprocessedBoxShadow(
+      PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
+
+  EXPECT_TRUE(boxShadows.empty());
+}
+
+TEST(ConversionsTest, unprocessed_box_object_negative_blur) {
+  RawValue value{folly::dynamic::array(folly::dynamic::object("offsetX", 10)(
+      "offsetY", 2)("blurRadius", -3)("spreadDistance", 5))};
+
+  std::vector<BoxShadow> boxShadows;
+  parseUnprocessedBoxShadow(
+      PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
+
+  EXPECT_TRUE(boxShadows.empty());
+}
+
+TEST(ConversionsTest, unprocessed_filter_string) {
+  RawValue value{folly::dynamic(
+      "drop-shadow(10px -2px 0.5px #fff) blur(5px) hue-rotate(90deg) saturate(2) brightness(50%)")};
+
+  std::vector<FilterFunction> filters;
+  parseUnprocessedFilter(
+      PropsParserContext{-1, ContextContainer{}}, value, filters);
+
+  EXPECT_EQ(filters.size(), 5);
+
+  EXPECT_EQ(filters[0].type, FilterType::DropShadow);
+  EXPECT_TRUE(std::holds_alternative<DropShadowParams>(filters[0].parameters));
+  EXPECT_EQ(std::get<DropShadowParams>(filters[0].parameters).offsetX, 10);
+  EXPECT_EQ(std::get<DropShadowParams>(filters[0].parameters).offsetY, -2);
+  EXPECT_EQ(
+      std::get<DropShadowParams>(filters[0].parameters).standardDeviation, 0.5);
+  EXPECT_EQ(
+      std::get<DropShadowParams>(filters[0].parameters).color,
+      colorFromRGBA(255, 255, 255, 255));
+
+  EXPECT_EQ(filters[1].type, FilterType::Blur);
+  EXPECT_TRUE(std::holds_alternative<Float>(filters[1].parameters));
+  EXPECT_EQ(std::get<Float>(filters[1].parameters), 5.0f);
+
+  EXPECT_EQ(filters[2].type, FilterType::HueRotate);
+  EXPECT_TRUE(std::holds_alternative<Float>(filters[2].parameters));
+  EXPECT_EQ(std::get<Float>(filters[2].parameters), 90.0f);
+
+  EXPECT_EQ(filters[3].type, FilterType::Saturate);
+  EXPECT_TRUE(std::holds_alternative<Float>(filters[3].parameters));
+  EXPECT_EQ(std::get<Float>(filters[3].parameters), 2.0f);
+
+  EXPECT_EQ(filters[4].type, FilterType::Brightness);
+  EXPECT_TRUE(std::holds_alternative<Float>(filters[4].parameters));
+  EXPECT_EQ(std::get<Float>(filters[4].parameters), 0.5f);
+}
+
+TEST(ConversionsTest, unprocessed_filter_objects) {
+  RawValue value{folly::dynamic::array(
+      folly::dynamic::object(
+          "drop-shadow",
+          folly::dynamic::object("offsetX", 10)("offsetY", "-2px")(
+              "standardDeviation", 0.5)),
+      folly::dynamic::object("drop-shadow", "2px 0 0.5px #fff"),
+      folly::dynamic::object("blur", 5),
+      folly::dynamic::object("hue-rotate", "90deg"),
+      folly::dynamic::object("saturate", 2),
+      folly::dynamic::object("brightness", "50%"))};
+
+  std::vector<FilterFunction> filters;
+  parseUnprocessedFilter(
+      PropsParserContext{-1, ContextContainer{}}, value, filters);
+
+  EXPECT_EQ(filters.size(), 6);
+
+  EXPECT_EQ(filters[0].type, FilterType::DropShadow);
+  EXPECT_TRUE(std::holds_alternative<DropShadowParams>(filters[0].parameters));
+  EXPECT_EQ(std::get<DropShadowParams>(filters[0].parameters).offsetX, 10);
+  EXPECT_EQ(std::get<DropShadowParams>(filters[0].parameters).offsetY, -2);
+  EXPECT_EQ(
+      std::get<DropShadowParams>(filters[0].parameters).standardDeviation, 0.5);
+  EXPECT_EQ(
+      std::get<DropShadowParams>(filters[0].parameters).color, SharedColor{});
+
+  EXPECT_EQ(filters[1].type, FilterType::DropShadow);
+  EXPECT_TRUE(std::holds_alternative<DropShadowParams>(filters[1].parameters));
+  EXPECT_EQ(std::get<DropShadowParams>(filters[1].parameters).offsetX, 2);
+  EXPECT_EQ(std::get<DropShadowParams>(filters[1].parameters).offsetY, 0);
+  EXPECT_EQ(
+      std::get<DropShadowParams>(filters[1].parameters).standardDeviation, 0.5);
+  EXPECT_EQ(
+      std::get<DropShadowParams>(filters[1].parameters).color,
+      colorFromRGBA(255, 255, 255, 255));
+
+  EXPECT_EQ(filters[2].type, FilterType::Blur);
+  EXPECT_TRUE(std::holds_alternative<Float>(filters[2].parameters));
+  EXPECT_EQ(std::get<Float>(filters[2].parameters), 5.0f);
+
+  EXPECT_EQ(filters[3].type, FilterType::HueRotate);
+  EXPECT_TRUE(std::holds_alternative<Float>(filters[3].parameters));
+  EXPECT_EQ(std::get<Float>(filters[3].parameters), 90.0f);
+
+  EXPECT_EQ(filters[4].type, FilterType::Saturate);
+  EXPECT_TRUE(std::holds_alternative<Float>(filters[4].parameters));
+  EXPECT_EQ(std::get<Float>(filters[4].parameters), 2.0f);
+
+  EXPECT_EQ(filters[5].type, FilterType::Brightness);
+  EXPECT_TRUE(std::holds_alternative<Float>(filters[5].parameters));
+  EXPECT_EQ(std::get<Float>(filters[5].parameters), 0.5f);
+}
+
+TEST(ConversionsTest, unprocessed_filter_objects_negative_shadow_blur) {
+  RawValue value{folly::dynamic::array(folly::dynamic::object(
+      "drop-shadow",
+      folly::dynamic::object("offsetX", 10)("offsetY", "-2px")(
+          "standardDeviation", -0.5)))};
+
+  std::vector<FilterFunction> filters;
+  parseUnprocessedFilter(
+      PropsParserContext{-1, ContextContainer{}}, value, filters);
+
+  EXPECT_TRUE(filters.empty());
+}
+
+TEST(ConversionsTest, unprocessed_filter_objects_negative_blur) {
+  RawValue value{folly::dynamic::array(folly::dynamic::object("blur", -5))};
+
+  std::vector<FilterFunction> filters;
+  parseUnprocessedFilter(
+      PropsParserContext{-1, ContextContainer{}}, value, filters);
+
+  EXPECT_TRUE(filters.empty());
+}
+
+TEST(ConversionsTest, unprocessed_filter_objects_negative_contrast) {
+  RawValue value{
+      folly::dynamic::array(folly::dynamic::object("constrast", -5))};
+
+  std::vector<FilterFunction> filters;
+  parseUnprocessedFilter(
+      PropsParserContext{-1, ContextContainer{}}, value, filters);
+
+  EXPECT_TRUE(filters.empty());
+}
+
+TEST(ConversionsTest, unprocessed_filter_objects_negative_hue_rotate) {
+  RawValue value{
+      folly::dynamic::array(folly::dynamic::object("hue-rotate", -5))};
+
+  std::vector<FilterFunction> filters;
+  parseUnprocessedFilter(
+      PropsParserContext{-1, ContextContainer{}}, value, filters);
+
+  EXPECT_EQ(filters.size(), 1);
+
+  EXPECT_EQ(filters[0].type, FilterType::HueRotate);
+  EXPECT_TRUE(std::holds_alternative<Float>(filters[0].parameters));
+  EXPECT_EQ(std::get<Float>(filters[0].parameters), -5.0f);
+}
+
+TEST(ConversionsTest, unprocessed_filter_objects_multiple_objects) {
+  RawValue value{folly::dynamic::array(
+      folly::dynamic::object("blur", 5)("hue-rotate", "90deg"))};
+
+  std::vector<FilterFunction> filters;
+  parseUnprocessedFilter(
+      PropsParserContext{-1, ContextContainer{}}, value, filters);
+
+  EXPECT_TRUE(filters.empty());
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/consistency/CMakeLists.txt

@@ -14,7 +14,7 @@ add_compile_options(
         -Wpedantic
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB react_render_consistency_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_consistency OBJECT ${react_render_consistency_SRC})
+file(GLOB react_renderer_consistency_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_renderer_consistency OBJECT ${react_renderer_consistency_SRC})
 
-target_include_directories(react_render_consistency PUBLIC ${REACT_COMMON_DIR})
+target_include_directories(react_renderer_consistency PUBLIC ${REACT_COMMON_DIR})

package/ReactCommon/react/renderer/core/CMakeLists.txt

@@ -14,20 +14,20 @@ add_compile_options(
         -Wpedantic
         -DLOG_TAG=\"Fabric\")
 
-file(GLOB react_render_core_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_core OBJECT ${react_render_core_SRC})
+file(GLOB react_renderer_core_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_renderer_core OBJECT ${react_renderer_core_SRC})
 
-target_include_directories(react_render_core PUBLIC ${REACT_COMMON_DIR})
-target_link_libraries(react_render_core
+target_include_directories(react_renderer_core PUBLIC ${REACT_COMMON_DIR})
+target_link_libraries(react_renderer_core
         folly_runtime
         glog
         jsi
         logger
         react_debug
         react_featureflags
-        react_render_debug
-        react_render_graphics
-        react_render_mapbuffer
-        react_render_runtimescheduler
+        react_renderer_debug
+        react_renderer_graphics
+        react_renderer_mapbuffer
+        react_renderer_runtimescheduler
         react_utils
         runtimeexecutor)

package/ReactCommon/react/renderer/core/ConcreteComponentDescriptor.h

@@ -114,11 +114,11 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
 
     rawProps.parse(rawPropsParser_);
 
+    auto shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
     // Use the new-style iterator
     // Note that we just check if `Props` has this flag set, no matter
     // the type of ShadowNode; it acts as the single global flag.
     if (ReactNativeFeatureFlags::enableCppPropsIteratorSetter()) {
-      auto shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
 #ifdef ANDROID
       const auto& dynamic = shadowNodeProps->rawProps;
 #else
@@ -132,11 +132,8 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
             name.c_str(),
             RawValue(pair.second));
       }
-      return shadowNodeProps;
-    } else {
-      // Call old-style constructor
-      return ShadowNodeT::Props(context, rawProps, props);
     }
+    return shadowNodeProps;
   };
 
   virtual State::Shared createInitialState(

package/ReactCommon/react/renderer/core/ConcreteShadowNode.h

@@ -105,6 +105,16 @@ class ConcreteShadowNode : public BaseShadowNodeT {
     return static_cast<const ConcreteProps&>(*props_);
   }
 
+  /*
+   * Returns a concrete props object associated with the node, as a shared_ptr.
+   * Thread-safe after the node is sealed.
+   */
+  const std::shared_ptr<const ConcreteProps>& getConcreteSharedProps() const {
+    react_native_assert(
+        BaseShadowNodeT::props_ && "Props must not be `nullptr`.");
+    return std::static_pointer_cast<const ConcreteProps>(props_);
+  }
+
   /*
    * Returns a concrete event emitter object associated with the node.
    * Thread-safe after the node is sealed.

package/ReactCommon/react/renderer/core/EventBeat.cpp

@@ -37,11 +37,19 @@ void EventBeat::setBeatCallback(BeatCallback beatCallback) {
   beatCallback_ = std::move(beatCallback);
 }
 
+void EventBeat::unstable_setInduceCallback(std::function<void()> callback) {
+  induceCallback_ = std::move(callback);
+}
+
 void EventBeat::induce() const {
   if (!isEventBeatRequested_) {
     return;
   }
 
+  if (induceCallback_) {
+    induceCallback_();
+  }
+
   isEventBeatRequested_ = false;
 
   if (isBeatCallbackScheduled_) {

package/ReactCommon/react/renderer/core/EventBeat.h

@@ -121,6 +121,15 @@ class EventBeat {
    */
   void setBeatCallback(BeatCallback beatCallback);
 
+  /*
+   * The callback will be executed once a consumer (for example EventQueue)
+   * calls either `EventBeat::request` or `EventBeat::requestSynchronous`. The
+   * callback will be executed on the UI thread.
+   *
+   * If not set, this is a no-op and callback won't be called.
+   */
+  void unstable_setInduceCallback(std::function<void()> callback);
+
  protected:
   /*
    * Induces the next beat to happen as soon as possible.
@@ -129,6 +138,7 @@ class EventBeat {
   void induce() const;
 
   BeatCallback beatCallback_;
+  std::function<void()> induceCallback_;
   std::shared_ptr<OwnerBox> ownerBox_;
 
   /*

package/ReactCommon/react/renderer/core/EventDispatcher.cpp

@@ -7,7 +7,6 @@
 
 #include "EventDispatcher.h"
 #include <cxxreact/JSExecutor.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/core/StateUpdate.h>
 
 #include "EventQueue.h"
@@ -43,11 +42,7 @@ void EventDispatcher::experimental_flushSync() const {
 }
 
 void EventDispatcher::dispatchStateUpdate(StateUpdate&& stateUpdate) const {
-  if (ReactNativeFeatureFlags::enableSynchronousStateUpdates()) {
-    statePipe_(stateUpdate);
-  } else {
-    eventQueue_.enqueueStateUpdate(std::move(stateUpdate));
-  }
+  eventQueue_.enqueueStateUpdate(std::move(stateUpdate));
 }
 
 void EventDispatcher::dispatchUniqueEvent(RawEvent&& rawEvent) const {

package/ReactCommon/react/renderer/core/EventQueue.cpp

@@ -7,6 +7,7 @@
 
 #include "EventQueue.h"
 
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include "EventEmitter.h"
 #include "ShadowNodeFamily.h"
 
@@ -19,6 +20,10 @@ EventQueue::EventQueue(
       eventBeat_(std::move(eventBeat)) {
   eventBeat_->setBeatCallback(
       [this](jsi::Runtime& runtime) { onBeat(runtime); });
+
+  if (ReactNativeFeatureFlags::enableSynchronousStateUpdates()) {
+    eventBeat_->unstable_setInduceCallback([this]() { flushStateUpdates(); });
+  }
 }
 
 void EventQueue::enqueueEvent(RawEvent&& rawEvent) const {
@@ -84,7 +89,9 @@ void EventQueue::experimental_flushSync() const {
 }
 
 void EventQueue::onBeat(jsi::Runtime& runtime) const {
-  flushStateUpdates();
+  if (!ReactNativeFeatureFlags::enableSynchronousStateUpdates()) {
+    flushStateUpdates();
+  }
   flushEvents(runtime);
 }
 

package/ReactCommon/react/renderer/core/LayoutMetrics.h

@@ -13,6 +13,7 @@
 #include <react/renderer/graphics/Rect.h>
 #include <react/renderer/graphics/RectangleEdges.h>
 #include <react/utils/hash_combine.h>
+#include <algorithm>
 
 namespace facebook::react {
 
@@ -55,6 +56,21 @@ struct LayoutMetrics {
             frame.size.height - contentInsets.top - contentInsets.bottom}};
   }
 
+  // Calculates the frame of the node including overflow insets.
+  // If the frame was drawn on screen, it would include all the children of the
+  // node (and their children, recursively).
+  Rect getOverflowInsetFrame() const {
+    return Rect{
+        Point{
+            frame.origin.x + std::min(Float{0}, overflowInset.left),
+            frame.origin.y + std::min(Float{0}, overflowInset.top)},
+        Size{
+            frame.size.width - std::min(Float{0}, overflowInset.left) +
+                -std::min(Float{0}, overflowInset.right),
+            frame.size.height - std::min(Float{0}, overflowInset.top) +
+                -std::min(Float{0}, overflowInset.bottom)}};
+  }
+
   // Origin: the outer border of the node.
   // Size: includes content and padding (but no borders).
   Rect getPaddingFrame() const {

package/ReactCommon/react/renderer/core/LayoutableShadowNode.cpp

@@ -261,15 +261,22 @@ ShadowNode::Shared LayoutableShadowNode::findNodeAtPoint(
     return nullptr;
   }
 
+  auto layoutMetrics = layoutableShadowNode->getLayoutMetrics();
   auto transform = layoutableShadowNode->getTransform();
-  auto frame = layoutableShadowNode->getLayoutMetrics().frame;
-  auto transformedFrame = frame * transform;
+  auto transformedFrame = layoutMetrics.frame * transform;
   auto isPointInside = transformedFrame.containsPoint(point);
 
-  if (!isPointInside) {
-    return nullptr;
-  } else if (!layoutableShadowNode->canChildrenBeTouchTarget()) {
+  if (isPointInside && !layoutableShadowNode->canChildrenBeTouchTarget()) {
     return node;
+  } else if (!isPointInside) {
+    auto overflowFrame =
+        insetBy(layoutMetrics.frame, layoutMetrics.overflowInset);
+    auto transformedOverflowFrame = overflowFrame * transform;
+    // If child overflows parent, the touch may be intercepted by the child
+    // only, so we should continue recursing.
+    if (!transformedOverflowFrame.containsPoint(point)) {
+      return nullptr;
+    }
   }
 
   if (Transform::isVerticalInversion(transform) ||

package/ReactCommon/react/renderer/core/Props.cpp

@@ -10,6 +10,7 @@
 #include <react/renderer/core/propsConversions.h>
 
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/renderer/debug/debugStringConvertibleUtils.h>
 #include "DynamicPropsUtilities.h"
 
 namespace facebook::react {
@@ -56,4 +57,12 @@ void Props::setProp(
   }
 }
 
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList Props::getDebugProps() const {
+  return {debugStringConvertibleItem("nativeID", nativeId)};
+}
+#endif
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/Props.h

@@ -35,7 +35,12 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
       const RawProps& rawProps,
       const std::function<bool(const std::string&)>& filterObjectKeys =
           nullptr);
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+  virtual ~Props() override = default;
+#else
   virtual ~Props() = default;
+#endif
 
   Props(const Props& other) = delete;
   Props& operator=(const Props& other) = delete;
@@ -65,6 +70,14 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
     return folly::dynamic::object();
   }
 
+#endif
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+
+#pragma mark - DebugStringConvertible (Partial)
+
+  SharedDebugStringConvertibleList getDebugProps() const override;
+
 #endif
 
  protected:

package/ReactCommon/react/renderer/core/RawProps.cpp

@@ -104,10 +104,6 @@ inline bool isYogaStyleProp(const std::string& prop) {
 }
 } // namespace
 
-RawProps::RawProps() {
-  mode_ = Mode::Empty;
-}
-
 /*
  * Creates an object with given `runtime` and `value`.
  */
@@ -149,18 +145,6 @@ RawProps::RawProps(const RawProps& other) noexcept {
   ignoreYogaStyleProps_ = other.ignoreYogaStyleProps_;
 }
 
-RawProps& RawProps::operator=(const RawProps& other) noexcept {
-  mode_ = other.mode_;
-  if (mode_ == Mode::JSI) {
-    runtime_ = other.runtime_;
-    value_ = jsi::Value(*runtime_, other.value_);
-  } else if (mode_ == Mode::Dynamic) {
-    dynamic_ = other.dynamic_;
-  }
-  ignoreYogaStyleProps_ = other.ignoreYogaStyleProps_;
-  return *this;
-}
-
 void RawProps::parse(const RawPropsParser& parser) noexcept {
   react_native_assert(parser_ == nullptr && "A parser was already assigned.");
   parser_ = &parser;

package/ReactCommon/react/renderer/core/RawProps.h

@@ -43,7 +43,7 @@ class RawProps final {
   /*
    * Creates empty RawProps objects.
    */
-  RawProps();
+  RawProps() : mode_(Mode::Empty) {}
 
   /*
    * Creates an object with given `runtime` and `value`.
@@ -51,10 +51,10 @@ class RawProps final {
   RawProps(jsi::Runtime& runtime, const jsi::Value& value) noexcept;
 
   explicit RawProps(const RawProps& rawProps) noexcept;
-  RawProps& operator=(const RawProps& other) noexcept;
-
   RawProps(RawProps&& other) noexcept = default;
-  RawProps& operator=(RawProps&& other) noexcept = default;
+
+  RawProps& operator=(const RawProps& other) noexcept = delete;
+  RawProps& operator=(RawProps&& other) noexcept = delete;
 
   /*
    * Creates an object with given `folly::dynamic` object.
@@ -112,8 +112,9 @@ class RawProps final {
   /*
    * Source artefacts:
    */
+
   // Mode
-  mutable Mode mode_;
+  Mode mode_;
 
   // Case 1: Source data is represented as `jsi::Object`.
   jsi::Runtime* runtime_{};

package/ReactCommon/react/renderer/core/ShadowNode.cpp

@@ -322,8 +322,7 @@ void ShadowNode::transferRuntimeShadowNodeReference(
     const Shared& destinationShadowNode,
     const ShadowNodeFragment& fragment) const {
   if (useRuntimeShadowNodeReferenceUpdateOnThread &&
-      fragment.runtimeShadowNodeReference &&
-      ReactNativeFeatureFlags::useRuntimeShadowNodeReferenceUpdate()) {
+      fragment.runtimeShadowNodeReference) {
     transferRuntimeShadowNodeReference(destinationShadowNode);
   }
 }

package/ReactCommon/react/renderer/core/ShadowNodeFamily.cpp

@@ -31,9 +31,7 @@ ShadowNodeFamily::ShadowNodeFamily(
       eventEmitter_(std::move(eventEmitter)),
       componentDescriptor_(componentDescriptor),
       componentHandle_(componentDescriptor.getComponentHandle()),
-      componentName_(componentDescriptor.getComponentName()),
-      isDeletionOfUnmountedViewsEnabled_(
-          ReactNativeFeatureFlags::enableDeletionOfUnmountedViews()) {}
+      componentName_(componentDescriptor.getComponentName()) {}
 
 void ShadowNodeFamily::setParent(const ShadowNodeFamily::Shared& parent) const {
   react_native_assert(parent_.lock() == nullptr || parent_.lock() == parent);
@@ -78,9 +76,17 @@ Tag ShadowNodeFamily::getTag() const {
   return tag_;
 }
 
+InstanceHandle::Shared ShadowNodeFamily::getInstanceHandle() const {
+  return instanceHandle_;
+}
+
+void ShadowNodeFamily::setInstanceHandle(
+    InstanceHandle::Shared& instanceHandle) const {
+  instanceHandle_ = instanceHandle;
+}
+
 ShadowNodeFamily::~ShadowNodeFamily() {
-  if (isDeletionOfUnmountedViewsEnabled_ && !hasBeenMounted_ &&
-      onUnmountedFamilyDestroyedCallback_ != nullptr) {
+  if (!hasBeenMounted_ && onUnmountedFamilyDestroyedCallback_ != nullptr) {
     onUnmountedFamilyDestroyedCallback_(*this);
   }
 }