react-native-enriched-markdown 0.1.0 → 0.2.0

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

@@ -0,0 +1,121 @@
+package com.swmansion.enriched.markdown.utils
+
+import android.os.Handler
+import android.os.Looper
+import android.text.Selection
+import android.text.Spannable
+import android.text.method.LinkMovementMethod
+import android.view.MotionEvent
+import android.view.ViewConfiguration
+import android.widget.TextView
+import com.swmansion.enriched.markdown.spans.LinkSpan
+import kotlin.math.abs
+
+/**
+ * Custom MovementMethod that handles both link clicks and long presses.
+ * Extends LinkMovementMethod to maintain click functionality while adding long press support.
+ */
+class LinkLongPressMovementMethod : LinkMovementMethod() {
+  private val handler = Handler(Looper.getMainLooper())
+  private var longPressRunnable: Runnable? = null
+
+  private var startX = 0f
+  private var startY = 0f
+
+  override fun onTouchEvent(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): Boolean {
+    when (event.action) {
+      MotionEvent.ACTION_DOWN -> {
+        startX = event.x
+        startY = event.y
+
+        // Identify if a LinkSpan exists at the touch coordinates
+        findLinkSpan(widget, buffer, event)?.let { span ->
+          scheduleLongPress(widget, span)
+        }
+      }
+
+      MotionEvent.ACTION_MOVE -> {
+        val config = ViewConfiguration.get(widget.context)
+        // Cancel if the finger moves beyond the standard system touch slop
+        if (abs(event.x - startX) > config.scaledTouchSlop ||
+          abs(event.y - startY) > config.scaledTouchSlop
+        ) {
+          cancelLongPress()
+        }
+      }
+
+      MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+        cancelLongPress()
+        // Clear text selection to prevent the "stuck" highlight look
+        if (widget.hasSelection()) {
+          Selection.removeSelection(buffer)
+        }
+      }
+    }
+
+    // Let the parent LinkMovementMethod handle the standard click logic
+    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)
+    }
+
+    return result
+  }
+
+  private fun scheduleLongPress(
+    widget: TextView,
+    span: LinkSpan,
+  ) {
+    cancelLongPress()
+
+    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)
+          widget.cancelLongPress()
+        }
+        longPressRunnable = null
+      }.also {
+        handler.postDelayed(it, ViewConfiguration.getLongPressTimeout().toLong())
+      }
+  }
+
+  private fun cancelLongPress() {
+    longPressRunnable?.let(handler::removeCallbacks)
+    longPressRunnable = null
+  }
+
+  private fun findLinkSpan(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): LinkSpan? {
+    // Adjust coordinates for padding and scroll
+    val x = event.x.toInt() - widget.totalPaddingLeft + widget.scrollX
+    val y = event.y.toInt() - widget.totalPaddingTop + widget.scrollY
+
+    val layout = widget.layout ?: return null
+    val line = layout.getLineForVertical(y)
+    val offset = layout.getOffsetForHorizontal(line, x.toFloat())
+
+    // Ensure the touch is within the character bounds
+    return buffer.getSpans(offset, offset, LinkSpan::class.java).firstOrNull()
+  }
+
+  companion object {
+    @JvmStatic
+    fun createInstance(): LinkLongPressMovementMethod = LinkLongPressMovementMethod()
+  }
+}

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

@@ -0,0 +1,375 @@
+package com.swmansion.enriched.markdown.utils
+
+import android.text.Spannable
+import android.text.style.UnderlineSpan
+import android.widget.TextView
+import com.swmansion.enriched.markdown.EnrichedMarkdownText
+import com.swmansion.enriched.markdown.spans.BlockquoteSpan
+import com.swmansion.enriched.markdown.spans.CodeBlockSpan
+import com.swmansion.enriched.markdown.spans.CodeSpan
+import com.swmansion.enriched.markdown.spans.EmphasisSpan
+import com.swmansion.enriched.markdown.spans.HeadingSpan
+import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.LinkSpan
+import com.swmansion.enriched.markdown.spans.OrderedListSpan
+import com.swmansion.enriched.markdown.spans.StrikethroughSpan
+import com.swmansion.enriched.markdown.spans.StrongSpan
+import com.swmansion.enriched.markdown.spans.ThematicBreakSpan
+import com.swmansion.enriched.markdown.spans.UnorderedListSpan
+
+/** Extracts markdown from styled text (Spannable). */
+object MarkdownExtractor {
+  /**
+   * Gets markdown for the current text selection.
+   * Full selection returns original markdown, partial reconstructs from spans.
+   */
+  fun getMarkdownForSelection(textView: TextView): String? {
+    val start = textView.selectionStart
+    val end = textView.selectionEnd
+    if (start < 0 || end < 0 || start >= end) return null
+
+    val spannable = textView.text as? Spannable ?: return null
+
+    val isFullSelection = start == 0 && end >= textView.text.length - 1
+    if (isFullSelection && textView is EnrichedMarkdownText) {
+      val original = textView.currentMarkdown
+      if (original.isNotEmpty()) return original
+    }
+
+    return extractFromSpannable(spannable, start, end)
+  }
+
+  /** Extracts markdown from a Spannable within a given range. */
+  fun extractFromSpannable(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+  ): String {
+    val result = StringBuilder()
+    val state = ExtractionState()
+    val headingAccumulator = HeadingAccumulator()
+
+    var i = start
+    while (i < end) {
+      val nextTransition = spannable.nextSpanTransition(i, end, Any::class.java)
+      val segmentText = spannable.subSequence(i, nextTransition).toString()
+
+      val handled =
+        processSegment(
+          spannable = spannable,
+          segmentText = segmentText,
+          segmentStart = i,
+          segmentEnd = nextTransition,
+          result = result,
+          state = state,
+          headingAccumulator = headingAccumulator,
+        )
+
+      if (!handled) {
+        // Regular text segment - apply inline formatting and block prefixes
+        appendFormattedSegment(spannable, segmentText, i, nextTransition, result, state)
+      }
+
+      i = nextTransition
+    }
+
+    headingAccumulator.flush(result, state)
+    return result.toString()
+  }
+
+  /** Returns true if segment was handled specially. */
+  private fun processSegment(
+    spannable: Spannable,
+    segmentText: String,
+    segmentStart: Int,
+    segmentEnd: Int,
+    result: StringBuilder,
+    state: ExtractionState,
+    headingAccumulator: HeadingAccumulator,
+  ): Boolean {
+    // Check for thematic breaks first (uses " \n" as placeholder)
+    val thematicBreakSpans = spannable.getSpans(segmentStart, segmentEnd, ThematicBreakSpan::class.java)
+    if (thematicBreakSpans.isNotEmpty()) {
+      appendThematicBreak(result, state)
+      return true
+    }
+
+    if (segmentText == "\uFFFC" || segmentText == "\u200B") {
+      val imageSpans = spannable.getSpans(segmentStart, segmentEnd, ImageSpan::class.java)
+      if (imageSpans.isNotEmpty()) {
+        appendImage(imageSpans[0], result, state)
+        return true
+      }
+    }
+
+    if (segmentText.isEmpty()) return true
+
+    if (segmentText == "\n" || segmentText == "\n\n") {
+      handleNewline(spannable, segmentStart, segmentEnd, result, state)
+      return true
+    }
+
+    val headingSpans = spannable.getSpans(segmentStart, segmentEnd, HeadingSpan::class.java)
+    if (headingSpans.isNotEmpty()) {
+      headingAccumulator.accumulate(headingSpans[0].level, segmentText, result, state)
+      return true
+    } else {
+      headingAccumulator.flush(result, state)
+    }
+
+    val codeBlockSpans = spannable.getSpans(segmentStart, segmentEnd, CodeBlockSpan::class.java)
+    if (codeBlockSpans.isNotEmpty()) {
+      appendCodeBlock(segmentText, result, state)
+      return true
+    }
+
+    return false
+  }
+
+  private fun appendFormattedSegment(
+    spannable: Spannable,
+    segmentText: String,
+    segmentStart: Int,
+    segmentEnd: Int,
+    result: StringBuilder,
+    state: ExtractionState,
+  ) {
+    val blockquotePrefix = detectBlockquote(spannable, segmentStart, segmentEnd, state)
+    val listPrefix = detectList(spannable, segmentStart, segmentEnd, state)
+    var segment = applyInlineFormatting(spannable, segmentText, segmentStart, segmentEnd)
+
+    if (result.isAtLineStart() && !segmentText.startsWith("\n")) {
+      segment = buildBlockPrefix(blockquotePrefix, listPrefix) + segment
+    }
+
+    if (state.needsBlankLine && result.isNotEmpty()) {
+      result.ensureBlankLine()
+      state.needsBlankLine = false
+    }
+
+    result.append(segment)
+  }
+
+  private fun appendImage(
+    img: ImageSpan,
+    result: StringBuilder,
+    state: ExtractionState,
+  ) {
+    if (img.isInline) {
+      result.append("![image](${img.imageUrl})")
+    } else {
+      result.ensureBlankLine()
+      result.append("![image](${img.imageUrl})\n")
+      state.needsBlankLine = true
+      state.blockquoteDepth = -1
+      state.listDepth = -1
+    }
+  }
+
+  private fun appendThematicBreak(
+    result: StringBuilder,
+    state: ExtractionState,
+  ) {
+    result.ensureBlankLine()
+    result.append("---\n")
+    state.needsBlankLine = true
+    state.blockquoteDepth = -1
+    state.listDepth = -1
+  }
+
+  private fun handleNewline(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+    result: StringBuilder,
+    state: ExtractionState,
+  ) {
+    val inBlockquote = spannable.getSpans(start, end, BlockquoteSpan::class.java).isNotEmpty()
+    val inList =
+      spannable.getSpans(start, end, OrderedListSpan::class.java).isNotEmpty() ||
+        spannable.getSpans(start, end, UnorderedListSpan::class.java).isNotEmpty()
+
+    when {
+      !inBlockquote && state.blockquoteDepth >= 0 -> {
+        result.ensureBlankLine()
+        state.blockquoteDepth = -1
+      }
+
+      !inList && state.listDepth >= 0 -> {
+        result.ensureBlankLine()
+        state.listDepth = -1
+      }
+
+      inBlockquote || inList -> {
+        if (!result.endsWith("\n")) result.append("\n")
+      }
+
+      else -> {
+        result.ensureBlankLine()
+      }
+    }
+  }
+
+  private fun appendCodeBlock(
+    text: String,
+    result: StringBuilder,
+    state: ExtractionState,
+  ) {
+    if (state.needsBlankLine) {
+      result.ensureBlankLine()
+      state.needsBlankLine = false
+    }
+
+    val needsFence = result.isEmpty() || result.endsWith("\n\n")
+    if (needsFence) result.append("```\n")
+
+    result.append(text)
+
+    if (text.endsWith("\n")) {
+      result.append("```\n")
+      state.needsBlankLine = true
+    }
+  }
+
+  private fun detectBlockquote(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+    state: ExtractionState,
+  ): String? {
+    val spans = spannable.getSpans(start, end, BlockquoteSpan::class.java)
+    val depth = spans.maxOfOrNull { it.depth } ?: -1
+
+    return if (depth >= 0) {
+      state.blockquoteDepth = depth
+      "> ".repeat(depth + 1)
+    } else {
+      if (state.blockquoteDepth >= 0) state.blockquoteDepth = -1
+      null
+    }
+  }
+
+  private fun detectList(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+    state: ExtractionState,
+  ): String? {
+    val orderedSpans = spannable.getSpans(start, end, OrderedListSpan::class.java)
+    val unorderedSpans = spannable.getSpans(start, end, UnorderedListSpan::class.java)
+
+    val orderedDepth = orderedSpans.maxOfOrNull { it.depth } ?: -1
+    val unorderedDepth = unorderedSpans.maxOfOrNull { it.depth } ?: -1
+    val depth = maxOf(orderedDepth, unorderedDepth)
+
+    return if (depth >= 0) {
+      state.listDepth = depth
+      val indent = "  ".repeat(depth)
+      if (orderedSpans.isNotEmpty()) {
+        "$indent${orderedSpans[0].itemNumber}. "
+      } else {
+        "$indent- "
+      }
+    } else {
+      if (state.listDepth >= 0) state.listDepth = -1
+      null
+    }
+  }
+
+  private fun applyInlineFormatting(
+    spannable: Spannable,
+    text: String,
+    start: Int,
+    end: Int,
+  ): String {
+    val hasStrong = spannable.getSpans(start, end, StrongSpan::class.java).isNotEmpty()
+    val hasEmphasis = spannable.getSpans(start, end, EmphasisSpan::class.java).isNotEmpty()
+    val hasCode = spannable.getSpans(start, end, CodeSpan::class.java).isNotEmpty()
+    val hasStrikethrough = spannable.getSpans(start, end, StrikethroughSpan::class.java).isNotEmpty()
+    val hasUnderline = spannable.getSpans(start, end, UnderlineSpan::class.java).isNotEmpty()
+    val linkSpans = spannable.getSpans(start, end, LinkSpan::class.java)
+
+    var result = text
+
+    // Innermost first
+    if (hasCode && linkSpans.isEmpty()) {
+      result = "`$result`"
+    }
+    if (hasStrikethrough) {
+      result = "~~$result~~"
+    }
+    if (hasUnderline && linkSpans.isEmpty()) {
+      result = "<u>$result</u>"
+    }
+    if (hasEmphasis) {
+      result = "*$result*"
+    }
+    if (hasStrong) {
+      result = "**$result**"
+    }
+    if (linkSpans.isNotEmpty()) {
+      result = "[$text](${linkSpans[0].url})"
+    }
+
+    return result
+  }
+
+  private fun buildBlockPrefix(
+    blockquotePrefix: String?,
+    listPrefix: String?,
+  ): String =
+    buildString {
+      blockquotePrefix?.let { append(it) }
+      listPrefix?.let { append(it) }
+    }
+
+  private data class ExtractionState(
+    var blockquoteDepth: Int = -1,
+    var listDepth: Int = -1,
+    var needsBlankLine: Boolean = false,
+  )
+
+  /** Accumulates heading content across multiple span segments. */
+  private class HeadingAccumulator {
+    private var level: Int? = null
+    private val content = StringBuilder()
+
+    fun accumulate(
+      newLevel: Int,
+      text: String,
+      result: StringBuilder,
+      state: ExtractionState,
+    ) {
+      if (level != newLevel) {
+        flush(result, state)
+        level = newLevel
+      }
+      content.append(text.trim('\n'))
+    }
+
+    fun flush(
+      result: StringBuilder,
+      state: ExtractionState,
+    ) {
+      val currentLevel = level ?: return
+      if (content.isEmpty()) return
+
+      result.ensureBlankLine()
+      result.append("#".repeat(currentLevel))
+      result.append(" ")
+      result.append(content.toString().trim())
+      result.append("\n")
+
+      level = null
+      content.clear()
+      state.needsBlankLine = true
+    }
+  }
+
+  private fun StringBuilder.ensureBlankLine() {
+    if (isEmpty() || endsWith("\n\n")) return
+    append(if (endsWith("\n")) "\n" else "\n\n")
+  }
+
+  private fun StringBuilder.isAtLineStart(): Boolean = isEmpty() || endsWith("\n")
+}

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

@@ -0,0 +1,139 @@
+package com.swmansion.enriched.markdown.utils
+
+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.widget.TextView
+import com.swmansion.enriched.markdown.EnrichedMarkdownText
+import com.swmansion.enriched.markdown.spans.ImageSpan
+
+private const val MENU_ITEM_COPY_MARKDOWN = 1000
+private const val MENU_ITEM_COPY_IMAGE_URL = 1001
+
+/**
+ * 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): 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_MARKDOWN)
+      menu.removeItem(MENU_ITEM_COPY_IMAGE_URL)
+
+      if (textView.selectionStart >= 0 && textView.selectionEnd > textView.selectionStart) {
+        menu.add(Menu.NONE, MENU_ITEM_COPY_MARKDOWN, Menu.NONE, "Copy as Markdown")
+      }
+
+      val imageUrls = textView.getImageUrlsInSelection()
+      if (imageUrls.isNotEmpty()) {
+        val title =
+          if (imageUrls.size == 1) {
+            "Copy Image URL"
+          } else {
+            "Copy ${imageUrls.size} Image URLs"
+          }
+        menu.add(Menu.NONE, MENU_ITEM_COPY_IMAGE_URL, Menu.NONE, title)
+      }
+
+      return true
+    }
+
+    override fun onActionItemClicked(
+      mode: ActionMode?,
+      item: MenuItem?,
+    ): Boolean {
+      when (item?.itemId) {
+        android.R.id.copy -> {
+          textView.copyWithHTML()
+          mode?.finish()
+          return true
+        }
+
+        MENU_ITEM_COPY_MARKDOWN -> {
+          textView.copyMarkdownToClipboard()
+          mode?.finish()
+          return true
+        }
+
+        MENU_ITEM_COPY_IMAGE_URL -> {
+          textView.copyImageUrlsToClipboard()
+          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.toString()
+
+  val enrichedMarkdownText = this as? EnrichedMarkdownText
+  val styleConfig = enrichedMarkdownText?.markdownStyle
+  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 html =
+      HTMLGenerator.generateHTML(
+        selectedText,
+        styleConfig,
+        displayMetrics.scaledDensity,
+        displayMetrics.density,
+      )
+    clipboard.setPrimaryClip(ClipData.newHtmlText("EnrichedMarkdown", plainText, html))
+  } else {
+    clipboard.setPrimaryClip(ClipData.newPlainText("Text", plainText))
+  }
+}
+
+private fun TextView.copyMarkdownToClipboard() {
+  val markdown = MarkdownExtractor.getMarkdownForSelection(this) ?: return
+  val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+  clipboard.setPrimaryClip(ClipData.newPlainText("Markdown", markdown))
+}
+
+/** 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")))
+}