react-native-enriched-html 0.0.0 → 1.0.0

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

@@ -0,0 +1,367 @@
+package com.swmansion.enriched.textinput.styles
+
+import android.text.Editable
+import android.text.Spannable
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.common.EnrichedConstants
+import com.swmansion.enriched.textinput.EnrichedTextInputView
+import com.swmansion.enriched.textinput.spans.EnrichedInputAlignmentSpan
+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.utils.getParagraphBounds
+import com.swmansion.enriched.textinput.utils.getSafeSpanBoundaries
+import com.swmansion.enriched.textinput.utils.safelyInsertZWS
+
+class AlignmentStyles(
+  private val view: EnrichedTextInputView,
+) {
+  private fun setAlignmentSpan(
+    spannable: Spannable,
+    cssValue: String,
+    start: Int,
+    end: Int,
+    flags: Int = Spannable.SPAN_EXCLUSIVE_EXCLUSIVE,
+  ) {
+    val (safeStart, safeEnd) = spannable.getSafeSpanBoundaries(start, end)
+    spannable.setSpan(
+      EnrichedInputAlignmentSpan(cssValue),
+      safeStart,
+      safeEnd,
+      flags,
+    )
+  }
+
+  private fun toCssValue(alignment: String): String =
+    when (alignment) {
+      "center" -> "center"
+      "right" -> "right"
+      "left" -> "left"
+      else -> "auto"
+    }
+
+  private fun getActiveListSpanType(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+  ): Class<*>? {
+    if (spannable.getSpans(start, end, EnrichedInputUnorderedListSpan::class.java).isNotEmpty()) {
+      return EnrichedInputUnorderedListSpan::class.java
+    }
+    if (spannable.getSpans(start, end, EnrichedInputOrderedListSpan::class.java).isNotEmpty()) {
+      return EnrichedInputOrderedListSpan::class.java
+    }
+    if (spannable.getSpans(start, end, EnrichedInputCheckboxListSpan::class.java).isNotEmpty()) {
+      return EnrichedInputCheckboxListSpan::class.java
+    }
+    return null
+  }
+
+  /**
+   * Expands [start, end] to cover all contiguous paragraphs that belong to the same list type.
+   * Alignment changes must apply to entire lists, not individual items within them.
+   */
+  private fun expandRangeToContiguousList(
+    spannable: Spannable,
+    start: Int,
+    end: Int,
+  ): Pair<Int, Int> {
+    if (spannable.isEmpty()) return Pair(start, end)
+
+    var expandedStart = start
+    var expandedEnd = end
+
+    // Expand backward through paragraphs of the same list type.
+    var (currentParaStart, currentParaEnd) = spannable.getParagraphBounds(start)
+    val activeStartType = getActiveListSpanType(spannable, currentParaStart, currentParaEnd)
+
+    if (activeStartType != null) {
+      expandedStart = currentParaStart
+      while (currentParaStart > 0) {
+        val (prevParaStart, prevParaEnd) = spannable.getParagraphBounds(currentParaStart - 1)
+        if (getActiveListSpanType(spannable, prevParaStart, prevParaEnd) == activeStartType) {
+          expandedStart = prevParaStart
+          currentParaStart = prevParaStart
+        } else {
+          break
+        }
+      }
+    }
+
+    // Expand forward through paragraphs of the same list type.
+    val endLoc = if (end > start) end - 1 else start
+    var (endParaStart, endParaEnd) = spannable.getParagraphBounds(endLoc)
+    val activeEndType = getActiveListSpanType(spannable, endParaStart, endParaEnd)
+
+    if (activeEndType != null) {
+      expandedEnd = endParaEnd
+      while (endParaEnd < spannable.length) {
+        val nextCursor = endParaEnd + 1
+        if (nextCursor >= spannable.length) break
+
+        val (nextParaStart, nextParaEnd) = spannable.getParagraphBounds(nextCursor)
+        if (getActiveListSpanType(spannable, nextParaStart, nextParaEnd) == activeEndType) {
+          expandedEnd = nextParaEnd
+          endParaEnd = nextParaEnd
+        } else {
+          break
+        }
+      }
+    }
+
+    return Pair(expandedStart, expandedEnd)
+  }
+
+  fun afterTextChanged(
+    s: Editable,
+    cursorPosition: Int,
+    deletedText: String,
+    anchorAlignmentToRestore: String? = null,
+  ) {
+    val isJustNewline = cursorPosition > 0 && s[cursorPosition - 1] == '\n'
+    val isOtherStyleInjectedZws =
+      cursorPosition > 1 &&
+        s[cursorPosition - 1].toString() == EnrichedConstants.ZWS_STRING &&
+        s[cursorPosition - 2] == '\n'
+    val isNewLineInserted = deletedText.isEmpty() && (isJustNewline || isOtherStyleInjectedZws)
+
+    val includesNewlineDeletion = deletedText.contains('\n')
+    val isZwsDeleted = deletedText == EnrichedConstants.ZWS_STRING
+
+    // Track cursor separately because deleting a newline shifts text indices.
+    var activeCursor = cursorPosition
+
+    // Exit early if no alignment spans exist in the current or previous paragraph.
+    if (anchorAlignmentToRestore == null) {
+      val bounded = activeCursor.coerceIn(0, s.length)
+      val (paraStart, paraEnd) = s.getParagraphBounds(bounded)
+      val prevStart = if (paraStart > 0) s.getParagraphBounds(paraStart - 1).first else 0
+      if (s.getSpans(prevStart, paraEnd, EnrichedInputAlignmentSpan::class.java).isEmpty()) {
+        view.selection?.validateStyles()
+        return
+      }
+    }
+
+    if (isNewLineInserted) {
+      activeCursor = handleNewlineInheritance(s, activeCursor, isOtherStyleInjectedZws)
+      autoStretchAlignmentSpan(s, activeCursor)
+    } else if (isZwsDeleted && anchorAlignmentToRestore != null) {
+      val (paraStart, paraEnd) = s.getParagraphBounds(activeCursor)
+      (s as SpannableStringBuilder).safelyInsertZWS(activeCursor)
+      if (paraStart == paraEnd) {
+        setAlignmentSpan(s, anchorAlignmentToRestore, activeCursor, activeCursor + 1)
+      }
+      autoStretchAlignmentSpan(s, activeCursor)
+    } else {
+      if (isZwsDeleted) {
+        activeCursor = handleZwsBackspace(s, activeCursor)
+      }
+      view.runAsATransaction {
+        if (includesNewlineDeletion) {
+          activeCursor = handleParagraphMerge(s, activeCursor)
+        }
+
+        autoStretchAlignmentSpan(s, activeCursor)
+      }
+    }
+
+    view.selection?.validateStyles()
+  }
+
+  /**
+   * Ensures the alignment span perfectly wraps the paragraph boundaries at [activeCursor].
+   * If a newline was inserted mid-paragraph the span is split; otherwise it is stretched
+   * to cover any newly typed text.
+   */
+  private fun autoStretchAlignmentSpan(
+    s: Editable,
+    activeCursor: Int,
+  ) {
+    val (paraStart, paraEnd) = s.getParagraphBounds(activeCursor)
+    val spans = s.getSpans(paraStart, paraEnd, EnrichedInputAlignmentSpan::class.java)
+
+    if (spans.isEmpty()) return
+
+    val dominantCss = spans.first().cssValue
+    // Remove and trim all existing alignment spans that overlap this paragraph.
+    for (span in spans) {
+      val sStart = s.getSpanStart(span)
+      val sEnd = s.getSpanEnd(span)
+      val cssValue = span.cssValue
+
+      s.removeSpan(span)
+
+      // This ensures top fragments always end before the '\n' character, not at the paraStart
+      if (sStart < paraStart) {
+        val topEnd = if (paraStart > 0 && s[paraStart - 1] == '\n') paraStart - 1 else paraStart
+        if (sStart < topEnd) {
+          setAlignmentSpan(s, cssValue, sStart, topEnd)
+        }
+      }
+      // This ensures bottom fragments always begin at the first character of the next paragraph, not on the '\n'  character
+      if (sEnd > paraEnd) {
+        val bottomStart = if (paraEnd < s.length && s[paraEnd] == '\n') paraEnd + 1 else paraEnd
+        if (bottomStart < sEnd) {
+          setAlignmentSpan(s, cssValue, bottomStart, sEnd)
+        }
+      }
+    }
+
+    // Re-apply a single span for the current paragraph with exact bounds.
+    setAlignmentSpan(s, dominantCss, paraStart, paraEnd)
+  }
+
+  fun setAlignment(alignment: String) {
+    val spannable = view.text as? SpannableStringBuilder ?: return
+    val selection = view.selection ?: return
+
+    val (rawStart, rawEnd) = selection.getParagraphSelection()
+    val (start, end) = expandRangeToContiguousList(spannable, rawStart, rawEnd)
+    val cssValue = toCssValue(alignment)
+
+    var shiftedEnd = end
+    var cursor = start
+
+    while (cursor <= shiftedEnd) {
+      val (paraStart, paraEnd) = spannable.getParagraphBounds(cursor)
+
+      cleanUpExistingSpans(spannable, paraStart, paraEnd)
+
+      if (cssValue != "auto") {
+        if (paraStart == paraEnd) {
+          // Empty paragraph: anchor alignment with a ZWS so the cursor sits inside the span.
+          spannable.safelyInsertZWS(paraStart)
+          setAlignmentSpan(spannable, cssValue, paraStart, paraStart + 1)
+
+          shiftedEnd++
+          if (paraStart + 1 >= shiftedEnd) break
+          cursor = paraStart + 2
+          continue
+        } else {
+          val wasInserted = spannable.safelyInsertZWS(paraStart)
+          val shift = if (wasInserted) 1 else 0
+          setAlignmentSpan(spannable, cssValue, paraStart, paraEnd + shift)
+          if (wasInserted) shiftedEnd++
+        }
+      }
+
+      if (paraEnd >= shiftedEnd || paraEnd == spannable.length) break
+      cursor = paraEnd + 1
+    }
+  }
+
+  fun getCurrentAlignment(): String {
+    val spannable = view.text as? Spannable ?: return "auto"
+    val selection = view.selection ?: return "auto"
+
+    val cursorPos = selection.start.coerceAtLeast(0).coerceAtMost(spannable.length)
+    val (paraStart, paraEnd) = spannable.getParagraphBounds(cursorPos)
+    val spans = spannable.getSpans(paraStart, paraEnd, EnrichedInputAlignmentSpan::class.java)
+
+    return spans.firstOrNull()?.cssValue ?: "auto"
+  }
+
+  private fun handleZwsBackspace(
+    s: Editable,
+    cursorPosition: Int,
+  ): Int {
+    if (cursorPosition > 0 && s[cursorPosition - 1] == '\n') {
+      val (currentParaStart, currentParaEnd) = s.getParagraphBounds(cursorPosition)
+      s
+        .getSpans(currentParaStart, currentParaEnd, EnrichedInputAlignmentSpan::class.java)
+        .forEach { s.removeSpan(it) }
+      s.delete(cursorPosition - 1, cursorPosition)
+      view.setSelection(cursorPosition - 1)
+      return cursorPosition - 1
+    } else if (cursorPosition == 0) {
+      val (paraStart, paraEnd) = s.getParagraphBounds(0)
+      s
+        .getSpans(paraStart, paraEnd, EnrichedInputAlignmentSpan::class.java)
+        .forEach { s.removeSpan(it) }
+      return 0
+    }
+    return cursorPosition
+  }
+
+  private fun handleParagraphMerge(
+    s: Editable,
+    cursorPosition: Int,
+  ): Int {
+    val (paraStart, paraEnd) = s.getParagraphBounds(cursorPosition)
+    val spans = s.getSpans(paraStart, paraEnd, EnrichedInputAlignmentSpan::class.java)
+    var dominantTopSpan: EnrichedInputAlignmentSpan? = null
+
+    spans.forEach { span ->
+      if (s.getSpanStart(span) >= cursorPosition) {
+        s.removeSpan(span)
+      } else {
+        dominantTopSpan = span
+      }
+    }
+
+    // INCLUSIVE_EXCLUSIVE is intentional here: autoStretchAlignmentSpan will convert
+    // it to EXCLUSIVE_EXCLUSIVE once the merge is complete.
+    val (safeStart, safeEnd) = s.getSafeSpanBoundaries(paraStart, paraEnd)
+    dominantTopSpan?.let { s.setSpan(it, safeStart, safeEnd, Spannable.SPAN_INCLUSIVE_EXCLUSIVE) }
+    return cursorPosition
+  }
+
+  private fun handleNewlineInheritance(
+    s: Editable,
+    cursorPosition: Int,
+    isZwsInjected: Boolean,
+  ): Int {
+    val prevCharIndex = (if (isZwsInjected) cursorPosition - 2 else cursorPosition - 1) - 1
+    if (prevCharIndex < 0) return cursorPosition
+
+    val (prevParaStart, prevParaEnd) = s.getParagraphBounds(prevCharIndex)
+    val prevSpan =
+      s
+        .getSpans(prevParaStart, prevParaEnd, EnrichedInputAlignmentSpan::class.java)
+        .firstOrNull() ?: return cursorPosition
+
+    val (newParaStart, newParaEnd) = s.getParagraphBounds(cursorPosition)
+
+    return if (newParaStart == newParaEnd) {
+      (s as SpannableStringBuilder).safelyInsertZWS(cursorPosition)
+      setAlignmentSpan(s, prevSpan.cssValue, cursorPosition, cursorPosition + 1)
+      cursorPosition + 1
+    } else {
+      (s as SpannableStringBuilder).safelyInsertZWS(newParaStart)
+      setAlignmentSpan(s, prevSpan.cssValue, newParaStart, newParaEnd + 1)
+      cursorPosition + 1
+    }
+  }
+
+  /**
+   * Removes all alignment spans that overlap [paraStart, paraEnd], trimming any span
+   * that extends beyond the paragraph rather than deleting it entirely.
+   */
+  private fun cleanUpExistingSpans(
+    spannable: SpannableStringBuilder,
+    paraStart: Int,
+    paraEnd: Int,
+  ) {
+    val existing = spannable.getSpans(paraStart, paraEnd, EnrichedInputAlignmentSpan::class.java)
+    for (span in existing) {
+      val sStart = spannable.getSpanStart(span)
+      val sEnd = spannable.getSpanEnd(span)
+      spannable.removeSpan(span)
+
+      // This ensures top fragments always end before the '\n' character, not at the paraStart
+      if (sStart < paraStart) {
+        val topEnd = if (paraStart > 0 && spannable[paraStart - 1] == '\n') paraStart - 1 else paraStart
+        if (sStart < topEnd) {
+          setAlignmentSpan(spannable, span.cssValue, sStart, topEnd)
+        }
+      }
+      // This ensures bottom fragments always begin at the first character of the next paragraph, not on the '\n'  character
+      if (sEnd > paraEnd) {
+        val bottomStart = if (paraEnd < spannable.length && spannable[paraEnd] == '\n') paraEnd + 1 else paraEnd
+        if (bottomStart < sEnd) {
+          setAlignmentSpan(spannable, span.cssValue, bottomStart, sEnd)
+        }
+      }
+    }
+  }
+}