react-native-enriched-html 0.0.0 → 1.0.1

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

@@ -0,0 +1,261 @@
+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.common.EnrichedSpanFlags
+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.safelyInsertZWS
+import com.swmansion.enriched.textinput.utils.safelyRemoveZWS
+
+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, EnrichedSpanFlags.forSpan(span))
+      }
+
+      EnrichedSpans.ORDERED_LIST -> {
+        val index = getOrderedListIndex(spannable, safeStart)
+        val span = EnrichedInputOrderedListSpan(index, view.htmlStyle)
+        spannable.setSpan(span, safeStart, safeEnd, EnrichedSpanFlags.forSpan(span))
+      }
+
+      EnrichedSpans.CHECKBOX_LIST -> {
+        val span = EnrichedInputCheckboxListSpan(isChecked ?: false, view.htmlStyle)
+        spannable.setSpan(span, safeStart, safeEnd, EnrichedSpanFlags.forSpan(span))
+
+        // 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.safelyRemoveZWS(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) {
+      val wasInserted = spannable.safelyInsertZWS(start)
+      val shift = if (wasInserted) 1 else 0
+
+      view.spanState?.setStart(name, start + shift)
+      removeSpansForRange(spannable, start, end, config.clazz)
+      setSpan(spannable, name, start, end + shift, checkboxState)
+
+      return
+    }
+
+    var currentStart = start
+    val paragraphs = spannable.substring(start, end).split("\n")
+    removeSpansForRange(spannable, start, end, config.clazz)
+
+    for (paragraph in paragraphs) {
+      val wasInserted = spannable.safelyInsertZWS(currentStart)
+      val shift = if (wasInserted) 1 else 0
+      val currentEnd = currentStart + paragraph.length + shift
+      setSpan(spannable, name, currentStart, currentEnd, checkboxState)
+
+      // Safely jump exactly 1 character over the '\n' to the next line
+      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 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 && 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)
+        }
+      }
+
+      val wasInserted = (s as SpannableStringBuilder).safelyInsertZWS(cursorPosition)
+      val shift = if (wasInserted) 1 else 0
+      setSpan(s, name, start, end + shift)
+      // 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/textinput/styles/ParagraphStyles.kt

@@ -0,0 +1,440 @@
+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.common.EnrichedSpanFlags
+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.safelyInsertZWS
+import com.swmansion.enriched.textinput.utils.safelyRemoveZWS
+
+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)
+    val spans = spannable.getSpans(previousParagraphStart, previousParagraphEnd, type)
+
+    // A paragraph implies a single cohesive style. having multiple spans of the
+    // same type (e.g., two codeblock spans) in one paragraph is an invalid state in current library logic
+    if (spans.size > 1) {
+      Log.w("ParagraphStyles", "getPreviousParagraphSpan(): Found more than one span in the paragraph!")
+    }
+
+    if (spans.isNotEmpty()) {
+      return spans.first()
+    }
+
+    return null
+  }
+
+  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)
+
+    val spans = spannable.getSpans(nextParagraphStart, nextParagraphEnd, type)
+
+    // A paragraph implies a single cohesive style. having multiple spans of the
+    // same type (e.g., two codeblock spans) in one paragraph is an invalid state in current library logic
+    if (spans.size > 1) {
+      Log.w("ParagraphStyles", "getNextParagraphSpan(): Found more than one span in the paragraph!")
+    }
+
+    if (spans.isNotEmpty()) {
+      return spans.first()
+    }
+
+    return null
+  }
+
+  /**
+   * 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>,
+  ) {
+    val span = type.getDeclaredConstructor(HtmlStyle::class.java).newInstance(view.htmlStyle)
+    val previousSpan = getPreviousParagraphSpan(spannable, start, type)
+    val nextSpan = getNextParagraphSpan(spannable, end, type)
+    var newStart = start
+    var newEnd = end
+
+    if (previousSpan != null) {
+      newStart = spannable.getSpanStart(previousSpan)
+      spannable.removeSpan(previousSpan)
+    }
+
+    if (nextSpan != null && start != end) {
+      newEnd = spannable.getSpanEnd(nextSpan)
+      spannable.removeSpan(nextSpan)
+    }
+
+    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(newStart, newEnd)
+    spannable.setSpan(span, safeStart, safeEnd, EnrichedSpanFlags.forSpan(span))
+  }
+
+  private fun <T> setSpan(
+    spannable: Spannable,
+    type: Class<T>,
+    start: Int,
+    end: Int,
+  ) {
+    if (EnrichedSpans.isTypeContinuous(type)) {
+      setContinuousSpan(spannable, start, end, type)
+      return
+    }
+
+    val span = type.getDeclaredConstructor(HtmlStyle::class.java).newInstance(view.htmlStyle)
+    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, end)
+    spannable.setSpan(span, safeStart, safeEnd, EnrichedSpanFlags.forSpan(span))
+  }
+
+  // Removes spans of the given type in the specified range.
+  // If the removed span intersects with the range, it will be split and the remaining part will be re-applied after the removal
+  // Returns true if any spans were removed, false otherwise
+  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) {
+      val spanStart = ssb.getSpanStart(span)
+      val spanEnd = ssb.getSpanEnd(span)
+      ssb.removeSpan(span)
+
+      if (spanStart < start) {
+        setSpan(ssb, clazz, spanStart, start - 1)
+      }
+
+      if (spanEnd > end) {
+        setSpan(ssb, clazz, end + 1, spanEnd)
+      }
+    }
+
+    ssb.safelyRemoveZWS(start, end)
+    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()
+  }
+
+  private fun <T> mergeAdjacentStyleSpans(
+    s: Editable,
+    endCursorPosition: Int,
+    type: Class<T>,
+  ) {
+    val (start, end) = s.getParagraphBounds(endCursorPosition)
+    val currParagraphSpans = s.getSpans(start, end, type)
+
+    if (currParagraphSpans.isEmpty()) {
+      return
+    }
+
+    val currSpan = currParagraphSpans[0]
+    val nextSpan = getNextParagraphSpan(s, end, type) ?: return
+
+    val newStart = s.getSpanStart(currSpan)
+    val newEnd = s.getSpanEnd(nextSpan)
+
+    s.removeSpan(nextSpan)
+    s.removeSpan(currSpan)
+
+    val (safeStart, safeEnd) = s.getSafeSpanBoundaries(newStart, newEnd)
+    val span = type.getDeclaredConstructor(HtmlStyle::class.java).newInstance(view.htmlStyle)
+
+    s.setSpan(span, safeStart, safeEnd, EnrichedSpanFlags.forSpan(span))
+  }
+
+  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 EnrichedInputSpan, 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: 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,
+  ) {
+    var endCursorPosition = endPosition
+    val isBackspace = s.length < previousTextLength
+    val isNewLine = endCursorPosition == 0 || (endCursorPosition > 0 && s[endCursorPosition - 1] == '\n')
+    val spanState = view.spanState ?: return
+
+    for ((style, config) in EnrichedSpans.paragraphSpans) {
+      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 EnrichedInputSpan, config.clazz, end)
+          }
+        }
+
+        if (config.isContinuous) {
+          mergeAdjacentStyleSpans(s, endCursorPosition, config.clazz)
+        }
+        continue
+      }
+
+      if (isNewLine) {
+        // If removing text at the beginning of the line, we want to remove the span for the whole paragraph
+        if (isBackspace) {
+          val currentParagraphBounds = s.getParagraphBounds(endCursorPosition)
+          removeSpansForRange(s, currentParagraphBounds.first, currentParagraphBounds.second, config.clazz)
+          spanState.setStart(style, null)
+          continue
+        }
+
+        if (!config.isContinuous) {
+          spanState.setStart(style, null)
+          continue
+        }
+
+        val wasInserted = (s as SpannableStringBuilder).safelyInsertZWS(endCursorPosition)
+        val shift = if (wasInserted) 1 else 0
+        endCursorPosition += shift
+      }
+
+      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)
+
+      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) {
+      val wasInserted = spannable.safelyInsertZWS(start)
+      val shift = if (wasInserted) 1 else 0
+      setAndMergeSpans(spannable, type, start, end + shift)
+      view.selection.validateStyles()
+
+      return
+    }
+
+    var currentStart = start
+    var currentEnd = currentStart
+    val paragraphs = spannable.substring(start, end).split("\n")
+
+    for (paragraph in paragraphs) {
+      val wasInserted = spannable.safelyInsertZWS(currentStart)
+      val shift = if (wasInserted) 1 else 0
+      currentEnd = currentStart + paragraph.length + shift
+
+      // Safely jump exactly 1 character over the '\n' to the next line
+      currentStart = currentEnd + 1
+    }
+
+    setAndMergeSpans(spannable, type, start, currentEnd)
+    view.selection.validateStyles()
+  }
+
+  fun getStyleRange(): Pair<Int, Int> = 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)
+  }
+}