react-native-enriched-markdown 0.1.0 → 0.2.0

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

@@ -0,0 +1,104 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.graphics.Paint
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.style.LineHeightSpan
+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,
+) : NodeRenderer {
+  override fun render(
+    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
+
+    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 {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+    } finally {
+      context.clearBlockStyle()
+    }
+
+    if (builder.length == contentStart) return
+
+    val end = builder.length
+    val padding = style.padding.toInt()
+
+    // Apply background, borders, and horizontal padding to content only
+    builder.setSpan(
+      CodeBlockSpan(style, factory.context, factory.styleCache),
+      contentStart,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+
+    // Apply vertical padding via line height manipulation
+    builder.setSpan(
+      CodeBlockBoundaryPaddingSpan(padding),
+      contentStart,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+
+    val marginStart = builder.length
+    builder.append("\n")
+    builder.setSpan(
+      MarginBottomSpan(style.marginBottom),
+      marginStart,
+      builder.length,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+  }
+
+  /**
+   * Internal span to handle top/bottom padding by modifying font metrics.
+   */
+  private class CodeBlockBoundaryPaddingSpan(
+    private val padding: Int,
+  ) : LineHeightSpan {
+    override fun chooseHeight(
+      text: CharSequence,
+      startLine: Int,
+      endLine: Int,
+      spanstartv: Int,
+      v: Int,
+      fm: Paint.FontMetricsInt,
+    ) {
+      if (text !is Spanned) return
+
+      val spanStart = text.getSpanStart(this)
+      val spanEnd = text.getSpanEnd(this)
+
+      // Adjust ascent/top for the first line to create internal top padding
+      if (startLine == spanStart) {
+        fm.ascent -= padding
+        fm.top -= padding
+      }
+
+      // 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
+        fm.bottom += padding
+      }
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.CodeBackgroundSpan
+import com.swmansion.enriched.markdown.spans.CodeSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class CodeRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    if (node.children.isEmpty() || node.children.all { it.content.isEmpty() }) return
+
+    factory.renderWithSpan(builder, { node.children.forEach { builder.append(it.content) } }) { start, end, blockStyle ->
+      builder.setSpan(
+        CodeSpan(factory.styleCache, blockStyle),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+      builder.setSpan(
+        CodeBackgroundSpan(config.style),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+
+class DocumentRenderer : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/EmphasisRenderer.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.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)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { 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,70 @@
+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(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((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, onLinkLongPress)
+    } 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,
+      )
+
+      // 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

@@ -0,0 +1,68 @@
+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)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val imageUrl = node.getAttribute("url") ?: return
+
+    val isInline = builder.isInlineImage()
+    val start = builder.length
+
+    // Append Object Replacement Character as the span anchor
+    builder.append("\uFFFC")
+    val end = builder.length
+
+    val altText = extractTextFromNode(node)
+
+    val span =
+      ImageSpan(
+        context = context,
+        imageUrl = imageUrl,
+        styleConfig = config.style,
+        isInline = isInline,
+        altText = altText,
+      )
+
+    builder.setSpan(
+      span,
+      start,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+
+    // 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()
+  }
+
+  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

@@ -0,0 +1,16 @@
+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)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    builder.append("\n")
+  }
+}

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

@@ -0,0 +1,29 @@
+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)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val url = node.getAttribute("url") ?: return
+
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress) }) { start, end, blockStyle ->
+      builder.setSpan(
+        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/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,59 @@
+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)?,
+    onLinkLongPress: ((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, onLinkLongPress)
+
+    // 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,76 @@
+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.applyMarginTop
+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)?,
+    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
+
+    val contextManager = ListContextManager(factory.blockStyleContext, config.style)
+    val entryState = contextManager.enterList(listType, listStyle)
+
+    // 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)
+    } finally {
+      contextManager.exitList(entryState)
+    }
+
+    if (builder.length > contentStart) {
+      applyListSpacing(builder, contentStart, entryState.previousDepth, listStyle)
+    }
+  }
+
+  private fun applyListSpacing(
+    builder: SpannableStringBuilder,
+    start: Int,
+    depth: Int,
+    style: com.swmansion.enriched.markdown.styles.BaseBlockStyle,
+  ) {
+    builder.setSpan(
+      createLineHeightSpan(style.lineHeight),
+      start,
+      builder.length,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+
+    // External bottom margin is only handled by the root-level list
+    if (depth == 0) {
+      builder.append("\n")
+      builder.setSpan(
+        MarginBottomSpan(style.marginBottom),
+        builder.length - 1,
+        builder.length,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}