react-native-enriched 0.0.0 → 0.1.1

package/android/src/main/java/com/swmansion/enriched/utils/EnrichedSelection.kt

@@ -0,0 +1,285 @@
+package com.swmansion.enriched.utils
+
+import android.text.Editable
+import android.text.Spannable
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.EnrichedTextInputView
+import com.swmansion.enriched.events.OnChangeSelectionEvent
+import com.swmansion.enriched.events.OnLinkDetectedEvent
+import com.swmansion.enriched.events.OnMentionDetectedEvent
+import com.swmansion.enriched.spans.EnrichedLinkSpan
+import com.swmansion.enriched.spans.EnrichedMentionSpan
+import com.swmansion.enriched.spans.EnrichedSpans
+import org.json.JSONObject
+
+class EnrichedSelection(private val view: EnrichedTextInputView) {
+  var start: Int = 0
+  var end: Int = 0
+
+  private var previousLinkDetectedEvent: MutableMap<String, String> = mutableMapOf("text" to "", "url" to "")
+  private var previousMentionDetectedEvent: MutableMap<String, String> = mutableMapOf("text" to "", "payload" to "")
+
+  fun onSelection(selStart: Int, selEnd: Int) {
+    var shouldValidateStyles = false
+    var newStart = start
+    var newEnd = end
+
+    if (selStart != -1 && selStart != newStart) {
+      newStart = selStart
+      shouldValidateStyles = true
+    }
+
+    if (selEnd != -1 && selEnd != newEnd) {
+      newEnd = selEnd
+      shouldValidateStyles = true
+    }
+
+    val textLength = view.text?.length ?: 0
+    val finalStart = newStart.coerceAtMost(newEnd).coerceAtLeast(0).coerceAtMost(textLength)
+    val finalEnd = newEnd.coerceAtLeast(newStart).coerceAtLeast(0).coerceAtMost(textLength)
+
+    if (isZeroWidthSelection(finalStart, finalEnd) && !view.isSettingValue) {
+      view.setSelection(finalStart + 1)
+      shouldValidateStyles = false
+    }
+
+    if (!shouldValidateStyles) return
+
+    start = finalStart
+    end = finalEnd
+    validateStyles()
+    emitSelectionChangeEvent(view.text, finalStart, finalEnd)
+  }
+
+  private fun isZeroWidthSelection(start: Int, end: Int): Boolean {
+    val text = view.text ?: return false
+
+    if (start != end) {
+      return text.substring(start, end) == "\u200B"
+    }
+
+    val isNewLine = if (start > 0 ) text.substring(start - 1, start) == "\n" else true
+    val isNextCharacterZeroWidth = if (start < text.length) {
+      text.substring(start, start + 1) == "\u200B"
+    } else {
+      false
+    }
+
+    return isNewLine && isNextCharacterZeroWidth
+  }
+
+  fun validateStyles() {
+    val state = view.spanState ?: return
+
+    // We don't validate inline styles when removing many characters at once
+    // We don't want to remove styles on auto-correction
+    // If user removes many characters at once, we want to keep the styles config
+    if (!view.isRemovingMany) {
+      for ((style, config) in EnrichedSpans.inlineSpans) {
+        state.setStart(style, getInlineStyleStart(config.clazz))
+      }
+    } else {
+      view.isRemovingMany = false
+    }
+
+    for ((style, config) in EnrichedSpans.paragraphSpans) {
+      state.setStart(style, getParagraphStyleStart(config.clazz))
+    }
+
+    for ((style, config) in EnrichedSpans.listSpans) {
+      state.setStart(style, getListStyleStart(config.clazz))
+    }
+
+    for ((style, config) in EnrichedSpans.parametrizedStyles) {
+      state.setStart(style, getParametrizedStyleStart(config.clazz))
+    }
+  }
+
+  fun getInlineSelection(): Pair<Int, Int> {
+    val finalStart = start.coerceAtMost(end).coerceAtLeast(0)
+    val finalEnd = end.coerceAtLeast(start).coerceAtLeast(0)
+
+    return Pair(finalStart, finalEnd)
+  }
+
+  private fun <T>getInlineStyleStart(type: Class<T>): Int? {
+    val (start, end) = getInlineSelection()
+    val spannable = view.text as Spannable
+    val spans = spannable.getSpans(start, end, type)
+    var styleStart: Int? = null
+
+    for (span in spans) {
+      val spanStart = spannable.getSpanStart(span)
+      val spanEnd = spannable.getSpanEnd(span)
+
+      if (start == end && start == spanStart) {
+        styleStart = null
+      } else if (start >= spanStart && end <= spanEnd) {
+        styleStart = spanStart
+      }
+    }
+
+    return styleStart
+  }
+
+  fun getParagraphSelection(): Pair<Int, Int> {
+    val (currentStart, currentEnd) = getInlineSelection()
+    val spannable = view.text as Spannable
+    return spannable.getParagraphBounds(currentStart, currentEnd)
+  }
+
+  private fun <T>getParagraphStyleStart(type: Class<T>): Int? {
+    val (start, end) = getParagraphSelection()
+    val spannable = view.text as Spannable
+    val spans = spannable.getSpans(start, end, type)
+    var styleStart: Int? = null
+
+    for (span in spans) {
+      val spanStart = spannable.getSpanStart(span)
+      val spanEnd = spannable.getSpanEnd(span)
+
+      if (start >= spanStart && end <= spanEnd) {
+        styleStart = spanStart
+        break
+      }
+    }
+
+    return styleStart
+  }
+
+  private fun <T>getListStyleStart(type: Class<T>): Int? {
+    val (start, end) = getParagraphSelection()
+    val spannable = view.text as Spannable
+    var styleStart: Int? = null
+
+    var paragraphStart = start
+    val paragraphs = spannable.substring(start, end).split("\n")
+    pi@ for (paragraph in paragraphs) {
+      val paragraphEnd = paragraphStart + paragraph.length
+      val spans = spannable.getSpans(paragraphStart, paragraphEnd, type)
+
+      for (span in spans) {
+        val spanStart = spannable.getSpanStart(span)
+        val spanEnd = spannable.getSpanEnd(span)
+
+        if (spanStart == paragraphStart && spanEnd == paragraphEnd) {
+          styleStart = spanStart
+          paragraphStart = paragraphEnd + 1
+          continue@pi
+        }
+      }
+
+      styleStart = null
+      break
+    }
+
+    return styleStart
+  }
+
+  private fun <T>getParametrizedStyleStart(type: Class<T>): Int? {
+    val (start, end) = getInlineSelection()
+    val spannable = view.text as Spannable
+    val spans = spannable.getSpans(start, end, type)
+    val isLinkType = type == EnrichedLinkSpan::class.java
+    val isMentionType = type == EnrichedMentionSpan::class.java
+
+    if (isLinkType && spans.isEmpty()) {
+      emitLinkDetectedEvent(spannable, null, start, end)
+      return null
+    }
+
+    if (isMentionType && spans.isEmpty()) {
+      emitMentionDetectedEvent(spannable, null, start, end)
+      return null
+    }
+
+    for (span in spans) {
+      val spanStart = spannable.getSpanStart(span)
+      val spanEnd = spannable.getSpanEnd(span)
+
+      if (start >= spanStart && end <= spanEnd) {
+        if (isLinkType && span is EnrichedLinkSpan) {
+          emitLinkDetectedEvent(spannable, span, spanStart, spanEnd)
+        } else if (isMentionType && span is EnrichedMentionSpan) {
+          emitMentionDetectedEvent(spannable, span, spanStart, spanEnd)
+        }
+
+        return spanStart
+      }
+    }
+
+    return null
+  }
+
+  private fun emitSelectionChangeEvent(editable: Editable?, start: Int, end: Int) {
+    if (editable == null) return
+
+    val context = view.context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+
+    val text = editable.substring(start, end)
+    dispatcher?.dispatchEvent(OnChangeSelectionEvent(
+      surfaceId,
+      view.id,
+      text,
+      start ,
+      end,
+      view.experimentalSynchronousEvents,
+    ))
+  }
+
+  private fun emitLinkDetectedEvent(spannable: Spannable, span: EnrichedLinkSpan?, start: Int, end: Int) {
+    val text = spannable.substring(start, end)
+    val url = span?.getUrl() ?: ""
+
+    // Prevents emitting unnecessary events
+    if (text == previousLinkDetectedEvent["text"] && url == previousLinkDetectedEvent["url"]) return
+
+    previousLinkDetectedEvent.put("text", text)
+    previousLinkDetectedEvent.put("url", url)
+
+    val context = view.context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    dispatcher?.dispatchEvent(OnLinkDetectedEvent(
+      surfaceId,
+      view.id,
+      text,
+      url,
+      start,
+      end,
+      view.experimentalSynchronousEvents,
+    ))
+  }
+
+  private fun emitMentionDetectedEvent(spannable: Spannable, span: EnrichedMentionSpan?, start: Int, end: Int) {
+    val text = spannable.substring(start, end)
+    val attributes = span?.getAttributes() ?: emptyMap()
+    val indicator = span?.getIndicator() ?: ""
+    val payload = JSONObject(attributes).toString()
+
+    val previousText = previousMentionDetectedEvent["text"] ?: ""
+    val previousPayload = previousMentionDetectedEvent["payload"] ?: ""
+    val previousIndicator = previousMentionDetectedEvent["indicator"] ?: ""
+
+    if (text == previousText && payload == previousPayload && indicator == previousIndicator) return
+
+    previousMentionDetectedEvent.put("text", text)
+    previousMentionDetectedEvent.put("payload", payload)
+    previousMentionDetectedEvent.put("indicator", indicator)
+
+    val context = view.context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    dispatcher?.dispatchEvent(OnMentionDetectedEvent(
+      surfaceId,
+      view.id,
+      text,
+      indicator,
+      payload,
+      view.experimentalSynchronousEvents,
+    ))
+  }
+}

package/android/src/main/java/com/swmansion/enriched/utils/EnrichedSpanState.kt

@@ -0,0 +1,204 @@
+package com.swmansion.enriched.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.EnrichedTextInputView
+import com.swmansion.enriched.events.OnChangeStateEvent
+import com.swmansion.enriched.spans.EnrichedSpans
+
+class EnrichedSpanState(private val view: EnrichedTextInputView) {
+  private var previousPayload: WritableMap? = null
+
+  var boldStart: Int? = null
+    private set
+  var italicStart: Int? = null
+    private set
+  var underlineStart: Int? = null
+    private set
+  var strikethroughStart: Int? = null
+    private set
+  var inlineCodeStart: Int? = null
+    private set
+  var h1Start: Int? = null
+    private set
+  var h2Start: Int? = null
+    private set
+  var h3Start: Int? = null
+    private set
+  var codeBlockStart: Int? = null
+    private set
+  var blockQuoteStart: Int? = null
+    private set
+  var orderedListStart: Int? = null
+    private set
+  var unorderedListStart: Int? = null
+    private set
+  var linkStart: Int? = null
+    private set
+  var imageStart: Int? = null
+    private set
+  var mentionStart: Int? = null
+    private set
+
+  fun setBoldStart(start: Int?) {
+    this.boldStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setItalicStart(start: Int?) {
+    this.italicStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setUnderlineStart(start: Int?) {
+    this.underlineStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setStrikethroughStart(start: Int?) {
+    this.strikethroughStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setInlineCodeStart(start: Int?) {
+    this.inlineCodeStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setH1Start(start: Int?) {
+    this.h1Start = start
+    emitStateChangeEvent()
+  }
+
+  fun setH2Start(start: Int?) {
+    this.h2Start = start
+    emitStateChangeEvent()
+  }
+
+  fun setH3Start(start: Int?) {
+    this.h3Start = start
+    emitStateChangeEvent()
+  }
+
+  fun setCodeBlockStart(start: Int?) {
+    this.codeBlockStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setBlockQuoteStart(start: Int?) {
+    this.blockQuoteStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setOrderedListStart(start: Int?) {
+    this.orderedListStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setUnorderedListStart(start: Int?) {
+    this.unorderedListStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setLinkStart(start: Int?) {
+    this.linkStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setImageStart(start: Int?) {
+    this.imageStart = start
+    emitStateChangeEvent()
+  }
+
+  fun setMentionStart(start: Int?) {
+    this.mentionStart = start
+    emitStateChangeEvent()
+  }
+
+  fun getStart(name: String): Int? {
+    val start = when (name) {
+      EnrichedSpans.BOLD -> boldStart
+      EnrichedSpans.ITALIC -> italicStart
+      EnrichedSpans.UNDERLINE -> underlineStart
+      EnrichedSpans.STRIKETHROUGH -> strikethroughStart
+      EnrichedSpans.INLINE_CODE -> inlineCodeStart
+      EnrichedSpans.H1 -> h1Start
+      EnrichedSpans.H2 -> h2Start
+      EnrichedSpans.H3 -> h3Start
+      EnrichedSpans.CODE_BLOCK -> codeBlockStart
+      EnrichedSpans.BLOCK_QUOTE -> blockQuoteStart
+      EnrichedSpans.ORDERED_LIST -> orderedListStart
+      EnrichedSpans.UNORDERED_LIST -> unorderedListStart
+      EnrichedSpans.LINK -> linkStart
+      EnrichedSpans.IMAGE -> imageStart
+      EnrichedSpans.MENTION -> mentionStart
+      else -> null
+    }
+
+    return start
+  }
+
+  fun setStart(name: String, start: Int?) {
+    when (name) {
+      EnrichedSpans.BOLD -> setBoldStart(start)
+      EnrichedSpans.ITALIC -> setItalicStart(start)
+      EnrichedSpans.UNDERLINE -> setUnderlineStart(start)
+      EnrichedSpans.STRIKETHROUGH -> setStrikethroughStart(start)
+      EnrichedSpans.INLINE_CODE -> setInlineCodeStart(start)
+      EnrichedSpans.H1 -> setH1Start(start)
+      EnrichedSpans.H2 -> setH2Start(start)
+      EnrichedSpans.H3 -> setH3Start(start)
+      EnrichedSpans.CODE_BLOCK -> setCodeBlockStart(start)
+      EnrichedSpans.BLOCK_QUOTE -> setBlockQuoteStart(start)
+      EnrichedSpans.ORDERED_LIST -> setOrderedListStart(start)
+      EnrichedSpans.UNORDERED_LIST -> setUnorderedListStart(start)
+      EnrichedSpans.LINK -> setLinkStart(start)
+      EnrichedSpans.IMAGE -> setImageStart(start)
+      EnrichedSpans.MENTION -> setMentionStart(start)
+    }
+  }
+
+  private fun emitStateChangeEvent() {
+    val payload: WritableMap = Arguments.createMap()
+    payload.putBoolean("isBold", boldStart != null)
+    payload.putBoolean("isItalic", italicStart != null)
+    payload.putBoolean("isUnderline", underlineStart != null)
+    payload.putBoolean("isStrikeThrough", strikethroughStart != null)
+    payload.putBoolean("isInlineCode", inlineCodeStart != null)
+    payload.putBoolean("isH1", h1Start != null)
+    payload.putBoolean("isH2", h2Start != null)
+    payload.putBoolean("isH3", h3Start != null)
+    payload.putBoolean("isCodeBlock", codeBlockStart != null)
+    payload.putBoolean("isBlockQuote", blockQuoteStart != null)
+    payload.putBoolean("isOrderedList", orderedListStart != null)
+    payload.putBoolean("isUnorderedList", unorderedListStart != null)
+    payload.putBoolean("isLink", linkStart != null)
+    payload.putBoolean("isImage", imageStart != null)
+    payload.putBoolean("isMention", mentionStart != null)
+
+    // Do not emit event if payload is the same
+    if (previousPayload == payload) {
+      return
+    }
+
+    previousPayload = Arguments.createMap().apply {
+      merge(payload)
+    }
+
+    val context = view.context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    dispatcher?.dispatchEvent(OnChangeStateEvent(
+      surfaceId,
+      view.id,
+      payload,
+      view.experimentalSynchronousEvents,
+    ))
+  }
+
+  companion object {
+    const val NAME = "ReactNativeEnrichedView"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/utils/Utils.kt

@@ -0,0 +1,91 @@
+package com.swmansion.enriched.utils
+
+import android.text.Spannable
+import android.text.SpannableString
+import android.text.SpannableStringBuilder
+import android.util.Log
+import com.swmansion.enriched.spans.interfaces.EnrichedBlockSpan
+import com.swmansion.enriched.spans.interfaces.EnrichedParagraphSpan
+import org.json.JSONObject
+
+fun jsonStringToStringMap(json: String): Map<String, String> {
+  val result = mutableMapOf<String, String>()
+  try {
+    val jsonObject = JSONObject(json)
+    for (key in jsonObject.keys()) {
+      val value = jsonObject.opt(key)
+      if (value is String) {
+        result[key] = value
+      }
+    }
+  } catch (e: Exception) {
+    Log.w("ReactNativeEnrichedView", "Failed to parse JSON string to Map: $json", e)
+  }
+
+  return result
+}
+
+fun Spannable.getSafeSpanBoundaries(start: Int, end: Int): Pair<Int, Int> {
+  val safeStart = start.coerceAtMost(end).coerceAtLeast(0)
+  val safeEnd = end.coerceAtLeast(start).coerceAtMost(this.length)
+
+  return Pair(safeStart, safeEnd)
+}
+
+fun Spannable.getParagraphBounds(start: Int, end: Int): Pair<Int, Int> {
+  var startPosition = start.coerceAtLeast(0).coerceAtMost(this.length)
+  var endPosition = end.coerceAtLeast(0).coerceAtMost(this.length)
+
+  // Find the start of the paragraph
+  while (startPosition > 0 && this[startPosition - 1] != '\n') {
+    startPosition--
+  }
+
+  // Find the end of the paragraph
+  while (endPosition < this.length && this[endPosition] != '\n') {
+    endPosition++
+  }
+
+  if (startPosition >= endPosition) {
+    // If the start position is equal or greater than the end position, return the same position
+    startPosition = endPosition
+  }
+
+  return Pair(startPosition, endPosition)
+}
+
+fun Spannable.getParagraphBounds(index: Int): Pair<Int, Int> {
+  return this.getParagraphBounds(index, index)
+}
+
+fun Spannable.mergeSpannables(start: Int, end: Int, string: String): Spannable {
+  return this.mergeSpannables(start, end, SpannableString(string))
+}
+
+fun Spannable.mergeSpannables(start: Int, end: Int, spannable: Spannable): Spannable {
+  var finalStart = start
+  var finalEnd = end
+
+  val builder = SpannableStringBuilder(this)
+  val startBlockSpans = spannable.getSpans(0, 0, EnrichedBlockSpan::class.java)
+  val startParagraphSpans = spannable.getSpans(0, 0, EnrichedParagraphSpan::class.java)
+  val endBlockSpans = spannable.getSpans(this.length, this.length, EnrichedBlockSpan::class.java)
+  val endParagraphSpans = spannable.getSpans(this.length, this.length, EnrichedParagraphSpan::class.java)
+  val (paragraphStart, paragraphEnd) = this.getParagraphBounds(start, end)
+  val isNewLineStart = startBlockSpans.isNotEmpty() || startParagraphSpans.isNotEmpty()
+  val isNewLineEnd = endBlockSpans.isNotEmpty() || endParagraphSpans.isNotEmpty()
+
+  if (isNewLineStart && start != paragraphStart) {
+    builder.insert(start, "\n")
+    finalStart = start + 1
+    finalEnd = end + 1
+  }
+
+  if (isNewLineEnd && end != paragraphEnd) {
+    builder.insert(finalEnd, "\n")
+  }
+
+  builder.replace(finalStart, finalEnd, spannable)
+
+  return builder
+}

package/android/src/main/java/com/swmansion/enriched/watchers/EnrichedSpanWatcher.kt

@@ -0,0 +1,73 @@
+package com.swmansion.enriched.watchers
+
+import android.text.SpanWatcher
+import android.text.Spannable
+import android.text.style.ParagraphStyle
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.EnrichedTextInputView
+import com.swmansion.enriched.events.OnChangeHtmlEvent
+import com.swmansion.enriched.spans.EnrichedOrderedListSpan
+import com.swmansion.enriched.spans.interfaces.EnrichedHeadingSpan
+import com.swmansion.enriched.spans.interfaces.EnrichedSpan
+import com.swmansion.enriched.utils.EnrichedParser
+import com.swmansion.enriched.utils.getSafeSpanBoundaries
+
+class EnrichedSpanWatcher(private val view: EnrichedTextInputView) : SpanWatcher {
+  private var previousHtml: String? = null
+
+  override fun onSpanAdded(text: Spannable, what: Any, start: Int, end: Int) {
+    updateNextLineLayout(what, text, end)
+    updateUnorderedListSpans(what, text, end)
+    emitEvent(text, what)
+  }
+
+  override fun onSpanRemoved(text: Spannable, what: Any, start: Int, end: Int) {
+    updateNextLineLayout(what, text, end)
+    updateUnorderedListSpans(what, text, end)
+    emitEvent(text, what)
+  }
+
+  override fun onSpanChanged(text: Spannable, what: Any, ostart: Int, oend: Int, nstart: Int, nend: Int) {
+    // Do nothing for now
+  }
+
+  private fun updateUnorderedListSpans(what: Any, text: Spannable, end: Int) {
+    if (what is EnrichedOrderedListSpan) {
+      view.listStyles?.updateOrderedListIndexes(text, end)
+    }
+  }
+
+  // After adding/removing heading span, we have to manually set empty paragraph span to the following text
+  // This allows us to update the layout (as it's not updated automatically - looks like an Android issue)
+  private fun updateNextLineLayout(what: Any, text: Spannable, end: Int) {
+    class EmptySpan : ParagraphStyle {}
+
+    if (what is EnrichedHeadingSpan) {
+      val finalStart = (end + 1)
+      val finalEnd = text.length
+      val (safeStart, safeEnd) = text.getSafeSpanBoundaries(finalStart, finalEnd)
+      text.setSpan(EmptySpan(), safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    }
+  }
+
+  fun emitEvent(s: Spannable, what: Any?) {
+    // Emit event only if we change one of ours spans
+    if (what != null && what !is EnrichedSpan) return
+
+    val html = EnrichedParser.toHtml(s)
+    if (html == previousHtml) return
+
+    previousHtml = html
+    view.layoutManager.invalidateLayout(view.text)
+    val context = view.context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    dispatcher?.dispatchEvent(OnChangeHtmlEvent(
+      surfaceId,
+      view.id,
+      html,
+      view.experimentalSynchronousEvents,
+    ))
+  }
+}

package/android/src/main/java/com/swmansion/enriched/watchers/EnrichedTextWatcher.kt

@@ -0,0 +1,51 @@
+package com.swmansion.enriched.watchers
+
+import android.text.Editable
+import android.text.TextWatcher
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.EnrichedTextInputView
+import com.swmansion.enriched.events.OnChangeTextEvent
+
+class EnrichedTextWatcher(private val view: EnrichedTextInputView) : TextWatcher {
+  private var endCursorPosition: Int = 0
+  private var previousTextLength: Int = 0
+
+  override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
+    previousTextLength = s?.length ?: 0
+  }
+
+  override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
+    endCursorPosition = start + count
+    view.layoutManager.measureSize(s ?: "")
+    view.isRemovingMany = !view.isSettingValue && before > count + 1
+  }
+
+  override fun afterTextChanged(s: Editable?) {
+    if (s == null) return
+    emitEvents(s)
+
+    if (view.isSettingValue) return
+    applyStyles(s)
+  }
+
+  private fun applyStyles(s: Editable) {
+    view.inlineStyles?.afterTextChanged(s, endCursorPosition)
+    view.paragraphStyles?.afterTextChanged(s, endCursorPosition, previousTextLength)
+    view.listStyles?.afterTextChanged(s, endCursorPosition, previousTextLength)
+    view.parametrizedStyles?.afterTextChanged(s, endCursorPosition)
+  }
+
+  private fun emitEvents(s: Editable) {
+    val context = view.context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    dispatcher?.dispatchEvent(OnChangeTextEvent(
+      surfaceId,
+      view.id,
+      s,
+      view.experimentalSynchronousEvents,
+    ))
+    view.spanWatcher?.emitEvent(s, null)
+  }
+}