react-native-enriched-markdown-scaffold 1.0.2-scaffold.3 → 1.0.2-scaffold.5

package/ios/utils/ENRMLinkLayout.h

@@ -0,0 +1,50 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Collects the chip rect of every link fragment laid out in `textView`, for
+/// the `onLinkLayout` event. Each entry is
+/// `@{linkIndex, url, text, x, y, width, height}` (NSNumber/NSString), so a
+/// payload compares with `-isEqualToArray:` for deduplication.
+///
+/// - `offset` is added to every rect (a segment's origin inside its container).
+/// - Links are numbered in document order starting at `indexBase`; the number
+///   of links found is written to `outLinkCount` so the next segment continues.
+///
+/// Rects are in points relative to the text view, which the markdown views
+/// configure with zero insets and no line-fragment padding.
+NSArray<NSDictionary *> *ENRMCollectLinkLayoutFragments(ENRMPlatformTextView *textView, CGPoint offset,
+                                                        NSInteger indexBase, NSInteger *_Nullable outLinkCount);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+/// Converts collected fragments into a codegen `OnLinkLayout` payload. Templated
+/// because each component has its own (structurally identical) event struct.
+template <typename Event> inline Event ENRMLinkLayoutEventFromFragments(NSArray<NSDictionary *> *fragments)
+{
+  Event event;
+  event.fragments.reserve(fragments.count);
+  for (NSDictionary *fragment in fragments) {
+    typename decltype(event.fragments)::value_type item;
+    item.linkIndex = [fragment[@"linkIndex"] intValue];
+    item.url = std::string([fragment[@"url"] UTF8String] ?: "");
+    item.text = std::string([fragment[@"text"] UTF8String] ?: "");
+    item.x = [fragment[@"x"] doubleValue];
+    item.y = [fragment[@"y"] doubleValue];
+    item.width = [fragment[@"width"] doubleValue];
+    item.height = [fragment[@"height"] doubleValue];
+    event.fragments.push_back(item);
+  }
+  return event;
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMLinkLayout.m

@@ -0,0 +1,45 @@
+#import "ENRMLinkLayout.h"
+#import "ENRMLinkChip.h"
+
+NSArray<NSDictionary *> *ENRMCollectLinkLayoutFragments(ENRMPlatformTextView *textView, CGPoint offset,
+                                                        NSInteger indexBase, NSInteger *outLinkCount)
+{
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  NSTextContainer *textContainer = textView.textContainer;
+  NSTextStorage *storage = layoutManager.textStorage;
+  NSMutableArray<NSDictionary *> *fragments = [NSMutableArray array];
+  __block NSInteger linkIndex = indexBase;
+
+  if (storage.length > 0 && textContainer != nil) {
+    // LinkRenderer attaches one ENRMLinkChip instance per link, so each
+    // attribute run is exactly one link (adjacent links never coalesce).
+    [storage enumerateAttribute:ENRMLinkChipAttributeName
+                        inRange:NSMakeRange(0, storage.length)
+                        options:0
+                     usingBlock:^(ENRMLinkChip *chip, NSRange range, BOOL *stop) {
+                       if (!chip)
+                         return;
+                       id link = [storage attribute:NSLinkAttributeName atIndex:range.location effectiveRange:NULL];
+                       NSString *url = [link isKindOfClass:[NSURL class]] ? [(NSURL *)link absoluteString] : link;
+                       NSString *text = ENRMPlainTextByRemovingLinkSpacers(storage, range);
+                       NSNumber *index = @(linkIndex++);
+
+                       ENRMEnumerateLinkChipFragments(layoutManager, textContainer, range, chip,
+                                                      ^(CGRect rect, BOOL isFirst, BOOL isLast) {
+                                                        [fragments addObject:@{
+                                                          @"linkIndex" : index,
+                                                          @"url" : url ?: @"",
+                                                          @"text" : text,
+                                                          @"x" : @(rect.origin.x + offset.x),
+                                                          @"y" : @(rect.origin.y + offset.y),
+                                                          @"width" : @(rect.size.width),
+                                                          @"height" : @(rect.size.height),
+                                                        }];
+                                                      });
+                     }];
+  }
+
+  if (outLinkCount)
+    *outLinkCount = linkIndex - indexBase;
+  return fragments;
+}

package/ios/utils/ENRMSelectionChange.h

@@ -0,0 +1,96 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Keys of an `onSelectionChange` payload. Rects are `NSValue`-wrapped CGRects in
+/// the reporting view's coordinates, so a payload compares with `-isEqual:` for
+/// deduplication.
+extern NSString *const ENRMSelectionActiveKey;
+extern NSString *const ENRMSelectionSourceKey;
+extern NSString *const ENRMSelectionTextKey;
+extern NSString *const ENRMSelectionMarkdownKey;
+extern NSString *const ENRMSelectionWholeKey;
+extern NSString *const ENRMSelectionRectKey;
+extern NSString *const ENRMSelectionStartRectKey;
+extern NSString *const ENRMSelectionEndRectKey;
+/// Only in `ENRMTextSelectionInTextView` results: whether the range spans the
+/// whole text (same threshold `markdownForRange` uses for the cached markdown).
+extern NSString *const ENRMSelectionFullKey;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// The payload reported once the selection is gone.
+NSDictionary *ENRMInactiveSelectionPayload(void);
+
+/// A long-pressed block (table / math / code): `whole`, every rect is `frame`.
+NSDictionary *ENRMBlockSelectionPayload(NSString *source, NSString *markdown, NSString *text, CGRect frame);
+
+#if !TARGET_OS_OSX
+/// Text, full-selection flag and rects of `textView`'s selection, converted to
+/// `targetView`'s coordinates; nil when nothing is selected. `rect` is the union
+/// of the selection rects, `startRect` / `endRect` the rects holding its start
+/// and end. The owner adds source, markdown and whole to build the payload.
+NSDictionary *_Nullable ENRMTextSelectionInTextView(UITextView *textView, UIView *targetView);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/// Coalesces selection changes into at most one report per run loop turn. The
+/// payload is read when the turn fires, so the latest state always reaches JS;
+/// a cleared selection is reported right away and drops any pending update.
+/// Identical payloads are sent once.
+@interface ENRMSelectionChangeReporter : NSObject
+
+- (instancetype)initWithSnapshot:(NSDictionary * (^)(void))snapshot
+                            emit:(void (^)(NSDictionary *payload))emit NS_DESIGNATED_INITIALIZER;
+- (instancetype)init NS_UNAVAILABLE;
+
+/// Off by default. Toggling resets the last reported payload to inactive.
+@property (nonatomic, assign) BOOL enabled;
+
+- (void)schedule;
+- (void)selectionChanged:(BOOL)hasSelection;
+- (void)flushNow;
+- (void)cancel;
+/// Makes the next report go out even if it equals the last one — a block
+/// long-pressed again is a new request for the app's menu, not a repeat.
+- (void)forgetLastReported;
+
+@end
+
+#ifdef __cplusplus
+/// Converts a payload into a codegen `OnSelectionChange` struct. Templated
+/// because each component has its own (structurally identical) event struct.
+template <typename Event> inline Event ENRMSelectionChangeEventFromPayload(NSDictionary *payload)
+{
+  Event event;
+  event.active = [payload[ENRMSelectionActiveKey] boolValue];
+  event.source = std::string([payload[ENRMSelectionSourceKey] UTF8String] ?: "selection");
+  event.text = std::string([payload[ENRMSelectionTextKey] UTF8String] ?: "");
+  event.markdown = std::string([payload[ENRMSelectionMarkdownKey] UTF8String] ?: "");
+  event.whole = [payload[ENRMSelectionWholeKey] boolValue];
+
+  auto assign = [](auto &target, NSValue *value) {
+#if TARGET_OS_OSX
+    CGRect rect = value ? NSRectToCGRect(value.rectValue) : CGRectZero;
+#else
+    CGRect rect = value ? value.CGRectValue : CGRectZero;
+#endif
+    target.x = rect.origin.x;
+    target.y = rect.origin.y;
+    target.width = rect.size.width;
+    target.height = rect.size.height;
+  };
+  assign(event.rect, payload[ENRMSelectionRectKey]);
+  assign(event.startRect, payload[ENRMSelectionStartRectKey]);
+  assign(event.endRect, payload[ENRMSelectionEndRectKey]);
+  return event;
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMSelectionChange.m

@@ -0,0 +1,204 @@
+#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 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

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.m

@@ -1,4 +1,5 @@
 #import "EditMenuUtils.h"
+#import "ENRMLinkChip.h"
 #import "PasteboardUtils.h"
 #import "StyleConfig.h"
 #include <TargetConditionals.h>
@@ -121,7 +122,9 @@ UIMenu *buildEditMenuForSelection(NSAttributedString *attributedText, NSRange ra
                                   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.

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

package/ios/utils/RTFExportUtils.m

@@ -1,6 +1,7 @@
 #import "RTFExportUtils.h"
 #import "BlockquoteBorder.h"
 #import "CodeBackground.h"
+#import "ENRMLinkChip.h"
 #import "LastElementUtils.h"
 #import "ListItemRenderer.h"
 #import "RenderContext.h"
@@ -288,6 +289,7 @@ NSAttributedString *prepareAttributedStringForRTFExport(NSAttributedString *attr
   RCTUIColor *blockquoteBgColor = [styleConfig blockquoteBackgroundColor];
 
   processThematicBreaks(prepared);
+  ENRMApplyLinkChipBackgroundsAsTextBackground(prepared);
   processCodes(prepared, codeBgColor);
   processCodeBlocks(prepared, codeBlockBgColor);
   processBlockquotes(prepared, blockquoteBgColor);

package/ios/utils/StylePropsUtils.h

@@ -523,6 +523,32 @@ BOOL applyMarkdownStyleToConfig(StyleConfig *config, const MarkdownStyle &newSty
     changed = YES;
   }
 
+  if (newStyle.link.borderRadius != oldStyle.link.borderRadius) {
+    [config setLinkBorderRadius:newStyle.link.borderRadius];
+    changed = YES;
+  }
+
+  if (newStyle.link.paddingHorizontal != oldStyle.link.paddingHorizontal) {
+    [config setLinkPaddingHorizontal:newStyle.link.paddingHorizontal];
+    changed = YES;
+  }
+
+  if (newStyle.link.paddingVertical != oldStyle.link.paddingVertical) {
+    [config setLinkPaddingVertical:newStyle.link.paddingVertical];
+    changed = YES;
+  }
+
+  if (newStyle.link.borderColor != oldStyle.link.borderColor) {
+    RCTUIColor *color = RCTUIColorFromSharedColor(newStyle.link.borderColor);
+    [config setLinkBorderColor:CGColorGetAlpha(color.CGColor) > 0 ? color : nil];
+    changed = YES;
+  }
+
+  if (newStyle.link.borderWidth != oldStyle.link.borderWidth) {
+    [config setLinkBorderWidth:newStyle.link.borderWidth];
+    changed = YES;
+  }
+
   {
     BOOL linkVariantsChanged = newStyle.linkVariants.size() != oldStyle.linkVariants.size();
     if (!linkVariantsChanged) {
@@ -530,7 +556,11 @@ BOOL applyMarkdownStyleToConfig(StyleConfig *config, const MarkdownStyle &newSty
         const auto &newVariant = newStyle.linkVariants[i];
         const auto &oldVariant = oldStyle.linkVariants[i];
         if (newVariant.pattern != oldVariant.pattern || newVariant.color != oldVariant.color ||
-            newVariant.underline != oldVariant.underline || newVariant.backgroundColor != oldVariant.backgroundColor) {
+            newVariant.underline != oldVariant.underline || newVariant.backgroundColor != oldVariant.backgroundColor ||
+            newVariant.borderRadius != oldVariant.borderRadius ||
+            newVariant.paddingHorizontal != oldVariant.paddingHorizontal ||
+            newVariant.paddingVertical != oldVariant.paddingVertical ||
+            newVariant.borderColor != oldVariant.borderColor || newVariant.borderWidth != oldVariant.borderWidth) {
           linkVariantsChanged = YES;
           break;
         }
@@ -545,6 +575,12 @@ BOOL applyMarkdownStyleToConfig(StyleConfig *config, const MarkdownStyle &newSty
         variant.underline = entry.underline;
         RCTUIColor *backgroundColor = RCTUIColorFromSharedColor(entry.backgroundColor);
         variant.backgroundColor = CGColorGetAlpha(backgroundColor.CGColor) > 0 ? backgroundColor : nil;
+        variant.borderRadius = entry.borderRadius;
+        variant.paddingHorizontal = entry.paddingHorizontal;
+        variant.paddingVertical = entry.paddingVertical;
+        RCTUIColor *borderColor = RCTUIColorFromSharedColor(entry.borderColor);
+        variant.borderColor = CGColorGetAlpha(borderColor.CGColor) > 0 ? borderColor : nil;
+        variant.borderWidth = entry.borderWidth;
         [variants addObject:variant];
       }
       [config setLinkVariants:variants];

package/ios/utils/TextViewLayoutManager.mm

@@ -2,6 +2,7 @@
 #import "BlockquoteBorder.h"
 #import "CodeBackground.h"
 #import "CodeBlockBackground.h"
+#import "ENRMLinkChip.h"
 #import "ListMarkerDrawer.h"
 #import "RuntimeKeys.h"
 #import "StyleConfig.h"
@@ -31,6 +32,8 @@
   // We fetch the objects into local variables FIRST to ensure they don't
   // disappear mid-method if setConfig: is called on another thread.
 
+  ENRMDrawLinkChipsForGlyphRange(self, textContainer, glyphsToShow, origin);
+
   CodeBackground *codeBg = [self getCodeBackgroundWithConfig:config];
   [codeBg drawBackgroundsForGlyphRange:glyphsToShow layoutManager:self textContainer:textContainer atPoint:origin];
 

package/ios/views/ENRMCodeBlockContainerView.h

@@ -45,6 +45,9 @@ typedef void (^ENRMCodeBlockCopyBlock)(NSString *code, NSString *language);
 /// Set by the host; receives the Copy item's content when
 /// `menuOptions.interceptCopy` is set.
 @property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onCopyRequest;
+/// Called instead of the menu on long press while `contextMenuHidden` is on, so
+/// the owner can report the block (`onSelectionChange`) and show its own UI.
+@property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onMenuSuppressed;
 
 // Fired when the code is copied (header button, context-menu Copy, or the
 // VoiceOver copy action); set by the host to bridge up to the JS onCopyPress

package/ios/views/ENRMCodeBlockContainerView.m

@@ -495,6 +495,9 @@ static BOOL ENRMColorIsDark(RCTUIColor *color)
 {
   // Returning nil is the UIKit-sanctioned way to suppress a context menu.
   if (_pending || self.contextMenuHidden) {
+    if (!_pending && self.onMenuSuppressed) {
+      self.onMenuSuppressed([self fencedMarkdown], _cachedCode ?: @"");
+    }
     return nil;
   }
   __weak __typeof(self) weakSelf = self;

package/ios/views/ENRMMathContainerView.h

@@ -42,6 +42,9 @@ NS_ASSUME_NONNULL_BEGIN
 /// Set by the host; receives the Copy item's content when
 /// `menuOptions.interceptCopy` is set.
 @property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onCopyRequest;
+/// Called instead of the menu on long press while `contextMenuHidden` is on, so
+/// the owner can report the block (`onSelectionChange`) and show its own UI.
+@property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onMenuSuppressed;
 
 @end
 

package/ios/views/ENRMMathContainerView.m

@@ -128,6 +128,9 @@
 {
   // Returning nil is the UIKit-sanctioned way to suppress a context menu.
   if (self.contextMenuHidden) {
+    if (self.onMenuSuppressed) {
+      self.onMenuSuppressed([NSString stringWithFormat:@"$$\n%@\n$$", _cachedLatex ?: @""], _cachedLatex ?: @"");
+    }
     return nil;
   }
   __weak __typeof(self) weakSelf = self;

package/ios/views/TableContainerView.h

@@ -63,8 +63,14 @@ typedef void (^TableLinkPressBlock)(NSString *url);
 /// Set by the host; receives the Copy item's content when
 /// `menuOptions.interceptCopy` is set.
 @property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onCopyRequest;
+/// Called instead of the menu on long press while `contextMenuHidden` is on, so
+/// the owner can report the block (`onSelectionChange`) and show its own UI.
+@property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onMenuSuppressed;
 
 @property (nonatomic, readonly) NSUInteger rowCount;
+/// Number of links across all cells. Tables are not reported by `onLinkLayout`,
+/// but their links still count so later link indices stay in document order.
+@property (nonatomic, readonly) NSInteger linkCount;
 
 - (void)animateNewRowsFromPreviousCount:(NSUInteger)previousRowCount duration:(NSTimeInterval)duration;