react-native-enriched 0.2.1 → 0.4.0

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

@@ -0,0 +1,263 @@
+package com.swmansion.enriched.textinput.styles
+
+import android.text.Editable
+import android.text.Spannable
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import com.swmansion.enriched.common.EnrichedConstants
+import com.swmansion.enriched.textinput.EnrichedTextInputView
+import com.swmansion.enriched.textinput.spans.EnrichedInputCheckboxListSpan
+import com.swmansion.enriched.textinput.spans.EnrichedInputOrderedListSpan
+import com.swmansion.enriched.textinput.spans.EnrichedInputUnorderedListSpan
+import com.swmansion.enriched.textinput.spans.EnrichedSpans
+import com.swmansion.enriched.textinput.utils.getParagraphBounds
+import com.swmansion.enriched.textinput.utils.getSafeSpanBoundaries
+import com.swmansion.enriched.textinput.utils.removeZWS
+
+class ListStyles(
+  private val view: EnrichedTextInputView,
+) {
+  private fun <T> getPreviousParagraphSpan(
+    spannable: Spannable,
+    s: Int,
+    type: Class<T>,
+  ): T? {
+    if (s <= 0) return null
+
+    val (previousParagraphStart, previousParagraphEnd) = spannable.getParagraphBounds(s - 1)
+    val spans = spannable.getSpans(previousParagraphStart, previousParagraphEnd, type)
+
+    if (spans.isNotEmpty()) {
+      return spans.last()
+    }
+
+    return null
+  }
+
+  private fun <T> isPreviousParagraphList(
+    spannable: Spannable,
+    s: Int,
+    type: Class<T>,
+  ): Boolean {
+    val previousSpan = getPreviousParagraphSpan(spannable, s, type)
+
+    return previousSpan != null
+  }
+
+  private fun getOrderedListIndex(
+    spannable: Spannable,
+    s: Int,
+  ): Int {
+    val span = getPreviousParagraphSpan(spannable, s, EnrichedInputOrderedListSpan::class.java)
+    val index = span?.getListIndex() ?: 0
+    return index + 1
+  }
+
+  private fun setSpan(
+    spannable: Spannable,
+    name: String,
+    start: Int,
+    end: Int,
+    isChecked: Boolean? = false,
+  ) {
+    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, end)
+
+    when (name) {
+      EnrichedSpans.UNORDERED_LIST -> {
+        val span = EnrichedInputUnorderedListSpan(view.htmlStyle)
+        spannable.setSpan(span, safeStart, safeEnd, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+      }
+
+      EnrichedSpans.ORDERED_LIST -> {
+        val index = getOrderedListIndex(spannable, safeStart)
+        val span = EnrichedInputOrderedListSpan(index, view.htmlStyle)
+        spannable.setSpan(span, safeStart, safeEnd, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+      }
+
+      EnrichedSpans.CHECKBOX_LIST -> {
+        val span = EnrichedInputCheckboxListSpan(isChecked ?: false, view.htmlStyle)
+        spannable.setSpan(span, safeStart, safeEnd, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+
+        // Invalidate layout to update checkbox drawing in case checkbox is bigger than line height
+        view.layoutManager.invalidateLayout()
+      }
+    }
+  }
+
+  private 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
+
+    for (span in spans) {
+      ssb.removeSpan(span)
+    }
+
+    ssb.removeZWS(start, end)
+    return true
+  }
+
+  fun updateOrderedListIndexes(
+    text: Spannable,
+    position: Int,
+  ) {
+    val spans = text.getSpans(position + 1, text.length, EnrichedInputOrderedListSpan::class.java)
+    val sortedSpans = spans.sortedBy { text.getSpanStart(it) }
+    for (span in sortedSpans) {
+      val spanStart = text.getSpanStart(span)
+      val index = getOrderedListIndex(text, spanStart)
+      span.setListIndex(index)
+    }
+  }
+
+  private fun toggleStyle(
+    name: String,
+    checkboxState: Boolean?,
+  ) {
+    if (view.selection == null) return
+    val config = EnrichedSpans.listSpans[name] ?: return
+    val spannable = view.text as SpannableStringBuilder
+    val (start, end) = view.selection.getParagraphSelection()
+    val styleStart = view.spanState?.getStart(name)
+
+    if (styleStart != null) {
+      view.spanState.setStart(name, null)
+      removeSpansForRange(spannable, start, end, config.clazz)
+      view.selection.validateStyles()
+
+      return
+    }
+
+    if (start == end) {
+      spannable.insert(start, EnrichedConstants.ZWS_STRING)
+      view.spanState?.setStart(name, start + 1)
+      removeSpansForRange(spannable, start, end, config.clazz)
+      setSpan(spannable, name, start, end + 1, checkboxState)
+
+      return
+    }
+
+    var currentStart = start
+    val paragraphs = spannable.substring(start, end).split("\n")
+    removeSpansForRange(spannable, start, end, config.clazz)
+
+    for (paragraph in paragraphs) {
+      spannable.insert(currentStart, EnrichedConstants.ZWS_STRING)
+      val currentEnd = currentStart + paragraph.length + 1
+      setSpan(spannable, name, currentStart, currentEnd, checkboxState)
+
+      currentStart = currentEnd + 1
+    }
+
+    view.spanState?.setStart(name, currentStart)
+  }
+
+  fun toggleStyle(name: String) {
+    toggleStyle(name, false)
+  }
+
+  fun toggleCheckboxListStyle(checked: Boolean) {
+    toggleStyle(EnrichedSpans.CHECKBOX_LIST, checked)
+  }
+
+  private fun handleAfterTextChanged(
+    s: Editable,
+    name: String,
+    endCursorPosition: Int,
+    previousTextLength: Int,
+  ) {
+    val config = EnrichedSpans.listSpans[name] ?: return
+    val cursorPosition = endCursorPosition.coerceAtMost(s.length)
+    val (start, end) = s.getParagraphBounds(cursorPosition)
+
+    val isBackspace = previousTextLength > s.length
+    val isNewLine = cursorPosition > 0 && s[cursorPosition - 1] == '\n'
+    val isShortcut = config.shortcut?.let { s.substring(start, end).startsWith(it) } ?: false
+    val spans = s.getSpans(start, end, config.clazz)
+
+    // Remove spans if cursor is at the start of the paragraph and spans exist
+    if (isBackspace && start == cursorPosition && spans.isNotEmpty()) {
+      removeSpansForRange(s, start, end, config.clazz)
+      return
+    }
+
+    if (!isBackspace && isShortcut) {
+      s.replace(start, cursorPosition, EnrichedConstants.ZWS_STRING)
+      setSpan(s, name, start, start + 1)
+      // Inform that new span has been added
+      view.selection?.validateStyles()
+      return
+    }
+
+    if (!isBackspace && isNewLine && isPreviousParagraphList(s, start, config.clazz)) {
+      // Check if the span from the previous line "leaked" into this one
+      if (spans.isNotEmpty()) {
+        val existingSpan = spans[0]
+        val spanStart = s.getSpanStart(existingSpan)
+
+        // If the span started before the current paragraph (belongs to the previous item)
+        // update it to end at the newline (start - 1)
+        if (spanStart < start) {
+          val spanFlags = s.getSpanFlags(existingSpan)
+          s.setSpan(existingSpan, spanStart, start - 1, spanFlags)
+        }
+      }
+
+      s.insert(cursorPosition, EnrichedConstants.ZWS_STRING)
+      setSpan(s, name, start, end + 1)
+      // Inform that new span has been added
+      view.selection?.validateStyles()
+      return
+    }
+
+    if (name === EnrichedSpans.CHECKBOX_LIST) {
+      if (spans.isNotEmpty()) {
+        val previousSpan = spans[0] as EnrichedInputCheckboxListSpan
+        val isChecked = previousSpan.isChecked
+
+        for (span in spans) {
+          s.removeSpan(span)
+        }
+
+        setSpan(s, EnrichedSpans.CHECKBOX_LIST, start, end, isChecked)
+      }
+
+      return
+    }
+
+    if (spans.isNotEmpty()) {
+      for (span in spans) {
+        s.removeSpan(span)
+      }
+
+      setSpan(s, name, start, end)
+    }
+  }
+
+  fun afterTextChanged(
+    s: Editable,
+    endCursorPosition: Int,
+    previousTextLength: Int,
+  ) {
+    handleAfterTextChanged(s, EnrichedSpans.ORDERED_LIST, endCursorPosition, previousTextLength)
+    handleAfterTextChanged(s, EnrichedSpans.UNORDERED_LIST, endCursorPosition, previousTextLength)
+    handleAfterTextChanged(s, EnrichedSpans.CHECKBOX_LIST, endCursorPosition, previousTextLength)
+  }
+
+  fun getStyleRange(): Pair<Int, Int> = view.selection?.getParagraphSelection() ?: Pair(0, 0)
+
+  fun removeStyle(
+    name: String,
+    start: Int,
+    end: Int,
+  ): Boolean {
+    val config = EnrichedSpans.listSpans[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 → textinput/styles}/ParagraphStyles.kt

@@ -1,17 +1,25 @@
-package com.swmansion.enriched.styles
+package com.swmansion.enriched.textinput.styles
 
 import android.text.Editable
 import android.text.Spannable
 import android.text.SpannableStringBuilder
 import android.util.Log
-import com.swmansion.enriched.EnrichedTextInputView
-import com.swmansion.enriched.spans.EnrichedSpans
-import com.swmansion.enriched.spans.interfaces.EnrichedSpan
-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.common.EnrichedConstants
+import com.swmansion.enriched.textinput.EnrichedTextInputView
+import com.swmansion.enriched.textinput.spans.EnrichedSpans
+import com.swmansion.enriched.textinput.spans.interfaces.EnrichedInputSpan
+import com.swmansion.enriched.textinput.utils.getParagraphBounds
+import com.swmansion.enriched.textinput.utils.getSafeSpanBoundaries
+import com.swmansion.enriched.textinput.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)
@@ -30,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)
@@ -54,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)
@@ -75,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
@@ -87,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
@@ -102,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
@@ -157,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()
@@ -166,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)
 
@@ -193,7 +233,12 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     s.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
   }
 
-  private fun handleConflictsDuringNewlineDeletion(s: Editable, style: String, paragraphStart: Int, paragraphEnd: Int): Boolean {
+  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
@@ -214,12 +259,12 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
       }
 
       for (span in spans) {
-        extendStyleOnWholeParagraph(s, span as EnrichedSpan, conflictingType, paragraphEnd)
+        extendStyleOnWholeParagraph(s, span as EnrichedInputSpan, conflictingType, paragraphEnd)
       }
     }
 
     if (isConflicting) {
-      val styleStart =  spanState.getStart(style) ?: return false
+      val styleStart = spanState.getStart(style) ?: return false
       spanState.setStart(style, null)
       removeStyle(style, styleStart, paragraphEnd)
       return true
@@ -228,8 +273,12 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     return false
   }
 
-
-  private fun deleteConflictingAndBlockingStyles(s: Editable, style: String, paragraphStart: Int, paragraphEnd: Int) {
+  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
 
@@ -243,17 +292,26 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
     }
   }
 
-  private fun <T>extendStyleOnWholeParagraph(s: Editable, span: EnrichedSpan, type: Class<T>, paragraphEnd: Int) {
+  private fun <T> extendStyleOnWholeParagraph(
+    s: Editable,
+    span: EnrichedInputSpan,
+    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) {
+  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) {
@@ -267,7 +325,7 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
           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)
+            extendStyleOnWholeParagraph(s, span as EnrichedInputSpan, config.clazz, end)
           }
         }
 
@@ -287,7 +345,7 @@ class ParagraphStyles(private val view: EnrichedTextInputView) {
           endCursorPosition -= 1
           spanState.setStart(style, null)
         } else {
-          s.insert(endCursorPosition, "\u200B")
+          s.insert(endCursorPosition, EnrichedConstants.ZWS_STRING)
           endCursorPosition += 1
         }
       }
@@ -336,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()
 
@@ -348,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
     }
@@ -357,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)