react-native-enriched 0.0.0 → 0.1.1

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

@@ -0,0 +1,186 @@
+package com.swmansion.enriched.styles
+
+import android.text.Editable
+import android.text.Spannable
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.EnrichedTextInputView
+import com.swmansion.enriched.spans.EnrichedSpans
+import com.swmansion.enriched.utils.getParagraphBounds
+import com.swmansion.enriched.utils.getSafeSpanBoundaries
+
+class ParagraphStyles(private val view: EnrichedTextInputView) {
+  private fun <T>setSpan(spannable: Spannable, type: Class<T>, start: Int, end: Int) {
+    val span = type.getDeclaredConstructor(HtmlStyle::class.java).newInstance(view.htmlStyle)
+    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, end)
+    spannable.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+  }
+
+  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
+
+    val spans = ssb.getSpans(start, end, clazz)
+    if (spans.isEmpty()) return false
+
+    for (span in spans) {
+      finalStart = ssb.getSpanStart(span).coerceAtMost(finalStart)
+      finalEnd = ssb.getSpanEnd(span).coerceAtLeast(finalEnd)
+
+      ssb.removeSpan(span)
+    }
+
+    ssb.replace(finalStart, finalEnd, ssb.substring(finalStart, finalEnd).replace("\u200B", ""))
+    return true
+  }
+
+  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
+    if (spans.isEmpty()) {
+      setSpan(spannable, type, start, end)
+      return
+    }
+
+    var setSpanOnFinish = false
+
+    // Some spans are present, we have to remove spans and (optionally) apply new spans
+    for (span in spans) {
+      val spanStart = spannable.getSpanStart(span)
+      val spanEnd = spannable.getSpanEnd(span)
+      var finalStart: Int? = null
+      var finalEnd: Int? = null
+
+      spannable.removeSpan(span)
+
+      if (start == spanStart && end == spanEnd) {
+        setSpanOnFinish = false
+      } else if (start > spanStart && end < spanEnd) {
+        setSpan(spannable, type, spanStart, start)
+        setSpan(spannable, type, end, spanEnd)
+      } else if (start == spanStart && end < spanEnd) {
+        finalStart = end
+        finalEnd = spanEnd
+      } else if (start > spanStart && end == spanEnd) {
+        finalStart = spanStart
+        finalEnd = start
+      } else if (start > spanStart) {
+        finalStart = spanStart
+        finalEnd = end
+      } else if (start < spanStart && end < spanEnd) {
+        finalStart = start
+        finalEnd = spanEnd
+      } else {
+        setSpanOnFinish = true
+      }
+
+      if (!setSpanOnFinish && finalStart != null && finalEnd != null) {
+        setSpan(spannable, type, finalStart, finalEnd)
+      }
+    }
+
+    if (setSpanOnFinish) {
+      setSpan(spannable, type, start, end)
+    }
+  }
+
+  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()
+
+    val spans = spannable.getSpans(start, end, type)
+    return spans.isNotEmpty()
+  }
+
+  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'
+
+    for ((style, config) in EnrichedSpans.paragraphSpans) {
+      val spanState = view.spanState ?: continue
+      val styleStart = spanState.getStart(style) ?: continue
+
+      if (isNewLine) {
+        if (!config.isContinuous) {
+          spanState.setStart(style, null)
+          continue
+        }
+
+        if (isBackspace) {
+          endCursorPosition -= 1
+          view.spanState.setStart(style, null)
+        } else {
+          s.insert(endCursorPosition, "\u200B")
+          endCursorPosition += 1
+        }
+      }
+
+      var (start, end) = s.getParagraphBounds(styleStart, endCursorPosition)
+      val isNotEndLineSpan = isSpanEnabledInNextLine(s, end, config.clazz)
+      val spans = s.getSpans(start, end, config.clazz)
+
+      for (span in spans) {
+        if (isNotEndLineSpan) {
+          start = s.getSpanStart(span).coerceAtMost(start)
+          end = s.getSpanEnd(span).coerceAtLeast(end)
+        }
+
+        s.removeSpan(span)
+      }
+
+      setSpan(s, config.clazz, start, end)
+    }
+  }
+
+  fun toggleStyle(name: String) {
+    if (view.selection == null) return
+    val spannable = view.text as SpannableStringBuilder
+    val (start, end) = view.selection.getParagraphSelection()
+    val config = EnrichedSpans.paragraphSpans[name] ?: return
+    val type = config.clazz
+
+    val styleStart = view.spanState?.getStart(name)
+
+    if (styleStart != null) {
+      view.spanState.setStart(name, null)
+      removeSpansForRange(spannable, start, end, type)
+      view.selection.validateStyles()
+
+      return
+    }
+
+    if (start == end) {
+      spannable.insert(start, "\u200B")
+      view.spanState?.setStart(name, start + 1)
+      setAndMergeSpans(spannable, type, start, end + 1)
+
+      return
+    }
+
+    var currentStart = start
+    var currentEnd = currentStart
+    val paragraphs = spannable.substring(start, end).split("\n")
+
+    for (paragraph in paragraphs) {
+      spannable.insert(currentStart, "\u200B")
+      currentEnd = currentStart + paragraph.length + 1
+      currentStart = currentEnd + 1
+    }
+
+    view.spanState?.setStart(name, start)
+    setAndMergeSpans(spannable, type, start, currentEnd)
+  }
+
+  fun getStyleRange(): Pair<Int, Int> {
+    return view.selection?.getParagraphSelection() ?: Pair(0, 0)
+  }
+
+  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

@@ -0,0 +1,223 @@
+package com.swmansion.enriched.styles
+
+import android.net.Uri
+import android.text.Editable
+import android.text.Spannable
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import com.swmansion.enriched.EnrichedTextInputView
+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.getSafeSpanBoundaries
+import java.io.File
+
+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 {
+    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", ""))
+
+    for (span in spans) {
+      ssb.removeSpan(span)
+    }
+
+    return true
+  }
+
+  fun setLinkSpan(start: Int, end: Int, text: String, url: String) {
+    isSettingLinkSpan = true
+
+    val spannable = view.text as SpannableStringBuilder
+    val spans = spannable.getSpans(start, end, EnrichedLinkSpan::class.java)
+    for (span in spans) {
+      spannable.removeSpan(span)
+    }
+
+    if (start == end) {
+      spannable.insert(start, text)
+    } else {
+      spannable.replace(start, end, text)
+    }
+
+    val spanEnd = start + text.length
+    val span = EnrichedLinkSpan(url, view.htmlStyle)
+    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, spanEnd)
+    spannable.setSpan(span, safeStart, safeEnd, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+
+    view.selection?.validateStyles()
+    isSettingLinkSpan = false
+  }
+
+  fun afterTextChanged(s: Editable, endCursorPosition: Int) {
+    val result = getWordAtIndex(s, endCursorPosition) ?: return
+
+    afterTextChangedLinks(result)
+    afterTextChangedMentions(result)
+  }
+
+  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)
+
+    val spans = spannable.getSpans(0, spannable.length, 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)
+    }
+  }
+
+  private fun getWordAtIndex(s: Editable, index: Int): Triple<String, Int, Int>? {
+    if (index < 0 ) return null
+
+    var start = index
+    var end = index
+
+    while (start > 0 && !Character.isWhitespace(s[start - 1])) {
+      start--
+    }
+
+    while (end < s.length && !Character.isWhitespace(s[end])) {
+      end++
+    }
+
+    val result = s.subSequence(start, end).toString()
+
+    return Triple(result, start, end)
+  }
+
+  private fun afterTextChangedLinks(result: Triple<String, Int, Int>) {
+    // Do not detect link if it's applied manually
+    if (isSettingLinkSpan) 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)
+    }
+  }
+
+  private fun afterTextChangedMentions(result: Triple<String, Int, Int>) {
+    val mentionHandler = view.mentionHandler ?: return
+    val spannable = view.text as Spannable
+    val (word, start, end) = result
+
+    val indicatorsPattern = mentionIndicators.joinToString("|") { Regex.escape(it) }
+    val mentionIndicatorRegex = Regex("^($indicatorsPattern)")
+    val mentionRegex= Regex("^($indicatorsPattern)\\w*")
+
+    val spans = spannable.getSpans(start, end, EnrichedMentionSpan::class.java)
+    for (span in spans) {
+      spannable.removeSpan(span)
+    }
+
+    if (mentionRegex.matches(word)) {
+      val indicator = mentionIndicatorRegex.find(word)?.value ?: ""
+      val text = word.replaceFirst(indicator, "")
+
+      // Means we are starting mention
+      if (text.isEmpty()) {
+        mentionStart = start
+      }
+
+      mentionHandler.onMention(indicator, word.replaceFirst(indicator, ""))
+    } else {
+      mentionHandler.endMention()
+    }
+  }
+
+  fun setImageSpan(src: String) {
+    if (view.selection == null) return
+
+    val spannable = view.text as SpannableStringBuilder
+    var (start, end) = view.selection.getInlineSelection()
+    val spans = spannable.getSpans(start, end, EnrichedImageSpan::class.java)
+
+    for (s in spans) {
+      spannable.removeSpan(s)
+    }
+
+    if (start == end) {
+      spannable.insert(start, "\uFFFC")
+      end++
+    }
+
+    val uri = Uri.fromFile(File(src))
+    val span = EnrichedImageSpan(view.context, uri, view.htmlStyle)
+    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, end)
+    spannable.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+  }
+
+  fun startMention(indicator: String) {
+    val selection = view.selection ?: return
+
+    val spannable = view.text as SpannableStringBuilder
+    val (start, end) = selection.getInlineSelection()
+
+    if (start == end) {
+      spannable.insert(start, indicator)
+    } else {
+      spannable.replace(start, end, indicator)
+    }
+  }
+
+  fun setMentionSpan(indicator: String, text: String, attributes: Map<String, String>) {
+    val selection = view.selection ?: return
+
+    val spannable = view.text as SpannableStringBuilder
+    val (selectionStart, selectionEnd) = selection.getInlineSelection()
+    val spans = spannable.getSpans(selectionStart, selectionEnd, EnrichedMentionSpan::class.java)
+
+    for (span in spans) {
+      spannable.removeSpan(span)
+    }
+
+    val start = mentionStart ?: return
+    spannable.replace(start, selectionEnd, text)
+
+    val span = EnrichedMentionSpan(text, indicator, attributes, view.htmlStyle)
+    val spanEnd = start + text.length
+    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, spanEnd)
+    spannable.setSpan(span, safeStart, safeEnd, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+
+    view.selection.validateStyles()
+  }
+
+  fun getStyleRange(): Pair<Int, Int> {
+    return view.selection?.getInlineSelection() ?: Pair(0, 0)
+  }
+
+  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)
+  }
+}