react-native-enriched-markdown-scaffold 1.0.2-scaffold.1 → 1.0.2-scaffold.10

package/ios/utils/ENRMSelectionChange.m

@@ -0,0 +1,282 @@
+#import "ENRMSelectionChange.h"
+#import "ENRMLinkChip.h"
+
+NSString *const ENRMSelectionActiveKey = @"active";
+NSString *const ENRMSelectionSourceKey = @"source";
+NSString *const ENRMSelectionTextKey = @"text";
+NSString *const ENRMSelectionMarkdownKey = @"markdown";
+NSString *const ENRMSelectionWholeKey = @"whole";
+NSString *const ENRMSelectionRectKey = @"rect";
+NSString *const ENRMSelectionStartRectKey = @"startRect";
+NSString *const ENRMSelectionEndRectKey = @"endRect";
+NSString *const ENRMSelectionAdjustingKey = @"adjusting";
+NSString *const ENRMSelectionFullKey = @"full";
+
+static NSValue *ENRMRectValue(CGRect rect)
+{
+#if TARGET_OS_OSX
+  return [NSValue valueWithRect:NSRectFromCGRect(rect)];
+#else
+  return [NSValue valueWithCGRect:rect];
+#endif
+}
+
+NSDictionary *ENRMInactiveSelectionPayload(void)
+{
+  static NSDictionary *payload;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSValue *zero = ENRMRectValue(CGRectZero);
+    payload = @{
+      ENRMSelectionActiveKey : @NO,
+      ENRMSelectionSourceKey : @"selection",
+      ENRMSelectionTextKey : @"",
+      ENRMSelectionMarkdownKey : @"",
+      ENRMSelectionWholeKey : @NO,
+      ENRMSelectionRectKey : zero,
+      ENRMSelectionStartRectKey : zero,
+      ENRMSelectionEndRectKey : zero,
+    };
+  });
+  return payload;
+}
+
+NSDictionary *ENRMBlockSelectionPayload(NSString *source, NSString *markdown, NSString *text, CGRect frame)
+{
+  NSValue *rect = ENRMRectValue(frame);
+  return @{
+    ENRMSelectionActiveKey : @YES,
+    ENRMSelectionSourceKey : source,
+    ENRMSelectionTextKey : text ?: @"",
+    ENRMSelectionMarkdownKey : markdown ?: @"",
+    ENRMSelectionWholeKey : @YES,
+    ENRMSelectionRectKey : rect,
+    ENRMSelectionStartRectKey : rect,
+    ENRMSelectionEndRectKey : rect,
+  };
+}
+
+#if !TARGET_OS_OSX
+NSDictionary *ENRMTextSelectionInTextView(UITextView *textView, UIView *targetView)
+{
+  NSRange range = textView.selectedRange;
+  UITextRange *textRange = textView.selectedTextRange;
+  if (range.location == NSNotFound || range.length == 0 || textRange == nil || textRange.isEmpty) {
+    return nil;
+  }
+
+  NSAttributedString *attributedText = textView.attributedText;
+  if (NSMaxRange(range) > attributedText.length) {
+    return nil;
+  }
+
+  CGRect unionRect = CGRectNull;
+  CGRect startRect = CGRectNull;
+  CGRect endRect = CGRectNull;
+  CGRect firstRect = CGRectNull;
+  CGRect lastRect = CGRectNull;
+  for (UITextSelectionRect *selectionRect in [textView selectionRectsForRange:textRange]) {
+    CGRect rect = selectionRect.rect;
+    if (CGRectIsNull(rect) || CGRectIsInfinite(rect) || CGRectIsEmpty(rect)) {
+      continue;
+    }
+    unionRect = CGRectUnion(unionRect, rect);
+    if (CGRectIsNull(firstRect)) {
+      firstRect = rect;
+    }
+    lastRect = rect;
+    if (selectionRect.containsStart && CGRectIsNull(startRect)) {
+      startRect = rect;
+    }
+    if (selectionRect.containsEnd) {
+      endRect = rect;
+    }
+  }
+  // Not laid out yet: report once layout gives the range a position.
+  if (CGRectIsNull(unionRect)) {
+    return nil;
+  }
+  if (CGRectIsNull(startRect)) {
+    startRect = firstRect;
+  }
+  if (CGRectIsNull(endRect)) {
+    endRect = lastRect;
+  }
+
+  return @{
+    ENRMSelectionTextKey : ENRMPlainTextByRemovingLinkSpacers(attributedText, range),
+    ENRMSelectionFullKey : @(range.location == 0 && range.length >= attributedText.length - 1),
+    ENRMSelectionRectKey : ENRMRectValue([textView convertRect:unionRect toView:targetView]),
+    ENRMSelectionStartRectKey : ENRMRectValue([textView convertRect:startRect toView:targetView]),
+    ENRMSelectionEndRectKey : ENRMRectValue([textView convertRect:endRect toView:targetView]),
+  };
+}
+#endif
+
+@implementation ENRMSelectionChangeReporter {
+  NSDictionary * (^_snapshot)(void);
+  void (^_emit)(NSDictionary *);
+  NSDictionary *_lastReported;
+  BOOL _pending;
+  // Bumped on cancel so a scheduled block that already left the queue is a no-op.
+  NSUInteger _generation;
+}
+
+- (instancetype)initWithSnapshot:(NSDictionary * (^)(void))snapshot emit:(void (^)(NSDictionary *))emit
+{
+  if (self = [super init]) {
+    _snapshot = [snapshot copy];
+    _emit = [emit copy];
+    _lastReported = ENRMInactiveSelectionPayload();
+  }
+  return self;
+}
+
+- (void)setEnabled:(BOOL)enabled
+{
+  if (_enabled == enabled) {
+    return;
+  }
+  _enabled = enabled;
+  [self cancel];
+  _lastReported = ENRMInactiveSelectionPayload();
+  if (enabled) {
+    [self schedule];
+  }
+}
+
+- (void)schedule
+{
+  if (!_enabled || _pending) {
+    return;
+  }
+  _pending = YES;
+  NSUInteger generation = _generation;
+  __weak ENRMSelectionChangeReporter *weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    ENRMSelectionChangeReporter *strongSelf = weakSelf;
+    if (!strongSelf || !strongSelf->_pending || strongSelf->_generation != generation) {
+      return;
+    }
+    strongSelf->_pending = NO;
+    [strongSelf report];
+  });
+}
+
+- (void)selectionChanged:(BOOL)hasSelection
+{
+  if (hasSelection) {
+    [self schedule];
+  } else {
+    [self flushNow];
+  }
+}
+
+- (void)flushNow
+{
+  [self cancel];
+  [self report];
+}
+
+- (void)forgetLastReported
+{
+  _lastReported = ENRMInactiveSelectionPayload();
+}
+
+- (void)cancel
+{
+  _pending = NO;
+  _generation++;
+}
+
+- (void)report
+{
+  if (!_enabled) {
+    return;
+  }
+  NSDictionary *current = _snapshot();
+  if ([current isEqualToDictionary:_lastReported]) {
+    return;
+  }
+  _lastReported = current;
+  _emit(current);
+}
+
+@end
+
+#if !TARGET_OS_OSX
+static void ENRMCollectGestures(UIView *view, NSMutableArray<UIGestureRecognizer *> *into)
+{
+  for (UIGestureRecognizer *recognizer in view.gestureRecognizers) {
+    [into addObject:recognizer];
+  }
+  for (UIView *subview in view.subviews) {
+    ENRMCollectGestures(subview, into);
+  }
+}
+
+@implementation ENRMSelectionGestureTracker {
+  void (^_change)(void);
+  NSHashTable<UIGestureRecognizer *> *_gestures;
+}
+
+- (instancetype)initWithChange:(void (^)(void))change
+{
+  if (self = [super init]) {
+    _change = [change copy];
+    _gestures = [NSHashTable weakObjectsHashTable];
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  // Recognizers don't retain their targets.
+  for (UIGestureRecognizer *recognizer in _gestures) {
+    [recognizer removeTarget:self action:@selector(gestureChanged:)];
+  }
+}
+
+- (void)trackTextView:(UITextView *)textView
+{
+  NSMutableArray<UIGestureRecognizer *> *all = [NSMutableArray array];
+  ENRMCollectGestures(textView, all);
+  for (UIGestureRecognizer *recognizer in all) {
+    if ([_gestures containsObject:recognizer]) {
+      continue;
+    }
+    if (recognizer == textView.panGestureRecognizer || recognizer == textView.pinchGestureRecognizer) {
+      continue;
+    }
+    if ([recognizer isKindOfClass:[UITapGestureRecognizer class]]) {
+      continue;
+    }
+    [_gestures addObject:recognizer];
+    [recognizer addTarget:self action:@selector(gestureChanged:)];
+  }
+}
+
+- (void)reset
+{
+  _adjusting = NO;
+}
+
+- (void)gestureChanged:(UIGestureRecognizer *)recognizer
+{
+  BOOL adjusting = NO;
+  for (UIGestureRecognizer *tracked in _gestures) {
+    UIGestureRecognizerState state = tracked.state;
+    if (state == UIGestureRecognizerStateBegan || state == UIGestureRecognizerStateChanged) {
+      adjusting = YES;
+      break;
+    }
+  }
+  if (adjusting == _adjusting) {
+    return;
+  }
+  _adjusting = adjusting;
+  _change();
+}
+
+@end
+#endif

package/ios/utils/EditMenuUtils+macOS.m

@@ -1,4 +1,5 @@
 #import "ContextMenuUtils.h"
+#import "ENRMLinkChip.h"
 #import "ENRMMenuAction.h"
 #import "EditMenuUtils.h"
 #import "PasteboardUtils.h"
@@ -19,7 +20,9 @@ NSMenu *_Nullable buildEditMenuForSelection(NSAttributedString *attributedText,
     return menu;
   }
 
-  NSAttributedString *selectedText = [attributedText attributedSubstringFromRange:range];
+  // Link spacers only reserve layout space; keep them out of every copied flavor.
+  NSAttributedString *selectedText =
+      ENRMAttributedStringByRemovingLinkSpacers([attributedText attributedSubstringFromRange:range]);
   NSString *markdown = markdownForRange(attributedText, range, cachedMarkdown);
   NSArray<NSString *> *imageURLs = imageURLsInRange(attributedText, range);
 

package/ios/utils/EditMenuUtils.h

@@ -9,6 +9,15 @@ NS_ASSUME_NONNULL_BEGIN
 typedef struct {
   BOOL copyAsMarkdown;
   BOOL copyImageURL;
+  BOOL copyEnabled;
+  // Copy writes Markdown as plain text instead of rich text.
+  BOOL copyFormatMarkdown;
+  // Drop every system-provided item from the text selection menu.
+  BOOL systemItemsNone;
+  BOOL codeBlockCopyButton;
+  // Copy hands the selection to the owner (JS `onCopy`) instead of writing the
+  // pasteboard.
+  BOOL interceptCopy;
   // 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;
@@ -18,6 +27,10 @@ typedef struct {
   __unsafe_unretained NSArray<NSString *> *_Nullable copyImageUrlPluralTemplates;
 } ENRMSelectionMenuConfig;
 
+/// Receives an intercepted Copy. `fullSelection` is whether the range spans the
+/// whole attributed text, in which case `markdown` is the cached markdown.
+typedef void (^ENRMCopyRequestHandler)(NSString *markdown, NSString *text, BOOL fullSelection);
+
 /// 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
@@ -36,6 +49,13 @@ static inline NSString *ENRMResolveImageURLsTitle(ENRMSelectionMenuConfig config
   return [titleTemplate stringByReplacingOccurrencesOfString:@"{count}" withString:[@(count) stringValue]];
 }
 
+/// Defaults matching the JS-side defaults, used until the first props update.
+static inline ENRMSelectionMenuConfig ENRMDefaultSelectionMenuConfig(void)
+{
+  return (ENRMSelectionMenuConfig){
+      .copyAsMarkdown = YES, .copyImageURL = YES, .copyEnabled = YES, .codeBlockCopyButton = YES};
+}
+
 #ifdef __cplusplus
 
 /// Strong owners for the label strings in ENRMSelectionMenuConfig.
@@ -63,13 +83,18 @@ template <typename T> static inline ENRMSelectionMenuLabels ENRMParseSelectionMe
   };
 }
 
-/// Builds an ENRMSelectionMenuConfig from pre-parsed labels and boolean flags.
-static inline ENRMSelectionMenuConfig ENRMBuildSelectionMenuConfig(const ENRMSelectionMenuLabels &labels,
-                                                                   bool copyAsMarkdown, bool copyImageUrl)
+/// Builds an ENRMSelectionMenuConfig from pre-parsed labels and the codegen struct's flags.
+template <typename T>
+static inline ENRMSelectionMenuConfig ENRMBuildSelectionMenuConfig(const ENRMSelectionMenuLabels &labels, const T &src)
 {
   return (ENRMSelectionMenuConfig){
-      .copyAsMarkdown = copyAsMarkdown,
-      .copyImageURL = copyImageUrl,
+      .copyAsMarkdown = src.copyAsMarkdown,
+      .copyImageURL = src.copyImageUrl,
+      .copyEnabled = src.copyEnabled,
+      .copyFormatMarkdown = src.copyFormatMarkdown,
+      .systemItemsNone = src.systemItemsNone,
+      .codeBlockCopyButton = src.codeBlockCopyButton,
+      .interceptCopy = src.interceptCopy,
       .copyLabel = labels.copyLabel,
       .copyAsMarkdownLabel = labels.copyAsMarkdownLabel,
       .copyImageUrlLabel = labels.copyImageUrlLabel,
@@ -90,7 +115,11 @@ extern "C" {
 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));
+                                  ENRMSelectionMenuConfig selectionMenuConfig,
+                                  ENRMCopyRequestHandler _Nullable onCopyRequest) API_AVAILABLE(ios(16.0));
+
+void ENRMSelectRangeAndPresentEditMenu(UITextView *textView, NSRange range);
+void ENRMDismissSelectionEditMenuIfMoved(UITextView *textView);
 #else
 NSMenu *_Nullable buildEditMenuForSelection(NSAttributedString *attributedText, NSRange range,
                                             NSString *_Nullable cachedMarkdown, StyleConfig *styleConfig,

package/ios/utils/EditMenuUtils.m

@@ -1,4 +1,5 @@
 #import "EditMenuUtils.h"
+#import "ENRMLinkChip.h"
 #import "PasteboardUtils.h"
 #import "StyleConfig.h"
 #include <TargetConditionals.h>
@@ -10,14 +11,34 @@ static NSString *const kActionIdentifierCopy = @"com.swmansion.enriched.markdown
 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,
-                                  NSString *copyLabel)
+static UIAction *_Nullable createCopyAction(NSAttributedString *selectedText, NSString *markdown, BOOL fullSelection,
+                                            StyleConfig *styleConfig, ENRMSelectionMenuConfig selectionMenuConfig,
+                                            ENRMCopyRequestHandler _Nullable onCopyRequest)
 {
-  return [UIAction actionWithTitle:copyLabel
+  if (!selectionMenuConfig.copyEnabled)
+    return nil;
+
+  if (selectionMenuConfig.interceptCopy && onCopyRequest) {
+    NSString *text = selectedText.string;
+    NSString *copied = markdown.length > 0 ? markdown : text;
+    return [UIAction actionWithTitle:selectionMenuConfig.copyLabel
+                               image:[RCTUIImage systemImageNamed:@"doc.on.doc"]
+                          identifier:kActionIdentifierCopy
+                             handler:^(__kindof UIAction *action) { onCopyRequest(copied, text, fullSelection); }];
+  }
+
+  BOOL writesMarkdown = selectionMenuConfig.copyFormatMarkdown;
+  return [UIAction actionWithTitle:selectionMenuConfig.copyLabel
                              image:[RCTUIImage systemImageNamed:@"doc.on.doc"]
                         identifier:kActionIdentifierCopy
                            handler:^(__kindof UIAction *action) {
-                             copyAttributedStringToPasteboard(selectedText, markdown, styleConfig);
+                             if (!writesMarkdown) {
+                               copyAttributedStringToPasteboard(selectedText, markdown, styleConfig);
+                             } else {
+                               // Plain text only: with HTML/RTF alongside, rich-paste targets
+                               // would take those and drop the Markdown.
+                               copyStringToPasteboard(markdown.length > 0 ? markdown : selectedText.string);
+                             }
                            }];
 }
 
@@ -48,10 +69,11 @@ static UIAction *_Nullable createCopyImageURLAction(NSArray<NSString *> *imageUR
 }
 
 /// Rebuilds the standard-edit menu with the system Copy swapped for the enhanced
-/// copy action. All other system items are kept — dropping them would remove
-/// Select All, which on iOS 16+ is the only way to start a selection from the
-/// long-press menu of a non-editable text view.
-static UIMenu *createEnhancedStandardEditMenu(UIMenu *originalMenu, UIAction *copyAction)
+/// copy action, or dropped when `copyAction` is nil (Copy disabled). All other
+/// system items are kept — dropping them would remove Select All, which on
+/// iOS 16+ is the only way to start a selection from the long-press menu of a
+/// non-editable text view.
+static UIMenu *createEnhancedStandardEditMenu(UIMenu *originalMenu, UIAction *_Nullable copyAction)
 {
   NSMutableArray<UIMenuElement *> *children = [NSMutableArray arrayWithCapacity:originalMenu.children.count];
   BOOL replacedCopy = NO;
@@ -59,14 +81,16 @@ static UIMenu *createEnhancedStandardEditMenu(UIMenu *originalMenu, UIAction *co
   for (UIMenuElement *element in originalMenu.children) {
     if (!replacedCopy && [element isKindOfClass:[UICommand class]] &&
         ((UICommand *)element).action == @selector(copy:)) {
-      [children addObject:copyAction];
+      if (copyAction) {
+        [children addObject:copyAction];
+      }
       replacedCopy = YES;
       continue;
     }
     [children addObject:element];
   }
 
-  if (!replacedCopy) {
+  if (!replacedCopy && copyAction) {
     [children insertObject:copyAction atIndex:0];
   }
 
@@ -95,13 +119,19 @@ static void insertOptionalAction(NSMutableArray<UIMenuElement *> *array, UIActio
 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))
+                                  ENRMSelectionMenuConfig selectionMenuConfig,
+                                  ENRMCopyRequestHandler _Nullable onCopyRequest) API_AVAILABLE(ios(16.0))
 {
-  NSAttributedString *selectedText = [attributedText attributedSubstringFromRange:range];
+  // Link spacers only reserve layout space; keep them out of every copied flavor.
+  NSAttributedString *selectedText =
+      ENRMAttributedStringByRemovingLinkSpacers([attributedText attributedSubstringFromRange:range]);
   NSString *markdown = markdownForRange(attributedText, range, cachedMarkdown);
   NSArray<NSString *> *imageURLs = imageURLsInRange(attributedText, range);
+  // Same threshold markdownForRange uses to return the cached markdown.
+  BOOL fullSelection = range.location == 0 && range.length >= attributedText.length - 1;
 
-  UIAction *copyAction = createCopyAction(selectedText, markdown, styleConfig, selectionMenuConfig.copyLabel);
+  UIAction *copyAction =
+      createCopyAction(selectedText, markdown, fullSelection, styleConfig, selectionMenuConfig, onCopyRequest);
   UIAction *copyMarkdownAction = selectionMenuConfig.copyAsMarkdown
                                      ? createCopyMarkdownAction(markdown, selectionMenuConfig.copyAsMarkdownLabel)
                                      : nil;
@@ -109,6 +139,16 @@ UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange ra
       selectionMenuConfig.copyImageURL ? createCopyImageURLAction(imageURLs, selectionMenuConfig) : nil;
 
   NSMutableArray<UIMenuElement *> *result = [NSMutableArray array];
+
+  if (selectionMenuConfig.systemItemsNone) {
+    // Skip suggestedActions entirely. An empty result still yields an (empty)
+    // menu: returning nil would make UIKit present its default menu.
+    addOptionalAction(result, copyAction);
+    addOptionalAction(result, copyMarkdownAction);
+    addOptionalAction(result, copyImageURLAction);
+    return [UIMenu menuWithChildren:[(customActions ?: @[]) arrayByAddingObjectsFromArray:result]];
+  }
+
   BOOL foundStandardEditMenu = NO;
 
   for (UIMenuElement *element in suggestedActions) {
@@ -128,8 +168,8 @@ UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange ra
   }
 
   if (!foundStandardEditMenu) {
-    [result insertObject:copyAction atIndex:0];
-    insertOptionalAction(result, copyMarkdownAction, 1);
+    insertOptionalAction(result, copyMarkdownAction, 0);
+    insertOptionalAction(result, copyAction, 0);
     addOptionalAction(result, copyImageURLAction);
   }
 
@@ -140,4 +180,120 @@ UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange ra
   return [UIMenu menuWithChildren:result];
 }
 
+#import <objc/runtime.h>
+
+static const void *kSelectionEditMenuPresenterKey = &kSelectionEditMenuPresenterKey;
+
+API_AVAILABLE(ios(16.0))
+@interface ENRMSelectionEditMenuPresenter : NSObject <UIEditMenuInteractionDelegate>
+@property (nonatomic, weak) UITextView *textView;
+@property (nonatomic, strong) UIEditMenuInteraction *interaction;
+@property (nonatomic, assign) NSRange range;
+@end
+
+@implementation ENRMSelectionEditMenuPresenter
+
+- (UIMenu *)editMenuInteraction:(UIEditMenuInteraction *)interaction
+           menuForConfiguration:(UIEditMenuConfiguration *)configuration
+               suggestedActions:(NSArray<UIMenuElement *> *)suggestedActions
+{
+  UITextView *textView = self.textView;
+  id<UITextViewDelegate> delegate = textView.delegate;
+  if (!textView || ![delegate respondsToSelector:@selector(textView:editMenuForTextInRange:suggestedActions:)]) {
+    return nil;
+  }
+  return [delegate textView:textView editMenuForTextInRange:textView.selectedRange suggestedActions:suggestedActions];
+}
+
+- (CGRect)editMenuInteraction:(UIEditMenuInteraction *)interaction
+    targetRectForConfiguration:(UIEditMenuConfiguration *)configuration
+{
+  UITextView *textView = self.textView;
+  UITextRange *textRange = textView.selectedTextRange;
+  if (!textView || !textRange) {
+    return CGRectNull;
+  }
+  return [textView firstRectForRange:textRange];
+}
+
+@end
+
+static BOOL selectionEditMenuTextViewHasActiveGesture(UITextView *textView)
+{
+  for (UIGestureRecognizer *recognizer in textView.gestureRecognizers) {
+    if (recognizer.state == UIGestureRecognizerStateBegan || recognizer.state == UIGestureRecognizerStateChanged) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+static void presentSelectionEditMenu(UITextView *textView)
+{
+  UITextRange *textRange = textView.selectedTextRange;
+  if (!textRange || textRange.isEmpty) {
+    return;
+  }
+  CGRect rect = [textView firstRectForRange:textRange];
+  if (CGRectIsNull(rect) || CGRectIsEmpty(rect)) {
+    return;
+  }
+  if (@available(iOS 16.0, *)) {
+    ENRMSelectionEditMenuPresenter *presenter = objc_getAssociatedObject(textView, kSelectionEditMenuPresenterKey);
+    if (!presenter) {
+      presenter = [[ENRMSelectionEditMenuPresenter alloc] init];
+      presenter.textView = textView;
+      presenter.interaction = [[UIEditMenuInteraction alloc] initWithDelegate:presenter];
+      [textView addInteraction:presenter.interaction];
+      objc_setAssociatedObject(textView, kSelectionEditMenuPresenterKey, presenter, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    }
+    presenter.range = textView.selectedRange;
+    UIEditMenuConfiguration *configuration =
+        [UIEditMenuConfiguration configurationWithIdentifier:nil
+                                                 sourcePoint:CGPointMake(CGRectGetMidX(rect), CGRectGetMinY(rect))];
+    [presenter.interaction presentEditMenuWithConfiguration:configuration];
+    return;
+  }
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  [[UIMenuController sharedMenuController] showMenuFromView:textView rect:rect];
+#pragma clang diagnostic pop
+}
+
+static void presentSelectionEditMenuWhenTouchEnds(UITextView *textView, NSRange range, NSUInteger attemptsLeft)
+{
+  if (!NSEqualRanges(textView.selectedRange, range)) {
+    return;
+  }
+  if (attemptsLeft > 0 && selectionEditMenuTextViewHasActiveGesture(textView)) {
+    __weak UITextView *weakTextView = textView;
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(50 * NSEC_PER_MSEC)), dispatch_get_main_queue(), ^{
+      UITextView *strongTextView = weakTextView;
+      if (strongTextView) {
+        presentSelectionEditMenuWhenTouchEnds(strongTextView, range, attemptsLeft - 1);
+      }
+    });
+    return;
+  }
+  presentSelectionEditMenu(textView);
+}
+
+void ENRMSelectRangeAndPresentEditMenu(UITextView *textView, NSRange range)
+{
+  [textView becomeFirstResponder];
+  textView.selectedRange = range;
+  presentSelectionEditMenuWhenTouchEnds(textView, range, 200);
+}
+
+void ENRMDismissSelectionEditMenuIfMoved(UITextView *textView)
+{
+  if (@available(iOS 16.0, *)) {
+    ENRMSelectionEditMenuPresenter *presenter = objc_getAssociatedObject(textView, kSelectionEditMenuPresenterKey);
+    if (presenter && !NSEqualRanges(textView.selectedRange, presenter.range)) {
+      presenter.range = NSMakeRange(NSNotFound, 0);
+      [presenter.interaction dismissMenu];
+    }
+  }
+}
+
 #endif

package/ios/utils/HTMLGenerator.m

@@ -3,6 +3,7 @@
 #import "CodeBackground.h"
 #import "ENRMFeatureFlags.h"
 #import "ENRMImageAttachment.h"
+#import "ENRMLinkChip.h"
 #import "HighlightRenderer.h"
 #if ENRICHED_MARKDOWN_MATH
 #import "ENRMMathInlineAttachment.h"
@@ -460,7 +461,7 @@ static void generateInlineHTML(NSMutableString *html, NSAttributedString *attrib
                       usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange attrRange, BOOL *stop) {
                         NSString *text = [string substringWithRange:attrRange];
 
-                        if ([text isEqualToString:@"\n"])
+                        if ([text isEqualToString:@"\n"] || attrs[ENRMLinkSpacerAttributeName])
                           return;
 
                         if ([text containsString:kObjectReplacementChar]) {

package/ios/utils/MarkdownAccessibilityElementBuilder.m

@@ -2,6 +2,7 @@
 #import "AccessibilityInfo.h"
 #import "BlockquoteBorder.h"
 #import "ENRMAccessibilityLabels.h"
+#import "ENRMLinkChip.h"
 #include <TargetConditionals.h>
 
 typedef NS_ENUM(NSInteger, ElementType) { ElementTypeText, ElementTypeLink, ElementTypeImage };
@@ -113,7 +114,8 @@ static const CGFloat kFocusRectPadding = 2.0;
     }
 
     BOOL isImg = item[@"altText"] != nil;
-    NSString *label = isImg ? item[@"altText"] : [fullText substringWithRange:itemRange];
+    // Link chips pad their text with spacer characters; keep them out of the spoken label.
+    NSString *label = isImg ? item[@"altText"] : ENRMPlainTextByRemovingLinkSpacers(textView.attributedText, itemRange);
     [elements addObject:[self createElementForRange:itemRange
                                                type:isImg ? ElementTypeImage : ElementTypeLink
                                                text:label

package/ios/utils/MarkdownExtractor.m

@@ -2,6 +2,7 @@
 #import "BlockquoteBorder.h"
 #import "ENRMFeatureFlags.h"
 #import "ENRMImageAttachment.h"
+#import "ENRMLinkChip.h"
 #import "ENRMUIKit.h"
 #import "HighlightRenderer.h"
 #include <TargetConditionals.h>
@@ -152,7 +153,7 @@ NSString *_Nullable extractMarkdownFromAttributedString(NSAttributedString *attr
                          options:0
                       usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange attrRange, BOOL *stop) {
                         NSString *text = [[attributedText attributedSubstringFromRange:attrRange] string];
-                        if (text.length == 0)
+                        if (text.length == 0 || attrs[ENRMLinkSpacerAttributeName])
                           return;
 
                         // Images and Thematic Breaks