react-native-enriched 0.2.1 → 0.4.0

package/android/src/main/java/com/swmansion/enriched/{EnrichedTextInputView.kt → textinput/EnrichedTextInputView.kt}

@@ -1,4 +1,4 @@
-package com.swmansion.enriched
+package com.swmansion.enriched.textinput
 
 import android.content.ClipData
 import android.content.ClipboardManager
@@ -13,12 +13,19 @@ import android.text.InputType
 import android.text.Spannable
 import android.util.AttributeSet
 import android.util.Log
+import android.util.Patterns
 import android.util.TypedValue
 import android.view.Gravity
 import android.view.MotionEvent
+import android.view.inputmethod.EditorInfo
+import android.view.inputmethod.InputConnection
 import android.view.inputmethod.InputMethodManager
 import androidx.appcompat.widget.AppCompatEditText
+import androidx.core.view.ViewCompat
+import androidx.core.view.inputmethod.EditorInfoCompat
+import androidx.core.view.inputmethod.InputConnectionCompat
 import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.common.ReactConstants
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.uimanager.StateWrapper
@@ -26,30 +33,38 @@ import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.views.text.ReactTypefaceUtils.applyStyles
 import com.facebook.react.views.text.ReactTypefaceUtils.parseFontStyle
 import com.facebook.react.views.text.ReactTypefaceUtils.parseFontWeight
-import com.swmansion.enriched.events.MentionHandler
-import com.swmansion.enriched.events.OnInputBlurEvent
-import com.swmansion.enriched.events.OnInputFocusEvent
-import com.swmansion.enriched.events.OnRequestHtmlResultEvent
-import com.swmansion.enriched.spans.EnrichedH1Span
-import com.swmansion.enriched.spans.EnrichedH2Span
-import com.swmansion.enriched.spans.EnrichedH3Span
-import com.swmansion.enriched.spans.EnrichedImageSpan
-import com.swmansion.enriched.spans.EnrichedSpans
-import com.swmansion.enriched.spans.interfaces.EnrichedSpan
-import com.swmansion.enriched.styles.InlineStyles
-import com.swmansion.enriched.styles.ListStyles
-import com.swmansion.enriched.styles.ParagraphStyles
-import com.swmansion.enriched.styles.ParametrizedStyles
-import com.swmansion.enriched.styles.HtmlStyle
-import com.swmansion.enriched.utils.EnrichedParser
-import com.swmansion.enriched.utils.EnrichedSelection
-import com.swmansion.enriched.utils.EnrichedSpanState
-import com.swmansion.enriched.utils.mergeSpannables
-import com.swmansion.enriched.watchers.EnrichedSpanWatcher
-import com.swmansion.enriched.watchers.EnrichedTextWatcher
+import com.swmansion.enriched.common.EnrichedConstants
+import com.swmansion.enriched.common.parser.EnrichedParser
+import com.swmansion.enriched.textinput.events.MentionHandler
+import com.swmansion.enriched.textinput.events.OnInputBlurEvent
+import com.swmansion.enriched.textinput.events.OnInputFocusEvent
+import com.swmansion.enriched.textinput.events.OnRequestHtmlResultEvent
+import com.swmansion.enriched.textinput.spans.EnrichedInputH1Span
+import com.swmansion.enriched.textinput.spans.EnrichedInputH2Span
+import com.swmansion.enriched.textinput.spans.EnrichedInputH3Span
+import com.swmansion.enriched.textinput.spans.EnrichedInputH4Span
+import com.swmansion.enriched.textinput.spans.EnrichedInputH5Span
+import com.swmansion.enriched.textinput.spans.EnrichedInputH6Span
+import com.swmansion.enriched.textinput.spans.EnrichedInputImageSpan
+import com.swmansion.enriched.textinput.spans.EnrichedSpans
+import com.swmansion.enriched.textinput.spans.interfaces.EnrichedInputSpan
+import com.swmansion.enriched.textinput.styles.HtmlStyle
+import com.swmansion.enriched.textinput.styles.InlineStyles
+import com.swmansion.enriched.textinput.styles.ListStyles
+import com.swmansion.enriched.textinput.styles.ParagraphStyles
+import com.swmansion.enriched.textinput.styles.ParametrizedStyles
+import com.swmansion.enriched.textinput.utils.EnrichedEditableFactory
+import com.swmansion.enriched.textinput.utils.EnrichedSelection
+import com.swmansion.enriched.textinput.utils.EnrichedSpanState
+import com.swmansion.enriched.textinput.utils.RichContentReceiver
+import com.swmansion.enriched.textinput.utils.mergeSpannables
+import com.swmansion.enriched.textinput.utils.setCheckboxClickListener
+import com.swmansion.enriched.textinput.watchers.EnrichedSpanWatcher
+import com.swmansion.enriched.textinput.watchers.EnrichedTextWatcher
+import java.util.regex.Pattern
+import java.util.regex.PatternSyntaxException
 import kotlin.math.ceil
 
-
 class EnrichedTextInputView : AppCompatEditText {
   var stateWrapper: StateWrapper? = null
   val selection: EnrichedSelection? = EnrichedSelection(this)
@@ -65,16 +80,19 @@ class EnrichedTextInputView : AppCompatEditText {
   val mentionHandler: MentionHandler? = MentionHandler(this)
   var htmlStyle: HtmlStyle = HtmlStyle(this, null)
     set(value) {
-        if (field != value) {
-            val prev = field
-            field = value
-            reApplyHtmlStyleForSpans(prev, value)
-        }
+      if (field != value) {
+        val prev = field
+        field = value
+        reApplyHtmlStyleForSpans(prev, value)
+      }
     }
+
+  var linkRegex: Pattern? = Patterns.WEB_URL
   var spanWatcher: EnrichedSpanWatcher? = null
   var layoutManager: EnrichedTextInputViewLayoutManager = EnrichedTextInputViewLayoutManager(this)
 
-  var shouldEmitHtml: Boolean = true
+  var shouldEmitHtml: Boolean = false
+  var shouldEmitOnChangeText: Boolean = false
   var experimentalSynchronousEvents: Boolean = false
 
   var fontSize: Float? = null
@@ -89,6 +107,7 @@ class EnrichedTextInputView : AppCompatEditText {
   private var defaultValueDirty: Boolean = false
 
   private var inputMethodManager: InputMethodManager? = null
+  private val spannableFactory = EnrichedTextInputSpannableFactory()
 
   constructor(context: Context) : super(context) {
     prepareComponent()
@@ -101,13 +120,33 @@ class EnrichedTextInputView : AppCompatEditText {
   constructor(context: Context, attrs: AttributeSet, defStyleAttr: Int) : super(
     context,
     attrs,
-    defStyleAttr
+    defStyleAttr,
   ) {
     prepareComponent()
   }
 
+  override fun onCreateInputConnection(outAttrs: EditorInfo): InputConnection? {
+    var inputConnection = super.onCreateInputConnection(outAttrs)
+    if (inputConnection != null) {
+      inputConnection =
+        EnrichedTextInputConnectionWrapper(
+          inputConnection,
+          context as ReactContext,
+          this,
+          experimentalSynchronousEvents,
+        )
+    }
+
+    return inputConnection
+  }
+
   init {
     inputMethodManager = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+    ViewCompat.setOnReceiveContentListener(
+      this,
+      RichContentReceiver.MIME_TYPES,
+      RichContentReceiver(this, context as ReactContext),
+    )
   }
 
   private fun prepareComponent() {
@@ -124,8 +163,15 @@ class EnrichedTextInputView : AppCompatEditText {
     setPadding(0, 0, 0, 0)
     setBackgroundColor(Color.TRANSPARENT)
 
-    addSpanWatcher(EnrichedSpanWatcher(this))
+    // Ensure that every time new editable is created, it has EnrichedSpanWatcher attached
+    val spanWatcher = EnrichedSpanWatcher(this)
+    this.spanWatcher = spanWatcher
+
+    setEditableFactory(EnrichedEditableFactory(spanWatcher))
     addTextChangedListener(EnrichedTextWatcher(this))
+
+    // Handle checkbox list item clicks
+    this.setCheckboxClickListener()
   }
 
   // https://github.com/facebook/react-native/blob/36df97f500aa0aa8031098caf7526db358b6ddc1/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactEditText.kt#L295C1-L296C1
@@ -138,31 +184,32 @@ class EnrichedTextInputView : AppCompatEditText {
         this.parent.requestDisallowInterceptTouchEvent(true)
       }
 
-      MotionEvent.ACTION_MOVE ->
+      MotionEvent.ACTION_MOVE -> {
         if (detectScrollMovement) {
           if (!canScrollVertically(-1) &&
             !canScrollVertically(1) &&
             !canScrollHorizontally(-1) &&
-            !canScrollHorizontally(1)) {
+            !canScrollHorizontally(1)
+          ) {
             // We cannot scroll, let parent views take care of these touches.
             this.parent.requestDisallowInterceptTouchEvent(false)
           }
           detectScrollMovement = false
         }
+      }
     }
 
     return super.onTouchEvent(ev)
   }
 
-  override fun canScrollVertically(direction: Int): Boolean {
-    return scrollEnabled
-  }
+  override fun canScrollVertically(direction: Int): Boolean = scrollEnabled
 
-  override fun canScrollHorizontally(direction: Int): Boolean {
-    return scrollEnabled
-  }
+  override fun canScrollHorizontally(direction: Int): Boolean = scrollEnabled
 
-  override fun onSelectionChanged(selStart: Int, selEnd: Int) {
+  override fun onSelectionChanged(
+    selStart: Int,
+    selEnd: Int,
+  ) {
     super.onSelectionChanged(selStart, selEnd)
     selection?.onSelection(selStart, selEnd)
   }
@@ -172,7 +219,11 @@ class EnrichedTextInputView : AppCompatEditText {
     inputMethodManager?.hideSoftInputFromWindow(windowToken, 0)
   }
 
-  override fun onFocusChanged(focused: Boolean, direction: Int, previouslyFocusedRect: Rect?) {
+  override fun onFocusChanged(
+    focused: Boolean,
+    direction: Int,
+    previouslyFocusedRect: Rect?,
+  ) {
     super.onFocusChanged(focused, direction, previouslyFocusedRect)
     val context = context as ReactContext
     val surfaceId = UIManagerHelper.getSurfaceId(context)
@@ -191,10 +242,6 @@ class EnrichedTextInputView : AppCompatEditText {
         handleCustomCopy()
         return true
       }
-      android.R.id.paste -> {
-        handleCustomPaste()
-        return true
-      }
     }
     return super.onTextContextMenuItem(id)
   }
@@ -214,16 +261,11 @@ class EnrichedTextInputView : AppCompatEditText {
     }
   }
 
-  private fun handleCustomPaste() {
-    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-    if (!clipboard.hasPrimaryClip()) return
-
-    val clip = clipboard.primaryClip
-    val item = clip?.getItemAt(0)
-    val htmlText = item?.htmlText
+  fun handleTextPaste(item: ClipData.Item) {
+    val htmlText = item.htmlText
     val currentText = text as Spannable
-    val start = selection?.start ?: 0
-    val end = selection?.end ?: 0
+    val start = selectionStart.coerceAtLeast(0)
+    val end = selectionEnd.coerceAtLeast(0)
 
     if (htmlText != null) {
       val parsedText = parseText(htmlText)
@@ -234,11 +276,14 @@ class EnrichedTextInputView : AppCompatEditText {
       }
     }
 
-    // Currently, we do not support pasting images
-    if (item?.text == null) return
+    if (item.text == null) return
+    val lengthBefore = currentText.length
     val finalText = currentText.mergeSpannables(start, end, item.text.toString())
     setValue(finalText)
-    parametrizedStyles?.detectAllLinks()
+
+    // Detect links in the newly pasted range
+    val finalEndIndex = start + finalText.length - lengthBefore
+    parametrizedStyles?.detectLinksInRange(finalText, start, finalEndIndex)
   }
 
   fun requestFocusProgrammatically() {
@@ -252,7 +297,7 @@ class EnrichedTextInputView : AppCompatEditText {
     if (!isHtml) return text
 
     try {
-      val parsed = EnrichedParser.fromHtml(text.toString(), htmlStyle, null)
+      val parsed = EnrichedParser.fromHtml(text.toString(), htmlStyle, spannableFactory)
       val withoutLastNewLine = parsed.trimEnd('\n')
       return withoutLastNewLine
     } catch (e: Exception) {
@@ -269,14 +314,43 @@ class EnrichedTextInputView : AppCompatEditText {
       setText(newText)
 
       observeAsyncImages()
-      // Assign SpanWatcher one more time as our previous spannable has been replaced
-      addSpanWatcher(EnrichedSpanWatcher(this))
 
       // Scroll to the last line of text
       setSelection(text?.length ?: 0)
     }
   }
 
+  fun setCustomSelection(
+    visibleStart: Int,
+    visibleEnd: Int,
+  ) {
+    val actualStart = getActualIndex(visibleStart)
+    val actualEnd = getActualIndex(visibleEnd)
+
+    setSelection(actualStart, actualEnd)
+  }
+
+  // Helper: Walks through the string skipping ZWSPs to find the Nth visible character
+  private fun getActualIndex(visibleIndex: Int): Int {
+    val currentText = text as Spannable
+    var currentVisibleCount = 0
+    var actualIndex = 0
+
+    while (actualIndex < currentText.length) {
+      if (currentVisibleCount == visibleIndex) {
+        return actualIndex
+      }
+
+      // If the current char is not a hidden space, it counts towards our visible index
+      if (currentText[actualIndex] != EnrichedConstants.ZWS) {
+        currentVisibleCount++
+      }
+      actualIndex++
+    }
+
+    return actualIndex
+  }
+
   /**
    * Finds all async images in the current text and sets up listeners
    * to redraw the text layout when they finish downloading.
@@ -284,7 +358,7 @@ class EnrichedTextInputView : AppCompatEditText {
   private fun observeAsyncImages() {
     val liveText = text ?: return
 
-    val spans = liveText.getSpans(0, liveText.length, EnrichedImageSpan::class.java)
+    val spans = liveText.getSpans(0, liveText.length, EnrichedInputImageSpan::class.java)
 
     for (span in spans) {
       span.observeAsyncDrawableLoaded(liveText)
@@ -376,19 +450,50 @@ class EnrichedTextInputView : AppCompatEditText {
   }
 
   fun setAutoCapitalize(flagName: String?) {
-    val flag = when (flagName) {
-      "none" -> InputType.TYPE_NULL
-      "sentences" -> InputType.TYPE_TEXT_FLAG_CAP_SENTENCES
-      "words" -> InputType.TYPE_TEXT_FLAG_CAP_WORDS
-      "characters" -> InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS
-      else -> InputType.TYPE_NULL
+    val flag =
+      when (flagName) {
+        "none" -> InputType.TYPE_NULL
+        "sentences" -> InputType.TYPE_TEXT_FLAG_CAP_SENTENCES
+        "words" -> InputType.TYPE_TEXT_FLAG_CAP_WORDS
+        "characters" -> InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS
+        else -> InputType.TYPE_NULL
+      }
+
+    inputType = (
+      inputType and
+        InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS.inv() and
+        InputType.TYPE_TEXT_FLAG_CAP_WORDS.inv() and
+        InputType.TYPE_TEXT_FLAG_CAP_SENTENCES.inv()
+    ) or if (flag == InputType.TYPE_NULL) 0 else flag
+  }
+
+  fun setLinkRegex(config: ReadableMap?) {
+    val patternStr = config?.getString("pattern")
+    if (patternStr == null) {
+      linkRegex = Patterns.WEB_URL
+      return
     }
 
-    inputType = (inputType and
-      InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS.inv() and
-      InputType.TYPE_TEXT_FLAG_CAP_WORDS.inv() and
-      InputType.TYPE_TEXT_FLAG_CAP_SENTENCES.inv()
-      ) or if (flag == InputType.TYPE_NULL) 0 else flag
+    if (config.getBoolean("isDefault")) {
+      linkRegex = Patterns.WEB_URL
+      return
+    }
+
+    if (config.getBoolean("isDisabled")) {
+      linkRegex = null
+      return
+    }
+
+    var flags = 0
+    if (config.getBoolean("caseInsensitive")) flags = flags or Pattern.CASE_INSENSITIVE
+    if (config.getBoolean("dotAll")) flags = flags or Pattern.DOTALL
+
+    try {
+      linkRegex = Pattern.compile("(?s).*?($patternStr).*", flags)
+    } catch (e: PatternSyntaxException) {
+      Log.w("EnrichedTextInputView", "Invalid link regex pattern: $patternStr")
+      linkRegex = Patterns.WEB_URL
+    }
   }
 
   // https://github.com/facebook/react-native/blob/36df97f500aa0aa8031098caf7526db358b6ddc1/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactEditText.kt#L283C2-L284C1
@@ -397,9 +502,7 @@ class EnrichedTextInputView : AppCompatEditText {
   // next layout() to be called. However, we do not perform a layout() after a requestLayout(), so
   // we need to override isLayoutRequested to force EditText to scroll to the end of the new text
   // immediately.
-  override fun isLayoutRequested(): Boolean {
-    return false
-  }
+  override fun isLayoutRequested(): Boolean = false
 
   fun afterUpdateTransaction() {
     updateTypeface()
@@ -439,58 +542,76 @@ class EnrichedTextInputView : AppCompatEditText {
       EnrichedSpans.H1 -> paragraphStyles?.toggleStyle(EnrichedSpans.H1)
       EnrichedSpans.H2 -> paragraphStyles?.toggleStyle(EnrichedSpans.H2)
       EnrichedSpans.H3 -> paragraphStyles?.toggleStyle(EnrichedSpans.H3)
+      EnrichedSpans.H4 -> paragraphStyles?.toggleStyle(EnrichedSpans.H4)
+      EnrichedSpans.H5 -> paragraphStyles?.toggleStyle(EnrichedSpans.H5)
+      EnrichedSpans.H6 -> paragraphStyles?.toggleStyle(EnrichedSpans.H6)
       EnrichedSpans.CODE_BLOCK -> paragraphStyles?.toggleStyle(EnrichedSpans.CODE_BLOCK)
       EnrichedSpans.BLOCK_QUOTE -> paragraphStyles?.toggleStyle(EnrichedSpans.BLOCK_QUOTE)
       EnrichedSpans.ORDERED_LIST -> listStyles?.toggleStyle(EnrichedSpans.ORDERED_LIST)
       EnrichedSpans.UNORDERED_LIST -> listStyles?.toggleStyle(EnrichedSpans.UNORDERED_LIST)
+      EnrichedSpans.CHECKBOX_LIST -> listStyles?.toggleStyle(EnrichedSpans.CHECKBOX_LIST)
       else -> Log.w("EnrichedTextInputView", "Unknown style: $name")
     }
 
     layoutManager.invalidateLayout()
   }
 
-  private fun removeStyle(name: String, start: Int, end: Int): Boolean {
-    val removed = when (name) {
-      EnrichedSpans.BOLD -> inlineStyles?.removeStyle(EnrichedSpans.BOLD, start, end)
-      EnrichedSpans.ITALIC -> inlineStyles?.removeStyle(EnrichedSpans.ITALIC, start, end)
-      EnrichedSpans.UNDERLINE -> inlineStyles?.removeStyle(EnrichedSpans.UNDERLINE, start, end)
-      EnrichedSpans.STRIKETHROUGH -> inlineStyles?.removeStyle(EnrichedSpans.STRIKETHROUGH, start, end)
-      EnrichedSpans.INLINE_CODE -> inlineStyles?.removeStyle(EnrichedSpans.INLINE_CODE, start, end)
-      EnrichedSpans.H1 -> paragraphStyles?.removeStyle(EnrichedSpans.H1, start, end)
-      EnrichedSpans.H2 -> paragraphStyles?.removeStyle(EnrichedSpans.H2, start, end)
-      EnrichedSpans.H3 -> paragraphStyles?.removeStyle(EnrichedSpans.H3, start, end)
-      EnrichedSpans.CODE_BLOCK -> paragraphStyles?.removeStyle(EnrichedSpans.CODE_BLOCK, start, end)
-      EnrichedSpans.BLOCK_QUOTE -> paragraphStyles?.removeStyle(EnrichedSpans.BLOCK_QUOTE, start, end)
-      EnrichedSpans.ORDERED_LIST -> listStyles?.removeStyle(EnrichedSpans.ORDERED_LIST, start, end)
-      EnrichedSpans.UNORDERED_LIST -> listStyles?.removeStyle(EnrichedSpans.UNORDERED_LIST, start, end)
-      EnrichedSpans.LINK -> parametrizedStyles?.removeStyle(EnrichedSpans.LINK, start, end)
-      EnrichedSpans.IMAGE -> parametrizedStyles?.removeStyle(EnrichedSpans.IMAGE, start, end)
-      EnrichedSpans.MENTION -> parametrizedStyles?.removeStyle(EnrichedSpans.MENTION, start, end)
-      else -> false
-    }
+  private fun removeStyle(
+    name: String,
+    start: Int,
+    end: Int,
+  ): Boolean {
+    val removed =
+      when (name) {
+        EnrichedSpans.BOLD -> inlineStyles?.removeStyle(EnrichedSpans.BOLD, start, end)
+        EnrichedSpans.ITALIC -> inlineStyles?.removeStyle(EnrichedSpans.ITALIC, start, end)
+        EnrichedSpans.UNDERLINE -> inlineStyles?.removeStyle(EnrichedSpans.UNDERLINE, start, end)
+        EnrichedSpans.STRIKETHROUGH -> inlineStyles?.removeStyle(EnrichedSpans.STRIKETHROUGH, start, end)
+        EnrichedSpans.INLINE_CODE -> inlineStyles?.removeStyle(EnrichedSpans.INLINE_CODE, start, end)
+        EnrichedSpans.H1 -> paragraphStyles?.removeStyle(EnrichedSpans.H1, start, end)
+        EnrichedSpans.H2 -> paragraphStyles?.removeStyle(EnrichedSpans.H2, start, end)
+        EnrichedSpans.H3 -> paragraphStyles?.removeStyle(EnrichedSpans.H3, start, end)
+        EnrichedSpans.H4 -> paragraphStyles?.removeStyle(EnrichedSpans.H4, start, end)
+        EnrichedSpans.H5 -> paragraphStyles?.removeStyle(EnrichedSpans.H5, start, end)
+        EnrichedSpans.H6 -> paragraphStyles?.removeStyle(EnrichedSpans.H6, start, end)
+        EnrichedSpans.CODE_BLOCK -> paragraphStyles?.removeStyle(EnrichedSpans.CODE_BLOCK, start, end)
+        EnrichedSpans.BLOCK_QUOTE -> paragraphStyles?.removeStyle(EnrichedSpans.BLOCK_QUOTE, start, end)
+        EnrichedSpans.ORDERED_LIST -> listStyles?.removeStyle(EnrichedSpans.ORDERED_LIST, start, end)
+        EnrichedSpans.UNORDERED_LIST -> listStyles?.removeStyle(EnrichedSpans.UNORDERED_LIST, start, end)
+        EnrichedSpans.CHECKBOX_LIST -> listStyles?.removeStyle(EnrichedSpans.CHECKBOX_LIST, start, end)
+        EnrichedSpans.LINK -> parametrizedStyles?.removeStyle(EnrichedSpans.LINK, start, end)
+        EnrichedSpans.IMAGE -> parametrizedStyles?.removeStyle(EnrichedSpans.IMAGE, start, end)
+        EnrichedSpans.MENTION -> parametrizedStyles?.removeStyle(EnrichedSpans.MENTION, start, end)
+        else -> false
+      }
 
     return removed == true
   }
 
   private fun getTargetRange(name: String): Pair<Int, Int> {
-    val result = when (name) {
-      EnrichedSpans.BOLD -> inlineStyles?.getStyleRange()
-      EnrichedSpans.ITALIC -> inlineStyles?.getStyleRange()
-      EnrichedSpans.UNDERLINE -> inlineStyles?.getStyleRange()
-      EnrichedSpans.STRIKETHROUGH -> inlineStyles?.getStyleRange()
-      EnrichedSpans.INLINE_CODE -> inlineStyles?.getStyleRange()
-      EnrichedSpans.H1 -> paragraphStyles?.getStyleRange()
-      EnrichedSpans.H2 -> paragraphStyles?.getStyleRange()
-      EnrichedSpans.H3 -> paragraphStyles?.getStyleRange()
-      EnrichedSpans.CODE_BLOCK -> paragraphStyles?.getStyleRange()
-      EnrichedSpans.BLOCK_QUOTE -> paragraphStyles?.getStyleRange()
-      EnrichedSpans.ORDERED_LIST -> listStyles?.getStyleRange()
-      EnrichedSpans.UNORDERED_LIST -> listStyles?.getStyleRange()
-      EnrichedSpans.LINK -> parametrizedStyles?.getStyleRange()
-      EnrichedSpans.IMAGE -> parametrizedStyles?.getStyleRange()
-      EnrichedSpans.MENTION -> parametrizedStyles?.getStyleRange()
-      else -> Pair(0, 0)
-    }
+    val result =
+      when (name) {
+        EnrichedSpans.BOLD -> inlineStyles?.getStyleRange()
+        EnrichedSpans.ITALIC -> inlineStyles?.getStyleRange()
+        EnrichedSpans.UNDERLINE -> inlineStyles?.getStyleRange()
+        EnrichedSpans.STRIKETHROUGH -> inlineStyles?.getStyleRange()
+        EnrichedSpans.INLINE_CODE -> inlineStyles?.getStyleRange()
+        EnrichedSpans.H1 -> paragraphStyles?.getStyleRange()
+        EnrichedSpans.H2 -> paragraphStyles?.getStyleRange()
+        EnrichedSpans.H3 -> paragraphStyles?.getStyleRange()
+        EnrichedSpans.H4 -> paragraphStyles?.getStyleRange()
+        EnrichedSpans.H5 -> paragraphStyles?.getStyleRange()
+        EnrichedSpans.H6 -> paragraphStyles?.getStyleRange()
+        EnrichedSpans.CODE_BLOCK -> paragraphStyles?.getStyleRange()
+        EnrichedSpans.BLOCK_QUOTE -> paragraphStyles?.getStyleRange()
+        EnrichedSpans.ORDERED_LIST -> listStyles?.getStyleRange()
+        EnrichedSpans.UNORDERED_LIST -> listStyles?.getStyleRange()
+        EnrichedSpans.CHECKBOX_LIST -> listStyles?.getStyleRange()
+        EnrichedSpans.LINK -> parametrizedStyles?.getStyleRange()
+        EnrichedSpans.IMAGE -> parametrizedStyles?.getStyleRange()
+        EnrichedSpans.MENTION -> parametrizedStyles?.getStyleRange()
+        else -> Pair(0, 0)
+      }
 
     return result ?: Pair(0, 0)
   }
@@ -524,11 +645,12 @@ class EnrichedTextInputView : AppCompatEditText {
 
       val lengthAfter = text?.length ?: 0
       val charactersRemoved = lengthBefore - lengthAfter
-      val finalEnd = if (charactersRemoved > 0) {
-        (end - charactersRemoved).coerceAtLeast(0)
-      } else {
-        end
-      }
+      val finalEnd =
+        if (charactersRemoved > 0) {
+          (end - charactersRemoved).coerceAtLeast(0)
+        } else {
+          end
+        }
 
       val finalStart = start.coerceAtLeast(0).coerceAtMost(finalEnd)
       selection?.onSelection(finalStart, finalEnd)
@@ -537,12 +659,6 @@ class EnrichedTextInputView : AppCompatEditText {
     return true
   }
 
-  private fun addSpanWatcher(watcher: EnrichedSpanWatcher) {
-    val spannable = text as Spannable
-    spannable.setSpan(watcher, 0, spannable.length, Spannable.SPAN_INCLUSIVE_INCLUSIVE)
-    spanWatcher = watcher
-  }
-
   fun verifyAndToggleStyle(name: String) {
     val isValid = verifyStyle(name)
     if (!isValid) return
@@ -550,14 +666,30 @@ class EnrichedTextInputView : AppCompatEditText {
     toggleStyle(name)
   }
 
-  fun addLink(start: Int, end: Int, text: String, url: String) {
+  fun toggleCheckboxListItem(checked: Boolean) {
+    val isValid = verifyStyle(EnrichedSpans.CHECKBOX_LIST)
+    if (!isValid) return
+
+    listStyles?.toggleCheckboxListStyle(checked)
+  }
+
+  fun addLink(
+    start: Int,
+    end: Int,
+    text: String,
+    url: String,
+  ) {
     val isValid = verifyStyle(EnrichedSpans.LINK)
     if (!isValid) return
 
     parametrizedStyles?.setLinkSpan(start, end, text, url)
   }
 
-  fun addImage(src: String, width: Float, height: Float) {
+  fun addImage(
+    src: String,
+    width: Float,
+    height: Float,
+  ) {
     val isValid = verifyStyle(EnrichedSpans.IMAGE)
     if (!isValid) return
 
@@ -572,7 +704,11 @@ class EnrichedTextInputView : AppCompatEditText {
     parametrizedStyles?.startMention(indicator)
   }
 
-  fun addMention(indicator: String, text: String, attributes: Map<String, String>) {
+  fun addMention(
+    indicator: String,
+    text: String,
+    attributes: Map<String, String>,
+  ) {
     val isValid = verifyStyle(EnrichedSpans.MENTION)
     if (!isValid) return
 
@@ -580,11 +716,12 @@ class EnrichedTextInputView : AppCompatEditText {
   }
 
   fun requestHTML(requestId: Int) {
-    val html = try {
-      EnrichedParser.toHtmlWithDefault(text)
-    } catch (e: Exception) {
-      null
-    }
+    val html =
+      try {
+        EnrichedParser.toHtmlWithDefault(text)
+      } catch (e: Exception) {
+        null
+      }
 
     val reactContext = context as ReactContext
     val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
@@ -604,45 +741,69 @@ class EnrichedTextInputView : AppCompatEditText {
     }
   }
 
-    private fun forceScrollToSelection() {
-      val textLayout = layout ?: return
-      val cursorOffset = selectionStart
-      if (cursorOffset <= 0) return
+  private fun forceScrollToSelection() {
+    val textLayout = layout ?: return
+    val cursorOffset = selectionStart
+    if (cursorOffset <= 0) return
 
-      val selectedLineIndex = textLayout.getLineForOffset(cursorOffset)
-      val selectedLineTop = textLayout.getLineTop(selectedLineIndex)
-      val selectedLineBottom = textLayout.getLineBottom(selectedLineIndex)
-      val visibleTextHeight = height - paddingTop - paddingBottom
+    val selectedLineIndex = textLayout.getLineForOffset(cursorOffset)
+    val selectedLineTop = textLayout.getLineTop(selectedLineIndex)
+    val selectedLineBottom = textLayout.getLineBottom(selectedLineIndex)
+    val visibleTextHeight = height - paddingTop - paddingBottom
 
-      if (visibleTextHeight <= 0) return
+    if (visibleTextHeight <= 0) return
 
-      val visibleTop = scrollY
-      val visibleBottom = scrollY + visibleTextHeight
-      var targetScrollY = scrollY
+    val visibleTop = scrollY
+    val visibleBottom = scrollY + visibleTextHeight
+    var targetScrollY = scrollY
 
-      if (selectedLineTop < visibleTop) {
-        targetScrollY = selectedLineTop
-      } else if (selectedLineBottom > visibleBottom) {
-        targetScrollY = selectedLineBottom - visibleTextHeight
-      }
+    if (selectedLineTop < visibleTop) {
+      targetScrollY = selectedLineTop
+    } else if (selectedLineBottom > visibleBottom) {
+      targetScrollY = selectedLineBottom - visibleTextHeight
+    }
 
-      val maxScrollY = (textLayout.height - visibleTextHeight).coerceAtLeast(0)
-      targetScrollY = targetScrollY.coerceIn(0, maxScrollY)
-      scrollTo(scrollX, targetScrollY)
+    val maxScrollY = (textLayout.height - visibleTextHeight).coerceAtLeast(0)
+    targetScrollY = targetScrollY.coerceIn(0, maxScrollY)
+    scrollTo(scrollX, targetScrollY)
+  }
+
+  private fun isHeadingBold(
+    style: HtmlStyle,
+    span: EnrichedInputSpan,
+  ): Boolean =
+    when (span) {
+      is EnrichedInputH1Span -> style.h1Bold
+      is EnrichedInputH2Span -> style.h2Bold
+      is EnrichedInputH3Span -> style.h3Bold
+      is EnrichedInputH4Span -> style.h4Bold
+      is EnrichedInputH5Span -> style.h5Bold
+      is EnrichedInputH6Span -> style.h6Bold
+      else -> false
     }
 
-  private fun reApplyHtmlStyleForSpans(previousHtmlStyle: HtmlStyle, nextHtmlStyle: HtmlStyle) {
-    val shouldRemoveBoldSpanFromH1Span = !previousHtmlStyle.h1Bold && nextHtmlStyle.h1Bold
-    val shouldRemoveBoldSpanFromH2Span = !previousHtmlStyle.h2Bold && nextHtmlStyle.h2Bold
-    val shouldRemoveBoldSpanFromH3Span = !previousHtmlStyle.h3Bold && nextHtmlStyle.h3Bold
+  private fun shouldRemoveBoldFromHeading(
+    span: EnrichedInputSpan,
+    prevStyle: HtmlStyle,
+    nextStyle: HtmlStyle,
+  ): Boolean {
+    val wasBold = isHeadingBold(prevStyle, span)
+    val isNowBold = isHeadingBold(nextStyle, span)
 
+    return !wasBold && isNowBold
+  }
+
+  private fun reApplyHtmlStyleForSpans(
+    previousHtmlStyle: HtmlStyle,
+    nextHtmlStyle: HtmlStyle,
+  ) {
     val spannable = text as? Spannable ?: return
     if (spannable.isEmpty()) return
 
     var shouldEmitStateChange = false
 
     runAsATransaction {
-      val spans = spannable.getSpans(0, spannable.length, EnrichedSpan::class.java)
+      val spans = spannable.getSpans(0, spannable.length, EnrichedInputSpan::class.java)
       for (span in spans) {
         if (!span.dependsOnHtmlStyle) continue
 
@@ -652,7 +813,8 @@ class EnrichedTextInputView : AppCompatEditText {
 
         if (start == -1 || end == -1) continue
 
-        if ((span is EnrichedH1Span && shouldRemoveBoldSpanFromH1Span) || (span is EnrichedH2Span && shouldRemoveBoldSpanFromH2Span) || (span is EnrichedH3Span && shouldRemoveBoldSpanFromH3Span)) {
+        // Check if we need to remove explicit bold spans
+        if (shouldRemoveBoldFromHeading(span, previousHtmlStyle, nextHtmlStyle)) {
           val isRemoved = removeStyle(EnrichedSpans.BOLD, start, end)
           if (isRemoved) shouldEmitStateChange = true
         }
@@ -673,6 +835,9 @@ class EnrichedTextInputView : AppCompatEditText {
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
 
+    // https://github.com/facebook/react-native/blob/36df97f500aa0aa8031098caf7526db358b6ddc1/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactEditText.kt#L946
+    super.setTextIsSelectable(true)
+
     if (autoFocus && !didAttachToWindow) {
       requestFocusProgrammatically()
     }