react-native 0.71.3 → 0.72.0-rc.0

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

@@ -401,6 +401,38 @@ static inline CascadedRectangleCorners<T> convertRawProp(
       defaultValue.bottomEnd,
       prefix,
       suffix);
+  result.endEnd = convertRawProp(
+      context,
+      rawProps,
+      "EndEnd",
+      sourceValue.endEnd,
+      defaultValue.endEnd,
+      prefix,
+      suffix);
+  result.endStart = convertRawProp(
+      context,
+      rawProps,
+      "EndStart",
+      sourceValue.endStart,
+      defaultValue.endStart,
+      prefix,
+      suffix);
+  result.startEnd = convertRawProp(
+      context,
+      rawProps,
+      "StartEnd",
+      sourceValue.startEnd,
+      defaultValue.startEnd,
+      prefix,
+      suffix);
+  result.startStart = convertRawProp(
+      context,
+      rawProps,
+      "StartStart",
+      sourceValue.startStart,
+      defaultValue.startStart,
+      prefix,
+      suffix);
 
   result.all = convertRawProp(
       context, rawProps, "", sourceValue.all, defaultValue.all, prefix, suffix);
@@ -483,6 +515,30 @@ static inline CascadedRectangleEdges<T> convertRawProp(
       defaultValue.vertical,
       prefix,
       suffix);
+  result.block = convertRawProp(
+      context,
+      rawProps,
+      "Block",
+      sourceValue.block,
+      defaultValue.block,
+      prefix,
+      suffix);
+  result.blockEnd = convertRawProp(
+      context,
+      rawProps,
+      "BlockEnd",
+      sourceValue.blockEnd,
+      defaultValue.blockEnd,
+      prefix,
+      suffix);
+  result.blockStart = convertRawProp(
+      context,
+      rawProps,
+      "BlockStart",
+      sourceValue.blockStart,
+      defaultValue.blockStart,
+      prefix,
+      suffix);
 
   result.all = convertRawProp(
       context, rawProps, "", sourceValue.all, defaultValue.all, prefix, suffix);
@@ -668,19 +724,20 @@ static inline void fromRawValue(
   auto map = (butter::map<std::string, RawValue>)rawValue;
 
   auto typeIterator = map.find("type");
-  react_native_assert(
+  react_native_expect(
       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(
+    react_native_expect(
         attrIterator != map.end() &&
         attrIterator->second.hasType<std::string>());
 
     result = NativeDrawable{
-        NativeDrawable::Kind::ThemeAttr,
         (std::string)attrIterator->second,
+        {},
+        NativeDrawable::Kind::ThemeAttr,
     };
   } else if (type == "RippleAndroid") {
     auto color = map.find("color");
@@ -688,23 +745,23 @@ static inline void fromRawValue(
     auto rippleRadius = map.find("rippleRadius");
 
     result = NativeDrawable{
-        NativeDrawable::Kind::Ripple,
         std::string{},
         NativeDrawable::Ripple{
             color != map.end() && color->second.hasType<int32_t>()
                 ? (int32_t)color->second
                 : std::optional<int32_t>{},
-            borderless != map.end() && borderless->second.hasType<bool>()
-                ? (bool)borderless->second
-                : false,
             rippleRadius != map.end() && rippleRadius->second.hasType<Float>()
                 ? (Float)rippleRadius->second
                 : std::optional<Float>{},
+            borderless != map.end() && borderless->second.hasType<bool>()
+                ? (bool)borderless->second
+                : false,
         },
+        NativeDrawable::Kind::Ripple,
     };
   } else {
     LOG(ERROR) << "Unknown native drawable type: " << type;
-    react_native_assert(false);
+    react_native_expect(false);
   }
 }
 

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

@@ -45,7 +45,14 @@ namespace facebook::react {
 //  ***********************│          │************************************
 //  ***********************└──────────┘************************************
 
-enum TestCase { AS_IS, CLIPPING, TRANSFORM_SCALE, TRANSFORM_TRANSLATE };
+enum TestCase {
+  AS_IS,
+  CLIPPING,
+  HIT_SLOP,
+  HIT_SLOP_TRANSFORM_TRANSLATE,
+  TRANSFORM_SCALE,
+  TRANSFORM_TRANSLATE,
+};
 
 class LayoutTest : public ::testing::Test {
  protected:
@@ -105,9 +112,14 @@ class LayoutTest : public ::testing::Test {
                       props.transform = props.transform * Transform::Scale(2, 2, 1);
                     }
 
-                    if (testCase == TRANSFORM_TRANSLATE) {
+                    if (testCase == TRANSFORM_TRANSLATE || testCase == HIT_SLOP_TRANSFORM_TRANSLATE) {
                       props.transform = props.transform * Transform::Translate(10, 10, 0);
                     }
+
+                    if (testCase == HIT_SLOP || testCase == HIT_SLOP_TRANSFORM_TRANSLATE) {
+                      props.hitSlop = EdgeInsets{50, 50, 50, 50};
+                    }
+
                     return sharedProps;
                   })
                   .children({
@@ -358,4 +370,78 @@ TEST_F(LayoutTest, overflowInsetTransformScaleTest) {
   EXPECT_EQ(layoutMetricsABC.overflowInset.bottom, 0);
 }
 
+TEST_F(LayoutTest, overflowInsetHitSlopTest) {
+  initialize(HIT_SLOP);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
+
+  // Change on parent node
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, -40);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -80);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -100);
+
+  auto layoutMetricsAB = viewShadowNodeAB_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsAB.frame.size.width, 30);
+  EXPECT_EQ(layoutMetricsAB.frame.size.height, 90);
+
+  // No change on self node
+  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_F(LayoutTest, overflowInsetHitSlopTransformTranslateTest) {
+  initialize(HIT_SLOP_TRANSFORM_TRANSLATE);
+
+  auto layoutMetricsA = viewShadowNodeA_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsA.frame.size.width, 50);
+  EXPECT_EQ(layoutMetricsA.frame.size.height, 50);
+
+  // Change on parent node
+  EXPECT_EQ(layoutMetricsA.overflowInset.left, -50);
+  EXPECT_EQ(layoutMetricsA.overflowInset.top, -40);
+  EXPECT_EQ(layoutMetricsA.overflowInset.right, -90);
+  EXPECT_EQ(layoutMetricsA.overflowInset.bottom, -110);
+
+  auto layoutMetricsAB = viewShadowNodeAB_->getLayoutMetrics();
+
+  EXPECT_EQ(layoutMetricsAB.frame.size.width, 30);
+  EXPECT_EQ(layoutMetricsAB.frame.size.height, 90);
+
+  // No change on self node
+  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);
+}
+
 } // namespace facebook::react

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

@@ -10,7 +10,7 @@
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/components/view/ViewPropsMapBuffer.h>
 #include <react/renderer/components/view/conversions.h>
-#include <react/renderer/graphics/conversions.h>
+#include <react/renderer/core/graphicsConversions.h>
 #include <react/renderer/mapbuffer/MapBuffer.h>
 #include <react/renderer/mapbuffer/MapBufferBuilder.h>
 
@@ -28,6 +28,9 @@ constexpr MapBuffer::Key EDGE_BOTTOM = 3;
 constexpr MapBuffer::Key EDGE_START = 4;
 constexpr MapBuffer::Key EDGE_END = 5;
 constexpr MapBuffer::Key EDGE_ALL = 6;
+constexpr MapBuffer::Key EDGE_BLOCK = 7;
+constexpr MapBuffer::Key EDGE_BLOCK_START = 8;
+constexpr MapBuffer::Key EDGE_BLOCK_END = 9;
 
 constexpr MapBuffer::Key CORNER_TOP_LEFT = 0;
 constexpr MapBuffer::Key CORNER_TOP_RIGHT = 1;
@@ -38,6 +41,10 @@ constexpr MapBuffer::Key CORNER_TOP_END = 5;
 constexpr MapBuffer::Key CORNER_BOTTOM_END = 6;
 constexpr MapBuffer::Key CORNER_BOTTOM_START = 7;
 constexpr MapBuffer::Key CORNER_ALL = 8;
+constexpr MapBuffer::Key CORNER_END_END = 9;
+constexpr MapBuffer::Key CORNER_END_START = 10;
+constexpr MapBuffer::Key CORNER_START_END = 11;
+constexpr MapBuffer::Key CORNER_START_START = 12;
 
 inline void putOptionalFloat(
     MapBufferBuilder &builder,
@@ -103,20 +110,24 @@ inline MapBuffer convertBorderColors(CascadedBorderColors const &colors) {
 
 template <typename T>
 MapBuffer convertCascadedEdges(CascadedRectangleEdges<T> const &edges) {
-  MapBufferBuilder builder(7);
+  MapBufferBuilder builder(10);
   putOptionalFloat(builder, EDGE_TOP, optionalFromValue(edges.top));
   putOptionalFloat(builder, EDGE_RIGHT, optionalFromValue(edges.right));
   putOptionalFloat(builder, EDGE_BOTTOM, optionalFromValue(edges.bottom));
   putOptionalFloat(builder, EDGE_LEFT, optionalFromValue(edges.left));
   putOptionalFloat(builder, EDGE_START, optionalFromValue(edges.start));
   putOptionalFloat(builder, EDGE_END, optionalFromValue(edges.end));
+  putOptionalFloat(builder, EDGE_BLOCK, optionalFromValue(edges.block));
+  putOptionalFloat(builder, EDGE_BLOCK_END, optionalFromValue(edges.blockEnd));
+  putOptionalFloat(
+      builder, EDGE_BLOCK_START, optionalFromValue(edges.blockStart));
   putOptionalFloat(builder, EDGE_ALL, optionalFromValue(edges.all));
   return builder.build();
 }
 
 template <typename T>
 MapBuffer convertCascadedCorners(CascadedRectangleCorners<T> const &corners) {
-  MapBufferBuilder builder(9);
+  MapBufferBuilder builder(13);
   putOptionalFloat(
       builder, CORNER_TOP_LEFT, optionalFromValue(corners.topLeft));
   putOptionalFloat(
@@ -132,6 +143,13 @@ MapBuffer convertCascadedCorners(CascadedRectangleCorners<T> const &corners) {
       builder, CORNER_BOTTOM_END, optionalFromValue(corners.bottomEnd));
   putOptionalFloat(
       builder, CORNER_BOTTOM_START, optionalFromValue(corners.bottomStart));
+  putOptionalFloat(builder, CORNER_END_END, optionalFromValue(corners.endEnd));
+  putOptionalFloat(
+      builder, CORNER_END_START, optionalFromValue(corners.endStart));
+  putOptionalFloat(
+      builder, CORNER_START_END, optionalFromValue(corners.startEnd));
+  putOptionalFloat(
+      builder, CORNER_START_START, optionalFromValue(corners.startStart));
   putOptionalFloat(builder, CORNER_ALL, optionalFromValue(corners.all));
   return builder.build();
 }

package/ReactCommon/react/renderer/core/BUCK

@@ -33,9 +33,9 @@ rn_xplat_cxx_library(
         prefix = "react/renderer/core",
     ),
     compiler_flags_pedantic = True,
+    fbandroid_tests_override = [],
     fbobjc_compiler_flags = APPLE_COMPILER_FLAGS,
     fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
-    force_static = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
     ],
@@ -54,11 +54,14 @@ rn_xplat_cxx_library(
         "//xplat/folly:hash",
         "//xplat/folly:likely",
         "//xplat/jsi:JSIDynamic",
-        "//xplat/jsi:jsi",
         react_native_xplat_target("react/debug:debug"),
         react_native_xplat_target("react/utils:utils"),
         react_native_xplat_target("react/renderer/debug:debug"),
         react_native_xplat_target("react/renderer/graphics:graphics"),
+        react_native_xplat_target("cxxreact:bridge"),
+    ],
+    exported_deps = [
+        "//xplat/jsi:jsi",
     ],
 )
 
@@ -73,7 +76,7 @@ fb_xplat_cxx_test(
         "-Wall",
     ],
     contacts = ["oncall+react_native@xmail.facebook.com"],
-    platforms = (ANDROID, APPLE, CXX),
+    platforms = (APPLE, CXX),
     deps = [
         ":core",
         "//xplat/hermes/API:HermesAPI",
@@ -84,6 +87,7 @@ fb_xplat_cxx_test(
         react_native_xplat_target("react/renderer/components/text:text"),
         react_native_xplat_target("react/renderer/element:element"),
         react_native_xplat_target("react/renderer/components/view:view"),
+        react_native_xplat_target("cxxreact:bridge"),
     ],
 )
 

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

@@ -195,7 +195,7 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
 
  protected:
   /*
-   * Called immediatelly after `ShadowNode` is created or cloned.
+   * Called immediately after `ShadowNode` is created or cloned.
    *
    * Override this method to pass information from custom `ComponentDescriptor`
    * to new instance of `ShadowNode`.

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

@@ -12,6 +12,9 @@ namespace react {
 
 bool CoreFeatures::enablePropIteratorSetter = false;
 bool CoreFeatures::enableMapBuffer = false;
+bool CoreFeatures::blockPaintForUseLayoutEffect = false;
+bool CoreFeatures::useNativeState = false;
+bool CoreFeatures::cacheNSTextStorage = false;
 
 } // namespace react
 } // namespace facebook

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

@@ -12,7 +12,7 @@ namespace react {
 
 /*
  * Contains the set of feature flags for the renderer core.
- * Some of them are temporary and may be eventualy phased out
+ * Some of them are temporary and may be eventually phased out
  * as soon as the feature is fully implemented.
  */
 class CoreFeatures {
@@ -25,6 +25,20 @@ class CoreFeatures {
   // its ShadowNode traits must set the MapBuffer trait; and this
   // must be set to "true" globally.
   static bool enableMapBuffer;
+
+  // When enabled, Fabric will block paint to allow for state updates in
+  // useLayoutEffect hooks to be processed. This changes affects scheduling of
+  // when a transaction is mounted.
+  static bool blockPaintForUseLayoutEffect;
+
+  // Whether to use Hermes' NativeState instead of HostObject
+  // in simple data passing scenarios with JS
+  static bool useNativeState;
+
+  // Creating NSTextStorage is relatively expensive operation and we were
+  // creating it twice. Once when measuring text and once when rendering it.
+  // This flag caches it inside ParagraphState.
+  static bool cacheNSTextStorage;
 };
 
 } // namespace react

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

@@ -8,6 +8,7 @@
 #include "DynamicPropsUtilities.h"
 
 namespace facebook::react {
+
 folly::dynamic mergeDynamicProps(
     folly::dynamic const &source,
     folly::dynamic const &patch) {

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

@@ -8,13 +8,17 @@
 #pragma once
 
 #include <folly/dynamic.h>
+#include <react/renderer/core/RawProps.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
+/*
+ * Accepts two `folly::dynamic` objects as arguments. Both arguments need to
+ * represent a dictionary. It updates `source` with key/value pairs from
+ * `patch`, overriding existing keys.
+ */
 folly::dynamic mergeDynamicProps(
     folly::dynamic const &source,
     folly::dynamic const &patch);
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

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

@@ -77,7 +77,7 @@ class EventBeat {
 
  protected:
   /*
-   * Should be used by sublasses to send a beat.
+   * Should be used by subclasses to send a beat.
    * Receiver might ignore the call if a beat was not requested.
    */
   void beat(jsi::Runtime &runtime) const;

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

@@ -6,8 +6,9 @@
  */
 
 #include "EventDispatcher.h"
-
+#include <cxxreact/JSExecutor.h>
 #include <react/renderer/core/StateUpdate.h>
+#include "EventLogger.h"
 
 #include "BatchedEventQueue.h"
 #include "RawEvent.h"
@@ -18,7 +19,7 @@ namespace facebook::react {
 EventDispatcher::EventDispatcher(
     EventQueueProcessor const &eventProcessor,
     EventBeat::Factory const &synchonousEventBeatFactory,
-    EventBeat::Factory const &asynchonousEventBeatFactory,
+    EventBeat::Factory const &asynchronousEventBeatFactory,
     EventBeat::SharedOwnerBox const &ownerBox)
     : synchronousUnbatchedQueue_(std::make_unique<UnbatchedEventQueue>(
           eventProcessor,
@@ -28,10 +29,10 @@ EventDispatcher::EventDispatcher(
           synchonousEventBeatFactory(ownerBox))),
       asynchronousUnbatchedQueue_(std::make_unique<UnbatchedEventQueue>(
           eventProcessor,
-          asynchonousEventBeatFactory(ownerBox))),
+          asynchronousEventBeatFactory(ownerBox))),
       asynchronousBatchedQueue_(std::make_unique<BatchedEventQueue>(
           eventProcessor,
-          asynchonousEventBeatFactory(ownerBox))) {}
+          asynchronousEventBeatFactory(ownerBox))) {}
 
 void EventDispatcher::dispatchEvent(RawEvent &&rawEvent, EventPriority priority)
     const {
@@ -39,6 +40,11 @@ void EventDispatcher::dispatchEvent(RawEvent &&rawEvent, EventPriority priority)
   if (eventListeners_.willDispatchEvent(rawEvent)) {
     return;
   }
+
+  auto eventLogger = getEventLogger();
+  if (eventLogger != nullptr) {
+    rawEvent.loggingTag = eventLogger->onEventStart(rawEvent.type.c_str());
+  }
   getEventQueue(priority).enqueueEvent(std::move(rawEvent));
 }
 

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

@@ -32,7 +32,7 @@ class EventDispatcher {
   EventDispatcher(
       EventQueueProcessor const &eventProcessor,
       EventBeat::Factory const &synchonousEventBeatFactory,
-      EventBeat::Factory const &asynchonousEventBeatFactory,
+      EventBeat::Factory const &asynchronousEventBeatFactory,
       EventBeat::SharedOwnerBox const &ownerBox);
 
   /*

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

@@ -10,7 +10,7 @@
 namespace facebook::react {
 
 bool EventListenerContainer::willDispatchEvent(const RawEvent &event) {
-  std::shared_lock<butter::shared_mutex> lock(mutex_);
+  std::shared_lock lock(mutex_);
 
   bool handled = false;
   for (auto const &listener : eventListeners_) {
@@ -21,14 +21,14 @@ bool EventListenerContainer::willDispatchEvent(const RawEvent &event) {
 
 void EventListenerContainer::addListener(
     const std::shared_ptr<EventListener const> &listener) {
-  std::unique_lock<butter::shared_mutex> lock(mutex_);
+  std::unique_lock lock(mutex_);
 
   eventListeners_.push_back(listener);
 }
 
 void EventListenerContainer::removeListener(
     const std::shared_ptr<EventListener const> &listener) {
-  std::unique_lock<butter::shared_mutex> lock(mutex_);
+  std::unique_lock lock(mutex_);
 
   auto it = std::find(eventListeners_.begin(), eventListeners_.end(), listener);
   if (it != eventListeners_.end()) {

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

@@ -7,12 +7,11 @@
 
 #pragma once
 
+#include <shared_mutex>
 #include <string>
 
 #include <react/renderer/core/RawEvent.h>
 
-#include <butter/mutex.h>
-
 namespace facebook {
 namespace react {
 
@@ -36,7 +35,7 @@ class EventListenerContainer {
   void removeListener(const std::shared_ptr<EventListener const> &listener);
 
  private:
-  butter::shared_mutex mutex_;
+  std::shared_mutex mutex_;
   std::vector<std::shared_ptr<EventListener const>> eventListeners_;
 };
 

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

@@ -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.
+ */
+
+#include "EventLogger.h"
+
+namespace facebook::react {
+
+EventLogger *eventLogger;
+
+void setEventLogger(EventLogger *logger) {
+  eventLogger = logger;
+}
+
+EventLogger *getEventLogger() {
+  return eventLogger;
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/core/EventLogger.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.
+ */
+
+#pragma once
+
+namespace facebook::react {
+
+using EventTag = unsigned int;
+
+/*
+ * Interface for logging discrete events (such as pointerenter/leave),
+ * which can be used for implementing W3C Event Timing API standard,
+ * see https://www.w3.org/TR/event-timing
+ */
+class EventLogger {
+ public:
+  virtual ~EventLogger() = default;
+
+  /*
+   * Called when an event is first created, returns and unique tag for this
+   * event, which can be used to log further event processing stages.
+   */
+  virtual EventTag onEventStart(const char *name) = 0;
+
+  /*
+   * Called when event starts getting dispatched (processed by the handlers, if
+   * any)
+   */
+  virtual void onEventDispatch(EventTag tag) = 0;
+
+  /*
+   * Called when event finishes being dispatched
+   */
+  virtual void onEventEnd(EventTag tag) = 0;
+};
+
+void setEventLogger(EventLogger *eventLogger);
+EventLogger *getEventLogger();
+
+} // namespace facebook::react

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

@@ -5,9 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "EventQueue.h"
-
+#include <cxxreact/JSExecutor.h>
 #include "EventEmitter.h"
+#include "EventLogger.h"
+#include "EventQueue.h"
 #include "ShadowNodeFamily.h"
 
 namespace facebook::react {
@@ -47,6 +48,11 @@ void EventQueueProcessor::flushEvents(
       reactPriority = ReactEventPriority::Discrete;
     }
 
+    auto eventLogger = getEventLogger();
+    if (eventLogger != nullptr) {
+      eventLogger->onEventDispatch(event.loggingTag);
+    }
+
     eventPipe_(
         runtime,
         event.eventTarget.get(),
@@ -54,6 +60,10 @@ void EventQueueProcessor::flushEvents(
         reactPriority,
         event.payloadFactory);
 
+    if (eventLogger != nullptr) {
+      eventLogger->onEventEnd(event.loggingTag);
+    }
+
     if (event.category == RawEvent::Category::ContinuousStart) {
       hasContinuousEventStarted_ = true;
     }

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

@@ -11,7 +11,7 @@
 
 #include <folly/Hash.h>
 #include <react/renderer/core/LayoutPrimitives.h>
-#include <react/renderer/graphics/Geometry.h>
+#include <react/renderer/graphics/Size.h>
 
 namespace facebook {
 namespace react {

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

@@ -10,7 +10,6 @@
 #include <vector>
 
 #include <react/renderer/core/LayoutableShadowNode.h>
-#include <react/renderer/graphics/Geometry.h>
 
 namespace facebook {
 namespace react {

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

@@ -11,7 +11,8 @@
 #include <react/renderer/core/LayoutPrimitives.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
 #include <react/renderer/debug/flags.h>
-#include <react/renderer/graphics/Geometry.h>
+#include <react/renderer/graphics/Rect.h>
+#include <react/renderer/graphics/RectangleEdges.h>
 
 namespace facebook {
 namespace react {