react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

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

@@ -5,6 +5,27 @@ import android.view.inputmethod.InputConnection
 import com.swmansion.enriched.markdown.input.EnrichedMarkdownTextInputView
 import android.view.inputmethod.InputConnectionWrapper as AndroidInputConnectionWrapper
 
+/**
+ * Intercepts IME traffic for two purposes: atomic link deletion (a backspace
+ * right after a link removes the whole link) and the `onKeyPress` event.
+ *
+ * Key derivation mirrors React Native's ReactEditTextInputConnectionWrapper.
+ * Soft keyboards don't report discrete key presses; the pressed key is inferred
+ * from InputConnection side effects:
+ * - [setComposingText] receives the whole composing region, not a one-character
+ *   diff, so the key is derived from cursor movement: a cursor that moved
+ *   backwards (or stayed put while collapsing a selection) means "Backspace",
+ *   otherwise the key is the character left of the cursor.
+ * - [commitText] with an empty string means "Backspace"; short strings (a char,
+ *   or a surrogate pair) are the key itself; longer strings are autocomplete
+ *   insertions, not key presses.
+ * - [deleteSurroundingText] is a backspace with nothing to compose.
+ * - [sendKeyEvent] is used by some keyboards (e.g. SwiftKey) for delete/enter
+ *   and by number-pad keys.
+ * IMEs wrap composed-word commits in a batch edit that ends with the actual
+ * user input, so during a batch only the last inferred key is emitted at
+ * [endBatchEdit]. Newlines are normalized to "Enter".
+ */
 class InputConnectionWrapper(
   target: InputConnection,
   private val editText: EnrichedMarkdownTextInputView,
@@ -12,6 +33,8 @@ class InputConnectionWrapper(
   var isBatchEdit = false
     private set
 
+  private var pendingKey: String? = null
+
   override fun beginBatchEdit(): Boolean {
     isBatchEdit = true
     return super.beginBatchEdit()
@@ -19,13 +42,46 @@ class InputConnectionWrapper(
 
   override fun endBatchEdit(): Boolean {
     isBatchEdit = false
+    pendingKey?.let {
+      dispatchKeyPress(it)
+      pendingKey = null
+    }
     return super.endBatchEdit()
   }
 
   override fun setComposingText(
     text: CharSequence,
     newCursorPosition: Int,
-  ): Boolean = super.setComposingText(text, newCursorPosition)
+  ): Boolean {
+    val previousSelectionStart = editText.selectionStart
+    val previousSelectionEnd = editText.selectionEnd
+
+    val consumed = super.setComposingText(text, newCursorPosition)
+
+    val currentSelectionStart = editText.selectionStart
+    val noPreviousSelection = previousSelectionStart == previousSelectionEnd
+    val cursorDidNotMove = currentSelectionStart == previousSelectionStart
+    val cursorMovedBackwardsOrAtBeginningOfInput =
+      currentSelectionStart < previousSelectionStart || currentSelectionStart <= 0
+
+    val key =
+      if (cursorMovedBackwardsOrAtBeginningOfInput || (!noPreviousSelection && cursorDidNotMove)) {
+        BACKSPACE_KEY_VALUE
+      } else {
+        codePointBeforeCursor(currentSelectionStart)
+      }
+    if (key.isNotEmpty()) {
+      dispatchKeyPressOrEnqueue(key)
+    }
+    return consumed
+  }
+
+  private fun codePointBeforeCursor(cursor: Int): String {
+    val content = editText.text ?: return ""
+    val end = cursor.coerceAtMost(content.length)
+    if (end < 1) return ""
+    return String(Character.toChars(Character.codePointBefore(content, end)))
+  }
 
   override fun setComposingRegion(
     start: Int,
@@ -45,12 +101,19 @@ class InputConnectionWrapper(
   override fun commitText(
     text: CharSequence,
     newCursorPosition: Int,
-  ): Boolean = super.commitText(text, newCursorPosition)
+  ): Boolean {
+    val key = text.toString()
+    if (key.length <= 2) {
+      dispatchKeyPressOrEnqueue(key.ifEmpty { BACKSPACE_KEY_VALUE })
+    }
+    return super.commitText(text, newCursorPosition)
+  }
 
   override fun deleteSurroundingText(
     beforeLength: Int,
     afterLength: Int,
   ): Boolean {
+    dispatchKeyPress(BACKSPACE_KEY_VALUE)
     if (beforeLength == 1 && afterLength == 0 && editText.deleteLinkBeforeCursor()) {
       return true
     }
@@ -58,12 +121,43 @@ class InputConnectionWrapper(
   }
 
   override fun sendKeyEvent(event: KeyEvent): Boolean {
-    if (event.action == KeyEvent.ACTION_DOWN &&
-      event.keyCode == KeyEvent.KEYCODE_DEL &&
-      editText.deleteLinkBeforeCursor()
-    ) {
-      return true
+    if (event.action == KeyEvent.ACTION_DOWN) {
+      val isNumberKey = event.unicodeChar in 48..57
+      when (event.keyCode) {
+        KeyEvent.KEYCODE_DEL -> dispatchKeyPress(BACKSPACE_KEY_VALUE)
+        KeyEvent.KEYCODE_ENTER -> dispatchKeyPress(ENTER_KEY_VALUE)
+        else -> if (isNumberKey) dispatchKeyPress(event.number.toString())
+      }
+      if (event.keyCode == KeyEvent.KEYCODE_DEL && editText.deleteLinkBeforeCursor()) {
+        return true
+      }
     }
     return super.sendKeyEvent(event)
   }
+
+  private fun dispatchKeyPressOrEnqueue(key: String) {
+    if (isBatchEdit) {
+      pendingKey = key
+    } else {
+      dispatchKeyPress(key)
+    }
+  }
+
+  private fun dispatchKeyPress(key: String) {
+    val resolved =
+      when (key) {
+        NEWLINE_RAW_VALUE -> ENTER_KEY_VALUE
+        TAB_RAW_VALUE -> TAB_KEY_VALUE
+        else -> key
+      }
+    editText.eventEmitter.emitKeyPress(resolved)
+  }
+
+  companion object {
+    private const val NEWLINE_RAW_VALUE = "\n"
+    private const val TAB_RAW_VALUE = "\t"
+    private const val BACKSPACE_KEY_VALUE = "Backspace"
+    private const val ENTER_KEY_VALUE = "Enter"
+    private const val TAB_KEY_VALUE = "Tab"
+  }
 }

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

@@ -0,0 +1,69 @@
+package com.swmansion.enriched.markdown.input.editing
+
+import android.text.Spannable
+import com.swmansion.enriched.markdown.input.autolink.AutoLinkDetector
+import com.swmansion.enriched.markdown.input.formatting.FormattingStore
+import com.swmansion.enriched.markdown.input.model.FormattingRange
+import com.swmansion.enriched.markdown.input.model.StyleType
+
+class LinkCoordinator(
+  private val formattingStore: FormattingStore,
+  private val autoLinkDetector: AutoLinkDetector,
+) {
+  fun sanitizeUrl(url: String): String =
+    url
+      .replace("(", "%28")
+      .replace(")", "%29")
+
+  fun linkAtPosition(position: Int): FormattingRange? = formattingStore.rangeOfType(StyleType.LINK, position)
+
+  fun setLinkForRange(
+    url: String,
+    start: Int,
+    end: Int,
+    editable: Spannable?,
+  ) {
+    if (start == end) return
+    if (editable != null) {
+      autoLinkDetector.clearAutoLinkInRange(editable, start, end)
+    }
+    formattingStore.addRange(FormattingRange(StyleType.LINK, start, end, url))
+  }
+
+  fun addLink(
+    url: String,
+    start: Int,
+    end: Int,
+    editable: Spannable?,
+  ) {
+    if (start >= end) return
+    if (editable != null) {
+      autoLinkDetector.clearAutoLinkInRange(editable, start, end)
+    }
+    formattingStore.addRange(FormattingRange(StyleType.LINK, start, end, sanitizeUrl(url)))
+  }
+
+  fun addLinkDirect(
+    url: String,
+    start: Int,
+    end: Int,
+  ) {
+    if (start >= end) return
+    formattingStore.addRange(FormattingRange(StyleType.LINK, start, end, url))
+  }
+
+  fun removeLink(position: Int): Boolean {
+    val linkRange = formattingStore.rangeOfType(StyleType.LINK, position) ?: return false
+    formattingStore.removeRange(linkRange)
+    return true
+  }
+
+  /**
+   * Finds the link containing `position - 1` and returns its range for deletion.
+   * Returns null if no link is found.
+   */
+  fun linkRangeForDeletion(position: Int): FormattingRange? {
+    if (position <= 0) return null
+    return formattingStore.rangeOfType(StyleType.LINK, position - 1)
+  }
+}

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

@@ -17,7 +17,7 @@ class MarkdownTextWatcher(
     count: Int,
     after: Int,
   ) {
-    if (view.isDuringTransaction || view.isProcessingTextChange) return
+    if (view.editSession.shouldSuppressTextWatcher) return
     editStart = start
     deletedLength = count
     insertedLength = after
@@ -30,12 +30,12 @@ class MarkdownTextWatcher(
     before: Int,
     count: Int,
   ) {
-    if (view.isDuringTransaction || view.isProcessingTextChange) return
+    if (view.editSession.shouldSuppressTextWatcher) return
     view.layoutManager.invalidateLayout()
   }
 
   override fun afterTextChanged(editable: Editable) {
-    if (view.isDuringTransaction || view.isProcessingTextChange) return
+    if (view.editSession.shouldSuppressTextWatcher) return
     view.onAfterTextChanged(editStart, deletedLength, insertedLength)
   }
 }

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

@@ -0,0 +1,118 @@
+package com.swmansion.enriched.markdown.input.editing
+
+import com.swmansion.enriched.markdown.input.detection.WordsUtils
+import com.swmansion.enriched.markdown.input.formatting.FormattingStore
+import com.swmansion.enriched.markdown.input.model.StyleType
+
+sealed class MentionEvent {
+  data class Start(
+    val indicator: String,
+  ) : MentionEvent()
+
+  data class Change(
+    val indicator: String,
+    val text: String,
+  ) : MentionEvent()
+
+  data class End(
+    val indicator: String,
+  ) : MentionEvent()
+}
+
+class MentionCoordinator(
+  private val formattingStore: FormattingStore,
+) {
+  private var indicators: LinkedHashSet<String> = linkedSetOf()
+  private var activeIndicator: String? = null
+  private var activeStart = -1
+  private var activeEnd = -1
+  private var activeText = ""
+
+  val isActive: Boolean get() = activeIndicator != null
+  val currentIndicator: String? get() = activeIndicator
+  val currentStart: Int get() = activeStart
+  val currentEnd: Int get() = activeEnd
+
+  fun containsIndicator(indicator: String): Boolean = indicator in indicators
+
+  fun setIndicators(newIndicators: List<String>): List<MentionEvent> {
+    val newSet = LinkedHashSet(newIndicators)
+    if (newSet == indicators) return emptyList()
+    indicators = newSet
+    val events = mutableListOf<MentionEvent>()
+    activeIndicator?.let { indicator ->
+      if (indicator !in indicators) {
+        events.addAll(clear(indicatorOverride = indicator))
+      }
+    }
+    return events
+  }
+
+  /**
+   * Re-evaluates the active mention based on the current cursor and text.
+   * Pass null [plainText] to force-clear (e.g. when the editable is absent).
+   */
+  fun update(
+    plainText: String?,
+    selStart: Int,
+    selEnd: Int,
+  ): List<MentionEvent> {
+    if (plainText == null || selStart != selEnd || selStart < 0 || selStart > plainText.length) {
+      return clear()
+    }
+
+    val candidate = detectCandidate(plainText, selStart) ?: return clear()
+    val events = mutableListOf<MentionEvent>()
+
+    if (activeIndicator != candidate.indicator || activeStart != candidate.start) {
+      activeIndicator?.let { events.add(MentionEvent.End(it)) }
+      activeIndicator = candidate.indicator
+      activeStart = candidate.start
+      events.add(MentionEvent.Start(candidate.indicator))
+    }
+
+    activeEnd = candidate.end
+    if (activeText != candidate.text) {
+      activeText = candidate.text
+      events.add(MentionEvent.Change(candidate.indicator, candidate.text))
+    }
+    return events
+  }
+
+  fun clear(
+    emit: Boolean = true,
+    indicatorOverride: String? = null,
+  ): List<MentionEvent> {
+    val indicator = indicatorOverride ?: activeIndicator
+    activeIndicator = null
+    activeStart = -1
+    activeEnd = -1
+    activeText = ""
+    return if (emit && indicator != null) listOf(MentionEvent.End(indicator)) else emptyList()
+  }
+
+  private fun detectCandidate(
+    plainText: String,
+    cursor: Int,
+  ): MentionCandidate? {
+    if (indicators.isEmpty()) return null
+    val start = WordsUtils.tokenStart(plainText, cursor)
+    val token = plainText.substring(start, cursor)
+    val indicator = indicators.firstOrNull { token.startsWith(it) } ?: return null
+    if (formattingStore.rangeOfType(StyleType.LINK, start) != null) return null
+
+    return MentionCandidate(
+      indicator = indicator,
+      start = start,
+      end = cursor,
+      text = token.substring(indicator.length),
+    )
+  }
+
+  private data class MentionCandidate(
+    val indicator: String,
+    val start: Int,
+    val end: Int,
+    val text: String,
+  )
+}

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

@@ -13,6 +13,11 @@ class OnChangeStateEvent(
   private val isStrikethrough: Boolean,
   private val isSpoiler: Boolean,
   private val isLink: Boolean,
+  private val headingLevel: Int,
+  private val isUnorderedList: Boolean,
+  private val unorderedListDepth: Int,
+  private val isOrderedList: Boolean,
+  private val orderedListDepth: Int,
 ) : Event<OnChangeStateEvent>(surfaceId, viewId) {
   override fun getEventName(): String = EVENT_NAME
 
@@ -42,6 +47,27 @@ class OnChangeStateEvent(
         "link",
         Arguments.createMap().apply { putBoolean("isActive", isLink) },
       )
+      putMap(
+        "heading",
+        Arguments.createMap().apply {
+          putBoolean("isActive", headingLevel > 0)
+          putInt("level", headingLevel)
+        },
+      )
+      putMap(
+        "unorderedList",
+        Arguments.createMap().apply {
+          putBoolean("isActive", isUnorderedList)
+          putInt("depth", unorderedListDepth)
+        },
+      )
+      putMap(
+        "orderedList",
+        Arguments.createMap().apply {
+          putBoolean("isActive", isOrderedList)
+          putInt("depth", orderedListDepth)
+        },
+      )
     }
 
   companion object {

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

@@ -17,6 +17,11 @@ class OnContextMenuItemPressEvent(
   private val isStrikethrough: Boolean,
   private val isSpoiler: Boolean,
   private val isLink: Boolean,
+  private val headingLevel: Int,
+  private val isUnorderedList: Boolean,
+  private val unorderedListDepth: Int,
+  private val isOrderedList: Boolean,
+  private val orderedListDepth: Int,
 ) : Event<OnContextMenuItemPressEvent>(surfaceId, viewId) {
   override fun getEventName(): String = EVENT_NAME
 
@@ -37,6 +42,27 @@ class OnContextMenuItemPressEvent(
           putMap("strikethrough", styleEntry(isStrikethrough))
           putMap("spoiler", styleEntry(isSpoiler))
           putMap("link", styleEntry(isLink))
+          putMap(
+            "heading",
+            Arguments.createMap().apply {
+              putBoolean("isActive", headingLevel > 0)
+              putInt("level", headingLevel)
+            },
+          )
+          putMap(
+            "unorderedList",
+            Arguments.createMap().apply {
+              putBoolean("isActive", isUnorderedList)
+              putInt("depth", unorderedListDepth)
+            },
+          )
+          putMap(
+            "orderedList",
+            Arguments.createMap().apply {
+              putBoolean("isActive", isOrderedList)
+              putInt("depth", orderedListDepth)
+            },
+          )
         },
       )
     }

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

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