react-native-enriched-markdown 0.1.0 → 0.2.0

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/NodeRenderer.kt

@@ -0,0 +1,103 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.content.Context
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.styles.StyleConfig
+
+interface NodeRenderer {
+  fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  )
+}
+
+data class RendererConfig(
+  val style: StyleConfig,
+)
+
+class RendererFactory(
+  private val config: RendererConfig,
+  val context: Context,
+  private val onImageSpanCreated: (ImageSpan) -> Unit,
+) {
+  val blockStyleContext = BlockStyleContext()
+
+  val styleCache = SpanStyleCache(config.style)
+
+  fun resetForNewRender() {
+    blockStyleContext.resetForNewRender()
+  }
+
+  private val textRenderer = TextRenderer()
+  private val lineBreakRenderer = LineBreakRenderer()
+
+  private val renderers: Map<MarkdownASTNode.NodeType, NodeRenderer> by lazy {
+    mapOf(
+      MarkdownASTNode.NodeType.Document to DocumentRenderer(),
+      MarkdownASTNode.NodeType.Paragraph to ParagraphRenderer(config),
+      MarkdownASTNode.NodeType.Heading to HeadingRenderer(config),
+      MarkdownASTNode.NodeType.Blockquote to BlockquoteRenderer(config),
+      MarkdownASTNode.NodeType.CodeBlock to CodeBlockRenderer(config),
+      MarkdownASTNode.NodeType.UnorderedList to ListRenderer(config, isOrdered = false),
+      MarkdownASTNode.NodeType.OrderedList to ListRenderer(config, isOrdered = true),
+      MarkdownASTNode.NodeType.ListItem to ListItemRenderer(config),
+      MarkdownASTNode.NodeType.Text to textRenderer,
+      MarkdownASTNode.NodeType.Link to LinkRenderer(config),
+      MarkdownASTNode.NodeType.Strong to StrongRenderer(config),
+      MarkdownASTNode.NodeType.Emphasis to EmphasisRenderer(config),
+      MarkdownASTNode.NodeType.Strikethrough to StrikethroughRenderer(config),
+      MarkdownASTNode.NodeType.Underline to UnderlineRenderer(config),
+      MarkdownASTNode.NodeType.Code to CodeRenderer(config),
+      MarkdownASTNode.NodeType.Image to ImageRenderer(config, context),
+      MarkdownASTNode.NodeType.LineBreak to lineBreakRenderer,
+      MarkdownASTNode.NodeType.ThematicBreak to ThematicBreakRenderer(config),
+    )
+  }
+
+  /**
+   * Called by ImageRenderer to report a new span to the collector.
+   */
+  fun registerImageSpan(span: ImageSpan) {
+    onImageSpanCreated(span)
+  }
+
+  fun getRenderer(node: MarkdownASTNode): NodeRenderer =
+    renderers[node.type] ?: run {
+      android.util.Log.w("RendererFactory", "No renderer for: ${node.type}")
+      textRenderer
+    }
+
+  fun renderChildren(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+  ) {
+    node.children.forEach { child ->
+      getRenderer(child).render(child, builder, onLinkPress, onLinkLongPress, this)
+    }
+  }
+
+  /**
+   * Improved helper for applying spans to blocks of text.
+   */
+  inline fun renderWithSpan(
+    builder: SpannableStringBuilder,
+    renderContent: () -> Unit,
+    applySpan: (start: Int, end: Int, blockStyle: BlockStyle) -> Unit,
+  ) {
+    val start = builder.length
+    renderContent()
+    val end = builder.length
+
+    if (end > start) {
+      val blockStyle = blockStyleContext.requireBlockStyle()
+      applySpan(start, end, blockStyle)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/ParagraphRenderer.kt

@@ -0,0 +1,80 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import android.text.style.AlignmentSpan
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.styles.ParagraphStyle
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.applyMarginBottom
+import com.swmansion.enriched.markdown.utils.applyMarginTop
+import com.swmansion.enriched.markdown.utils.containsBlockImage
+import com.swmansion.enriched.markdown.utils.createLineHeightSpan
+
+class ParagraphRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val context = factory.blockStyleContext
+
+    // If nested (e.g., inside a list or blockquote), render content simply with a newline
+    if (context.isInsideBlockElement()) {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+      builder.append("\n")
+      return
+    }
+
+    val start = builder.length
+    val style = config.style.paragraphStyle
+
+    context.setParagraphStyle(style)
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+    } finally {
+      context.clearBlockStyle()
+    }
+
+    if (builder.length > start) {
+      builder.applySpans(node, style, start)
+    }
+  }
+
+  private fun SpannableStringBuilder.applySpans(
+    node: MarkdownASTNode,
+    style: ParagraphStyle,
+    start: Int,
+  ) {
+    val end = length
+
+    // LineHeightSpan is avoided for block images to prevent clipping/overlapping
+    if (!node.containsBlockImage()) {
+      setSpan(
+        createLineHeightSpan(style.lineHeight),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+
+    // Only apply AlignmentSpan for non-default alignments (Center/Right)
+    if (style.textAlign.needsAlignmentSpan) {
+      setSpan(
+        AlignmentSpan.Standard(style.textAlign.layoutAlignment),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+
+    val marginTop = if (node.containsBlockImage()) config.style.imageStyle.marginTop else style.marginTop
+    applyMarginTop(this, start, marginTop)
+
+    val marginBottom = if (node.containsBlockImage()) config.style.imageStyle.marginBottom else style.marginBottom
+    applyMarginBottom(this, marginBottom)
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/Renderer.kt

@@ -0,0 +1,109 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.content.Context
+import android.text.SpannableString
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.MarginBottomSpan
+import com.swmansion.enriched.markdown.styles.StyleConfig
+
+class Renderer {
+  private var cachedFactory: RendererFactory? = null
+  private var cachedStyle: StyleConfig? = null
+  private var cachedContext: Context? = null
+
+  private val collectedImageSpans = mutableListOf<ImageSpan>()
+  private var lastElementMarginBottom: Float = 0f
+
+  fun configure(
+    style: StyleConfig,
+    context: Context,
+  ) {
+    if (cachedStyle === style && cachedContext === context) return
+
+    cachedStyle = style
+    cachedContext = context
+    cachedFactory =
+      RendererFactory(
+        RendererConfig(style),
+        context,
+      ) { span -> reportImageSpan(span) }
+  }
+
+  fun renderDocument(
+    document: MarkdownASTNode,
+    onLinkPress: ((String) -> Unit)? = null,
+    onLinkLongPress: ((String) -> Unit)? = null,
+  ): SpannableString {
+    val factory =
+      requireNotNull(cachedFactory) {
+        "Renderer must be configured with a style before calling renderDocument."
+      }
+
+    factory.resetForNewRender()
+    collectedImageSpans.clear()
+    lastElementMarginBottom = 0f
+
+    val builder = SpannableStringBuilder()
+
+    renderNode(document, builder, onLinkPress, onLinkLongPress, factory)
+
+    // Remove trailing margin from last block element
+    removeTrailingMargin(builder)
+
+    return SpannableString(builder)
+  }
+
+  /** Removes trailing newlines and captures the margin of the final element. */
+  private fun removeTrailingMargin(builder: SpannableStringBuilder) {
+    if (builder.isEmpty()) return
+
+    // Identify the last margin span and store its value
+    val lastSpan =
+      builder
+        .getSpans(0, builder.length, MarginBottomSpan::class.java)
+        .maxByOrNull { builder.getSpanEnd(it) }
+
+    lastElementMarginBottom = lastSpan?.marginBottom ?: 0f
+
+    // Trim trailing newlines
+    while (builder.endsWith('\n')) {
+      builder.delete(builder.length - 1, builder.length)
+    }
+
+    // Clean up the span if it no longer covers any text
+    if (lastSpan != null && builder.getSpanEnd(lastSpan) >= builder.length) {
+      builder.removeSpan(lastSpan)
+    }
+  }
+
+  /**
+   * Returns the marginBottom value of the last element in the document.
+   * This is dynamically determined from the actual last element (paragraph, image, heading, etc.)
+   * and can be used in MeasurementStore to adjust the measured height.
+   */
+  fun getLastElementMarginBottom(): Float = lastElementMarginBottom
+
+  private fun renderNode(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.getRenderer(node).render(node, builder, onLinkPress, onLinkLongPress, factory)
+  }
+
+  /**
+   * Internal helper used by the Factory's lambda to collect spans.
+   */
+  private fun reportImageSpan(span: ImageSpan) {
+    collectedImageSpans.add(span)
+  }
+
+  /**
+   * Provides the EnrichedMarkdownText with the exact list of spans that need registration.
+   */
+  fun getCollectedImageSpans(): List<ImageSpan> = collectedImageSpans
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/SpanStyleCache.kt

@@ -0,0 +1,86 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.graphics.Typeface
+import com.swmansion.enriched.markdown.styles.StyleConfig
+
+/** Shared style cache for spans to avoid redundant calculations. */
+class SpanStyleCache(
+  style: StyleConfig,
+) {
+  // Colors to preserve when applying inline styles (links, code, strong, emphasis)
+  val colorsToPreserve: IntArray = buildColorsToPreserve(style)
+
+  val strongColor: Int? = style.strongStyle.color
+  val emphasisColor: Int? = style.emphasisStyle.color
+  val strikethroughColor: Int = style.strikethroughStyle.color
+  val linkColor: Int = style.linkStyle.color
+  val linkUnderline: Boolean = style.linkStyle.underline
+  val codeColor: Int = style.codeStyle.color
+
+  private fun buildColorsToPreserve(style: StyleConfig): IntArray =
+    buildList {
+      style.strongStyle.color
+        ?.takeIf { it != 0 }
+        ?.let { add(it) }
+      style.emphasisStyle.color
+        ?.takeIf { it != 0 }
+        ?.let { add(it) }
+      style.linkStyle.color
+        .takeIf { it != 0 }
+        ?.let { add(it) }
+      style
+        .codeStyle
+        .color
+        .takeIf { it != 0 }
+        ?.let { add(it) }
+    }.toIntArray()
+
+  fun getStrongColorFor(blockColor: Int): Int = strongColor ?: blockColor
+
+  fun getEmphasisColorFor(
+    blockColor: Int,
+    currentColor: Int,
+  ): Int =
+    if (currentColor == blockColor) {
+      emphasisColor ?: blockColor
+    } else {
+      currentColor
+    }
+
+  companion object {
+    private val typefaceCache = mutableMapOf<String, Typeface>()
+
+    /** Cached typeface for font family + style (BOLD, ITALIC, BOLD_ITALIC) */
+    fun getTypeface(
+      fontFamily: String,
+      style: Int,
+    ): Typeface =
+      typefaceCache.getOrPut("$fontFamily|$style") {
+        val base =
+          fontFamily
+            .takeIf { it.isNotEmpty() }
+            ?.let { Typeface.create(it, Typeface.NORMAL) }
+            ?: Typeface.DEFAULT
+        Typeface.create(base, style)
+      }
+
+    /** Cached typeface using weight string (e.g., "bold", "700") */
+    fun getTypefaceWithWeight(
+      fontFamily: String,
+      fontWeight: String,
+    ): Typeface {
+      val style =
+        when (fontWeight.lowercase()) {
+          "bold", "700", "800", "900" -> Typeface.BOLD
+          else -> Typeface.NORMAL
+        }
+      return getTypeface(fontFamily, style)
+    }
+
+    /** Cached monospace typeface preserving bold/italic */
+    fun getMonospaceTypeface(currentStyle: Int): Typeface =
+      typefaceCache.getOrPut("monospace|$currentStyle") {
+        Typeface.create(Typeface.MONOSPACE, currentStyle)
+      }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/StrikethroughRenderer.kt

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.StrikethroughSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class StrikethroughRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { start, end, blockStyle ->
+      builder.setSpan(
+        StrikethroughSpan(factory.styleCache.strikethroughColor),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/StrongRenderer.kt

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.StrongSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class StrongRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { start, end, blockStyle ->
+      builder.setSpan(
+        StrongSpan(factory.styleCache, blockStyle),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/TextRenderer.kt

@@ -0,0 +1,30 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.TextSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class TextRenderer : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val content = node.content
+    if (content.isEmpty()) return
+
+    val blockType = factory.blockStyleContext.currentBlockType
+
+    factory.renderWithSpan(builder, { builder.append(content) }) { start, end, blockStyle ->
+      builder.setSpan(
+        TextSpan(blockStyle, factory.context),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/ThematicBreakRenderer.kt

@@ -0,0 +1,45 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.ThematicBreakSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class ThematicBreakRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    builder.ensureNewline()
+
+    val start = builder.length
+
+    builder.append(" \n")
+    val end = builder.length
+
+    val style = config.style.thematicBreakStyle
+
+    builder.setSpan(
+      ThematicBreakSpan(
+        style.color,
+        style.height,
+        style.marginTop,
+        style.marginBottom,
+      ),
+      start,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+  }
+
+  private fun SpannableStringBuilder.ensureNewline() {
+    if (isNotEmpty() && this[length - 1] != '\n') {
+      append('\n')
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/UnderlineRenderer.kt

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import android.text.style.UnderlineSpan
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class UnderlineRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { start, end, _ ->
+      builder.setSpan(
+        UnderlineSpan(),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/spans/BaseListSpan.kt

@@ -0,0 +1,136 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.text.Layout
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.markdown.renderer.BlockStyle
+import com.swmansion.enriched.markdown.renderer.SpanStyleCache
+import com.swmansion.enriched.markdown.utils.applyBlockStyleFont
+import com.swmansion.enriched.markdown.utils.applyColorPreserving
+
+abstract class BaseListSpan(
+  val depth: Int,
+  protected val context: Context,
+  protected val styleCache: SpanStyleCache,
+  protected val blockStyle: BlockStyle,
+  protected val marginLeft: Float,
+  protected val gapWidth: Float,
+) : MetricAffectingSpan(),
+  LeadingMarginSpan {
+  // Cache for shouldSkipDrawing to avoid repeated getSpans() calls during draw passes
+  private var cachedText: CharSequence? = null
+  private var cachedHasDeeperSpanByPosition = mutableMapOf<Int, Boolean>()
+
+  protected abstract fun getMarkerWidth(): Float
+
+  // --- MetricAffectingSpan Implementation ---
+
+  override fun updateMeasureState(tp: TextPaint) = applyTextStyle(tp)
+
+  override fun updateDrawState(tp: TextPaint) = applyTextStyle(tp)
+
+  // --- LeadingMarginSpan Implementation ---
+
+  override fun getLeadingMargin(first: Boolean): Int {
+    // Root items: just marker width + gap (flush to left edge)
+    // Nested items: add marginLeft for each nesting level
+    return if (depth == 0) {
+      val effectiveGap = gapWidth.coerceAtLeast(DEFAULT_MIN_GAP)
+      (getMarkerWidth() + effectiveGap).toInt()
+    } else {
+      marginLeft.toInt()
+    }
+  }
+
+  protected fun getEffectiveGapWidth(): Float = gapWidth.coerceAtLeast(DEFAULT_MIN_GAP)
+
+  override fun drawLeadingMargin(
+    c: Canvas,
+    p: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    // Draw only on the first line of paragraphs that have content and are not nested deeper
+    if (!first || shouldSkipDrawing(text, start) || !hasContent(text, start, end)) return
+
+    val originalStyle = p.style
+    val originalColor = p.color
+    drawMarker(c, p, x, dir, top, baseline, bottom, layout, start)
+    p.style = originalStyle
+    p.color = originalColor
+  }
+
+  protected abstract fun drawMarker(
+    c: Canvas,
+    p: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    layout: Layout?,
+    start: Int,
+  )
+
+  @SuppressLint("WrongConstant") // Result of mask is always valid: 0, 1, 2, or 3
+  private fun applyTextStyle(tp: TextPaint) {
+    tp.textSize = blockStyle.fontSize
+
+    val preservedStyle = (tp.typeface?.style ?: 0) and BOLD_ITALIC_MASK
+    tp.applyBlockStyleFont(blockStyle, context)
+    if (preservedStyle != 0) {
+      tp.typeface?.let { base -> tp.typeface = Typeface.create(base, preservedStyle) }
+    }
+
+    tp.applyColorPreserving(blockStyle.color, *styleCache.colorsToPreserve)
+  }
+
+  companion object {
+    private const val BOLD_ITALIC_MASK = Typeface.BOLD or Typeface.ITALIC // 3
+    private const val DEFAULT_MIN_GAP = 4f
+  }
+
+  // --- Helper Methods ---
+
+  private fun hasContent(
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+  ): Boolean {
+    if (text == null || end <= start) return false
+    // Check if there is at least one non-whitespace character in the range
+    return (start until end).any { !text[it].isWhitespace() }
+  }
+
+  private fun shouldSkipDrawing(
+    text: CharSequence?,
+    start: Int,
+  ): Boolean {
+    if (text !is Spanned) return false
+
+    if (cachedText !== text) {
+      cachedText = text
+      cachedHasDeeperSpanByPosition.clear()
+    }
+
+    return cachedHasDeeperSpanByPosition.getOrPut(start) {
+      val spans = text.getSpans(start, start + 1, BaseListSpan::class.java)
+      spans.any { it.depth > depth }
+    }
+  }
+}