@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.9

package/ios/utils/ENRMTextViewSetup.h

@@ -0,0 +1,132 @@
+#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]);
+  }
+}
+
+/// Returns maxWidth for soft-wrapped content, otherwise the tight width of its
+/// lines, or fallbackWidth when no line fragment was laid out. The tight width
+/// adds each line's head and tail indent to its used rect, which TextKit leaves
+/// out; lists and code blocks re-wrap without them.
+static inline CGFloat ENRMContentWidth(NSLayoutManager *layoutManager, CGFloat maxWidth, CGFloat fallbackWidth)
+{
+  CGFloat tightWidth = 0;
+  NSTextStorage *storage = layoutManager.textStorage;
+  NSString *string = storage.string;
+  NSCharacterSet *newlines = [NSCharacterSet newlineCharacterSet];
+  NSUInteger glyphCount = [layoutManager numberOfGlyphs];
+  BOOL startsParagraph = YES;
+  NSUInteger glyphIndex = 0;
+  while (glyphIndex < glyphCount) {
+    NSRange lineGlyphRange;
+    CGRect usedRect = [layoutManager lineFragmentUsedRectForGlyphAtIndex:glyphIndex effectiveRange:&lineGlyphRange];
+    if (lineGlyphRange.location == NSNotFound || NSMaxRange(lineGlyphRange) <= glyphIndex) {
+      break; // past a numberOfLines clamp: no fragment holds these glyphs
+    }
+    NSRange lineCharRange = [layoutManager characterRangeForGlyphRange:lineGlyphRange actualGlyphRange:NULL];
+    if (lineCharRange.length == 0) {
+      break;
+    }
+
+    NSParagraphStyle *style = [storage attribute:NSParagraphStyleAttributeName
+                                         atIndex:lineCharRange.location
+                                  effectiveRange:NULL];
+    CGFloat headIndent = startsParagraph ? style.firstLineHeadIndent : style.headIndent;
+    CGFloat tailInset = style.tailIndent < 0 ? -style.tailIndent : 0;
+    tightWidth = MAX(tightWidth, usedRect.size.width + headIndent + tailInset);
+    if (tightWidth >= maxWidth) {
+      return maxWidth;
+    }
+
+    BOOL endsParagraph = [newlines characterIsMember:[string characterAtIndex:NSMaxRange(lineCharRange) - 1]];
+    NSUInteger nextGlyphIndex = NSMaxRange(lineGlyphRange);
+    if (nextGlyphIndex < glyphCount && !endsParagraph) {
+      return maxWidth; // soft wrap
+    }
+    startsParagraph = endsParagraph;
+    glyphIndex = nextGlyphIndex;
+  }
+  return tightWidth > 0 ? tightWidth : fallbackWidth;
+}
+
+/// Turns a raw TextKit layout pass into the final measured size. Shared by
+/// the view-backed path (`ENRMMeasureTiptapText`) and the view-free path
+/// (`ENRMMeasureTiptapViewFree`) so both measure with one algorithm.
+///
+/// Steps, in order:
+/// - Soft-wrapped content reports maxWidth: a tight width would let flexShrink
+///   narrow the view, re-wrapping it and mismatching the measured height.
+///   Content broken only by explicit newlines keeps its tight width.
+/// - Optionally subtract the extra line fragment (iOS counts a trailing
+///   newline's empty line fragment into usedRect). Read-only tiptap passes
+///   YES; text input passes NO so trailing newlines keep a blank line (RN Text
+///   parity).
+/// - Add code-block padding when the last element is a code block, and the
+///   trailing margin when enabled.
+/// - Round up to the pixel grid of `scale` (pass `RCTScreenScale()` on main;
+///   off-main callers must pass `LayoutContext::pointScaleFactor` instead —
+///   `RCTScreenScale()` dispatch_syncs to main on first use, which the
+///   measure path must never do, see issue #550).
+static inline CGSize ENRMFinalizeMeasuredTextSize(ENRMTextLayoutResult layout, NSLayoutManager *layoutManager,
+                                                  CGFloat maxWidth, StyleConfig *config, BOOL allowTrailingMargin,
+                                                  CGFloat lastElementMarginBottom, BOOL subtractExtraLineFragment,
+                                                  CGFloat scale)
+{
+  CGFloat measuredWidth = ENRMContentWidth(layoutManager, maxWidth, layout.usedRect.size.width);
+  CGFloat measuredHeight = layout.usedRect.size.height;
+
+  if (subtractExtraLineFragment && !CGRectIsEmpty(layout.extraLineFragmentRect)) {
+    measuredHeight -= layout.extraLineFragmentRect.size.height;
+  }
+
+  if (isLastElementCodeBlock(layoutManager.textStorage)) {
+    measuredHeight += [config codeBlockPadding];
+  }
+
+  if (allowTrailingMargin && lastElementMarginBottom > 0) {
+    measuredHeight += lastElementMarginBottom;
+  }
+
+  return CGSizeMake(ceil(measuredWidth * scale) / scale, ceil(measuredHeight * scale) / scale);
+}
+
+static inline CGSize ENRMMeasureTiptapText(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);
+  return ENRMFinalizeMeasuredTextSize(layout, textView.layoutManager, maxWidth, config, allowTrailingMargin,
+                                      lastElementMarginBottom, YES, RCTScreenScale());
+}
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMUIKit.h

@@ -0,0 +1,429 @@
+#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
+
+/// Value for `usesFontLeading` on every NSLayoutManager that draws or
+/// measures tiptap. NSLayoutManager defaults to YES, which adds each font's
+/// built-in leading on top of the paragraph line height. React Native turns it
+/// off for Text layout, and drawing and measuring must agree, or the reported
+/// height and the on-screen layout drift apart. Fonts pulled in by glyph
+/// fallback make this visible: Geeza Pro (Arabic) has nonzero leading, so with
+/// YES every Arabic line measures taller than it renders.
+/// https://github.com/react/react-native/blob/v0.86.2/packages/react-native/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextLayoutManager.mm#L237
+static const BOOL ENRMLayoutManagerUsesFontLeading = NO;
+
+/// 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 tiptap input editing.
+/// Handles platform differences: scroll indicators, text container insets,
+/// drawsBackground (macOS). Sets editable=YES, scrollEnabled=YES.
+static inline void ENRMConfigureTiptapTextInputTextView(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 tiptap rendering.
+/// Handles platform differences: scroll indicators, text container insets,
+/// drawsBackground (macOS), accessibilityElementsHidden (iOS).
+static inline void ENRMConfigureTiptapTextView(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.layoutManager.usesFontLeading = ENRMLayoutManagerUsesFontLeading;
+  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 attributed text setter.
+static inline void ENRMSetPlaceholderAttributedText(ENRMPlaceholderLabel *label, NSAttributedString *text)
+{
+#if !TARGET_OS_OSX
+  label.attributedText = text;
+#else
+  label.attributedStringValue = text;
+#endif
+}

package/ios/utils/EditMenuUtils.h

@@ -0,0 +1,105 @@
+#pragma once
+#import "ENRMUIKit.h"
+#import <Foundation/Foundation.h>
+
+@class StyleConfig;
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef struct {
+  BOOL copyAsTiptap;
+  BOOL copyImageURL;
+  // The owner must keep these strings alive for the duration of the call (the
+  // view holds them in strong ivars).
+  __unsafe_unretained NSString *_Nullable copyLabel;
+  __unsafe_unretained NSString *_Nullable copyAsTiptapLabel;
+  __unsafe_unretained NSString *_Nullable copyImageUrlLabel;
+  __unsafe_unretained NSString *_Nullable copyImageUrlsLabel;
+  __unsafe_unretained NSArray<NSString *> *_Nullable copyImageUrlPluralTemplates;
+} ENRMSelectionMenuConfig;
+
+/// Resolves the "Copy Image URL(s)" menu title for a given image count.
+/// Uses the precomputed plural templates (indexed by count, 0..100) when present;
+/// counts > 100 use the "other" form (copyImageUrlsLabel). Otherwise the
+/// singular/`{count}` templates. All labels are resolved JS-side.
+static inline NSString *ENRMResolveImageURLsTitle(ENRMSelectionMenuConfig config, NSUInteger count)
+{
+  NSArray<NSString *> *templates = config.copyImageUrlPluralTemplates;
+  NSString *titleTemplate;
+  if (count < templates.count) {
+    titleTemplate = templates[count];
+  } else if (count == 1) {
+    titleTemplate = config.copyImageUrlLabel;
+  } else {
+    titleTemplate = config.copyImageUrlsLabel;
+  }
+  return [titleTemplate stringByReplacingOccurrencesOfString:@"{count}" withString:[@(count) stringValue]];
+}
+
+#ifdef __cplusplus
+
+/// Strong owners for the label strings in ENRMSelectionMenuConfig.
+struct ENRMSelectionMenuLabels {
+  NSString *copyLabel = nil;
+  NSString *copyAsTiptapLabel = nil;
+  NSString *copyImageUrlLabel = nil;
+  NSString *copyImageUrlsLabel = nil;
+  NSArray<NSString *> *copyImageUrlPluralTemplates = nil;
+};
+
+/// Converts a codegen SelectionMenuConfig struct into strong NSString labels.
+template <typename T> static inline ENRMSelectionMenuLabels ENRMParseSelectionMenuLabels(const T &src)
+{
+  NSMutableArray<NSString *> *templates = [NSMutableArray array];
+  for (const auto &s : src.copyImageUrlPluralTemplates) {
+    [templates addObject:[[NSString alloc] initWithUTF8String:s.c_str()]];
+  }
+  return {
+      [[NSString alloc] initWithUTF8String:src.copyLabel.c_str()],
+      [[NSString alloc] initWithUTF8String:src.copyAsTiptapLabel.c_str()],
+      [[NSString alloc] initWithUTF8String:src.copyImageUrlLabel.c_str()],
+      [[NSString alloc] initWithUTF8String:src.copyImageUrlsLabel.c_str()],
+      templates,
+  };
+}
+
+/// Builds an ENRMSelectionMenuConfig from pre-parsed labels and boolean flags.
+static inline ENRMSelectionMenuConfig ENRMBuildSelectionMenuConfig(const ENRMSelectionMenuLabels &labels,
+                                                                   bool copyAsTiptap, bool copyImageUrl)
+{
+  return (ENRMSelectionMenuConfig){
+      .copyAsTiptap = copyAsTiptap,
+      .copyImageURL = copyImageUrl,
+      .copyLabel = labels.copyLabel,
+      .copyAsTiptapLabel = labels.copyAsTiptapLabel,
+      .copyImageUrlLabel = labels.copyImageUrlLabel,
+      .copyImageUrlsLabel = labels.copyImageUrlsLabel,
+      .copyImageUrlPluralTemplates = labels.copyImageUrlPluralTemplates,
+  };
+}
+
+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.
+// TODO: selectionMenuConfig labels do NOT reach the system "Save to Camera Roll /
+// Copy" sheet shown when long-pressing an NSTextAttachment image — UIKit owns
+// that sheet end-to-end. Hooking UIContextMenuInteraction on image regions and
+// returning a custom UIContextMenuConfiguration would let us relabel those items.
+UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range, NSString *_Nullable cachedTiptap,
+                                  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 cachedTiptap, StyleConfig *styleConfig,
+                                            NSArray *suggestedActions, NSArray<NSMenuItem *> *_Nullable customItems,
+                                            ENRMSelectionMenuConfig selectionMenuConfig);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END