react-native-enriched 0.2.0 → 0.3.0

package/android/src/main/java/com/swmansion/enriched/styles/ParagraphStyles.kt

@@ -5,14 +5,21 @@ import android.text.Spannable
 import android.text.SpannableStringBuilder
 import android.util.Log
 import com.swmansion.enriched.EnrichedTextInputView
-import com.swmansion.enriched.spans.EnrichedBlockQuoteSpan
-import com.swmansion.enriched.spans.EnrichedCodeBlockSpan
 import com.swmansion.enriched.spans.EnrichedSpans
+import com.swmansion.enriched.spans.interfaces.EnrichedSpan
+import com.swmansion.enriched.utils.EnrichedConstants
 import com.swmansion.enriched.utils.getParagraphBounds
 import com.swmansion.enriched.utils.getSafeSpanBoundaries
-
-class ParagraphStyles(private val view: EnrichedTextInputView) {
-  private fun <T>getPreviousParagraphSpan(spannable: Spannable, paragraphStart: Int, type: Class<T>): T? {
+import com.swmansion.enriched.utils.removeZWS
+
+class ParagraphStyles(
+  private val view: EnrichedTextInputView,
+) {
+  private fun <T> getPreviousParagraphSpan(
+    spannable: Spannable,
+    paragraphStart: Int,
+    type: Class<T>,
+  ): T? {
     if (paragraphStart <= 0) return null
 
     val (previousParagraphStart, previousParagraphEnd) = spannable.getParagraphBounds(paragraphStart - 1)
@@ -31,7 +38,11 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     return null
   }
 
-  private fun <T>getNextParagraphSpan(spannable: Spannable, paragraphEnd: Int, type: Class<T>): T? {
+  private fun <T> getNextParagraphSpan(
+    spannable: Spannable,
+    paragraphEnd: Int,
+    type: Class<T>,
+  ): T? {
     if (paragraphEnd >= spannable.length - 1) return null
 
     val (nextParagraphStart, nextParagraphEnd) = spannable.getParagraphBounds(paragraphEnd + 1)
@@ -55,7 +66,12 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
    * Applies a continuous span to the specified range.
    * If the new range touches existing continuous spans, they are coalesced into a single span
    */
-  private fun <T>setContinuousSpan(spannable: Spannable, start: Int, end: Int, type: Class<T>) {
+  private fun <T> setContinuousSpan(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+    type: Class<T>,
+  ) {
     val span = type.getDeclaredConstructor(HtmlStyle::class.java).newInstance(view.htmlStyle)
     val previousSpan = getPreviousParagraphSpan(spannable, start, type)
     val nextSpan = getNextParagraphSpan(spannable, end, type)
@@ -76,8 +92,12 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     spannable.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
   }
 
-
-  private fun <T>setSpan(spannable: Spannable, type: Class<T>, start: Int, end: Int) {
+  private fun <T> setSpan(
+    spannable: Spannable,
+    type: Class<T>,
+    start: Int,
+    end: Int,
+  ) {
     if (EnrichedSpans.isTypeContinuous(type)) {
       setContinuousSpan(spannable, start, end, type)
       return
@@ -88,7 +108,12 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     spannable.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
   }
 
-  private fun <T>removeSpansForRange(spannable: Spannable, start: Int, end: Int, clazz: Class<T>): Boolean {
+  private fun <T> removeSpansForRange(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+    clazz: Class<T>,
+  ): Boolean {
     val ssb = spannable as SpannableStringBuilder
     var finalStart = start
     var finalEnd = end
@@ -103,11 +128,17 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
       ssb.removeSpan(span)
     }
 
-    ssb.replace(finalStart, finalEnd, ssb.substring(finalStart, finalEnd).replace("\u200B", ""))
+    ssb.removeZWS(finalStart, finalEnd)
+
     return true
   }
 
-  private fun <T>setAndMergeSpans(spannable: Spannable, type: Class<T>, start: Int, end: Int) {
+  private fun <T> setAndMergeSpans(
+    spannable: Spannable,
+    type: Class<T>,
+    start: Int,
+    end: Int,
+  ) {
     val spans = spannable.getSpans(start, end, type)
 
     // No spans setup for current selection, means we just need to assign new span
@@ -158,7 +189,11 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     }
   }
 
-  private fun <T>isSpanEnabledInNextLine(spannable: Spannable, index: Int, type: Class<T>): Boolean {
+  private fun <T> isSpanEnabledInNextLine(
+    spannable: Spannable,
+    index: Int,
+    type: Class<T>,
+  ): Boolean {
     val selection = view.selection ?: return false
     if (index + 1 >= spannable.length) return false
     val (start, end) = selection.getParagraphSelection()
@@ -167,7 +202,11 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     return spans.isNotEmpty()
   }
 
-  private fun <T>mergeAdjacentStyleSpans(s: Editable, endCursorPosition: Int, type: Class<T>) {
+  private fun <T> mergeAdjacentStyleSpans(
+    s: Editable,
+    endCursorPosition: Int,
+    type: Class<T>,
+  ) {
     val (start, end) = s.getParagraphBounds(endCursorPosition)
     val currParagraphSpans = s.getSpans(start, end, type)
 
@@ -194,16 +233,102 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     s.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
   }
 
-  fun afterTextChanged(s: Editable, endPosition: Int, previousTextLength: Int) {
+  private fun handleConflictsDuringNewlineDeletion(
+    s: Editable,
+    style: String,
+    paragraphStart: Int,
+    paragraphEnd: Int,
+  ): Boolean {
+    val spanState = view.spanState ?: return false
+    val mergingConfig = EnrichedSpans.getMergingConfigForStyle(style, view.htmlStyle) ?: return false
+    var isConflicting = false
+    val stylesToCheck = mergingConfig.blockingStyles + mergingConfig.conflictingStyles
+
+    for (styleToCheck in stylesToCheck) {
+      val conflictingType = EnrichedSpans.allSpans[styleToCheck]?.clazz ?: continue
+
+      val spans = s.getSpans(paragraphStart, paragraphEnd, conflictingType)
+      if (spans.isEmpty()) {
+        continue
+      }
+      isConflicting = true
+
+      val isParagraphStyle = EnrichedSpans.paragraphSpans[styleToCheck] != null
+      if (!isParagraphStyle) {
+        continue
+      }
+
+      for (span in spans) {
+        extendStyleOnWholeParagraph(s, span as EnrichedSpan, conflictingType, paragraphEnd)
+      }
+    }
+
+    if (isConflicting) {
+      val styleStart = spanState.getStart(style) ?: return false
+      spanState.setStart(style, null)
+      removeStyle(style, styleStart, paragraphEnd)
+      return true
+    }
+
+    return false
+  }
+
+  private fun deleteConflictingAndBlockingStyles(
+    s: Editable,
+    style: String,
+    paragraphStart: Int,
+    paragraphEnd: Int,
+  ) {
+    val mergingConfig = EnrichedSpans.getMergingConfigForStyle(style, view.htmlStyle) ?: return
+    val stylesToCheck = mergingConfig.blockingStyles + mergingConfig.conflictingStyles
+
+    for (styleToCheck in stylesToCheck) {
+      val conflictingType = EnrichedSpans.allSpans[styleToCheck]?.clazz ?: continue
+
+      val spans = s.getSpans(paragraphStart, paragraphEnd, conflictingType)
+      for (span in spans) {
+        s.removeSpan(span)
+      }
+    }
+  }
+
+  private fun <T> extendStyleOnWholeParagraph(
+    s: Editable,
+    span: EnrichedSpan,
+    type: Class<T>,
+    paragraphEnd: Int,
+  ) {
+    val currStyleStart = s.getSpanStart(span)
+    s.removeSpan(span)
+    val (safeStart, safeEnd) = s.getSafeSpanBoundaries(currStyleStart, paragraphEnd)
+    setSpan(s, type, safeStart, safeEnd)
+  }
+
+  fun afterTextChanged(
+    s: Editable,
+    endPosition: Int,
+    previousTextLength: Int,
+  ) {
     var endCursorPosition = endPosition
     val isBackspace = s.length < previousTextLength
-    val isNewLine = endCursorPosition == 0 || endCursorPosition > 0 && s[endCursorPosition - 1] == '\n'
+    val isNewLine = endCursorPosition == 0 || (endCursorPosition > 0 && s[endCursorPosition - 1] == '\n')
+    val spanState = view.spanState ?: return
 
     for ((style, config) in EnrichedSpans.paragraphSpans) {
-      val spanState = view.spanState ?: continue
       val styleStart = spanState.getStart(style)
 
       if (styleStart == null) {
+        if (isBackspace) {
+          val (start, end) = s.getParagraphBounds(endCursorPosition)
+          val spans = s.getSpans(start, end, config.clazz)
+
+          for (span in spans) {
+            // handle conflicts when entering paragraph with some paragraph style applied
+            deleteConflictingAndBlockingStyles(s, style, start, end)
+            extendStyleOnWholeParagraph(s, span as EnrichedSpan, config.clazz, end)
+          }
+        }
+
         if (config.isContinuous) {
           mergeAdjacentStyleSpans(s, endCursorPosition, config.clazz)
         }
@@ -218,14 +343,23 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
 
         if (isBackspace) {
           endCursorPosition -= 1
-          view.spanState.setStart(style, null)
+          spanState.setStart(style, null)
         } else {
-          s.insert(endCursorPosition, "\u200B")
+          s.insert(endCursorPosition, EnrichedConstants.ZWS_STRING)
           endCursorPosition += 1
         }
       }
 
       var (start, end) = s.getParagraphBounds(styleStart, endCursorPosition)
+
+      // handle conflicts when deleting newline from paragraph style (going back to previous line)
+      if (isBackspace && styleStart != start) {
+        val isConflicting = handleConflictsDuringNewlineDeletion(s, style, start, end)
+        if (isConflicting) {
+          continue
+        }
+      }
+
       val isNotEndLineSpan = isSpanEnabledInNextLine(s, end, config.clazz)
       val spans = s.getSpans(start, end, config.clazz)
 
@@ -260,7 +394,7 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     }
 
     if (start == end) {
-      spannable.insert(start, "\u200B")
+      spannable.insert(start, EnrichedConstants.ZWS_STRING)
       setAndMergeSpans(spannable, type, start, end + 1)
       view.selection.validateStyles()
 
@@ -272,7 +406,7 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     val paragraphs = spannable.substring(start, end).split("\n")
 
     for (paragraph in paragraphs) {
-      spannable.insert(currentStart, "\u200B")
+      spannable.insert(currentStart, EnrichedConstants.ZWS_STRING)
       currentEnd = currentStart + paragraph.length + 1
       currentStart = currentEnd + 1
     }
@@ -281,11 +415,13 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     view.selection.validateStyles()
   }
 
-  fun getStyleRange(): Pair<Int, Int> {
-    return view.selection?.getParagraphSelection() ?: Pair(0, 0)
-  }
+  fun getStyleRange(): Pair<Int, Int> = view.selection?.getParagraphSelection() ?: Pair(0, 0)
 
-  fun removeStyle(name: String, start: Int, end: Int): Boolean {
+  fun removeStyle(
+    name: String,
+    start: Int,
+    end: Int,
+  ): Boolean {
     val config = EnrichedSpans.paragraphSpans[name] ?: return false
     val spannable = view.text as Spannable
     return removeSpansForRange(spannable, start, end, config.clazz)

package/android/src/main/java/com/swmansion/enriched/styles/ParametrizedStyles.kt

@@ -9,20 +9,29 @@ import com.swmansion.enriched.spans.EnrichedImageSpan
 import com.swmansion.enriched.spans.EnrichedLinkSpan
 import com.swmansion.enriched.spans.EnrichedMentionSpan
 import com.swmansion.enriched.spans.EnrichedSpans
+import com.swmansion.enriched.utils.EnrichedConstants
 import com.swmansion.enriched.utils.getSafeSpanBoundaries
+import com.swmansion.enriched.utils.removeZWS
 
-class ParametrizedStyles(private val view: EnrichedTextInputView) {
+class ParametrizedStyles(
+  private val view: EnrichedTextInputView,
+) {
   private var mentionStart: Int? = null
   private var isSettingLinkSpan = false
 
   var mentionIndicators: Array<String> = emptyArray<String>()
 
-  fun <T>removeSpansForRange(spannable: Spannable, start: Int, end: Int, clazz: Class<T>): Boolean {
+  fun <T> removeSpansForRange(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+    clazz: Class<T>,
+  ): Boolean {
     val ssb = spannable as SpannableStringBuilder
     val spans = ssb.getSpans(start, end, clazz)
     if (spans.isEmpty()) return false
 
-    ssb.replace(start, end, ssb.substring(start, end).replace("\u200B", ""))
+    ssb.removeZWS(start, end)
 
     for (span in spans) {
       ssb.removeSpan(span)
@@ -31,7 +40,12 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     return true
   }
 
-  fun setLinkSpan(start: Int, end: Int, text: String, url: String) {
+  fun setLinkSpan(
+    start: Int,
+    end: Int,
+    text: String,
+    url: String,
+  ) {
     isSettingLinkSpan = true
 
     val spannable = view.text as SpannableStringBuilder
@@ -55,36 +69,66 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     isSettingLinkSpan = false
   }
 
-  fun afterTextChanged(s: Editable, endCursorPosition: Int) {
-    val result = getWordAtIndex(s, endCursorPosition) ?: return
-
-    afterTextChangedLinks(result)
-    afterTextChangedMentions(result)
+  fun afterTextChanged(
+    s: Editable,
+    startCursorPosition: Int,
+    endCursorPosition: Int,
+  ) {
+    afterTextChangedLinks(startCursorPosition, endCursorPosition)
+    afterTextChangedMentions(s, startCursorPosition)
   }
 
-  fun detectAllLinks() {
-    val spannable = view.text as Spannable
-
-    // TODO: Consider using more reliable regex, this one matches almost anything
-    val urlPattern = android.util.Patterns.WEB_URL.matcher(spannable)
+  fun detectLinksInRange(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+  ) {
+    val regex = view.linkRegex ?: return
+    val contextText = spannable.subSequence(start, end).toString()
 
-    val spans = spannable.getSpans(0, spannable.length, EnrichedLinkSpan::class.java)
+    val spans = spannable.getSpans(start, end, EnrichedLinkSpan::class.java)
     for (span in spans) {
       spannable.removeSpan(span)
     }
 
-    while (urlPattern.find()) {
-      val word = urlPattern.group()
-      val start = urlPattern.start()
-      val end = urlPattern.end()
-      val span = EnrichedLinkSpan(word, view.htmlStyle)
-      val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, end)
-      spannable.setSpan(span, safeStart, safeEnd, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+    val wordsRegex = Regex("\\S+")
+    for (wordMatch in wordsRegex.findAll(contextText)) {
+      var word = wordMatch.value
+      var wordStart = wordMatch.range.first
+
+      // Do not include zero-width space in link detection
+      if (word.startsWith("\u200B")) {
+        word = word.substring(1)
+        wordStart += 1
+      }
+
+      // Loop over words and detect links
+      val matcher = regex.matcher(word)
+      while (matcher.find()) {
+        val linkStart = matcher.start()
+        val linkEnd = matcher.end()
+
+        val spanStart = start + wordStart + linkStart
+        val spanEnd = start + wordStart + linkEnd
+
+        val span = EnrichedLinkSpan(matcher.group(), view.htmlStyle)
+        val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(spanStart, spanEnd)
+
+        spannable.setSpan(
+          span,
+          safeStart,
+          safeEnd,
+          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
+        )
+      }
     }
   }
 
-  private fun getWordAtIndex(s: CharSequence, index: Int): TextRange? {
-    if (index < 0 ) return null
+  private fun getWordAtIndex(
+    s: CharSequence,
+    index: Int,
+  ): TextRange? {
+    if (index < 0) return null
 
     var start = index
     var end = index
@@ -102,8 +146,31 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     return TextRange(result, start, end)
   }
 
+  // After editing text we want to automatically detect links in the affected range
+  // Affected range is range + previous word + next word
+  private fun getLinksAffectedRange(
+    s: CharSequence,
+    start: Int,
+    end: Int,
+  ): IntRange {
+    var actualStart = start
+    var actualEnd = end
+
+    // Expand backward to find the start of the first affected word
+    while (actualStart > 0 && !Character.isWhitespace(s[actualStart - 1])) {
+      actualStart--
+    }
+
+    // Expand forward to find the end of the last affected word
+    while (actualEnd < s.length && !Character.isWhitespace(s[actualEnd])) {
+      actualEnd++
+    }
+
+    return actualStart..actualEnd
+  }
+
   private fun canLinkBeApplied(): Boolean {
-    val mergingConfig = EnrichedSpans.getMergingConfigForStyle(EnrichedSpans.LINK, view.htmlStyle)?: return true
+    val mergingConfig = EnrichedSpans.getMergingConfigForStyle(EnrichedSpans.LINK, view.htmlStyle) ?: return true
     val conflictingStyles = mergingConfig.conflictingStyles
     val blockingStyles = mergingConfig.blockingStyles
 
@@ -118,34 +185,29 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     return true
   }
 
-  private fun afterTextChangedLinks(result: TextRange) {
+  private fun afterTextChangedLinks(
+    editStart: Int,
+    editEnd: Int,
+  ) {
     // Do not detect link if it's applied manually
     if (isSettingLinkSpan || !canLinkBeApplied()) return
 
-    val spannable = view.text as Spannable
-    val (word, start, end) = result
-
-    // TODO: Consider using more reliable regex, this one matches almost anything
-    val urlPattern = android.util.Patterns.WEB_URL.matcher(word)
-    val spans = spannable.getSpans(start, end, EnrichedLinkSpan::class.java)
-    for (span in spans) {
-      spannable.removeSpan(span)
-    }
-
-    if (urlPattern.matches()) {
-      val span = EnrichedLinkSpan(word, view.htmlStyle)
-      val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, end)
-      spannable.setSpan(span, safeStart, safeEnd, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
-    }
+    val spannable = view.text as? Spannable ?: return
+    val affectedRange = getLinksAffectedRange(spannable, editStart, editEnd)
+    detectLinksInRange(spannable, affectedRange.first, affectedRange.last)
   }
 
-  private fun afterTextChangedMentions(currentWord: TextRange) {
+  private fun afterTextChangedMentions(
+    s: CharSequence,
+    endCursorPosition: Int,
+  ) {
     val mentionHandler = view.mentionHandler ?: return
+    val currentWord = getWordAtIndex(s, endCursorPosition) ?: return
     val spannable = view.text as Spannable
 
     val indicatorsPattern = mentionIndicators.joinToString("|") { Regex.escape(it) }
     val mentionIndicatorRegex = Regex("^($indicatorsPattern)")
-    val mentionRegex= Regex("^($indicatorsPattern)\\w*")
+    val mentionRegex = Regex("^($indicatorsPattern)\\w*")
 
     val spans = spannable.getSpans(currentWord.start, currentWord.end, EnrichedMentionSpan::class.java)
     for (span in spans) {
@@ -192,20 +254,24 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     mentionHandler.onMention(indicator, text)
   }
 
-  fun setImageSpan(src: String, width: Float, height: Float) {
+  fun setImageSpan(
+    src: String,
+    width: Float,
+    height: Float,
+  ) {
     if (view.selection == null) return
     val spannable = view.text as SpannableStringBuilder
     val (start, originalEnd) = view.selection.getInlineSelection()
 
     if (start == originalEnd) {
-      spannable.insert(start, "\uFFFC")
+      spannable.insert(start, EnrichedConstants.ORC_STRING)
     } else {
       val spans = spannable.getSpans(start, originalEnd, EnrichedImageSpan::class.java)
       for (s in spans) {
         spannable.removeSpan(s)
       }
 
-      spannable.replace(start, originalEnd, "\uFFFC")
+      spannable.replace(start, originalEnd, EnrichedConstants.ORC_STRING)
     }
 
     val (imageStart, imageEnd) = spannable.getSafeSpanBoundaries(start, start + 1)
@@ -228,7 +294,11 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     }
   }
 
-  fun setMentionSpan(indicator: String, text: String, attributes: Map<String, String>) {
+  fun setMentionSpan(
+    indicator: String,
+    text: String,
+    attributes: Map<String, String>,
+  ) {
     val selection = view.selection ?: return
 
     val spannable = view.text as SpannableStringBuilder
@@ -259,17 +329,23 @@ class ParametrizedStyles(private val view: EnrichedTextInputView) {
     view.selection.validateStyles()
   }
 
-  fun getStyleRange(): Pair<Int, Int> {
-    return view.selection?.getInlineSelection() ?: Pair(0, 0)
-  }
+  fun getStyleRange(): Pair<Int, Int> = view.selection?.getInlineSelection() ?: Pair(0, 0)
 
-  fun removeStyle(name: String, start: Int, end: Int): Boolean {
+  fun removeStyle(
+    name: String,
+    start: Int,
+    end: Int,
+  ): Boolean {
     val config = EnrichedSpans.parametrizedStyles[name] ?: return false
     val spannable = view.text as Spannable
     return removeSpansForRange(spannable, start, end, config.clazz)
   }
 
   companion object {
-    data class TextRange(val text: String, val start: Int, val end: Int)
+    data class TextRange(
+      val text: String,
+      val start: Int,
+      val end: Int,
+    )
   }
 }

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

@@ -13,12 +13,12 @@ import android.os.Looper
 import android.util.Log
 import androidx.core.content.res.ResourcesCompat
 import androidx.core.graphics.drawable.DrawableCompat
-import java.net.URL
-import java.util.concurrent.Executors
 import androidx.core.graphics.drawable.toDrawable
 import com.swmansion.enriched.R
+import java.net.URL
+import java.util.concurrent.Executors
 
-class AsyncDrawable (
+class AsyncDrawable(
   private val url: String,
 ) : Drawable() {
   private var internalDrawable: Drawable = Color.TRANSPARENT.toDrawable()
@@ -78,11 +78,14 @@ class AsyncDrawable (
   }
 
   @Deprecated("Deprecated in Java")
-  override fun getOpacity(): Int {
-    return PixelFormat.TRANSLUCENT
-  }
+  override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
 
-  override fun setBounds(left: Int, top: Int, right: Int, bottom: Int) {
+  override fun setBounds(
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int,
+  ) {
     super.setBounds(left, top, right, bottom)
     internalDrawable.setBounds(left, top, right, bottom)
   }

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

@@ -0,0 +1,11 @@
+package com.swmansion.enriched.utils
+
+object EnrichedConstants {
+  // Zero Width Space
+  const val ZWS = '\u200B'
+  const val ZWS_STRING = "\u200B"
+
+  // Object Replacement Character
+  const val ORC = '\uFFFC'
+  const val ORC_STRING = "\uFFFC"
+}

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

@@ -0,0 +1,17 @@
+package com.swmansion.enriched.utils
+
+import android.text.Editable
+import android.text.Spannable
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.watchers.EnrichedSpanWatcher
+
+class EnrichedEditableFactory(
+  private val watcher: EnrichedSpanWatcher,
+) : Editable.Factory() {
+  override fun newEditable(source: CharSequence): Editable {
+    val s = source as? SpannableStringBuilder ?: SpannableStringBuilder(source)
+    s.removeSpan(watcher)
+    s.setSpan(watcher, 0, s.length, Spannable.SPAN_INCLUSIVE_INCLUSIVE)
+    return s
+  }
+}