@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.10

package/android/src/main/java/com/renderrichtext/utils/text/interaction/TaskListTapUtils.kt

@@ -0,0 +1,286 @@
+package com.renderrichtext.utils.text.interaction
+
+import android.text.Spannable
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.style.ForegroundColorSpan
+import android.text.style.StrikethroughSpan
+import android.widget.TextView
+import com.renderrichtext.renderer.SpanStyleCache
+import com.renderrichtext.spans.BaseListSpan
+import com.renderrichtext.spans.CodeBlockSpan
+import com.renderrichtext.spans.ListMarkerAnchorSpan
+import com.renderrichtext.spans.TaskListSpan
+import com.renderrichtext.styles.StyleConfig
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+data class TaskListHitTestResult(
+  val taskIndex: Int,
+  val checked: Boolean,
+  val itemText: String,
+)
+
+object TaskListToggleUtils {
+  private val TASK_PATTERN = Regex("""^([ \t]*[-*+][ \t]+)\[[ xX]]""", RegexOption.MULTILINE)
+
+  fun toggleAtIndex(
+    tiptap: String,
+    index: Int,
+    checked: Boolean,
+  ): String {
+    val matches = TASK_PATTERN.findAll(tiptap).toList()
+    if (index < 0 || index >= matches.size) return tiptap
+
+    val match = matches[index]
+    val prefix = match.groupValues[1]
+
+    val replacement = "$prefix[${if (checked) "x" else " "}]"
+
+    return tiptap.replaceRange(match.range, replacement)
+  }
+}
+
+object TaskListTapUtils {
+  fun hitTest(
+    textView: TextView,
+    rawX: Float,
+    rawY: Float,
+  ): TaskListHitTestResult? =
+    with(textView) {
+      val layout = layout ?: return null
+      val spannable = text as? Spanned ?: return null
+
+      val x = rawX.toInt() - totalPaddingLeft + scrollX
+      val y = rawY.toInt() - totalPaddingTop + scrollY
+
+      val line = layout.getLineForVertical(y)
+
+      val taskSpan =
+        spannable
+          .getSpans(
+            layout.getLineStart(line),
+            layout.getLineEnd(line),
+            TaskListSpan::class.java,
+          ).maxByOrNull { it.depth } ?: return null
+
+      val isRtl = layout.getParagraphDirection(line) == android.text.Layout.DIR_RIGHT_TO_LEFT
+      if (isRtl) {
+        val lineRight = layout.getLineRight(line).toInt()
+        val indentWidth = lineRight - layout.getParagraphRight(line).toInt()
+        if (x <= layout.width - indentWidth) return null
+      } else {
+        val lineLeft = layout.getLineLeft(line).toInt()
+        val indentWidth = layout.getParagraphLeft(line).toInt() - lineLeft
+        if (x >= indentWidth) return null
+      }
+
+      val spanStart = spannable.getSpanStart(taskSpan)
+      val spanEnd = spannable.getSpanEnd(taskSpan)
+
+      val itemText =
+        spannable
+          .subSequence(spanStart, spanEnd)
+          .toString()
+          .substringBefore('\n')
+          .trim()
+
+      return TaskListHitTestResult(
+        taskIndex = taskSpan.taskIndex,
+        checked = taskSpan.isChecked,
+        itemText = itemText,
+      )
+    }
+
+  fun updateTaskListItemCheckedState(
+    textView: TextView,
+    targetIndex: Int,
+    newChecked: Boolean,
+    styleConfig: StyleConfig,
+  ): Boolean {
+    val text = textView.text
+    if (text !is Spannable) {
+      return false
+    }
+
+    val spannable = SpannableStringBuilder(text)
+    val targetSpans =
+      spannable
+        .getSpans(0, spannable.length, TaskListSpan::class.java)
+        .filter { it.taskIndex == targetIndex }
+    if (targetSpans.isEmpty()) {
+      return false
+    }
+
+    if (targetSpans.all { it.isChecked == newChecked }) {
+      return true
+    }
+
+    val itemDepth = targetSpans.first().depth
+    val spanStart = targetSpans.minOf { spannable.getSpanStart(it) }
+    val spanEnd = targetSpans.maxOf { spannable.getSpanEnd(it) }
+
+    val styleCache = SpanStyleCache(styleConfig)
+
+    fun toggledCopy(old: TaskListSpan): TaskListSpan =
+      TaskListSpan(
+        taskStyle = styleConfig.taskListStyle,
+        listStyle = styleConfig.listStyle,
+        depth = old.depth,
+        context = textView.context,
+        styleCache = styleCache,
+        taskIndex = targetIndex,
+        isChecked = newChecked,
+        drawsMarker = old.drawsMarker,
+        ancestorMarkerOffset = old.ancestorMarkerOffset,
+        markerExtraWidth = old.markerExtraWidth,
+        parentMarkerWidth = old.parentMarkerWidth,
+      )
+
+    // Layout draws leading margins in insertion order, and a re-added span moves to the end of it.
+    // Re-add the task's spans and everything attached after them (its ancestors) in their original
+    // order; the task's own nested items were attached first and stay where they are.
+    data class ListSpanState(
+      val span: BaseListSpan,
+      val start: Int,
+      val end: Int,
+      val flags: Int,
+    )
+
+    val coveringSpans = spannable.getSpans(spanStart, spanEnd, BaseListSpan::class.java)
+    val firstTarget = coveringSpans.indexOfFirst { it is TaskListSpan && it.taskIndex == targetIndex }
+    val listSpans =
+      coveringSpans.drop(firstTarget).map {
+        ListSpanState(it, spannable.getSpanStart(it), spannable.getSpanEnd(it), spannable.getSpanFlags(it))
+      }
+    listSpans.forEach { spannable.removeSpan(it.span) }
+    for ((old, start, end, flags) in listSpans) {
+      val replacement = if (old is TaskListSpan && old.taskIndex == targetIndex) toggledCopy(old) else old
+      spannable.setSpan(replacement, start, end, flags)
+    }
+
+    // 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 } +
+          spannable.getSpans(spanStart, spanEnd, CodeBlockSpan::class.java).toList()
+      ).map { spannable.getSpanStart(it) to spannable.getSpanEnd(it) }
+        .sortedBy { it.first }
+
+    applyDecorationsToRanges(
+      spannable = spannable,
+      spanStart = spanStart,
+      spanEnd = spanEnd,
+      excludedRanges = excludedRanges,
+      isChecked = newChecked,
+      checkedTextColor = checkedTextColor,
+      strikethrough = strikethrough,
+      styleConfig = styleConfig,
+    )
+
+    val imageSpans = text.getSpans(0, text.length, com.renderrichtext.spans.ImageSpan::class.java).toList()
+    val originalSpanStarts = imageSpans.associateWith { text.getSpanStart(it) }
+
+    textView.text = spannable
+
+    val newImageSpans = spannable.getSpans(0, spannable.length, com.renderrichtext.spans.ImageSpan::class.java)
+    imageSpans.forEach { originalSpan ->
+      val matchingSpan =
+        newImageSpans.firstOrNull {
+          it.imageUrl == originalSpan.imageUrl &&
+            spannable.getSpanStart(it) == originalSpanStarts[originalSpan]
+        }
+      (matchingSpan ?: originalSpan).registerTextView(textView)
+    }
+
+    textView.invalidate()
+
+    return true
+  }
+
+  private fun applyDecorationsToRanges(
+    spannable: Spannable,
+    spanStart: Int,
+    spanEnd: Int,
+    excludedRanges: List<Pair<Int, Int>>,
+    isChecked: Boolean,
+    checkedTextColor: Int,
+    strikethrough: Boolean,
+    styleConfig: StyleConfig,
+  ) {
+    var currentPos = spanStart
+    for ((start, end) in excludedRanges) {
+      if (start > currentPos) {
+        if (isChecked) {
+          applyCheckedSpans(spannable, currentPos, start, checkedTextColor, strikethrough)
+        } else {
+          removeCheckedSpans(spannable, currentPos, start, styleConfig)
+        }
+      }
+      currentPos = maxOf(currentPos, end)
+    }
+    if (currentPos < spanEnd) {
+      if (isChecked) {
+        applyCheckedSpans(spannable, currentPos, spanEnd, checkedTextColor, strikethrough)
+      } else {
+        removeCheckedSpans(spannable, currentPos, spanEnd, styleConfig)
+      }
+    }
+  }
+
+  private fun applyCheckedSpans(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+    color: Int,
+    strikethrough: Boolean,
+  ) {
+    if (color != 0) {
+      spannable.setSpan(ForegroundColorSpan(color), start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    }
+    if (strikethrough) {
+      spannable.setSpan(StrikethroughSpan(), start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    }
+  }
+
+  private fun removeCheckedSpans(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+    styleConfig: StyleConfig,
+  ) {
+    val strikethroughSpans = spannable.getSpans(start, end, StrikethroughSpan::class.java)
+    strikethroughSpans.forEach { spannable.removeSpan(it) }
+
+    val colorSpans = spannable.getSpans(start, end, ForegroundColorSpan::class.java)
+    colorSpans.forEach { spannable.removeSpan(it) }
+
+    val listStyleColor = styleConfig.listStyle.color
+    if (listStyleColor != 0) {
+      spannable.setSpan(
+        ForegroundColorSpan(listStyleColor),
+        start,
+        end,
+        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/utils/text/span/ApplyLineHeight.kt

@@ -0,0 +1,39 @@
+package com.renderrichtext.utils.text.span
+
+import android.graphics.Paint.FontMetricsInt
+import kotlin.math.ceil
+import kotlin.math.floor
+
+/**
+ * Splits extra leading above and below the line, copied from RN
+ * CustomLineHeightSpan so we do not depend on React Native internal span types.
+ *
+ * Mirrors CustomLineHeightSpan.chooseHeight:
+ * https://github.com/react/react-native/blob/v0.86.2/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/internal/span/CustomLineHeightSpan.kt#L44-L57
+ *
+ * Unlike RN, [lineHeight] is a floor, not a clamp: taller content grows the
+ * line instead of being clipped (for example, inline code taller than the paragraph).
+ */
+internal fun applyLineHeight(
+  fm: FontMetricsInt,
+  lineHeight: Int,
+  start: Int,
+  end: Int,
+  textLength: Int,
+) {
+  val leading = lineHeight - ((-fm.ascent) + fm.descent)
+
+  // Use lineHeight as a floor: if the default line-height is greater, don't
+  // override it
+  if (leading > 0) {
+    fm.ascent -= ceil(leading / 2.0f).toInt()
+    fm.descent += floor(leading / 2.0f).toInt()
+  }
+
+  if (start == 0) {
+    fm.top = fm.ascent
+  }
+  if (end == textLength) {
+    fm.bottom = fm.descent
+  }
+}

package/android/src/main/java/com/renderrichtext/utils/text/span/BlockSpacing.kt

@@ -0,0 +1,142 @@
+package com.renderrichtext.utils.text.span
+
+import android.text.SpannableStringBuilder
+import com.renderrichtext.spans.CodeBlockSpan
+import com.renderrichtext.spans.ImageSpan
+import com.renderrichtext.spans.LineHeightSpan
+import com.renderrichtext.spans.LinkPillSpan
+import com.renderrichtext.spans.MarginBottomSpan
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import android.text.style.LineHeightSpan as AndroidLineHeightSpan
+
+fun createLineHeightSpan(lineHeight: Float): AndroidLineHeightSpan = LineHeightSpan(lineHeight)
+
+/** The line height floor that link pills ask of their paragraph. */
+private class LinkPillLineHeightSpan(
+  height: Float,
+) : AndroidLineHeightSpan by LineHeightSpan(height)
+
+/**
+ * Raises the line height of every paragraph in [start]..[end] to the largest
+ * `pill.lineHeight` among its link pills. A line grows to fit a pill on its own, but only
+ * that line and only to the pill's box, so pills on consecutive lines touch. A style that
+ * sets `pill.lineHeight` gets a floor for the whole paragraph instead, which keeps its
+ * lines even and the pills apart.
+ *
+ * Nested blocks set line height over ranges that overlap, so a paragraph that already
+ * has its floor is left alone. [spanFlags] are those of the block's own line height span:
+ * line height spans apply in order, and the floor has to come before the spans that add a
+ * margin to a line, or it would swallow that margin.
+ */
+fun applyLinkPillLineHeight(
+  builder: SpannableStringBuilder,
+  start: Int,
+  end: Int,
+  spanFlags: Int = SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+) {
+  val heights = HashMap<Int, Float>()
+  for (pill in builder.getSpans(start, end, LinkPillSpan::class.java)) {
+    val pillStart = builder.getSpanStart(pill)
+    // getSpans also returns a pill that only touches the range.
+    if (pill.lineHeight <= 0 || pillStart < start || pillStart >= end) continue
+    val paragraphStart = builder.lastIndexOf('\n', pillStart - 1).let { if (it < start) start else it + 1 }
+    heights[paragraphStart] = maxOf(heights[paragraphStart] ?: 0f, pill.lineHeight)
+  }
+  for ((paragraphStart, height) in heights) {
+    val paragraphEnd = builder.indexOf('\n', paragraphStart).let { if (it < 0 || it >= end) end else it + 1 }
+    // getSpans also returns the floor of a neighbouring paragraph, which only touches this one.
+    val hasFloor =
+      builder
+        .getSpans(paragraphStart, paragraphEnd, LinkPillLineHeightSpan::class.java)
+        .any { builder.getSpanStart(it) <= paragraphStart && builder.getSpanEnd(it) > paragraphStart }
+    if (hasFloor) continue
+    builder.setSpan(LinkPillLineHeightSpan(height), paragraphStart, paragraphEnd, spanFlags)
+  }
+}
+
+/**
+ * Applies [LineHeightSpan] to [start]..[end] but skips ranges occupied by
+ * 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,
+  start: Int,
+  end: Int,
+  lineHeight: Float,
+  spanFlags: Int = SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+) {
+  val blockImageRanges =
+    builder
+      .getSpans(start, end, ImageSpan::class.java)
+      .filter { !it.isInline }
+      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+
+  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 ((exStart, exEnd) in excludedRanges) {
+    if (pos < exStart) {
+      builder.setSpan(
+        createLineHeightSpan(lineHeight),
+        pos,
+        exStart,
+        spanFlags,
+      )
+    }
+    val skipEnd = if (exEnd < end && builder[exEnd] == '\n') exEnd + 1 else exEnd
+    pos = maxOf(pos, skipEnd)
+  }
+  if (pos < end) {
+    builder.setSpan(
+      createLineHeightSpan(lineHeight),
+      pos,
+      end,
+      spanFlags,
+    )
+  }
+  applyLinkPillLineHeight(builder, start, end, spanFlags)
+}
+
+fun applyMarginTop(
+  builder: SpannableStringBuilder,
+  insertionPoint: Int,
+  marginTop: Float,
+) {
+  if (marginTop <= 0) return
+
+  // Insert a newline character to act as a vertical spacer
+  builder.insert(insertionPoint, "\n")
+
+  // Apply MarginBottomSpan to the spacer character to create the gap before the content
+  builder.setSpan(
+    MarginBottomSpan(marginTop),
+    insertionPoint,
+    insertionPoint + 1,
+    SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+  )
+}
+
+fun applyMarginBottom(
+  builder: SpannableStringBuilder,
+  marginBottom: Float,
+) {
+  val spacerStart = builder.length
+  builder.append("\n")
+  // Always create a MarginBottomSpan, even when marginBottom = 0.
+  // This ensures removeTrailingMargin can correctly identify the LAST element's
+  // margin value. Without a span on the last element, it would pick up a previous
+  // element's span (e.g. blockquote with marginBottom: 16) and use that wrong value.
+  builder.setSpan(
+    MarginBottomSpan(marginBottom),
+    spacerStart,
+    builder.length,
+    SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+  )
+}

package/android/src/main/java/com/renderrichtext/utils/text/span/SpanFlags.kt

@@ -0,0 +1,43 @@
+package com.renderrichtext.utils.text.span
+
+import android.text.SpannableString
+import android.text.Spanned
+
+const val SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE = SpannableString.SPAN_EXCLUSIVE_EXCLUSIVE
+
+/**
+ * `SPAN_EXCLUSIVE_EXCLUSIVE` with the maximum span priority.
+ *
+ * Higher-priority spans are iterated — and therefore applied and drawn — first,
+ * so lower-priority spans over the same range override them. Use this for a
+ * block span set after its children that must not override the inline spans
+ * inside it (e.g. [HeadingSpan]), or for a container background that must sit
+ * under inline pill/chip backgrounds (e.g. [BlockquoteSpan]).
+ */
+const val SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE_PRIORITY =
+  Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or Spanned.SPAN_PRIORITY
+
+/**
+ * `SPAN_EXCLUSIVE_EXCLUSIVE` with the maximum span priority, for a block-wide
+ * LineHeightSpan (e.g. a blockquote's uniform line height) that must be iterated
+ * BEFORE the per-block [MarginBottomSpan]s it overlaps. LineHeightSpans are
+ * applied in iteration order and higher priority iterates first, so this span
+ * sets the base line height and the lower-priority margin span then adds its gap
+ * on top instead of being normalized away. Without it a line-height pass applied
+ * after the margins (e.g. in BlockquoteTextRenderer.postProcess) would erase them
+ * and clip the first line's ascent.
+ */
+const val SPAN_FLAGS_LINE_HEIGHT_PRIORITY =
+  Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or Spanned.SPAN_PRIORITY
+
+/**
+ * `SPAN_EXCLUSIVE_EXCLUSIVE` with a span priority just above the default.
+ *
+ * List item spans are set after the item's children, so at the default
+ * priority they apply after inline spans such as `CodeSpan` and replace their
+ * font and size. This priority applies them first, while staying below
+ * [SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE_PRIORITY] so a blockquote still draws its
+ * leading margin before a list's.
+ */
+const val SPAN_FLAGS_LIST_ITEM =
+  Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or (1 shl Spanned.SPAN_PRIORITY_SHIFT)

package/android/src/main/java/com/renderrichtext/utils/text/span/WidthAwareSpans.kt

@@ -0,0 +1,30 @@
+package com.renderrichtext.utils.text.span
+
+import android.text.Spanned
+import com.renderrichtext.spans.ImageSpan
+import com.renderrichtext.spans.LinkPillSpan
+
+/**
+ * Primes every span whose size depends on the layout width (pills, images). Call it
+ * before building any layout over [text]. [includeImages] is off for a visible text
+ * view, whose image spans size themselves from the view they are registered with.
+ *
+ * Returns true when a pill's width limit changed, i.e. an existing layout is stale.
+ */
+fun prepareWidthAwareSpans(
+  text: CharSequence?,
+  widthPx: Int,
+  includeImages: Boolean = true,
+): Boolean {
+  val spanned = text as? Spanned ?: return false
+  // widthPx == 1 is the coerceAtLeast(1) fallback for a not-yet-measured view. Priming
+  // with it would squeeze pills on screen to a sliver until the next real measure.
+  if (widthPx <= 1) return false
+  val pillsChanged = LinkPillSpan.prepareForMeasurement(spanned, widthPx)
+  if (includeImages) {
+    spanned
+      .getSpans(0, spanned.length, ImageSpan::class.java)
+      .forEach { it.prepareForMeasurement(spanned, widthPx) }
+  }
+  return pillsChanged
+}

package/android/src/main/java/com/renderrichtext/utils/text/view/CodeBlockPressHost.kt

@@ -0,0 +1,15 @@
+package com.renderrichtext.utils.text.view
+
+/**
+ * Implemented by the commonmark host view so [LinkLongPressMovementMethod] can
+ * gate and dispatch taps landing on a code block span. GFM uses a separate
+ * CodeBlockContainerView, so its host walk resolves to none.
+ */
+interface CodeBlockPressHost {
+  val codeBlockPressEnabled: Boolean
+
+  fun emitOnCodeBlockPress(
+    code: String,
+    language: String,
+  )
+}

package/android/src/main/java/com/renderrichtext/utils/text/view/ImagePressHost.kt

@@ -0,0 +1,19 @@
+package com.renderrichtext.utils.text.view
+
+/**
+ * Implemented by the React-tagged host views (EnrichedTiptapText and the GFM
+ * EnrichedTiptap container) so [LinkLongPressMovementMethod] can gate and
+ * dispatch image taps without knowing which flavor owns the tapped TextView.
+ *
+ * In GFM the tapped TextView is an internal segment child, so the movement
+ * method walks up to the nearest host - the same routing ImageSpan uses for its
+ * box-height notifications.
+ */
+interface ImagePressHost {
+  val imagePressEnabled: Boolean
+
+  fun emitOnImagePress(
+    url: String,
+    altText: String,
+  )
+}

package/android/src/main/java/com/renderrichtext/utils/text/view/LinkEvents.kt

@@ -0,0 +1,88 @@
+package com.renderrichtext.utils.text.view
+
+import android.view.MotionEvent
+import android.view.View
+import android.widget.TextView
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.NativeGestureUtil
+import com.renderrichtext.events.FactoidPressEvent
+import com.renderrichtext.events.ImagePressEvent
+import com.renderrichtext.events.LinkLongPressEvent
+import com.renderrichtext.events.LinkPressEvent
+import com.renderrichtext.events.MentionLongPressEvent
+import com.renderrichtext.events.MentionPressEvent
+
+fun View.emitMentionPressEvent(
+  mentionId: String,
+  label: String,
+) {
+  val reactContext = context as? ReactContext ?: return
+  val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+  val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+  dispatcher?.dispatchEvent(MentionPressEvent(surfaceId, id, mentionId, label))
+}
+
+fun View.emitMentionLongPressEvent(
+  mentionId: String,
+  label: String,
+) {
+  val reactContext = context as? ReactContext ?: return
+  val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+  val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+  dispatcher?.dispatchEvent(MentionLongPressEvent(surfaceId, id, mentionId, label))
+}
+
+fun View.emitFactoidPressEvent(factoidId: String) {
+  val reactContext = context as? ReactContext ?: return
+  val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+  val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+  dispatcher?.dispatchEvent(FactoidPressEvent(surfaceId, id, factoidId))
+}
+
+fun View.emitLinkPressEvent(url: String) {
+  val reactContext = context as? ReactContext ?: return
+  val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+  val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+  dispatcher?.dispatchEvent(LinkPressEvent(surfaceId, id, url))
+}
+
+fun View.emitImagePressEvent(
+  url: String,
+  altText: String,
+) {
+  val reactContext = context as? ReactContext ?: return
+  val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+  val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+  dispatcher?.dispatchEvent(ImagePressEvent(surfaceId, id, url, altText))
+}
+
+fun View.emitLinkLongPressEvent(url: String) {
+  val reactContext = context as? ReactContext ?: return
+  val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+  val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+  dispatcher?.dispatchEvent(LinkLongPressEvent(surfaceId, id, url))
+}
+
+/**
+ * Cancels the JS touch for an active link tap, preventing parent
+ * Pressable/TouchableOpacity from firing onPress for the same tap.
+ *
+ * Parent intercept is handled by [LinkLongPressMovementMethod], which
+ * disallows it for the press and releases it when the press ends.
+ */
+fun TextView.cancelJSTouchForLinkTap(event: MotionEvent) {
+  val currentMovementMethod = movementMethod
+  if (currentMovementMethod is LinkLongPressMovementMethod && currentMovementMethod.isLinkTouchActive) {
+    NativeGestureUtil.notifyNativeGestureStarted(this, event)
+  }
+}
+
+/**
+ * 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)
+}