@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.10

package/android/src/main/java/com/renderrichtext/renderer/FactoidRenderer.kt

@@ -0,0 +1,97 @@
+package com.renderrichtext.renderer
+
+import android.graphics.Color
+import android.text.SpannableStringBuilder
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.FactoidBackgroundSpan
+import com.renderrichtext.spans.FactoidPaddingSpan
+import com.renderrichtext.spans.FactoidSpan
+import com.renderrichtext.spans.leadingFactoidEdge
+import com.renderrichtext.spans.trailingFactoidEdge
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class FactoidRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    // Node attributes replace one channel. Otherwise the spans use the same objects code uses:
+    // SpanStyleCache for the text color, StyleConfig for the background and border.
+    val textColor = node.getAttribute("color").toColorOrNull()
+    val backgroundColor = node.getAttribute("backgroundColor").toColorOrNull()
+    val borderColor = node.getAttribute("borderColor").toColorOrNull()
+    val factoidId = node.getAttribute("id").orEmpty()
+
+    // Children are inline nodes (text, marks, links). Push the text color onto the block style
+    // so they keep the surrounding font and pick up this color as their base.
+    factory.blockStyleContext.pushInlineColor(textColor ?: factory.styleCache.factoidColor)
+    try {
+      val contentStart = builder.length
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress)
+      val contentEnd = builder.length
+      if (contentEnd == contentStart) return
+
+      // The gap is extra advance on the edge word, not its own character. A character
+      // is a separate metric run, and the line breaker will leave those 8px on the
+      // previous line when the word wraps. A pill already has its own padding; the edge
+      // helpers refuse a run that is already a replacement.
+      val lead = leadingFactoidEdge(builder, contentStart, contentEnd)
+      val trail = trailingFactoidEdge(builder, contentStart, contentEnd)
+      if (lead != null && trail != null && lead.runEnd >= trail.runStart) {
+        builder.setSpan(
+          FactoidPaddingSpan(padStart = true, padEnd = true),
+          lead.runStart,
+          trail.runEnd,
+          SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+        )
+      } else {
+        if (lead != null) {
+          builder.setSpan(
+            FactoidPaddingSpan(padStart = true, padEnd = false),
+            lead.runStart,
+            lead.runEnd,
+            SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+          )
+        }
+        if (trail != null) {
+          builder.setSpan(
+            FactoidPaddingSpan(padStart = false, padEnd = true),
+            trail.runStart,
+            trail.runEnd,
+            SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+          )
+        }
+      }
+      builder.setSpan(
+        FactoidSpan(factory.styleCache, factoidId, onFactoidPress, textColor),
+        contentStart,
+        contentEnd,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+      builder.setSpan(
+        FactoidBackgroundSpan(config.style, backgroundColor, borderColor),
+        contentStart,
+        contentEnd,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    } finally {
+      factory.blockStyleContext.popInlineColor()
+    }
+  }
+}
+
+private fun String?.toColorOrNull(): Int? {
+  val value = this?.trim().orEmpty()
+  if (value.isEmpty()) return null
+  return try {
+    Color.parseColor(value)
+  } catch (_: IllegalArgumentException) {
+    null
+  }
+}

package/android/src/main/java/com/renderrichtext/renderer/HeadingRenderer.kt

@@ -0,0 +1,81 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import android.text.style.AlignmentSpan
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.HeadingSpan
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE_PRIORITY
+import com.renderrichtext.utils.text.span.applyLinkPillLineHeight
+import com.renderrichtext.utils.text.span.applyMarginBottom
+import com.renderrichtext.utils.text.span.applyMarginTop
+import com.renderrichtext.utils.text.span.createLineHeightSpan
+
+class HeadingRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    if (builder.isNotEmpty() && builder.last() != '\n') {
+      builder.append("\n")
+    }
+
+    val level = node.getAttribute("level")?.toIntOrNull() ?: 1
+    val start = builder.length
+
+    val headingStyle = config.style.headingStyles[level]!!
+    val blockStyleContext = factory.blockStyleContext
+    blockStyleContext.setHeadingStyle(headingStyle, level)
+
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress)
+    } finally {
+      blockStyleContext.popBlockStyle()
+    }
+
+    val end = builder.length
+    val contentLength = end - start
+
+    if (contentLength > 0) {
+      // Set after the children, so top priority makes it apply first and the
+      // inline spans inside the heading (code, links, strong, emphasis) win.
+      builder.setSpan(
+        HeadingSpan(
+          level,
+          config.style,
+        ),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE_PRIORITY,
+      )
+
+      builder.setSpan(
+        createLineHeightSpan(headingStyle.lineHeight),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+      applyLinkPillLineHeight(builder, start, end)
+
+      // Only apply AlignmentSpan for non-default alignments (Center/Right).
+      // Justify is handled at the TextView level (API 26+).
+      if (headingStyle.textAlign.needsAlignmentSpan) {
+        builder.setSpan(
+          AlignmentSpan.Standard(headingStyle.textAlign.layoutAlignment),
+          start,
+          end,
+          SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+        )
+      }
+
+      applyMarginTop(builder, start, headingStyle.marginTop)
+      applyMarginBottom(builder, headingStyle.marginBottom)
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/renderer/HighlightRenderer.kt

@@ -0,0 +1,26 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.HighlightSpan
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class HighlightRenderer : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress) }) { start, end, blockStyle ->
+      builder.setSpan(
+        HighlightSpan(factory.styleCache, blockStyle),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/renderer/LineBreakRenderer.kt

@@ -0,0 +1,17 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import com.renderrichtext.parser.TiptapASTNode
+
+class LineBreakRenderer : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    builder.append("\n")
+  }
+}

package/android/src/main/java/com/renderrichtext/renderer/LinkRenderer.kt

@@ -0,0 +1,90 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import android.text.TextPaint
+import android.text.style.ReplacementSpan
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.FactoidPaddingSpan
+import com.renderrichtext.spans.LinkPillSpan
+import com.renderrichtext.spans.LinkSpan
+import com.renderrichtext.spans.SpoilerSpan
+import com.renderrichtext.spans.stripFactoidPadding
+import com.renderrichtext.utils.text.extensions.applyBlockStyleFont
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class LinkRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  // Reused to resolve each pill's typeface; a renderer serves one render at a time.
+  private val fontProbe = TextPaint()
+
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val url = node.getAttribute("url") ?: return
+    val recognizedLink = node.getAttribute("recognizedLink") == "true"
+
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress) }) { start, end, blockStyle ->
+      val variant = factory.styleCache.resolvedVariantForUrl(url)
+      if (variant?.pill != null && canPresentAsPill(builder, start, end)) {
+        val fontFamily = variant.fontFamily.ifEmpty { factory.styleCache.linkFontFamily }.ifEmpty { blockStyle.fontFamily }
+        val font = fontProbe.apply { applyBlockStyleFont(blockStyle.copy(fontFamily = fontFamily), factory.context) }
+        val pill =
+          LinkPillSpan(
+            variant,
+            font.typeface,
+            blockStyle.fontSize,
+            builder.subSequence(start, end).stripFactoidPadding(),
+            factory.context,
+            config.style.linkPillContent[url],
+            config.style.imageRequestHeaders,
+            followsRunTypeface = variant.fontFamily.isEmpty() && factory.styleCache.linkFontFamily.isEmpty(),
+          )
+        // Set directly, not deferred: the pill measures with its own font, so it does not
+        // need to come after the block spans, and a late insertion makes the builder re-sort.
+        builder.setSpan(pill, start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+        factory.runAfterRender { text -> pill.resolveLeadingMargin(text, text.getSpanStart(pill), text.getSpanEnd(pill)) }
+      }
+      builder.setSpan(
+        LinkSpan(
+          url,
+          onLinkPress,
+          onLinkLongPress,
+          factory.styleCache,
+          blockStyle,
+          factory.context,
+          recognizedLink = recognizedLink,
+          keepsCodeFont = recognizedLink && node.children.any { it.type == TiptapASTNode.NodeType.Code },
+        ),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+
+  /**
+   * A pill replaces one unbroken run. Links that already hold a replacement (image,
+   * math) or span a line break stay ordinary links: a replacement straddling two
+   * paragraphs would be drawn once per paragraph. So do links holding a spoiler,
+   * whose hidden text the label would show. Factoid padding only reserves a gap.
+   */
+  private fun canPresentAsPill(
+    builder: SpannableStringBuilder,
+    start: Int,
+    end: Int,
+  ): Boolean {
+    if (builder.getSpans(start, end, ReplacementSpan::class.java).any { it !is FactoidPaddingSpan }) return false
+    if (builder.getSpans(start, end, SpoilerSpan::class.java).isNotEmpty()) return false
+    for (index in start until end) {
+      val char = builder[index]
+      if (char == '\n' || char == '\r' || char == '\u2028' || char == '\u2029') return false
+    }
+    return true
+  }
+}

package/android/src/main/java/com/renderrichtext/renderer/ListContextManager.kt

@@ -0,0 +1,109 @@
+package com.renderrichtext.renderer
+
+import com.renderrichtext.styles.ListStyle
+
+/**
+ * Manages list context transitions (entering/exiting lists, handling nesting, etc.).
+ * Centralizes logic for managing list depth, item numbers, and parent context restoration.
+ *
+ * Key concepts:
+ * - **listDepth**: Tracks nesting level (0 = top-level, 1 = first nested, etc.)
+ * - **Stack-based numbering**: Pushes parent's item number when entering nested ordered lists,
+ *   allowing each level to maintain its own counter while preserving parent's position.
+ * - **Parent context restoration**: Restores parent list's style when exiting nested lists
+ *   so subsequent parent items render correctly.
+ * - **Marker column**: An ordered list widens its `99.` column to fit its widest marker, and a
+ *   nested list inherits the widening of the item it sits in.
+ */
+class ListContextManager(
+  private val context: BlockStyleContext,
+) {
+  /**
+   * Captures the state when entering a list, needed for proper restoration when exiting.
+   * This ensures we can restore the exact parent context even after nested lists modify it.
+   */
+  data class ListEntryState(
+    val previousDepth: Int,
+    val parentListType: BlockStyleContext.ListType?,
+    val wasNestedInOrderedList: Boolean,
+    val previousMarkerExtra: Float,
+    val previousMarkerOffset: Float,
+  )
+
+  /**
+   * Enters a list context. Handles:
+   * - Saving parent list item numbers to stack (for ordered lists) before resetting counter
+   * - Incrementing list depth
+   * - Setting the appropriate list style
+   * - Resetting item number for the new list
+   * - Widening the marker column by [markerExtraWidth] and shifting a nested list by its parent item's widening
+   */
+  fun enterList(
+    listType: BlockStyleContext.ListType,
+    style: ListStyle,
+    startNumber: Int = 1,
+    markerExtraWidth: Float = 0f,
+  ): ListEntryState {
+    val previousDepth = context.listDepth
+    val isNested = previousDepth > 0
+    val parentListType = if (isNested) context.listType else null
+    val parentIsOrdered = parentListType == BlockStyleContext.ListType.ORDERED
+
+    // Push parent's item number to stack before resetting for nested list.
+    // Even if entering an unordered list, we need to save if parent is ordered.
+    if (isNested && parentIsOrdered) {
+      context.pushOrderedListItemNumber()
+    }
+
+    context.listDepth = previousDepth + 1
+    when (listType) {
+      BlockStyleContext.ListType.ORDERED -> {
+        context.setOrderedListStyle(style)
+      }
+
+      BlockStyleContext.ListType.UNORDERED -> {
+        context.setUnorderedListStyle(style)
+      }
+    }
+    context.resetListItemNumber(startNumber)
+
+    val previousMarkerExtra = context.listMarkerExtra
+    val previousMarkerOffset = context.ancestorMarkerOffset
+    if (isNested) {
+      context.ancestorMarkerOffset += context.listItemMarkerExtra
+    }
+    context.listMarkerExtra = markerExtraWidth
+
+    return ListEntryState(
+      previousDepth = previousDepth,
+      parentListType = parentListType,
+      wasNestedInOrderedList = isNested && parentIsOrdered,
+      previousMarkerExtra = previousMarkerExtra,
+      previousMarkerOffset = previousMarkerOffset,
+    )
+  }
+
+  /**
+   * Exits a list context. Handles:
+   * - Popping current list block style from stack
+   * - Decrementing list depth back to previousDepth
+   * - Restoring parent list item numbers from stack (if applicable)
+   * - Restoring parent list metadata (if nested) so subsequent parent items render correctly
+   * - Restoring the parent list's marker column and offset
+   */
+  fun exitList(entryState: ListEntryState) {
+    context.listDepth = entryState.previousDepth
+    context.clearListStyle()
+
+    if (entryState.wasNestedInOrderedList) {
+      context.popOrderedListItemNumber()
+    }
+
+    if (entryState.previousDepth > 0) {
+      context.listType = entryState.parentListType
+    }
+
+    context.listMarkerExtra = entryState.previousMarkerExtra
+    context.ancestorMarkerOffset = entryState.previousMarkerOffset
+  }
+}

package/android/src/main/java/com/renderrichtext/renderer/ListItemRenderer.kt

@@ -0,0 +1,211 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import android.text.style.ForegroundColorSpan
+import android.text.style.StrikethroughSpan
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.BaseListSpan
+import com.renderrichtext.spans.CodeBlockSpan
+import com.renderrichtext.spans.ListMarkerAnchorSpan
+import com.renderrichtext.spans.OrderedListSpan
+import com.renderrichtext.spans.TaskListSpan
+import com.renderrichtext.spans.UnorderedListSpan
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_LIST_ITEM
+
+class ListItemRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val styleContext = factory.blockStyleContext
+    val start = builder.length
+    val listType = styleContext.listType ?: return
+
+    val isTask = node.attributes["isTask"] == "true"
+    val isChecked = isTask && node.attributes["taskChecked"] == "true"
+
+    if (listType == BlockStyleContext.ListType.ORDERED) {
+      styleContext.incrementListItemNumber()
+    }
+
+    val taskIndex = if (isTask) styleContext.taskItemCount++ else -1
+
+    val depth = styleContext.listDepth - 1
+    val listStyle = config.style.listStyle
+
+    fun makeSpan(drawsMarker: Boolean): BaseListSpan =
+      if (isTask) {
+        TaskListSpan(
+          taskStyle = config.style.taskListStyle,
+          listStyle = listStyle,
+          depth = depth,
+          context = factory.context,
+          styleCache = factory.styleCache,
+          taskIndex = taskIndex,
+          isChecked = isChecked,
+          drawsMarker = drawsMarker,
+          ancestorMarkerOffset = styleContext.ancestorMarkerOffset,
+          markerExtraWidth = styleContext.listMarkerExtra,
+          parentMarkerWidth = styleContext.listItemMarkerWidth,
+        )
+      } else {
+        when (listType) {
+          BlockStyleContext.ListType.UNORDERED -> {
+            UnorderedListSpan(
+              listStyle,
+              depth,
+              factory.context,
+              factory.styleCache,
+              drawsMarker,
+              ancestorMarkerOffset = styleContext.ancestorMarkerOffset,
+              parentMarkerWidth = styleContext.listItemMarkerWidth,
+            )
+          }
+
+          BlockStyleContext.ListType.ORDERED -> {
+            OrderedListSpan(
+              listStyle,
+              depth,
+              factory.context,
+              factory.styleCache,
+              drawsMarker,
+              markerExtraWidth = styleContext.listMarkerExtra,
+              ancestorMarkerOffset = styleContext.ancestorMarkerOffset,
+              parentMarkerWidth = styleContext.listItemMarkerWidth,
+            ).apply {
+              setItemNumber(styleContext.listItemNumber)
+            }
+          }
+        }
+      }
+
+    val markerSpan = makeSpan(drawsMarker = true)
+
+    val previousMarkerExtra = styleContext.listItemMarkerExtra
+    styleContext.listItemMarkerExtra = markerSpan.markerExtraWidth
+    val previousMarkerWidth = styleContext.listItemMarkerWidth
+    styleContext.listItemMarkerWidth = markerSpan.baselineMarkerWidth
+    val prevIndent = styleContext.accumulatedIndent
+    styleContext.accumulatedIndent = prevIndent + markerSpan.getLeadingMargin(false)
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress)
+    } finally {
+      styleContext.accumulatedIndent = prevIndent
+      styleContext.listItemMarkerExtra = previousMarkerExtra
+      styleContext.listItemMarkerWidth = previousMarkerWidth
+    }
+
+    if (builder.length == start || builder.substring(start).isBlank()) return
+
+    styleContext.listItemStarts.add(start)
+
+    if (builder.last() != '\n') {
+      builder.append("\n")
+    }
+
+    val itemEnd = builder.length
+
+    // Anchor the marker on the first content character so items that open with
+    // a code block or nested sublist still get their marker.
+    var anchor = start
+    while (anchor < itemEnd && builder[anchor].isWhitespace()) anchor++
+    if (anchor == itemEnd) anchor = start
+
+    val plainAnchor =
+      builder.getSpans(anchor, anchor + 1, CodeBlockSpan::class.java).isEmpty() &&
+        builder.getSpans(anchor, anchor + 1, BaseListSpan::class.java).none { it.depth > depth }
+
+    val codeBlockRanges =
+      builder
+        .getSpans(start, itemEnd, CodeBlockSpan::class.java)
+        .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+        .filter { it.first < it.second }
+        .sortedBy { it.first }
+
+    var pos = start
+    var isFirstSegment = true
+    for ((cbStart, cbEnd) in codeBlockRanges) {
+      if (pos < cbStart) {
+        builder.setSpan(
+          if (isFirstSegment && plainAnchor) markerSpan else makeSpan(drawsMarker = false),
+          pos,
+          cbStart,
+          SPAN_FLAGS_LIST_ITEM,
+        )
+        isFirstSegment = false
+      }
+      pos = maxOf(pos, cbEnd)
+    }
+    if (pos < itemEnd) {
+      builder.setSpan(
+        if (isFirstSegment && plainAnchor) markerSpan else makeSpan(drawsMarker = false),
+        pos,
+        itemEnd,
+        SPAN_FLAGS_LIST_ITEM,
+      )
+    }
+
+    if (!plainAnchor) {
+      builder.setSpan(ListMarkerAnchorSpan(markerSpan), anchor, anchor + 1, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    }
+
+    if (isTask && isChecked) {
+      applyCheckedDecorations(builder, start, itemEnd, depth)
+    }
+  }
+
+  private fun applyCheckedDecorations(
+    builder: SpannableStringBuilder,
+    itemStart: Int,
+    itemEnd: Int,
+    itemDepth: Int,
+  ) {
+    val taskStyle = config.style.taskListStyle
+    val checkedTextColor = taskStyle.checkedTextColor
+    val strikethrough = taskStyle.checkedStrikethrough
+
+    if (checkedTextColor == 0 && !strikethrough) return
+
+    val excludedRanges =
+      (
+        builder.getSpans(itemStart, itemEnd, BaseListSpan::class.java).filter { it.depth > itemDepth } +
+          builder.getSpans(itemStart, itemEnd, CodeBlockSpan::class.java).toList()
+      ).map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+        .sortedBy { it.first }
+
+    var currentPos = itemStart
+
+    for ((start, end) in excludedRanges) {
+      if (start > currentPos) {
+        applySpans(builder, currentPos, start, checkedTextColor, strikethrough)
+      }
+      currentPos = maxOf(currentPos, end)
+    }
+
+    if (currentPos < itemEnd) {
+      applySpans(builder, currentPos, itemEnd, checkedTextColor, strikethrough)
+    }
+  }
+
+  private fun applySpans(
+    builder: SpannableStringBuilder,
+    start: Int,
+    end: Int,
+    color: Int,
+    strikethrough: Boolean,
+  ) {
+    if (color != 0) {
+      builder.setSpan(ForegroundColorSpan(color), start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    }
+    if (strikethrough) {
+      builder.setSpan(StrikethroughSpan(), start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    }
+  }
+}