react-native-enriched-markdown 0.1.1 → 0.2.0

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

@@ -3,8 +3,9 @@ package com.swmansion.enriched.markdown.renderer
 import android.text.SpannableStringBuilder
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode
 import com.swmansion.enriched.markdown.spans.BlockquoteSpan
-import com.swmansion.enriched.markdown.spans.MarginBottomSpan
 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.createLineHeightSpan
 
 class BlockquoteRenderer(
@@ -14,6 +15,7 @@ class BlockquoteRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
     val start = builder.length
@@ -21,12 +23,12 @@ class BlockquoteRenderer(
     val context = factory.blockStyleContext
     val depth = context.blockquoteDepth
 
-    // 1. Context management
+    // Track depth to handle nested indentation levels
     context.blockquoteDepth = depth + 1
     context.setBlockquoteStyle(style)
 
     try {
-      factory.renderChildren(node, builder, onLinkPress)
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
     } finally {
       context.clearBlockStyle()
       context.blockquoteDepth = depth
@@ -35,7 +37,7 @@ class BlockquoteRenderer(
     if (builder.length == start) return
     val end = builder.length
 
-    // 2. Identify Nested Ranges (Essential for excluding them from parent-level styles)
+    // Find immediately nested quotes to exclude them from this level's line-height/margins
     val nestedRanges =
       builder
         .getSpans(start, end, BlockquoteSpan::class.java)
@@ -43,7 +45,7 @@ class BlockquoteRenderer(
         .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
         .sortedBy { it.first }
 
-    // 3. Apply the Accent Bar Span (Must cover the full range for continuity)
+    // The Accent Bar Span covers the full range for visual continuity
     builder.setSpan(
       BlockquoteSpan(style, depth, factory.context, factory.styleCache),
       start,
@@ -51,20 +53,13 @@ class BlockquoteRenderer(
       SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
     )
 
-    // 4. Fragmented Styling Logic
-    // We apply line height and margin specifically to the segments that are NOT nested quotes.
+    // Apply styling only to segments that are NOT nested quotes
     applySpansExcludingNested(builder, nestedRanges, start, end, createLineHeightSpan(style.lineHeight))
 
-    // 5. Root-level Spacing
-    if (depth == 0 && style.marginBottom > 0) {
-      val spacerLocation = builder.length
-      builder.append("\n") // Physical break
-      builder.setSpan(
-        MarginBottomSpan(style.marginBottom),
-        spacerLocation,
-        builder.length,
-        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
-      )
+    // Margins are only applied by the outermost (root) quote
+    if (depth == 0) {
+      applyMarginTop(builder, start, style.marginTop)
+      applyMarginBottom(builder, style.marginBottom)
     }
   }
 
@@ -73,7 +68,7 @@ class BlockquoteRenderer(
     nestedRanges: List<Pair<Int, Int>>,
     start: Int,
     end: Int,
-    span: Any, // Changed to Any to handle both LineHeight and MarginBottom spans
+    span: Any,
   ) {
     var currentPos = start
     for ((nestedStart, nestedEnd) in nestedRanges) {

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

@@ -8,6 +8,7 @@ import com.swmansion.enriched.markdown.parser.MarkdownASTNode
 import com.swmansion.enriched.markdown.spans.CodeBlockSpan
 import com.swmansion.enriched.markdown.spans.MarginBottomSpan
 import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.applyMarginTop
 
 class CodeBlockRenderer(
   private val config: RendererConfig,
@@ -16,56 +17,55 @@ class CodeBlockRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
     val start = builder.length
     val style = config.style.codeBlockStyle
     val context = factory.blockStyleContext
 
-    // Set code block style in context for children to inherit
+    applyMarginTop(builder, start, style.marginTop)
+
+    // Content starts after the potential 1-character marginTop spacer
+    val contentStart = start + (if (style.marginTop > 0) 1 else 0)
+
     context.setCodeBlockStyle(style)
 
     try {
-      // Render children (code content)
-      factory.renderChildren(node, builder, onLinkPress)
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
     } finally {
       context.clearBlockStyle()
     }
 
-    // Safety check for empty code blocks
-    if (builder.length == start) return
+    if (builder.length == contentStart) return
 
     val end = builder.length
     val padding = style.padding.toInt()
 
-    // 1. Apply CodeBlockSpan (Handles Background, Borders, and Horizontal Padding)
-    // Matches the logic in the updated CodeBlockSpan for full-width support
+    // Apply background, borders, and horizontal padding to content only
     builder.setSpan(
       CodeBlockSpan(style, factory.context, factory.styleCache),
-      start,
+      contentStart,
       end,
       SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
     )
 
-    // 2. Apply Boundary Vertical Padding
+    // Apply vertical padding via line height manipulation
     builder.setSpan(
       CodeBlockBoundaryPaddingSpan(padding),
-      start,
+      contentStart,
       end,
       SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
     )
 
-    // 3. Apply External Margin Bottom
-    if (style.marginBottom > 0) {
-      val marginStart = builder.length
-      builder.append("\n")
-      builder.setSpan(
-        MarginBottomSpan(style.marginBottom),
-        marginStart,
-        builder.length,
-        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
-      )
-    }
+    val marginStart = builder.length
+    builder.append("\n")
+    builder.setSpan(
+      MarginBottomSpan(style.marginBottom),
+      marginStart,
+      builder.length,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
   }
 
   /**
@@ -87,14 +87,13 @@ class CodeBlockRenderer(
       val spanStart = text.getSpanStart(this)
       val spanEnd = text.getSpanEnd(this)
 
-      // Apply top vertical padding to the first line fragment
+      // Adjust ascent/top for the first line to create internal top padding
       if (startLine == spanStart) {
         fm.ascent -= padding
         fm.top -= padding
       }
 
-      // Apply bottom vertical padding to the last line fragment
-      // Checks for both character index and trailing newlines to ensure a tight fit
+      // Adjust descent/bottom for the last line (handling trailing newlines)
       val isLastLine = endLine == spanEnd || (spanEnd <= endLine && text[spanEnd - 1] == '\n')
       if (isLastLine) {
         fm.descent += padding

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

@@ -13,6 +13,7 @@ class CodeRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
     if (node.children.isEmpty() || node.children.all { it.content.isEmpty() }) return

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

@@ -8,8 +8,9 @@ class DocumentRenderer : NodeRenderer {
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
-    factory.renderChildren(node, builder, onLinkPress)
+    factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
   }
 }

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

@@ -12,9 +12,10 @@ class EmphasisRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
-    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress) }) { start, end, blockStyle ->
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { start, end, blockStyle ->
       builder.setSpan(
         EmphasisSpan(factory.styleCache, blockStyle),
         start,

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

@@ -1,10 +1,12 @@
 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.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.applyMarginTop
 import com.swmansion.enriched.markdown.utils.createLineHeightSpan
 
 class HeadingRenderer(
@@ -14,6 +16,7 @@ class HeadingRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
     val level = node.getAttribute("level")?.toIntOrNull() ?: 1
@@ -23,13 +26,14 @@ class HeadingRenderer(
     factory.blockStyleContext.setHeadingStyle(headingStyle, level)
 
     try {
-      factory.renderChildren(node, builder, onLinkPress)
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
     } finally {
       factory.blockStyleContext.clearBlockStyle()
     }
 
     val end = builder.length
     val contentLength = end - start
+
     if (contentLength > 0) {
       builder.setSpan(
         HeadingSpan(
@@ -48,7 +52,19 @@ class HeadingRenderer(
         SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
       )
 
-      applyMarginBottom(builder, start, headingStyle.marginBottom)
+      // 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/swmansion/enriched/markdown/renderer/ImageRenderer.kt

@@ -15,6 +15,7 @@ class ImageRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
     val imageUrl = node.getAttribute("url") ?: return
@@ -22,20 +23,21 @@ class ImageRenderer(
     val isInline = builder.isInlineImage()
     val start = builder.length
 
-    // 1. Append the placeholder character
+    // Append Object Replacement Character as the span anchor
     builder.append("\uFFFC")
     val end = builder.length
 
-    // 2. Create the Span
+    val altText = extractTextFromNode(node)
+
     val span =
       ImageSpan(
         context = context,
         imageUrl = imageUrl,
         styleConfig = config.style,
         isInline = isInline,
+        altText = altText,
       )
 
-    // 3. Attach it to the builder
     builder.setSpan(
       span,
       start,
@@ -43,10 +45,24 @@ class ImageRenderer(
       SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
     )
 
-    // 4. REPORT the span to the collector via the factory
+    // Notify factory for external span tracking/collection
     factory.registerImageSpan(span)
+  }
+
+  /**
+   * Recursively extracts text content from children to use as alt text.
+   */
+  private fun extractTextFromNode(node: MarkdownASTNode): String {
+    val buffer = StringBuilder()
+    appendChildText(node, buffer)
+    return buffer.toString().trim()
+  }
 
-    // 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
+  private fun appendChildText(
+    node: MarkdownASTNode,
+    buffer: StringBuilder,
+  ) {
+    node.content?.let { buffer.append(it) }
+    node.children.forEach { child -> appendChildText(child, buffer) }
   }
 }

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

@@ -8,6 +8,7 @@ class LineBreakRenderer : NodeRenderer {
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
     builder.append("\n")

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

@@ -12,13 +12,14 @@ class LinkRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
     val url = node.getAttribute("url") ?: return
 
-    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress) }) { start, end, blockStyle ->
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { start, end, blockStyle ->
       builder.setSpan(
-        LinkSpan(url, onLinkPress, factory.styleCache, blockStyle, factory.context),
+        LinkSpan(url, onLinkPress, onLinkLongPress, factory.styleCache, blockStyle, factory.context),
         start,
         end,
         SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,

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

@@ -13,6 +13,7 @@ class ListItemRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
     val styleContext = factory.blockStyleContext
@@ -25,7 +26,7 @@ class ListItemRenderer(
     }
 
     // 2. Render Children
-    factory.renderChildren(node, builder, onLinkPress)
+    factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
 
     // 3. Normalize whitespace: Ensure the item ends with exactly one newline
     if (builder.length == start || builder.substring(start).isBlank()) return

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

@@ -4,6 +4,7 @@ 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.applyMarginTop
 import com.swmansion.enriched.markdown.utils.createLineHeightSpan
 
 class ListRenderer(
@@ -14,30 +15,37 @@ class ListRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((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
+    // 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)
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
     } finally {
       contextManager.exitList(entryState)
     }
 
-    // 3. Spacing & Styling
-    if (builder.length > start) {
-      applyListSpacing(builder, start, entryState.previousDepth, listStyle)
+    if (builder.length > contentStart) {
+      applyListSpacing(builder, contentStart, entryState.previousDepth, listStyle)
     }
   }
 
@@ -47,7 +55,6 @@ class ListRenderer(
     depth: Int,
     style: com.swmansion.enriched.markdown.styles.BaseBlockStyle,
   ) {
-    // Apply line height to the entire list block
     builder.setSpan(
       createLineHeightSpan(style.lineHeight),
       start,
@@ -55,8 +62,8 @@ class ListRenderer(
       SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
     )
 
-    // Only apply bottom margin for top-level lists
-    if (depth == 0 && style.marginBottom > 0) {
+    // External bottom margin is only handled by the root-level list
+    if (depth == 0) {
       builder.append("\n")
       builder.setSpan(
         MarginBottomSpan(style.marginBottom),

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

@@ -11,6 +11,7 @@ interface NodeRenderer {
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   )
 }
@@ -49,6 +50,8 @@ class RendererFactory(
       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,
@@ -73,9 +76,10 @@ class RendererFactory(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
   ) {
     node.children.forEach { child ->
-      getRenderer(child).render(child, builder, onLinkPress, this)
+      getRenderer(child).render(child, builder, onLinkPress, onLinkLongPress, this)
     }
   }
 

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

@@ -1,13 +1,14 @@
 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
-import com.swmansion.enriched.markdown.utils.getMarginBottomForParagraph
 
 class ParagraphRenderer(
   private val config: RendererConfig,
@@ -16,29 +17,28 @@ class ParagraphRenderer(
     node: MarkdownASTNode,
     builder: SpannableStringBuilder,
     onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
     factory: RendererFactory,
   ) {
     val context = factory.blockStyleContext
 
-    // If nested, just render content and a newline
+    // If nested (e.g., inside a list or blockquote), render content simply with a newline
     if (context.isInsideBlockElement()) {
-      factory.renderChildren(node, builder, onLinkPress)
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
       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)
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
     } finally {
       context.clearBlockStyle()
     }
 
-    // Apply spans only if content was actually added
     if (builder.length > start) {
       builder.applySpans(node, style, start)
     }
@@ -49,8 +49,9 @@ class ParagraphRenderer(
     style: ParagraphStyle,
     start: Int,
   ) {
-    val end = length // Current length is the end point
+    val end = length
 
+    // LineHeightSpan is avoided for block images to prevent clipping/overlapping
     if (!node.containsBlockImage()) {
       setSpan(
         createLineHeightSpan(style.lineHeight),
@@ -60,7 +61,20 @@ class ParagraphRenderer(
       )
     }
 
-    val margin = getMarginBottomForParagraph(node, style, config.style)
-    applyMarginBottom(this, start, margin)
+    // 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

@@ -14,6 +14,7 @@ class Renderer {
   private var cachedContext: Context? = null
 
   private val collectedImageSpans = mutableListOf<ImageSpan>()
+  private var lastElementMarginBottom: Float = 0f
 
   fun configure(
     style: StyleConfig,
@@ -33,6 +34,7 @@ class Renderer {
   fun renderDocument(
     document: MarkdownASTNode,
     onLinkPress: ((String) -> Unit)? = null,
+    onLinkLongPress: ((String) -> Unit)? = null,
   ): SpannableString {
     val factory =
       requireNotNull(cachedFactory) {
@@ -41,10 +43,11 @@ class Renderer {
 
     factory.resetForNewRender()
     collectedImageSpans.clear()
+    lastElementMarginBottom = 0f
 
     val builder = SpannableStringBuilder()
 
-    renderNode(document, builder, onLinkPress, factory)
+    renderNode(document, builder, onLinkPress, onLinkLongPress, factory)
 
     // Remove trailing margin from last block element
     removeTrailingMargin(builder)
@@ -52,33 +55,44 @@ class Renderer {
     return SpannableString(builder)
   }
 
-  /** Removes trailing margin to eliminate bottom spacing */
+  /** Removes trailing newlines and captures the margin of the final element. */
   private fun removeTrailingMargin(builder: SpannableStringBuilder) {
     if (builder.isEmpty()) return
 
-    val spans = builder.getSpans(0, builder.length, MarginBottomSpan::class.java)
-    if (spans.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) }
 
-    val lastSpan = spans.maxByOrNull { builder.getSpanEnd(it) } ?: return
-    val spanEnd = builder.getSpanEnd(lastSpan)
+    lastElementMarginBottom = lastSpan?.marginBottom ?: 0f
 
-    // Remove trailing newlines (added for block spacing)
-    while (builder.isNotEmpty() && builder.last() == '\n') {
+    // Trim trailing newlines
+    while (builder.endsWith('\n')) {
       builder.delete(builder.length - 1, builder.length)
     }
 
-    if (spanEnd >= 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, factory)
+    factory.getRenderer(node).render(node, builder, onLinkPress, onLinkLongPress, factory)
   }
 
   /**

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

@@ -12,6 +12,7 @@ class SpanStyleCache(
 
   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