react-native-tvos 0.87.1-1 → 0.88.0-0rc2

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTFontUtils.mm

@@ -10,6 +10,7 @@
 #import <CoreText/CoreText.h>
 #import <React/RCTFont+Private.h>
 #import <React/RCTFont.h>
+#import <React/RCTLog.h>
 
 #import <algorithm>
 #import <cmath>
@@ -248,6 +249,58 @@ static NSArray *RCTFontFeatures(RCTFontVariant fontVariant)
   return fontFeatures;
 }
 
+NSDictionary<NSNumber *, NSNumber *> *RCTParseFontVariationSettings(NSString *variationSettings)
+{
+  NSString *trimmedSettings =
+      [variationSettings stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+  if (trimmedSettings.length == 0 || [trimmedSettings isEqualToString:@"normal"]) {
+    return @{};
+  }
+
+  static NSRegularExpression *variationExpression;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    variationExpression =
+        [NSRegularExpression regularExpressionWithPattern:
+                                 @R"(\s*(['"])([ -~]{4})\1\s+([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)\s*(,|$))"
+                                                  options:0
+                                                    error:nil];
+  });
+
+  NSMutableDictionary<NSNumber *, NSNumber *> *variations = [NSMutableDictionary dictionary];
+  NSUInteger location = 0;
+  while (location < variationSettings.length) {
+    NSTextCheckingResult *match =
+        [variationExpression firstMatchInString:variationSettings
+                                        options:NSMatchingAnchored
+                                          range:NSMakeRange(location, variationSettings.length - location)];
+    if (match == nil || match.range.location != location) {
+      RCTLogWarn(@"Invalid fontVariationSettings value: %@", variationSettings);
+      return @{};
+    }
+
+    NSString *axis = [variationSettings substringWithRange:[match rangeAtIndex:2]];
+    uint32_t axisIdentifier = (uint32_t)[axis characterAtIndex:0] << 24 | (uint32_t)[axis characterAtIndex:1] << 16 |
+        (uint32_t)[axis characterAtIndex:2] << 8 | (uint32_t)[axis characterAtIndex:3];
+    NSString *valueString = [variationSettings substringWithRange:[match rangeAtIndex:3]];
+    double value = valueString.doubleValue;
+    if (!std::isfinite(value)) {
+      RCTLogWarn(@"Invalid fontVariationSettings value: %@", variationSettings);
+      return @{};
+    }
+    variations[@(axisIdentifier)] = @(value);
+
+    NSString *separator = [variationSettings substringWithRange:[match rangeAtIndex:4]];
+    location = NSMaxRange(match.range);
+    if ([separator isEqualToString:@","] && location == variationSettings.length) {
+      RCTLogWarn(@"Invalid fontVariationSettings value: %@", variationSettings);
+      return @{};
+    }
+  }
+
+  return variations;
+}
+
 static RCTDefaultFontResolver defaultFontResolver;
 
 void RCTSetDefaultFontResolver(RCTDefaultFontResolver handler)
@@ -278,7 +331,9 @@ static UIFont *RCTDefaultFontWithFontProperties(const RCTFontProperties &fontPro
 
   if (font == nil) {
     if (defaultFontResolver != nil) {
-      font = defaultFontResolver(fontProperties);
+      RCTFontProperties baseFontProperties = fontProperties;
+      baseFontProperties.variations = nil;
+      font = defaultFontResolver(baseFontProperties);
     }
 
     if (font == nil) {
@@ -402,5 +457,13 @@ UIFont *RCTFontWithFontProperties(RCTFontProperties fontProperties)
     font = [UIFont fontWithDescriptor:fontDescriptor size:effectiveFontSize];
   }
 
+  NSDictionary<NSNumber *, NSNumber *> *variations = fontProperties.variations;
+  if (variations != nil) {
+    UIFontDescriptor *fontDescriptor = [font.fontDescriptor fontDescriptorByAddingAttributes:@{
+      (UIFontDescriptorAttributeName)kCTFontVariationAttribute : variations,
+    }];
+    font = [UIFont fontWithDescriptor:fontDescriptor size:effectiveFontSize];
+  }
+
   return font;
 }

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextLayoutManager.mm

@@ -14,6 +14,7 @@
 #import <React/NSTextStorage+FontScaling.h>
 #import <React/RCTUtils.h>
 #import <react/featureflags/ReactNativeFeatureFlags.h>
+#import <react/renderer/textlayoutmanager/TextMeasurementRounding.h>
 #import <react/utils/ManagedObjectWrapper.h>
 #import <react/utils/SimpleThreadSafeCache.h>
 
@@ -399,9 +400,11 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
                                          .width = usedRect.size.width, .height = usedRect.size.height}};
 
                                  CGFloat baseline = [layoutManager locationForGlyphAtIndex:range.location].y;
-                                 const char *renderedUTF8 = [renderedString UTF8String];
+                                 NSData *renderedData = [renderedString dataUsingEncoding:NSUTF8StringEncoding];
                                  auto line = LineMeasurement{
-                                     std::string(renderedUTF8 != nullptr ? renderedUTF8 : ""),
+                                     std::string(
+                                         renderedData != nil ? static_cast<const char *>(renderedData.bytes) : "",
+                                         renderedData != nil ? renderedData.length : 0),
                                      rect,
                                      overallRect.size.height - baseline,
                                      font.capHeight,
@@ -581,8 +584,11 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
     size.height = enumeratedLinesHeight;
   }
 
-  size = (CGSize){ceil(size.width * layoutContext.pointScaleFactor) / layoutContext.pointScaleFactor,
-                  ceil(size.height * layoutContext.pointScaleFactor) / layoutContext.pointScaleFactor};
+  facebook::react::Size roundedSize = facebook::react::internal_roundTextMeasurementToPixelGrid(
+      {.width = static_cast<facebook::react::Float>(size.width),
+       .height = static_cast<facebook::react::Float>(size.height)},
+      layoutContext.pointScaleFactor);
+  size = CGSize{roundedSize.width, roundedSize.height};
 
   NSRange visibleGlyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
 

package/ReactCommon/react/renderer/textlayoutmanager/tests/TextLayoutManagerTest.cpp

@@ -7,7 +7,11 @@
 
 #include <gtest/gtest.h>
 
+#include <array>
+#include <cmath>
+
 #include <react/renderer/textlayoutmanager/TextMeasureCache.h>
+#include <react/renderer/textlayoutmanager/TextMeasurementRounding.h>
 
 using namespace facebook::react;
 
@@ -45,6 +49,155 @@ TEST(TextLayoutManagerTest, maxFontSizeMultiplierAffectsLayoutCacheHash) {
       textAttributesHashLayoutWise(lhs), textAttributesHashLayoutWise(rhs));
 }
 
+TEST(TextLayoutManagerTest, fontVariationSettingsAffectLayoutCacheEquality) {
+  TextAttributes lhs;
+  TextAttributes rhs;
+
+  lhs.fontVariationSettings = "'wght' 400";
+  rhs.fontVariationSettings = "'wght' 700";
+
+  EXPECT_FALSE(areTextAttributesEquivalentLayoutWise(lhs, rhs));
+}
+
+TEST(TextLayoutManagerTest, fontVariationSettingsAffectLayoutCacheHash) {
+  TextAttributes lhs;
+  TextAttributes rhs;
+
+  lhs.fontVariationSettings = "'wght' 400";
+  rhs.fontVariationSettings = "'wght' 700";
+
+  EXPECT_NE(
+      textAttributesHashLayoutWise(lhs), textAttributesHashLayoutWise(rhs));
+}
+
+TEST(TextLayoutManagerTest, emptyFontVariationSettingsClearInheritedSettings) {
+  TextAttributes parent;
+  TextAttributes child;
+
+  parent.fontVariationSettings = "'wght' 700";
+  child.fontVariationSettings = "";
+  parent.apply(child);
+
+  EXPECT_TRUE(parent.fontVariationSettings.has_value());
+  EXPECT_TRUE(parent.fontVariationSettings->empty());
+}
+
+TEST(TextLayoutManagerTest, everyLayoutAttributeAffectsEqualityAndHash) {
+  TextAttributes baseline;
+  baseline.fontFamily = "Inter";
+  baseline.fontSize = 16;
+  baseline.fontSizeMultiplier = 1;
+  baseline.maxFontSizeMultiplier = 2;
+  baseline.letterSpacing = 0.5;
+  baseline.lineHeight = 20;
+  baseline.fontWeight = FontWeight::Weight400;
+  baseline.fontStyle = FontStyle::Normal;
+  baseline.fontVariant = FontVariant::Default;
+  baseline.fontVariationSettings = "'wght' 400";
+  baseline.allowFontScaling = true;
+  baseline.dynamicTypeRamp = DynamicTypeRamp::Body;
+  baseline.alignment = TextAlignment::Natural;
+
+  struct TestCase {
+    const char* name;
+    void (*mutate)(TextAttributes&);
+  };
+  const std::array<TestCase, 13> testCases{{
+      {.name = "fontFamily",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.fontFamily = "Roboto";
+           }},
+      {.name = "fontSize",
+       .mutate = [](TextAttributes& attributes) { attributes.fontSize = 17; }},
+      {.name = "fontSizeMultiplier",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.fontSizeMultiplier = 1.5;
+           }},
+      {.name = "maxFontSizeMultiplier",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.maxFontSizeMultiplier = 3;
+           }},
+      {.name = "letterSpacing",
+       .mutate =
+           [](TextAttributes& attributes) { attributes.letterSpacing = 1; }},
+      {.name = "lineHeight",
+       .mutate =
+           [](TextAttributes& attributes) { attributes.lineHeight = 24; }},
+      {.name = "fontWeight",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.fontWeight = FontWeight::Weight700;
+           }},
+      {.name = "fontStyle",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.fontStyle = FontStyle::Italic;
+           }},
+      {.name = "fontVariant",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.fontVariant = FontVariant::SmallCaps;
+           }},
+      {.name = "fontVariationSettings",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.fontVariationSettings = "'wght' 700";
+           }},
+      {.name = "allowFontScaling",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.allowFontScaling = false;
+           }},
+      {.name = "dynamicTypeRamp",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.dynamicTypeRamp = DynamicTypeRamp::Headline;
+           }},
+      {.name = "alignment",
+       .mutate =
+           [](TextAttributes& attributes) {
+             attributes.alignment = TextAlignment::Center;
+           }},
+  }};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.name);
+    auto changed = baseline;
+    testCase.mutate(changed);
+
+    EXPECT_FALSE(areTextAttributesEquivalentLayoutWise(baseline, changed));
+    EXPECT_NE(
+        textAttributesHashLayoutWise(baseline),
+        textAttributesHashLayoutWise(changed));
+  }
+}
+
+TEST(TextLayoutManagerTest, equivalentPopulatedLayoutAttributesHashEqually) {
+  TextAttributes lhs;
+  lhs.fontFamily = "Inter";
+  lhs.fontSize = 16;
+  lhs.fontSizeMultiplier = 1;
+  lhs.maxFontSizeMultiplier = 2;
+  lhs.letterSpacing = 0.5;
+  lhs.lineHeight = 20;
+  lhs.fontWeight = FontWeight::Weight400;
+  lhs.fontStyle = FontStyle::Italic;
+  lhs.fontVariant = FontVariant::SmallCaps;
+  lhs.fontVariationSettings = "'wght' 400";
+  lhs.allowFontScaling = true;
+  lhs.dynamicTypeRamp = DynamicTypeRamp::Body;
+  lhs.alignment = TextAlignment::Center;
+
+  auto rhs = lhs;
+
+  EXPECT_TRUE(areTextAttributesEquivalentLayoutWise(lhs, rhs));
+  EXPECT_EQ(
+      textAttributesHashLayoutWise(lhs), textAttributesHashLayoutWise(rhs));
+}
+
 // Measurements are rounded to the pixel grid, so a measurement cached at one
 // pixel scale factor must not satisfy a lookup at another. Keys that differ
 // only by pointScaleFactor must compare unequal.
@@ -97,3 +250,47 @@ TEST(TextLayoutManagerTest, pointScaleFactorAffectsPreparedTextCacheHash) {
       std::hash<PreparedTextCacheKey>{}(lhs),
       std::hash<PreparedTextCacheKey>{}(rhs));
 }
+
+// Tests for internal_roundTextMeasurementToPixelGrid (the pixel-grid rounding
+// used by text measurement). A small epsilon is added before ceil so a
+// dimension that lands exactly on a pixel boundary gains one physical pixel of
+// slack (avoiding double->float->Yoga precision from clipping the last line or
+// trailing glyph), while dimensions with sub-pixel headroom are left untouched.
+// pointScaleFactor 3 (an @3x screen) is used so one physical pixel is 1/3 pt.
+// These lock in the behavior of D7074168 / PR #54260 in the new architecture,
+// with the unit coverage that change lacked.
+namespace {
+constexpr Float kScale = 3.0;
+long heightInPixels(Size raw) {
+  return std::lround(
+      internal_roundTextMeasurementToPixelGrid(raw, kScale).height * kScale);
+}
+long widthInPixels(Size raw) {
+  return std::lround(
+      internal_roundTextMeasurementToPixelGrid(raw, kScale).width * kScale);
+}
+} // namespace
+
+// Height exactly on a pixel boundary gains one extra physical pixel (60 -> 61)
+// so the final line is not clipped after layout rounding.
+TEST(TextMeasurementRoundingTest, addsSlackWhenHeightOnPixelBoundary) {
+  EXPECT_EQ(heightInPixels(Size{100.0, 20.0}), 61);
+}
+
+// Width exactly on a pixel boundary likewise gains one extra physical pixel so
+// the trailing glyph is not clipped (matches the legacy both-dimensions fix).
+TEST(TextMeasurementRoundingTest, addsSlackWhenWidthOnPixelBoundary) {
+  EXPECT_EQ(widthInPixels(Size{20.0, 100.0}), 61);
+}
+
+// Height with sub-pixel headroom must NOT be inflated: 20.1pt -> 60.3px ->
+// 61px, never 62. The epsilon only nudges boundary values, so text is not made
+// taller than needed.
+TEST(TextMeasurementRoundingTest, doesNotInflateHeightWithSubpixelHeadroom) {
+  EXPECT_EQ(heightInPixels(Size{100.0, 20.1}), 61);
+}
+
+// Width with sub-pixel headroom must NOT be inflated either: 20.1pt -> 61px.
+TEST(TextMeasurementRoundingTest, doesNotInflateWidthWithSubpixelHeadroom) {
+  EXPECT_EQ(widthInPixels(Size{20.1, 100.0}), 61);
+}

package/ReactCommon/react/renderer/textlayoutmanager/tests/benchmarks/TextAttributesHashBenchmark.cpp

@@ -0,0 +1,252 @@
+/*
+ * 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 <benchmark/benchmark.h>
+
+#include <react/renderer/textlayoutmanager/TextMeasureCache.h>
+#include <react/utils/hash_combine.h>
+
+namespace facebook::react {
+namespace {
+
+size_t legacyTextAttributesHash(const TextAttributes& textAttributes) {
+  size_t textEffectsHash = 0;
+  for (const auto& effect : textAttributes.textEffects) {
+    hash_combine(textEffectsHash, effect);
+  }
+  return hash_combine(
+      textAttributes.foregroundColor,
+      textAttributes.backgroundColor,
+      textAttributes.opacity,
+      textAttributes.fontFamily,
+      textAttributes.fontSize,
+      textAttributes.maxFontSizeMultiplier,
+      textAttributes.fontSizeMultiplier,
+      textAttributes.fontWeight,
+      textAttributes.fontStyle,
+      textAttributes.fontVariant,
+      textAttributes.fontVariationSettings,
+      textAttributes.allowFontScaling,
+      textAttributes.letterSpacing,
+      textAttributes.textTransform,
+      textAttributes.lineHeight,
+      textAttributes.alignment,
+      textAttributes.baseWritingDirection,
+      textAttributes.lineBreakStrategy,
+      textAttributes.lineBreakMode,
+      textAttributes.textDecorationColor,
+      textAttributes.textDecorationLineType,
+      textAttributes.textDecorationStyle,
+      textAttributes.textShadowOffset,
+      textAttributes.textShadowRadius,
+      textAttributes.textShadowColor,
+      textAttributes.isHighlighted,
+      textAttributes.isPressable,
+      textAttributes.layoutDirection,
+      textAttributes.accessibilityRole,
+      textAttributes.role,
+      textEffectsHash);
+}
+
+size_t legacyLayoutHash(const TextAttributes& textAttributes) {
+  return hash_combine(
+      textAttributes.fontFamily,
+      textAttributes.fontSize,
+      textAttributes.fontSizeMultiplier,
+      textAttributes.fontWeight,
+      textAttributes.fontStyle,
+      textAttributes.fontVariant,
+      textAttributes.fontVariationSettings,
+      textAttributes.allowFontScaling,
+      textAttributes.maxFontSizeMultiplier,
+      textAttributes.dynamicTypeRamp,
+      textAttributes.letterSpacing,
+      textAttributes.lineHeight,
+      textAttributes.alignment);
+}
+
+TextAttributes sparseAttributes() {
+  TextAttributes attributes;
+  attributes.fontWeight = FontWeight::Weight400;
+  return attributes;
+}
+
+TextAttributes partialAttributes() {
+  TextAttributes attributes;
+  attributes.fontFamily = "Inter";
+  attributes.fontSize = 16;
+  attributes.fontSizeMultiplier = 1;
+  attributes.maxFontSizeMultiplier = 2;
+  attributes.letterSpacing = 0.5;
+  attributes.lineHeight = 20;
+  attributes.fontWeight = FontWeight::Weight400;
+  attributes.fontStyle = FontStyle::Normal;
+  attributes.allowFontScaling = true;
+  attributes.alignment = TextAlignment::Natural;
+  return attributes;
+}
+
+TextAttributes fullAttributes() {
+  auto attributes = partialAttributes();
+  attributes.fontVariant = FontVariant::SmallCaps;
+  attributes.fontVariationSettings = "'wght' 400";
+  attributes.dynamicTypeRamp = DynamicTypeRamp::Body;
+  attributes.textTransform = TextTransform::None;
+  attributes.baseWritingDirection = WritingDirection::LeftToRight;
+  attributes.lineBreakStrategy = LineBreakStrategy::Standard;
+  attributes.lineBreakMode = LineBreakMode::Word;
+  attributes.textDecorationLineType = TextDecorationLineType::Underline;
+  attributes.textDecorationStyle = TextDecorationStyle::Solid;
+  attributes.textShadowOffset = Size{.width = 1, .height = 1};
+  attributes.isHighlighted = false;
+  attributes.isPressable = true;
+  attributes.layoutDirection = LayoutDirection{};
+  attributes.accessibilityRole = AccessibilityRole{};
+  attributes.role = Role{};
+  return attributes;
+}
+
+struct DefaultAttributes {
+  static TextAttributes make() {
+    return {};
+  }
+};
+
+struct SparseAttributes {
+  static TextAttributes make() {
+    return sparseAttributes();
+  }
+};
+
+struct PartialAttributes {
+  static TextAttributes make() {
+    return partialAttributes();
+  }
+};
+
+struct FullAttributes {
+  static TextAttributes make() {
+    return fullAttributes();
+  }
+};
+
+struct LegacyFullHash {
+  static size_t hash(const TextAttributes& attributes) {
+    return legacyTextAttributesHash(attributes);
+  }
+};
+
+struct OptimizedFullHash {
+  static size_t hash(const TextAttributes& attributes) {
+    return std::hash<TextAttributes>{}(attributes);
+  }
+};
+
+struct LegacyLayoutHash {
+  static size_t hash(const TextAttributes& attributes) {
+    return legacyLayoutHash(attributes);
+  }
+};
+
+struct OptimizedLayoutHash {
+  static size_t hash(const TextAttributes& attributes) {
+    return textAttributesHashLayoutWise(attributes);
+  }
+};
+
+template <typename Attributes, typename Hash>
+void textAttributesHashBenchmark(benchmark::State& state) {
+  const auto attributes = Attributes::make();
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(attributes);
+    benchmark::DoNotOptimize(Hash::hash(attributes));
+  }
+}
+
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    DefaultAttributes,
+    LegacyFullHash)
+    ->Name("LegacyFull_Default");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    DefaultAttributes,
+    OptimizedFullHash)
+    ->Name("OptimizedFull_Default");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    SparseAttributes,
+    LegacyFullHash)
+    ->Name("LegacyFull_Sparse");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    SparseAttributes,
+    OptimizedFullHash)
+    ->Name("OptimizedFull_Sparse");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    PartialAttributes,
+    LegacyFullHash)
+    ->Name("LegacyFull_Partial");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    PartialAttributes,
+    OptimizedFullHash)
+    ->Name("OptimizedFull_Partial");
+BENCHMARK_TEMPLATE(textAttributesHashBenchmark, FullAttributes, LegacyFullHash)
+    ->Name("LegacyFull_Full");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    FullAttributes,
+    OptimizedFullHash)
+    ->Name("OptimizedFull_Full");
+
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    DefaultAttributes,
+    LegacyLayoutHash)
+    ->Name("LegacyLayout_Default");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    DefaultAttributes,
+    OptimizedLayoutHash)
+    ->Name("OptimizedLayout_Default");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    SparseAttributes,
+    LegacyLayoutHash)
+    ->Name("LegacyLayout_Sparse");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    SparseAttributes,
+    OptimizedLayoutHash)
+    ->Name("OptimizedLayout_Sparse");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    PartialAttributes,
+    LegacyLayoutHash)
+    ->Name("LegacyLayout_Partial");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    PartialAttributes,
+    OptimizedLayoutHash)
+    ->Name("OptimizedLayout_Partial");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    FullAttributes,
+    LegacyLayoutHash)
+    ->Name("LegacyLayout_Full");
+BENCHMARK_TEMPLATE(
+    textAttributesHashBenchmark,
+    FullAttributes,
+    OptimizedLayoutHash)
+    ->Name("OptimizedLayout_Full");
+
+} // namespace
+} // namespace facebook::react
+
+BENCHMARK_MAIN();

package/ReactCommon/react/renderer/uimanager/AppRegistryBinding.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <folly/dynamic.h>
 #include <jsi/jsi.h>
 #include <react/renderer/core/ReactPrimitives.h>

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

@@ -18,6 +18,7 @@ target_link_libraries(react_renderer_uimanager
         folly_runtime
         jsi
         react_cxxreact
+        react_cxxstableapi
         react_debug
         react_featureflags
         react_renderer_componentregistry

package/ReactCommon/react/renderer/uimanager/LayoutAnimationStatusDelegate.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 namespace facebook::react {
 
 class LayoutAnimationStatusDelegate {

package/ReactCommon/react/renderer/uimanager/LayoutEventEmitter.cpp

@@ -0,0 +1,38 @@
+/*
+ * 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 "LayoutEventEmitter.h"
+
+#include <cxxreact/TraceSection.h>
+#include <react/renderer/components/view/ViewShadowNode.h>
+#include <react/renderer/core/LayoutableShadowNode.h>
+
+namespace facebook::react {
+
+void LayoutEventEmitter::shadowTreeDidCommit(
+    const ShadowTree& /*shadowTree*/,
+    const RootShadowNode::Shared& /*rootShadowNode*/,
+    const std::vector<const LayoutableShadowNode*>&
+        affectedLayoutableNodes) noexcept {
+  TraceSection s(
+      "LayoutEventEmitter::shadowTreeDidCommit",
+      "affectedLayoutableNodes",
+      affectedLayoutableNodes.size());
+
+  for (const auto* layoutableNode : affectedLayoutableNodes) {
+    if (auto viewProps =
+            dynamic_cast<const ViewProps*>(layoutableNode->getProps().get())) {
+      if (viewProps->onLayout) {
+        static_cast<const BaseViewEventEmitter&>(
+            *layoutableNode->getEventEmitter())
+            .onLayout(layoutableNode->getLayoutMetrics());
+      }
+    }
+  }
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/LayoutEventEmitter.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/cxxstableapi/FrameworksGuard.h>
+
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
+
+namespace facebook::react {
+
+/*
+ * Emits layout events (`onLayout`) for the nodes whose layout changed in
+ * each commit, using the `shadowTreeDidCommit` commit hook as the source of
+ * layout changes (this logic used to be implemented directly in
+ * `ShadowTree`).
+ */
+class LayoutEventEmitter final : public UIManagerCommitHook {
+ public:
+  void commitHookWasRegistered(const UIManager & /*uiManager*/) noexcept override {}
+  void commitHookWasUnregistered(const UIManager & /*uiManager*/) noexcept override {}
+
+  void shadowTreeDidCommit(
+      const ShadowTree &shadowTree,
+      const RootShadowNode::Shared &rootShadowNode,
+      const std::vector<const LayoutableShadowNode *> &affectedLayoutableNodes) noexcept override;
+};
+
+} // namespace facebook::react