react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/android/src/main/java/com/swmansion/enriched/markdown/input/autolink/AutoDetectedLinkSpan.kt

@@ -0,0 +1,29 @@
+package com.swmansion.enriched.markdown.input.autolink
+
+import android.text.TextPaint
+import android.text.style.CharacterStyle
+import android.text.style.ForegroundColorSpan
+import android.text.style.UnderlineSpan
+
+/**
+ * Visual spans for auto-detected links. These intentionally do NOT implement
+ * MarkdownSpan so they survive the diff-based removal in InputFormatter.applyFormatting.
+ */
+class AutoDetectedLinkColorSpan(
+  color: Int,
+) : ForegroundColorSpan(color)
+
+class AutoDetectedLinkUnderlineSpan : UnderlineSpan()
+
+/**
+ * Zero-width marker span that carries the matched URL and marks a range as
+ * auto-detected. Used to enumerate existing auto-link ranges without confusing
+ * them with manual MarkdownSpan link spans.
+ */
+class AutoDetectedLinkMarkerSpan(
+  val url: String,
+) : CharacterStyle() {
+  override fun updateDrawState(tp: TextPaint) {
+    // no-op — styling is handled by the color/underline spans
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/autolink/AutoLinkDetector.kt

@@ -0,0 +1,188 @@
+package com.swmansion.enriched.markdown.input.autolink
+
+import android.text.Spannable
+import com.swmansion.enriched.markdown.input.detection.TextDetector
+import com.swmansion.enriched.markdown.input.detection.WordResult
+import com.swmansion.enriched.markdown.input.formatting.FormattingStore
+import com.swmansion.enriched.markdown.input.model.FormattingRange
+import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
+import com.swmansion.enriched.markdown.input.model.StyleType
+import java.util.regex.Pattern
+
+typealias OnLinkDetectedCallback = (text: String, url: String, start: Int, end: Int) -> Unit
+
+class AutoLinkDetector(
+  private val formattingStore: FormattingStore,
+) : TextDetector {
+  private var config: LinkRegexConfig? = null
+  private var compiledPattern: Pattern? = null
+  var style: InputFormatterStyle? = null
+  var onLinkDetected: OnLinkDetectedCallback? = null
+
+  fun setRegexConfig(newConfig: LinkRegexConfig) {
+    if (newConfig == config) return
+    config = newConfig
+    compiledPattern = null
+
+    if (!newConfig.isDefault && !newConfig.isDisabled && newConfig.pattern.isNotEmpty()) {
+      var flags = 0
+      if (newConfig.caseInsensitive) flags = flags or Pattern.CASE_INSENSITIVE
+      if (newConfig.dotAll) flags = flags or Pattern.DOTALL
+      compiledPattern =
+        try {
+          Pattern.compile(newConfig.pattern, flags)
+        } catch (_: Exception) {
+          null
+        }
+    }
+  }
+
+  override fun processWord(
+    spannable: Spannable,
+    wordResult: WordResult,
+  ) {
+    val detectedUrl = detectNewLinkInWord(spannable, wordResult)
+    if (detectedUrl != null) {
+      onLinkDetected?.invoke(wordResult.word, detectedUrl, wordResult.start, wordResult.end)
+    }
+  }
+
+  override fun refreshStyling(spannable: Spannable) {
+    val currentStyle = style ?: return
+    val markers = spannable.getSpans(0, spannable.length, AutoDetectedLinkMarkerSpan::class.java)
+    for (marker in markers) {
+      val start = spannable.getSpanStart(marker)
+      val end = spannable.getSpanEnd(marker)
+      applyVisualStyling(spannable, start, end, currentStyle)
+    }
+  }
+
+  override fun transientFormattingRanges(spannable: Spannable): List<FormattingRange> {
+    val markers = spannable.getSpans(0, spannable.length, AutoDetectedLinkMarkerSpan::class.java)
+    return markers.map { marker ->
+      FormattingRange(
+        StyleType.LINK,
+        spannable.getSpanStart(marker),
+        spannable.getSpanEnd(marker),
+        marker.url,
+      )
+    }
+  }
+
+  fun clearAutoLinkInRange(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+  ) {
+    removeAutoLinkSpans(spannable, start, end)
+  }
+
+  private fun detectNewLinkInWord(
+    spannable: Spannable,
+    wordResult: WordResult,
+  ): String? {
+    if (config?.isDisabled == true) return null
+
+    val (word, wordStart, wordEnd) = wordResult
+
+    val hasManualLink = formattingStore.rangeOfType(StyleType.LINK, wordStart) != null
+    if (hasManualLink) {
+      removeAutoLinkSpans(spannable, wordStart, wordEnd)
+      return null
+    }
+
+    val matchedUrl = matchWord(word)
+    val existingMarker =
+      spannable
+        .getSpans(wordStart, wordEnd, AutoDetectedLinkMarkerSpan::class.java)
+        .firstOrNull { spannable.getSpanStart(it) == wordStart && spannable.getSpanEnd(it) == wordEnd }
+
+    if (matchedUrl != null) {
+      if (existingMarker?.url == matchedUrl) return null
+
+      removeAutoLinkSpans(spannable, wordStart, wordEnd)
+      spannable.setSpan(
+        AutoDetectedLinkMarkerSpan(matchedUrl),
+        wordStart,
+        wordEnd,
+        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE,
+      )
+      val currentStyle = style
+      if (currentStyle != null) {
+        applyVisualStyling(spannable, wordStart, wordEnd, currentStyle)
+      }
+      return matchedUrl
+    } else {
+      if (existingMarker != null) {
+        removeAutoLinkSpans(spannable, wordStart, wordEnd)
+      }
+      return null
+    }
+  }
+
+  private fun matchWord(word: String): String? {
+    if (word.isEmpty()) return null
+
+    val custom = compiledPattern
+    if (custom != null) {
+      return if (custom.matcher(word).matches()) normalizeUrl(word) else null
+    }
+
+    if (DEFAULT_PATTERN.matcher(word).matches()) return normalizeUrl(word)
+
+    return null
+  }
+
+  private fun removeAutoLinkSpans(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+  ) {
+    for (span in spannable.getSpans(start, end, AutoDetectedLinkMarkerSpan::class.java)) {
+      spannable.removeSpan(span)
+    }
+    for (span in spannable.getSpans(start, end, AutoDetectedLinkColorSpan::class.java)) {
+      spannable.removeSpan(span)
+    }
+    for (span in spannable.getSpans(start, end, AutoDetectedLinkUnderlineSpan::class.java)) {
+      spannable.removeSpan(span)
+    }
+  }
+
+  private fun applyVisualStyling(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+    style: InputFormatterStyle,
+  ) {
+    spannable.setSpan(
+      AutoDetectedLinkColorSpan(style.linkColor),
+      start,
+      end,
+      Spannable.SPAN_EXCLUSIVE_EXCLUSIVE,
+    )
+    if (style.linkUnderline) {
+      spannable.setSpan(
+        AutoDetectedLinkUnderlineSpan(),
+        start,
+        end,
+        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+
+  companion object {
+    private val DEFAULT_PATTERN: Pattern =
+      Pattern.compile(
+        "(?:https?://[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-z]{2,6}\\b[-a-zA-Z0-9@:%_+.~#?&//=]*" +
+          "|www\\.[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-z]{2,6}\\b[-a-zA-Z0-9@:%_+.~#?&//=]*" +
+          "|[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-z]{2,6}\\b[-a-zA-Z0-9@:%_+.~#?&//=]*)",
+        Pattern.CASE_INSENSITIVE,
+      )
+
+    private fun normalizeUrl(url: String): String {
+      if (url.startsWith("http://") || url.startsWith("https://")) return url
+      return "https://$url"
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/autolink/LinkRegexConfig.kt

@@ -0,0 +1,9 @@
+package com.swmansion.enriched.markdown.input.autolink
+
+data class LinkRegexConfig(
+  val pattern: String,
+  val caseInsensitive: Boolean,
+  val dotAll: Boolean,
+  val isDisabled: Boolean,
+  val isDefault: Boolean,
+)

package/android/src/main/java/com/swmansion/enriched/markdown/input/detection/DetectorPipeline.kt

@@ -0,0 +1,40 @@
+package com.swmansion.enriched.markdown.input.detection
+
+import android.text.Spannable
+import com.swmansion.enriched.markdown.input.model.FormattingRange
+
+/**
+ * Coordinates a set of [TextDetector] instances. The input view calls
+ * this pipeline instead of individual detectors.
+ */
+class DetectorPipeline {
+  private val detectors = mutableListOf<TextDetector>()
+
+  fun addDetector(detector: TextDetector) {
+    detectors.add(detector)
+  }
+
+  fun processTextChange(
+    spannable: Spannable,
+    text: String,
+    editStart: Int,
+    editLength: Int,
+  ) {
+    val words = WordsUtils.getAffectedWords(text, editStart, editLength)
+
+    for (wordResult in words) {
+      for (detector in detectors) {
+        detector.processWord(spannable, wordResult)
+      }
+    }
+  }
+
+  fun refreshAllStyling(spannable: Spannable) {
+    for (detector in detectors) {
+      detector.refreshStyling(spannable)
+    }
+  }
+
+  fun allTransientFormattingRanges(spannable: Spannable): List<FormattingRange> =
+    detectors.flatMap { it.transientFormattingRanges(spannable) }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/detection/TextDetector.kt

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.input.detection
+
+import android.text.Spannable
+import com.swmansion.enriched.markdown.input.model.FormattingRange
+
+/**
+ * Interface for pluggable text detectors that run after each text edit.
+ * Each detector processes affected words, can refresh its own visual styling
+ * after the formatter resets spans, and contributes transient formatting ranges
+ * for markdown serialization.
+ */
+interface TextDetector {
+  /** Process a single word at the given range after a text edit. */
+  fun processWord(
+    spannable: Spannable,
+    wordResult: WordResult,
+  )
+
+  /** Re-apply any visual styling owned by this detector. */
+  fun refreshStyling(spannable: Spannable)
+
+  /**
+   * Return transient formatting ranges that should be merged
+   * with the FormattingStore ranges during markdown serialization.
+   */
+  fun transientFormattingRanges(spannable: Spannable): List<FormattingRange>
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/detection/WordResult.kt

@@ -0,0 +1,7 @@
+package com.swmansion.enriched.markdown.input.detection
+
+data class WordResult(
+  val word: String,
+  val start: Int,
+  val end: Int,
+)

package/android/src/main/java/com/swmansion/enriched/markdown/input/detection/WordsUtils.kt

@@ -0,0 +1,65 @@
+package com.swmansion.enriched.markdown.input.detection
+
+object WordsUtils {
+  /**
+   * Returns the start index of the token (non-whitespace run) that ends at [position].
+   * If [position] is directly after whitespace (or at the start of text), returns [position].
+   */
+  fun tokenStart(
+    text: String,
+    position: Int,
+  ): Int {
+    var start = position
+    while (start > 0 && !text[start - 1].isWhitespace()) {
+      start--
+    }
+    return start
+  }
+
+  fun getAffectedWords(
+    text: String,
+    editStart: Int,
+    editLength: Int,
+  ): List<WordResult> {
+    val textLength = text.length
+    if (textLength == 0) return emptyList()
+
+    var left = editStart.coerceIn(0, textLength)
+    if (left > 0) {
+      left--
+      while (left > 0 && !text[left].isWhitespace()) {
+        left--
+      }
+      if (text[left].isWhitespace()) left++
+    }
+
+    var right = (editStart + editLength).coerceIn(0, textLength)
+    if (right < textLength) {
+      while (right < textLength && !text[right].isWhitespace()) {
+        right++
+      }
+    }
+
+    if (left >= right) return emptyList()
+
+    val results = mutableListOf<WordResult>()
+    var wordStart = left
+    var i = left
+
+    while (i < right) {
+      if (text[i].isWhitespace()) {
+        if (i > wordStart) {
+          results.add(WordResult(text.substring(wordStart, i), wordStart, i))
+        }
+        wordStart = i + 1
+      }
+      i++
+    }
+
+    if (wordStart < right) {
+      results.add(WordResult(text.substring(wordStart, right), wordStart, right))
+    }
+
+    return results
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/editing/InputConnectionWrapper.kt

@@ -0,0 +1,69 @@
+package com.swmansion.enriched.markdown.input.editing
+
+import android.view.KeyEvent
+import android.view.inputmethod.InputConnection
+import com.swmansion.enriched.markdown.input.EnrichedMarkdownTextInputView
+import android.view.inputmethod.InputConnectionWrapper as AndroidInputConnectionWrapper
+
+class InputConnectionWrapper(
+  target: InputConnection,
+  private val editText: EnrichedMarkdownTextInputView,
+) : AndroidInputConnectionWrapper(target, false) {
+  var isBatchEdit = false
+    private set
+
+  override fun beginBatchEdit(): Boolean {
+    isBatchEdit = true
+    return super.beginBatchEdit()
+  }
+
+  override fun endBatchEdit(): Boolean {
+    isBatchEdit = false
+    return super.endBatchEdit()
+  }
+
+  override fun setComposingText(
+    text: CharSequence,
+    newCursorPosition: Int,
+  ): Boolean = super.setComposingText(text, newCursorPosition)
+
+  override fun setComposingRegion(
+    start: Int,
+    end: Int,
+  ): Boolean {
+    // Adjust the composing region to skip over math chips. Composing decorations
+    // (e.g. the dotted underline drawn by some IMEs while building Hangul/Kana
+    // jamo) would otherwise paint on top of the chip glyph and let the IME mutate
+    // the chip's placeholder char as if it were normal text.
+    val adjusted = editText.adjustComposingRegionAwayFromChips(start, end)
+    if (adjusted == null || (adjusted.first == start && adjusted.second == end)) {
+      return super.setComposingRegion(start, end)
+    }
+    return super.setComposingRegion(adjusted.first, adjusted.second)
+  }
+
+  override fun commitText(
+    text: CharSequence,
+    newCursorPosition: Int,
+  ): Boolean = super.commitText(text, newCursorPosition)
+
+  override fun deleteSurroundingText(
+    beforeLength: Int,
+    afterLength: Int,
+  ): Boolean {
+    if (beforeLength == 1 && afterLength == 0 && editText.deleteLinkBeforeCursor()) {
+      return true
+    }
+    return super.deleteSurroundingText(beforeLength, afterLength)
+  }
+
+  override fun sendKeyEvent(event: KeyEvent): Boolean {
+    if (event.action == KeyEvent.ACTION_DOWN &&
+      event.keyCode == KeyEvent.KEYCODE_DEL &&
+      editText.deleteLinkBeforeCursor()
+    ) {
+      return true
+    }
+    return super.sendKeyEvent(event)
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/editing/MarkdownEditableFactory.kt

@@ -0,0 +1,15 @@
+package com.swmansion.enriched.markdown.input.editing
+
+import android.text.Editable
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.input.EnrichedMarkdownTextInputView
+
+class MarkdownEditableFactory(
+  private val view: EnrichedMarkdownTextInputView,
+) : Editable.Factory() {
+  override fun newEditable(source: CharSequence): Editable {
+    val builder = (source as? SpannableStringBuilder) ?: SpannableStringBuilder(source)
+    view.attachTextWatcher(builder)
+    return builder
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/editing/MarkdownTextWatcher.kt

@@ -0,0 +1,41 @@
+package com.swmansion.enriched.markdown.input.editing
+
+import android.text.Editable
+import android.text.TextWatcher
+import com.swmansion.enriched.markdown.input.EnrichedMarkdownTextInputView
+
+class MarkdownTextWatcher(
+  private val view: EnrichedMarkdownTextInputView,
+) : TextWatcher {
+  private var editStart = 0
+  private var deletedLength = 0
+  private var insertedLength = 0
+
+  override fun beforeTextChanged(
+    text: CharSequence,
+    start: Int,
+    count: Int,
+    after: Int,
+  ) {
+    if (view.isDuringTransaction || view.isProcessingTextChange) return
+    editStart = start
+    deletedLength = count
+    insertedLength = after
+    view.onBeforeTextChanged()
+  }
+
+  override fun onTextChanged(
+    text: CharSequence,
+    start: Int,
+    before: Int,
+    count: Int,
+  ) {
+    if (view.isDuringTransaction || view.isProcessingTextChange) return
+    view.layoutManager.invalidateLayout()
+  }
+
+  override fun afterTextChanged(editable: Editable) {
+    if (view.isDuringTransaction || view.isProcessingTextChange) return
+    view.onAfterTextChanged(editStart, deletedLength, insertedLength)
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnCaretRectChangeEvent.kt

@@ -0,0 +1,20 @@
+package com.swmansion.enriched.markdown.input.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.swmansion.enriched.markdown.input.model.CaretRect
+
+class OnCaretRectChangeEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val rect: CaretRect,
+) : Event<OnCaretRectChangeEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap().also { rect.putInto(it) }
+
+  companion object {
+    const val EVENT_NAME = "onCaretRectChange"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnChangeMarkdownEvent.kt

@@ -0,0 +1,22 @@
+package com.swmansion.enriched.markdown.input.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnChangeMarkdownEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val markdown: String,
+) : Event<OnChangeMarkdownEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("value", markdown)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onChangeMarkdown"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnChangeMentionEvent.kt

@@ -0,0 +1,24 @@
+package com.swmansion.enriched.markdown.input.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnChangeMentionEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val indicator: String,
+  private val text: String,
+) : Event<OnChangeMentionEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("indicator", indicator)
+      putString("text", text)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onChangeMention"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnChangeSelectionEvent.kt

@@ -0,0 +1,24 @@
+package com.swmansion.enriched.markdown.input.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnChangeSelectionEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val start: Int,
+  private val end: Int,
+) : Event<OnChangeSelectionEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("start", start)
+      putInt("end", end)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onChangeSelection"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnChangeStateEvent.kt

@@ -0,0 +1,50 @@
+package com.swmansion.enriched.markdown.input.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnChangeStateEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val isBold: Boolean,
+  private val isItalic: Boolean,
+  private val isUnderline: Boolean,
+  private val isStrikethrough: Boolean,
+  private val isSpoiler: Boolean,
+  private val isLink: Boolean,
+) : Event<OnChangeStateEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putMap(
+        "bold",
+        Arguments.createMap().apply { putBoolean("isActive", isBold) },
+      )
+      putMap(
+        "italic",
+        Arguments.createMap().apply { putBoolean("isActive", isItalic) },
+      )
+      putMap(
+        "underline",
+        Arguments.createMap().apply { putBoolean("isActive", isUnderline) },
+      )
+      putMap(
+        "strikethrough",
+        Arguments.createMap().apply { putBoolean("isActive", isStrikethrough) },
+      )
+      putMap(
+        "spoiler",
+        Arguments.createMap().apply { putBoolean("isActive", isSpoiler) },
+      )
+      putMap(
+        "link",
+        Arguments.createMap().apply { putBoolean("isActive", isLink) },
+      )
+    }
+
+  companion object {
+    const val EVENT_NAME = "onChangeState"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnChangeTextEvent.kt

@@ -0,0 +1,22 @@
+package com.swmansion.enriched.markdown.input.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnChangeTextEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val text: String,
+) : Event<OnChangeTextEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("value", text)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onChangeText"
+  }
+}