react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/ios/utils/ENRMSpoilerOverlayView.h

@@ -0,0 +1,49 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import "StyleConfig.h"
+
+typedef NS_ENUM(NSInteger, ENRMSpoilerOverlay) {
+  ENRMSpoilerOverlayParticles = 0,
+  ENRMSpoilerOverlaySolid,
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ENRMSpoilerOverlay ENRMSpoilerOverlayFromString(NSString *_Nullable string);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+#if !TARGET_OS_OSX
+@interface ENRMSpoilerOverlayView : UIView
+#else
+@interface ENRMSpoilerOverlayView : NSView
+#endif
+
+@property (nonatomic, readonly) NSRange charRange;
+@property (nonatomic, readonly) BOOL revealing;
+
+- (instancetype)initWithCharRange:(NSRange)charRange;
+
+- (CGColorRef)resolveBackgroundCGColor;
+
+- (void)animateRevealWithCompletion:(nullable dispatch_block_t)completion;
+
+#pragma mark - Subclass hooks
+
+- (void)didAttachToSuperview;
+- (void)didLayoutOverlay;
+- (void)prepareRevealAnimation;
+
++ (ENRMSpoilerOverlayView *)overlayWithMode:(ENRMSpoilerOverlay)mode
+                                     config:(StyleConfig *)config
+                                  charRange:(NSRange)charRange;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMSpoilerOverlayView.m

@@ -0,0 +1,144 @@
+#import "ENRMSpoilerOverlayView.h"
+#import "ENRMParticleOverlayView.h"
+#import "ENRMSolidOverlayView.h"
+#import <QuartzCore/QuartzCore.h>
+
+static const NSTimeInterval kRevealDuration = 0.45;
+
+ENRMSpoilerOverlay ENRMSpoilerOverlayFromString(NSString *string)
+{
+  if ([string isEqualToString:@"solid"]) {
+    return ENRMSpoilerOverlaySolid;
+  }
+  return ENRMSpoilerOverlayParticles;
+}
+
+@implementation ENRMSpoilerOverlayView
+
+- (instancetype)initWithCharRange:(NSRange)charRange
+{
+  if (self = [super initWithFrame:CGRectZero]) {
+    _charRange = charRange;
+    _revealing = NO;
+#if !TARGET_OS_OSX
+    self.userInteractionEnabled = NO;
+    self.clipsToBounds = YES;
+#else
+    self.wantsLayer = YES;
+    self.layer.masksToBounds = YES;
+#endif
+  }
+  return self;
+}
+
+#pragma mark - Background helper
+
+- (CGColorRef)resolveBackgroundCGColor
+{
+#if !TARGET_OS_OSX
+  for (UIView *view = self.superview; view; view = view.superview) {
+    CGColorRef color = view.backgroundColor.CGColor;
+    if (color && CGColorGetAlpha(color) > 0)
+      return color;
+  }
+  return [UIColor whiteColor].CGColor;
+#else
+  for (NSView *view = self.superview; view; view = view.superview) {
+    CGColorRef color = view.layer.backgroundColor;
+    if (color && CGColorGetAlpha(color) > 0)
+      return color;
+  }
+  return [NSColor whiteColor].CGColor;
+#endif
+}
+
+#pragma mark - Lifecycle → subclass hooks
+
+#if !TARGET_OS_OSX
+- (void)didMoveToSuperview
+{
+  [super didMoveToSuperview];
+  if (self.superview)
+    [self didAttachToSuperview];
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  [self didLayoutOverlay];
+}
+#else
+- (void)viewDidMoveToSuperview
+{
+  [super viewDidMoveToSuperview];
+  if (self.superview)
+    [self didAttachToSuperview];
+}
+
+- (void)layout
+{
+  [super layout];
+  [self didLayoutOverlay];
+}
+#endif
+
+#pragma mark - Subclass hooks (no-op defaults)
+
+- (void)didAttachToSuperview
+{
+}
+
+- (void)didLayoutOverlay
+{
+}
+
+- (void)prepareRevealAnimation
+{
+}
+
+#pragma mark - Reveal animation
+
+- (void)animateRevealWithCompletion:(dispatch_block_t)completion
+{
+  if (_revealing)
+    return;
+  _revealing = YES;
+
+  [self prepareRevealAnimation];
+
+  __weak typeof(self) weakSelf = self;
+  [CATransaction begin];
+  [CATransaction setCompletionBlock:^{
+    if (completion)
+      completion();
+    [weakSelf removeFromSuperview];
+  }];
+
+  CABasicAnimation *fade = [CABasicAnimation animationWithKeyPath:@"opacity"];
+  fade.fromValue = @1.0;
+  fade.toValue = @0.0;
+  fade.duration = kRevealDuration;
+  fade.timingFunction = [CAMediaTimingFunction functionWithControlPoints:0.0:0.0:0.58:1.0];
+  fade.fillMode = kCAFillModeForwards;
+  fade.removedOnCompletion = NO;
+  [self.layer addAnimation:fade forKey:@"fadeOut"];
+
+  [CATransaction commit];
+}
+
+#pragma mark - Factory
+
++ (ENRMSpoilerOverlayView *)overlayWithMode:(ENRMSpoilerOverlay)mode
+                                     config:(StyleConfig *)config
+                                  charRange:(NSRange)charRange
+{
+  switch (mode) {
+    case ENRMSpoilerOverlaySolid:
+      return [[ENRMSolidOverlayView alloc] initWithConfig:config charRange:charRange];
+    case ENRMSpoilerOverlayParticles:
+    default:
+      return [[ENRMParticleOverlayView alloc] initWithConfig:config charRange:charRange];
+  }
+}
+
+@end

package/ios/utils/ENRMSpoilerTapUtils.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#import "ENRMUIKit.h"
+
+@class ENRMSpoilerOverlayManager;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern NSString *const SpoilerAttributeName;
+extern NSString *const SpoilerOriginalColorAttributeName;
+
+BOOL handleSpoilerTap(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer,
+                      ENRMSpoilerOverlayManager *spoilerManager);
+
+void ENRMRestoreSpoilerTextColors(NSTextStorage *textStorage, NSRange range);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMSpoilerTapUtils.m

@@ -0,0 +1,68 @@
+#import "ENRMSpoilerTapUtils.h"
+#import "ENRMSpoilerOverlayManager.h"
+#import "ENRMTextHitTest.h"
+
+NSString *const SpoilerAttributeName = @"Spoiler";
+NSString *const SpoilerOriginalColorAttributeName = @"SpoilerOriginalColor";
+
+// Expands outward because internal formatting can split the attribute into multiple runs.
+static NSRange expandSpoilerRange(NSTextStorage *textStorage, NSUInteger index)
+{
+  NSRange run;
+  [textStorage attribute:SpoilerAttributeName atIndex:index effectiveRange:&run];
+
+  NSUInteger start = run.location;
+  NSUInteger end = NSMaxRange(run);
+  NSUInteger length = textStorage.length;
+
+  while (start > 0) {
+    if (![textStorage attribute:SpoilerAttributeName atIndex:start - 1 effectiveRange:&run])
+      break;
+    start = run.location;
+  }
+
+  while (end < length) {
+    if (![textStorage attribute:SpoilerAttributeName atIndex:end effectiveRange:&run])
+      break;
+    end = NSMaxRange(run);
+  }
+
+  return NSMakeRange(start, end - start);
+}
+
+void ENRMRestoreSpoilerTextColors(NSTextStorage *textStorage, NSRange range)
+{
+  [textStorage beginEditing];
+  [textStorage enumerateAttribute:SpoilerOriginalColorAttributeName
+                          inRange:range
+                          options:0
+                       usingBlock:^(id value, NSRange subRange, BOOL *stop) {
+                         if (value) {
+                           [textStorage addAttribute:NSForegroundColorAttributeName value:value range:subRange];
+                           [textStorage removeAttribute:SpoilerOriginalColorAttributeName range:subRange];
+                         }
+                       }];
+  [textStorage endEditing];
+}
+
+BOOL handleSpoilerTap(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer,
+                      ENRMSpoilerOverlayManager *spoilerManager)
+{
+  NSUInteger characterIndex = ENRMCharacterIndexForTap(textView, recognizer);
+  if (characterIndex == NSNotFound)
+    return NO;
+
+  NSTextStorage *textStorage = textView.textStorage;
+  if (![textStorage attribute:SpoilerAttributeName atIndex:characterIndex effectiveRange:NULL])
+    return NO;
+
+  NSRange fullRange = expandSpoilerRange(textStorage, characterIndex);
+
+  [textStorage beginEditing];
+  [textStorage removeAttribute:SpoilerAttributeName range:fullRange];
+  ENRMRestoreSpoilerTextColors(textStorage, fullRange);
+  [textStorage endEditing];
+
+  [spoilerManager removeOverlaysForCharRange:fullRange];
+  return YES;
+}

package/ios/utils/ENRMTailFadeInAnimator.h

@@ -0,0 +1,16 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import "LinkTapUtils.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMTailFadeInAnimator : NSObject
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView;
+
+- (void)animateFrom:(NSUInteger)tailStart to:(NSUInteger)tailEnd;
+- (void)cancel;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMTailFadeInAnimator.m

@@ -0,0 +1,161 @@
+#import "ENRMTailFadeInAnimator.h"
+#import "LinkTapUtils.h"
+#import <QuartzCore/QuartzCore.h>
+#include <TargetConditionals.h>
+
+static const NSTimeInterval kFadeDuration = 0.20;
+
+typedef struct {
+  NSRange range;
+  __unsafe_unretained RCTUIColor *color;
+} ENRMColorEntry;
+
+@implementation ENRMTailFadeInAnimator {
+  __weak ENRMPlatformTextView *_textView;
+#if !TARGET_OS_OSX
+  CADisplayLink *_displayLink;
+#endif
+  CFTimeInterval _startTime;
+
+  NSArray<RCTUIColor *> *_retainedColors;
+  ENRMColorEntry *_colorEntries;
+  NSUInteger _entriesCount;
+}
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView
+{
+  self = [super init];
+  if (self) {
+    _textView = textView;
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+#if !TARGET_OS_OSX
+  [_displayLink invalidate];
+  _displayLink = nil;
+#endif
+  [self cleanupEntries];
+}
+
+- (void)animateFrom:(NSUInteger)tailStart to:(NSUInteger)tailEnd
+{
+  [self cancel];
+
+  NSTextStorage *storage = _textView.textStorage;
+  if (!storage || tailEnd <= tailStart || tailEnd > storage.length)
+    return;
+
+#if !TARGET_OS_OSX
+  if (UIAccessibilityIsReduceMotionEnabled()) {
+    return;
+  }
+#endif
+
+  NSRange range = NSMakeRange(tailStart, tailEnd - tailStart);
+
+  [self snapshotColorsInRange:range storage:storage];
+  [self updateAlpha:0.0];
+
+#if !TARGET_OS_OSX
+  _startTime = CACurrentMediaTime();
+  _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(step:)];
+  // 0 tells the system to use the display's maximum frame rate — 60 Hz on standard displays and 120 Hz on ProMotion ones
+  _displayLink.preferredFramesPerSecond = 0;
+  [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+#else
+  // TODO: Implement the tail fade-in animation on macOS.
+  // CADisplayLink doesn't exist on macOS; the equivalent is CVDisplayLink (Core Video)
+  // or an NSTimer driven at the display refresh rate. The iOS step:/eased-progress
+  // logic below can be reused directly once a display-sync callback is wired up.
+  // TODO: When this is implemented, gate it on
+  // NSWorkspace.sharedWorkspace.accessibilityDisplayShouldReduceMotion so macOS
+  // users with Reduce Motion enabled also skip the fade.
+  [self updateAlpha:1.0];
+  [self cleanupEntries];
+#endif
+}
+
+#if !TARGET_OS_OSX
+- (void)step:(CADisplayLink *)link
+{
+  CFTimeInterval elapsed = CACurrentMediaTime() - _startTime;
+  CGFloat progress = fmin(elapsed / kFadeDuration, 1.0);
+
+  CGFloat eased = 1.0 - (1.0 - progress) * (1.0 - progress);
+
+  [self updateAlpha:eased];
+
+  if (progress >= 1.0) {
+    [self cancel];
+  }
+}
+#endif
+
+- (void)updateAlpha:(CGFloat)alpha
+{
+  NSTextStorage *storage = _textView.textStorage;
+  if (!storage || _entriesCount == 0)
+    return;
+
+  [storage beginEditing];
+  for (NSUInteger i = 0; i < _entriesCount; i++) {
+    ENRMColorEntry entry = _colorEntries[i];
+    if (NSMaxRange(entry.range) <= storage.length) {
+      RCTUIColor *fadedColor = [entry.color colorWithAlphaComponent:alpha];
+      [storage addAttribute:NSForegroundColorAttributeName value:fadedColor range:entry.range];
+    }
+  }
+  [storage endEditing];
+}
+
+- (void)snapshotColorsInRange:(NSRange)range storage:(NSTextStorage *)storage
+{
+  [self cleanupEntries];
+
+  NSMutableArray<RCTUIColor *> *colors = [NSMutableArray array];
+  NSMutableArray<NSValue *> *ranges = [NSMutableArray array];
+  [storage enumerateAttribute:NSForegroundColorAttributeName
+                      inRange:range
+                      options:0
+                   usingBlock:^(RCTUIColor *color, NSRange subRange, BOOL *stop) {
+                     [colors addObject:color ?: [RCTUIColor labelColor]];
+                     [ranges addObject:[NSValue valueWithRange:subRange]];
+                   }];
+
+  _entriesCount = colors.count;
+  _retainedColors = [colors copy];
+  _colorEntries = malloc(sizeof(ENRMColorEntry) * _entriesCount);
+
+  for (NSUInteger i = 0; i < _entriesCount; i++) {
+    _colorEntries[i].color = _retainedColors[i];
+    _colorEntries[i].range = [ranges[i] rangeValue];
+  }
+}
+
+- (void)cancel
+{
+#if !TARGET_OS_OSX
+  [_displayLink invalidate];
+  _displayLink = nil;
+#endif
+
+  if (_entriesCount > 0) {
+    [self updateAlpha:1.0];
+    [self cleanupEntries];
+  }
+}
+
+- (void)cleanupEntries
+{
+  if (_colorEntries) {
+    free(_colorEntries);
+    _colorEntries = NULL;
+  }
+  _retainedColors = nil;
+  _entriesCount = 0;
+}
+
+@end

package/ios/utils/ENRMTextHitTest.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Returns the character index in textView's text storage corresponding to
+/// the tap location, or NSNotFound if the point falls outside the text.
+NSUInteger ENRMCharacterIndexForTap(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer);
+
+/// Returns the character index in textView's text storage corresponding to
+/// the given point (in textView coordinates), or NSNotFound if out of range.
+NSUInteger ENRMCharacterIndexAtPoint(ENRMPlatformTextView *textView, CGPoint point);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMTextHitTest.m

@@ -0,0 +1,20 @@
+#import "ENRMTextHitTest.h"
+
+NSUInteger ENRMCharacterIndexAtPoint(ENRMPlatformTextView *textView, CGPoint point)
+{
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  CGPoint adjusted = CGPointMake(point.x - textView.textContainerInset.left, point.y - textView.textContainerInset.top);
+
+  NSUInteger index = [layoutManager characterIndexForPoint:adjusted
+                                           inTextContainer:textView.textContainer
+                  fractionOfDistanceBetweenInsertionPoints:NULL];
+
+  NSUInteger length = ENRMGetAttributedText(textView).length;
+  return index < length ? index : NSNotFound;
+}
+
+NSUInteger ENRMCharacterIndexForTap(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer)
+{
+  CGPoint location = [recognizer locationInView:textView];
+  return ENRMCharacterIndexAtPoint(textView, location);
+}

package/ios/utils/ENRMTextInteractionUtils.h

@@ -0,0 +1,20 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Resolves the link URL at the tap location.
+/// If a link is found, calls onLinkPress and returns YES.
+/// If no link is found, calls ENRMClearSelection and returns NO.
+BOOL ENRMHandleTapOnTextView(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer,
+                             void (^onLinkPress)(NSString *url));
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMTextInteractionUtils.m

@@ -0,0 +1,15 @@
+#import "ENRMTextInteractionUtils.h"
+#import "LinkTapUtils.h"
+
+BOOL ENRMHandleTapOnTextView(ENRMPlatformTextView *textView, ENRMTapRecognizer *recognizer,
+                             void (^onLinkPress)(NSString *url))
+{
+  NSString *url = linkURLAtTapLocation(textView, recognizer);
+  if (!url) {
+    ENRMClearSelection(textView);
+    return NO;
+  }
+  if (onLinkPress)
+    onLinkPress(url);
+  return YES;
+}

package/ios/utils/ENRMTextRenderer.h

@@ -0,0 +1,30 @@
+#pragma once
+#import <Foundation/Foundation.h>
+
+@class AccessibilityInfo;
+@class MarkdownASTNode;
+@class RenderContext;
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMRenderResult : NSObject
+@property (nonatomic, strong) NSMutableAttributedString *attributedText;
+@property (nonatomic, strong) RenderContext *context;
+@property (nonatomic, strong) AccessibilityInfo *accessibilityInfo;
+@property (nonatomic, assign) CGFloat lastElementMarginBottom;
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ENRMRenderResult *ENRMRenderASTNodes(NSArray<MarkdownASTNode *> *nodes, StyleConfig *config, BOOL allowTrailingMargin,
+                                     BOOL allowFontScaling, CGFloat maxFontSizeMultiplier,
+                                     NSLineBreakStrategy lineBreakStrategy);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMTextRenderer.m

@@ -0,0 +1,38 @@
+#import "ENRMTextRenderer.h"
+#import "AccessibilityInfo.h"
+#import "AttributedRenderer.h"
+#import "MarkdownASTNode.h"
+#import "ParagraphStyleUtils.h"
+#import "RenderContext.h"
+#import "StyleConfig.h"
+
+@implementation ENRMRenderResult
+@end
+
+ENRMRenderResult *ENRMRenderASTNodes(NSArray<MarkdownASTNode *> *nodes, StyleConfig *config, BOOL allowTrailingMargin,
+                                     BOOL allowFontScaling, CGFloat maxFontSizeMultiplier,
+                                     NSLineBreakStrategy lineBreakStrategy)
+{
+  MarkdownASTNode *root = [[MarkdownASTNode alloc] initWithType:MarkdownNodeTypeDocument];
+  for (MarkdownASTNode *node in nodes) {
+    [root addChild:node];
+  }
+
+  AttributedRenderer *renderer = [[AttributedRenderer alloc] initWithConfig:config];
+  [renderer setAllowTrailingMargin:allowTrailingMargin];
+
+  RenderContext *context = [RenderContext new];
+  context.allowFontScaling = allowFontScaling;
+  context.maxFontSizeMultiplier = maxFontSizeMultiplier;
+
+  NSMutableAttributedString *attributedText = [renderer renderRoot:root context:context];
+  [context applyLinkAttributesToString:attributedText];
+  ENRMApplyLineBreakStrategyToParagraphStyles(attributedText, lineBreakStrategy);
+
+  ENRMRenderResult *result = [[ENRMRenderResult alloc] init];
+  result.attributedText = attributedText;
+  result.context = context;
+  result.accessibilityInfo = [AccessibilityInfo infoFromContext:context];
+  result.lastElementMarginBottom = [renderer getLastElementMarginBottom];
+  return result;
+}

package/ios/utils/ENRMTextViewSetup.h

@@ -0,0 +1,78 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import "LastElementUtils.h"
+#import "StyleConfig.h"
+#import "TextViewLayoutManager.h"
+#import <React/RCTUtils.h>
+#import <objc/runtime.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+static inline void ENRMAttachLayoutManager(ENRMPlatformTextView *textView, StyleConfig *_Nullable config)
+{
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  if (layoutManager == nil) {
+    return;
+  }
+  layoutManager.allowsNonContiguousLayout = NO;
+  object_setClass(layoutManager, [TextViewLayoutManager class]);
+  if (config != nil) {
+    [layoutManager setValue:config forKey:@"config"];
+  }
+}
+
+static inline void ENRMDetachLayoutManager(ENRMPlatformTextView *textView)
+{
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  if (layoutManager != nil && [object_getClass(layoutManager) isEqual:[TextViewLayoutManager class]]) {
+    [layoutManager setValue:nil forKey:@"config"];
+    object_setClass(layoutManager, [NSLayoutManager class]);
+  }
+}
+
+static inline CGSize ENRMMeasureMarkdownText(ENRMPlatformTextView *textView, CGFloat maxWidth, StyleConfig *config,
+                                             BOOL allowTrailingMargin, CGFloat lastElementMarginBottom)
+{
+  NSAttributedString *text = ENRMGetAttributedText(textView);
+  if (text.length == 0) {
+    return CGSizeZero;
+  }
+
+  ENRMTextLayoutResult layout = ENRMMeasureTextLayout(textView, maxWidth);
+
+  CGFloat measuredWidth = layout.usedRect.size.width;
+  CGFloat measuredHeight = layout.usedRect.size.height;
+
+  // Detect multiline content by checking if the layout produced more than one
+  // line fragment. When text wraps, returning the tight usedRect width lets
+  // flexShrink narrow the view below maxWidth, causing re-wrap at the narrower
+  // width and a height mismatch. Pin to maxWidth for multiline content so Yoga
+  // assigns the width the text was actually measured at. Single-line content
+  // keeps its tight width for shrink-to-fit behavior.
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  NSUInteger glyphCount = [layoutManager numberOfGlyphs];
+  if (glyphCount > 0) {
+    NSRange firstLineRange;
+    [layoutManager lineFragmentRectForGlyphAtIndex:0 effectiveRange:&firstLineRange];
+    if (NSMaxRange(firstLineRange) < glyphCount) {
+      measuredWidth = maxWidth;
+    }
+  }
+
+  if (!CGRectIsEmpty(layout.extraLineFragmentRect)) {
+    measuredHeight -= layout.extraLineFragmentRect.size.height;
+  }
+
+  if (isLastElementCodeBlock(text)) {
+    measuredHeight += [config codeBlockPadding];
+  }
+
+  if (allowTrailingMargin && lastElementMarginBottom > 0) {
+    measuredHeight += lastElementMarginBottom;
+  }
+
+  CGFloat scale = RCTScreenScale();
+  return CGSizeMake(ceil(measuredWidth * scale) / scale, ceil(measuredHeight * scale) / scale);
+}
+
+NS_ASSUME_NONNULL_END