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

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

@@ -12,6 +12,12 @@ class CheckboxTouchHelper(
 ) {
   var onCheckboxTap: ((taskIndex: Int, checked: Boolean, itemText: String) -> Unit)? = null
 
+  /**
+   * When false, checkbox taps are ignored: hit-testing is skipped and no
+   * gesture is consumed, so the tap falls through to the text view unchanged.
+   */
+  var isEnabled: Boolean = true
+
   private var touchDownX = 0f
   private var touchDownY = 0f
   private var pendingHit: TaskListHitTestResult? = null
@@ -19,6 +25,7 @@ class CheckboxTouchHelper(
 
   /** Returns `true` if the event was consumed by a checkbox gesture. */
   fun onTouchEvent(event: MotionEvent): Boolean {
+    if (!isEnabled) return false
     when (event.actionMasked) {
       MotionEvent.ACTION_DOWN -> {
         val hit = TaskListTapUtils.hitTest(textView, event.x, event.y) ?: return false

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/HeadlessActionMode.kt

@@ -0,0 +1,88 @@
+package com.swmansion.enriched.markdown.utils.text.view
+
+import android.view.ActionMode
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.View
+import android.widget.PopupMenu
+
+/**
+ * Stands in for the floating text-selection toolbar while `contextMenuHidden`
+ * is on. An empty menu only hides the AOSP FloatingToolbar; ROMs that draw
+ * their own selection popup (MIUI) still show it. Answering the Editor's
+ * startActionMode with this mode means no toolbar window is ever created.
+ *
+ * The callback is the Editor's TextActionModeCallback wrapping ours, so it
+ * still gets the full create/prepare/destroy lifecycle: Editor keeps the
+ * selection handles and its transient-state bookkeeping, and finish() clears
+ * the selection exactly as dismissing the real toolbar would.
+ */
+internal class HeadlessActionMode private constructor(
+  private val view: View,
+  private val callback: ActionMode.Callback,
+) : ActionMode() {
+  // A real framework menu: Editor populates it with MenuItem calls
+  // (setAlphabeticShortcut, setShowAsAction, setIntent) a stub can't take.
+  private val menu: Menu = PopupMenu(view.context, view).menu
+  private var finished = false
+
+  override fun setTitle(title: CharSequence?) = Unit
+
+  override fun setTitle(resId: Int) = Unit
+
+  override fun setSubtitle(subtitle: CharSequence?) = Unit
+
+  override fun setSubtitle(resId: Int) = Unit
+
+  override fun setCustomView(view: View?) = Unit
+
+  override fun invalidate() {
+    if (!finished) callback.onPrepareActionMode(this, menu)
+  }
+
+  override fun invalidateContentRect() = Unit
+
+  override fun hide(duration: Long) = Unit
+
+  override fun finish() {
+    if (finished) return
+    finished = true
+    callback.onDestroyActionMode(this)
+  }
+
+  override fun getMenu(): Menu = menu
+
+  override fun getTitle(): CharSequence? = null
+
+  override fun getSubtitle(): CharSequence? = null
+
+  override fun getCustomView(): View? = null
+
+  override fun getMenuInflater(): MenuInflater = MenuInflater(view.context)
+
+  companion object {
+    /** Mirrors the framework: null when the callback declines to start. */
+    fun start(
+      view: View,
+      callback: ActionMode.Callback,
+    ): ActionMode? {
+      val mode = HeadlessActionMode(view, callback)
+      mode.type = TYPE_FLOATING
+      if (!callback.onCreateActionMode(mode, mode.menu)) return null
+      callback.onPrepareActionMode(mode, mode.menu)
+      return mode
+    }
+  }
+}
+
+/**
+ * MIUI 12 (Android 10) replaces android.widget.Editor: text selection never reaches
+ * startActionMode or the custom ActionMode callback, so HeadlessActionMode is never used.
+ * Its own popup is shown by Editor$HandleView.showActionPopupWindow, which posts a runnable
+ * on the TextView (Editor$HandleView$2). Dropping that runnable is the only hook left while
+ * `contextMenuHidden` is on.
+ */
+private const val ROM_SELECTION_POPUP_SHOWER_PREFIX = "android.widget.Editor\$HandleView"
+
+internal fun isRomSelectionPopupShower(action: Runnable?): Boolean =
+  action != null && action.javaClass.name.startsWith(ROM_SELECTION_POPUP_SHOWER_PREFIX)

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/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(