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

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

@@ -0,0 +1,48 @@
+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 OnContextMenuItemPressEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val itemText: String,
+  private val selectedText: String,
+  private val selectionStart: Int,
+  private val selectionEnd: 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<OnContextMenuItemPressEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap {
+    fun styleEntry(isActive: Boolean) = Arguments.createMap().apply { putBoolean("isActive", isActive) }
+
+    return Arguments.createMap().apply {
+      putString("itemText", itemText)
+      putString("selectedText", selectedText)
+      putInt("selectionStart", selectionStart)
+      putInt("selectionEnd", selectionEnd)
+      putMap(
+        "styleState",
+        Arguments.createMap().apply {
+          putMap("bold", styleEntry(isBold))
+          putMap("italic", styleEntry(isItalic))
+          putMap("underline", styleEntry(isUnderline))
+          putMap("strikethrough", styleEntry(isStrikethrough))
+          putMap("spoiler", styleEntry(isSpoiler))
+          putMap("link", styleEntry(isLink))
+        },
+      )
+    }
+  }
+
+  companion object {
+    const val EVENT_NAME = "onContextMenuItemPress"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnEndMentionEvent.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 OnEndMentionEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val indicator: String,
+) : Event<OnEndMentionEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("indicator", indicator)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onEndMention"
+  }
+}

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

@@ -0,0 +1,18 @@
+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 OnInputBlurEvent(
+  surfaceId: Int,
+  viewId: Int,
+) : Event<OnInputBlurEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "onInputBlur"
+  }
+}

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

@@ -0,0 +1,18 @@
+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 OnInputFocusEvent(
+  surfaceId: Int,
+  viewId: Int,
+) : Event<OnInputFocusEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "onInputFocus"
+  }
+}

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

@@ -0,0 +1,28 @@
+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 OnLinkDetectedEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val text: String,
+  private val url: String,
+  private val start: Int,
+  private val end: Int,
+) : Event<OnLinkDetectedEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("text", text)
+      putString("url", url)
+      putInt("start", start)
+      putInt("end", end)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onLinkDetected"
+  }
+}

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

@@ -0,0 +1,36 @@
+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 OnMathPressEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val latex: String,
+  private val start: Int,
+  private val end: Int,
+  private val displayMode: Boolean,
+  private val x: Double,
+  private val y: Double,
+  private val width: Double,
+  private val height: Double,
+) : Event<OnMathPressEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("latex", latex)
+      putInt("start", start)
+      putInt("end", end)
+      putBoolean("displayMode", displayMode)
+      putDouble("x", x)
+      putDouble("y", y)
+      putDouble("width", width)
+      putDouble("height", height)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onMathPress"
+  }
+}

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

@@ -0,0 +1,25 @@
+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 OnRequestCaretRectResultEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val requestId: Int,
+  private val rect: CaretRect,
+) : Event<OnRequestCaretRectResultEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("requestId", requestId)
+      rect.putInto(this)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onRequestCaretRectResult"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnRequestMarkdownResultEvent.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 OnRequestMarkdownResultEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val requestId: Int,
+  private val markdown: String,
+) : Event<OnRequestMarkdownResultEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("requestId", requestId)
+      putString("markdown", markdown)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onRequestMarkdownResult"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/events/OnStartMentionEvent.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 OnStartMentionEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val indicator: String,
+) : Event<OnStartMentionEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("indicator", indicator)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onStartMention"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/FormattingStore.kt

@@ -0,0 +1,192 @@
+package com.swmansion.enriched.markdown.input.formatting
+
+import com.swmansion.enriched.markdown.input.model.FormattingRange
+import com.swmansion.enriched.markdown.input.model.StyleType
+import java.util.Collections
+
+class FormattingStore {
+  private val ranges = mutableListOf<FormattingRange>()
+
+  val allRanges: List<FormattingRange> get() = Collections.unmodifiableList(ranges)
+
+  fun setRanges(newRanges: List<FormattingRange>) {
+    ranges.clear()
+    ranges.addAll(newRanges.sortedBy { it.start })
+  }
+
+  fun clearAll() {
+    ranges.clear()
+  }
+
+  fun rangeOfType(
+    type: StyleType,
+    containingPosition: Int,
+  ): FormattingRange? = ranges.firstOrNull { it.type == type && containingPosition >= it.start && containingPosition < it.end }
+
+  fun isStyleActive(
+    type: StyleType,
+    position: Int,
+  ): Boolean = rangeOfType(type, position) != null
+
+  fun isStyleActiveInRange(
+    type: StyleType,
+    start: Int,
+    end: Int,
+  ): Boolean = ranges.any { it.type == type && it.start < end && it.end > start }
+
+  fun addRange(newRange: FormattingRange) {
+    var mergedStart = newRange.start
+    var mergedEnd = newRange.end
+    val mergeIndexes = mutableListOf<Int>()
+
+    for ((idx, existing) in ranges.withIndex()) {
+      if (existing.type != newRange.type) continue
+      if (existing.start <= mergedEnd && existing.end >= mergedStart) {
+        mergedStart = minOf(mergedStart, existing.start)
+        mergedEnd = maxOf(mergedEnd, existing.end)
+        mergeIndexes.add(idx)
+      }
+    }
+
+    for (idx in mergeIndexes.reversed()) {
+      ranges.removeAt(idx)
+    }
+
+    val merged = FormattingRange(newRange.type, mergedStart, mergedEnd, newRange.url)
+    val insertAt = sortedInsertionIndex(mergedStart)
+    ranges.add(insertAt, merged)
+  }
+
+  fun removeType(
+    type: StyleType,
+    start: Int,
+    end: Int,
+  ) {
+    val remainders = mutableListOf<FormattingRange>()
+    val indexesToRemove = mutableListOf<Int>()
+
+    for ((idx, existing) in ranges.withIndex()) {
+      if (existing.type != type) continue
+      if (existing.end <= start || existing.start >= end) continue
+
+      indexesToRemove.add(idx)
+
+      if (existing.start < start) {
+        remainders.add(FormattingRange(type, existing.start, start, existing.url))
+      }
+      if (existing.end > end) {
+        remainders.add(FormattingRange(type, end, existing.end, existing.url))
+      }
+    }
+
+    for (idx in indexesToRemove.reversed()) {
+      ranges.removeAt(idx)
+    }
+
+    // Remainders are fragments of a just-removed range and cannot overlap others.
+    for (remainder in remainders) {
+      val insertAt = sortedInsertionIndex(remainder.start)
+      ranges.add(insertAt, remainder)
+    }
+  }
+
+  fun removeRange(range: FormattingRange) {
+    ranges.remove(range)
+  }
+
+  fun adjustForEdit(
+    editLocation: Int,
+    deletedLength: Int,
+    insertedLength: Int,
+  ) {
+    if (deletedLength == 0 && insertedLength == 0) return
+
+    val deleteEnd = editLocation + deletedLength
+    val indexesToRemove = mutableListOf<Int>()
+
+    for ((idx, range) in ranges.withIndex()) {
+      if (deletedLength > 0) {
+        when (classifyOverlap(range.start, range.end, editLocation, deleteEnd)) {
+          EditOverlap.BEFORE_EDIT -> { /* no change */ }
+
+          EditOverlap.AFTER_EDIT -> {
+            range.start = range.start - deletedLength + insertedLength
+            range.end = range.end - deletedLength + insertedLength
+          }
+
+          EditOverlap.FULLY_DELETED -> {
+            indexesToRemove.add(idx)
+          }
+
+          EditOverlap.DELETED_INSIDE -> {
+            range.end = range.end - deletedLength + insertedLength
+          }
+
+          EditOverlap.CLIPPED_END -> {
+            val newEnd = editLocation + insertedLength
+            val newLength = if (newEnd > range.start) newEnd - range.start else 0
+            range.end = range.start + newLength
+            if (newLength == 0) indexesToRemove.add(idx)
+          }
+
+          EditOverlap.CLIPPED_START -> {
+            val charsClipped = deleteEnd - range.start
+            val newStart = editLocation + insertedLength
+            val oldLength = range.length
+            range.start = newStart
+            range.end = newStart + oldLength - charsClipped
+            if (range.length == 0) indexesToRemove.add(idx)
+          }
+        }
+      } else {
+        when {
+          range.start >= editLocation -> {
+            range.start += insertedLength
+            range.end += insertedLength
+          }
+
+          editLocation > range.start && editLocation < range.end -> {
+            range.end += insertedLength
+          }
+        }
+      }
+    }
+
+    for (idx in indexesToRemove.reversed()) {
+      ranges.removeAt(idx)
+    }
+
+    ranges.removeAll { it.length == 0 }
+  }
+
+  private fun sortedInsertionIndex(location: Int): Int {
+    var index = 0
+    for (existing in ranges) {
+      if (existing.start > location) break
+      index++
+    }
+    return index
+  }
+
+  private enum class EditOverlap {
+    BEFORE_EDIT,
+    AFTER_EDIT,
+    FULLY_DELETED,
+    DELETED_INSIDE,
+    CLIPPED_END,
+    CLIPPED_START,
+  }
+
+  private fun classifyOverlap(
+    rangeStart: Int,
+    rangeEnd: Int,
+    editLocation: Int,
+    deleteEnd: Int,
+  ): EditOverlap {
+    if (rangeEnd <= editLocation) return EditOverlap.BEFORE_EDIT
+    if (rangeStart >= deleteEnd) return EditOverlap.AFTER_EDIT
+    if (rangeStart >= editLocation && rangeEnd <= deleteEnd) return EditOverlap.FULLY_DELETED
+    if (rangeStart < editLocation && rangeEnd > deleteEnd) return EditOverlap.DELETED_INSIDE
+    return if (rangeStart < editLocation) EditOverlap.CLIPPED_END else EditOverlap.CLIPPED_START
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/InputFormatter.kt

@@ -0,0 +1,117 @@
+package com.swmansion.enriched.markdown.input.formatting
+
+import android.text.Spannable
+import android.text.style.CharacterStyle
+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 com.swmansion.enriched.markdown.input.styles.BoldStyleHandler
+import com.swmansion.enriched.markdown.input.styles.ItalicStyleHandler
+import com.swmansion.enriched.markdown.input.styles.LinkStyleHandler
+import com.swmansion.enriched.markdown.input.styles.SpoilerStyleHandler
+import com.swmansion.enriched.markdown.input.styles.StrikethroughStyleHandler
+import com.swmansion.enriched.markdown.input.styles.StyleHandler
+import com.swmansion.enriched.markdown.input.styles.UnderlineStyleHandler
+
+/**
+ * Marker interface so we only remove spans we created, leaving
+ * system spans (IME underline, selection highlight) untouched.
+ */
+interface MarkdownSpan
+
+class InputFormatter {
+  val handlers: Map<StyleType, StyleHandler> =
+    mapOf(
+      StyleType.BOLD to BoldStyleHandler(),
+      StyleType.ITALIC to ItalicStyleHandler(),
+      StyleType.UNDERLINE to UnderlineStyleHandler(),
+      StyleType.STRIKETHROUGH to StrikethroughStyleHandler(),
+      StyleType.LINK to LinkStyleHandler(),
+      StyleType.SPOILER to SpoilerStyleHandler(),
+    )
+
+  private var style: InputFormatterStyle? = null
+
+  fun updateStyle(newStyle: InputFormatterStyle): Boolean {
+    if (newStyle == style) return false
+    style = newStyle
+    return true
+  }
+
+  fun applyFormatting(
+    spannable: Spannable,
+    ranges: List<FormattingRange>,
+  ) {
+    val currentStyle = style ?: return
+
+    val existingSpans =
+      spannable
+        .getSpans(0, spannable.length, CharacterStyle::class.java)
+        .filterIsInstance<MarkdownSpan>()
+    val linkSpanClasses = handlers[StyleType.LINK]?.spanClasses().orEmpty().toSet()
+    val existingLinkSpans = existingSpans.filter { span -> linkSpanClasses.any { it.isInstance(span) } }
+    for (span in existingLinkSpans) {
+      spannable.removeSpan(span as CharacterStyle)
+    }
+
+    val desired = mutableListOf<SpanDescriptor>()
+    for (range in ranges) {
+      if (range.start >= range.end || range.start < 0 || range.end > spannable.length) continue
+      val handler = handlers[range.type] ?: continue
+      val spans = handler.createSpans(range, currentStyle)
+      for (span in spans) {
+        desired.add(SpanDescriptor(range.start, range.end, span::class.java, range.url))
+      }
+    }
+
+    val existing =
+      existingSpans
+        .filter { span -> span !in existingLinkSpans }
+        .map { span ->
+          SpanDescriptor(
+            spannable.getSpanStart(span as CharacterStyle),
+            spannable.getSpanEnd(span as CharacterStyle),
+            span::class.java,
+            null,
+          ) to (span as CharacterStyle)
+        }
+
+    val desiredSet = desired.toSet()
+    val existingSet = existing.map { it.first }.toSet()
+
+    if (desiredSet == existingSet) return
+
+    for ((desc, span) in existing) {
+      if (desc !in desiredSet) {
+        spannable.removeSpan(span)
+      }
+    }
+
+    for (desc in desired) {
+      if (desc !in existingSet) {
+        val handler =
+          handlers.values.firstOrNull { h ->
+            h.spanClasses().any { it == desc.spanClass }
+          } ?: continue
+        val dummyRange = FormattingRange(handler.styleType, desc.start, desc.end, desc.url)
+        val newSpans = handler.createSpans(dummyRange, currentStyle)
+        val matchingSpan = newSpans.firstOrNull { it::class.java == desc.spanClass }
+        if (matchingSpan != null) {
+          spannable.setSpan(
+            matchingSpan,
+            desc.start,
+            desc.end,
+            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE,
+          )
+        }
+      }
+    }
+  }
+
+  private data class SpanDescriptor(
+    val start: Int,
+    val end: Int,
+    val spanClass: Class<*>,
+    val url: String?,
+  )
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/InputParser.kt

@@ -0,0 +1,117 @@
+package com.swmansion.enriched.markdown.input.formatting
+
+import com.swmansion.enriched.markdown.input.model.FormattingRange
+import com.swmansion.enriched.markdown.input.model.MathAtom
+import com.swmansion.enriched.markdown.input.model.StyleType
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode.NodeType
+import com.swmansion.enriched.markdown.parser.Md4cFlags
+import com.swmansion.enriched.markdown.parser.Parser
+import com.swmansion.enriched.markdown.utils.common.FeatureFlags
+
+data class ParseResult(
+  val plainText: String,
+  val formattingRanges: List<FormattingRange>,
+  val mathAtoms: List<MathAtom> = emptyList(),
+)
+
+object InputParser {
+  private const val ATTACHMENT_CHAR = ''
+
+  fun parseToPlainTextAndRanges(markdown: String): ParseResult {
+    if (markdown.isEmpty()) {
+      return ParseResult("", emptyList())
+    }
+
+    val completed = InputRemend.complete(markdown)
+    val flags =
+      Md4cFlags(
+        underline = true,
+        latexMath = FeatureFlags.IS_MATH_ENABLED,
+        permissiveAutolinks = false,
+      )
+    val ast = Parser.shared.parseMarkdown(completed, flags) ?: return ParseResult(markdown, emptyList())
+
+    val plainText = StringBuilder()
+    val ranges = mutableListOf<FormattingRange>()
+    val mathAtoms = mutableListOf<MathAtom>()
+
+    walkNode(ast, plainText, ranges, mathAtoms, ArrayDeque())
+
+    return ParseResult(plainText.toString(), ranges, mathAtoms)
+  }
+
+  private fun walkNode(
+    node: MarkdownASTNode,
+    plainText: StringBuilder,
+    ranges: MutableList<FormattingRange>,
+    mathAtoms: MutableList<MathAtom>,
+    activeStyles: ArrayDeque<ActiveStyle>,
+  ) {
+    if (node.type == NodeType.LatexMathInline || node.type == NodeType.LatexMathDisplay) {
+      val latex = extractLatex(node)
+      val position = plainText.length
+      plainText.append(ATTACHMENT_CHAR)
+      mathAtoms.add(
+        MathAtom(
+          position = position,
+          latex = latex,
+          displayMode = node.type == NodeType.LatexMathDisplay,
+        ),
+      )
+      return
+    }
+
+    val styleType = nodeTypeToStyleType(node.type)
+
+    if (styleType != null) {
+      val url = if (styleType == StyleType.LINK) node.getAttribute("url") else null
+      activeStyles.addLast(ActiveStyle(styleType, plainText.length, url))
+    }
+
+    if (node.type == NodeType.Text) {
+      plainText.append(node.content)
+    } else if (node.type == NodeType.LineBreak) {
+      plainText.append("\n")
+    }
+
+    for (child in node.children) {
+      walkNode(child, plainText, ranges, mathAtoms, activeStyles)
+    }
+
+    if (styleType != null) {
+      val activeStyle = activeStyles.removeLast()
+      val end = plainText.length
+      if (end > activeStyle.startPosition) {
+        ranges.add(FormattingRange(styleType, activeStyle.startPosition, end, activeStyle.url))
+      }
+    }
+  }
+
+  private fun extractLatex(node: MarkdownASTNode): String {
+    if (node.content.isNotEmpty()) return node.content
+    if (node.children.isEmpty()) return ""
+    val builder = StringBuilder()
+    for (child in node.children) {
+      if (child.content.isNotEmpty()) builder.append(child.content)
+    }
+    return builder.toString()
+  }
+
+  private fun nodeTypeToStyleType(nodeType: NodeType): StyleType? =
+    when (nodeType) {
+      NodeType.Strong -> StyleType.BOLD
+      NodeType.Emphasis -> StyleType.ITALIC
+      NodeType.Underline -> StyleType.UNDERLINE
+      NodeType.Strikethrough -> StyleType.STRIKETHROUGH
+      NodeType.Link -> StyleType.LINK
+      NodeType.Spoiler -> StyleType.SPOILER
+      else -> null
+    }
+
+  private data class ActiveStyle(
+    val type: StyleType,
+    val startPosition: Int,
+    val url: String?,
+  )
+}