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

package/android/src/main/java/com/swmansion/enriched/markdown/views/BlockMenuOptions.kt

@@ -2,6 +2,9 @@ package com.swmansion.enriched.markdown.views
 
 import com.swmansion.enriched.markdown.utils.text.view.SelectionMenuConfig
 
+/** Receives an intercepted block Copy: the block's Markdown and its raw content. */
+typealias BlockCopyRequest = (markdown: String, text: String) -> Unit
+
 /**
  * Selection-menu options that table, math and code block views need for their
  * own long-press menus. Every default keeps the legacy behavior, so a block view
@@ -14,17 +17,23 @@ data class BlockMenuOptions(
   val copyAsMarkdownHidden: Boolean = false,
   // Hides the copy button in the code block header.
   val copyButtonHidden: Boolean = false,
+  // Set when `onCopy` is on: the Copy item hands the content here instead of
+  // writing the clipboard. The host binds it to the block's source.
+  val onCopyRequest: BlockCopyRequest? = null,
 ) {
   val hasItems: Boolean get() = !copyHidden || !copyAsMarkdownHidden
 
   companion object {
-    fun from(config: SelectionMenuConfig) =
-      BlockMenuOptions(
-        copyHidden = !config.copyEnabled,
-        copyWritesMarkdown = config.copyFormatMarkdown,
-        copyAsMarkdownHidden = !config.copyAsMarkdown,
-        copyButtonHidden = !config.codeBlockCopyButton,
-      )
+    fun from(
+      config: SelectionMenuConfig,
+      onCopyRequest: BlockCopyRequest? = null,
+    ) = BlockMenuOptions(
+      copyHidden = !config.copyEnabled,
+      copyWritesMarkdown = config.copyFormatMarkdown,
+      copyAsMarkdownHidden = !config.copyAsMarkdown,
+      copyButtonHidden = !config.codeBlockCopyButton,
+      onCopyRequest = onCopyRequest.takeIf { config.interceptCopy },
+    )
   }
 }
 
@@ -33,11 +42,21 @@ fun ContextMenuPopup.Builder.blockCopyItems(
   options: BlockMenuOptions,
   copyLabel: String,
   copyAsMarkdownLabel: String,
+  // The block's Markdown and raw content, read only for an intercepted Copy.
+  markdown: () -> String,
+  rawText: () -> String,
   copyRaw: () -> Unit,
   copyMarkdown: () -> Unit,
 ) {
   if (!options.copyHidden) {
-    item(ContextMenuPopup.Icon.COPY, copyLabel, if (options.copyWritesMarkdown) copyMarkdown else copyRaw)
+    val onCopyRequest = options.onCopyRequest
+    val onCopy =
+      when {
+        onCopyRequest != null -> { -> onCopyRequest(markdown(), rawText()) }
+        options.copyWritesMarkdown -> copyMarkdown
+        else -> copyRaw
+      }
+    item(ContextMenuPopup.Icon.COPY, copyLabel, onCopy)
   }
   if (!options.copyAsMarkdownHidden) {
     item(ContextMenuPopup.Icon.DOCUMENT, copyAsMarkdownLabel, copyMarkdown)

package/android/src/main/java/com/swmansion/enriched/markdown/views/CodeBlockContainerView.kt

@@ -261,7 +261,15 @@ class CodeBlockContainerView(
   private fun showContextMenu(anchor: View): Boolean {
     if (pending || contextMenuHidden || !menuOptions.hasItems) return false
     ContextMenuPopup.show(anchor, this) {
-      blockCopyItems(menuOptions, copyLabel, copyAsMarkdownLabel, ::copyCode, ::copyFencedMarkdown)
+      blockCopyItems(
+        menuOptions,
+        copyLabel,
+        copyAsMarkdownLabel,
+        markdown = { CodeBlockNode.fencedMarkdown(code, language, fenceChar) },
+        rawText = { code },
+        copyRaw = ::copyCode,
+        copyMarkdown = ::copyFencedMarkdown,
+      )
     }
     return true
   }

package/android/src/main/java/com/swmansion/enriched/markdown/views/TableContainerView.kt

@@ -24,6 +24,7 @@ import com.swmansion.enriched.markdown.accessibility.AccessibilityLabels
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode.NodeType
 import com.swmansion.enriched.markdown.renderer.Renderer
+import com.swmansion.enriched.markdown.spans.LinkChipBackgroundSpan
 import com.swmansion.enriched.markdown.styles.StyleConfig
 import com.swmansion.enriched.markdown.styles.TableStyle
 import com.swmansion.enriched.markdown.utils.common.layout.isLayoutRTL
@@ -81,6 +82,19 @@ class TableContainerView(
 
   val rowCount: Int get() = rows.size
 
+  /**
+   * 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.
+   */
+  val linkCount: Int
+    get() =
+      rows.sumOf { row ->
+        row.sumOf { cell ->
+          // LinkRenderer attaches one LinkChipBackgroundSpan per link.
+          cell.attributedText.getSpans(0, cell.attributedText.length, LinkChipBackgroundSpan::class.java).size
+        }
+      }
+
   fun animateNewRows(
     previousRowCount: Int,
     durationMs: Long,
@@ -367,8 +381,8 @@ class TableContainerView(
     if (contextMenuHidden) return
     val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
     ContextMenuPopup.show(anchor, this) {
-      blockCopyItems(menuOptions, copyLabel, copyAsMarkdownLabel, copyRaw = {
-        val plainText = rows.joinToString("\n") { row -> row.joinToString("\t") { it.plainText } }
+      blockCopyItems(menuOptions, copyLabel, copyAsMarkdownLabel, markdown = { tableMarkdown }, rawText = ::buildPlainText, copyRaw = {
+        val plainText = buildPlainText()
         if (plainText.isNotEmpty()) {
           val displayMetrics = context.resources.displayMetrics
           val tableRows =
@@ -384,6 +398,8 @@ class TableContainerView(
     }
   }
 
+  private fun buildPlainText(): String = rows.joinToString("\n") { row -> row.joinToString("\t") { it.plainText } }
+
   private fun buildMarkdownFromRows(): String =
     rows.joinToString("") { row ->
       val line = "| ${row.joinToString(" | ") { it.markdownText }} |\n"

package/android/src/math/java/com/swmansion/enriched/markdown/views/MathContainerView.kt

@@ -122,7 +122,9 @@ class MathContainerView(
     if (contextMenuHidden) return
     val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
     ContextMenuPopup.show(anchor, this) {
-      blockCopyItems(menuOptions, copyLabel, copyAsMarkdownLabel, copyRaw = {
+      blockCopyItems(menuOptions, copyLabel, copyAsMarkdownLabel, markdown = {
+        "$$\n$cachedLatex\n$$"
+      }, rawText = { cachedLatex }, copyRaw = {
         clipboard.setPrimaryClip(ClipData.newPlainText("Math", cachedLatex))
       }, copyMarkdown = {
         clipboard.setPrimaryClip(ClipData.newPlainText("Math", "$$\n$cachedLatex\n$$"))

package/docs/API_REFERENCE.md

@@ -69,6 +69,59 @@ Callback when a link is long pressed. Access URL via `event.url`. On iOS, automa
 />
 ```
 
+### `renderLinkDecoration`
+
+Renders a React Native view on top of each link — for example a badge or sparkle on a [link chip](STYLES.md#link-chips). Return `null` to leave a link undecorated.
+
+| Type                                                   | Default Value | Platform |
+| ------------------------------------------------------ | ------------- | -------- |
+| `(info: LinkDecorationInfo) => ReactNode \| null`       | -             | Both     |
+
+`LinkDecorationInfo`:
+
+| Field   | Type         | Description |
+| ------- | ------------ | ----------- |
+| `index` | `number`     | Position of the link in the document (0-based). Stable key for the link |
+| `url`   | `string`     | Link URL |
+| `text`  | `string`     | Visible link text |
+| `rect`  | `LinkRect`   | Anchor rect: the drawn chip (glyphs + horizontal/vertical padding) of the link's **last** line fragment |
+| `rects` | `LinkRect[]` | Every line fragment, in order (several when the link wraps) |
+
+`LinkRect` is `{ x, y, width, height }` in dp, relative to the component's content box (inside `containerStyle` padding).
+
+The returned node is placed inside an absolutely positioned box matching `rect`, with `pointerEvents="box-none"`, so position it relative to that box. Negative offsets let it overflow the chip:
+
+```tsx
+<EnrichedMarkdownText
+  markdown="Read the [guide](https://example.com/guide) first."
+  markdownStyle={{
+    link: {
+      backgroundColor: '#DCE2FF',
+      borderRadius: 5,
+      paddingHorizontal: 7,
+      underline: false,
+    },
+  }}
+  renderLinkDecoration={({ url }) =>
+    url.startsWith('https://') ? (
+      <View style={{ position: 'absolute', top: -8, right: -8 }}>
+        <SparkleIcon />
+      </View>
+    ) : null
+  }
+/>
+```
+
+Notes and limitations:
+
+- When this prop is not set the component renders exactly as before: no wrapper view and no layout events.
+- Setting it wraps the native view in a `View` (which takes `containerStyle`). Switching between set and unset remounts the native view.
+- Rects are measured natively after layout and sent to JS, so decorations appear one frame after the text. Updates are deduplicated — streaming does not re-render decorations unless a link actually moves.
+- Links inside tables (`flavor="github"`) are not reported.
+- On Android, parts of a decoration that overflow the component's bounds do not receive touches.
+- Web: `rect` is the link's whole inline box and `rects` is `[rect]`; for a wrapping link the decoration anchors to that box rather than the last line.
+- Not supported by `EnrichedMarkdownTextInput`.
+
 ### `onTaskListItemPress`
 
 Callback when a task list checkbox is tapped. Receives `index` (0-based), `checked` (new state after toggling), and `text` (item text).
@@ -122,6 +175,54 @@ Only fires when `flavor="github"` — the copy button is part of the GitHub flav
 />
 ```
 
+### `onCopy`
+
+Takes over the **Copy** item of the text selection menu and of the table, math and code block menus. When set, native does **not** write the clipboard: it calls `onCopy` with the copied content and your handler writes whatever it wants — for example with [`expo-clipboard`](https://docs.expo.dev/versions/latest/sdk/clipboard/). Use it to post-process what users copy (strip formatting, drop link targets…) without a native change.
+
+| Type                          | Default Value | Platform |
+| ----------------------------- | ------------- | -------- |
+| `(event: CopyEvent) => void`  | -             | Both     |
+
+```ts
+interface CopyEvent {
+  /** Which menu the Copy item belongs to. */
+  source: 'selection' | 'math' | 'table' | 'code';
+  /** What `copy.format: 'markdown'` would write. */
+  markdown: string;
+  /** Rendered text of the selection, or the block's raw content. */
+  text: string;
+  /** The selection spans the whole component (`markdown` is the source). Always true for blocks. */
+  whole: boolean;
+}
+```
+
+| `source`    | `markdown`                                                                 | `text`                        |
+| ----------- | -------------------------------------------------------------------------- | ----------------------------- |
+| `selection` | Original source when `whole`, otherwise rebuilt from the rendered styles   | Selected text as rendered     |
+| `math`      | `$$…$$`                                                                     | LaTeX                         |
+| `table`     | The table as Markdown                                                      | Tab-separated cells           |
+| `code`      | Fenced code block                                                          | Raw code                      |
+
+- `onCopy` overrides `selectionMenuConfig.copy.format`; `copy.enabled: false` still hides the item, so no event fires.
+- **Copy as Markdown**, the code block header copy button and the VoiceOver copy action are unaffected. `onCopyPress` does not fire for an intercepted Copy.
+- With `flavor="github"` the text is split into segments around blocks, so a selection is `whole` only when the markdown renders as a single text segment.
+- A rebuilt `markdown` wraps each styled run separately (`**a *****b***** c**`) and does not escape literal `*` / `_`.
+- Copying with a hardware keyboard (Cmd+C / Ctrl+C) does not go through the menu and is not intercepted.
+- Ignored on macOS. On web the prop is not this API: it reaches the container `div` as the DOM `onCopy` clipboard event.
+
+**Example:**
+
+```tsx
+import * as Clipboard from 'expo-clipboard';
+
+<EnrichedMarkdownText
+  markdown={content}
+  onCopy={({ source, markdown }) => {
+    Clipboard.setStringAsync(source === 'selection' ? stripFormatting(markdown) : markdown);
+  }}
+/>
+```
+
 ### `enableLinkPreview`
 
 Controls the native link preview on long press (iOS only). Automatically set to `false` when `onLinkLongPress` is provided.

package/docs/COPY_OPTIONS.md

@@ -70,6 +70,20 @@ code and fire `onCopyPress`; `codeBlockCopyButton: { enabled: false }` hides the
 button, and `copy: { enabled: false }` also removes the VoiceOver action.
 `copy.enabled`, `copy.format` and `systemItems` are ignored on macOS.
 
+### Handling Copy in JS
+
+To decide in JS what lands on the clipboard, pass `onCopy`. The Copy item
+(text selection and block menus) then writes nothing itself and hands you the
+content — `markdown`, `text`, `source` and `whole` — to write with your
+clipboard library. See [`onCopy`](API_REFERENCE.md#oncopy).
+
+```tsx
+<EnrichedMarkdownText
+  markdown={content}
+  onCopy={({ markdown }) => Clipboard.setStringAsync(markdown)}
+/>
+```
+
 To turn the menu off entirely rather than item by item, use `contextMenuHidden`:
 
 ```tsx

package/docs/MENTIONS.md

@@ -69,7 +69,14 @@ linkVariants: {
 }
 ```
 
-Each key is a regex tested against the link URL. First match wins. Unspecified properties inherit from the base `link` style. Patterns are auto-sorted longest-first.
+Each key is a regex tested against the link URL. First match wins. Patterns are auto-sorted longest-first.
+
+Inheritance from the base `link` style is split in two groups:
+
+- **Text** (`color`, `underline`): unspecified properties inherit from `link`.
+- **Box** (`backgroundColor`, `borderRadius`, `paddingHorizontal`, `paddingVertical`, `borderColor`, `borderWidth`): never inherited. A variant that sets none of them renders without a chip, even when `link` is a chip.
+
+`fontFamily` is only configurable on `link` and applies to every variant. See [Link chips](STYLES.md#link-chips) for the box properties.
 
 ## Positioning the Suggestion List
 

package/docs/STYLES.md

@@ -368,6 +368,33 @@ Per-token foreground colors for syntax highlighting, keyed on the highlight toke
 | `fontFamily` | `string` | Font family for links. Overrides the parent block's font family when set |
 | `color` | `string` | Link text color |
 | `underline` | `boolean` | Show underline |
+| `backgroundColor` | `string` | Chip background, drawn behind the link's glyphs (ascender to descender) plus padding |
+| `borderRadius` | `number` | Chip corner radius |
+| `paddingHorizontal` | `number` | Space added before and after the link text. It takes real room in the line, so it affects wrapping and measured size |
+| `paddingVertical` | `number` | Extends the chip above and below the text. Drawn only: it does not change the line height, so it can overlap neighbouring lines (or be clipped at the component's top/bottom edge) if the line height is too small |
+| `borderColor` | `string` | Chip border color |
+| `borderWidth` | `number` | Chip border width, drawn inset (does not grow the chip) |
+
+#### Link chips
+
+Setting `backgroundColor`, `borderRadius`, padding or a border turns a link into a chip. When a link wraps, each line gets its own piece of the chip; only the outer ends are rounded and the border is left open where the link breaks.
+
+```tsx
+link: {
+  color: '#3346C8',
+  underline: false,
+  backgroundColor: '#DCE2FF',
+  borderRadius: 5,
+  paddingHorizontal: 7,
+  paddingVertical: 4,
+}
+```
+
+Horizontal padding is reserved with an invisible non-breaking spacer at each end of the link, so the padding always stays attached to the text on wrap. The spacer is removed from copied text (plain, HTML, RTF, Markdown and `onCopy`) and is part of the link's tap area.
+
+On iOS (and in RTF copies), links inside table cells fall back to a plain text background: `backgroundColor` and `paddingHorizontal` are kept (the background covers the horizontal padding), but `borderRadius`, `paddingVertical` and the border are not drawn.
+
+Use [`renderLinkDecoration`](API_REFERENCE.md#renderlinkdecoration) to draw a React Native view on top of a chip (e.g. a badge or icon).
 
 ### Strong-specific
 

package/docs/TEXT.md

@@ -95,6 +95,8 @@ Links in Markdown are interactive and can be handled with the `onLinkPress` and
 
 See the [API Reference](API_REFERENCE.md#onlinkpress) for detailed examples and usage.
 
+Links can be styled as chips (background, radius, padding, border — see [Link chips](STYLES.md#link-chips)) and decorated with your own views via [`renderLinkDecoration`](API_REFERENCE.md#renderlinkdecoration).
+
 ## Supported Markdown Elements
 
 `react-native-enriched-markdown-scaffold` supports a comprehensive set of Markdown elements. See [Element Structure](ELEMENTS_STRUCTURE.md) for a detailed overview of all supported elements, their syntax, block vs inline categorization, nesting behavior, and how elements inherit typography from their parent blocks.

package/ios/EnrichedMarkdown.mm

@@ -38,6 +38,7 @@
 #import "SegmentReconciler.h"
 #import "SegmentRenderer.h"
 #import "SegmentViewRegistry.h"
+#import "ENRMLinkLayout.h"
 #import "SelectionColorUtils.h"
 #import "StreamingMarkdownFilter.h"
 #import "StyleConfig.h"
@@ -73,8 +74,10 @@ static char kENRMSegmentFadeAnimatorKey;
 + (ENRMMd4cFlags *)flagsFromProps:(const EnrichedMarkdownMd4cFlagsStruct &)props;
 - (void)emitLinkPress:(NSString *)url;
 - (void)emitLinkLongPress:(NSString *)url;
+- (void)emitLinkLayoutIfNeeded;
 - (void)emitTaskListItemPress:(NSInteger)index checked:(BOOL)checked text:(NSString *)text;
 - (void)emitCopyPress:(NSString *)code language:(NSString *)language;
+- (void)emitCopyRequest:(NSString *)source markdown:(NSString *)markdown text:(NSString *)text whole:(BOOL)whole;
 - (void)emitContextMenuItemPress:(NSString *)itemText
                     selectedText:(NSString *)selectedText
                   selectionStart:(NSUInteger)selectionStart
@@ -122,6 +125,9 @@ static char kENRMSegmentFadeAnimatorKey;
 
   ENRMSpoilerOverlay _spoilerOverlay;
 
+  BOOL _emitLinkLayout;
+  NSArray<NSDictionary *> *_lastLinkLayout;
+
   NSLineBreakStrategy _lineBreakStrategy;
 
   ENRMWritingDirectionMode _writingDirectionMode;
@@ -512,6 +518,17 @@ static char kENRMSegmentFadeAnimatorKey;
       .copyWritesMarkdown = _selectionMenuConfig.copyFormatMarkdown,
       .copyAsMarkdownHidden = !_selectionMenuConfig.copyAsMarkdown,
       .copyButtonHidden = !_selectionMenuConfig.codeBlockCopyButton,
+      .interceptCopy = _selectionMenuConfig.interceptCopy,
+  };
+}
+
+- (ENRMBlockCopyRequestBlock)blockCopyRequestForSource:(NSString *)source
+{
+  __weak EnrichedMarkdown *weakSelf = self;
+  return ^(NSString *markdown, NSString *text) {
+    EnrichedMarkdown *strongSelf = weakSelf;
+    if (strongSelf)
+      [strongSelf emitCopyRequest:source markdown:markdown text:text whole:YES];
   };
 }
 
@@ -800,7 +817,7 @@ static char kENRMSegmentFadeAnimatorKey;
                                   selectionEnd:selectionEnd];
         });
     return buildEditMenuForSelection(textView.textStorage, textView.selectedRange, segmentMarkdown, strongSelf->_config,
-                                     @[ baseMenu ], customItems, strongSelf -> _selectionMenuConfig);
+                                     @[ baseMenu ], customItems, strongSelf->_selectionMenuConfig);
   }];
 #endif
 
@@ -821,6 +838,7 @@ static char kENRMSegmentFadeAnimatorKey;
   tableView.copyAsMarkdownLabel = _selectionMenuLabels.copyAsMarkdownLabel;
   tableView.contextMenuHidden = _contextMenuHidden;
   tableView.menuOptions = [self blockMenuOptions];
+  tableView.onCopyRequest = [self blockCopyRequestForSource:@"table"];
 
   __weak EnrichedMarkdown *weakSelf = self;
 
@@ -862,6 +880,7 @@ static char kENRMSegmentFadeAnimatorKey;
   mathView.copyAsMarkdownLabel = _selectionMenuLabels.copyAsMarkdownLabel;
   mathView.contextMenuHidden = _contextMenuHidden;
   mathView.menuOptions = [self blockMenuOptions];
+  mathView.onCopyRequest = [self blockCopyRequestForSource:@"math"];
   [mathView applyLatex:mathSegment.latex];
   return mathView;
 }
@@ -874,6 +893,7 @@ static char kENRMSegmentFadeAnimatorKey;
   codeBlockView.copyAsMarkdownLabel = _selectionMenuLabels.copyAsMarkdownLabel;
   codeBlockView.contextMenuHidden = _contextMenuHidden;
   codeBlockView.menuOptions = [self blockMenuOptions];
+  codeBlockView.onCopyRequest = [self blockCopyRequestForSource:@"code"];
 
   __weak EnrichedMarkdown *weakSelf = self;
   codeBlockView.onCopyPress = ^(NSString *code, NSString *language) {
@@ -926,6 +946,7 @@ static char kENRMSegmentFadeAnimatorKey;
 {
   [super layoutSubviews];
   [self computeSegmentLayoutForWidth:self.bounds.size.width applyFrames:YES];
+  [self emitLinkLayoutIfNeeded];
 }
 
 - (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
@@ -961,6 +982,12 @@ static char kENRMSegmentFadeAnimatorKey;
 
   _selectable = newViewProps.selectable;
 
+  if (newViewProps.emitLinkLayout != _emitLinkLayout) {
+    _emitLinkLayout = newViewProps.emitLinkLayout;
+    _lastLinkLayout = nil;
+    [self setNeedsLayout];
+  }
+
   for (RCTUIView *segment in _segmentViews) {
     if ([segment isKindOfClass:[EnrichedMarkdownInternalText class]]) {
       EnrichedMarkdownInternalText *textSegment = (EnrichedMarkdownInternalText *)segment;
@@ -1156,6 +1183,8 @@ static char kENRMSegmentFadeAnimatorKey;
   _cachedMarkdown = nil;
   _renderedMarkdown = nil;
   _config = nil;
+  _emitLinkLayout = NO;
+  _lastLinkLayout = nil;
   _md4cFlags = [EnrichedMarkdown flagsFromProps:resetProps->md4cFlags];
   _maxFontSizeMultiplier = 0;
   _allowTrailingMargin = NO;
@@ -1266,6 +1295,40 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownCls(void)
     emitter->onLinkPress({.url = std::string(url.UTF8String)});
 }
 
+/// Reports link rects of every text segment (offset by the segment origin) to
+/// JS for `renderLinkDecoration`. Tables are skipped: their cells scroll
+/// horizontally, so rects would go stale. Runs after each segment layout pass;
+/// deduplicated so an unchanged layout sends nothing.
+- (void)emitLinkLayoutIfNeeded
+{
+  if (!_emitLinkLayout || self.bounds.size.width <= 0)
+    return;
+
+  auto emitter = std::static_pointer_cast<EnrichedMarkdownEventEmitter const>(_eventEmitter);
+  if (!emitter)
+    return;
+
+  NSMutableArray<NSDictionary *> *fragments = [NSMutableArray array];
+  NSInteger linkCount = 0;
+  for (RCTUIView *segment in _segmentViews) {
+    if ([segment isKindOfClass:[TableContainerView class]]) {
+      linkCount += ((TableContainerView *)segment).linkCount;
+      continue;
+    }
+    if (![segment isKindOfClass:[EnrichedMarkdownInternalText class]])
+      continue;
+    NSInteger segmentLinks = 0;
+    [fragments addObjectsFromArray:ENRMCollectLinkLayoutFragments(((EnrichedMarkdownInternalText *)segment).textView,
+                                                                  segment.frame.origin, linkCount, &segmentLinks)];
+    linkCount += segmentLinks;
+  }
+
+  if (_lastLinkLayout != nil && [fragments isEqualToArray:_lastLinkLayout])
+    return;
+  _lastLinkLayout = [fragments copy];
+  emitter->onLinkLayout(ENRMLinkLayoutEventFromFragments<EnrichedMarkdownEventEmitter::OnLinkLayout>(fragments));
+}
+
 - (void)emitLinkLongPress:(NSString *)url
 {
   auto emitter = std::static_pointer_cast<EnrichedMarkdownEventEmitter const>(_eventEmitter);
@@ -1288,6 +1351,18 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownCls(void)
         {.code = std::string(code.UTF8String ?: ""), .language = std::string(language.UTF8String ?: "")});
 }
 
+- (void)emitCopyRequest:(NSString *)source markdown:(NSString *)markdown text:(NSString *)text whole:(BOOL)whole
+{
+  auto emitter = std::static_pointer_cast<EnrichedMarkdownEventEmitter const>(_eventEmitter);
+  if (emitter)
+    emitter->onCopyRequest({
+        .source = std::string(source.UTF8String),
+        .markdown = std::string(markdown.UTF8String ?: ""),
+        .text = std::string(text.UTF8String ?: ""),
+        .whole = (bool)whole,
+    });
+}
+
 - (void)emitContextMenuItemPress:(NSString *)itemText
                     selectedText:(NSString *)selectedText
                   selectionStart:(NSUInteger)selectionStart
@@ -1355,8 +1430,22 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownCls(void)
       ENRMBuildContextMenuActions(_contextMenuItemTexts, _contextMenuItemIcons, textView, range, handler);
 
   NSString *segmentMarkdown = extractMarkdownFromAttributedString(textView.attributedText, range);
+
+  // Segments only see their own text, so a selection is the whole component
+  // only when it spans the sole segment; the markdown is then the original.
+  ENRMCopyRequestHandler onCopyRequest = ^(NSString *markdown, NSString *text, BOOL fullSelection) {
+    EnrichedMarkdown *strongSelf = weakSelf;
+    if (!strongSelf)
+      return;
+    BOOL whole = fullSelection && strongSelf->_segmentViews.count == 1 && strongSelf->_cachedMarkdown.length > 0;
+    [strongSelf emitCopyRequest:@"selection"
+                       markdown:whole ? strongSelf->_cachedMarkdown : markdown
+                           text:text
+                          whole:whole];
+  };
+
   return buildEditMenuForSelection(textView.attributedText, range, segmentMarkdown, _config, suggestedActions,
-                                   customActions, _selectionMenuConfig);
+                                   customActions, _selectionMenuConfig, onCopyRequest);
 }
 
 - (BOOL)textView:(UITextView *)textView