react-native-enriched 0.2.0 → 0.3.0

package/android/src/main/java/com/swmansion/enriched/EnrichedTextInputView.kt

@@ -13,12 +13,16 @@ 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 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
@@ -29,22 +33,30 @@ 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.HtmlStyle
 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.EnrichedConstants
+import com.swmansion.enriched.utils.EnrichedEditableFactory
 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 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)
@@ -59,10 +71,20 @@ 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)
+      }
+    }
+
+  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,11 +111,26 @@ 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
   }
@@ -112,7 +149,11 @@ 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))
   }
 
@@ -126,31 +167,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)
   }
@@ -160,7 +202,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)
@@ -179,6 +225,7 @@ class EnrichedTextInputView : AppCompatEditText {
         handleCustomCopy()
         return true
       }
+
       android.R.id.paste -> {
         handleCustomPaste()
         return true
@@ -224,9 +271,13 @@ class EnrichedTextInputView : AppCompatEditText {
 
     // Currently, we do not support pasting images
     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() {
@@ -257,14 +308,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.
@@ -335,6 +415,7 @@ class EnrichedTextInputView : AppCompatEditText {
     // This ensured that newly created spans will take the new font size into account
     htmlStyle.invalidateStyles()
     layoutManager.invalidateLayout()
+    forceScrollToSelection()
   }
 
   fun setFontFamily(family: String?) {
@@ -363,19 +444,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
+    }
+
+    if (config.getBoolean("isDefault")) {
+      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("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
@@ -384,9 +496,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()
@@ -426,6 +536,9 @@ 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)
@@ -436,48 +549,60 @@ class EnrichedTextInputView : AppCompatEditText {
     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.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.LINK -> parametrizedStyles?.getStyleRange()
+        EnrichedSpans.IMAGE -> parametrizedStyles?.getStyleRange()
+        EnrichedSpans.MENTION -> parametrizedStyles?.getStyleRange()
+        else -> Pair(0, 0)
+      }
 
     return result ?: Pair(0, 0)
   }
@@ -511,11 +636,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)
@@ -524,12 +650,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
@@ -537,14 +657,23 @@ class EnrichedTextInputView : AppCompatEditText {
     toggleStyle(name)
   }
 
-  fun addLink(start: Int, end: Int, text: String, url: String) {
+  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
 
@@ -559,13 +688,31 @@ 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
 
     parametrizedStyles?.setMentionSpan(text, indicator, attributes)
   }
 
+  fun requestHTML(requestId: Int) {
+    val html =
+      try {
+        EnrichedParser.toHtmlWithDefault(text)
+      } catch (e: Exception) {
+        null
+      }
+
+    val reactContext = context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+    dispatcher?.dispatchEvent(OnRequestHtmlResultEvent(surfaceId, id, requestId, html, experimentalSynchronousEvents))
+  }
+
   // Sometimes setting up style triggers many changes in sequence
   // Eg. removing conflicting styles -> changing text -> applying spans
   // In such scenario we want to prevent from handling side effects (eg. onTextChanged)
@@ -578,9 +725,83 @@ class EnrichedTextInputView : AppCompatEditText {
     }
   }
 
+  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
+
+    if (visibleTextHeight <= 0) return
+
+    val visibleTop = scrollY
+    val visibleBottom = scrollY + visibleTextHeight
+    var targetScrollY = scrollY
+
+    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)
+  }
+
+  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
+
+    val spannable = text as? Spannable ?: return
+    if (spannable.isEmpty()) return
+
+    var shouldEmitStateChange = false
+
+    runAsATransaction {
+      val spans = spannable.getSpans(0, spannable.length, EnrichedSpan::class.java)
+      for (span in spans) {
+        if (!span.dependsOnHtmlStyle) continue
+
+        val start = spannable.getSpanStart(span)
+        val end = spannable.getSpanEnd(span)
+        val flags = spannable.getSpanFlags(span)
+
+        if (start == -1 || end == -1) continue
+
+        if ((span is EnrichedH1Span && shouldRemoveBoldSpanFromH1Span) || (span is EnrichedH2Span && shouldRemoveBoldSpanFromH2Span) ||
+          (span is EnrichedH3Span && shouldRemoveBoldSpanFromH3Span)
+        ) {
+          val isRemoved = removeStyle(EnrichedSpans.BOLD, start, end)
+          if (isRemoved) shouldEmitStateChange = true
+        }
+
+        spannable.removeSpan(span)
+        val newSpan = span.rebuildWithStyle(htmlStyle)
+        spannable.setSpan(newSpan, start, end, flags)
+      }
+
+      if (shouldEmitStateChange) {
+        selection?.validateStyles()
+      }
+    }
+    layoutManager.invalidateLayout()
+    forceScrollToSelection()
+  }
+
   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()
     }

package/android/src/main/java/com/swmansion/enriched/EnrichedTextInputViewLayoutManager.kt

@@ -2,7 +2,9 @@ package com.swmansion.enriched
 
 import com.facebook.react.bridge.Arguments
 
-class EnrichedTextInputViewLayoutManager(private val view: EnrichedTextInputView) {
+class EnrichedTextInputViewLayoutManager(
+  private val view: EnrichedTextInputView,
+) {
   private var forceHeightRecalculationCounter: Int = 0
 
   fun invalidateLayout() {