react-native-enriched-markdown 0.1.0 → 0.2.0

package/ios/utils/AccessibilityInfo.h

@@ -0,0 +1,35 @@
+#import <Foundation/Foundation.h>
+
+@class RenderContext;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Container for accessibility-related data extracted from RenderContext.
+ * Used by MarkdownAccessibilityElementBuilder to build VoiceOver elements.
+ */
+@interface AccessibilityInfo : NSObject
+
+// Headings
+@property (nonatomic, copy, readonly) NSArray<NSValue *> *headingRanges;
+@property (nonatomic, copy, readonly) NSArray<NSNumber *> *headingLevels;
+
+// Links
+@property (nonatomic, copy, readonly) NSArray<NSValue *> *linkRanges;
+@property (nonatomic, copy, readonly) NSArray<NSString *> *linkURLs;
+
+// Images
+@property (nonatomic, copy, readonly) NSArray<NSValue *> *imageRanges;
+@property (nonatomic, copy, readonly) NSArray<NSString *> *imageAltTexts;
+
+// List items
+@property (nonatomic, copy, readonly) NSArray<NSValue *> *listItemRanges;
+@property (nonatomic, copy, readonly) NSArray<NSNumber *> *listItemPositions;
+@property (nonatomic, copy, readonly) NSArray<NSNumber *> *listItemDepths;
+@property (nonatomic, copy, readonly) NSArray<NSNumber *> *listItemOrdered; // YES = ordered, NO = bullet
+
++ (instancetype)infoFromContext:(RenderContext *)context;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/AccessibilityInfo.m

@@ -0,0 +1,24 @@
+#import "AccessibilityInfo.h"
+#import "RenderContext.h"
+
+@implementation AccessibilityInfo
+
++ (instancetype)infoFromContext:(RenderContext *)context
+{
+  AccessibilityInfo *info = [[AccessibilityInfo alloc] init];
+  if (info) {
+    info->_headingRanges = [context.headingRanges copy];
+    info->_headingLevels = [context.headingLevels copy];
+    info->_linkRanges = [context.linkRanges copy];
+    info->_linkURLs = [context.linkURLs copy];
+    info->_imageRanges = [context.imageRanges copy];
+    info->_imageAltTexts = [context.imageAltTexts copy];
+    info->_listItemRanges = [context.listItemRanges copy];
+    info->_listItemPositions = [context.listItemPositions copy];
+    info->_listItemDepths = [context.listItemDepths copy];
+    info->_listItemOrdered = [context.listItemOrdered copy];
+  }
+  return info;
+}
+
+@end

package/ios/utils/BlockquoteBorder.h

@@ -0,0 +1,20 @@
+#pragma once
+#import "StyleConfig.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+extern NSString *const BlockquoteDepthAttributeName;
+extern NSString *const BlockquoteBackgroundColorAttributeName;
+
+@interface BlockquoteBorder : NSObject
+
+- (instancetype)initWithConfig:(StyleConfig *)config;
+- (void)drawBordersForGlyphRange:(NSRange)glyphsToShow
+                   layoutManager:(NSLayoutManager *)layoutManager
+                   textContainer:(NSTextContainer *)textContainer
+                         atPoint:(CGPoint)origin;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/BlockquoteBorder.m

@@ -0,0 +1,92 @@
+#import "BlockquoteBorder.h"
+#import "StyleConfig.h"
+
+// Attribute constants for identifying blockquote segments in text storage
+NSString *const BlockquoteDepthAttributeName = @"BlockquoteDepth";
+NSString *const BlockquoteBackgroundColorAttributeName = @"BlockquoteBackgroundColor";
+
+@implementation BlockquoteBorder {
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  if (self = [super init]) {
+    _config = config;
+  }
+  return self;
+}
+
+/**
+ * Main drawing entry point called by the LayoutManager.
+ * Iterates through line fragments to draw backgrounds and borders for nested blockquotes.
+ */
+- (void)drawBordersForGlyphRange:(NSRange)glyphsToShow
+                   layoutManager:(NSLayoutManager *)layoutManager
+                   textContainer:(NSTextContainer *)textContainer
+                         atPoint:(CGPoint)origin
+{
+  NSTextStorage *textStorage = layoutManager.textStorage;
+  if (!textStorage || textStorage.length == 0) {
+    return;
+  }
+
+  // Cache configuration values to minimize pointer chasing and method lookups in the loop
+  StyleConfig *c = _config;
+  CGFloat borderWidth = c.blockquoteBorderWidth;
+  CGFloat gapWidth = c.blockquoteGapWidth;
+  CGFloat levelSpacing = borderWidth + gapWidth;
+  CGFloat containerWidth = textContainer.size.width;
+  UIColor *defaultBgColor = c.blockquoteBackgroundColor;
+  UIColor *borderColor = c.blockquoteBorderColor;
+
+  // Use a Bezier path to batch all vertical border rectangles into a single GPU draw call
+  UIBezierPath *borderPath = [UIBezierPath bezierPath];
+
+  [layoutManager
+      enumerateLineFragmentsForGlyphRange:glyphsToShow
+                               usingBlock:^(CGRect rect, CGRect usedRect, NSTextContainer *container,
+                                            NSRange glyphRange, BOOL *stop) {
+                                 // Map the glyph range back to character indices to retrieve attributes
+                                 NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphRange
+                                                                               actualGlyphRange:NULL];
+                                 if (charRange.location == NSNotFound || charRange.length == 0) {
+                                   return;
+                                 }
+
+                                 // Perform a single attribute lookup for the current line fragment
+                                 NSDictionary *attrs = [textStorage attributesAtIndex:charRange.location
+                                                                       effectiveRange:NULL];
+                                 NSNumber *depthNum = attrs[BlockquoteDepthAttributeName];
+
+                                 // If no depth is found, this fragment is not part of a blockquote
+                                 if (!depthNum) {
+                                   return;
+                                 }
+
+                                 NSInteger depth = [depthNum integerValue];
+                                 CGFloat baseY = origin.y + rect.origin.y;
+
+                                 // 1. Draw Background (Painter's algorithm: draw backgrounds before borders)
+                                 UIColor *bgColor = attrs[BlockquoteBackgroundColorAttributeName] ?: defaultBgColor;
+                                 if (bgColor && bgColor != [UIColor clearColor]) {
+                                   [bgColor setFill];
+                                   UIRectFill(CGRectMake(origin.x, baseY, containerWidth, rect.size.height));
+                                 }
+
+                                 // 2. Aggregate vertical borders into the batch path
+                                 for (NSInteger level = 0; level <= depth; level++) {
+                                   CGFloat borderX = origin.x + (levelSpacing * level);
+                                   CGRect borderRect = CGRectMake(borderX, baseY, borderWidth, rect.size.height);
+                                   [borderPath appendPath:[UIBezierPath bezierPathWithRect:borderRect]];
+                                 }
+                               }];
+
+  // 3. Perform a single batch fill for all borders
+  if (!borderPath.isEmpty) {
+    [borderColor setFill];
+    [borderPath fill];
+  }
+}
+
+@end

package/ios/utils/CodeBackground.h

@@ -0,0 +1,19 @@
+#pragma once
+#import "StyleConfig.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+extern NSString *const CodeAttributeName;
+
+@interface CodeBackground : NSObject
+
+- (instancetype)initWithConfig:(StyleConfig *)config;
+- (void)drawBackgroundsForGlyphRange:(NSRange)glyphsToShow
+                       layoutManager:(NSLayoutManager *)layoutManager
+                       textContainer:(NSTextContainer *)textContainer
+                             atPoint:(CGPoint)origin;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/CodeBackground.m

@@ -0,0 +1,191 @@
+#import "CodeBackground.h"
+#import "RenderContext.h"
+
+NSString *const CodeAttributeName = @"Code";
+
+static const CGFloat kCodeBackgroundCornerRadius = 2.0;
+static const CGFloat kCodeBackgroundBorderWidth = 0.5;
+
+@implementation CodeBackground {
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  self = [super init];
+  if (self) {
+    _config = config;
+  }
+  return self;
+}
+
+- (void)drawBackgroundsForGlyphRange:(NSRange)glyphsToShow
+                       layoutManager:(NSLayoutManager *)layoutManager
+                       textContainer:(NSTextContainer *)textContainer
+                             atPoint:(CGPoint)origin
+{
+  UIColor *backgroundColor = _config.codeBackgroundColor;
+  if (!backgroundColor)
+    return;
+
+  NSTextStorage *textStorage = layoutManager.textStorage;
+  NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphsToShow actualGlyphRange:NULL];
+  if (charRange.location == NSNotFound || charRange.length == 0)
+    return;
+
+  [textStorage enumerateAttribute:CodeAttributeName
+                          inRange:NSMakeRange(0, textStorage.length)
+                          options:0
+                       usingBlock:^(id value, NSRange range, BOOL *stop) {
+                         if (!value || range.length == 0)
+                           return;
+                         if (NSIntersectionRange(range, charRange).length == 0)
+                           return;
+
+                         [self drawCodeBackgroundForRange:range
+                                            layoutManager:layoutManager
+                                            textContainer:textContainer
+                                                  atPoint:origin
+                                          backgroundColor:backgroundColor
+                                              borderColor:self->_config.codeBorderColor];
+                       }];
+}
+
+- (void)drawCodeBackgroundForRange:(NSRange)range
+                     layoutManager:(NSLayoutManager *)layoutManager
+                     textContainer:(NSTextContainer *)textContainer
+                           atPoint:(CGPoint)origin
+                   backgroundColor:(UIColor *)backgroundColor
+                       borderColor:(UIColor *)borderColor
+{
+  NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:range actualCharacterRange:NULL];
+  if (glyphRange.location == NSNotFound || glyphRange.length == 0)
+    return;
+
+  CGFloat referenceHeight = [self findReferenceHeightForRange:range textStorage:layoutManager.textStorage];
+
+  [layoutManager
+      enumerateLineFragmentsForGlyphRange:glyphRange
+                               usingBlock:^(CGRect rect, CGRect usedRect, NSTextContainer *tc, NSRange lineRange,
+                                            BOOL *stop) {
+                                 NSRange intersect = NSIntersectionRange(lineRange, glyphRange);
+                                 if (intersect.length == 0)
+                                   return;
+
+                                 BOOL isFirst = (intersect.location == glyphRange.location);
+                                 BOOL isLast = (NSMaxRange(intersect) == NSMaxRange(glyphRange));
+
+                                 CGRect finalRect;
+                                 if (isFirst || isLast) {
+                                   // Precise bounds are only required for the start and end of the span
+                                   CGRect textRect = [layoutManager boundingRectForGlyphRange:intersect
+                                                                              inTextContainer:textContainer];
+                                   finalRect = CGRectMake(textRect.origin.x + origin.x, textRect.origin.y + origin.y,
+                                                          textRect.size.width, textRect.size.height);
+
+                                   // For multi-line, extend the first line to the right edge of the fragment
+                                   if (isFirst && !isLast) {
+                                     finalRect.size.width =
+                                         (usedRect.origin.x + usedRect.size.width + origin.x) - finalRect.origin.x;
+                                   }
+                                 } else {
+                                   // OPTIMIZATION: Middle lines use the usedRect of the fragment directly
+                                   finalRect = CGRectMake(usedRect.origin.x + origin.x, usedRect.origin.y + origin.y,
+                                                          usedRect.size.width, usedRect.size.height);
+                                 }
+
+                                 // Ensure consistent height and no gaps
+                                 if (finalRect.size.height < referenceHeight) {
+                                   finalRect.size.height = referenceHeight;
+                                 }
+
+                                 [self drawBackgroundAndBorders:finalRect
+                                                backgroundColor:backgroundColor
+                                                    borderColor:borderColor
+                                                        isFirst:isFirst
+                                                         isLast:isLast];
+                               }];
+}
+
+#pragma mark - Drawing Logic
+
+- (void)drawBackgroundAndBorders:(CGRect)rect
+                 backgroundColor:(UIColor *)backgroundColor
+                     borderColor:(UIColor *)borderColor
+                         isFirst:(BOOL)isFirst
+                          isLast:(BOOL)isLast
+{
+  UIBezierPath *path = [self pathForRect:rect isFirst:isFirst isLast:isLast];
+  [backgroundColor setFill];
+  [path fill];
+
+  if (borderColor) {
+    [borderColor setStroke];
+    UIBezierPath *strokePath =
+        (isFirst && isLast) ? path : [self openBorderPathForRect:rect isFirst:isFirst isLast:isLast];
+    strokePath.lineWidth = kCodeBackgroundBorderWidth;
+    strokePath.lineCapStyle = kCGLineCapRound;
+    strokePath.lineJoinStyle = kCGLineJoinRound;
+    [strokePath stroke];
+  }
+}
+
+- (UIBezierPath *)pathForRect:(CGRect)rect isFirst:(BOOL)isFirst isLast:(BOOL)isLast
+{
+  UIRectCorner corners = 0;
+  if (isFirst)
+    corners |= (UIRectCornerTopLeft | UIRectCornerBottomLeft);
+  if (isLast)
+    corners |= (UIRectCornerTopRight | UIRectCornerBottomRight);
+
+  return [UIBezierPath bezierPathWithRoundedRect:rect
+                               byRoundingCorners:corners
+                                     cornerRadii:CGSizeMake(kCodeBackgroundCornerRadius, kCodeBackgroundCornerRadius)];
+}
+
+- (UIBezierPath *)openBorderPathForRect:(CGRect)rect isFirst:(BOOL)isFirst isLast:(BOOL)isLast
+{
+  UIBezierPath *path = [UIBezierPath bezierPath];
+  CGFloat r = kCodeBackgroundCornerRadius;
+  CGFloat inset = kCodeBackgroundBorderWidth / 2.0;
+  CGRect insetRect = CGRectInset(rect, inset, inset);
+
+  if (isFirst) {
+    [path moveToPoint:CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y)];
+    [path addLineToPoint:CGPointMake(insetRect.origin.x + r, insetRect.origin.y)];
+    [path addQuadCurveToPoint:CGPointMake(insetRect.origin.x, insetRect.origin.y + r)
+                 controlPoint:CGPointMake(insetRect.origin.x, insetRect.origin.y)];
+    [path addLineToPoint:CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect) - r)];
+    [path addQuadCurveToPoint:CGPointMake(insetRect.origin.x + r, CGRectGetMaxY(insetRect))
+                 controlPoint:CGPointMake(insetRect.origin.x, CGRectGetMaxY(insetRect))];
+    [path addLineToPoint:CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect))];
+  } else if (isLast) {
+    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
+    [path addLineToPoint:CGPointMake(CGRectGetMaxX(insetRect) - r, insetRect.origin.y)];
+    [path addQuadCurveToPoint:CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y + r)
+                 controlPoint:CGPointMake(CGRectGetMaxX(insetRect), insetRect.origin.y)];
+    [path addLineToPoint:CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect) - r)];
+    [path addQuadCurveToPoint:CGPointMake(CGRectGetMaxX(insetRect) - r, CGRectGetMaxY(insetRect))
+                 controlPoint:CGPointMake(CGRectGetMaxX(insetRect), CGRectGetMaxY(insetRect))];
+    [path addLineToPoint:CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect))];
+  } else {
+    [path moveToPoint:CGPointMake(rect.origin.x, insetRect.origin.y)];
+    [path addLineToPoint:CGPointMake(CGRectGetMaxX(rect), insetRect.origin.y)];
+    [path moveToPoint:CGPointMake(rect.origin.x, CGRectGetMaxY(insetRect))];
+    [path addLineToPoint:CGPointMake(CGRectGetMaxX(rect), CGRectGetMaxY(insetRect))];
+  }
+  return path;
+}
+
+#pragma mark - Helpers
+
+- (CGFloat)findReferenceHeightForRange:(NSRange)range textStorage:(NSTextStorage *)textStorage
+{
+  if (range.location == NSNotFound || range.length == 0 || !textStorage) {
+    return [_config paragraphFontSize] * 1.2;
+  }
+  NSNumber *lineHeightValue = [textStorage attribute:@"BlockLineHeight" atIndex:range.location effectiveRange:NULL];
+  return lineHeightValue ? [lineHeightValue doubleValue] : ([_config paragraphFontSize] * 1.2);
+}
+
+@end

package/ios/utils/CodeBlockBackground.h

@@ -0,0 +1,17 @@
+#pragma once
+#import "StyleConfig.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface CodeBlockBackground : NSObject
+
+- (instancetype)initWithConfig:(StyleConfig *)config;
+- (void)drawBackgroundsForGlyphRange:(NSRange)glyphsToShow
+                       layoutManager:(NSLayoutManager *)layoutManager
+                       textContainer:(NSTextContainer *)textContainer
+                             atPoint:(CGPoint)origin;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/CodeBlockBackground.m

@@ -0,0 +1,82 @@
+#import "CodeBlockBackground.h"
+#import "LastElementUtils.h"
+#import "StyleConfig.h"
+
+@implementation CodeBlockBackground {
+  StyleConfig *_config;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config
+{
+  if (self = [super init]) {
+    _config = config;
+  }
+  return self;
+}
+
+- (void)drawBackgroundsForGlyphRange:(NSRange)glyphsToShow
+                       layoutManager:(NSLayoutManager *)layoutManager
+                       textContainer:(NSTextContainer *)textContainer
+                             atPoint:(CGPoint)origin
+{
+  NSTextStorage *textStorage = layoutManager.textStorage;
+  NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphsToShow actualGlyphRange:NULL];
+
+  [textStorage enumerateAttribute:CodeBlockAttributeName
+                          inRange:charRange
+                          options:0
+                       usingBlock:^(id value, NSRange range, BOOL *stop) {
+                         if (!value)
+                           return;
+                         [self drawCodeBlockBackgroundForRange:range
+                                                 layoutManager:layoutManager
+                                                 textContainer:textContainer
+                                                       atPoint:origin];
+                       }];
+}
+
+- (void)drawCodeBlockBackgroundForRange:(NSRange)range
+                          layoutManager:(NSLayoutManager *)layoutManager
+                          textContainer:(NSTextContainer *)textContainer
+                                atPoint:(CGPoint)origin
+{
+  NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:range actualCharacterRange:NULL];
+  CGRect blockRect = [layoutManager boundingRectForGlyphRange:glyphRange inTextContainer:textContainer];
+
+  if (CGRectIsEmpty(blockRect))
+    return;
+
+  blockRect.origin.x = origin.x;
+  blockRect.origin.y += origin.y;
+  blockRect.size.width = textContainer.size.width;
+
+  // We extend the background specifically to cover the bottom padding spacer,
+  // excluding any additional marginBottom applied via measurement.
+  BOOL isLastCodeBlock = (NSMaxRange(range) == layoutManager.textStorage.length);
+  if (isLastCodeBlock) {
+    blockRect.size.height += [_config codeBlockPadding];
+  }
+
+  CGFloat borderWidth = [_config codeBlockBorderWidth];
+  CGFloat borderRadius = [_config codeBlockBorderRadius];
+  CGFloat inset = borderWidth / 2.0;
+
+  CGRect insetRect = CGRectInset(blockRect, inset, inset);
+  UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:insetRect cornerRadius:MAX(0, borderRadius - inset)];
+
+  CGContextRef ctx = UIGraphicsGetCurrentContext();
+  CGContextSaveGState(ctx);
+  {
+    [[_config codeBlockBackgroundColor] setFill];
+    [path fill];
+
+    if (borderWidth > 0) {
+      [[_config codeBlockBorderColor] setStroke];
+      path.lineWidth = borderWidth;
+      path.lineJoinStyle = kCGLineJoinRound;
+      [path stroke];
+    }
+  }
+  CGContextRestoreGState(ctx);
+}
+@end

package/ios/utils/EditMenuUtils.h

@@ -0,0 +1,22 @@
+#pragma once
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Builds edit menu with enhanced Copy (RTF/HTML/Markdown) and optional "Copy as Markdown"/"Copy Image URL".
+UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range, NSString *_Nullable cachedMarkdown,
+                                  StyleConfig *styleConfig, NSArray<UIMenuElement *> *suggestedActions)
+    API_AVAILABLE(ios(16.0));
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/EditMenuUtils.m

@@ -0,0 +1,118 @@
+#import "EditMenuUtils.h"
+#import "PasteboardUtils.h"
+#import "StyleConfig.h"
+#import <UIKit/UIPasteboard.h>
+
+static NSString *const kMenuIdentifierStandardEdit = @"com.apple.menu.standard-edit";
+static NSString *const kActionIdentifierCopy = @"com.swmansion.enriched.markdown.copy";
+static NSString *const kActionIdentifierCopyMarkdown = @"com.swmansion.enriched.markdown.copyMarkdown";
+static NSString *const kActionIdentifierCopyImageURL = @"com.swmansion.enriched.markdown.copyImageURL";
+
+#pragma mark - Action Creators
+
+static UIAction *createCopyAction(NSAttributedString *selectedText, NSString *markdown, StyleConfig *styleConfig)
+{
+  return [UIAction actionWithTitle:@"Copy"
+                             image:[UIImage systemImageNamed:@"doc.on.doc"]
+                        identifier:kActionIdentifierCopy
+                           handler:^(__kindof UIAction *action) {
+                             copyAttributedStringToPasteboard(selectedText, markdown, styleConfig);
+                           }];
+}
+
+static UIAction *_Nullable createCopyMarkdownAction(NSString *markdown)
+{
+  if (markdown.length == 0)
+    return nil;
+
+  return [UIAction
+      actionWithTitle:@"Copy as Markdown"
+                image:[UIImage systemImageNamed:@"doc.text"]
+           identifier:kActionIdentifierCopyMarkdown
+              handler:^(__kindof UIAction *action) { [[UIPasteboard generalPasteboard] setString:markdown]; }];
+}
+
+static UIAction *_Nullable createCopyImageURLAction(NSArray<NSString *> *imageURLs)
+{
+  if (imageURLs.count == 0)
+    return nil;
+
+  NSString *urlsToCopy = [imageURLs componentsJoinedByString:@"\n"];
+  NSString *title = (imageURLs.count == 1)
+                        ? @"Copy Image URL"
+                        : [NSString stringWithFormat:@"Copy %lu Image URLs", (unsigned long)imageURLs.count];
+
+  return [UIAction
+      actionWithTitle:title
+                image:[UIImage systemImageNamed:@"link"]
+           identifier:kActionIdentifierCopyImageURL
+              handler:^(__kindof UIAction *action) { [[UIPasteboard generalPasteboard] setString:urlsToCopy]; }];
+}
+
+#pragma mark - Menu Building Helpers
+
+static UIMenu *createEnhancedStandardEditMenu(UIMenu *originalMenu, UIAction *copyAction)
+{
+  return [UIMenu menuWithTitle:originalMenu.title
+                         image:originalMenu.image
+                    identifier:originalMenu.identifier
+                       options:originalMenu.options
+                      children:@[ copyAction ]];
+}
+
+static void addOptionalAction(NSMutableArray<UIMenuElement *> *array, UIAction *_Nullable action)
+{
+  if (action) {
+    [array addObject:action];
+  }
+}
+
+static void insertOptionalAction(NSMutableArray<UIMenuElement *> *array, UIAction *_Nullable action, NSUInteger index)
+{
+  if (action) {
+    [array insertObject:action atIndex:index];
+  }
+}
+
+#pragma mark - Public API
+
+UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range, NSString *_Nullable cachedMarkdown,
+                                  StyleConfig *styleConfig, NSArray<UIMenuElement *> *suggestedActions)
+    API_AVAILABLE(ios(16.0))
+{
+  NSAttributedString *selectedText = [attributedText attributedSubstringFromRange:range];
+  NSString *markdown = markdownForRange(attributedText, range, cachedMarkdown);
+  NSArray<NSString *> *imageURLs = imageURLsInRange(attributedText, range);
+
+  UIAction *copyAction = createCopyAction(selectedText, markdown, styleConfig);
+  UIAction *copyMarkdownAction = createCopyMarkdownAction(markdown);
+  UIAction *copyImageURLAction = createCopyImageURLAction(imageURLs);
+
+  NSMutableArray<UIMenuElement *> *result = [NSMutableArray array];
+  BOOL foundStandardEditMenu = NO;
+
+  for (UIMenuElement *element in suggestedActions) {
+    if ([element isKindOfClass:[UIMenu class]]) {
+      UIMenu *menu = (UIMenu *)element;
+
+      if ([menu.identifier isEqualToString:kMenuIdentifierStandardEdit]) {
+        // Replace standard Copy with our enhanced version
+        [result addObject:createEnhancedStandardEditMenu(menu, copyAction)];
+        addOptionalAction(result, copyMarkdownAction);
+        addOptionalAction(result, copyImageURLAction);
+        foundStandardEditMenu = YES;
+        continue;
+      }
+    }
+    [result addObject:element];
+  }
+
+  // Fallback if standard-edit menu wasn't found
+  if (!foundStandardEditMenu) {
+    [result insertObject:copyAction atIndex:0];
+    insertOptionalAction(result, copyMarkdownAction, 1);
+    addOptionalAction(result, copyImageURLAction);
+  }
+
+  return [UIMenu menuWithChildren:result];
+}

package/ios/utils/FontUtils.h

@@ -0,0 +1,25 @@
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+@class BlockStyle;
+@class RenderContext;
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Returns a cached UIFont from BlockStyle properties via RenderContext. */
+extern UIFont *cachedFontFromBlockStyle(BlockStyle *blockStyle, RenderContext *context);
+
+/** Returns the font scale multiplier, capped by maxFontSizeMultiplier.
+ *  Uses React Native's RCTFontSizeMultiplier() internally.
+ *  @param maxFontSizeMultiplier Values >= 1.0 cap the result, < 1.0 means no cap. */
+extern CGFloat RCTFontSizeMultiplierWithMax(CGFloat maxFontSizeMultiplier);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/FontUtils.m

@@ -0,0 +1,27 @@
+#import "FontUtils.h"
+#import "RenderContext.h"
+#import <React/RCTUtils.h>
+
+UIFont *cachedFontFromBlockStyle(BlockStyle *blockStyle, RenderContext *context)
+{
+  if (!blockStyle) {
+    return nil;
+  }
+  if (blockStyle.cachedFont) {
+    return blockStyle.cachedFont;
+  }
+  return [context cachedFontForSize:blockStyle.fontSize family:blockStyle.fontFamily weight:blockStyle.fontWeight];
+}
+
+CGFloat RCTFontSizeMultiplierWithMax(CGFloat maxFontSizeMultiplier)
+{
+  CGFloat multiplier = RCTFontSizeMultiplier();
+
+  // Apply maxFontSizeMultiplier cap if >= 1.0
+  // Values < 1.0 (including 0 and NaN) mean no cap is applied
+  if (!isnan(maxFontSizeMultiplier) && maxFontSizeMultiplier >= 1.0) {
+    return fmin(maxFontSizeMultiplier, multiplier);
+  }
+
+  return multiplier;
+}