react-native-enriched-markdown 0.1.0 → 0.1.1

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

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

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

@@ -0,0 +1,54 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.HeadingSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.applyMarginBottom
+import com.swmansion.enriched.markdown.utils.createLineHeightSpan
+
+class HeadingRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val level = node.getAttribute("level")?.toIntOrNull() ?: 1
+    val start = builder.length
+
+    val headingStyle = config.style.headingStyles[level]!!
+    factory.blockStyleContext.setHeadingStyle(headingStyle, level)
+
+    try {
+      factory.renderChildren(node, builder, onLinkPress)
+    } finally {
+      factory.blockStyleContext.clearBlockStyle()
+    }
+
+    val end = builder.length
+    val contentLength = end - start
+    if (contentLength > 0) {
+      builder.setSpan(
+        HeadingSpan(
+          level,
+          config.style,
+        ),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+
+      builder.setSpan(
+        createLineHeightSpan(headingStyle.lineHeight),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+
+      applyMarginBottom(builder, start, headingStyle.marginBottom)
+    }
+  }
+}

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

@@ -0,0 +1,52 @@
+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.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.isInlineImage
+
+class ImageRenderer(
+  private val config: RendererConfig,
+  private val context: Context,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val imageUrl = node.getAttribute("url") ?: return
+
+    val isInline = builder.isInlineImage()
+    val start = builder.length
+
+    // 1. Append the placeholder character
+    builder.append("\uFFFC")
+    val end = builder.length
+
+    // 2. Create the Span
+    val span =
+      ImageSpan(
+        context = context,
+        imageUrl = imageUrl,
+        styleConfig = config.style,
+        isInline = isInline,
+      )
+
+    // 3. Attach it to the builder
+    builder.setSpan(
+      span,
+      start,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+
+    // 4. REPORT the span to the collector via the factory
+    factory.registerImageSpan(span)
+
+    // Note: marginBottom for images is handled by ParagraphRenderer when the paragraph contains only an image
+    // This ensures consistent spacing behavior and prevents paragraph's marginBottom from affecting images
+  }
+}

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

@@ -0,0 +1,15 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+
+class LineBreakRenderer : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    builder.append("\n")
+  }
+}

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

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

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

@@ -0,0 +1,105 @@
+package com.swmansion.enriched.markdown.renderer
+
+import com.swmansion.enriched.markdown.styles.ListStyle
+import com.swmansion.enriched.markdown.styles.StyleConfig
+
+/**
+ * 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.
+ */
+class ListContextManager(
+  private val context: BlockStyleContext,
+  private val styleConfig: StyleConfig,
+) {
+  /**
+   * 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,
+  )
+
+  /**
+   * 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
+   */
+  fun enterList(
+    listType: BlockStyleContext.ListType,
+    style: Any,
+  ): 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 as ListStyle)
+      }
+
+      BlockStyleContext.ListType.UNORDERED -> {
+        context.setUnorderedListStyle(style as ListStyle)
+      }
+    }
+    context.resetListItemNumber()
+
+    return ListEntryState(
+      previousDepth = previousDepth,
+      parentListType = parentListType,
+      wasNestedInOrderedList = isNested && parentIsOrdered,
+    )
+  }
+
+  /**
+   * Exits a list context. Handles:
+   * - Clearing list style (only if top-level, depth == 0)
+   * - Decrementing list depth back to previousDepth
+   * - Restoring parent list item numbers from stack (if applicable)
+   * - Restoring parent list context (if nested) so subsequent parent items render correctly
+   */
+  fun exitList(entryState: ListEntryState) {
+    context.clearListStyle()
+    context.listDepth = entryState.previousDepth
+
+    if (entryState.wasNestedInOrderedList) {
+      context.popOrderedListItemNumber()
+    }
+
+    if (entryState.previousDepth > 0) {
+      restoreParentListContext(entryState.parentListType)
+    }
+  }
+
+  private fun restoreParentListContext(parentListType: BlockStyleContext.ListType?) {
+    when (parentListType) {
+      BlockStyleContext.ListType.UNORDERED -> {
+        context.setUnorderedListStyle(styleConfig.listStyle)
+      }
+
+      BlockStyleContext.ListType.ORDERED -> {
+        context.setOrderedListStyle(styleConfig.listStyle)
+      }
+
+      null -> {}
+    }
+  }
+}

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

@@ -0,0 +1,58 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.OrderedListSpan
+import com.swmansion.enriched.markdown.spans.UnorderedListSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class ListItemRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val styleContext = factory.blockStyleContext
+    val start = builder.length
+    val listType = styleContext.listType ?: return
+
+    // 1. Maintain item state
+    if (listType == BlockStyleContext.ListType.ORDERED) {
+      styleContext.incrementListItemNumber()
+    }
+
+    // 2. Render Children
+    factory.renderChildren(node, builder, onLinkPress)
+
+    // 3. Normalize whitespace: Ensure the item ends with exactly one newline
+    if (builder.length == start || builder.substring(start).isBlank()) return
+
+    while (builder.length > start && builder.last() == '\n') {
+      builder.delete(builder.length - 1, builder.length)
+    }
+    builder.append("\n")
+
+    // 4. Calculate Depth and Style
+    val depth = styleContext.listDepth - 1
+    val listStyle = config.style.listStyle
+
+    // 5. Apply the correct Span
+    val span =
+      when (listType) {
+        BlockStyleContext.ListType.UNORDERED -> {
+          UnorderedListSpan(listStyle, depth, factory.context, factory.styleCache)
+        }
+
+        BlockStyleContext.ListType.ORDERED -> {
+          OrderedListSpan(listStyle, depth, factory.context, factory.styleCache).apply {
+            setItemNumber(styleContext.listItemNumber)
+          }
+        }
+      }
+
+    builder.setSpan(span, start, builder.length, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+  }
+}

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

@@ -0,0 +1,69 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.MarginBottomSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.createLineHeightSpan
+
+class ListRenderer(
+  private val config: RendererConfig,
+  private val isOrdered: Boolean,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val start = builder.length
+    val listStyle = config.style.listStyle
+    val listType = if (isOrdered) BlockStyleContext.ListType.ORDERED else BlockStyleContext.ListType.UNORDERED
+
+    // 1. Context Lifecycle Management
+    val contextManager = ListContextManager(factory.blockStyleContext, config.style)
+    val entryState = contextManager.enterList(listType, listStyle)
+
+    // 2. Nested List Isolation
+    if (entryState.previousDepth > 0 && builder.isNotEmpty() && builder.last() != '\n') {
+      builder.append("\n")
+    }
+
+    try {
+      factory.renderChildren(node, builder, onLinkPress)
+    } finally {
+      contextManager.exitList(entryState)
+    }
+
+    // 3. Spacing & Styling
+    if (builder.length > start) {
+      applyListSpacing(builder, start, entryState.previousDepth, listStyle)
+    }
+  }
+
+  private fun applyListSpacing(
+    builder: SpannableStringBuilder,
+    start: Int,
+    depth: Int,
+    style: com.swmansion.enriched.markdown.styles.BaseBlockStyle,
+  ) {
+    // Apply line height to the entire list block
+    builder.setSpan(
+      createLineHeightSpan(style.lineHeight),
+      start,
+      builder.length,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+
+    // Only apply bottom margin for top-level lists
+    if (depth == 0 && style.marginBottom > 0) {
+      builder.append("\n")
+      builder.setSpan(
+        MarginBottomSpan(style.marginBottom),
+        builder.length - 1,
+        builder.length,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,99 @@
+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)?,
+    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.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)?,
+  ) {
+    node.children.forEach { child ->
+      getRenderer(child).render(child, builder, onLinkPress, 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,66 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+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.containsBlockImage
+import com.swmansion.enriched.markdown.utils.createLineHeightSpan
+import com.swmansion.enriched.markdown.utils.getMarginBottomForParagraph
+
+class ParagraphRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val context = factory.blockStyleContext
+
+    // If nested, just render content and a newline
+    if (context.isInsideBlockElement()) {
+      factory.renderChildren(node, builder, onLinkPress)
+      builder.append("\n")
+      return
+    }
+
+    // Top-level paragraph rendering
+    val start = builder.length
+    val style = config.style.paragraphStyle
+
+    context.setParagraphStyle(style)
+    try {
+      factory.renderChildren(node, builder, onLinkPress)
+    } finally {
+      context.clearBlockStyle()
+    }
+
+    // Apply spans only if content was actually added
+    if (builder.length > start) {
+      builder.applySpans(node, style, start)
+    }
+  }
+
+  private fun SpannableStringBuilder.applySpans(
+    node: MarkdownASTNode,
+    style: ParagraphStyle,
+    start: Int,
+  ) {
+    val end = length // Current length is the end point
+
+    if (!node.containsBlockImage()) {
+      setSpan(
+        createLineHeightSpan(style.lineHeight),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+
+    val margin = getMarginBottomForParagraph(node, style, config.style)
+    applyMarginBottom(this, start, margin)
+  }
+}

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

@@ -0,0 +1,95 @@
+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>()
+
+  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,
+  ): SpannableString {
+    val factory =
+      requireNotNull(cachedFactory) {
+        "Renderer must be configured with a style before calling renderDocument."
+      }
+
+    factory.resetForNewRender()
+    collectedImageSpans.clear()
+
+    val builder = SpannableStringBuilder()
+
+    renderNode(document, builder, onLinkPress, factory)
+
+    // Remove trailing margin from last block element
+    removeTrailingMargin(builder)
+
+    return SpannableString(builder)
+  }
+
+  /** Removes trailing margin to eliminate bottom spacing */
+  private fun removeTrailingMargin(builder: SpannableStringBuilder) {
+    if (builder.isEmpty()) return
+
+    val spans = builder.getSpans(0, builder.length, MarginBottomSpan::class.java)
+    if (spans.isEmpty()) return
+
+    val lastSpan = spans.maxByOrNull { builder.getSpanEnd(it) } ?: return
+    val spanEnd = builder.getSpanEnd(lastSpan)
+
+    // Remove trailing newlines (added for block spacing)
+    while (builder.isNotEmpty() && builder.last() == '\n') {
+      builder.delete(builder.length - 1, builder.length)
+    }
+
+    if (spanEnd >= builder.length) {
+      builder.removeSpan(lastSpan)
+    }
+  }
+
+  private fun renderNode(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.getRenderer(node).render(node, builder, onLinkPress, 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
+}