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

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
@@ -32,6 +33,14 @@ data class SelectionMenuConfig(
   // Plural templates indexed by image count (0..100). Empty when no pluralLabels
   // are set; counts > 100 use copyImageUrlsLabel (the "other" form).
   val copyImageUrlPluralTemplates: List<String> = emptyList(),
+  val copyEnabled: Boolean = true,
+  // Copy writes Markdown (plain text) instead of plain + HTML / raw block content.
+  val copyFormatMarkdown: Boolean = false,
+  // 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,
 )
 
 /**
@@ -63,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(
@@ -92,19 +104,26 @@ fun createSelectionActionModeCallback(
       menu.removeGroup(MENU_ITEM_CUSTOM_GROUP)
 
       val selectionMenuConfig = getSelectionMenuConfig()
+      val hasSelection = textView.selectionStart >= 0 && textView.selectionEnd > textView.selectionStart
 
-      // The system Copy item is added by the platform; relabel it so it
-      // matches the rest of the localized menu (iOS rebuilds the menu so
-      // gets this for free; Android only intercepts the click).
-      if (selectionMenuConfig.copyLabel.isNotEmpty()) {
+      if (selectionMenuConfig.systemItemsNone) {
+        // Editor re-adds Select all and the text-assist items before calling
+        // us on every prepare, so clear on each pass and put back only Copy.
+        // Its click is still intercepted in onActionItemClicked.
+        menu.clear()
+        if (selectionMenuConfig.copyEnabled && hasSelection) {
+          menu.add(Menu.NONE, android.R.id.copy, Menu.NONE, selectionMenuConfig.copyLabel)
+        }
+      } else if (!selectionMenuConfig.copyEnabled) {
+        menu.removeItem(android.R.id.copy)
+      } else if (selectionMenuConfig.copyLabel.isNotEmpty()) {
+        // The system Copy item is added by the platform; relabel it so it
+        // matches the rest of the localized menu (iOS rebuilds the menu so
+        // gets this for free; Android only intercepts the click).
         menu.findItem(android.R.id.copy)?.title = selectionMenuConfig.copyLabel
       }
 
-      if (
-        selectionMenuConfig.copyAsMarkdown &&
-        textView.selectionStart >= 0 &&
-        textView.selectionEnd > textView.selectionStart
-      ) {
+      if (selectionMenuConfig.copyAsMarkdown && hasSelection) {
         menu.add(
           Menu.NONE,
           MENU_ITEM_COPY_MARKDOWN,
@@ -113,7 +132,7 @@ fun createSelectionActionModeCallback(
         )
       }
 
-      if (textView.selectionStart >= 0 && textView.selectionEnd > textView.selectionStart) {
+      if (hasSelection) {
         val customItems = getCustomItemTexts()
         customItems.forEachIndexed { index, text ->
           menu
@@ -144,7 +163,12 @@ fun createSelectionActionModeCallback(
 
       when (itemId) {
         android.R.id.copy -> {
-          textView.copyWithHTML()
+          val config = getSelectionMenuConfig()
+          if (config.interceptCopy) {
+            textView.requestCopy(onCopyRequest)
+          } else if (!config.copyFormatMarkdown || !textView.copyMarkdownToClipboard()) {
+            textView.copyWithHTML()
+          }
           mode?.finish()
           return true
         }
@@ -188,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 =
@@ -214,10 +239,24 @@ private fun TextView.copyWithHTML() {
   }
 }
 
-private fun TextView.copyMarkdownToClipboard() {
-  val markdown = MarkdownExtractor.getMarkdownForSelection(this) ?: return
+/** 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
   val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
   clipboard.setPrimaryClip(ClipData.newPlainText("Markdown", markdown))
+  return true
 }
 
 /** Returns remote image URLs (http/https only) from the current selection. */

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

@@ -0,0 +1,232 @@
+package com.swmansion.enriched.markdown.utils.text.view
+
+import android.text.Layout
+import android.text.Selection
+import android.text.Spannable
+import android.view.View
+import android.widget.TextView
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.enriched.markdown.spans.LinkSpacers
+import com.swmansion.enriched.markdown.utils.text.conversion.MarkdownExtractor
+import kotlin.math.max
+import kotlin.math.min
+
+/** A rect in dp, relative to the reporting view. */
+data class SelectionRect(
+  val x: Float,
+  val y: Float,
+  val width: Float,
+  val height: Float,
+) {
+  companion object {
+    val ZERO = SelectionRect(0f, 0f, 0f, 0f)
+
+    /** Converts a px rect (already in the reporting view's coordinates) to dp. */
+    fun fromPx(
+      left: Float,
+      top: Float,
+      right: Float,
+      bottom: Float,
+    ) = SelectionRect(
+      PixelUtil.toDIPFromPixel(min(left, right)),
+      PixelUtil.toDIPFromPixel(min(top, bottom)),
+      PixelUtil.toDIPFromPixel(kotlin.math.abs(right - left)),
+      PixelUtil.toDIPFromPixel(kotlin.math.abs(bottom - top)),
+    )
+  }
+}
+
+/** Payload of `onSelectionChange`. Compared structurally for deduplication. */
+data class SelectionSnapshot(
+  val active: Boolean,
+  val source: String,
+  val text: String,
+  val markdown: String,
+  val whole: Boolean,
+  val rect: SelectionRect,
+  val startRect: SelectionRect,
+  val endRect: SelectionRect,
+  // Not tracked on Android: the selection is reported continuously while a handle is dragged.
+  val adjusting: Boolean = false,
+) {
+  companion object {
+    val INACTIVE =
+      SelectionSnapshot(false, "selection", "", "", false, SelectionRect.ZERO, SelectionRect.ZERO, SelectionRect.ZERO)
+
+    /** A long-pressed block: `whole`, and every rect is the block's frame. */
+    fun block(
+      source: String,
+      markdown: String,
+      text: String,
+      rect: SelectionRect,
+    ) = SelectionSnapshot(true, source, text, markdown, true, rect, rect, rect)
+  }
+}
+
+/** A text view's current selection, before the owner applies its `whole` rule. */
+data class TextSelection(
+  val text: String,
+  val markdown: String,
+  // Same threshold MarkdownExtractor uses to return the original markdown.
+  val fullSelection: Boolean,
+  val rect: SelectionRect,
+  val startRect: SelectionRect,
+  val endRect: SelectionRect,
+)
+
+/**
+ * Reads the selection of this text view with its rects offset by [offsetXPx]/[offsetYPx]
+ * (a segment's position inside its container). `rect` spans the full content width when the
+ * selection covers several lines; `startRect`/`endRect` cover the selected part of the first
+ * and last line. Returns null when nothing is selected.
+ */
+fun TextView.currentTextSelection(
+  offsetXPx: Int = 0,
+  offsetYPx: Int = 0,
+): TextSelection? {
+  val start = selectionStart
+  val end = selectionEnd
+  if (start < 0 || end <= start) return null
+  val layout = layout ?: return null
+  val content = text ?: return null
+
+  val selectedText = LinkSpacers.strip(content.subSequence(start, end)).toString()
+  val markdown = MarkdownExtractor.getMarkdownForSelection(this) ?: selectedText
+
+  val originX = (offsetXPx + totalPaddingLeft - scrollX).toFloat()
+  val originY = (offsetYPx + totalPaddingTop - scrollY).toFloat()
+
+  val startLine = layout.getLineForOffset(start)
+  // An end at a line break belongs to the line it closes, not the next one.
+  val endLine = layout.getLineForOffset(max(start, end - 1))
+  val startX = layout.getPrimaryHorizontal(start)
+  val endX = lineEndHorizontal(layout, endLine, end)
+
+  fun lineRect(
+    line: Int,
+    left: Float,
+    right: Float,
+  ) = SelectionRect.fromPx(
+    left + originX,
+    layout.getLineTop(line) + originY,
+    right + originX,
+    layout.getLineBottom(line) + originY,
+  )
+
+  val startRect: SelectionRect
+  val endRect: SelectionRect
+  val rect: SelectionRect
+  if (startLine == endLine) {
+    startRect = lineRect(startLine, startX, endX)
+    endRect = startRect
+    rect = startRect
+  } else {
+    startRect = lineRect(startLine, startX, layout.getLineRight(startLine))
+    endRect = lineRect(endLine, layout.getLineLeft(endLine), endX)
+    rect =
+      SelectionRect.fromPx(
+        originX,
+        layout.getLineTop(startLine) + originY,
+        layout.width + originX,
+        layout.getLineBottom(endLine) + originY,
+      )
+  }
+
+  return TextSelection(
+    text = selectedText,
+    markdown = markdown,
+    fullSelection = start == 0 && end >= content.length - 1,
+    rect = rect,
+    startRect = startRect,
+    endRect = endRect,
+  )
+}
+
+/** Clears this text view's selection, which also ends its selection ActionMode. */
+fun TextView.clearTextSelection() {
+  val spannable = text as? Spannable ?: return
+  Selection.removeSelection(spannable)
+}
+
+/**
+ * x of [offset] on [line]. At a line's end offset `getPrimaryHorizontal` reports the start
+ * of the next line, so a selection ending there 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)
+  }
+
+/**
+ * Coalesces selection changes into at most one `onSelectionChange` per frame. The payload is
+ * read when the frame 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, so the
+ * `setText` passes of streaming don't repeat `active: false`.
+ */
+class SelectionChangeReporter(
+  private val view: View,
+  private val snapshot: () -> SelectionSnapshot,
+  private val emit: (SelectionSnapshot) -> Unit,
+) {
+  var enabled = false
+    set(value) {
+      if (field == value) return
+      field = value
+      cancel()
+      lastReported = SelectionSnapshot.INACTIVE
+      if (value) schedule()
+    }
+
+  private var lastReported = SelectionSnapshot.INACTIVE
+  private var pending = false
+  private val flushRunnable =
+    Runnable {
+      pending = false
+      report()
+    }
+
+  /** Reports the current state on the next frame. */
+  fun schedule() {
+    if (!enabled || pending) return
+    pending = true
+    view.postOnAnimation(flushRunnable)
+  }
+
+  fun onSelectionChanged(hasSelection: Boolean) {
+    if (hasSelection) schedule() else flushNow()
+  }
+
+  /** Reports the current state right away, dropping any pending frame. */
+  fun flushNow() {
+    cancel()
+    report()
+  }
+
+  /**
+   * 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.
+   */
+  fun forgetLastReported() {
+    lastReported = SelectionSnapshot.INACTIVE
+  }
+
+  fun cancel() {
+    if (!pending) return
+    pending = false
+    view.removeCallbacks(flushRunnable)
+  }
+
+  private fun report() {
+    if (!enabled) return
+    val current = snapshot()
+    if (current == lastReported) return
+    lastReported = current
+    emit(current)
+  }
+}

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

@@ -0,0 +1,64 @@
+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
+ * that has not received options yet behaves exactly as before.
+ */
+data class BlockMenuOptions(
+  val copyHidden: Boolean = false,
+  // The Copy item writes the block's Markdown instead of its raw content.
+  val copyWritesMarkdown: Boolean = false,
+  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,
+      onCopyRequest: BlockCopyRequest? = null,
+    ) = BlockMenuOptions(
+      copyHidden = !config.copyEnabled,
+      copyWritesMarkdown = config.copyFormatMarkdown,
+      copyAsMarkdownHidden = !config.copyAsMarkdown,
+      copyButtonHidden = !config.codeBlockCopyButton,
+      onCopyRequest = onCopyRequest.takeIf { config.interceptCopy },
+    )
+  }
+}
+
+/** Adds the Copy / Copy as Markdown items shared by the table, math and code block menus. */
+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) {
+    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

@@ -70,6 +70,19 @@ class CodeBlockContainerView(
   // control, not a context menu, and stays.
   var contextMenuHidden: Boolean = false
 
+  // 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.
+  var onMenuSuppressed: ((markdown: String, text: String) -> Unit)? = null
+
+  // Copy / Copy as Markdown visibility, Copy format and the header copy button.
+  // The header button always copies the raw code.
+  var menuOptions: BlockMenuOptions = BlockMenuOptions()
+    set(value) {
+      field = value
+      // Hiding the button leaves the header (and its height) untouched.
+      copyButton.visibility = if (value.copyButtonHidden) View.GONE else View.VISIBLE
+    }
+
   var onCopyPress: ((code: String, language: String) -> Unit)? = null
 
   private var code: String = ""
@@ -250,10 +263,23 @@ class CodeBlockContainerView(
   // the event when there is one (a pending block has no menu yet, and a hidden
   // one never does).
   private fun showContextMenu(anchor: View): Boolean {
-    if (pending || contextMenuHidden) return false
+    if (pending) return false
+    if (contextMenuHidden) {
+      val onSuppressed = onMenuSuppressed ?: return false
+      onSuppressed(CodeBlockNode.fencedMarkdown(code, language, fenceChar), code)
+      return true
+    }
+    if (!menuOptions.hasItems) return false
     ContextMenuPopup.show(anchor, this) {
-      item(ContextMenuPopup.Icon.COPY, copyLabel) { copyCode() }
-      item(ContextMenuPopup.Icon.DOCUMENT, copyAsMarkdownLabel) { 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
@@ -64,6 +65,11 @@ class TableContainerView(
   var copyLabel: String = ""
   var copyAsMarkdownLabel: String = ""
   var contextMenuHidden: Boolean = false
+  var menuOptions: BlockMenuOptions = BlockMenuOptions()
+
+  // 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.
+  var onMenuSuppressed: ((markdown: String, text: String) -> Unit)? = null
 
   private val scrollView =
     HorizontalScrollView(context).apply {
@@ -80,6 +86,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,
@@ -363,11 +382,14 @@ class TableContainerView(
   }
 
   private fun showContextMenu(anchor: View) {
-    if (contextMenuHidden) return
+    if (contextMenuHidden) {
+      onMenuSuppressed?.invoke(tableMarkdown, buildPlainText())
+      return
+    }
     val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
     ContextMenuPopup.show(anchor, this) {
-      item(ContextMenuPopup.Icon.COPY, copyLabel) {
-        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 =
@@ -377,13 +399,14 @@ class TableContainerView(
           val html = HTMLGenerator.generateTableHTML(tableRows, styleConfig, displayMetrics.scaledDensity, displayMetrics.density)
           clipboard.setPrimaryClip(ClipData.newHtmlText("Table", plainText, html))
         }
-      }
-      item(ContextMenuPopup.Icon.DOCUMENT, copyAsMarkdownLabel) {
+      }, copyMarkdown = {
         if (tableMarkdown.isNotEmpty()) clipboard.setPrimaryClip(ClipData.newPlainText("Table", tableMarkdown))
-      }
+      })
     }
   }
 
+  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"
@@ -483,7 +506,7 @@ class TableContainerView(
                     .apply { configure(config, context) }
                     .renderDocument(MarkdownASTNode(NodeType.Document, children = listOf(paragraph)), null, null)
                 }
-              styledText.replaceMathSpansWithPlaceholders(context, config.inlineMathStyle.paddingVertical)
+              styledText.replaceMathSpansWithPlaceholders(context, config.inlineMathStyle.boxPaddingVertical)
               if (isHeader && styledText.isNotEmpty()) {
                 styledText.setSpan(HeaderTypefaceSpan(headerTypeface), 0, styledText.length, 33)
               }

package/android/src/math/java/com/swmansion/enriched/markdown/renderer/MathInlineRenderer.kt

@@ -37,6 +37,7 @@ class MathInlineRenderer(
         textColor = config.style.inlineMathStyle.color,
         paddingVertical = config.style.inlineMathStyle.paddingVertical,
         fontWeight = config.style.inlineMathStyle.fontWeight,
+        glyphOverflow = config.style.inlineMathStyle.glyphOverflow,
       )
 
     builder.setSpan(span, start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)