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

package/android/src/main/java/com/swmansion/enriched/markdown/spans/InlineChipPainter.kt

@@ -0,0 +1,140 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.Spanned
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+
+/**
+ * Shared geometry and drawing for inline "chips" painted from a [android.text.style.LineBackgroundSpan]
+ * (inline code, link chips). For a chip that wraps, only the outer ends are rounded and the border
+ * stays open where a fragment is cut.
+ */
+internal object InlineChipPainter {
+  /**
+   * Returns the x position of [index] relative to the line's left edge, including any
+   * leading margin. The measuring StaticLayout is built from a subSequence that keeps
+   * all spans, so LeadingMarginSpans (lists, blockquotes) are already applied to
+   * getPrimaryHorizontal; adding the margin again on top would shift the background
+   * right by the indent. The margin is only added explicitly in the early-return case,
+   * where no layout is built.
+   */
+  fun horizontalOffset(
+    text: CharSequence,
+    lineStart: Int,
+    lineEnd: Int,
+    index: Int,
+    paint: Paint,
+    leadingMargin: Int,
+  ): Float {
+    if (index <= lineStart) return leadingMargin.toFloat()
+    val lineText = text.subSequence(lineStart, lineEnd)
+    val textPaint = paint as? TextPaint ?: TextPaint(paint)
+    val layout = StaticLayout.Builder.obtain(lineText, 0, lineText.length, textPaint, 10000).build()
+    return layout.getPrimaryHorizontal(index - lineStart)
+  }
+
+  fun leadingMarginAt(
+    text: Spanned,
+    lineStart: Int,
+  ): Int {
+    if (lineStart >= text.length) return 0
+    val spans = text.getSpans(lineStart, lineStart + 1, LeadingMarginSpan::class.java)
+    var margin = 0
+    for (span in spans) {
+      margin += span.getLeadingMargin(false)
+    }
+    return margin
+  }
+
+  /**
+   * Fills [rect] and strokes its border. [strokeInset] keeps a closed border inside [rect]
+   * (link chips); otherwise it is centered on the edge (inline code, kept for pixel parity).
+   * [path] is caller-owned scratch space to avoid per-draw allocations.
+   */
+  fun draw(
+    canvas: Canvas,
+    rect: RectF,
+    path: Path,
+    cornerRadius: Float,
+    backgroundPaint: Paint?,
+    borderPaint: Paint?,
+    isFirst: Boolean,
+    isLast: Boolean,
+    strokeInset: Boolean,
+  ) {
+    val r = minOf(maxOf(cornerRadius, 0f), minOf(rect.width(), rect.height()) / 2f)
+
+    if (backgroundPaint != null) {
+      path.reset()
+      path.addRoundRect(rect, radii(r, isFirst, isLast), Path.Direction.CW)
+      canvas.drawPath(path, backgroundPaint)
+    }
+
+    if (borderPaint == null || borderPaint.strokeWidth <= 0f) return
+
+    path.reset()
+    if (isFirst && isLast) {
+      if (strokeInset) {
+        val inset = borderPaint.strokeWidth / 2f
+        val insetRect = RectF(rect.left + inset, rect.top + inset, rect.right - inset, rect.bottom - inset)
+        path.addRoundRect(insetRect, radii(maxOf(r - inset, 0f), true, true), Path.Direction.CW)
+      } else {
+        path.addRoundRect(rect, radii(r, true, true), Path.Direction.CW)
+      }
+    } else {
+      val inset = if (strokeInset) borderPaint.strokeWidth / 2f else 0f
+      addOpenBorder(path, rect, r, inset, isFirst, isLast)
+    }
+    canvas.drawPath(path, borderPaint)
+  }
+
+  private fun addOpenBorder(
+    path: Path,
+    rect: RectF,
+    r: Float,
+    inset: Float,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) {
+    val left = rect.left + inset
+    val top = rect.top + inset
+    val right = rect.right - inset
+    val bottom = rect.bottom - inset
+
+    if (isFirst) {
+      path.moveTo(rect.right, top)
+      path.lineTo(left + r, top)
+      path.quadTo(left, top, left, top + r)
+      path.lineTo(left, bottom - r)
+      path.quadTo(left, bottom, left + r, bottom)
+      path.lineTo(rect.right, bottom)
+    } else if (isLast) {
+      path.moveTo(rect.left, top)
+      path.lineTo(right - r, top)
+      path.quadTo(right, top, right, top + r)
+      path.lineTo(right, bottom - r)
+      path.quadTo(right, bottom, right - r, bottom)
+      path.lineTo(rect.left, bottom)
+    } else {
+      path.moveTo(rect.left, top)
+      path.lineTo(rect.right, top)
+      path.moveTo(rect.left, bottom)
+      path.lineTo(rect.right, bottom)
+    }
+  }
+
+  private fun radii(
+    r: Float,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ): FloatArray {
+    val left = if (isFirst) r else 0f
+    val right = if (isLast) r else 0f
+    return floatArrayOf(left, left, right, right, right, right, left, left)
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/spans/LinkChipSpans.kt

@@ -0,0 +1,177 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LineBackgroundSpan
+import android.text.style.ReplacementSpan
+import com.swmansion.enriched.markdown.styles.LinkChipStyle
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+/**
+ * Reserves a link's `paddingHorizontal` at one outer edge. It covers one [LinkSpacers.CHAR]
+ * inserted by `LinkRenderer`: U+00A0 is line-break class GL, so a break is allowed before it
+ * after a space but never after it, and never before it after a non-space — the spacer always
+ * travels with the link's first (or last) glyph, never orphaned at a wrap.
+ *
+ * Layout-only: every text exit point strips spacers by this span ([LinkSpacers.strip]).
+ */
+class LinkSpacerSpan(
+  private val width: Float,
+) : ReplacementSpan() {
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int {
+    // Keep the line metrics of the surrounding text.
+    if (fm != null) paint.getFontMetricsInt(fm)
+    return width.roundToInt()
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) = Unit
+}
+
+object LinkSpacers {
+  const val CHAR = '\u00A0'
+
+  /** [text] without link spacers (returns [text] itself when it has none). */
+  fun strip(text: CharSequence): CharSequence {
+    if (text !is Spanned) return text
+    val spacers = text.getSpans(0, text.length, LinkSpacerSpan::class.java)
+    if (spacers.isEmpty()) return text
+    val builder = SpannableStringBuilder(text)
+    spacers
+      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+      .filter { (start, end) -> start in 0 until end }
+      .sortedByDescending { it.first }
+      .forEach { (start, end) -> builder.delete(start, end) }
+    return builder
+  }
+
+  /** True when [start, end) lies inside a spacer (a segment exporters must skip). */
+  fun isSpacer(
+    text: Spanned,
+    start: Int,
+    end: Int,
+  ): Boolean = end > start && text.getSpans(start, end, LinkSpacerSpan::class.java).isNotEmpty()
+}
+
+/**
+ * Paints a link chip (background + border) behind the link glyphs. One instance per link,
+ * spanning the link including its spacers, so the chip already covers `paddingHorizontal`.
+ * Vertically the chip spans the link font's ascent..descent ± `paddingVertical`; the vertical
+ * padding only bleeds into the surrounding line spacing and never changes the line box.
+ */
+class LinkChipBackgroundSpan(
+  val chip: LinkChipStyle,
+) : LineBackgroundSpan {
+  private val rect = RectF()
+  private val path = Path()
+  private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+  private val borderPaint =
+    Paint(Paint.ANTI_ALIAS_FLAG).apply {
+      style = Paint.Style.STROKE
+      strokeJoin = Paint.Join.ROUND
+      strokeCap = Paint.Cap.ROUND
+    }
+
+  override fun drawBackground(
+    canvas: Canvas,
+    p: Paint,
+    left: Int,
+    right: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    lineNum: Int,
+  ) {
+    if (!chip.isVisible || text !is Spanned) return
+
+    val spanStart = text.getSpanStart(this)
+    val spanEnd = text.getSpanEnd(this)
+    if (spanStart !in 0 until spanEnd || spanEnd <= start || spanStart >= end) return
+
+    val isFirst = spanStart >= start
+    val isLast = spanEnd <= end
+
+    val leadingMargin = InlineChipPainter.leadingMarginAt(text, start)
+    val fragmentStart = max(spanStart, start)
+    val fragmentEnd = trimTrailingWhitespace(text, fragmentStart, min(spanEnd, end))
+    val startX = InlineChipPainter.horizontalOffset(text, start, end, fragmentStart, p, leadingMargin) + left
+    val endX = InlineChipPainter.horizontalOffset(text, start, end, fragmentEnd, p, leadingMargin) + left
+
+    val (ascent, descent) = linkFontMetrics(text, spanStart, spanEnd, p)
+    rect.set(
+      min(startX, endX),
+      baseline + ascent - chip.paddingVertical,
+      max(startX, endX),
+      baseline + descent + chip.paddingVertical,
+    )
+
+    backgroundPaint.color = chip.backgroundColor
+    borderPaint.color = chip.borderColor
+    borderPaint.strokeWidth = chip.borderWidth
+    InlineChipPainter.draw(
+      canvas,
+      rect,
+      path,
+      chip.borderRadius,
+      backgroundPaint.takeIf { android.graphics.Color.alpha(chip.backgroundColor) > 0 },
+      borderPaint.takeIf { android.graphics.Color.alpha(chip.borderColor) > 0 && chip.borderWidth > 0f },
+      isFirst,
+      isLast,
+      strokeInset = true,
+    )
+  }
+
+  companion object {
+    /** A wrapped fragment ends before the whitespace the line break hangs. */
+    fun trimTrailingWhitespace(
+      text: CharSequence,
+      start: Int,
+      end: Int,
+    ): Int {
+      var index = end
+      while (index > start && text[index - 1] != LinkSpacers.CHAR && text[index - 1].isWhitespace()) index--
+      return index
+    }
+
+    /**
+     * Ascent/descent of the link's own font: [LinkSpan] sets its size and typeface at draw
+     * time only, so the base paint [p] alone would report the paragraph's metrics.
+     */
+    fun linkFontMetrics(
+      text: Spanned,
+      spanStart: Int,
+      spanEnd: Int,
+      p: Paint,
+    ): Pair<Float, Float> {
+      val paint = TextPaint(p)
+      text.getSpans(spanStart, spanEnd, LinkSpan::class.java).firstOrNull()?.updateDrawState(paint)
+      val metrics = paint.fontMetrics
+      return metrics.ascent to metrics.descent
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/spans/LinkSpan.kt

@@ -1,7 +1,6 @@
 package com.swmansion.enriched.markdown.spans
 
 import android.content.Context
-import android.graphics.Color
 import android.text.TextPaint
 import android.text.style.ClickableSpan
 import android.view.View
@@ -57,10 +56,6 @@ class LinkSpan(
 
     textPaint.color = variant?.color ?: styleCache.linkColor
     textPaint.isUnderlineText = variant?.underline ?: styleCache.linkUnderline
-
-    val backgroundColor = variant?.backgroundColor ?: styleCache.linkBackgroundColor
-    if (Color.alpha(backgroundColor) > 0) {
-      textPaint.bgColor = backgroundColor
-    }
+    // The background is painted as a chip by LinkChipBackgroundSpan.
   }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/styles/LinkStyle.kt

@@ -7,6 +7,7 @@ data class LinkStyle(
   val color: Int,
   val underline: Boolean,
   val backgroundColor: Int,
+  val chip: LinkChipStyle,
 ) {
   companion object {
     fun fromReadableMap(
@@ -17,7 +18,41 @@ data class LinkStyle(
       val color = parser.parseColor(map, "color")
       val underline = map.getBoolean("underline")
       val backgroundColor = parser.parseColor(map, "backgroundColor")
-      return LinkStyle(fontFamily, color, underline, backgroundColor)
+      return LinkStyle(fontFamily, color, underline, backgroundColor, LinkChipStyle.fromReadableMap(map, parser, backgroundColor))
     }
   }
 }
+
+/**
+ * Chip ("box") properties of a link, in pixels. Never inherited from the base link
+ * style by variants — the JS normalizer fills missing values with 0 / transparent.
+ */
+data class LinkChipStyle(
+  val backgroundColor: Int,
+  val borderColor: Int,
+  val borderRadius: Float,
+  val borderWidth: Float,
+  val paddingHorizontal: Float,
+  val paddingVertical: Float,
+) {
+  val isVisible: Boolean
+    get() =
+      android.graphics.Color.alpha(backgroundColor) > 0 ||
+        (android.graphics.Color.alpha(borderColor) > 0 && borderWidth > 0f)
+
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+      backgroundColor: Int,
+    ): LinkChipStyle =
+      LinkChipStyle(
+        backgroundColor = backgroundColor,
+        borderColor = parser.parseOptionalColor(map, "borderColor") ?: 0,
+        borderRadius = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderRadius").toFloat()),
+        borderWidth = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderWidth").toFloat()),
+        paddingHorizontal = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingHorizontal").toFloat()),
+        paddingVertical = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingVertical").toFloat()),
+      )
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/styles/LinkVariantEntry.kt

@@ -13,17 +13,21 @@ data class LinkVariantEntry(
   val color: Int,
   val underline: Boolean,
   val backgroundColor: Int,
+  val chip: LinkChipStyle,
 ) {
   companion object {
     fun fromReadableMap(
       map: ReadableMap,
       parser: StyleParser,
-    ): LinkVariantEntry =
-      LinkVariantEntry(
+    ): LinkVariantEntry {
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      return LinkVariantEntry(
         pattern = map.getString("pattern") ?: "",
         color = parser.parseColor(map, "color"),
         underline = parser.parseBoolean(map, "underline"),
-        backgroundColor = parser.parseColor(map, "backgroundColor"),
+        backgroundColor = backgroundColor,
+        chip = LinkChipStyle.fromReadableMap(map, parser, backgroundColor),
       )
+    }
   }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/MarkdownViewManagerUtils.kt

@@ -7,10 +7,13 @@ import com.facebook.react.uimanager.UIManagerHelper
 import com.swmansion.enriched.markdown.accessibility.AccessibilityLabels
 import com.swmansion.enriched.markdown.events.ContextMenuItemPressEvent
 import com.swmansion.enriched.markdown.events.CopyPressEvent
+import com.swmansion.enriched.markdown.events.CopyRequestEvent
+import com.swmansion.enriched.markdown.events.LinkLayoutEvent
 import com.swmansion.enriched.markdown.events.LinkLongPressEvent
 import com.swmansion.enriched.markdown.events.LinkPressEvent
 import com.swmansion.enriched.markdown.events.TaskListItemPressEvent
 import com.swmansion.enriched.markdown.parser.Md4cFlags
+import com.swmansion.enriched.markdown.utils.text.view.LinkLayoutFragment
 import com.swmansion.enriched.markdown.utils.text.view.SelectionMenuConfig
 
 fun markdownEventTypeConstants(): MutableMap<String, Any> {
@@ -22,11 +25,25 @@ fun markdownEventTypeConstants(): MutableMap<String, Any> {
     mapOf("registrationName" to TaskListItemPressEvent.EVENT_NAME)
   map[CopyPressEvent.EVENT_NAME] =
     mapOf("registrationName" to CopyPressEvent.EVENT_NAME)
+  map[CopyRequestEvent.EVENT_NAME] =
+    mapOf("registrationName" to CopyRequestEvent.EVENT_NAME)
   map[ContextMenuItemPressEvent.EVENT_NAME] =
     mapOf("registrationName" to ContextMenuItemPressEvent.EVENT_NAME)
+  map[LinkLayoutEvent.EVENT_NAME] =
+    mapOf("registrationName" to LinkLayoutEvent.EVENT_NAME)
   return map
 }
 
+fun emitLinkLayout(
+  view: View,
+  fragments: List<LinkLayoutFragment>,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(LinkLayoutEvent(surfaceId, view.id, fragments))
+}
+
 fun emitLinkPress(
   view: View,
   url: String,
@@ -74,6 +91,21 @@ fun emitCopyPress(
   )
 }
 
+fun emitCopyRequest(
+  view: View,
+  source: String,
+  markdown: String,
+  text: String,
+  whole: Boolean,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(
+    CopyRequestEvent(surfaceId, view.id, source, markdown, text, whole),
+  )
+}
+
 fun emitContextMenuItemPress(
   view: View,
   itemText: String,
@@ -132,6 +164,7 @@ fun parseSelectionMenuConfig(value: ReadableMap?): SelectionMenuConfig {
     copyFormatMarkdown = value.getBooleanOrDefault("copyFormatMarkdown", false),
     systemItemsNone = value.getBooleanOrDefault("systemItemsNone", false),
     codeBlockCopyButton = value.getBooleanOrDefault("codeBlockCopyButton", true),
+    interceptCopy = value.getBooleanOrDefault("interceptCopy", false),
   )
 }
 

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/conversion/HTMLGenerator.kt

@@ -12,6 +12,7 @@ import com.swmansion.enriched.markdown.spans.EmphasisSpan
 import com.swmansion.enriched.markdown.spans.HeadingSpan
 import com.swmansion.enriched.markdown.spans.HighlightSpan
 import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacers
 import com.swmansion.enriched.markdown.spans.LinkSpan
 import com.swmansion.enriched.markdown.spans.OrderedListSpan
 import com.swmansion.enriched.markdown.spans.StrikethroughSpan
@@ -676,7 +677,7 @@ object HTMLGenerator {
           val segmentEnd = minOf(text.nextSpanTransition(i, end, Any::class.java), end)
           val segmentText = text.subSequence(i, segmentEnd).toString()
 
-          if (segmentText.isNotEmpty() && segmentText != "\n") {
+          if (segmentText.isNotEmpty() && segmentText != "\n" && !LinkSpacers.isSpacer(text, i, segmentEnd)) {
             appendStyledSegment(html, text, i, segmentEnd, segmentText, styles, isCodeBlock)
           }
           i = segmentEnd

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/conversion/MarkdownExtractor.kt

@@ -12,6 +12,7 @@ import com.swmansion.enriched.markdown.spans.EmphasisSpan
 import com.swmansion.enriched.markdown.spans.HeadingSpan
 import com.swmansion.enriched.markdown.spans.HighlightSpan
 import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacers
 import com.swmansion.enriched.markdown.spans.LinkSpan
 import com.swmansion.enriched.markdown.spans.OrderedListSpan
 import com.swmansion.enriched.markdown.spans.StrikethroughSpan
@@ -55,6 +56,11 @@ object MarkdownExtractor {
     var i = start
     while (i < end) {
       val nextTransition = spannable.nextSpanTransition(i, end, Any::class.java)
+      // Link spacers only reserve layout space for chip padding.
+      if (LinkSpacers.isSpacer(spannable, i, nextTransition)) {
+        i = nextTransition
+        continue
+      }
       val segmentText = spannable.subSequence(i, nextTransition).toString()
 
       val handled =

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/view/LinkLayoutCollector.kt

@@ -0,0 +1,100 @@
+package com.swmansion.enriched.markdown.utils.text.view
+
+import android.text.Layout
+import android.text.Spanned
+import android.widget.TextView
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.enriched.markdown.spans.LinkChipBackgroundSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacers
+import com.swmansion.enriched.markdown.spans.LinkSpan
+import kotlin.math.max
+import kotlin.math.min
+
+/** One laid-out line of a link, in dp relative to the reporting view. Covers the drawn chip. */
+data class LinkLayoutFragment(
+  val linkIndex: Int,
+  val url: String,
+  val text: String,
+  val x: Float,
+  val y: Float,
+  val width: Float,
+  val height: Float,
+)
+
+object LinkLayoutCollector {
+  /**
+   * Collects the chip rect of every link fragment laid out in [textView], for `onLinkLayout`.
+   * Rects are offset by the text view's own padding plus [offsetXPx]/[offsetYPx] (a segment's
+   * position inside its container), then converted to dp. Links are numbered in document order
+   * from [indexBase]; returns the fragments and the number of links found.
+   */
+  fun collect(
+    textView: TextView,
+    offsetXPx: Int = 0,
+    offsetYPx: Int = 0,
+    indexBase: Int = 0,
+  ): Pair<List<LinkLayoutFragment>, Int> {
+    val layout = textView.layout ?: return emptyList<LinkLayoutFragment>() to 0
+    val text = textView.text as? Spanned ?: return emptyList<LinkLayoutFragment>() to 0
+
+    // LinkRenderer sets one LinkChipBackgroundSpan per link, spacers included.
+    val chips =
+      text
+        .getSpans(0, text.length, LinkChipBackgroundSpan::class.java)
+        .sortedBy { text.getSpanStart(it) }
+    val originX = offsetXPx + textView.totalPaddingLeft
+    val originY = offsetYPx + textView.totalPaddingTop
+
+    val fragments = mutableListOf<LinkLayoutFragment>()
+    chips.forEachIndexed { i, chipSpan ->
+      val start = text.getSpanStart(chipSpan)
+      val end = text.getSpanEnd(chipSpan)
+      if (start !in 0 until end) return@forEachIndexed
+
+      val url = text.getSpans(start, end, LinkSpan::class.java).firstOrNull()?.url ?: ""
+      val linkText = LinkSpacers.strip(text.subSequence(start, end)).toString()
+      val (ascent, descent) = LinkChipBackgroundSpan.linkFontMetrics(text, start, end, textView.paint)
+      val paddingVertical = chipSpan.chip.paddingVertical
+
+      for (line in layout.getLineForOffset(start)..layout.getLineForOffset(end - 1)) {
+        val fragmentStart = max(start, layout.getLineStart(line))
+        val fragmentEnd =
+          LinkChipBackgroundSpan.trimTrailingWhitespace(text, fragmentStart, min(end, layout.getLineEnd(line)))
+        if (fragmentEnd <= fragmentStart) continue
+
+        val left = layout.getPrimaryHorizontal(fragmentStart)
+        val right = lineEndHorizontal(layout, line, fragmentEnd)
+        val baseline = layout.getLineBaseline(line).toFloat()
+        val top = baseline + ascent - paddingVertical
+        val bottom = baseline + descent + paddingVertical
+
+        fragments +=
+          LinkLayoutFragment(
+            linkIndex = indexBase + i,
+            url = url,
+            text = linkText,
+            x = PixelUtil.toDIPFromPixel(min(left, right) + originX),
+            y = PixelUtil.toDIPFromPixel(top + originY),
+            width = PixelUtil.toDIPFromPixel(kotlin.math.abs(right - left)),
+            height = PixelUtil.toDIPFromPixel(bottom - top),
+          )
+      }
+    }
+    return fragments to chips.size
+  }
+
+  /**
+   * x of [offset] on [line]. At a line's end offset `getPrimaryHorizontal` reports the start
+   * of the next line (the same offset), so a fragment cut mid-word uses the line's right edge.
+   */
+  private fun lineEndHorizontal(
+    layout: Layout,
+    line: Int,
+    offset: Int,
+  ): Float =
+    if (offset >= layout.getLineEnd(line) && line < layout.lineCount - 1) {
+      layout.getLineRight(line)
+    } else {
+      layout.getPrimaryHorizontal(offset)
+    }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/view/SelectionActionMode.kt

@@ -12,6 +12,7 @@ import android.widget.TextView
 import com.swmansion.enriched.markdown.EnrichedMarkdown
 import com.swmansion.enriched.markdown.EnrichedMarkdownText
 import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacers
 import com.swmansion.enriched.markdown.styles.StyleConfig
 import com.swmansion.enriched.markdown.utils.common.layout.isLayoutRTL
 import com.swmansion.enriched.markdown.utils.text.conversion.HTMLGenerator
@@ -38,6 +39,8 @@ data class SelectionMenuConfig(
   // Drop every system-provided item (Select all, Share, text assist, PROCESS_TEXT…).
   val systemItemsNone: Boolean = false,
   val codeBlockCopyButton: Boolean = true,
+  // Copy hands the selection to onCopyRequest instead of writing the clipboard.
+  val interceptCopy: Boolean = false,
 )
 
 /**
@@ -69,6 +72,9 @@ fun createSelectionActionModeCallback(
   onActionModeChanged: (mode: ActionMode?) -> Unit = {},
   onCustomItemPress: (itemText: String, selectedText: String, selectionStart: Int, selectionEnd: Int) -> Unit =
     { _, _, _, _ -> },
+  // Receives the intercepted Copy when `interceptCopy` is set. `fullSelection`
+  // is whether the selection spans the whole text view.
+  onCopyRequest: (markdown: String, text: String, fullSelection: Boolean) -> Unit = { _, _, _ -> },
 ): ActionMode.Callback =
   object : ActionMode.Callback {
     override fun onCreateActionMode(
@@ -157,7 +163,10 @@ fun createSelectionActionModeCallback(
 
       when (itemId) {
         android.R.id.copy -> {
-          if (!getSelectionMenuConfig().copyFormatMarkdown || !textView.copyMarkdownToClipboard()) {
+          val config = getSelectionMenuConfig()
+          if (config.interceptCopy) {
+            textView.requestCopy(onCopyRequest)
+          } else if (!config.copyFormatMarkdown || !textView.copyMarkdownToClipboard()) {
             textView.copyWithHTML()
           }
           mode?.finish()
@@ -203,7 +212,8 @@ private fun TextView.copyWithHTML() {
   if (start < 0 || end < 0 || start >= end) return
 
   val spannable = text as? Spannable ?: return
-  val selectedText = spannable.subSequence(start, end)
+  // Link spacers only reserve layout space; keep them out of every copied flavor.
+  val selectedText = LinkSpacers.strip(spannable.subSequence(start, end))
   val plainText = selectedText.toString()
 
   val styleConfig =
@@ -229,6 +239,18 @@ private fun TextView.copyWithHTML() {
   }
 }
 
+/** Hands the selection to [onCopyRequest] without touching the clipboard. */
+private fun TextView.requestCopy(onCopyRequest: (markdown: String, text: String, fullSelection: Boolean) -> Unit) {
+  val start = selectionStart
+  val end = selectionEnd
+  if (start < 0 || end < 0 || start >= end) return
+
+  val selectedText = LinkSpacers.strip(text.subSequence(start, end)).toString()
+  val markdown = MarkdownExtractor.getMarkdownForSelection(this) ?: selectedText
+  // Same threshold MarkdownExtractor uses to return the original markdown.
+  onCopyRequest(markdown, selectedText, start == 0 && end >= text.length - 1)
+}
+
 /** Returns false when the selection has no Markdown to copy. */
 private fun TextView.copyMarkdownToClipboard(): Boolean {
   val markdown = MarkdownExtractor.getMarkdownForSelection(this) ?: return false