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

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

@@ -0,0 +1,133 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.ListItemSpacingSpan
+import com.renderrichtext.spans.MarginBottomSpan
+import com.renderrichtext.spans.OrderedListSpan
+import com.renderrichtext.styles.ListStyle
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.renderrichtext.utils.text.span.applyLineHeightSkippingImages
+import com.renderrichtext.utils.text.span.applyMarginTop
+
+class ListRenderer(
+  private val config: RendererConfig,
+  private val isOrdered: Boolean,
+) : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val start = builder.length
+    val listStyle = config.style.listStyle
+    val listType = if (isOrdered) BlockStyleContext.ListType.ORDERED else BlockStyleContext.ListType.UNORDERED
+
+    val startNumber =
+      if (isOrdered) {
+        node.getAttribute("start")?.toIntOrNull()?.coerceAtLeast(0) ?: 1
+      } else {
+        1
+      }
+
+    val markerExtraWidth = if (isOrdered) markerExtraWidth(node, listStyle, startNumber, factory) else 0f
+    val contextManager = ListContextManager(factory.blockStyleContext)
+    val entryState = contextManager.enterList(listType, listStyle, startNumber, markerExtraWidth)
+
+    // For top-level lists, insert marginTop spacer before rendering content
+    if (entryState.previousDepth == 0) {
+      applyMarginTop(builder, start, listStyle.marginTop)
+    }
+
+    // Track start index after the potential 1-character marginTop spacer
+    val contentStart = if (entryState.previousDepth == 0 && listStyle.marginTop > 0) start + 1 else start
+
+    // Ensure nested lists start on a new line if the parent hasn't provided one
+    if (entryState.previousDepth > 0 && builder.isNotEmpty() && builder.last() != '\n') {
+      builder.append("\n")
+    }
+
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress)
+    } finally {
+      contextManager.exitList(entryState)
+    }
+
+    if (builder.length > contentStart) {
+      applyListSpacing(builder, contentStart, entryState.previousDepth, listStyle, factory.blockStyleContext)
+    }
+  }
+
+  /** Lists under 100 keep the `99.` column, so only numbers from 100 on widen it. Task items draw a checkbox. */
+  private fun markerExtraWidth(
+    node: TiptapASTNode,
+    listStyle: ListStyle,
+    startNumber: Int,
+    factory: RendererFactory,
+  ): Float {
+    val wideNumbers = mutableListOf<Int>()
+    var number = startNumber
+    for (item in node.children) {
+      if (item.type != TiptapASTNode.NodeType.ListItem) continue
+      if (number >= 100 && item.attributes["isTask"] != "true") wideNumbers += number
+      number++
+    }
+    return OrderedListSpan.measureExtraWidth(listStyle, factory.context, wideNumbers)
+  }
+
+  private fun applyListSpacing(
+    builder: SpannableStringBuilder,
+    start: Int,
+    depth: Int,
+    style: ListStyle,
+    styleContext: BlockStyleContext,
+  ) {
+    // TODO: LineHeightSpan may also clip superscript/subscript glyphs that extend
+    // outside the normal line bounds. A similar "skip" strategy as for images may
+    // be needed here once super/subscript usage in practice is better understood.
+    applyLineHeightSkippingImages(builder, start, builder.length, style.lineHeight)
+
+    // Item spacing and external bottom margin are only handled by the root-level list
+    if (depth == 0) {
+      applyItemSpacing(builder, start, style.itemSpacing, styleContext)
+
+      builder.append("\n")
+      builder.setSpan(
+        MarginBottomSpan(style.marginBottom),
+        builder.length - 1,
+        builder.length,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+
+  // Inserts the vertical gap between consecutive items (including nested ones)
+  // by spanning the newline that precedes each item start. The first item of
+  // the root list gets no spacing above it.
+  private fun applyItemSpacing(
+    builder: SpannableStringBuilder,
+    start: Int,
+    itemSpacing: Float,
+    styleContext: BlockStyleContext,
+  ) {
+    if (itemSpacing <= 0f) return
+
+    val itemStarts =
+      styleContext.listItemStarts
+        .filter { it in start until builder.length }
+        .distinct()
+        .sorted()
+
+    for (itemStart in itemStarts.drop(1)) {
+      builder.setSpan(
+        ListItemSpacingSpan(itemSpacing),
+        itemStart - 1,
+        itemStart,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,85 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import com.facebook.react.uimanager.PixelUtil
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.MentionChipSpan
+import com.renderrichtext.spans.MentionSpan
+import com.renderrichtext.spans.TextSpan
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+/**
+ * Tiptap mention atom. The node has no children; the visible text is `@` plus
+ * `label`, or `id` when `label` is blank. That is the suggestion character the
+ * Mention extension inserts.
+ *
+ * Weight is medium (`500`), the Android face used for a name inside body text.
+ * iOS uses semibold for the same role.
+ */
+class MentionRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val mentionId = node.getAttribute("id").orEmpty()
+    val label = node.getAttribute("label").orEmpty()
+    val name = label.ifBlank { mentionId }
+    val text = "@$name"
+    val mentionStyle = config.style.mentionStyle
+    val block = factory.blockStyleContext.currentBlockStyleOrNull()
+    val fontSize = block?.fontSize ?: config.style.paragraphStyle.fontSize
+    val fontFamily = block?.fontFamily ?: config.style.paragraphStyle.fontFamily
+
+    val start = builder.length
+    builder.append(text)
+    val end = builder.length
+    builder.setSpan(
+      TextSpan(
+        BlockStyle(
+          fontSize = fontSize,
+          fontFamily = fontFamily,
+          fontWeight = "500",
+          color = mentionStyle.color,
+        ),
+        factory.context,
+      ),
+      start,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+    builder.setSpan(
+      MentionSpan(
+        mentionId,
+        label,
+        mentionStyle.color,
+        factory.onMentionPress,
+        factory.onMentionLongPress,
+      ),
+      start,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+    builder.setSpan(
+      MentionChipSpan(
+        backgroundColor = mentionStyle.backgroundColor,
+        textColor = mentionStyle.color,
+        paddingX = PixelUtil.toPixelFromDIP(PADDING_X_DP),
+        paddingY = PixelUtil.toPixelFromDIP(PADDING_Y_DP),
+      ),
+      start,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+  }
+
+  companion object {
+    private const val PADDING_X_DP = 3f
+    private const val PADDING_Y_DP = 1f
+  }
+}

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

@@ -0,0 +1,207 @@
+package com.renderrichtext.renderer
+
+import android.content.Context
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.style.MetricAffectingSpan
+import com.renderrichtext.math.LatexErrorReporter
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.ImageSpan
+import com.renderrichtext.styles.StyleConfig
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+interface NodeRenderer {
+  fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  )
+}
+
+data class RendererConfig(
+  val style: StyleConfig,
+  val onLatexError: LatexErrorReporter? = null,
+)
+
+class RendererFactory(
+  private val config: RendererConfig,
+  val context: Context,
+  private val onImageSpanCreated: (ImageSpan) -> Unit,
+) {
+  val blockStyleContext = BlockStyleContext()
+
+  val styleCache = SpanStyleCache(config.style)
+
+  /** Set for the duration of one render. Mention spans capture the values. */
+  var onMentionPress: ((String, String) -> Unit)? = null
+  var onMentionLongPress: ((String, String) -> Unit)? = null
+
+  /**
+   * Spans registered here are applied after the full document tree is rendered, so they
+   * always end up after block-level spans in the SpannableStringBuilder's internal array.
+   * See [BaselineShiftRenderer] for the root cause and the proper long-term fix.
+   *
+   * The range is kept as offsets. A renderer that inserts text into the builder after
+   * its children rendered (the blockquote padding spacer) must report it through
+   * [shiftDeferredSpans], so the recorded ranges keep following their text.
+   */
+  private class DeferredSpan(
+    val span: MetricAffectingSpan,
+    var start: Int,
+    var end: Int,
+  )
+
+  private val deferredSpans = mutableListOf<DeferredSpan>()
+  private val afterRenderActions = mutableListOf<(Spanned) -> Unit>()
+
+  fun registerDeferredSpan(
+    span: MetricAffectingSpan,
+    start: Int,
+    end: Int,
+  ) {
+    deferredSpans.add(DeferredSpan(span, start, end))
+  }
+
+  /** Runs [action] on the finished text, once every block-level span is in place. */
+  fun runAfterRender(action: (Spanned) -> Unit) {
+    afterRenderActions.add(action)
+  }
+
+  /** Call right after inserting [length] characters at [position] into the builder being rendered. */
+  fun shiftDeferredSpans(
+    position: Int,
+    length: Int,
+  ) {
+    // Spans are registered in document order, so only the most recent ones can lie at
+    // or after the insertion point.
+    for (index in deferredSpans.indices.reversed()) {
+      val deferred = deferredSpans[index]
+      if (deferred.end <= position) break
+      if (deferred.start >= position) deferred.start += length
+      deferred.end += length
+    }
+  }
+
+  fun flushDeferredSpans(builder: SpannableStringBuilder) {
+    for (deferred in deferredSpans) {
+      builder.setSpan(deferred.span, deferred.start, deferred.end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    }
+    deferredSpans.clear()
+    afterRenderActions.forEach { it(builder) }
+    afterRenderActions.clear()
+  }
+
+  fun resetForNewRender() {
+    blockStyleContext.resetForNewRender()
+    deferredSpans.clear()
+    afterRenderActions.clear()
+  }
+
+  fun createImageSpan(
+    imageUrl: String,
+    isInline: Boolean,
+    altText: String,
+  ): ImageSpan =
+    ImageSpan(
+      context = context,
+      imageUrl = imageUrl,
+      styleConfig = config.style,
+      isInline = isInline,
+      altText = altText,
+    )
+
+  private val textRenderer = TextRenderer()
+  private val lineBreakRenderer = LineBreakRenderer()
+  private val softBreakRenderer = SoftBreakRenderer()
+
+  private val renderers: Map<TiptapASTNode.NodeType, NodeRenderer> by lazy {
+    buildMap {
+      put(TiptapASTNode.NodeType.Paragraph, ParagraphRenderer(config))
+      put(TiptapASTNode.NodeType.Heading, HeadingRenderer(config))
+      put(TiptapASTNode.NodeType.Blockquote, BlockquoteRenderer(config))
+      // A list-nested admonition falls back to the inline blockquote renderer
+      // (no themed header); top-level admonitions use the segment container path.
+      put(TiptapASTNode.NodeType.Admonition, BlockquoteRenderer(config))
+      put(TiptapASTNode.NodeType.CodeBlock, CodeBlockRenderer(config))
+      put(TiptapASTNode.NodeType.UnorderedList, ListRenderer(config, isOrdered = false))
+      put(TiptapASTNode.NodeType.OrderedList, ListRenderer(config, isOrdered = true))
+      put(TiptapASTNode.NodeType.ListItem, ListItemRenderer(config))
+      put(TiptapASTNode.NodeType.Text, textRenderer)
+      put(TiptapASTNode.NodeType.Link, LinkRenderer(config))
+      put(TiptapASTNode.NodeType.Strong, StrongRenderer(config))
+      put(TiptapASTNode.NodeType.Emphasis, EmphasisRenderer(config))
+      put(TiptapASTNode.NodeType.Strikethrough, StrikethroughRenderer(config))
+      put(TiptapASTNode.NodeType.Underline, UnderlineRenderer(config))
+      put(TiptapASTNode.NodeType.Highlight, HighlightRenderer())
+      put(TiptapASTNode.NodeType.Code, CodeRenderer(config))
+      put(TiptapASTNode.NodeType.Factoid, FactoidRenderer(config))
+      put(TiptapASTNode.NodeType.Mention, MentionRenderer(config))
+      put(TiptapASTNode.NodeType.LineBreak, lineBreakRenderer)
+      put(TiptapASTNode.NodeType.SoftBreak, softBreakRenderer)
+      put(TiptapASTNode.NodeType.ThematicBreak, ThematicBreakRenderer(config))
+      put(TiptapASTNode.NodeType.BlankLine, BlankLineRenderer(config))
+    }
+  }
+
+  /**
+   * Called by ImageRenderer to report a new span to the collector.
+   */
+  fun registerImageSpan(span: ImageSpan) {
+    onImageSpanCreated(span)
+  }
+
+  fun getRenderer(node: TiptapASTNode): NodeRenderer =
+    renderers[node.type] ?: run {
+      android.util.Log.w("RendererFactory", "No renderer for: ${node.type}")
+      textRenderer
+    }
+
+  fun renderChildren(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+  ) {
+    renderNodes(node.children, builder, onLinkPress, onLinkLongPress, onFactoidPress)
+  }
+
+  /**
+   * Renders a flat list of sibling nodes in order, dispatching each to its
+   * NodeRenderer. Renders a block's own child content directly - e.g. a GFM
+   * blockquote's content once its nested block segments have been split out -
+   * without wrapping it in a synthetic root node.
+   */
+  fun renderNodes(
+    nodes: List<TiptapASTNode>,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+  ) {
+    nodes.forEach { node ->
+      getRenderer(node).render(node, builder, onLinkPress, onLinkLongPress, onFactoidPress, 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/renderrichtext/renderer/ParagraphRenderer.kt

@@ -0,0 +1,91 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import android.text.style.AlignmentSpan
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.styles.ParagraphStyle
+import com.renderrichtext.utils.text.extensions.containsBlockImage
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.renderrichtext.utils.text.span.applyLineHeightSkippingImages
+import com.renderrichtext.utils.text.span.applyMarginBottom
+import com.renderrichtext.utils.text.span.applyMarginTop
+
+class ParagraphRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val context = factory.blockStyleContext
+
+    // Inside a list, render tight with a single newline - lists own their item spacing.
+    if (context.listDepth > 0) {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress)
+      builder.append("\n")
+      return
+    }
+
+    val start = builder.length
+    val style = config.style.paragraphStyle
+
+    // Inside a blockquote, keep the quote's block style (font/color) and line height
+    // - applied by BlockquoteTextRenderer.postProcess - but still emit block margins so
+    // spacing between blocks matches the top-level document (a heading defaults to
+    // marginTop 0, so the gap before it comes from the preceding paragraph's marginBottom).
+    if (context.blockquoteDepth > 0) {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress)
+      if (builder.length > start) {
+        val marginTop = if (node.containsBlockImage()) config.style.imageStyle.marginTop else style.marginTop
+        applyMarginTop(builder, start, marginTop)
+        val marginBottom = if (node.containsBlockImage()) config.style.imageStyle.marginBottom else style.marginBottom
+        applyMarginBottom(builder, marginBottom)
+      }
+      return
+    }
+
+    context.setParagraphStyle(style)
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress)
+    } finally {
+      context.popBlockStyle()
+    }
+
+    if (builder.length > start) {
+      builder.applySpans(node, style, start)
+    }
+  }
+
+  private fun SpannableStringBuilder.applySpans(
+    node: TiptapASTNode,
+    style: ParagraphStyle,
+    start: Int,
+  ) {
+    val end = length
+
+    // TODO: LineHeightSpan may also clip superscript/subscript glyphs that extend
+    // outside the normal line bounds. A similar "skip" strategy as for images may
+    // be needed here once super/subscript usage in practice is better understood.
+    applyLineHeightSkippingImages(this, start, end, style.lineHeight)
+
+    // 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/renderrichtext/renderer/Renderer.kt

@@ -0,0 +1,148 @@
+package com.renderrichtext.renderer
+
+import android.content.Context
+import android.text.SpannableStringBuilder
+import com.renderrichtext.math.LatexErrorReporter
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.ImageSpan
+import com.renderrichtext.spans.MarginBottomSpan
+import com.renderrichtext.styles.StyleConfig
+
+class Renderer {
+  private var cachedFactory: RendererFactory? = null
+  private var cachedStyle: StyleConfig? = null
+  private var cachedContext: Context? = null
+  private var cachedOnLatexError: LatexErrorReporter? = null
+
+  private val collectedImageSpans = mutableListOf<ImageSpan>()
+  private var lastElementMarginBottom: Float = 0f
+
+  fun configure(
+    style: StyleConfig,
+    context: Context,
+    onLatexError: LatexErrorReporter? = null,
+  ) {
+    if (cachedStyle === style && cachedContext === context && cachedOnLatexError === onLatexError) return
+
+    cachedStyle = style
+    cachedContext = context
+    cachedOnLatexError = onLatexError
+    cachedFactory =
+      RendererFactory(
+        RendererConfig(style, onLatexError),
+        context,
+      ) { span -> reportImageSpan(span) }
+  }
+
+  fun renderDocument(
+    document: TiptapASTNode,
+    onLinkPress: ((String) -> Unit)? = null,
+    onLinkLongPress: ((String) -> Unit)? = null,
+    onFactoidPress: ((String) -> Unit)? = null,
+    onMentionPress: ((String, String) -> Unit)? = null,
+    onMentionLongPress: ((String, String) -> Unit)? = null,
+  ): SpannableStringBuilder =
+    renderContent(
+      document.children,
+      onLinkPress,
+      onLinkLongPress,
+      onFactoidPress,
+      onMentionPress,
+      onMentionLongPress,
+    )
+
+  /**
+   * Renders a flat list of sibling nodes into a fresh buffer and hands over
+   * ownership of it. This is the generic envelope shared by the document and
+   * block-segment paths: reset the factory, build the spannable, trim the trailing
+   * margin, and flush deferred spans (e.g. BaselineShiftSpan) after all block-level
+   * spans are set - see BaselineShiftRenderer for the proper long-term fix.
+   *
+   * An optional [block] decorates the pass - it enters a block style before the
+   * nodes render and post-processes the finished builder - letting a caller render
+   * content as e.g. blockquote text without this class knowing anything
+   * block-specific. See [BlockquoteTextRenderer].
+   *
+   * The builder is returned as-is rather than frozen into a `SpannableString`:
+   * the tiptap text view adopts it verbatim (see `NoCopySpannableFactory`),
+   * and converting it would cost a quadratic span copy for no benefit. Each call
+   * builds its own buffer, so callers must not mutate one they have passed on.
+   */
+  fun renderContent(
+    nodes: List<TiptapASTNode>,
+    onLinkPress: ((String) -> Unit)? = null,
+    onLinkLongPress: ((String) -> Unit)? = null,
+    onFactoidPress: ((String) -> Unit)? = null,
+    onMentionPress: ((String, String) -> Unit)? = null,
+    onMentionLongPress: ((String, String) -> Unit)? = null,
+    block: BlockquoteTextRenderer? = null,
+  ): SpannableStringBuilder {
+    val factory =
+      requireNotNull(cachedFactory) {
+        "Renderer must be configured with a style before rendering."
+      }
+
+    factory.resetForNewRender()
+    factory.onMentionPress = onMentionPress
+    factory.onMentionLongPress = onMentionLongPress
+    collectedImageSpans.clear()
+    lastElementMarginBottom = 0f
+
+    val builder = SpannableStringBuilder()
+
+    block?.push(factory.blockStyleContext)
+    try {
+      factory.renderNodes(nodes, builder, onLinkPress, onLinkLongPress, onFactoidPress)
+    } finally {
+      block?.pop(factory.blockStyleContext)
+    }
+
+    removeTrailingMargin(builder)
+    block?.postProcess(builder)
+    factory.flushDeferredSpans(builder)
+
+    return 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
+
+  /**
+   * Internal helper used by the Factory's lambda to collect spans.
+   */
+  private fun reportImageSpan(span: ImageSpan) {
+    collectedImageSpans.add(span)
+  }
+
+  /**
+   * Provides the EnrichedTiptapText with the exact list of spans that need registration.
+   */
+  fun getCollectedImageSpans(): List<ImageSpan> = collectedImageSpans
+}

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

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