react-native 0.68.1 → 0.69.0-rc.0

package/ReactCommon/react/renderer/components/view/propsConversions.h

@@ -11,6 +11,8 @@
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/propsConversions.h>
 
+#include <optional>
+
 namespace facebook {
 namespace react {
 
@@ -463,5 +465,194 @@ static inline CascadedRectangleEdges<T> convertRawProp(
   return result;
 }
 
+static inline ViewEvents convertRawProp(
+    const PropsParserContext &context,
+    RawProps const &rawProps,
+    ViewEvents const &sourceValue,
+    ViewEvents const &defaultValue) {
+  ViewEvents result{};
+  using Offset = ViewEvents::Offset;
+
+  result[Offset::PointerEnter] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerEnter",
+      sourceValue[Offset::PointerEnter],
+      defaultValue[Offset::PointerEnter]);
+  result[Offset::PointerMove] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerMove",
+      sourceValue[Offset::PointerMove],
+      defaultValue[Offset::PointerMove]);
+  result[Offset::PointerLeave] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerLeave",
+      sourceValue[Offset::PointerLeave],
+      defaultValue[Offset::PointerLeave]);
+
+  // PanResponder callbacks
+  result[Offset::MoveShouldSetResponder] = convertRawProp(
+      context,
+      rawProps,
+      "onMoveShouldSetResponder",
+      sourceValue[Offset::MoveShouldSetResponder],
+      defaultValue[Offset::MoveShouldSetResponder]);
+  result[Offset::MoveShouldSetResponderCapture] = convertRawProp(
+      context,
+      rawProps,
+      "onMoveShouldSetResponderCapture",
+      sourceValue[Offset::MoveShouldSetResponderCapture],
+      defaultValue[Offset::MoveShouldSetResponderCapture]);
+  result[Offset::StartShouldSetResponder] = convertRawProp(
+      context,
+      rawProps,
+      "onStartShouldSetResponder",
+      sourceValue[Offset::StartShouldSetResponder],
+      defaultValue[Offset::StartShouldSetResponder]);
+  result[Offset::StartShouldSetResponderCapture] = convertRawProp(
+      context,
+      rawProps,
+      "onStartShouldSetResponderCapture",
+      sourceValue[Offset::StartShouldSetResponderCapture],
+      defaultValue[Offset::StartShouldSetResponderCapture]);
+  result[Offset::ResponderGrant] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderGrant",
+      sourceValue[Offset::ResponderGrant],
+      defaultValue[Offset::ResponderGrant]);
+  result[Offset::ResponderReject] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderReject",
+      sourceValue[Offset::ResponderReject],
+      defaultValue[Offset::ResponderReject]);
+  result[Offset::ResponderStart] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderStart",
+      sourceValue[Offset::ResponderStart],
+      defaultValue[Offset::ResponderStart]);
+  result[Offset::ResponderEnd] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderEnd",
+      sourceValue[Offset::ResponderEnd],
+      defaultValue[Offset::ResponderEnd]);
+  result[Offset::ResponderRelease] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderRelease",
+      sourceValue[Offset::ResponderRelease],
+      defaultValue[Offset::ResponderRelease]);
+  result[Offset::ResponderMove] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderMove",
+      sourceValue[Offset::ResponderMove],
+      defaultValue[Offset::ResponderMove]);
+  result[Offset::ResponderTerminate] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderTerminate",
+      sourceValue[Offset::ResponderTerminate],
+      defaultValue[Offset::ResponderTerminate]);
+  result[Offset::ResponderTerminationRequest] = convertRawProp(
+      context,
+      rawProps,
+      "onResponderTerminationRequest",
+      sourceValue[Offset::ResponderTerminationRequest],
+      defaultValue[Offset::ResponderTerminationRequest]);
+  result[Offset::ShouldBlockNativeResponder] = convertRawProp(
+      context,
+      rawProps,
+      "onShouldBlockNativeResponder",
+      sourceValue[Offset::ShouldBlockNativeResponder],
+      defaultValue[Offset::ShouldBlockNativeResponder]);
+
+  // Touch events
+  result[Offset::TouchStart] = convertRawProp(
+      context,
+      rawProps,
+      "onTouchStart",
+      sourceValue[Offset::TouchStart],
+      defaultValue[Offset::TouchStart]);
+  result[Offset::TouchMove] = convertRawProp(
+      context,
+      rawProps,
+      "onTouchMove",
+      sourceValue[Offset::TouchMove],
+      defaultValue[Offset::TouchMove]);
+  result[Offset::TouchEnd] = convertRawProp(
+      context,
+      rawProps,
+      "onTouchEnd",
+      sourceValue[Offset::TouchEnd],
+      defaultValue[Offset::TouchEnd]);
+  result[Offset::TouchCancel] = convertRawProp(
+      context,
+      rawProps,
+      "onTouchCancel",
+      sourceValue[Offset::TouchCancel],
+      defaultValue[Offset::TouchCancel]);
+
+  return result;
+}
+
+#ifdef ANDROID
+
+static inline void fromRawValue(
+    const PropsParserContext &context,
+    RawValue const &rawValue,
+    NativeDrawable &result) {
+  auto map = (butter::map<std::string, RawValue>)rawValue;
+
+  auto typeIterator = map.find("type");
+  react_native_assert(
+      typeIterator != map.end() && typeIterator->second.hasType<std::string>());
+  std::string type = (std::string)typeIterator->second;
+
+  if (type == "ThemeAttrAndroid") {
+    auto attrIterator = map.find("attribute");
+    react_native_assert(
+        attrIterator != map.end() &&
+        attrIterator->second.hasType<std::string>());
+
+    result = NativeDrawable{
+        .kind = NativeDrawable::Kind::ThemeAttr,
+        .themeAttr = (std::string)attrIterator->second,
+    };
+  } else if (type == "RippleAndroid") {
+    auto color = map.find("color");
+    auto borderless = map.find("borderless");
+    auto rippleRadius = map.find("rippleRadius");
+
+    result = NativeDrawable{
+        .kind = NativeDrawable::Kind::Ripple,
+        .ripple =
+            NativeDrawable::Ripple{
+                .color = color != map.end() && color->second.hasType<int32_t>()
+                    ? (int32_t)color->second
+                    : std::optional<int32_t>{},
+                .borderless = borderless != map.end() &&
+                        borderless->second.hasType<bool>()
+                    ? (bool)borderless->second
+                    : false,
+                .rippleRadius = rippleRadius != map.end() &&
+                        rippleRadius->second.hasType<Float>()
+                    ? (Float)rippleRadius->second
+                    : std::optional<Float>{},
+            },
+    };
+  } else {
+    LOG(ERROR) << "Unknown native drawable type: " << type;
+    react_native_assert(false);
+  }
+}
+
+#endif
+
 } // namespace react
 } // namespace facebook

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

@@ -17,6 +17,9 @@
 namespace facebook {
 namespace react {
 
+// Note: the (x, y) origin is always relative to the parent node. You may use
+// P482342650 to re-create this test case in playground.
+
 //  *******************************************************┌─ABCD:────┐****
 //  *******************************************************│ {70,-50} │****
 //  *******************************************************│ {30,60}  │****
@@ -43,6 +46,8 @@ namespace react {
 //  ***********************│          │************************************
 //  ***********************└──────────┘************************************
 
+enum TestCase { AS_IS, CLIPPING, TRANSFORM_SCALE, TRANSFORM_TRANSLATE };
+
 class LayoutTest : public ::testing::Test {
  protected:
   ComponentBuilder builder_;
@@ -55,7 +60,7 @@ class LayoutTest : public ::testing::Test {
 
   LayoutTest() : builder_(simpleComponentBuilder()) {}
 
-  void initialize(bool enforceClippingForABC) {
+  void initialize(TestCase testCase) {
     // clang-format off
     auto element =
         Element<RootShadowNode>()
@@ -73,8 +78,9 @@ class LayoutTest : public ::testing::Test {
           .children({
             Element<ViewShadowNode>()
               .reference(viewShadowNodeA_)
+              .tag(2)
               .props([] {
-                auto sharedProps = std::make_shared<ViewProps>();
+                auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                 auto &props = *sharedProps;
                 auto &yogaStyle = props.yogaStyle;
                 yogaStyle.positionType() = YGPositionTypeAbsolute;
@@ -85,8 +91,9 @@ class LayoutTest : public ::testing::Test {
               .children({
                 Element<ViewShadowNode>()
                   .reference(viewShadowNodeAB_)
-                  .props([] {
-                    auto sharedProps = std::make_shared<ViewProps>();
+                  .tag(3)
+                  .props([=] {
+                    auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                     auto &props = *sharedProps;
                     auto &yogaStyle = props.yogaStyle;
                     yogaStyle.positionType() = YGPositionTypeAbsolute;
@@ -94,17 +101,26 @@ class LayoutTest : public ::testing::Test {
                     yogaStyle.position()[YGEdgeTop] = YGValue{10, YGUnitPoint};
                     yogaStyle.dimensions()[YGDimensionWidth] = YGValue{30, YGUnitPoint};
                     yogaStyle.dimensions()[YGDimensionHeight] = YGValue{90, YGUnitPoint};
+
+                    if (testCase == TRANSFORM_SCALE) {
+                      props.transform = props.transform * Transform::Scale(2, 2, 1);
+                    }
+
+                    if (testCase == TRANSFORM_TRANSLATE) {
+                      props.transform = props.transform * Transform::Translate(10, 10, 0);
+                    }
                     return sharedProps;
                   })
                   .children({
                     Element<ViewShadowNode>()
                       .reference(viewShadowNodeABC_)
+                      .tag(4)
                       .props([=] {
-                        auto sharedProps = std::make_shared<ViewProps>();
+                        auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                         auto &props = *sharedProps;
                         auto &yogaStyle = props.yogaStyle;
 
-                        if (enforceClippingForABC) {
+                        if (testCase == CLIPPING) {
                           yogaStyle.overflow() = YGOverflowHidden;
                         }
 
@@ -118,8 +134,9 @@ class LayoutTest : public ::testing::Test {
                       .children({
                         Element<ViewShadowNode>()
                           .reference(viewShadowNodeABCD_)
+                          .tag(5)
                           .props([] {
-                            auto sharedProps = std::make_shared<ViewProps>();
+                            auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                             auto &props = *sharedProps;
                             auto &yogaStyle = props.yogaStyle;
                             yogaStyle.positionType() = YGPositionTypeAbsolute;
@@ -132,8 +149,9 @@ class LayoutTest : public ::testing::Test {
                       }),
                     Element<ViewShadowNode>()
                       .reference(viewShadowNodeABE_)
+                      .tag(6)
                       .props([] {
-                        auto sharedProps = std::make_shared<ViewProps>();
+                        auto sharedProps = std::make_shared<ViewShadowNodeProps>();
                         auto &props = *sharedProps;
                         auto &yogaStyle = props.yogaStyle;
                         yogaStyle.positionType() = YGPositionTypeAbsolute;
@@ -154,32 +172,191 @@ class LayoutTest : public ::testing::Test {
   }
 };
 
+// Test the layout as described above with no extra changes
 TEST_F(LayoutTest, overflowInsetTest) {
-  initialize(false);
+  initialize(AS_IS);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
 
-  auto layoutMetrics = viewShadowNodeA_->getLayoutMetrics();
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
 
-  EXPECT_EQ(layoutMetrics.frame.size.width, 50);
-  EXPECT_EQ(layoutMetrics.frame.size.height, 50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, -30);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -80);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -50);
 
-  EXPECT_EQ(layoutMetrics.overflowInset.left, -50);
-  EXPECT_EQ(layoutMetrics.overflowInset.top, -30);
-  EXPECT_EQ(layoutMetrics.overflowInset.right, -80);
-  EXPECT_EQ(layoutMetrics.overflowInset.bottom, -50);
+  auto layoutMetricsABC = viewShadowNodeABC_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsABC.frame.size.width, 110);
+  EXPECT_EQ(layoutMetricsABC.frame.size.height, 20);
+
+  EXPECT_EQ(layoutMetricsABC.overflowInset.left, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.top, -50);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.right, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.bottom, 0);
 }
 
+// Test when box ABC has clipping (aka overflow hidden)
 TEST_F(LayoutTest, overflowInsetWithClippingTest) {
-  initialize(true);
+  initialize(CLIPPING);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
+
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, 0);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -80);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -50);
+
+  auto layoutMetricsABC = viewShadowNodeABC_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsABC.frame.size.width, 110);
+  EXPECT_EQ(layoutMetricsABC.frame.size.height, 20);
+
+  EXPECT_EQ(layoutMetricsABC.overflowInset.left, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.top, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.right, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.bottom, 0);
+}
+
+// Test when box AB translate (10, 10, 0) in transform. The parent node's
+// overflowInset will be affected, but the transformed node and its child nodes
+// are not affected. Here is an example:
+//
+//      ┌────────────────┐                  ┌────────────────┐
+//      │Original Layout │                  │  Translate AB  │
+//      └────────────────┘                  └────────────────┘
+//                                                          ─────▶
+// ┌ ─ ─ ─ ┬──────────┐─ ─ ─ ─ ┐      ┌ ─ ─ ─ ┬──────────┐─ ─ ─ ─ ─ ┐
+//         │ A        │                       │ A        │
+// │       │          │        │      │       │          │          │
+//  ─ ─ ─ ─│─ ─ ─┌───┐┼ ─ ─ ─ ─               │          │
+// │       │     │AB ││        │      │ ┌ ─ ─ ┼ ─ ─ ─ ┬──┴┬ ─ ─ ─ ─ ┤
+//         └─────┤   ├┘                       └───────┤AB │
+// │             │┌──┴─────────┤      │ │             │   │         │
+//               ││ABC         │                      │┌──┴─────────┐
+// │             │└──┬─────────┤    │ │ │             ││ABC         │
+// ┌───ABD───────┴─┐ │              │                 │└──┬─────────┘
+// ├─────────────┬─┘ │         │    │ │ ├───ABD───────┴─┐ │         │
+//  ─ ─ ─ ─ ─ ─ ─└───┘─ ─ ─ ─ ─     ▼   └─────────────┬─┘ │
+//                                    └ ┴ ─ ─ ─ ─ ─ ─ ┴───┴ ─ ─ ─ ─ ┘
+
+TEST_F(LayoutTest, overflowInsetTransformTranslateTest) {
+  initialize(TRANSFORM_TRANSLATE);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
+
+  // Change on parent node
+  // The top/left values are NOT changing as overflowInset is union of before
+  // and after transform layout. In this case, we move to the right and bottom,
+  // so the left and top is not changing, while right and bottom values are
+  // increased.
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, -30);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -90);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -60);
+
+  auto layoutMetricsAB = viewShadowNodeAB_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsAB.frame.size.width, 30);
+  EXPECT_EQ(layoutMetricsAB.frame.size.height, 90);
+
+  // No change on self node with translate transform
+  EXPECT_EQ(layoutMetricsAB.overflowInset.left, -60);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.top, -40);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.right, -90);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.bottom, 0);
+
+  auto layoutMetricsABC = viewShadowNodeABC_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsABC.frame.size.width, 110);
+  EXPECT_EQ(layoutMetricsABC.frame.size.height, 20);
+
+  // No change on child node
+  EXPECT_EQ(layoutMetricsABC.overflowInset.left, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.top, -50);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.right, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.bottom, 0);
+}
+
+// Test when box AB scaled 2X in transform. The parent node's overflowInset will
+// be affected. However, the transformed node and its child nodes only appears
+// to be affected (dashed arrow). Since all transform is cosmetic only, the
+// actual values are NOT changed. It will be converted later when mapping the
+// values to pixels during rendering. Here is an example:
+//
+//      ┌────────────────┐                    ┌────────────────┐
+//      │Original Layout │                    │    Scale AB    │
+//      └────────────────┘                    └────────────────┘
+//                                                             ─────▶
+// ┌ ─ ─ ─ ┬──────────┐─ ─ ─ ─ ┐     ┌ ─ ─ ─ ─ ─ ┬──────────┐─ ─ ─ ─ ─ ┐
+//         │ A        │                          │ A        │
+// │       │          │        │     ├ ─ ─ ─ ─ ─ ┼ ─ ─┌─────┤─ ─ ─ ─ ─ ┤
+//  ─ ─ ─ ─│─ ─ ─┌───┐┼ ─ ─ ─ ─                  │    │AB   │  ─ ─ ─▶
+// │       │     │AB ││        │     │           │    │     │          │
+//         └─────┤   ├┘                          └────┤     │
+// │             │┌──┴─────────┤     │                │ ┌───┴──────────┤
+//               ││ABC         │                      │ │ABC           │
+// │             │└──┬─────────┤   │ │                │ │              │
+// ┌───ABD───────┴─┐ │             │                  │ └───┬──────────┘
+// ├─────────────┬─┘ │         │   │ ├────────────────┴──┐  │          │
+//  ─ ─ ─ ─ ─ ─ ─└───┘─ ─ ─ ─ ─    ▼ │      ABD          │  │
+//                                   ├────────────────┬──┘  │          │
+//                                    ─ ─ ─ ─ ─ ─ ─ ─ ┴─────┴ ─ ─ ─ ─ ─
+
+TEST_F(LayoutTest, overflowInsetTransformScaleTest) {
+  initialize(TRANSFORM_SCALE);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
+
+  // Change on parent node when a child view scale up
+  // Note that AB scale up from its center point. The numbers are calculated
+  // assuming AB's center point is not moving.
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -125);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, -115);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -185);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -95);
+
+  auto layoutMetricsAB = viewShadowNodeAB_->getLayoutMetrics();
+
+  // The frame of box AB won't actually scale up. The transform matrix is
+  // purely cosmetic and should apply later in mounting phase.
+  EXPECT_EQ(layoutMetricsAB.frame.size.width, 30);
+  EXPECT_EQ(layoutMetricsAB.frame.size.height, 90);
+
+  // No change on self node with scale transform. This may sound a bit
+  // surprising, but the overflowInset values will be scaled up via pixel
+  // density ratio along with width/height of the view. When we do hit-testing,
+  // the overflowInset value will appears to be doubled as expected.
+  EXPECT_EQ(layoutMetricsAB.overflowInset.left, -60);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.top, -40);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.right, -90);
+  EXPECT_EQ(layoutMetricsAB.overflowInset.bottom, 0);
 
-  auto layoutMetrics = viewShadowNodeA_->getLayoutMetrics();
+  auto layoutMetricsABC = viewShadowNodeABC_->getLayoutMetrics();
 
-  EXPECT_EQ(layoutMetrics.frame.size.width, 50);
-  EXPECT_EQ(layoutMetrics.frame.size.height, 50);
+  // The frame of box ABC won't actually scale up. The transform matrix is
+  // purely cosmatic and should apply later in mounting phase.
+  EXPECT_EQ(layoutMetricsABC.frame.size.width, 110);
+  EXPECT_EQ(layoutMetricsABC.frame.size.height, 20);
 
-  EXPECT_EQ(layoutMetrics.overflowInset.left, -50);
-  EXPECT_EQ(layoutMetrics.overflowInset.top, 0);
-  EXPECT_EQ(layoutMetrics.overflowInset.right, -80);
-  EXPECT_EQ(layoutMetrics.overflowInset.bottom, -50);
+  // The overflowInset of ABC won't change either. This may sound a bit
+  // surprising, but the overflowInset values will be scaled up via pixel
+  // density ratio along with width/height of the view. When we do hit-testing,
+  // the overflowInset value will appears to be doubled as expected.
+  EXPECT_EQ(layoutMetricsABC.overflowInset.left, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.top, -50);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.right, 0);
+  EXPECT_EQ(layoutMetricsABC.overflowInset.bottom, 0);
 }
 
 } // namespace react

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

@@ -49,7 +49,7 @@ class YogaDirtyFlagTest : public ::testing::Test {
                     /*
                      * Some non-default props.
                      */
-                    auto mutableViewProps = std::make_shared<ViewProps>();
+                    auto mutableViewProps = std::make_shared<ViewShadowNodeProps>();
                     auto &props = *mutableViewProps;
                     props.nativeId = "native Id";
                     props.opacity = 0.5;
@@ -111,7 +111,7 @@ TEST_F(YogaDirtyFlagTest, changingNonLayoutSubPropsMustNotDirtyYogaNode) {
    */
   auto newRootShadowNode = rootShadowNode_->cloneTree(
       innerShadowNode_->getFamily(), [](ShadowNode const &oldShadowNode) {
-        auto viewProps = std::make_shared<ViewProps>();
+        auto viewProps = std::make_shared<ViewShadowNodeProps>();
         auto &props = *viewProps;
 
         props.nativeId = "some new native Id";
@@ -135,7 +135,7 @@ TEST_F(YogaDirtyFlagTest, changingLayoutSubPropsMustDirtyYogaNode) {
    */
   auto newRootShadowNode = rootShadowNode_->cloneTree(
       innerShadowNode_->getFamily(), [](ShadowNode const &oldShadowNode) {
-        auto viewProps = std::make_shared<ViewProps>();
+        auto viewProps = std::make_shared<ViewShadowNodeProps>();
         auto &props = *viewProps;
 
         props.yogaStyle.alignContent() = YGAlignBaseline;

package/ReactCommon/react/renderer/core/Android.mk

@@ -16,8 +16,7 @@ LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp)
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../../
 
 LOCAL_SHARED_LIBRARIES := \
-  libfolly_futures \
-  libfolly_json \
+  libfolly_runtime \
   libglog \
   libjsi \
   libreact_debug \

package/ReactCommon/react/renderer/core/BUCK

@@ -32,12 +32,13 @@ rn_xplat_cxx_library(
         ],
         prefix = "react/renderer/core",
     ),
-    compiler_flags_enable_exceptions = False,
-    compiler_flags_enable_rtti = False,  # Needed for DebugStringConvertible - need to find a non-RTTI way to do this / enable RTTI for debug builds only. Also EventBeat/AsyncEventBeat
     fbobjc_compiler_flags = APPLE_COMPILER_FLAGS,
     fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
     force_static = True,
-    labels = ["supermodule:xplat/default/public.react_native.infra"],
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+        "supermodule:xplat/default/public.react_native.infra",
+    ],
     macosx_tests_override = [],
     platforms = (ANDROID, APPLE, CXX),
     preprocessor_flags = [

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

@@ -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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+add_compile_options(-fexceptions -frtti -std=c++17 -Wall -DLOG_TAG=\"Fabric\")
+
+file(GLOB react_render_core_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_render_core SHARED ${react_render_core_SRC})
+
+target_include_directories(react_render_core PUBLIC ${REACT_COMMON_DIR})
+target_link_libraries(react_render_core
+        folly_runtime
+        glog
+        jsi
+        react_debug
+        react_render_debug
+        react_render_graphics
+        react_utils)

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

@@ -179,6 +179,18 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   }
 
  protected:
+  /*
+   * Called immediatelly after `ShadowNode` is created or cloned.
+   *
+   * Override this method to pass information from custom `ComponentDescriptor`
+   * to new instance of `ShadowNode`.
+   *
+   * Example usages:
+   *   - Inject image manager to `ImageShadowNode` in
+   * `ImageComponentDescriptor`.
+   *   - Set `ShadowNode`'s size from state in
+   * `ModalHostViewComponentDescriptor`.
+   */
   virtual void adopt(ShadowNode::Unshared const &shadowNode) const {
     // Default implementation does nothing.
     react_native_assert(

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

@@ -36,6 +36,10 @@ EventDispatcher::EventDispatcher(
 
 void EventDispatcher::dispatchEvent(RawEvent &&rawEvent, EventPriority priority)
     const {
+  // Allows the event listener to interrupt default event dispatch
+  if (eventListeners_.willDispatchEvent(rawEvent)) {
+    return;
+  }
   getEventQueue(priority).enqueueEvent(std::move(rawEvent));
 }
 
@@ -46,6 +50,10 @@ void EventDispatcher::dispatchStateUpdate(
 }
 
 void EventDispatcher::dispatchUniqueEvent(RawEvent &&rawEvent) const {
+  // Allows the event listener to interrupt default event dispatch
+  if (eventListeners_.willDispatchEvent(rawEvent)) {
+    return;
+  }
   asynchronousBatchedQueue_->enqueueUniqueEvent(std::move(rawEvent));
 }
 
@@ -62,5 +70,18 @@ const EventQueue &EventDispatcher::getEventQueue(EventPriority priority) const {
   }
 }
 
+void EventDispatcher::addListener(
+    const std::shared_ptr<EventListener const> &listener) const {
+  eventListeners_.addListener(listener);
+}
+
+/*
+ * Removes provided event listener to the event dispatcher.
+ */
+void EventDispatcher::removeListener(
+    const std::shared_ptr<EventListener const> &listener) const {
+  eventListeners_.removeListener(listener);
+}
+
 } // namespace react
 } // namespace facebook