react-native-enriched-markdown-scaffold 0.6.0-scaffold.8 → 0.7.4-scaffold.2

package/android/src/main/java/com/swmansion/enriched/markdown/input/EnrichedMarkdownTextInputManager.kt

@@ -32,6 +32,8 @@ import com.swmansion.enriched.markdown.input.events.OnRequestMarkdownResultEvent
 import com.swmansion.enriched.markdown.input.events.OnStartMentionEvent
 import com.swmansion.enriched.markdown.input.layout.InputMeasurementStore
 import com.swmansion.enriched.markdown.input.model.StyleType
+import com.swmansion.enriched.markdown.input.toolbar.FormatMenuConfig
+import com.swmansion.enriched.markdown.input.toolbar.InputSelectionMenuConfig
 import com.swmansion.enriched.markdown.utils.input.BorderPropsApplicator
 import com.swmansion.enriched.markdown.utils.input.MarkdownStyleParser
 
@@ -266,6 +268,52 @@ class EnrichedMarkdownTextInputManager :
     view.setContextMenuItems(items)
   }
 
+  @ReactProp(name = "selectionMenuConfig")
+  override fun setSelectionMenuConfig(
+    view: EnrichedMarkdownTextInputView?,
+    value: ReadableMap?,
+  ) {
+    if (view == null) return
+    view.contextMenu.selectionMenuConfig =
+      if (value == null) {
+        InputSelectionMenuConfig()
+      } else {
+        InputSelectionMenuConfig(
+          format = value.getBoolean("format"),
+          formatLabel = value.getString("formatLabel") ?: "",
+          copyAsMarkdown = value.getBoolean("copyAsMarkdown"),
+          copyAsMarkdownLabel = value.getString("copyAsMarkdownLabel") ?: "",
+        )
+      }
+  }
+
+  @ReactProp(name = "formatMenuConfig")
+  override fun setFormatMenuConfig(
+    view: EnrichedMarkdownTextInputView?,
+    value: ReadableMap?,
+  ) {
+    if (view == null) return
+    view.contextMenu.formatMenuConfig =
+      if (value == null) {
+        FormatMenuConfig()
+      } else {
+        FormatMenuConfig(
+          bold = value.getBoolean("bold"),
+          boldLabel = value.getString("boldLabel") ?: "",
+          italic = value.getBoolean("italic"),
+          italicLabel = value.getString("italicLabel") ?: "",
+          underline = value.getBoolean("underline"),
+          underlineLabel = value.getString("underlineLabel") ?: "",
+          strikethrough = value.getBoolean("strikethrough"),
+          strikethroughLabel = value.getString("strikethroughLabel") ?: "",
+          spoiler = value.getBoolean("spoiler"),
+          spoilerLabel = value.getString("spoilerLabel") ?: "",
+          link = value.getBoolean("link"),
+          linkLabel = value.getString("linkLabel") ?: "",
+        )
+      }
+  }
+
   @ReactProp(name = "linkRegex")
   override fun setLinkRegex(
     view: EnrichedMarkdownTextInputView?,
@@ -445,6 +493,10 @@ class EnrichedMarkdownTextInputManager :
     view?.removeMath(start)
   }
 
+  override fun copyToClipboard(view: EnrichedMarkdownTextInputView?) {
+    view?.copyToClipboard()
+  }
+
   override fun requestMarkdown(
     view: EnrichedMarkdownTextInputView?,
     requestId: Int,

package/android/src/main/java/com/swmansion/enriched/markdown/input/EnrichedMarkdownTextInputView.kt

@@ -1,5 +1,7 @@
 package com.swmansion.enriched.markdown.input
 
+import android.content.ClipData
+import android.content.ClipboardManager
 import android.content.Context
 import android.graphics.BlendMode
 import android.graphics.BlendModeColorFilter
@@ -44,6 +46,8 @@ import com.swmansion.enriched.markdown.input.toolbar.InputContextMenu
 import com.swmansion.enriched.markdown.utils.input.AutoCapitalizeUtils
 import kotlin.math.ceil
 
+private fun Char.isLineBreak(): Boolean = this == '\n' || this == '\r' || this == '\u0085' || this == '\u2028' || this == '\u2029'
+
 class EnrichedMarkdownTextInputView(
   context: Context,
 ) : AppCompatEditText(context) {
@@ -71,6 +75,7 @@ class EnrichedMarkdownTextInputView(
   var autoFocusRequested = false
   var stateWrapper: StateWrapper? = null
   val layoutManager = InputLayoutManager(this)
+  private var pendingAutoFocusKeyboard = false
 
   private var typefaceDirty = false
   private var fontFamilyValue: String? = null
@@ -176,6 +181,13 @@ class EnrichedMarkdownTextInputView(
     refreshAllMathChips()
   }
 
+  override fun onWindowFocusChanged(hasWindowFocus: Boolean) {
+    super.onWindowFocusChanged(hasWindowFocus)
+    // The autofocus keyboard request may run before the window has IME focus (e.g. while a modal is
+    // still presenting), where showSoftInput() is dropped.
+    showAutoFocusKeyboardIfPending()
+  }
+
   override fun clearFocus() {
     super.clearFocus()
     inputMethodManager?.hideSoftInputFromWindow(windowToken, 0)
@@ -312,6 +324,12 @@ class EnrichedMarkdownTextInputView(
     if (!isComponentReady || isDuringTransaction) return
 
     if (!isTextChanging) {
+      // Links (e.g. mentions) are atomic: snap a partial selection to the whole link, and a caret
+      // inside a link to its end. Returning lets the recursive onSelectionChanged emit for the result.
+      formattingStore.selectionAdjustedForAtomicLinks(selStart, selEnd)?.let { (newStart, newEnd) ->
+        setSelection(newStart, newEnd)
+        return
+      }
       if (didTextChangeRecently) {
         didTextChangeRecently = false
       } else {
@@ -345,8 +363,18 @@ class EnrichedMarkdownTextInputView(
     val rangeStart = if (preEditSelectionStart != preEditSelectionEnd) preEditSelectionStart else editStart
     val rangeEnd = rangeStart + insertedLength
 
-    for (style in pendingStyles) {
-      formattingStore.addRange(FormattingRange(style, rangeStart, rangeEnd))
+    // Skip applying pending styles when the insertion is only line breaks —
+    // a phantom range over a bare newline corrupts isStyleActive() at the boundary.
+    val currentText = text
+    val insertedHasGlyphContent =
+      currentText != null &&
+        rangeEnd <= currentText.length &&
+        (rangeStart until rangeEnd).any { !currentText[it].isLineBreak() }
+
+    if (insertedHasGlyphContent) {
+      for (style in pendingStyles) {
+        formattingStore.addRange(FormattingRange(style, rangeStart, rangeEnd))
+      }
     }
 
     for (style in pendingStyleRemovals) {
@@ -439,6 +467,16 @@ class EnrichedMarkdownTextInputView(
     }
   }
 
+  // Copies the input's plain text to the system clipboard without disturbing
+  // the current selection. Android's system clipboard round-trip is plain text
+  // only — inline styles are not preserved for external paste targets.
+  fun copyToClipboard() {
+    val content = text
+    if (content.isNullOrEmpty()) return
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return
+    clipboard.setPrimaryClip(ClipData.newPlainText(null, content))
+  }
+
   fun setLinkForSelection(url: String) {
     val selStart = selectionStart
     val selEnd = selectionEnd
@@ -810,18 +848,36 @@ class EnrichedMarkdownTextInputView(
     return true
   }
 
-  private fun computeChipBounds(
+  /** Chip glyph rect in [Layout] coordinates — no padding, no scroll offset. */
+  private fun chipBoundsInLayout(
     layout: Layout,
     start: Int,
   ): Rect {
     val line = layout.getLineForOffset(start)
-    val xStart = (layout.getPrimaryHorizontal(start)).toInt() + totalPaddingLeft - scrollX
-    val xEnd = (layout.getPrimaryHorizontal(start + 1)).toInt() + totalPaddingLeft - scrollX
-    val top = layout.getLineTop(line) + totalPaddingTop - scrollY
-    val bottom = layout.getLineBottom(line) + totalPaddingTop - scrollY
-    return Rect(xStart, top, xEnd, bottom)
+    val xStart = layout.getPrimaryHorizontal(start).toInt()
+    val xEnd = layout.getPrimaryHorizontal(start + 1).toInt()
+    // Ordered, not raw start/end: in an RTL run xStart > xEnd, which would make an
+    // inverted Rect that contains() always rejects.
+    val left = xStart.coerceAtMost(xEnd)
+    var right = xStart.coerceAtLeast(xEnd)
+    if (right <= left) {
+      // A chip that is the last character has start + 1 == length, where some layouts
+      // report the same horizontal for both offsets. Fall back to the line's content edge
+      // so the rect keeps a real width instead of collapsing.
+      right = layout.getLineRight(line).toInt()
+    }
+    return Rect(left, layout.getLineTop(line), right, layout.getLineBottom(line))
   }
 
+  /** Chip glyph rect in view coordinates, for reporting to JS. */
+  private fun computeChipBounds(
+    layout: Layout,
+    start: Int,
+  ): Rect =
+    chipBoundsInLayout(layout, start).apply {
+      offset(totalPaddingLeft - scrollX, totalPaddingTop - scrollY)
+    }
+
   fun mathChipPositionAtTouch(
     x: Float,
     y: Float,
@@ -831,13 +887,21 @@ class EnrichedMarkdownTextInputView(
     val layoutNow = layout ?: return -1
     val adjustedX = (x - totalPaddingLeft + scrollX).toInt()
     val adjustedY = (y - totalPaddingTop + scrollY).toInt()
-    if (adjustedY < 0) return -1
+    // getLineForVertical and getOffsetForHorizontal both clamp into the laid-out text, so
+    // a touch in the padding or in the blank space below the last line resolves onto the
+    // nearest character. Bound the touch to the text box, then require it to land inside
+    // the chip's own rect — otherwise a tap beside a chip reads as a tap on it.
+    if (adjustedY < 0 || adjustedY > layoutNow.height) return -1
     val line = layoutNow.getLineForVertical(adjustedY)
     val offset = layoutNow.getOffsetForHorizontal(line, adjustedX.toFloat())
-    if (offset < 0 || offset >= editable.length) return -1
+    if (offset < 0) return -1
     val candidates = intArrayOf(offset, offset - 1).filter { it in 0 until editable.length }
     for (candidate in candidates) {
       val range = controller.chipRangeAt(editable, candidate) ?: continue
+      // An empty rect means the layout could not give us the chip's extent; accept the
+      // candidate then, rather than making the chip untappable.
+      val bounds = chipBoundsInLayout(layoutNow, range.first)
+      if (!bounds.isEmpty && !bounds.contains(adjustedX, adjustedY)) continue
       return range.first
     }
     return -1
@@ -954,11 +1018,25 @@ class EnrichedMarkdownTextInputView(
     setSelection(selectionStart.coerceAtLeast(0))
   }
 
+  private fun showAutoFocusKeyboardIfPending() {
+    if (!pendingAutoFocusKeyboard || !hasWindowFocus()) return
+    pendingAutoFocusKeyboard = false
+    inputMethodManager?.showSoftInput(this, 0)
+  }
+
   fun afterUpdateTransaction() {
     updateTypeface()
     if (autoFocusRequested) {
       autoFocusRequested = false
-      requestFocusProgrammatically()
+      pendingAutoFocusKeyboard = true
+      post {
+        // afterUpdateTransaction runs before onAttachedToWindow, where requestFocus()/showSoftInput()
+        // are dropped and setTextIsSelectable(true) would reset the caret to 0. Defer to the next loop
+        // so focus sticks and the caret lands at end (matching iOS).
+        requestFocus()
+        setSelection(text?.length ?: 0)
+        showAutoFocusKeyboardIfPending()
+      }
     }
   }
 

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/FormattingStore.kt

@@ -34,6 +34,25 @@ class FormattingStore {
     end: Int,
   ): Boolean = ranges.any { it.type == type && it.start < end && it.end > start }
 
+  /**
+   * Snaps a selection so it never partially overlaps an atomic link: a partial selection expands to
+   * the whole link, a caret inside a link moves to its end. Returns the adjusted (start, end) or null.
+   */
+  fun selectionAdjustedForAtomicLinks(
+    start: Int,
+    end: Int,
+  ): Pair<Int, Int>? {
+    if (start != end) {
+      var newStart = start
+      var newEnd = end
+      rangeOfType(StyleType.LINK, newStart)?.let { newStart = minOf(newStart, it.start) }
+      if (newEnd > 0) rangeOfType(StyleType.LINK, newEnd - 1)?.let { newEnd = maxOf(newEnd, it.end) }
+      return if (newStart != start || newEnd != end) Pair(newStart, newEnd) else null
+    }
+    val link = rangeOfType(StyleType.LINK, start)
+    return if (link != null && start > link.start && start < link.end) Pair(link.end, link.end) else null
+  }
+
   fun addRange(newRange: FormattingRange) {
     var mergedStart = newRange.start
     var mergedEnd = newRange.end

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/InputParser.kt

@@ -7,6 +7,7 @@ import com.swmansion.enriched.markdown.parser.MarkdownASTNode
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode.NodeType
 import com.swmansion.enriched.markdown.parser.Md4cFlags
 import com.swmansion.enriched.markdown.parser.Parser
+import com.swmansion.enriched.markdown.parser.isTopLevelBlock
 import com.swmansion.enriched.markdown.utils.common.FeatureFlags
 
 data class ParseResult(
@@ -18,6 +19,9 @@ data class ParseResult(
 object InputParser {
   private const val ATTACHMENT_CHAR = ''
 
+  // A source paragraph break: a newline followed by one or more blank lines.
+  private val PARAGRAPH_BREAK_RE = Regex("\\n[ \\t]*(?:\\n[ \\t]*)+")
+
   fun parseToPlainTextAndRanges(markdown: String): ParseResult {
     if (markdown.isEmpty()) {
       return ParseResult("", emptyList())
@@ -36,7 +40,17 @@ object InputParser {
     val ranges = mutableListOf<FormattingRange>()
     val mathAtoms = mutableListOf<MathAtom>()
 
-    walkNode(ast, plainText, ranges, mathAtoms, ArrayDeque())
+    // md4c collapses any blank-line run into a single break, unlike iOS which keeps them.
+    // Re-read the real runs so each break replays its original number of newlines.
+    val blankRuns =
+      ArrayDeque(
+        PARAGRAPH_BREAK_RE
+          .findAll(completed.trim())
+          .map { match -> match.value.count { it == '\n' } }
+          .toList(),
+      )
+
+    walkNode(ast, plainText, ranges, mathAtoms, ArrayDeque(), blankRuns)
 
     return ParseResult(plainText.toString(), ranges, mathAtoms)
   }
@@ -47,6 +61,7 @@ object InputParser {
     ranges: MutableList<FormattingRange>,
     mathAtoms: MutableList<MathAtom>,
     activeStyles: ArrayDeque<ActiveStyle>,
+    blankRuns: ArrayDeque<Int>,
   ) {
     if (node.type == NodeType.LatexMathInline || node.type == NodeType.LatexMathDisplay) {
       val latex = extractLatex(node)
@@ -75,8 +90,12 @@ object InputParser {
       plainText.append("\n")
     }
 
-    for (child in node.children) {
-      walkNode(child, plainText, ranges, mathAtoms, activeStyles)
+    for ((index, child) in node.children.withIndex()) {
+      // Keep the source's blank lines between top-level blocks (md4c drops them, iOS keeps them).
+      if (index > 0 && child.type.isTopLevelBlock() && plainText.isNotEmpty()) {
+        plainText.append("\n".repeat(blankRuns.removeFirstOrNull() ?: 2))
+      }
+      walkNode(child, plainText, ranges, mathAtoms, activeStyles, blankRuns)
     }
 
     if (styleType != null) {

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/InputRemend.kt

@@ -9,6 +9,7 @@ object InputRemend {
 
   private val DELIMITER_PAIRS =
     arrayOf(
+      DelimiterPair("***", "***", true),
       DelimiterPair("**", "**", true),
       DelimiterPair("*", "*", true),
       DelimiterPair("_", "_", true),

package/android/src/main/java/com/swmansion/enriched/markdown/input/layout/InputMeasurementStore.kt

@@ -9,6 +9,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.yoga.YogaMeasureMode
 import com.facebook.yoga.YogaMeasureOutput
+import com.swmansion.enriched.markdown.input.formatting.InputParser
 import java.util.concurrent.ConcurrentHashMap
 
 object InputMeasurementStore {
@@ -93,7 +94,12 @@ object InputMeasurementStore {
     width: Float,
     props: ReadableMap?,
   ): Long {
-    val text = props?.getString("defaultValue") ?: props?.getString("placeholder") ?: "I"
+    // Measure the rendered plain text, not the raw markdown. A mention link such as
+    // [Label](placeholder://x) hides its URL in the source, so measuring the markdown counts those
+    // invisible characters and over-estimates the height into extra lines, until the next text
+    // change forces a re-measure. Parsing first matches what the editor actually renders.
+    val markdown = props?.getString("defaultValue") ?: props?.getString("placeholder") ?: "I"
+    val text = InputParser.parseToPlainTextAndRanges(markdown).plainText
     val fontSize = props?.getDouble("fontSize")?.toFloat() ?: 16f
     val spSize = kotlin.math.ceil(PixelUtil.toPixelFromSP(fontSize).toDouble()).toFloat()
 

package/android/src/main/java/com/swmansion/enriched/markdown/input/toolbar/InputContextMenu.kt

@@ -14,12 +14,34 @@ import com.swmansion.enriched.markdown.input.formatting.MarkdownSerializer
 import com.swmansion.enriched.markdown.input.model.FormattingRange
 import com.swmansion.enriched.markdown.input.model.StyleType
 
-// TODO: Wrap all user-facing strings for localization support.
+data class InputSelectionMenuConfig(
+  val format: Boolean = true,
+  val formatLabel: String = "",
+  val copyAsMarkdown: Boolean = true,
+  val copyAsMarkdownLabel: String = "",
+)
+
+data class FormatMenuConfig(
+  val bold: Boolean = true,
+  val boldLabel: String = "",
+  val italic: Boolean = true,
+  val italicLabel: String = "",
+  val underline: Boolean = true,
+  val underlineLabel: String = "",
+  val strikethrough: Boolean = true,
+  val strikethroughLabel: String = "",
+  val spoiler: Boolean = true,
+  val spoilerLabel: String = "",
+  val link: Boolean = true,
+  val linkLabel: String = "",
+)
 
 class InputContextMenu(
   private val view: EnrichedMarkdownTextInputView,
 ) {
   private var customItemTexts: List<String> = emptyList()
+  var selectionMenuConfig: InputSelectionMenuConfig = InputSelectionMenuConfig()
+  var formatMenuConfig: FormatMenuConfig = FormatMenuConfig()
 
   fun setContextMenuItems(items: List<String>) {
     customItemTexts = items
@@ -42,13 +64,20 @@ class InputContextMenu(
           menu.removeGroup(FORMAT_MENU_GROUP_ID)
           menu.removeGroup(CUSTOM_MENU_GROUP_ID)
 
-          val formatSubMenu = menu.addSubMenu(FORMAT_MENU_GROUP_ID, MENU_FORMAT_ID, 100, "Format")
-          FORMAT_ITEMS.forEachIndexed { index, (title, _) ->
-            formatSubMenu.add(Menu.NONE, MENU_FORMAT_ITEM_BASE + index, index, title)
+          if (selectionMenuConfig.format) {
+            val formatSubMenu =
+              menu.addSubMenu(FORMAT_MENU_GROUP_ID, MENU_FORMAT_ID, 100, selectionMenuConfig.formatLabel)
+            FORMAT_ITEMS.forEachIndexed { index, (styleType, labelOf) ->
+              if (isFormatItemVisible(styleType)) {
+                formatSubMenu.add(Menu.NONE, MENU_FORMAT_ITEM_BASE + index, index, labelOf(formatMenuConfig))
+              }
+            }
           }
 
           if (view.selectionStart < view.selectionEnd) {
-            menu.add(FORMAT_MENU_GROUP_ID, MENU_COPY_MARKDOWN_ID, 101, "Copy as Markdown")
+            if (selectionMenuConfig.copyAsMarkdown) {
+              menu.add(FORMAT_MENU_GROUP_ID, MENU_COPY_MARKDOWN_ID, 101, selectionMenuConfig.copyAsMarkdownLabel)
+            }
 
             customItemTexts.forEachIndexed { index, text ->
               menu
@@ -74,7 +103,7 @@ class InputContextMenu(
 
           val formatIndex = itemId - MENU_FORMAT_ITEM_BASE
           if (formatIndex in FORMAT_ITEMS.indices) {
-            applyFormat(FORMAT_ITEMS[formatIndex].second)
+            applyFormat(FORMAT_ITEMS[formatIndex].first)
             mode.finish()
             return true
           }
@@ -96,6 +125,16 @@ class InputContextMenu(
       }
   }
 
+  private fun isFormatItemVisible(styleType: StyleType): Boolean =
+    when (styleType) {
+      StyleType.BOLD -> formatMenuConfig.bold
+      StyleType.ITALIC -> formatMenuConfig.italic
+      StyleType.UNDERLINE -> formatMenuConfig.underline
+      StyleType.STRIKETHROUGH -> formatMenuConfig.strikethrough
+      StyleType.SPOILER -> formatMenuConfig.spoiler
+      StyleType.LINK -> formatMenuConfig.link
+    }
+
   private fun applyFormat(styleType: StyleType) {
     val start = view.selectionStart
     val end = view.selectionEnd
@@ -168,14 +207,16 @@ class InputContextMenu(
     private const val CUSTOM_MENU_GROUP_ID = 2000
     private const val MENU_CUSTOM_BASE = 2001
 
-    private val FORMAT_ITEMS =
+    // Order here defines submenu order and the index used by
+    // `MENU_FORMAT_ITEM_BASE + index` when handling clicks.
+    private val FORMAT_ITEMS: List<Pair<StyleType, (FormatMenuConfig) -> String>> =
       listOf(
-        "Bold" to StyleType.BOLD,
-        "Italic" to StyleType.ITALIC,
-        "Underline" to StyleType.UNDERLINE,
-        "Strikethrough" to StyleType.STRIKETHROUGH,
-        "Spoiler" to StyleType.SPOILER,
-        "Link" to StyleType.LINK,
+        StyleType.BOLD to { it.boldLabel },
+        StyleType.ITALIC to { it.italicLabel },
+        StyleType.UNDERLINE to { it.underlineLabel },
+        StyleType.STRIKETHROUGH to { it.strikethroughLabel },
+        StyleType.SPOILER to { it.spoilerLabel },
+        StyleType.LINK to { it.linkLabel },
       )
   }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/parser/MarkdownASTNode.kt

@@ -41,3 +41,20 @@ data class MarkdownASTNode(
 
   fun getAttribute(key: String): String? = attributes[key]
 }
+
+// A node type that md4c emits as a standalone block stacked vertically, as opposed to an inline span.
+internal fun MarkdownASTNode.NodeType.isTopLevelBlock(): Boolean =
+  when (this) {
+    MarkdownASTNode.NodeType.Paragraph,
+    MarkdownASTNode.NodeType.Heading,
+    MarkdownASTNode.NodeType.Blockquote,
+    MarkdownASTNode.NodeType.UnorderedList,
+    MarkdownASTNode.NodeType.OrderedList,
+    MarkdownASTNode.NodeType.CodeBlock,
+    MarkdownASTNode.NodeType.ThematicBreak,
+    MarkdownASTNode.NodeType.Table,
+    MarkdownASTNode.NodeType.LatexMathDisplay,
+    -> true
+
+    else -> false
+  }

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/SpanStyleCache.kt

@@ -52,10 +52,10 @@ class SpanStyleCache(
     val paragraphColor = style.paragraphStyle.color
     return buildList {
       style.strongStyle.color
-        ?.takeIf { it != 0 }
+        ?.takeIf { it != 0 && it != paragraphColor }
         ?.let { add(it) }
       style.emphasisStyle.color
-        ?.takeIf { it != 0 }
+        ?.takeIf { it != 0 && it != paragraphColor }
         ?.let { add(it) }
       style.linkStyle.color
         .takeIf { it != 0 && it != paragraphColor }
@@ -68,10 +68,10 @@ class SpanStyleCache(
       style
         .codeStyle
         .color
-        .takeIf { it != 0 }
+        .takeIf { it != 0 && it != paragraphColor }
         ?.let { add(it) }
       style.taskListStyle.checkedTextColor
-        .takeIf { it != 0 }
+        .takeIf { it != 0 && it != paragraphColor }
         ?.let { add(it) }
     }.toIntArray()
   }

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

@@ -4,6 +4,7 @@ import android.view.View
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 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.LinkLongPressEvent
 import com.swmansion.enriched.markdown.events.LinkPressEvent
@@ -96,5 +97,34 @@ fun parseSelectionMenuConfig(value: ReadableMap?): SelectionMenuConfig {
   return SelectionMenuConfig(
     copyAsMarkdown = value.getBoolean("copyAsMarkdown"),
     copyImageUrl = value.getBoolean("copyImageUrl"),
+    copyLabel = value.getString("copyLabel") ?: "",
+    copyAsMarkdownLabel = value.getString("copyAsMarkdownLabel") ?: "",
+    copyImageUrlLabel = value.getString("copyImageUrlLabel") ?: "",
+    copyImageUrlsLabel = value.getString("copyImageUrlsLabel") ?: "",
+    copyImageUrlPluralTemplates = parseStringList(value.getArray("copyImageUrlPluralTemplates")),
   )
 }
+
+fun parseAccessibilityLabels(value: ReadableMap?): AccessibilityLabels {
+  if (value == null) return AccessibilityLabels()
+  val list = value.getMap("list")
+  val blockquote = value.getMap("blockquote")
+  val table = value.getMap("table")
+  val math = value.getMap("math")
+  val rotor = value.getMap("rotor")
+  return AccessibilityLabels(
+    bulletPoint = list?.getString("bulletPoint") ?: "",
+    nestedBulletPoint = list?.getString("nestedBulletPoint") ?: "",
+    orderedItem = list?.getString("orderedItem") ?: "",
+    nestedOrderedItem = list?.getString("nestedOrderedItem") ?: "",
+    blockquote = blockquote?.getString("quote") ?: "",
+    nestedBlockquote = blockquote?.getString("nestedQuote") ?: "",
+    tableRow = table?.getString("row") ?: "",
+    mathEquation = math?.getString("equation") ?: "",
+    rotorHeadings = rotor?.getString("headings") ?: "",
+    rotorLinks = rotor?.getString("links") ?: "",
+    rotorImages = rotor?.getString("images") ?: "",
+  )
+}
+
+private fun parseStringList(value: ReadableArray?): List<String> = (0 until (value?.size() ?: 0)).mapNotNull { value?.getString(it) }

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

@@ -26,18 +26,40 @@ fun View.emitLinkLongPressEvent(url: String) {
 /**
  * Cancels the JS touch for an active link tap, preventing parent
  * Pressable/TouchableOpacity from firing onPress for the same tap.
+ *
+ * Also requests that parent ViewGroups do not intercept subsequent touch
+ * events in this gesture. This is necessary for react-native-gesture-handler's
+ * Pressable, which intercepts at the native ViewGroup level and would otherwise
+ * steal the gesture before ACTION_UP reaches the TextView.
  */
 fun TextView.cancelJSTouchForLinkTap(event: MotionEvent) {
   val currentMovementMethod = movementMethod
   if (currentMovementMethod is LinkLongPressMovementMethod && currentMovementMethod.isLinkTouchActive) {
+    parent?.requestDisallowInterceptTouchEvent(true)
     NativeGestureUtil.notifyNativeGestureStarted(this, event)
   }
 }
 
+/**
+ * Re-allows parent ViewGroups to intercept touch events once the link
+ * touch is no longer active (slop exceeded, gesture ended, or cancelled).
+ * This restores normal scrolling behavior for parent ScrollView/RecyclerView.
+ *
+ * Must be called after [LinkLongPressMovementMethod.onTouchEvent] has
+ * processed the event, since that is where [isLinkTouchActive] is updated.
+ */
+fun TextView.reallowParentInterceptIfLinkReleased() {
+  val currentMovementMethod = movementMethod
+  if (currentMovementMethod is LinkLongPressMovementMethod && !currentMovementMethod.isLinkTouchActive) {
+    parent?.requestDisallowInterceptTouchEvent(false)
+  }
+}
+
 /**
  * Cancels the JS touch unconditionally, preventing parent
  * Pressable/TouchableOpacity from firing onPress for the same gesture.
  */
 fun View.cancelJSTouchForCheckboxTap(event: MotionEvent) {
+  parent?.requestDisallowInterceptTouchEvent(true)
   NativeGestureUtil.notifyNativeGestureStarted(this, event)
 }