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

package/ios/utils/ENRMUIKit.h

@@ -0,0 +1,418 @@
+#pragma once
+
+#include <TargetConditionals.h>
+
+// RCTUIKit.h is react-native-macos only. On iOS we import UIKit and define the aliases ourselves.
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#define RCTUIColor UIColor
+#define RCTUIImage UIImage
+#define RCTUIView UIView
+#define RCTUIScrollView UIScrollView
+#define RCTUIGraphicsImageRenderer UIGraphicsImageRenderer
+#define RCTUIGraphicsImageRendererContext UIGraphicsImageRendererContext
+#define RCTUIGraphicsImageRendererFormat UIGraphicsImageRendererFormat
+#define ENRMPlatformTextView UITextView
+#define ENRMTapRecognizer UITapGestureRecognizer
+
+// Inline helpers that RCTUIKit.h normally provides on iOS.
+static inline UIBezierPath *UIBezierPathWithRoundedRect(CGRect rect, CGFloat cornerRadius)
+{
+  return [UIBezierPath bezierPathWithRoundedRect:rect cornerRadius:cornerRadius];
+}
+static inline void UIBezierPathAppendPath(UIBezierPath *path, UIBezierPath *appendPath)
+{
+  [path appendPath:appendPath];
+}
+static inline CGFloat UIFontLineHeight(UIFont *font)
+{
+  return font.lineHeight;
+}
+#else
+#import <React/RCTTextUIKit.h>
+#import <React/RCTUIKit.h>
+#import <React/RCTUITextView.h>
+#define ENRMPlatformTextView RCTUITextView
+#define ENRMTapRecognizer NSClickGestureRecognizer
+#endif
+
+/// On iOS, explicitly sets opaque=NO — without it the renderer produces an opaque backing,
+/// breaking transparent backgrounds. macOS handles transparency by default.
+static inline RCTUIGraphicsImageRenderer *ImageRendererForSize(CGSize size)
+{
+#if !TARGET_OS_OSX
+  RCTUIGraphicsImageRendererFormat *format = [RCTUIGraphicsImageRendererFormat preferredFormat];
+  format.opaque = NO;
+  return [[RCTUIGraphicsImageRenderer alloc] initWithSize:size format:format];
+#else
+  return [[RCTUIGraphicsImageRenderer alloc] initWithSize:size];
+#endif
+}
+
+/// NSBezierPath uses NS-prefixed enum values; UIBezierPath uses kCG-prefixed constants.
+static inline void BezierPathSetRoundStyle(UIBezierPath *path)
+{
+#if !TARGET_OS_OSX
+  path.lineCapStyle = kCGLineCapRound;
+  path.lineJoinStyle = kCGLineJoinRound;
+#else
+  path.lineCapStyle = NSLineCapStyleRound;
+  path.lineJoinStyle = NSLineJoinStyleRound;
+#endif
+}
+
+/// Cross-platform line segment: NSBezierPath uses lineToPoint: instead of addLineToPoint:.
+static inline void BezierPathAddLine(UIBezierPath *path, CGPoint point)
+{
+#if !TARGET_OS_OSX
+  [path addLineToPoint:point];
+#else
+  [path lineToPoint:point];
+#endif
+}
+
+/// Cross-platform quad-curve: NSBezierPath lacks addQuadCurveToPoint:, so we approximate
+/// with a cubic Bezier using the standard quadratic-to-cubic conversion.
+static inline void BezierPathAddQuadCurve(UIBezierPath *path, CGPoint end, CGPoint control)
+{
+#if !TARGET_OS_OSX
+  [path addQuadCurveToPoint:end controlPoint:control];
+#else
+  CGPoint start = [path currentPoint];
+  [path curveToPoint:end
+       controlPoint1:CGPointMake(start.x + 2.0 / 3.0 * (control.x - start.x),
+                                 start.y + 2.0 / 3.0 * (control.y - start.y))
+       controlPoint2:CGPointMake(end.x + 2.0 / 3.0 * (control.x - end.x), end.y + 2.0 / 3.0 * (control.y - end.y))];
+#endif
+}
+
+/// Cross-platform IME composition check: UITextView uses markedTextRange (nullable UITextRange);
+/// NSTextView uses hasMarkedText (BOOL).
+static inline BOOL ENRMHasMarkedText(ENRMPlatformTextView *textView)
+{
+#if !TARGET_OS_OSX
+  return textView.markedTextRange != nil;
+#else
+  return textView.hasMarkedText;
+#endif
+}
+
+/// Cross-platform plain text read: UITextView uses .text; NSTextView uses .string.
+static inline NSString *ENRMGetPlainText(ENRMPlatformTextView *textView)
+{
+#if !TARGET_OS_OSX
+  return textView.text;
+#else
+  return textView.string;
+#endif
+}
+
+/// Cross-platform plain text write: UITextView uses .text setter; NSTextView uses setString:.
+static inline void ENRMSetPlainText(ENRMPlatformTextView *textView, NSString *text)
+{
+#if !TARGET_OS_OSX
+  textView.text = text;
+#else
+  [textView setString:text];
+#endif
+}
+
+/// Cross-platform attributed text read: NSTextView exposes content via textStorage;
+/// UITextView exposes it via attributedText.
+static inline NSAttributedString *ENRMGetAttributedText(ENRMPlatformTextView *textView)
+{
+#if !TARGET_OS_OSX
+  return textView.attributedText;
+#else
+  return textView.textStorage;
+#endif
+}
+
+/// Cross-platform attributed text write: NSTextView uses textStorage setAttributedString:;
+/// UITextView uses the attributedText property setter.
+static inline void ENRMSetAttributedText(ENRMPlatformTextView *textView, NSAttributedString *text)
+{
+#if !TARGET_OS_OSX
+  textView.attributedText = text;
+#else
+  [textView.textStorage setAttributedString:text];
+#endif
+}
+
+/// Cross-platform text replacement at a given range.
+/// iOS uses UITextInput protocol methods; macOS uses NSTextView's insertText:replacementRange:.
+static inline void ENRMReplaceTextInRange(ENRMPlatformTextView *textView, NSString *text, NSRange range)
+{
+#if !TARGET_OS_OSX
+  UITextPosition *start = [textView positionFromPosition:textView.beginningOfDocument offset:(NSInteger)range.location];
+  UITextPosition *end = [textView positionFromPosition:textView.beginningOfDocument
+                                                offset:(NSInteger)NSMaxRange(range)];
+  [textView replaceRange:[textView textRangeFromPosition:start toPosition:end] withText:text];
+#else
+  [textView insertText:text replacementRange:range];
+#endif
+}
+
+/// Cross-platform content size update after measurement.
+/// iOS UITextView has a settable contentSize; macOS NSTextView does not.
+static inline void ENRMSetContentSize(ENRMPlatformTextView *textView, CGSize size)
+{
+#if !TARGET_OS_OSX
+  textView.contentSize = size;
+#endif
+}
+
+/// Returns YES when the user has asked the system to minimise motion.
+/// iOS: UIAccessibilityIsReduceMotionEnabled.
+/// macOS: NSWorkspace.shared.accessibilityDisplayShouldReduceMotion.
+/// Always NO on platforms where the API is unavailable.
+static inline BOOL ENRMShouldReduceMotion(void)
+{
+#if !TARGET_OS_OSX
+  return UIAccessibilityIsReduceMotionEnabled();
+#else
+  if (@available(macOS 10.12, *)) {
+    return NSWorkspace.sharedWorkspace.accessibilityDisplayShouldReduceMotion;
+  }
+  return NO;
+#endif
+}
+
+/// Sets default typing attributes on the text view.
+/// On macOS, RCTUITextView overrides setTypingAttributes: to use defaultTextAttributes,
+/// so we must set that property as well.
+static inline void ENRMSetDefaultTypingAttributes(ENRMPlatformTextView *textView, NSDictionary *attrs)
+{
+#if TARGET_OS_OSX
+  textView.defaultTextAttributes = attrs;
+#endif
+  textView.typingAttributes = attrs;
+}
+
+/// Applies shared configuration to a text view used for markdown input editing.
+/// Handles platform differences: scroll indicators, text container insets,
+/// drawsBackground (macOS). Sets editable=YES, scrollEnabled=YES.
+static inline void ENRMConfigureMarkdownTextInputTextView(ENRMPlatformTextView *textView)
+{
+  textView.font = [UIFont systemFontOfSize:16.0];
+  textView.backgroundColor = [RCTUIColor clearColor];
+  textView.editable = YES;
+#if !TARGET_OS_OSX
+  textView.scrollEnabled = YES;
+  textView.showsVerticalScrollIndicator = NO;
+  textView.showsHorizontalScrollIndicator = NO;
+  textView.textContainerInset = UIEdgeInsetsZero;
+#else
+  textView.textContainerInsets = UIEdgeInsetsZero;
+  textView.drawsBackground = NO;
+#endif
+  textView.textContainer.lineFragmentPadding = 0;
+}
+
+/// Cross-platform cursor color: iOS uses tintColor; macOS uses insertionPointColor.
+static inline void ENRMSetCursorColor(ENRMPlatformTextView *textView, RCTUIColor *color)
+{
+#if !TARGET_OS_OSX
+  textView.tintColor = color;
+#else
+  textView.insertionPointColor = color;
+#endif
+}
+
+/// Cross-platform selection color: iOS uses tintColor (also affects the caret
+/// and selection handles); macOS sets the selection background via
+/// `selectedTextAttributes`. Pass `nil` to restore the system default.
+static inline void ENRMSetSelectionColor(ENRMPlatformTextView *textView, RCTUIColor *color)
+{
+#if !TARGET_OS_OSX
+  textView.tintColor = color;
+#else
+  RCTUIColor *resolved = color ?: [NSColor selectedTextBackgroundColor];
+  textView.selectedTextAttributes = @{NSBackgroundColorAttributeName : resolved};
+#endif
+}
+
+/// Cross-platform focus: iOS uses becomeFirstResponder;
+/// macOS uses makeFirstResponder: on the window.
+static inline void ENRMFocusTextView(ENRMPlatformTextView *textView)
+{
+#if !TARGET_OS_OSX
+  [textView becomeFirstResponder];
+#else
+  [textView.window makeFirstResponder:textView];
+#endif
+}
+
+/// Cross-platform blur: iOS uses resignFirstResponder;
+/// macOS clears first responder via the window.
+static inline void ENRMBlurTextView(ENRMPlatformTextView *textView)
+{
+#if !TARGET_OS_OSX
+  [textView resignFirstResponder];
+#else
+  [textView.window makeFirstResponder:nil];
+#endif
+}
+
+/// Applies shared configuration to a text view used for markdown rendering.
+/// Handles platform differences: scroll indicators, text container insets,
+/// drawsBackground (macOS), accessibilityElementsHidden (iOS).
+static inline void ENRMConfigureMarkdownTextView(ENRMPlatformTextView *textView)
+{
+  textView.font = [UIFont systemFontOfSize:16.0];
+  textView.backgroundColor = [RCTUIColor clearColor];
+  textView.textColor = [RCTUIColor blackColor];
+  textView.editable = NO;
+  textView.scrollEnabled = NO;
+#if !TARGET_OS_OSX
+  textView.showsVerticalScrollIndicator = NO;
+  textView.showsHorizontalScrollIndicator = NO;
+  textView.textContainerInset = UIEdgeInsetsZero;
+#else
+  textView.textContainerInsets = UIEdgeInsetsZero;
+  textView.drawsBackground = NO;
+#endif
+  textView.textContainer.lineFragmentPadding = 0;
+  textView.linkTextAttributes = @{};
+  textView.selectable = YES;
+#if !TARGET_OS_OSX
+  textView.accessibilityElementsHidden = YES;
+#endif
+}
+
+/// Result of a text layout measurement pass.
+typedef struct {
+  CGRect usedRect;
+  CGRect extraLineFragmentRect;
+} ENRMTextLayoutResult;
+
+/// Measures text layout in a text view for a given width.
+/// On macOS, temporarily disables widthTracksTextView so the container width
+/// can be set directly without being overridden by the view's frame.
+static inline ENRMTextLayoutResult ENRMMeasureTextLayout(ENRMPlatformTextView *textView, CGFloat maxWidth)
+{
+#if TARGET_OS_OSX
+  textView.textContainer.widthTracksTextView = NO;
+#endif
+  textView.textContainer.size = CGSizeMake(maxWidth, CGFLOAT_MAX);
+  [textView.layoutManager ensureLayoutForTextContainer:textView.textContainer];
+  ENRMTextLayoutResult result;
+  result.usedRect = [textView.layoutManager usedRectForTextContainer:textView.textContainer];
+  result.extraLineFragmentRect = textView.layoutManager.extraLineFragmentRect;
+#if TARGET_OS_OSX
+  textView.textContainer.widthTracksTextView = YES;
+#endif
+  return result;
+}
+
+/// Cross-platform display refresh: UIView requires layoutIfNeeded before setNeedsDisplay
+/// to flush pending layout before the redraw; NSView takes a BOOL argument.
+/// Implemented as a macro to avoid Objective-C++ implicit pointer conversion issues in .mm files.
+#if !TARGET_OS_OSX
+#define ENRMSetNeedsDisplay(view)                                                                                      \
+  do {                                                                                                                 \
+    [(view) layoutIfNeeded];                                                                                           \
+    [(view) setNeedsDisplay];                                                                                          \
+  } while (0)
+#else
+#define ENRMSetNeedsDisplay(view) [(view) setNeedsDisplay:YES]
+#endif
+
+/// Invalidates the text container, re-lays out any existing content, and
+/// triggers a redraw.  On iOS also resets contentOffset to zero.
+/// Does NOT touch the text view's frame — callers that need to reposition
+/// the view should set the frame themselves before calling this.
+static inline void ENRMRefreshTextViewLayout(ENRMPlatformTextView *textView)
+{
+#if !TARGET_OS_OSX
+  textView.contentOffset = CGPointZero;
+#endif
+  textView.textContainer.size = CGSizeMake(textView.bounds.size.width, CGFLOAT_MAX);
+  NSUInteger textLength = ENRMGetAttributedText(textView).length;
+  if (textLength > 0) {
+    [textView.layoutManager invalidateLayoutForCharacterRange:NSMakeRange(0, textLength) actualCharacterRange:NULL];
+    [textView.layoutManager ensureLayoutForTextContainer:textView.textContainer];
+  }
+  ENRMSetNeedsDisplay(textView);
+}
+
+/// Refreshes a text view's layout and display after it is attached to a window.
+/// Sets the frame and text container to the given bounds, invalidates layout for
+/// any existing content, then triggers a redraw.
+static inline void ENRMRefreshTextViewAfterWindowAttach(ENRMPlatformTextView *textView, CGRect bounds)
+{
+  textView.frame = bounds;
+  ENRMRefreshTextViewLayout(textView);
+}
+
+/// Cross-platform text deselection: UITextView uses selectedTextRange (nullable);
+/// NSTextView uses selectedRange (length-based).
+static inline void ENRMClearSelection(ENRMPlatformTextView *textView)
+{
+#if !TARGET_OS_OSX
+  if (textView.selectedTextRange != nil) {
+    textView.selectedTextRange = nil;
+  }
+#else
+  if (textView.selectedRange.length > 0) {
+    textView.selectedRange = NSMakeRange(0, 0);
+  }
+#endif
+}
+
+// ── Placeholder label abstraction ──────────────────────────────────────────────
+
+#if !TARGET_OS_OSX
+typedef UILabel ENRMPlaceholderLabel;
+#else
+typedef NSTextField ENRMPlaceholderLabel;
+#endif
+
+/// Creates a placeholder label configured for use inside an ENRMPlatformTextView.
+/// On iOS: UILabel with multiline, placeholderTextColor, auto-layout pinned to
+/// textContainerInset and lineFragmentPadding.
+/// On macOS: borderless, non-editable NSTextField pinned to the text view origin.
+static inline ENRMPlaceholderLabel *ENRMCreatePlaceholderLabel(ENRMPlatformTextView *textView, UIFont *font)
+{
+#if !TARGET_OS_OSX
+  UILabel *label = [[UILabel alloc] init];
+  label.numberOfLines = 0;
+  label.textColor = [UIColor placeholderTextColor];
+  label.font = font;
+  label.translatesAutoresizingMaskIntoConstraints = NO;
+  [textView addSubview:label];
+  [NSLayoutConstraint activateConstraints:@[
+    [label.topAnchor constraintEqualToAnchor:textView.topAnchor constant:textView.textContainerInset.top],
+    [label.leadingAnchor constraintEqualToAnchor:textView.leadingAnchor
+                                        constant:textView.textContainer.lineFragmentPadding],
+    [label.trailingAnchor constraintEqualToAnchor:textView.trailingAnchor
+                                         constant:-textView.textContainer.lineFragmentPadding],
+  ]];
+  return label;
+#else
+  NSTextField *label = [[NSTextField alloc] initWithFrame:CGRectZero];
+  label.bordered = NO;
+  label.editable = NO;
+  label.selectable = NO;
+  label.drawsBackground = NO;
+  label.textColor = [NSColor placeholderTextColor];
+  label.font = font;
+  label.translatesAutoresizingMaskIntoConstraints = NO;
+  [textView addSubview:label];
+  [NSLayoutConstraint activateConstraints:@[
+    [label.topAnchor constraintEqualToAnchor:textView.topAnchor],
+    [label.leadingAnchor constraintEqualToAnchor:textView.leadingAnchor],
+  ]];
+  return label;
+#endif
+}
+
+/// Cross-platform placeholder text setter.
+static inline void ENRMSetPlaceholderText(ENRMPlaceholderLabel *label, NSString *text)
+{
+#if !TARGET_OS_OSX
+  label.text = text;
+#else
+  label.stringValue = text;
+#endif
+}

package/ios/utils/EditMenuUtils+macOS.m

@@ -0,0 +1,60 @@
+#import "ContextMenuUtils.h"
+#import "ENRMMenuAction.h"
+#import "EditMenuUtils.h"
+#import "PasteboardUtils.h"
+#import "StyleConfig.h"
+#include <TargetConditionals.h>
+
+#if TARGET_OS_OSX
+
+NSMenu *_Nullable buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range,
+                                            NSString *_Nullable cachedMarkdown, StyleConfig *styleConfig,
+                                            NSArray *suggestedActions, NSArray<NSMenuItem *> *_Nullable customItems,
+                                            ENRMSelectionMenuConfig selectionMenuConfig)
+{
+  NSMenu *menu = ([suggestedActions.firstObject isKindOfClass:[NSMenu class]]) ? (NSMenu *)suggestedActions.firstObject
+                                                                               : [[NSMenu alloc] initWithTitle:@""];
+
+  if (range.length == 0) {
+    return menu;
+  }
+
+  NSAttributedString *selectedText = [attributedText attributedSubstringFromRange:range];
+  NSString *markdown = markdownForRange(attributedText, range, cachedMarkdown);
+  NSArray<NSString *> *imageURLs = imageURLsInRange(attributedText, range);
+
+  // Replace the system Copy item with our enhanced version (copies RTF/HTML/Markdown).
+  // This mirrors the iOS behaviour where we replace the standard-edit Copy action.
+  NSMenuItem *enhancedCopy =
+      ENRMCreateMenuItem(@"Copy", ^{ copyAttributedStringToPasteboard(selectedText, markdown, styleConfig); });
+  NSInteger systemCopyIndex = [menu indexOfItemWithTarget:nil andAction:@selector(copy:)];
+  if (systemCopyIndex != NSNotFound) {
+    [menu removeItemAtIndex:systemCopyIndex];
+    [menu insertItem:enhancedCopy atIndex:systemCopyIndex];
+  } else {
+    if (menu.numberOfItems > 0) {
+      [menu addItem:[NSMenuItem separatorItem]];
+    }
+    [menu addItem:enhancedCopy];
+  }
+
+  if (selectionMenuConfig.copyAsMarkdown && markdown.length > 0) {
+    [menu addItem:ENRMCreateMenuItem(@"Copy as Markdown", ^{ copyStringToPasteboard(markdown); })];
+  }
+
+  if (selectionMenuConfig.copyImageURL && imageURLs.count > 0) {
+    NSString *title = (imageURLs.count == 1)
+                          ? @"Copy Image URL"
+                          : [NSString stringWithFormat:@"Copy %lu Image URLs", (unsigned long)imageURLs.count];
+    [menu addItem:ENRMCreateMenuItem(title, ^{
+            NSString *urlsToCopy = [imageURLs componentsJoinedByString:@"\n"];
+            copyStringToPasteboard(urlsToCopy);
+          })];
+  }
+
+  ENRMPrependMenuItems(menu, customItems);
+
+  return menu;
+}
+
+#endif

package/ios/utils/EditMenuUtils.h

@@ -0,0 +1,35 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef struct {
+  BOOL copyAsMarkdown;
+  BOOL copyImageURL;
+} ENRMSelectionMenuConfig;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !TARGET_OS_OSX
+// TODO: Remove API_AVAILABLE(ios(16.0)) guard when the minimum iOS deployment target in RN is bumped to 16.
+UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range, NSString *_Nullable cachedMarkdown,
+                                  StyleConfig *styleConfig, NSArray<UIMenuElement *> *suggestedActions,
+                                  NSArray<UIAction *> *_Nullable customActions,
+                                  ENRMSelectionMenuConfig selectionMenuConfig) API_AVAILABLE(ios(16.0));
+#else
+NSMenu *_Nullable buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range,
+                                            NSString *_Nullable cachedMarkdown, StyleConfig *styleConfig,
+                                            NSArray *suggestedActions, NSArray<NSMenuItem *> *_Nullable customItems,
+                                            ENRMSelectionMenuConfig selectionMenuConfig);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/EditMenuUtils.m

@@ -0,0 +1,119 @@
+#import "EditMenuUtils.h"
+#import "PasteboardUtils.h"
+#import "StyleConfig.h"
+#include <TargetConditionals.h>
+
+#if !TARGET_OS_OSX
+
+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";
+
+static UIAction *createCopyAction(NSAttributedString *selectedText, NSString *markdown, StyleConfig *styleConfig)
+{
+  return [UIAction actionWithTitle:@"Copy"
+                             image:[RCTUIImage 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:[RCTUIImage systemImageNamed:@"doc.text"]
+                        identifier:kActionIdentifierCopyMarkdown
+                           handler:^(__kindof UIAction *action) { copyStringToPasteboard(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:[RCTUIImage systemImageNamed:@"link"]
+                        identifier:kActionIdentifierCopyImageURL
+                           handler:^(__kindof UIAction *action) { copyStringToPasteboard(urlsToCopy); }];
+}
+
+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];
+  }
+}
+
+// TODO: Remove API_AVAILABLE(ios(16.0)) guard when the minimum iOS deployment target in RN is bumped to 16.
+UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range, NSString *_Nullable cachedMarkdown,
+                                  StyleConfig *styleConfig, NSArray<UIMenuElement *> *suggestedActions,
+                                  NSArray<UIAction *> *_Nullable customActions,
+                                  ENRMSelectionMenuConfig selectionMenuConfig) 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 = selectionMenuConfig.copyAsMarkdown ? createCopyMarkdownAction(markdown) : nil;
+  UIAction *copyImageURLAction = selectionMenuConfig.copyImageURL ? createCopyImageURLAction(imageURLs) : nil;
+
+  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];
+  }
+
+  if (!foundStandardEditMenu) {
+    [result insertObject:copyAction atIndex:0];
+    insertOptionalAction(result, copyMarkdownAction, 1);
+    addOptionalAction(result, copyImageURLAction);
+  }
+
+  if (customActions.count > 0) {
+    return [UIMenu menuWithChildren:[customActions arrayByAddingObjectsFromArray:result]];
+  }
+
+  return [UIMenu menuWithChildren:result];
+}
+
+#endif

package/ios/utils/FontScaleObserver.h

@@ -0,0 +1,10 @@
+#import "ENRMUIKit.h"
+
+@interface FontScaleObserver : NSObject
+
+@property (nonatomic, assign) BOOL allowFontScaling;
+@property (nonatomic, readonly) CGFloat effectiveFontScale;
+
+@property (nonatomic, copy, nullable) void (^onChange)(void);
+
+@end

package/ios/utils/FontScaleObserver.m

@@ -0,0 +1,55 @@
+#import "FontScaleObserver.h"
+#import <React/RCTUtils.h>
+#include <TargetConditionals.h>
+
+@implementation FontScaleObserver {
+  CGFloat _currentFontScale;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _allowFontScaling = YES;
+    _currentFontScale = RCTFontSizeMultiplier();
+
+#if !TARGET_OS_OSX
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(contentSizeCategoryDidChange:)
+                                                 name:UIContentSizeCategoryDidChangeNotification
+                                               object:nil];
+#endif
+    // TODO: Observe macOS system font size changes. UIContentSizeCategoryDidChangeNotification
+    // is iOS-only; macOS has no direct equivalent. Possible approaches: KVO on
+    // NSApplication.effectiveAppearance or polling NSFont.systemFontSize.
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+#if !TARGET_OS_OSX
+  [[NSNotificationCenter defaultCenter] removeObserver:self name:UIContentSizeCategoryDidChangeNotification object:nil];
+#endif
+}
+
+- (CGFloat)effectiveFontScale
+{
+  return _allowFontScaling ? _currentFontScale : 1.0;
+}
+
+- (void)contentSizeCategoryDidChange:(NSNotification *)notification
+{
+  if (!_allowFontScaling) {
+    return;
+  }
+
+  CGFloat newFontScale = RCTFontSizeMultiplier();
+  if (_currentFontScale != newFontScale) {
+    _currentFontScale = newFontScale;
+    if (self.onChange) {
+      self.onChange();
+    }
+  }
+}
+
+@end