react-native-enriched 0.2.1 → 0.3.0

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
+  }
+}