react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/BlockStore.kt

@@ -0,0 +1,254 @@
+package com.swmansion.enriched.markdown.input.formatting
+
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
+import com.swmansion.enriched.markdown.input.model.MAX_LIST_DEPTH
+import java.util.Collections
+
+/**
+ * Stores the block-level (paragraph-scoped) ranges for the editor, mirroring
+ * [FormattingStore]. Unlike inline ranges, block ranges never overlap: at most
+ * one block covers any given paragraph, and ranges are kept normalized to
+ * whole-line boundaries.
+ */
+class BlockStore {
+  private val ranges = mutableListOf<BlockRange>()
+
+  val allRanges: List<BlockRange> get() = Collections.unmodifiableList(ranges)
+
+  /**
+   * Returns the block whose paragraph starts exactly at [lineStart], or null.
+   * [ranges] is kept sorted by `start`, so this is an O(log n) binary search —
+   * the single lookup the view funnels through instead of the linear
+   * `allRanges.firstOrNull { it.start == lineStart }` scans it used to repeat.
+   * Relies on the one-block-per-paragraph invariant (starts are unique).
+   */
+  fun blockStartingAt(lineStart: Int): BlockRange? {
+    var lo = 0
+    var hi = ranges.size - 1
+    while (lo <= hi) {
+      val mid = (lo + hi) ushr 1
+      val start = ranges[mid].start
+      when {
+        start < lineStart -> lo = mid + 1
+        start > lineStart -> hi = mid - 1
+        else -> return ranges[mid]
+      }
+    }
+    return null
+  }
+
+  /**
+   * Incoming ranges are trusted to be non-overlapping and line-scoped — the
+   * parser owns that invariant (md4c block structure never overlaps at the same
+   * nesting level, and nested containers are not yet mapped). Revisit
+   * enforcement here if a container block type (list, blockquote) is added.
+   */
+  fun setRanges(newRanges: List<BlockRange>) {
+    ranges.clear()
+    ranges.addAll(newRanges.sortedBy { it.start })
+    recomputeListMetadata()
+  }
+
+  fun clearAll() {
+    ranges.clear()
+  }
+
+  /**
+   * Sets/replaces the block on every paragraph the given range touches, expanding
+   * to whole-line boundaries within [text]. Removes any block previously covering
+   * those paragraphs.
+   */
+  fun setBlock(
+    type: BlockType,
+    level: Int,
+    paragraphStart: Int,
+    paragraphEnd: Int,
+    text: CharSequence,
+  ) {
+    val (start, end) = paragraphBounds(paragraphStart, paragraphEnd, text)
+    removeBlocksOverlapping(start, end)
+    // An anchored block (heading, list item) on an empty line is kept as a zero-length
+    // anchor (see adjustForEdit); other blocks need real content.
+    if (end < start || (end == start && type !in BlockType.ANCHORED)) return
+
+    val block = BlockRange(type, start, end, level)
+    ranges.add(sortedInsertionIndex(ranges, start), block)
+  }
+
+  /**
+   * Clears any block on the paragraphs the given range touches (reverting them to
+   * the implicit paragraph default).
+   */
+  fun removeBlock(
+    paragraphStart: Int,
+    paragraphEnd: Int,
+    text: CharSequence,
+  ) {
+    val (start, end) = paragraphBounds(paragraphStart, paragraphEnd, text)
+    removeBlocksOverlapping(start, end)
+  }
+
+  /**
+   * Shifts/clips block ranges to follow a text edit (see [RangeEditAdjustment]),
+   * with anchored-block (heading / list item) persistence layered on top: a block
+   * deleted exactly to its end collapses to a zero-length anchor at the edit
+   * location (its line survives), and existing anchors shift/keep/drop with their
+   * line. The view's prune/normalize pass reconciles anchors against the final text.
+   */
+  fun adjustForEdit(
+    editLocation: Int,
+    deletedLength: Int,
+    insertedLength: Int,
+  ) {
+    if (deletedLength == 0 && insertedLength == 0) return
+
+    val deleteEnd = editLocation + deletedLength
+    val delta = insertedLength - deletedLength
+
+    val anchors = ranges.filter { it.length == 0 && it.type in BlockType.ANCHORED }
+    ranges.removeAll { it.length == 0 }
+
+    // At most one range can end exactly at deleteEnd, so this restores at most
+    // one collapsed block.
+    val collapsed =
+      ranges.firstOrNull {
+        it.type in BlockType.ANCHORED && it.start >= editLocation && it.end == deleteEnd
+      }
+
+    RangeEditAdjustment.adjustForEdit(
+      ranges,
+      editLocation,
+      deletedLength,
+      insertedLength,
+      inheritsReplacementAtStart = { true },
+      growsAtStartOnInsert = { true },
+    )
+
+    for (anchor in anchors) {
+      when {
+        anchor.start <= editLocation -> { /* keeps its position */ }
+
+        anchor.start >= deleteEnd -> {
+          anchor.start += delta
+          anchor.end = anchor.start
+        }
+
+        else -> {
+          continue // the anchor's line was deleted
+        }
+      }
+      ranges.add(sortedInsertionIndex(ranges, anchor.start), anchor)
+    }
+
+    if (collapsed != null && collapsed !in ranges) {
+      ranges.add(
+        sortedInsertionIndex(ranges, editLocation),
+        BlockRange(collapsed.type, editLocation, editLocation, collapsed.level),
+      )
+    }
+  }
+
+  /**
+   * Snaps every stored range to the line bounds of its start position.
+   * Absorbs edge-typed chars, clips split ranges to first line, drops
+   * duplicates. On an empty line an anchored block (heading, list item)
+   * persists as a zero-length anchor; any other collapsed range is dropped.
+   * List depths are clamped so an item nests at most one level under the
+   * previous adjacent item (CommonMark cannot represent orphan nesting).
+   * Call after [adjustForEdit] once [text] is final. Idempotent.
+   */
+  fun normalizeToLineBounds(text: CharSequence) {
+    if (ranges.isEmpty()) return
+
+    var previousEnd = -1
+    val iterator = ranges.listIterator()
+    while (iterator.hasNext()) {
+      val range = iterator.next()
+      val (lineStart, lineEnd) = paragraphBounds(range.start, range.start, text)
+      val isEmptyLine = lineEnd == lineStart
+      if ((isEmptyLine && range.type !in BlockType.ANCHORED) || lineStart <= previousEnd) {
+        // Dedup: drop a range that resolves to an already-claimed paragraph. This is
+        // a legitimate self-heal path (a heading anchor and the block it merges into
+        // can briefly share a start after a line-join), so it is deliberately silent.
+        iterator.remove()
+        continue
+      }
+      range.start = lineStart
+      range.end = lineEnd
+      previousEnd = lineEnd
+    }
+
+    recomputeListMetadata()
+  }
+
+  /**
+   * Clamps list depths to valid ancestry (an item nests at most one level under
+   * the previous adjacent list item — CommonMark cannot represent orphan nesting)
+   * and renumbers ordered items among their adjacent same-depth, same-type run.
+   */
+  private fun recomputeListMetadata() {
+    var prevEnd = -2
+    var prevDepth = -1
+    val counters = IntArray(MAX_LIST_DEPTH + 2)
+    val counterTypes = arrayOfNulls<BlockType>(MAX_LIST_DEPTH + 2)
+    for (range in ranges) {
+      if (range.type !in BlockType.LIST_ITEMS) {
+        prevDepth = -1
+        continue
+      }
+      val adjacent = prevDepth >= 0 && range.start == prevEnd + 1
+      if (!adjacent) {
+        counters.fill(0)
+        counterTypes.fill(null)
+      }
+      val maxDepth = if (adjacent) prevDepth + 1 else 0
+      if (range.level > maxDepth) range.level = maxDepth
+      val depth = range.level
+      for (i in depth + 1..MAX_LIST_DEPTH + 1) {
+        counters[i] = 0
+        counterTypes[i] = null
+      }
+      if (counterTypes[depth] != range.type) {
+        counters[depth] = 0
+        counterTypes[depth] = range.type
+      }
+      counters[depth]++
+      range.ordinal = counters[depth]
+      prevEnd = range.end
+      prevDepth = range.level
+    }
+  }
+
+  /**
+   * Drops any stored block overlapping `[start, end)`. Blocks never partially
+   * overlap, so a touched block is removed wholesale; a zero-length anchor is
+   * dropped when it sits within the bounds (so toggle-off clears an empty line).
+   */
+  private fun removeBlocksOverlapping(
+    start: Int,
+    end: Int,
+  ) {
+    ranges.removeAll { (it.end > start && it.start < end) || (it.length == 0 && it.start in start..end) }
+  }
+
+  /** Expands a selection to cover whole lines (line-scoped block boundaries). */
+  private fun paragraphBounds(
+    rangeStart: Int,
+    rangeEnd: Int,
+    text: CharSequence,
+  ): Pair<Int, Int> {
+    if (text.isEmpty()) return 0 to 0
+
+    val clampedStart = rangeStart.coerceIn(0, text.length)
+    val clampedEnd = rangeEnd.coerceIn(clampedStart, text.length)
+
+    var lineStart = clampedStart
+    while (lineStart > 0 && text[lineStart - 1] != '\n') lineStart--
+
+    var lineEnd = clampedEnd
+    while (lineEnd < text.length && text[lineEnd] != '\n') lineEnd++
+
+    return lineStart to lineEnd
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/FormattingStore.kt

@@ -53,6 +53,55 @@ class FormattingStore {
     return if (link != null && start > link.start && start < link.end) Pair(link.end, link.end) else null
   }
 
+  enum class ToggleResult {
+    /** The style was active and has been removed (or is active at the caret). */
+    WAS_ACTIVE,
+
+    /** The style was inactive and has been added (or is inactive at the caret). */
+    WAS_INACTIVE,
+  }
+
+  /**
+   * Toggles [type] on the range `[start, end)`. For a selection (`start < end`),
+   * removes the style when active at `start`, otherwise strips [conflictingStyles]
+   * and adds it. For a caret (`start == end`), reports the current state without
+   * mutating — the caller manages pending-style bookkeeping.
+   */
+  fun toggleStyle(
+    type: StyleType,
+    start: Int,
+    end: Int,
+    conflictingStyles: Set<StyleType>,
+  ): ToggleResult {
+    val isActive = isStyleActive(type, start)
+    if (start < end) {
+      if (isActive) {
+        removeType(type, start, end)
+      } else {
+        for (conflict in conflictingStyles) {
+          removeType(conflict, start, end)
+        }
+        addRange(FormattingRange(type, start, end))
+      }
+    }
+    return if (isActive) ToggleResult.WAS_ACTIVE else ToggleResult.WAS_INACTIVE
+  }
+
+  /**
+   * Returns true when toggling [type] ON at [position] should be refused
+   * because one of the [blockingStyles] is currently active there.
+   * Toggling OFF (the style is already active) is never blocked.
+   */
+  fun isToggleBlocked(
+    type: StyleType,
+    position: Int,
+    blockingStyles: Set<StyleType>,
+  ): Boolean {
+    if (blockingStyles.isEmpty()) return false
+    if (isStyleActive(type, position)) return false
+    return blockingStyles.any { isStyleActive(it, position) }
+  }
+
   fun addRange(newRange: FormattingRange) {
     var mergedStart = newRange.start
     var mergedEnd = newRange.end
@@ -72,7 +121,7 @@ class FormattingStore {
     }
 
     val merged = FormattingRange(newRange.type, mergedStart, mergedEnd, newRange.url)
-    val insertAt = sortedInsertionIndex(mergedStart)
+    val insertAt = sortedInsertionIndex(ranges, mergedStart)
     ranges.add(insertAt, merged)
   }
 
@@ -104,7 +153,7 @@ class FormattingStore {
 
     // Remainders are fragments of a just-removed range and cannot overlap others.
     for (remainder in remainders) {
-      val insertAt = sortedInsertionIndex(remainder.start)
+      val insertAt = sortedInsertionIndex(ranges, remainder.start)
       ranges.add(insertAt, remainder)
     }
   }
@@ -113,99 +162,43 @@ class FormattingStore {
     ranges.remove(range)
   }
 
+  /** Shifts/clips formatting ranges to follow a text edit. See [RangeEditAdjustment]. */
   fun adjustForEdit(
     editLocation: Int,
     deletedLength: Int,
     insertedLength: Int,
   ) {
-    if (deletedLength == 0 && insertedLength == 0) return
-
-    val deleteEnd = editLocation + deletedLength
-    val indexesToRemove = mutableListOf<Int>()
+    RangeEditAdjustment.adjustForEdit(
+      ranges,
+      editLocation,
+      deletedLength,
+      insertedLength,
+      inheritsReplacementAtStart = { it.type != StyleType.LINK },
+    )
+    coalesceAdjacentSameTypeRanges()
+  }
 
-    for ((idx, range) in ranges.withIndex()) {
-      if (deletedLength > 0) {
-        when (classifyOverlap(range.start, range.end, editLocation, deleteEnd)) {
-          EditOverlap.BEFORE_EDIT -> { /* no change */ }
-
-          EditOverlap.AFTER_EDIT -> {
-            range.start = range.start - deletedLength + insertedLength
-            range.end = range.end - deletedLength + insertedLength
-          }
-
-          EditOverlap.FULLY_DELETED -> {
-            indexesToRemove.add(idx)
-          }
-
-          EditOverlap.DELETED_INSIDE -> {
-            range.end = range.end - deletedLength + insertedLength
-          }
-
-          EditOverlap.CLIPPED_END -> {
-            val newEnd = editLocation + insertedLength
-            val newLength = if (newEnd > range.start) newEnd - range.start else 0
-            range.end = range.start + newLength
-            if (newLength == 0) indexesToRemove.add(idx)
-          }
-
-          EditOverlap.CLIPPED_START -> {
-            val charsClipped = deleteEnd - range.start
-            val newStart = editLocation + insertedLength
-            val oldLength = range.length
-            range.start = newStart
-            range.end = newStart + oldLength - charsClipped
-            if (range.length == 0) indexesToRemove.add(idx)
-          }
-        }
-      } else {
-        when {
-          range.start >= editLocation -> {
-            range.start += insertedLength
-            range.end += insertedLength
-          }
-
-          editLocation > range.start && editLocation < range.end -> {
-            range.end += insertedLength
-          }
+  /**
+   * Merge same-type (and same-url) ranges left adjacent or overlapping by an
+   * edit — e.g. deleting the space in "**foo** **bar**" leaves two touching
+   * bold ranges that would serialize as "**foo****bar**". [addRange] keeps
+   * this invariant on insert; the edit path must too.
+   */
+  private fun coalesceAdjacentSameTypeRanges() {
+    var idx = 0
+    while (idx < ranges.size) {
+      val current = ranges[idx]
+      var next = idx + 1
+      while (next < ranges.size && ranges[next].start <= current.end) {
+        val candidate = ranges[next]
+        if (candidate.type == current.type && candidate.url == current.url) {
+          current.end = maxOf(current.end, candidate.end)
+          ranges.removeAt(next)
+        } else {
+          next++
         }
       }
+      idx++
     }
-
-    for (idx in indexesToRemove.reversed()) {
-      ranges.removeAt(idx)
-    }
-
-    ranges.removeAll { it.length == 0 }
-  }
-
-  private fun sortedInsertionIndex(location: Int): Int {
-    var index = 0
-    for (existing in ranges) {
-      if (existing.start > location) break
-      index++
-    }
-    return index
-  }
-
-  private enum class EditOverlap {
-    BEFORE_EDIT,
-    AFTER_EDIT,
-    FULLY_DELETED,
-    DELETED_INSIDE,
-    CLIPPED_END,
-    CLIPPED_START,
-  }
-
-  private fun classifyOverlap(
-    rangeStart: Int,
-    rangeEnd: Int,
-    editLocation: Int,
-    deleteEnd: Int,
-  ): EditOverlap {
-    if (rangeEnd <= editLocation) return EditOverlap.BEFORE_EDIT
-    if (rangeStart >= deleteEnd) return EditOverlap.AFTER_EDIT
-    if (rangeStart >= editLocation && rangeEnd <= deleteEnd) return EditOverlap.FULLY_DELETED
-    if (rangeStart < editLocation && rangeEnd > deleteEnd) return EditOverlap.DELETED_INSIDE
-    return if (rangeStart < editLocation) EditOverlap.CLIPPED_END else EditOverlap.CLIPPED_START
   }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/InputFormatter.kt

@@ -2,16 +2,23 @@ package com.swmansion.enriched.markdown.input.formatting
 
 import android.text.Spannable
 import android.text.style.CharacterStyle
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
 import com.swmansion.enriched.markdown.input.model.FormattingRange
 import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
 import com.swmansion.enriched.markdown.input.model.StyleType
+import com.swmansion.enriched.markdown.input.spans.InputListItemSpacingSpan
+import com.swmansion.enriched.markdown.input.styles.BlockHandler
 import com.swmansion.enriched.markdown.input.styles.BoldStyleHandler
+import com.swmansion.enriched.markdown.input.styles.HeadingBlockHandler
 import com.swmansion.enriched.markdown.input.styles.ItalicStyleHandler
 import com.swmansion.enriched.markdown.input.styles.LinkStyleHandler
+import com.swmansion.enriched.markdown.input.styles.OrderedListBlockHandler
 import com.swmansion.enriched.markdown.input.styles.SpoilerStyleHandler
 import com.swmansion.enriched.markdown.input.styles.StrikethroughStyleHandler
 import com.swmansion.enriched.markdown.input.styles.StyleHandler
 import com.swmansion.enriched.markdown.input.styles.UnderlineStyleHandler
+import com.swmansion.enriched.markdown.input.styles.UnorderedListBlockHandler
 
 /**
  * Marker interface so we only remove spans we created, leaving
@@ -19,7 +26,15 @@ import com.swmansion.enriched.markdown.input.styles.UnderlineStyleHandler
  */
 interface MarkdownSpan
 
-class InputFormatter {
+/**
+ * @property displayDensity px-per-dp of the host display, handed to the list block
+ *   handlers so they can build density-correct spans without a Context. This is a
+ *   platform constant, not style data, which is why it lives here rather than in
+ *   [InputFormatterStyle].
+ */
+class InputFormatter(
+  private val displayDensity: Float = 1f,
+) {
   val handlers: Map<StyleType, StyleHandler> =
     mapOf(
       StyleType.BOLD to BoldStyleHandler(),
@@ -30,6 +45,22 @@ class InputFormatter {
       StyleType.SPOILER to SpoilerStyleHandler(),
     )
 
+  /**
+   * Block handlers, keyed by block type. A single [HeadingBlockHandler] serves all
+   * six heading levels — it reads the level from the [BlockRange] — so it is mapped
+   * under every `HEADING_n` key. One [UnorderedListBlockHandler] serves every list
+   * depth (depth lives on the range), so it is mapped under the single list key.
+   */
+  val blockHandlers: Map<BlockType, BlockHandler> =
+    buildMap {
+      val heading = HeadingBlockHandler()
+      for (type in BlockType.HEADINGS) put(type, heading)
+      put(BlockType.UNORDERED_LIST_ITEM, UnorderedListBlockHandler(displayDensity))
+      put(BlockType.ORDERED_LIST_ITEM, OrderedListBlockHandler(displayDensity))
+    }
+
+  fun handlerForBlock(type: BlockType): BlockHandler? = blockHandlers[type]
+
   private var style: InputFormatterStyle? = null
 
   fun updateStyle(newStyle: InputFormatterStyle): Boolean {
@@ -38,16 +69,20 @@ class InputFormatter {
     return true
   }
 
+  fun resolveHeadingFontSizePx(level: Int): Float? = style?.headingStyle(level)?.fontSizePx
+
   fun applyFormatting(
     spannable: Spannable,
     ranges: List<FormattingRange>,
   ) {
     val currentStyle = style ?: return
 
+    val blockSpanClasses = blockHandlers.values.flatMap { it.spanClasses() }.toSet()
     val existingSpans =
       spannable
         .getSpans(0, spannable.length, CharacterStyle::class.java)
         .filterIsInstance<MarkdownSpan>()
+        .filter { span -> blockSpanClasses.none { it.isInstance(span) } }
     val linkSpanClasses = handlers[StyleType.LINK]?.spanClasses().orEmpty().toSet()
     val existingLinkSpans = existingSpans.filter { span -> linkSpanClasses.any { it.isInstance(span) } }
     for (span in existingLinkSpans) {
@@ -108,6 +143,79 @@ class InputFormatter {
     }
   }
 
+  /**
+   * Applies each block range's paragraph-scoped spans via its handler, after the
+   * inline pass. Mirrors [applyFormatting]: removes the block spans we previously
+   * set (identified by the registered handlers' [BlockHandler.spanClasses]) and
+   * re-applies from the current ranges. With no handlers registered (PR1) both
+   * the cleanup and the apply loops are no-ops, so block formatting is inert.
+   */
+  fun applyBlockFormatting(
+    spannable: Spannable,
+    blockRanges: List<BlockRange>,
+  ) = applyBlockFormatting(spannable, blockRanges, 0, spannable.length)
+
+  /**
+   * Re-stamps block spans, scoped to `[scopeStart, scopeEnd)`. Only the block spans
+   * we created that intersect the scope are removed, and only the block ranges
+   * intersecting the scope are re-applied — so an edit re-normalizes just the
+   * affected line(s) instead of the whole document on every keystroke. Pass the
+   * full document range for a wholesale re-apply (import / style change).
+   */
+  fun applyBlockFormatting(
+    spannable: Spannable,
+    blockRanges: List<BlockRange>,
+    scopeStart: Int,
+    scopeEnd: Int,
+  ) {
+    val currentStyle = style ?: return
+    if (blockHandlers.isEmpty()) return
+
+    val start = scopeStart.coerceIn(0, spannable.length)
+    val end = scopeEnd.coerceIn(start, spannable.length)
+
+    val blockSpanClasses = blockHandlers.values.flatMap { it.spanClasses() }.toSet()
+
+    val existingBlockSpans =
+      spannable
+        .getSpans(start, end, Any::class.java)
+        .filter { span -> span is MarkdownSpan && blockSpanClasses.any { it.isInstance(span) } }
+    for (span in existingBlockSpans) {
+      spannable.removeSpan(span)
+    }
+
+    for (range in blockRanges) {
+      val isAnchor = range.length == 0 && range.type in BlockType.ANCHORED
+      if (!isAnchor && (range.start >= range.end || range.start < 0 || range.end > spannable.length)) continue
+      if (isAnchor && (range.start < 0 || range.start > spannable.length)) continue
+      if (isAnchor) {
+        if (range.start < start || range.start > end) continue
+      } else if (range.end <= start || range.start >= end) {
+        continue
+      }
+      val handler = blockHandlers[range.type] ?: continue
+
+      // Extend a zero-length anchor to cover the next character (usually '\n') so
+      // the Layout gives the empty line the block's metrics. At the very end of
+      // text the span stays zero-length; the view-level paint override handles
+      // cursor height for that edge case.
+      val anchorEnd = if (isAnchor && range.start < spannable.length) range.start + 1 else range.end
+      val flags = if (isAnchor) Spannable.SPAN_INCLUSIVE_INCLUSIVE else Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
+      for (span in handler.createSpans(range, currentStyle)) {
+        // A LineHeightSpan (list-item spacing) must cover only the item's first
+        // character so it spaces just the first visual line, not wrapped lines.
+        val spanEnd =
+          if (span is InputListItemSpacingSpan) {
+            (range.start + 1).coerceAtMost(range.end).coerceAtMost(spannable.length)
+          } else {
+            anchorEnd
+          }
+        if (span is InputListItemSpacingSpan && spanEnd <= range.start) continue
+        spannable.setSpan(span, range.start, spanEnd, flags)
+      }
+    }
+  }
+
   private data class SpanDescriptor(
     val start: Int,
     val end: Int,