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

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

@@ -0,0 +1,449 @@
+package com.renderrichtext.utils.text.view
+
+import android.os.Handler
+import android.os.Looper
+import android.text.Spannable
+import android.text.method.ArrowKeyMovementMethod
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewConfiguration
+import android.view.ViewParent
+import android.widget.TextView
+import com.renderrichtext.spans.CodeBlockSpan
+import com.renderrichtext.spans.FactoidSpan
+import com.renderrichtext.spans.ImageSpan
+import com.renderrichtext.spans.LinkSpan
+import com.renderrichtext.spans.MentionChipSpan
+import com.renderrichtext.spans.MentionSpan
+import com.renderrichtext.spans.SpoilerSpan
+import com.renderrichtext.spoiler.SpoilerCapable
+import kotlin.math.abs
+
+/**
+ * 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.
+ */
+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
+  private var pressedImage: ImageSpan? = null
+  private var pressedFactoid: FactoidSpan? = null
+  private var pressedMention: MentionSpan? = null
+  private var pressedCodeBlock: CodeBlockSpan? = null
+
+  var isLinkTouchActive: Boolean = false
+    private set
+  private var isTouchWithinTextBounds: Boolean = true
+  private var disallowsParentIntercept = false
+
+  override fun onTouchEvent(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): Boolean {
+    when (event.action) {
+      MotionEvent.ACTION_DOWN -> {
+        startX = event.x
+        startY = event.y
+
+        pressedLink = findLinkSpan(widget, buffer, event)
+        pressedImage =
+          if (pressedLink == null && imagePressHost(widget)?.imagePressEnabled == true) {
+            findImageSpan(widget, buffer, event)
+          } else {
+            null
+          }
+        pressedFactoid =
+          if (pressedLink == null && pressedImage == null) {
+            findFactoidSpan(widget, buffer, event)
+          } else {
+            null
+          }
+        pressedMention =
+          if (pressedLink == null && pressedImage == null && pressedFactoid == null) {
+            findMentionSpan(widget, buffer, event)
+          } else {
+            null
+          }
+        pressedCodeBlock =
+          if (pressedLink == null &&
+            pressedImage == null &&
+            pressedFactoid == null &&
+            pressedMention == null &&
+            // Skip while text is selected so the tap clears the selection
+            // instead of firing the press (matches the web guard).
+            !widget.hasSelection() &&
+            codeBlockPressHost(widget)?.codeBlockPressEnabled == true
+          ) {
+            findCodeBlockSpan(widget, buffer, event)
+          } else {
+            null
+          }
+        isLinkTouchActive =
+          pressedLink != null || pressedImage != null || pressedFactoid != null ||
+            pressedMention != null || pressedCodeBlock != null
+        setFactoidPressed(widget, pressedFactoid, pressed = true)
+        setMentionPressed(widget, pressedMention, pressed = true)
+        pressedLink?.let { scheduleLongPress(widget, it) }
+        pressedMention?.let { scheduleMentionLongPress(widget, it) }
+        // Keeps RNGH Pressable and scrolling parents from stealing the press before ACTION_UP.
+        disallowsParentIntercept = isLinkTouchActive
+        if (isLinkTouchActive) widget.parent?.requestDisallowInterceptTouchEvent(true)
+      }
+
+      MotionEvent.ACTION_MOVE -> {
+        val config = ViewConfiguration.get(widget.context)
+        if (abs(event.x - startX) > config.scaledTouchSlop ||
+          abs(event.y - startY) > config.scaledTouchSlop
+        ) {
+          cancelLongPress()
+          isLinkTouchActive = false
+          setFactoidPressed(widget, pressedFactoid, pressed = false)
+          setMentionPressed(widget, pressedMention, pressed = false)
+          pressedLink = null
+          pressedImage = null
+          pressedFactoid = null
+          pressedMention = null
+          pressedCodeBlock = null
+          releaseParentIntercept(widget)
+        } else if (pressedFactoid != null) {
+          setFactoidPressed(widget, pressedFactoid, findFactoidSpan(widget, buffer, event) === pressedFactoid)
+        } else if (pressedMention != null) {
+          setMentionPressed(widget, pressedMention, findMentionSpan(widget, buffer, event) === pressedMention)
+        }
+      }
+
+      MotionEvent.ACTION_UP -> {
+        cancelLongPress()
+        val tappedLink = pressedLink
+        val tappedImage = pressedImage
+        val tappedFactoid = pressedFactoid
+        val tappedMention = pressedMention
+        val tappedCodeBlock = pressedCodeBlock
+        isLinkTouchActive = false
+        setFactoidPressed(widget, tappedFactoid, pressed = false)
+        setMentionPressed(widget, tappedMention, pressed = false)
+        pressedLink = null
+        pressedImage = null
+        pressedFactoid = null
+        pressedMention = null
+        pressedCodeBlock = null
+        releaseParentIntercept(widget)
+
+        if (handleSpoilerTap(widget, buffer, event)) {
+          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
+        }
+
+        if (tappedImage != null && findImageSpan(widget, buffer, event) === tappedImage) {
+          imagePressHost(widget)?.emitOnImagePress(tappedImage.imageUrl, tappedImage.altText)
+          return true
+        }
+
+        if (tappedFactoid != null && findFactoidSpan(widget, buffer, event) === tappedFactoid) {
+          tappedFactoid.onClick(widget)
+          return true
+        }
+
+        if (tappedMention != null && findMentionSpan(widget, buffer, event) === tappedMention) {
+          tappedMention.onClick(widget)
+          return true
+        }
+
+        if (tappedCodeBlock != null && findCodeBlockSpan(widget, buffer, event) === tappedCodeBlock) {
+          codeBlockPressHost(widget)?.emitOnCodeBlockPress(tappedCodeBlock.code, tappedCodeBlock.language)
+          return true
+        }
+      }
+
+      MotionEvent.ACTION_CANCEL -> {
+        cancelLongPress()
+        isLinkTouchActive = false
+        setFactoidPressed(widget, pressedFactoid, pressed = false)
+        setMentionPressed(widget, pressedMention, pressed = false)
+        pressedLink = null
+        pressedImage = null
+        pressedCodeBlock = null
+        pressedFactoid = null
+        pressedMention = null
+        releaseParentIntercept(widget)
+      }
+    }
+
+    // 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 super.onTouchEvent(widget, buffer, event)
+  }
+
+  private fun setFactoidPressed(
+    widget: TextView,
+    span: FactoidSpan?,
+    pressed: Boolean,
+  ) {
+    if (span == null || span.pressed == pressed) return
+    span.pressed = pressed
+    widget.invalidate()
+  }
+
+  private fun setMentionPressed(
+    widget: TextView,
+    span: MentionSpan?,
+    pressed: Boolean,
+  ) {
+    if (span == null || span.pressed == pressed) return
+    span.pressed = pressed
+    val text = widget.text as? Spannable
+    val start = text?.getSpanStart(span) ?: -1
+    val end = if (text != null && start >= 0) text.getSpanEnd(span) else -1
+    val chip =
+      if (text != null && end > start) {
+        text.getSpans(start, end, MentionChipSpan::class.java).firstOrNull { candidate ->
+          text.getSpanStart(candidate) == start && text.getSpanEnd(candidate) == end
+        }
+      } else {
+        null
+      }
+    // A factoid fill is a line background, so invalidate() draws it again. The mention
+    // is a replacement run, and a selectable TextView keeps that run in a display list
+    // that invalidate() does not rebuild. Re-setting the chip records the darker fill.
+    if (text != null && chip != null) {
+      chip.pressed = pressed
+      text.setSpan(chip, start, end, text.getSpanFlags(chip))
+    } else {
+      widget.invalidate()
+    }
+  }
+
+  private fun scheduleLongPress(
+    widget: TextView,
+    span: LinkSpan,
+  ) {
+    cancelLongPress()
+    // The view's own long-press races the runnable below; cancel it so only the link fires.
+    widget.cancelLongPress()
+
+    longPressRunnable =
+      Runnable {
+        // 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)
+          widget.cancelLongPress()
+        }
+        longPressRunnable = null
+      }.also {
+        handler.postDelayed(it, ViewConfiguration.getLongPressTimeout().toLong())
+      }
+  }
+
+  private fun scheduleMentionLongPress(
+    widget: TextView,
+    span: MentionSpan,
+  ) {
+    cancelLongPress()
+    widget.cancelLongPress()
+
+    longPressRunnable =
+      Runnable {
+        if (span.onLongClick(widget)) {
+          widget.cancelLongPress()
+        }
+        longPressRunnable = null
+      }.also {
+        handler.postDelayed(it, ViewConfiguration.getLongPressTimeout().toLong())
+      }
+  }
+
+  private fun cancelLongPress() {
+    longPressRunnable?.let(handler::removeCallbacks)
+    longPressRunnable = null
+  }
+
+  // Undo only our own request: a long-press drag selection relies on the Editor's
+  // request staying in place until ACTION_UP, or a scrolling parent steals the drag.
+  private fun releaseParentIntercept(widget: TextView) {
+    if (!disallowsParentIntercept) return
+    disallowsParentIntercept = false
+    widget.parent?.requestDisallowInterceptTouchEvent(false)
+  }
+
+  private fun charOffsetAt(
+    widget: TextView,
+    event: MotionEvent,
+  ): Int? {
+    val x = event.x - widget.totalPaddingLeft + widget.scrollX
+    val y = event.y - widget.totalPaddingTop + widget.scrollY
+    val layout = widget.layout ?: return null
+
+    // 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(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): LinkSpan? {
+    val offset = charOffsetAt(widget, event) ?: return null
+    return buffer.getSpans(offset, offset, LinkSpan::class.java).firstOrNull()
+  }
+
+  private fun findMentionSpan(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): MentionSpan? {
+    val offset = charOffsetAt(widget, event) ?: return null
+    return buffer
+      .getSpans(offset, offset, MentionSpan::class.java)
+      .minByOrNull { buffer.getSpanEnd(it) - buffer.getSpanStart(it) }
+  }
+
+  private fun findFactoidSpan(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): FactoidSpan? {
+    val offset = charOffsetAt(widget, event) ?: return null
+    return buffer
+      .getSpans(offset, offset, FactoidSpan::class.java)
+      .minByOrNull { buffer.getSpanEnd(it) - buffer.getSpanStart(it) }
+  }
+
+  private fun findImageSpan(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): ImageSpan? {
+    val offset = charOffsetAt(widget, event) ?: return null
+    return buffer.getSpans(offset, offset, ImageSpan::class.java).firstOrNull()
+  }
+
+  private fun imagePressHost(widget: View): ImagePressHost? {
+    if (widget is ImagePressHost) return widget
+    var parent: ViewParent? = widget.parent
+    while (parent != null && parent !is ImagePressHost) {
+      parent = parent.parent
+    }
+    return parent as? ImagePressHost
+  }
+
+  // A code block is a whole-line box, so this matches a tap anywhere on the line
+  // (ignoring x), unlike charOffsetAt which needs an exact glyph.
+  private fun findCodeBlockSpan(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): CodeBlockSpan? {
+    val layout = widget.layout ?: return null
+    val y = event.y - widget.totalPaddingTop + widget.scrollY
+    if (y < 0f || y > layout.height) return null
+    val line = layout.getLineForVertical(y.toInt())
+    val lineStart = layout.getLineStart(line)
+    val lineEnd = layout.getLineEnd(line)
+    return buffer.getSpans(lineStart, lineEnd, CodeBlockSpan::class.java).firstOrNull()
+  }
+
+  private fun codeBlockPressHost(widget: View): CodeBlockPressHost? {
+    if (widget is CodeBlockPressHost) return widget
+    var parent: ViewParent? = widget.parent
+    while (parent != null && parent !is CodeBlockPressHost) {
+      parent = parent.parent
+    }
+    return parent as? CodeBlockPressHost
+  }
+
+  private fun handleSpoilerTap(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): Boolean {
+    val offset = charOffsetAt(widget, event) ?: return false
+    val tappedSpan =
+      buffer
+        .getSpans(offset, offset, SpoilerSpan::class.java)
+        .firstOrNull { !it.revealed && !it.revealing } ?: return false
+
+    val drawer = (widget as? SpoilerCapable)?.spoilerOverlayDrawer ?: return false
+    val spans = expandContiguousSpoilers(buffer, tappedSpan)
+    val remaining = intArrayOf(spans.size)
+
+    for (span in spans) {
+      drawer.revealSpan(span) {
+        remaining[0]--
+        if (remaining[0] <= 0) widget.invalidate()
+      }
+    }
+    widget.invalidate()
+    return true
+  }
+
+  private fun expandContiguousSpoilers(
+    buffer: Spannable,
+    seed: SpoilerSpan,
+  ): List<SpoilerSpan> {
+    val allSpans = buffer.getSpans(0, buffer.length, SpoilerSpan::class.java)
+    if (allSpans.size <= 1) return listOf(seed)
+
+    val result = mutableSetOf(seed)
+    var rangeStart = buffer.getSpanStart(seed)
+    var rangeEnd = buffer.getSpanEnd(seed)
+    var changed = true
+    while (changed) {
+      changed = false
+      for (span in allSpans) {
+        if (span in result) continue
+        val spanStart = buffer.getSpanStart(span)
+        val spanEnd = buffer.getSpanEnd(span)
+        if (spanEnd >= rangeStart && spanStart <= rangeEnd) {
+          result.add(span)
+          if (spanStart < rangeStart) rangeStart = spanStart
+          if (spanEnd > rangeEnd) rangeEnd = spanEnd
+          changed = true
+        }
+      }
+    }
+    return result.sortedBy { buffer.getSpanStart(it) }
+  }
+
+  companion object {
+    @JvmStatic
+    fun createInstance(): LinkLongPressMovementMethod = LinkLongPressMovementMethod()
+  }
+}

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

@@ -0,0 +1,235 @@
+package com.renderrichtext.utils.text.view
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.text.Spannable
+import android.view.ActionMode
+import android.view.Menu
+import android.view.MenuItem
+import android.view.ViewParent
+import android.widget.TextView
+import com.renderrichtext.EnrichedTiptapText
+import com.renderrichtext.spans.ImageSpan
+import com.renderrichtext.spans.stripFactoidPadding
+import com.renderrichtext.styles.StyleConfig
+import com.renderrichtext.utils.common.layout.isLayoutRTL
+import com.renderrichtext.utils.text.conversion.HTMLGenerator
+import com.renderrichtext.utils.text.conversion.TiptapExtractor
+
+private const val MENU_ITEM_COPY_TIPTAP = 1000
+private const val MENU_ITEM_COPY_IMAGE_URL = 1001
+private const val MENU_ITEM_CUSTOM_BASE = 2000
+private const val MENU_ITEM_CUSTOM_GROUP = 2001
+
+data class SelectionMenuConfig(
+  val copyAsTiptap: Boolean = true,
+  val copyImageUrl: Boolean = true,
+  val copyLabel: String = "",
+  val copyAsTiptapLabel: String = "",
+  val copyImageUrlLabel: String = "",
+  val copyImageUrlsLabel: String = "",
+  // 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(),
+)
+
+/**
+ * Resolves the "Copy Image URL(s)" menu title for the given image count. Uses the
+ * precomputed plural templates when present (counts > 100 use the "other" form),
+ * otherwise the singular/`{count}` templates. All labels are resolved JS-side.
+ */
+private fun SelectionMenuConfig.imageUrlsTitle(count: Int): String {
+  val template =
+    when {
+      copyImageUrlPluralTemplates.isNotEmpty() && count in 0..100 -> copyImageUrlPluralTemplates[count]
+      count == 1 -> copyImageUrlLabel
+      else -> copyImageUrlsLabel
+    }
+  return template.replace("{count}", count.toString())
+}
+
+/**
+ * Creates an ActionMode.Callback that adds custom copy options and
+ * overrides the default "Copy" action to include HTML for rich text support.
+ */
+fun createSelectionActionModeCallback(
+  textView: TextView,
+  getCustomItemTexts: () -> List<String> = { emptyList() },
+  getSelectionMenuConfig: () -> SelectionMenuConfig = { SelectionMenuConfig() },
+  onCustomItemPress: (itemText: String, selectedText: String, selectionStart: Int, selectionEnd: Int) -> Unit =
+    { _, _, _, _ -> },
+): ActionMode.Callback =
+  object : ActionMode.Callback {
+    override fun onCreateActionMode(
+      mode: ActionMode?,
+      menu: Menu?,
+    ): Boolean = true
+
+    override fun onPrepareActionMode(
+      mode: ActionMode?,
+      menu: Menu?,
+    ): Boolean {
+      if (menu == null) return false
+
+      menu.removeItem(MENU_ITEM_COPY_TIPTAP)
+      menu.removeItem(MENU_ITEM_COPY_IMAGE_URL)
+      menu.removeGroup(MENU_ITEM_CUSTOM_GROUP)
+
+      val selectionMenuConfig = getSelectionMenuConfig()
+
+      // 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()) {
+        menu.findItem(android.R.id.copy)?.title = selectionMenuConfig.copyLabel
+      }
+
+      if (
+        selectionMenuConfig.copyAsTiptap &&
+        textView.selectionStart >= 0 &&
+        textView.selectionEnd > textView.selectionStart
+      ) {
+        menu.add(
+          Menu.NONE,
+          MENU_ITEM_COPY_TIPTAP,
+          Menu.NONE,
+          selectionMenuConfig.copyAsTiptapLabel,
+        )
+      }
+
+      if (textView.selectionStart >= 0 && textView.selectionEnd > textView.selectionStart) {
+        val customItems = getCustomItemTexts()
+        customItems.forEachIndexed { index, text ->
+          menu
+            .add(MENU_ITEM_CUSTOM_GROUP, MENU_ITEM_CUSTOM_BASE + index, index, text)
+            .setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
+        }
+      }
+
+      val imageUrls =
+        if (selectionMenuConfig.copyImageUrl) {
+          textView.getImageUrlsInSelection()
+        } else {
+          emptyList()
+        }
+      if (imageUrls.isNotEmpty()) {
+        val title = selectionMenuConfig.imageUrlsTitle(imageUrls.size)
+        menu.add(Menu.NONE, MENU_ITEM_COPY_IMAGE_URL, Menu.NONE, title)
+      }
+
+      return true
+    }
+
+    override fun onActionItemClicked(
+      mode: ActionMode?,
+      item: MenuItem?,
+    ): Boolean {
+      val itemId = item?.itemId ?: return false
+
+      when (itemId) {
+        android.R.id.copy -> {
+          textView.copyWithHTML()
+          mode?.finish()
+          return true
+        }
+
+        MENU_ITEM_COPY_TIPTAP -> {
+          textView.copyTiptapToClipboard()
+          mode?.finish()
+          return true
+        }
+
+        MENU_ITEM_COPY_IMAGE_URL -> {
+          textView.copyImageUrlsToClipboard()
+          mode?.finish()
+          return true
+        }
+      }
+
+      val customItems = getCustomItemTexts()
+      val customIndex = itemId - MENU_ITEM_CUSTOM_BASE
+      if (customIndex in customItems.indices) {
+        val start = textView.selectionStart
+        val end = textView.selectionEnd
+        val selectedText =
+          if (start >= 0 && end > start) textView.text.subSequence(start, end).stripFactoidPadding() else ""
+        onCustomItemPress(customItems[customIndex], selectedText, start, end)
+        mode?.finish()
+        return true
+      }
+
+      return false
+    }
+
+    override fun onDestroyActionMode(mode: ActionMode?) {}
+  }
+
+/** Copies selection as both plain text and HTML with inline styles. */
+private fun TextView.copyWithHTML() {
+  val start = selectionStart
+  val end = selectionEnd
+  if (start < 0 || end < 0 || start >= end) return
+
+  val spannable = text as? Spannable ?: return
+  val selectedText = spannable.subSequence(start, end)
+  val plainText = selectedText.stripFactoidPadding()
+
+  val styleConfig =
+    (this as? EnrichedTiptapText)?.tiptapStyle
+      ?: findParentTiptapStyle()
+  val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+
+  if (styleConfig != null && selectedText is Spannable) {
+    // Density values convert device pixels back to CSS pixels
+    val displayMetrics = context.resources.displayMetrics
+    val isRTL = context.resources.isLayoutRTL()
+    val html =
+      HTMLGenerator.generateHTML(
+        selectedText,
+        styleConfig,
+        displayMetrics.scaledDensity,
+        displayMetrics.density,
+        isRTL,
+      )
+    clipboard.setPrimaryClip(ClipData.newHtmlText("EnrichedTiptap", plainText, html))
+  } else {
+    clipboard.setPrimaryClip(ClipData.newPlainText("Text", plainText))
+  }
+}
+
+private fun TextView.copyTiptapToClipboard() {
+  val tiptap = TiptapExtractor.getTiptapForSelection(this) ?: return
+  val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+  clipboard.setPrimaryClip(ClipData.newPlainText("Tiptap", tiptap))
+}
+
+/** Returns remote image URLs (http/https only) from the current selection. */
+private fun TextView.getImageUrlsInSelection(): List<String> {
+  val start = selectionStart
+  val end = selectionEnd
+  if (start < 0 || end < 0 || start >= end) return emptyList()
+
+  val spannable = text as? Spannable ?: return emptyList()
+  return spannable
+    .getSpans(start, end, ImageSpan::class.java)
+    .mapNotNull { it.imageUrl }
+    .filter { it.startsWith("http://") || it.startsWith("https://") }
+}
+
+private fun TextView.copyImageUrlsToClipboard() {
+  val urls = getImageUrlsInSelection()
+  if (urls.isEmpty()) return
+
+  val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+  clipboard.setPrimaryClip(ClipData.newPlainText("Image URLs", urls.joinToString("\n")))
+}
+
+private fun TextView.findParentTiptapStyle(): StyleConfig? {
+  var current: ViewParent? = parent
+  while (current != null) {
+    if (current is EnrichedTiptapText) return current.tiptapStyle
+    current = current.parent
+  }
+  return null
+}