@depup/react-native 0.86.2-depup.0 → 0.87.0-depup.0

package/ReactCommon/react/renderer/textlayoutmanager/TextMeasureCache.h

@@ -66,6 +66,10 @@ class TextMeasureCacheKey final {
   AttributedString attributedString{};
   ParagraphAttributes paragraphAttributes{};
   LayoutConstraints layoutConstraints{};
+  // The measured size depends on the pixel scale factor because layout metrics
+  // are rounded to the pixel grid. Two otherwise-identical measures at different
+  // densities are not interchangeable, so the scale factor is part of the key.
+  Float pointScaleFactor{};
 };
 
 // The Key type that is used for Line Measure Cache.
@@ -87,6 +91,9 @@ class PreparedTextCacheKey final {
   AttributedString attributedString{};
   ParagraphAttributes paragraphAttributes{};
   LayoutConstraints layoutConstraints{};
+  // A prepared layout is rounded to the pixel grid, so it is only reusable at
+  // the pixel scale factor it was laid out at.
+  Float pointScaleFactor{};
 };
 
 /*
@@ -130,7 +137,8 @@ inline bool areTextAttributesEquivalentLayoutWise(const TextAttributes &lhs, con
              rhs.dynamicTypeRamp,
              rhs.alignment) &&
       floatEquality(lhs.fontSize, rhs.fontSize) && floatEquality(lhs.fontSizeMultiplier, rhs.fontSizeMultiplier) &&
-      floatEquality(lhs.letterSpacing, rhs.letterSpacing) && floatEquality(lhs.lineHeight, rhs.lineHeight);
+      floatEquality(lhs.letterSpacing, rhs.letterSpacing) && floatEquality(lhs.lineHeight, rhs.lineHeight) &&
+      floatEquality(lhs.maxFontSizeMultiplier, rhs.maxFontSizeMultiplier);
 }
 
 inline size_t textAttributesHashLayoutWise(const TextAttributes &textAttributes)
@@ -145,6 +153,7 @@ inline size_t textAttributesHashLayoutWise(const TextAttributes &textAttributes)
       textAttributes.fontStyle,
       textAttributes.fontVariant,
       textAttributes.allowFontScaling,
+      textAttributes.maxFontSizeMultiplier,
       textAttributes.dynamicTypeRamp,
       textAttributes.letterSpacing,
       textAttributes.lineHeight,
@@ -250,7 +259,8 @@ inline size_t attributedStringHashDisplayWise(const AttributedString &attributed
 inline bool operator==(const TextMeasureCacheKey &lhs, const TextMeasureCacheKey &rhs)
 {
   return areAttributedStringsEquivalentLayoutWise(lhs.attributedString, rhs.attributedString) &&
-      lhs.paragraphAttributes == rhs.paragraphAttributes && lhs.layoutConstraints == rhs.layoutConstraints;
+      lhs.paragraphAttributes == rhs.paragraphAttributes && lhs.layoutConstraints == rhs.layoutConstraints &&
+      floatEquality(lhs.pointScaleFactor, rhs.pointScaleFactor);
 }
 
 inline bool operator==(const LineMeasureCacheKey &lhs, const LineMeasureCacheKey &rhs)
@@ -262,7 +272,8 @@ inline bool operator==(const LineMeasureCacheKey &lhs, const LineMeasureCacheKey
 inline bool operator==(const PreparedTextCacheKey &lhs, const PreparedTextCacheKey &rhs)
 {
   return areAttributedStringsEquivalentDisplayWise(lhs.attributedString, rhs.attributedString) &&
-      lhs.paragraphAttributes == rhs.paragraphAttributes && lhs.layoutConstraints == rhs.layoutConstraints;
+      lhs.paragraphAttributes == rhs.paragraphAttributes && lhs.layoutConstraints == rhs.layoutConstraints &&
+      floatEquality(lhs.pointScaleFactor, rhs.pointScaleFactor);
 }
 
 } // namespace facebook::react
@@ -274,7 +285,10 @@ struct hash<facebook::react::TextMeasureCacheKey> {
   size_t operator()(const facebook::react::TextMeasureCacheKey &key) const
   {
     return facebook::react::hash_combine(
-        attributedStringHashLayoutWise(key.attributedString), key.paragraphAttributes, key.layoutConstraints);
+        attributedStringHashLayoutWise(key.attributedString),
+        key.paragraphAttributes,
+        key.layoutConstraints,
+        key.pointScaleFactor);
   }
 };
 
@@ -292,7 +306,10 @@ struct hash<facebook::react::PreparedTextCacheKey> {
   size_t operator()(const facebook::react::PreparedTextCacheKey &key) const
   {
     return facebook::react::hash_combine(
-        attributedStringHashDisplayWise(key.attributedString), key.paragraphAttributes, key.layoutConstraints);
+        attributedStringHashDisplayWise(key.attributedString),
+        key.paragraphAttributes,
+        key.layoutConstraints,
+        key.pointScaleFactor);
   }
 };
 

package/ReactCommon/react/renderer/textlayoutmanager/platform/android/react/renderer/textlayoutmanager/TextLayoutManager.cpp

@@ -193,7 +193,8 @@ TextMeasurement TextLayoutManager::measure(
       : textMeasureCache_.get(
             {.attributedString = attributedString,
              .paragraphAttributes = paragraphAttributes,
-             .layoutConstraints = layoutConstraints},
+             .layoutConstraints = layoutConstraints,
+             .pointScaleFactor = layoutContext.pointScaleFactor},
             std::move(measureText));
 
   measurement.size = layoutConstraints.clamp(measurement.size);
@@ -315,7 +316,8 @@ TextLayoutManager::PreparedTextLayout TextLayoutManager::prepareLayout(
   const auto [key, preparedText] = preparedTextCache_.getWithKey(
       {.attributedString = attributedString,
        .paragraphAttributes = paragraphAttributes,
-       .layoutConstraints = layoutConstraints},
+       .layoutConstraints = layoutConstraints,
+       .pointScaleFactor = layoutContext.pointScaleFactor},
       [&]() {
         const auto& fabricUIManager =
             contextContainer_->at<jni::global_ref<jobject>>("FabricUIManager");

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

@@ -19,6 +19,17 @@ NSString *const RCTAttributedStringEventEmitterKey = @"EventEmitter";
 // String representation of either `role` or `accessibilityRole`
 NSString *const RCTTextAttributesAccessibilityRoleAttributeName = @"AccessibilityRole";
 
+// Custom attribute key for ranges whose decoration line cannot be rendered
+// faithfully via UIKit's `NSUnderlineStyle` pattern bits (wavy has no native
+// equivalent; dotted/dashed don't match the geometry browsers use). These
+// ranges are painted by `RCTTextLayoutManager`'s drawing pass.
+//
+// Stored as an NSDictionary:
+//   @"lines": NSArray of @"underline" / @"line-through"
+//   @"color": UIColor stroke color
+//   @"style": NSString — @"wavy" | @"dotted" | @"dashed"
+NSString *const RCTCustomDecorationAttributeName = @"RCTCustomDecoration";
+
 /*
  * Creates `NSTextAttributes` from given `facebook::react::TextAttributes`
  */

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

@@ -18,6 +18,23 @@
 
 using namespace facebook::react;
 
+inline static TextAlignment RCTResolveTextAlignment(TextAlignment textAlignment, LayoutDirection layoutDirection)
+{
+  const bool isRTL = layoutDirection == LayoutDirection::RightToLeft;
+  switch (textAlignment) {
+    case TextAlignment::Start:
+      return isRTL ? TextAlignment::Right : TextAlignment::Left;
+    case TextAlignment::End:
+      return isRTL ? TextAlignment::Left : TextAlignment::Right;
+    case TextAlignment::Right:
+      return isRTL ? TextAlignment::Left : TextAlignment::Right;
+    case TextAlignment::Left:
+      return isRTL ? TextAlignment::Right : TextAlignment::Left;
+    default:
+      return textAlignment;
+  }
+}
+
 inline static UIFontWeight RCTUIFontWeightFromInteger(NSInteger fontWeight)
 {
   assert(fontWeight > 50);
@@ -196,14 +213,9 @@ NSMutableDictionary<NSAttributedStringKey, id> *RCTNSTextAttributesFromTextAttri
   NSMutableParagraphStyle *paragraphStyle = [NSMutableParagraphStyle new];
   BOOL isParagraphStyleUsed = NO;
   if (textAttributes.alignment.has_value()) {
-    TextAlignment textAlignment = textAttributes.alignment.value_or(TextAlignment::Natural);
-    if (textAttributes.layoutDirection.value_or(LayoutDirection::LeftToRight) == LayoutDirection::RightToLeft) {
-      if (textAlignment == TextAlignment::Right) {
-        textAlignment = TextAlignment::Left;
-      } else if (textAlignment == TextAlignment::Left) {
-        textAlignment = TextAlignment::Right;
-      }
-    }
+    TextAlignment textAlignment = RCTResolveTextAlignment(
+        textAttributes.alignment.value_or(TextAlignment::Natural),
+        textAttributes.layoutDirection.value_or(LayoutDirection::LeftToRight));
 
     paragraphStyle.alignment = RCTNSTextAlignmentFromTextAlignment(textAlignment);
     isParagraphStyleUsed = YES;
@@ -240,29 +252,56 @@ NSMutableDictionary<NSAttributedStringKey, id> *RCTNSTextAttributesFromTextAttri
   // Decoration
   if (textAttributes.textDecorationLineType.value_or(TextDecorationLineType::None) != TextDecorationLineType::None) {
     auto textDecorationLineType = textAttributes.textDecorationLineType.value();
-
-    NSUnderlineStyle style = RCTNSUnderlineStyleFromTextDecorationStyle(
-        textAttributes.textDecorationStyle.value_or(TextDecorationStyle::Solid));
-
+    auto textDecorationStyleValue = textAttributes.textDecorationStyle.value_or(TextDecorationStyle::Solid);
     UIColor *textDecorationColor = RCTUIColorFromSharedColor(textAttributes.textDecorationColor);
 
-    // Underline
-    if (textDecorationLineType == TextDecorationLineType::Underline ||
-        textDecorationLineType == TextDecorationLineType::UnderlineStrikethrough) {
-      attributes[NSUnderlineStyleAttributeName] = @(style);
+    // Custom drawing for styles UIKit can't render faithfully: wavy (no
+    // native value), and dotted/dashed (UIKit's pattern bits don't match
+    // browser geometry). The other styles continue to use NSUnderlineStyle.
+    bool needsCustomDrawing = textDecorationStyleValue == TextDecorationStyle::Wavy ||
+        textDecorationStyleValue == TextDecorationStyle::Dotted ||
+        textDecorationStyleValue == TextDecorationStyle::Dashed;
+    if (needsCustomDrawing) {
+      UIColor *strokeColor = (textDecorationColor != nil) ? textDecorationColor
+                                                          : RCTUIColorFromSharedColor(textAttributes.foregroundColor);
+      NSMutableArray<NSString *> *lines = [NSMutableArray array];
+      if (textDecorationLineType == TextDecorationLineType::Underline ||
+          textDecorationLineType == TextDecorationLineType::UnderlineStrikethrough) {
+        [lines addObject:@"underline"];
+      }
+      if (textDecorationLineType == TextDecorationLineType::Strikethrough ||
+          textDecorationLineType == TextDecorationLineType::UnderlineStrikethrough) {
+        [lines addObject:@"line-through"];
+      }
+      NSString *styleKey = textDecorationStyleValue == TextDecorationStyle::Wavy
+          ? @"wavy"
+          : (textDecorationStyleValue == TextDecorationStyle::Dotted ? @"dotted" : @"dashed");
+      attributes[RCTCustomDecorationAttributeName] = @{
+        @"lines" : lines,
+        @"color" : (strokeColor != nil) ? strokeColor : [UIColor labelColor],
+        @"style" : styleKey
+      };
+    } else {
+      NSUnderlineStyle style = RCTNSUnderlineStyleFromTextDecorationStyle(textDecorationStyleValue);
+
+      // Underline
+      if (textDecorationLineType == TextDecorationLineType::Underline ||
+          textDecorationLineType == TextDecorationLineType::UnderlineStrikethrough) {
+        attributes[NSUnderlineStyleAttributeName] = @(style);
 
-      if (textDecorationColor) {
-        attributes[NSUnderlineColorAttributeName] = textDecorationColor;
+        if (textDecorationColor != nil) {
+          attributes[NSUnderlineColorAttributeName] = textDecorationColor;
+        }
       }
-    }
 
-    // Strikethrough
-    if (textDecorationLineType == TextDecorationLineType::Strikethrough ||
-        textDecorationLineType == TextDecorationLineType::UnderlineStrikethrough) {
-      attributes[NSStrikethroughStyleAttributeName] = @(style);
+      // Strikethrough
+      if (textDecorationLineType == TextDecorationLineType::Strikethrough ||
+          textDecorationLineType == TextDecorationLineType::UnderlineStrikethrough) {
+        attributes[NSStrikethroughStyleAttributeName] = @(style);
 
-      if (textDecorationColor) {
-        attributes[NSStrikethroughColorAttributeName] = textDecorationColor;
+        if (textDecorationColor != nil) {
+          attributes[NSStrikethroughColorAttributeName] = textDecorationColor;
+        }
       }
     }
   }
@@ -330,7 +369,7 @@ static void RCTApplyBaselineOffsetForRange(NSMutableAttributedString *attributed
                             maximumFontLineHeight = MAX(font.lineHeight, maximumFontLineHeight);
                           }];
 
-  if (maximumLineHeight < maximumFontLineHeight) {
+  if (maximumLineHeight < maximumFontLineHeight && !ReactNativeFeatureFlags::enableIOSCompressedTextFrameAdjustment()) {
     return;
   }
 

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

@@ -7,6 +7,8 @@
 
 #import "RCTTextLayoutManager.h"
 
+#import <array>
+
 #import "RCTAttributedTextUtils.h"
 
 #import <React/NSTextStorage+FontScaling.h>
@@ -66,6 +68,64 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
                        layoutConstraints:layoutConstraints];
 }
 
+- (CGRect)drawingFrameForAttributedString:(AttributedString)attributedString
+                      paragraphAttributes:(ParagraphAttributes)paragraphAttributes
+                                    frame:(CGRect)frame
+                           containerFrame:(CGRect *)containerFrame
+{
+  if (containerFrame != nullptr) {
+    *containerFrame = frame;
+  }
+
+  if (!ReactNativeFeatureFlags::enableIOSCompressedTextFrameAdjustment()) {
+    return frame;
+  }
+
+  NSTextStorage *textStorage = [self
+      _textStorageAndLayoutManagerWithAttributesString:[self _nsAttributedStringFromAttributedString:attributedString]
+                                   paragraphAttributes:paragraphAttributes
+                                                  size:frame.size];
+  NSLayoutManager *layoutManager = textStorage.layoutManagers.firstObject;
+  NSTextContainer *textContainer = layoutManager.textContainers.firstObject;
+  [layoutManager ensureLayoutForTextContainer:textContainer];
+
+  NSRange glyphRange = [layoutManager glyphRangeForTextContainer:textContainer];
+  [self processTruncatedAttributedText:textStorage textContainer:textContainer layoutManager:layoutManager];
+
+  __block CGFloat maximumLineHeight = 0;
+  [textStorage enumerateAttribute:NSParagraphStyleAttributeName
+                          inRange:NSMakeRange(0, textStorage.length)
+                          options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                       usingBlock:^(NSParagraphStyle *paragraphStyle, __unused NSRange range, __unused BOOL *stop) {
+                         if (paragraphStyle != nil) {
+                           maximumLineHeight = MAX(paragraphStyle.maximumLineHeight, maximumLineHeight);
+                         }
+                       }];
+  if (maximumLineHeight == 0 || glyphRange.length == 0) {
+    return frame;
+  }
+
+  CGRect glyphBounds = [layoutManager boundingRectForGlyphRange:glyphRange inTextContainer:textContainer];
+  CGFloat glyphHeight = CGRectGetMaxY(glyphBounds) - MIN(glyphBounds.origin.y, 0);
+  CGFloat drawingHeight = MAX(frame.size.height, glyphHeight);
+  CGFloat extraHeight = drawingHeight - frame.size.height;
+
+  CGRect localContainerFrame = frame;
+  localContainerFrame.origin.y -= extraHeight / 2.0;
+  localContainerFrame.size.height = drawingHeight;
+  if (containerFrame != nullptr) {
+    *containerFrame = localContainerFrame;
+  }
+
+  CGRect drawingFrame = frame;
+  drawingFrame.size.height = drawingHeight;
+  drawingFrame.origin.y = localContainerFrame.origin.y;
+  if (glyphBounds.origin.y < 0) {
+    drawingFrame.origin.y += (drawingHeight - glyphBounds.size.height) / 2.0 - glyphBounds.origin.y;
+  }
+  return drawingFrame;
+}
+
 - (void)drawAttributedString:(AttributedString)attributedString
          paragraphAttributes:(ParagraphAttributes)paragraphAttributes
                        frame:(CGRect)frame
@@ -95,6 +155,137 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
   CGContextRestoreGState(context);
 #endif
 
+  // Custom decoration pass: enumerate `RCTCustomDecorationAttributeName`
+  // ranges and paint each one ourselves. Covers wavy (no UIKit equivalent),
+  // dotted, and dashed (UIKit's pattern bits don't match browser geometry).
+  {
+    CGContextRef ctx = UIGraphicsGetCurrentContext();
+    if (ctx != nullptr) {
+      NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphRange actualGlyphRange:nullptr];
+      [textStorage
+          enumerateAttribute:RCTCustomDecorationAttributeName
+                     inRange:charRange
+                     options:0
+                  usingBlock:^(NSDictionary *_Nullable attrs, NSRange attrRange, __unused BOOL *stop) {
+                    if (attrs == nil) {
+                      return;
+                    }
+                    NSArray<NSString *> *lines = attrs[@"lines"];
+                    UIColor *strokeColor = attrs[@"color"];
+                    NSString *style = attrs[@"style"];
+                    UIFont *font = [textStorage attribute:NSFontAttributeName
+                                                  atIndex:attrRange.location
+                                           effectiveRange:nullptr];
+                    if (font == nil || strokeColor == nil || style == nil) {
+                      return;
+                    }
+
+                    CGFloat fontSize = font.pointSize;
+                    // Thickness scales with the type size so the decoration
+                    // remains visible at small sizes and proportionate at
+                    // large ones. ~`fontSize / 12` plus a 1.5pt floor.
+                    CGFloat thickness = MAX(fontSize / 12.0f, 1.5f);
+                    CGFloat wavyWavelength = 1.0f + 2.0f * round(2.0f * thickness + 0.5f);
+                    CGFloat wavyCpDistance = 0.5f + round(3.0f * thickness + 0.5f);
+
+                    NSRange targetGlyphRange = [layoutManager glyphRangeForCharacterRange:attrRange
+                                                                     actualCharacterRange:nullptr];
+
+                    CGContextSaveGState(ctx);
+                    CGContextSetStrokeColorWithColor(ctx, strokeColor.CGColor);
+                    CGContextSetLineWidth(ctx, thickness);
+                    CGContextSetShouldAntialias(ctx, YES);
+
+                    if ([style isEqualToString:@"dotted"]) {
+                      const std::array<CGFloat, 2> dotIntervals = {0.0f, thickness * 2.0f};
+                      CGContextSetLineDash(ctx, 0, dotIntervals.data(), dotIntervals.size());
+                      CGContextSetLineCap(ctx, kCGLineCapRound);
+                    } else if ([style isEqualToString:@"dashed"]) {
+                      const std::array<CGFloat, 2> dashIntervals = {thickness * 2.0f, thickness};
+                      CGContextSetLineDash(ctx, 0, dashIntervals.data(), dashIntervals.size());
+                      CGContextSetLineCap(ctx, kCGLineCapButt);
+                    } else {
+                      CGContextSetLineCap(ctx, kCGLineCapRound);
+                    }
+
+                    [layoutManager
+                        enumerateLineFragmentsForGlyphRange:targetGlyphRange
+                                                 usingBlock:^(
+                                                     CGRect lineRect,
+                                                     __unused CGRect usedRect,
+                                                     NSTextContainer *_Nonnull container,
+                                                     NSRange lineGlyphRange,
+                                                     __unused BOOL *_Nonnull innerStop) {
+                                                   NSRange intersection =
+                                                       NSIntersectionRange(targetGlyphRange, lineGlyphRange);
+                                                   if (intersection.length == 0) {
+                                                     return;
+                                                   }
+                                                   CGRect firstGlyphRect = [layoutManager
+                                                       boundingRectForGlyphRange:NSMakeRange(intersection.location, 1)
+                                                                 inTextContainer:container];
+                                                   CGRect lastGlyphRect = [layoutManager
+                                                       boundingRectForGlyphRange:NSMakeRange(
+                                                                                     NSMaxRange(intersection) - 1, 1)
+                                                                 inTextContainer:container];
+                                                   CGFloat x1 = firstGlyphRect.origin.x + frame.origin.x;
+                                                   CGFloat x2 = CGRectGetMaxX(lastGlyphRect) + frame.origin.x;
+                                                   CGFloat baseline =
+                                                       lineRect.origin.y + font.ascender + frame.origin.y;
+
+                                                   // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+                                                   for (NSString *line in lines) {
+                                                     CGFloat y = 0.0f;
+                                                     if ([line isEqualToString:@"underline"]) {
+                                                       if ([style isEqualToString:@"wavy"]) {
+                                                         y = baseline + 1.0f;
+                                                       } else {
+                                                         y = baseline + thickness + 1.0f;
+                                                       }
+                                                     } else {
+                                                       y = baseline - (font.ascender + font.descender) / 2.0f + 1.0f;
+                                                     }
+                                                     if ([style isEqualToString:@"wavy"]) {
+                                                       CGContextSaveGState(ctx);
+                                                       CGContextClipToRect(
+                                                           ctx,
+                                                           CGRectMake(
+                                                               x1,
+                                                               y - wavyCpDistance - thickness,
+                                                               x2 - x1,
+                                                               2 * wavyCpDistance + 2 * thickness));
+                                                       CGContextBeginPath(ctx);
+                                                       CGContextMoveToPoint(ctx, x1, y);
+                                                       CGFloat step = wavyWavelength / 2.0f;
+                                                       CGFloat wx = x1;
+                                                       while (wx < x2) {
+                                                         CGFloat midX = wx + step;
+                                                         CGContextAddCurveToPoint(
+                                                             ctx,
+                                                             midX,
+                                                             y + wavyCpDistance,
+                                                             midX,
+                                                             y - wavyCpDistance,
+                                                             wx + wavyWavelength,
+                                                             y);
+                                                         wx += wavyWavelength;
+                                                       }
+                                                       CGContextStrokePath(ctx);
+                                                       CGContextRestoreGState(ctx);
+                                                     } else {
+                                                       CGContextBeginPath(ctx);
+                                                       CGContextMoveToPoint(ctx, x1, y);
+                                                       CGContextAddLineToPoint(ctx, x2, y);
+                                                       CGContextStrokePath(ctx);
+                                                     }
+                                                   }
+                                                 }];
+
+                    CGContextRestoreGState(ctx);
+                  }];
+    }
+  }
+
   if (block != nil) {
     __block UIBezierPath *highlightPath = nil;
     NSRange characterRange = [layoutManager characterRangeForGlyphRange:glyphRange actualGlyphRange:NULL];
@@ -371,7 +562,8 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
                                  }
                                }];
 
-  CGSize size = [layoutManager usedRectForTextContainer:textContainer].size;
+  CGRect usedBounds = [layoutManager usedRectForTextContainer:textContainer];
+  CGSize size = usedBounds.size;
 
   if (textDidWrap) {
     size.width = textContainer.size.width;

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

@@ -24,6 +24,10 @@ inline static NSTextAlignment RCTNSTextAlignmentFromTextAlignment(facebook::reac
       return NSTextAlignmentCenter;
     case facebook::react::TextAlignment::Justified:
       return NSTextAlignmentJustified;
+    case facebook::react::TextAlignment::Start:
+      return NSTextAlignmentNatural;
+    case facebook::react::TextAlignment::End:
+      return NSTextAlignmentRight;
   }
 }
 
@@ -106,10 +110,18 @@ inline static NSUnderlineStyle RCTNSUnderlineStyleFromTextDecorationStyle(
       return NSUnderlineStyleSingle;
     case facebook::react::TextDecorationStyle::Double:
       return NSUnderlineStyleDouble;
+    // Dotted, dashed, and wavy are tagged with
+    // `RCTCustomDecorationAttributeName` in `RCTAttributedTextUtils.mm` and
+    // painted by `RCTTextLayoutManager.mm`'s drawing pass; UIKit's pattern
+    // bits don't match the geometry browsers use, and there is no native
+    // wavy value at all. These branches are unreachable in normal flow; the
+    // returned values keep the switch exhaustive.
     case facebook::react::TextDecorationStyle::Dashed:
-      return NSUnderlineStylePatternDash | NSUnderlineStyleSingle;
+      return NSUnderlineStyleSingle;
     case facebook::react::TextDecorationStyle::Dotted:
-      return NSUnderlineStylePatternDot | NSUnderlineStyleSingle;
+      return NSUnderlineStyleSingle;
+    case facebook::react::TextDecorationStyle::Wavy:
+      return NSUnderlineStyleSingle;
   }
 }
 

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

@@ -43,7 +43,8 @@ TextMeasurement TextLayoutManager::measure(
       measurement = textMeasureCache_.get(
           {.attributedString = attributedString,
            .paragraphAttributes = paragraphAttributes,
-           .layoutConstraints = layoutConstraints},
+           .layoutConstraints = layoutConstraints,
+           .pointScaleFactor = layoutContext.pointScaleFactor},
           [&]() {
             auto telemetry = TransactionTelemetry::threadLocalTelemetry();
             if (telemetry) {

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

@@ -5,14 +5,95 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <memory>
-
 #include <gtest/gtest.h>
 
-#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+#include <react/renderer/textlayoutmanager/TextMeasureCache.h>
 
 using namespace facebook::react;
 
-TEST(TextLayoutManagerTest, testSomething) {
-  // TODO:
+TEST(TextLayoutManagerTest, defaultTextAttributesAreLayoutEquivalent) {
+  TextAttributes lhs;
+  TextAttributes rhs;
+
+  EXPECT_TRUE(areTextAttributesEquivalentLayoutWise(lhs, rhs));
+  EXPECT_EQ(
+      textAttributesHashLayoutWise(lhs), textAttributesHashLayoutWise(rhs));
+}
+
+TEST(TextLayoutManagerTest, maxFontSizeMultiplierAffectsLayoutCacheEquality) {
+  TextAttributes lhs;
+  TextAttributes rhs;
+
+  lhs.fontSize = rhs.fontSize = 16;
+  lhs.fontSizeMultiplier = rhs.fontSizeMultiplier = 2;
+  lhs.maxFontSizeMultiplier = 1;
+  rhs.maxFontSizeMultiplier = 2;
+
+  EXPECT_FALSE(areTextAttributesEquivalentLayoutWise(lhs, rhs));
+}
+
+TEST(TextLayoutManagerTest, maxFontSizeMultiplierAffectsLayoutCacheHash) {
+  TextAttributes lhs;
+  TextAttributes rhs;
+
+  lhs.fontSize = rhs.fontSize = 16;
+  lhs.fontSizeMultiplier = rhs.fontSizeMultiplier = 2;
+  lhs.maxFontSizeMultiplier = 1;
+  rhs.maxFontSizeMultiplier = 2;
+
+  EXPECT_NE(
+      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.
+TEST(TextLayoutManagerTest, pointScaleFactorAffectsTextMeasureCacheEquality) {
+  TextMeasureCacheKey lhs;
+  TextMeasureCacheKey rhs;
+
+  lhs.pointScaleFactor = 2.0;
+  rhs.pointScaleFactor = 1.6;
+  EXPECT_FALSE(lhs == rhs);
+
+  rhs.pointScaleFactor = 2.0;
+  EXPECT_TRUE(lhs == rhs);
+}
+
+TEST(TextLayoutManagerTest, pointScaleFactorAffectsTextMeasureCacheHash) {
+  TextMeasureCacheKey lhs;
+  TextMeasureCacheKey rhs;
+
+  lhs.pointScaleFactor = 2.0;
+  rhs.pointScaleFactor = 1.6;
+
+  EXPECT_NE(
+      std::hash<TextMeasureCacheKey>{}(lhs),
+      std::hash<TextMeasureCacheKey>{}(rhs));
+}
+
+// Same invariant for the prepared-text cache: a prepared layout is pixel-grid
+// rounded and is only reusable at the pixel scale factor it was prepared at.
+TEST(TextLayoutManagerTest, pointScaleFactorAffectsPreparedTextCacheEquality) {
+  PreparedTextCacheKey lhs;
+  PreparedTextCacheKey rhs;
+
+  lhs.pointScaleFactor = 2.0;
+  rhs.pointScaleFactor = 1.6;
+  EXPECT_FALSE(lhs == rhs);
+
+  rhs.pointScaleFactor = 2.0;
+  EXPECT_TRUE(lhs == rhs);
+}
+
+TEST(TextLayoutManagerTest, pointScaleFactorAffectsPreparedTextCacheHash) {
+  PreparedTextCacheKey lhs;
+  PreparedTextCacheKey rhs;
+
+  lhs.pointScaleFactor = 2.0;
+  rhs.pointScaleFactor = 1.6;
+
+  EXPECT_NE(
+      std::hash<PreparedTextCacheKey>{}(lhs),
+      std::hash<PreparedTextCacheKey>{}(rhs));
 }