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

package/ios/utils/ENRMLinkChip.h

@@ -0,0 +1,70 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Marks a link range that carries chip styling. The value is one
+/// `ENRMLinkChip` instance per link: instances compare by identity, so two
+/// adjacent links never coalesce into one attribute run (one chip).
+extern NSString *const ENRMLinkChipAttributeName;
+
+/// Marks the spacer characters `LinkRenderer` inserts at both outer edges of a
+/// link to reserve `paddingHorizontal` in the line. Spacers are layout-only:
+/// every text exit point (copy, markdown/HTML export, decoration text) strips
+/// them by this attribute — never by character, since U+00A0 can be content.
+extern NSString *const ENRMLinkSpacerAttributeName;
+
+@interface ENRMLinkChip : NSObject
+@property (nonatomic, strong, nullable) RCTUIColor *backgroundColor;
+@property (nonatomic, strong, nullable) RCTUIColor *borderColor;
+@property (nonatomic, assign) CGFloat borderWidth;
+@property (nonatomic, assign) CGFloat borderRadius;
+@property (nonatomic, assign) CGFloat paddingHorizontal;
+@property (nonatomic, assign) CGFloat paddingVertical;
+/// YES when the chip paints something (a background or a visible border).
+@property (nonatomic, readonly) BOOL isVisible;
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// A spacer character (U+00A0) whose advance is exactly `width`.
+///
+/// U+00A0 is line-break class GL: a break is allowed before it after a space
+/// but never after it, and never before it after a non-space — so a leading
+/// spacer always travels with the link's first glyph and a trailing one with
+/// its last glyph (no orphaned padding at a wrap). It uses a 1pt system font
+/// so its own advance and line-height contribution are negligible whatever
+/// the link font (a custom font may lack U+00A0), and NSKern makes up the rest.
+NSAttributedString *ENRMLinkSpacerString(NSDictionary<NSAttributedStringKey, id> *baseAttributes, CGFloat width);
+
+/// `string` without link spacers (returns `string` itself when it has none).
+NSAttributedString *ENRMAttributedStringByRemovingLinkSpacers(NSAttributedString *string);
+
+/// Plain text of `range` without link spacers.
+NSString *ENRMPlainTextByRemovingLinkSpacers(NSAttributedString *string, NSRange range);
+
+/// Falls back to a plain `NSBackgroundColorAttributeName` for every chip
+/// background, for text drawn without `TextViewLayoutManager` (table cells,
+/// RTF export). Radius, border and vertical padding are not represented.
+void ENRMApplyLinkChipBackgroundsAsTextBackground(NSMutableAttributedString *string);
+
+/// Enumerates the chip rect of every laid-out line fragment of the link at
+/// `charRange`, in text-container coordinates. The rect spans the glyphs
+/// (spacers included, so it already covers `paddingHorizontal`) horizontally
+/// and the link font's ascender..descender ± `paddingVertical` vertically.
+void ENRMEnumerateLinkChipFragments(NSLayoutManager *layoutManager, NSTextContainer *textContainer, NSRange charRange,
+                                    ENRMLinkChip *_Nullable chip,
+                                    void (^block)(CGRect rect, BOOL isFirst, BOOL isLast));
+
+/// Draws the visible link chips intersecting `glyphsToShow`. Called from the
+/// layout manager's background pass, before glyphs are drawn.
+void ENRMDrawLinkChipsForGlyphRange(NSLayoutManager *layoutManager, NSTextContainer *textContainer,
+                                    NSRange glyphsToShow, CGPoint origin);
+
+#ifdef __cplusplus
+}
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMLinkChip.m

@@ -0,0 +1,194 @@
+#import "ENRMLinkChip.h"
+#import "ENRMChipDrawing.h"
+#import <CoreText/CoreText.h>
+
+NSString *const ENRMLinkChipAttributeName = @"ENRMLinkChip";
+NSString *const ENRMLinkSpacerAttributeName = @"ENRMLinkSpacer";
+
+static const unichar kSpacerChar = 0x00A0;
+static const CGFloat kSpacerFontSize = 1.0;
+
+@implementation ENRMLinkChip
+
+- (BOOL)isVisible
+{
+  return self.backgroundColor != nil || (self.borderColor != nil && self.borderWidth > 0);
+}
+
+@end
+
+#pragma mark - Spacers
+
+static CGFloat spacerAdvance(UIFont *font)
+{
+  CTFontRef ctFont = (__bridge CTFontRef)font;
+  UniChar character = kSpacerChar;
+  CGGlyph glyph = 0;
+  if (!CTFontGetGlyphsForCharacters(ctFont, &character, &glyph, 1))
+    return 0;
+  CGSize advance = CGSizeZero;
+  CTFontGetAdvancesForGlyphs(ctFont, kCTFontOrientationHorizontal, &glyph, &advance, 1);
+  return advance.width;
+}
+
+NSAttributedString *ENRMLinkSpacerString(NSDictionary<NSAttributedStringKey, id> *baseAttributes, CGFloat width)
+{
+  static UIFont *spacerFont;
+  static CGFloat spacerFontAdvance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    spacerFont = [UIFont systemFontOfSize:kSpacerFontSize];
+    spacerFontAdvance = spacerAdvance(spacerFont);
+  });
+
+  NSMutableDictionary *attributes = [baseAttributes mutableCopy] ?: [NSMutableDictionary dictionary];
+  attributes[NSFontAttributeName] = spacerFont;
+  attributes[NSKernAttributeName] = @(width - spacerFontAdvance);
+  attributes[ENRMLinkSpacerAttributeName] = @YES;
+  // Padding is not text: keep decorations and attachments off it.
+  [attributes removeObjectForKey:NSUnderlineStyleAttributeName];
+  [attributes removeObjectForKey:NSStrikethroughStyleAttributeName];
+  [attributes removeObjectForKey:NSAttachmentAttributeName];
+
+  NSString *spacer = [NSString stringWithCharacters:&kSpacerChar length:1];
+  return [[NSAttributedString alloc] initWithString:spacer attributes:attributes];
+}
+
+NSAttributedString *ENRMAttributedStringByRemovingLinkSpacers(NSAttributedString *string)
+{
+  __block NSMutableAttributedString *stripped = nil;
+  [string enumerateAttribute:ENRMLinkSpacerAttributeName
+                     inRange:NSMakeRange(0, string.length)
+                     options:NSAttributedStringEnumerationReverse
+                  usingBlock:^(id value, NSRange range, BOOL *stop) {
+                    if (!value)
+                      return;
+                    if (!stripped)
+                      stripped = [string mutableCopy];
+                    [stripped deleteCharactersInRange:range];
+                  }];
+  return stripped ?: string;
+}
+
+NSString *ENRMPlainTextByRemovingLinkSpacers(NSAttributedString *string, NSRange range)
+{
+  if (range.location == NSNotFound || NSMaxRange(range) > string.length)
+    return @"";
+  return ENRMAttributedStringByRemovingLinkSpacers([string attributedSubstringFromRange:range]).string;
+}
+
+void ENRMApplyLinkChipBackgroundsAsTextBackground(NSMutableAttributedString *string)
+{
+  [string enumerateAttribute:ENRMLinkChipAttributeName
+                     inRange:NSMakeRange(0, string.length)
+                     options:0
+                  usingBlock:^(ENRMLinkChip *chip, NSRange range, BOOL *stop) {
+                    if (chip.backgroundColor) {
+                      [string addAttribute:NSBackgroundColorAttributeName value:chip.backgroundColor range:range];
+                    }
+                  }];
+}
+
+#pragma mark - Geometry
+
+/// The font of the first non-spacer character of `charRange` — the spacer's
+/// 1pt font must not drive the chip's height.
+static UIFont *_Nullable chipFontInRange(NSTextStorage *storage, NSRange charRange)
+{
+  __block UIFont *font = nil;
+  [storage enumerateAttributesInRange:charRange
+                              options:0
+                           usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange range, BOOL *stop) {
+                             if (attrs[ENRMLinkSpacerAttributeName])
+                               return;
+                             font = attrs[NSFontAttributeName];
+                             *stop = font != nil;
+                           }];
+  return font;
+}
+
+void ENRMEnumerateLinkChipFragments(NSLayoutManager *layoutManager, NSTextContainer *textContainer, NSRange charRange,
+                                    ENRMLinkChip *chip, void (^block)(CGRect rect, BOOL isFirst, BOOL isLast))
+{
+  NSTextStorage *storage = layoutManager.textStorage;
+  if (charRange.length == 0 || NSMaxRange(charRange) > storage.length)
+    return;
+
+  NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:charRange actualCharacterRange:NULL];
+  if (glyphRange.location == NSNotFound || glyphRange.length == 0)
+    return;
+
+  CGFloat paddingHorizontal = chip.paddingHorizontal;
+  CGFloat paddingVertical = chip.paddingVertical;
+
+  [layoutManager
+      enumerateLineFragmentsForGlyphRange:glyphRange
+                               usingBlock:^(CGRect lineRect, CGRect usedRect, NSTextContainer *tc, NSRange lineRange,
+                                            BOOL *stop) {
+                                 NSRange intersect = NSIntersectionRange(lineRange, glyphRange);
+                                 if (intersect.length == 0)
+                                   return;
+
+                                 BOOL isFirst = intersect.location == glyphRange.location;
+                                 BOOL isLast = NSMaxRange(intersect) == NSMaxRange(glyphRange);
+
+                                 CGRect textRect = [layoutManager boundingRectForGlyphRange:intersect
+                                                                            inTextContainer:textContainer];
+                                 CGFloat left = CGRectGetMinX(textRect);
+                                 CGFloat right = CGRectGetMaxX(textRect);
+
+                                 // The trailing spacer's kern is its advance; don't rely on the
+                                 // glyph bounds including it.
+                                 if (isLast && paddingHorizontal > 0) {
+                                   NSUInteger lastGlyph = NSMaxRange(intersect) - 1;
+                                   CGFloat spacerX =
+                                       lineRect.origin.x + [layoutManager locationForGlyphAtIndex:lastGlyph].x;
+                                   right = MAX(right, spacerX + paddingHorizontal);
+                                 }
+
+                                 NSRange fragmentChars = [layoutManager characterRangeForGlyphRange:intersect
+                                                                                   actualGlyphRange:NULL];
+                                 UIFont *font = chipFontInRange(storage, fragmentChars);
+                                 CGFloat top = CGRectGetMinY(textRect);
+                                 CGFloat bottom = CGRectGetMaxY(textRect);
+                                 if (font) {
+                                   // locationForGlyphAtIndex: y is the baseline within the line fragment.
+                                   CGFloat baseline =
+                                       lineRect.origin.y + [layoutManager locationForGlyphAtIndex:intersect.location].y;
+                                   top = baseline - font.ascender;
+                                   bottom = baseline - font.descender;
+                                 }
+                                 top -= paddingVertical;
+                                 bottom += paddingVertical;
+
+                                 block(CGRectMake(left, top, right - left, bottom - top), isFirst, isLast);
+                               }];
+}
+
+#pragma mark - Drawing
+
+void ENRMDrawLinkChipsForGlyphRange(NSLayoutManager *layoutManager, NSTextContainer *textContainer,
+                                    NSRange glyphsToShow, CGPoint origin)
+{
+  NSTextStorage *storage = layoutManager.textStorage;
+  NSRange charRange = [layoutManager characterRangeForGlyphRange:glyphsToShow actualGlyphRange:NULL];
+  if (charRange.location == NSNotFound || charRange.length == 0)
+    return;
+
+  // Enumerate the whole storage (like CodeBackground) so a chip that starts
+  // before the dirty range still gets its full rect.
+  [storage enumerateAttribute:ENRMLinkChipAttributeName
+                      inRange:NSMakeRange(0, storage.length)
+                      options:0
+                   usingBlock:^(ENRMLinkChip *chip, NSRange range, BOOL *stop) {
+                     if (!chip.isVisible || NSIntersectionRange(range, charRange).length == 0)
+                       return;
+
+                     ENRMEnumerateLinkChipFragments(
+                         layoutManager, textContainer, range, chip, ^(CGRect rect, BOOL isFirst, BOOL isLast) {
+                           ENRMDrawChipFragment(CGRectOffset(rect, origin.x, origin.y), chip.backgroundColor,
+                                                chip.borderColor, chip.borderWidth, chip.borderRadius, isFirst, isLast,
+                                                YES);
+                         });
+                   }];
+}

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/EditMenuUtils+macOS.m

@@ -1,6 +1,7 @@
 #import "ContextMenuUtils.h"
 #import "ENRMMenuAction.h"
 #import "EditMenuUtils.h"
+#import "ENRMLinkChip.h"
 #import "PasteboardUtils.h"
 #import "StyleConfig.h"
 #include <TargetConditionals.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,9 @@ 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/TableContainerView.h

@@ -65,6 +65,9 @@ typedef void (^TableLinkPressBlock)(NSString *url);
 @property (nonatomic, copy, nullable) ENRMBlockCopyRequestBlock onCopyRequest;
 
 @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;
 

package/ios/views/TableContainerView.m

@@ -1,4 +1,5 @@
 #import "TableContainerView.h"
+#import "ENRMLinkChip.h"
 #import "AttributedRenderer.h"
 #import "ENRMAccessibilityLabels.h"
 #import "HTMLGenerator.h"
@@ -90,6 +91,8 @@ static NSMutableAttributedString *ENRMTableRenderCellNode(MarkdownASTNode *cellN
   NSMutableAttributedString *attributedText = [renderer renderRoot:temporaryRoot context:context];
 
   [context applyLinkAttributesToString:attributedText];
+  // Cells draw with -drawWithRect:, which bypasses the layout manager that paints link chips.
+  ENRMApplyLinkChipBackgroundsAsTextBackground(attributedText);
 
   ENRMApplyWritingDirectionMode(attributedText, writingDirectionMode, resolvedLayoutDirection);
 
@@ -302,6 +305,24 @@ static void ENRMTableComputeLayout(NSArray<NSArray<TableCellData *> *> *rows, NS
   return _rows.count;
 }
 
+- (NSInteger)linkCount
+{
+  __block NSInteger count = 0;
+  for (NSArray<TableCellData *> *row in _rows) {
+    for (TableCellData *cell in row) {
+      // LinkRenderer attaches one ENRMLinkChip instance per link.
+      [cell.attributedText enumerateAttribute:ENRMLinkChipAttributeName
+                                      inRange:NSMakeRange(0, cell.attributedText.length)
+                                      options:0
+                                   usingBlock:^(id chip, NSRange range, BOOL *stop) {
+                                     if (chip)
+                                       count++;
+                                   }];
+    }
+  }
+  return count;
+}
+
 #if !TARGET_OS_OSX
 - (void)animateNewRowsFromPreviousCount:(NSUInteger)previousRowCount duration:(NSTimeInterval)duration
 {

package/lib/module/EnrichedMarkdownNativeComponent.ts

@@ -75,6 +75,11 @@ interface LinkStyleInternal {
   color: ColorValue;
   underline: boolean;
   backgroundColor: ColorValue;
+  borderRadius: CodegenTypes.Float;
+  paddingHorizontal: CodegenTypes.Float;
+  paddingVertical: CodegenTypes.Float;
+  borderColor: ColorValue;
+  borderWidth: CodegenTypes.Float;
 }
 
 // Mirrors EnrichedMarkdownTextNativeComponent.ts — kept in sync manually (codegen spec files must be self-contained).
@@ -83,6 +88,11 @@ interface LinkVariantEntryInternal {
   color: ColorValue;
   underline: boolean;
   backgroundColor: ColorValue;
+  borderRadius: CodegenTypes.Float;
+  paddingHorizontal: CodegenTypes.Float;
+  paddingVertical: CodegenTypes.Float;
+  borderColor: ColorValue;
+  borderWidth: CodegenTypes.Float;
 }
 
 interface StrongStyleInternal {
@@ -245,6 +255,25 @@ export interface LinkLongPressEvent {
   url: string;
 }
 
+/**
+ * `fragments` holds one entry per laid-out line of a link (a wrapping link
+ * yields several). Rects are in dp, relative to the native view's origin, and
+ * cover the drawn chip (glyphs + padding). Flattened rather than nested per
+ * link, and written inline, because codegen only accepts inline object
+ * literals as event array elements.
+ */
+export interface LinkLayoutEvent {
+  fragments: {
+    linkIndex: CodegenTypes.Int32;
+    url: string;
+    text: string;
+    x: CodegenTypes.Double;
+    y: CodegenTypes.Double;
+    width: CodegenTypes.Double;
+    height: CodegenTypes.Double;
+  }[];
+}
+
 export interface TaskListItemPressEvent {
   index: CodegenTypes.Int32;
   checked: boolean;
@@ -400,6 +429,18 @@ export interface NativeProps extends ViewProps {
    * - Android: Handles long press gestures on links.
    */
   onLinkLongPress?: CodegenTypes.BubblingEventHandler<LinkLongPressEvent>;
+  /**
+   * When true, the view reports the laid-out rects of every link through
+   * `onLinkLayout` (after each render and whenever its size changes).
+   * Set by the JS wrapper only when `renderLinkDecoration` is provided.
+   * @default false
+   */
+  emitLinkLayout?: CodegenTypes.WithDefault<boolean, false>;
+  /**
+   * Fired with the rects of every link fragment while `emitLinkLayout` is on.
+   * Deduplicated: not re-fired when the payload is unchanged.
+   */
+  onLinkLayout?: CodegenTypes.DirectEventHandler<LinkLayoutEvent>;
   /**
    * Callback fired when a task list checkbox is tapped.
    * Receives the 0-based task index, current checked state, and the item's plain text.