react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/interaction/TaskListTapUtils.kt

@@ -8,6 +8,8 @@ import android.text.style.StrikethroughSpan
 import android.widget.TextView
 import com.swmansion.enriched.markdown.renderer.SpanStyleCache
 import com.swmansion.enriched.markdown.spans.BaseListSpan
+import com.swmansion.enriched.markdown.spans.CodeBlockSpan
+import com.swmansion.enriched.markdown.spans.ListMarkerAnchorSpan
 import com.swmansion.enriched.markdown.spans.TaskListSpan
 import com.swmansion.enriched.markdown.styles.StyleConfig
 import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
@@ -101,51 +103,69 @@ object TaskListTapUtils {
     }
 
     val spannable = SpannableStringBuilder(text)
-    val taskSpans = spannable.getSpans(0, spannable.length, TaskListSpan::class.java)
-
-    val targetSpan = taskSpans.firstOrNull { it.taskIndex == targetIndex }
-    if (targetSpan == null) {
+    val targetSpans =
+      spannable
+        .getSpans(0, spannable.length, TaskListSpan::class.java)
+        .filter { it.taskIndex == targetIndex }
+    if (targetSpans.isEmpty()) {
       return false
     }
 
-    if (targetSpan.isChecked == newChecked) {
+    if (targetSpans.all { it.isChecked == newChecked }) {
       return true
     }
 
-    val spanStart = spannable.getSpanStart(targetSpan)
-    val spanEnd = spannable.getSpanEnd(targetSpan)
-    val itemDepth = targetSpan.depth
+    val itemDepth = targetSpans.first().depth
+    val spanStart = targetSpans.minOf { spannable.getSpanStart(it) }
+    val spanEnd = targetSpans.maxOf { spannable.getSpanEnd(it) }
 
     val styleCache = SpanStyleCache(styleConfig)
-    val newTaskSpan =
+
+    fun toggledCopy(old: TaskListSpan): TaskListSpan =
       TaskListSpan(
         taskStyle = styleConfig.taskListStyle,
         listStyle = styleConfig.listStyle,
-        depth = itemDepth,
+        depth = old.depth,
         context = textView.context,
         styleCache = styleCache,
         taskIndex = targetIndex,
         isChecked = newChecked,
+        drawsMarker = old.drawsMarker,
       )
 
-    spannable.removeSpan(targetSpan)
-    spannable.setSpan(newTaskSpan, spanStart, spanEnd, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
-
-    val verifySpans = spannable.getSpans(spanStart, spanEnd, TaskListSpan::class.java)
-    val verifySpan = verifySpans.firstOrNull { it.taskIndex == targetIndex }
-    if (verifySpan == null || verifySpan.isChecked != newChecked) {
-      return false
+    // Replace every segment of the item — spans are split around code blocks
+    for (old in targetSpans) {
+      val start = spannable.getSpanStart(old)
+      val end = spannable.getSpanEnd(old)
+      spannable.removeSpan(old)
+      spannable.setSpan(toggledCopy(old), start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
     }
 
+    // The marker may be drawn by an anchor span wrapping an unattached copy
+    spannable
+      .getSpans(0, spannable.length, ListMarkerAnchorSpan::class.java)
+      .filter { (it.marker as? TaskListSpan)?.taskIndex == targetIndex }
+      .forEach { old ->
+        val start = spannable.getSpanStart(old)
+        val end = spannable.getSpanEnd(old)
+        spannable.removeSpan(old)
+        spannable.setSpan(
+          ListMarkerAnchorSpan(toggledCopy(old.marker as TaskListSpan)),
+          start,
+          end,
+          SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+        )
+      }
+
     val taskStyle = styleConfig.taskListStyle
     val checkedTextColor = taskStyle.checkedTextColor
     val strikethrough = taskStyle.checkedStrikethrough
 
     val excludedRanges =
-      spannable
-        .getSpans(spanStart, spanEnd, BaseListSpan::class.java)
-        .filter { it.depth > itemDepth }
-        .map { spannable.getSpanStart(it) to spannable.getSpanEnd(it) }
+      (
+        spannable.getSpans(spanStart, spanEnd, BaseListSpan::class.java).filter { it.depth > itemDepth } +
+          spannable.getSpans(spanStart, spanEnd, CodeBlockSpan::class.java).toList()
+      ).map { spannable.getSpanStart(it) to spannable.getSpanEnd(it) }
         .sortedBy { it.first }
 
     applyDecorationsToRanges(

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/span/BlockSpacing.kt

@@ -1,6 +1,7 @@
 package com.swmansion.enriched.markdown.utils.text.span
 
 import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.spans.CodeBlockSpan
 import com.swmansion.enriched.markdown.spans.ImageSpan
 import com.swmansion.enriched.markdown.spans.LineHeightSpan
 import com.swmansion.enriched.markdown.spans.MarginBottomSpan
@@ -11,9 +12,9 @@ fun createLineHeightSpan(lineHeight: Float): AndroidLineHeightSpan = LineHeightS
 
 /**
  * Applies [LineHeightSpan] to [start]..[end] but skips ranges occupied by
- * block [ImageSpan]s (and their trailing '\n'). Without this, the fixed line
- * height would re-clamp the metrics that [ImageSpan.chooseHeight] expanded,
- * causing the image to overflow downward and overlap subsequent content.
+ * block [ImageSpan]s (and their trailing '\n') and by [CodeBlockSpan]s —
+ * both of these apply their own font-metric adjustments that a fixed
+ * line height would override.
  */
 fun applyLineHeightSkippingImages(
   builder: SpannableStringBuilder,
@@ -26,19 +27,25 @@ fun applyLineHeightSkippingImages(
       .getSpans(start, end, ImageSpan::class.java)
       .filter { !it.isInline }
       .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
-      .sortedBy { it.first }
+
+  val codeBlockRanges =
+    builder
+      .getSpans(start, end, CodeBlockSpan::class.java)
+      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+
+  val excludedRanges = (blockImageRanges + codeBlockRanges).sortedBy { it.first }
 
   var pos = start
-  for ((imgStart, imgEnd) in blockImageRanges) {
-    if (pos < imgStart) {
+  for ((exStart, exEnd) in excludedRanges) {
+    if (pos < exStart) {
       builder.setSpan(
         createLineHeightSpan(lineHeight),
         pos,
-        imgStart,
+        exStart,
         SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
       )
     }
-    val skipEnd = if (imgEnd < end && builder[imgEnd] == '\n') imgEnd + 1 else imgEnd
+    val skipEnd = if (exEnd < end && builder[exEnd] == '\n') exEnd + 1 else exEnd
     pos = maxOf(pos, skipEnd)
   }
   if (pos < end) {

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

@@ -2,9 +2,8 @@ package com.swmansion.enriched.markdown.utils.text.view
 
 import android.os.Handler
 import android.os.Looper
-import android.text.Selection
 import android.text.Spannable
-import android.text.method.LinkMovementMethod
+import android.text.method.ArrowKeyMovementMethod
 import android.view.MotionEvent
 import android.view.ViewConfiguration
 import android.widget.TextView
@@ -13,15 +12,26 @@ import com.swmansion.enriched.markdown.spans.SpoilerSpan
 import com.swmansion.enriched.markdown.spoiler.SpoilerCapable
 import kotlin.math.abs
 
-class LinkLongPressMovementMethod : LinkMovementMethod() {
+/**
+ * Movement method that adds link tap / long-press and spoiler tap handling on
+ * top of [ArrowKeyMovementMethod], the method [setTextIsSelectable] installs.
+ *
+ * Must never mutate the buffer's Selection spans — the platform Editor
+ * manages them during long-press gestures, and removing or overwriting
+ * them mid-gesture crashes on some OEM skins.
+ * See: https://github.com/software-mansion/enriched-markdown/issues/580
+ */
+class LinkLongPressMovementMethod : ArrowKeyMovementMethod() {
   private val handler = Handler(Looper.getMainLooper())
   private var longPressRunnable: Runnable? = null
 
   private var startX = 0f
   private var startY = 0f
+  private var pressedLink: LinkSpan? = null
 
   var isLinkTouchActive: Boolean = false
     private set
+  private var isTouchWithinTextBounds: Boolean = true
 
   override fun onTouchEvent(
     widget: TextView,
@@ -33,9 +43,10 @@ class LinkLongPressMovementMethod : LinkMovementMethod() {
         startX = event.x
         startY = event.y
 
-        val span = findLinkSpan(widget, buffer, event)
-        isLinkTouchActive = span != null
-        span?.let { scheduleLongPress(widget, it) }
+        pressedLink = findLinkSpan(widget, buffer, event)
+        isLinkTouchActive = pressedLink != null
+        isTouchWithinTextBounds = charOffsetAt(widget, event) != null
+        pressedLink?.let { scheduleLongPress(widget, it) }
       }
 
       MotionEvent.ACTION_MOVE -> {
@@ -45,17 +56,25 @@ class LinkLongPressMovementMethod : LinkMovementMethod() {
         ) {
           cancelLongPress()
           isLinkTouchActive = false
+          pressedLink = null
         }
       }
 
       MotionEvent.ACTION_UP -> {
         cancelLongPress()
+        val tappedLink = pressedLink
         isLinkTouchActive = false
-        if (widget.hasSelection()) {
-          Selection.removeSelection(buffer)
-        }
+        pressedLink = null
+
         if (handleSpoilerTap(widget, buffer, event)) {
-          Selection.removeSelection(buffer)
+          return true
+        }
+
+        // LinkSpan.onClick itself swallows the click that follows a completed
+        // long-press (and resets its internal flag), so it is always invoked
+        // for a tap that started and ended on the same link.
+        if (tappedLink != null && findLinkSpan(widget, buffer, event) === tappedLink) {
+          tappedLink.onClick(widget)
           return true
         }
       }
@@ -63,22 +82,19 @@ class LinkLongPressMovementMethod : LinkMovementMethod() {
       MotionEvent.ACTION_CANCEL -> {
         cancelLongPress()
         isLinkTouchActive = false
-        if (widget.hasSelection()) {
-          Selection.removeSelection(buffer)
-        }
+        pressedLink = null
       }
     }
 
-    val result = super.onTouchEvent(widget, buffer, event)
-
-    // LinkMovementMethod sets a Selection highlight around the link on ACTION_DOWN,
-    // which causes a visible selection color on the link text while pressed.
-    // We remove that selection immediately so the user never sees it.
-    if (event.action == MotionEvent.ACTION_DOWN) {
-      Selection.removeSelection(buffer)
+    // getOffsetForHorizontal snaps to the nearest character, so without this
+    // guard taps in empty space past the end of a line would still be treated
+    // as text touches. Let them fall through to the parent (e.g. RNGH
+    // Pressable) instead.
+    if (!isTouchWithinTextBounds) {
+      return false
     }
 
-    return result
+    return super.onTouchEvent(widget, buffer, event)
   }
 
   private fun scheduleLongPress(
@@ -89,9 +105,6 @@ class LinkLongPressMovementMethod : LinkMovementMethod() {
 
     longPressRunnable =
       Runnable {
-        if (widget.hasSelection()) {
-          Selection.removeSelection(widget.text as Spannable)
-        }
         // Execute the long click logic on the span
         if (span.onLongClick(widget)) {
           // If consumed, cancel the system's own long-press logic (like context menus)
@@ -112,10 +125,28 @@ class LinkLongPressMovementMethod : LinkMovementMethod() {
     widget: TextView,
     event: MotionEvent,
   ): Int? {
-    val x = event.x.toInt() - widget.totalPaddingLeft + widget.scrollX
-    val y = event.y.toInt() - widget.totalPaddingTop + widget.scrollY
+    val x = event.x - widget.totalPaddingLeft + widget.scrollX
+    val y = event.y - widget.totalPaddingTop + widget.scrollY
     val layout = widget.layout ?: return null
-    return layout.getOffsetForHorizontal(layout.getLineForVertical(y), x.toFloat())
+
+    // getLineForVertical clamps to the first/last line for out-of-range
+    // values, so taps in vertical padding would silently map to a real
+    // line. Reject them before proceeding.
+    if (y < 0f || y > layout.height) {
+      return null
+    }
+
+    val line = layout.getLineForVertical(y.toInt())
+
+    // getOffsetForHorizontal snaps to the nearest character even when the
+    // tap is outside the actual text content (e.g. empty space after the
+    // last word on a line). Guard against that by checking the tap falls
+    // within the line's text bounds.
+    if (x < layout.getLineLeft(line) || x > layout.getLineRight(line)) {
+      return null
+    }
+
+    return layout.getOffsetForHorizontal(line, x)
   }
 
   private fun findLinkSpan(

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

@@ -32,6 +32,12 @@ 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,
 )
 
 /**
@@ -57,6 +63,10 @@ fun createSelectionActionModeCallback(
   textView: TextView,
   getCustomItemTexts: () -> List<String> = { emptyList() },
   getSelectionMenuConfig: () -> SelectionMenuConfig = { SelectionMenuConfig() },
+  isContextMenuHidden: () -> Boolean = { false },
+  // Lets the owning view hold the live ActionMode so it can invalidate() the
+  // toolbar when a prop changes while the menu is already on screen.
+  onActionModeChanged: (mode: ActionMode?) -> Unit = {},
   onCustomItemPress: (itemText: String, selectedText: String, selectionStart: Int, selectionEnd: Int) -> Unit =
     { _, _, _, _ -> },
 ): ActionMode.Callback =
@@ -64,7 +74,10 @@ fun createSelectionActionModeCallback(
     override fun onCreateActionMode(
       mode: ActionMode?,
       menu: Menu?,
-    ): Boolean = true
+    ): Boolean {
+      onActionModeChanged(mode)
+      return true
+    }
 
     override fun onPrepareActionMode(
       mode: ActionMode?,
@@ -72,24 +85,39 @@ fun createSelectionActionModeCallback(
     ): Boolean {
       if (menu == null) return false
 
+      // Keep the ActionMode alive (selection handles and highlighting stay
+      // usable, which is what TalkBack relies on) but ship an empty menu so
+      // the floating toolbar has nothing to show.
+      if (isContextMenuHidden()) {
+        menu.clear()
+        return true
+      }
+
       menu.removeItem(MENU_ITEM_COPY_MARKDOWN)
       menu.removeItem(MENU_ITEM_COPY_IMAGE_URL)
       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,
@@ -98,7 +126,7 @@ fun createSelectionActionModeCallback(
         )
       }
 
-      if (textView.selectionStart >= 0 && textView.selectionEnd > textView.selectionStart) {
+      if (hasSelection) {
         val customItems = getCustomItemTexts()
         customItems.forEachIndexed { index, text ->
           menu
@@ -129,7 +157,9 @@ fun createSelectionActionModeCallback(
 
       when (itemId) {
         android.R.id.copy -> {
-          textView.copyWithHTML()
+          if (!getSelectionMenuConfig().copyFormatMarkdown || !textView.copyMarkdownToClipboard()) {
+            textView.copyWithHTML()
+          }
           mode?.finish()
           return true
         }
@@ -161,7 +191,9 @@ fun createSelectionActionModeCallback(
       return false
     }
 
-    override fun onDestroyActionMode(mode: ActionMode?) {}
+    override fun onDestroyActionMode(mode: ActionMode?) {
+      onActionModeChanged(null)
+    }
   }
 
 /** Copies selection as both plain text and HTML with inline styles. */
@@ -197,10 +229,12 @@ private fun TextView.copyWithHTML() {
   }
 }
 
-private fun TextView.copyMarkdownToClipboard() {
-  val markdown = MarkdownExtractor.getMarkdownForSelection(this) ?: return
+/** 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/views/BlockMenuOptions.kt

@@ -0,0 +1,45 @@
+package com.swmansion.enriched.markdown.views
+
+import com.swmansion.enriched.markdown.utils.text.view.SelectionMenuConfig
+
+/**
+ * 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,
+) {
+  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,
+      )
+  }
+}
+
+/** 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,
+  copyRaw: () -> Unit,
+  copyMarkdown: () -> Unit,
+) {
+  if (!options.copyHidden) {
+    item(ContextMenuPopup.Icon.COPY, copyLabel, if (options.copyWritesMarkdown) copyMarkdown else copyRaw)
+  }
+  if (!options.copyAsMarkdownHidden) {
+    item(ContextMenuPopup.Icon.DOCUMENT, copyAsMarkdownLabel, copyMarkdown)
+  }
+}