react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

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

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

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

@@ -0,0 +1,134 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.graphics.Typeface
+import com.swmansion.enriched.markdown.styles.LinkVariantEntry
+import com.swmansion.enriched.markdown.styles.StyleConfig
+
+/** Shared style cache for spans to avoid redundant calculations. */
+class SpanStyleCache(
+  style: StyleConfig,
+) {
+  // Colors to preserve when applying inline styles (links, code, strong, emphasis)
+  val colorsToPreserve: IntArray = buildColorsToPreserve(style)
+
+  val strongFontFamily: String = style.strongStyle.fontFamily
+  val strongFontWeight: String = style.strongStyle.fontWeight
+  val strongColor: Int? = style.strongStyle.color
+  val emphasisFontFamily: String = style.emphasisStyle.fontFamily
+  val emphasisFontStyle: String = style.emphasisStyle.fontStyle
+  val emphasisColor: Int? = style.emphasisStyle.color
+  val strikethroughColor: Int = style.strikethroughStyle.color
+  val linkFontFamily: String = style.linkStyle.fontFamily
+  val linkColor: Int = style.linkStyle.color
+  val linkUnderline: Boolean = style.linkStyle.underline
+  val linkBackgroundColor: Int = style.linkStyle.backgroundColor
+  val linkVariants: List<LinkVariantEntry> = style.linkVariants
+
+  private val compiledVariantPatterns: List<Pair<Regex, LinkVariantEntry>> =
+    linkVariants.mapNotNull { entry ->
+      try {
+        Regex(entry.pattern) to entry
+      } catch (_: Exception) {
+        null
+      }
+    }
+
+  val codeFontFamily: String = style.codeStyle.fontFamily
+  val codeFontSize: Float = style.codeStyle.fontSize
+  val codeColor: Int = style.codeStyle.color
+  val spoilerColor: Int = style.spoilerStyle.color
+  val spoilerParticleDensity: Float = style.spoilerStyle.particleDensity
+  val spoilerParticleSpeed: Float = style.spoilerStyle.particleSpeed
+  val spoilerSolidBorderRadius: Float = style.spoilerStyle.solidBorderRadius
+  val superscriptFontScale: Float = style.superscriptStyle.fontScale
+  val superscriptBaselineOffsetScale: Float = style.superscriptStyle.baselineOffsetScale
+  val subscriptFontScale: Float = style.subscriptStyle.fontScale
+  val subscriptBaselineOffsetScale: Float = style.subscriptStyle.baselineOffsetScale
+  val highlightColor: Int = style.highlightStyle.color
+  val highlightBackgroundColor: Int = style.highlightStyle.backgroundColor
+  private val paragraphColor: Int = style.paragraphStyle.color
+
+  private fun buildColorsToPreserve(style: StyleConfig): IntArray {
+    val paragraphColor = style.paragraphStyle.color
+    return buildList {
+      style.strongStyle.color
+        ?.takeIf { it != 0 }
+        ?.let { add(it) }
+      style.emphasisStyle.color
+        ?.takeIf { it != 0 }
+        ?.let { add(it) }
+      style.linkStyle.color
+        .takeIf { it != 0 && it != paragraphColor }
+        ?.let { add(it) }
+      style.linkVariants.forEach { variant ->
+        variant.color
+          .takeIf { it != 0 && it != paragraphColor }
+          ?.let { add(it) }
+      }
+      style
+        .codeStyle
+        .color
+        .takeIf { it != 0 }
+        ?.let { add(it) }
+      style.taskListStyle.checkedTextColor
+        .takeIf { it != 0 }
+        ?.let { add(it) }
+    }.toIntArray()
+  }
+
+  fun getStrongColorFor(blockColor: Int): Int = strongColor ?: blockColor
+
+  fun getHighlightColorFor(blockColor: Int): Int = if (highlightColor == paragraphColor) blockColor else highlightColor
+
+  fun getEmphasisColorFor(
+    blockColor: Int,
+    currentColor: Int,
+  ): Int =
+    if (currentColor == blockColor) {
+      emphasisColor ?: blockColor
+    } else {
+      currentColor
+    }
+
+  fun resolvedVariantForUrl(url: String): LinkVariantEntry? {
+    if (compiledVariantPatterns.isEmpty()) return null
+    return compiledVariantPatterns.firstOrNull { (regex, _) -> regex.containsMatchIn(url) }?.second
+  }
+
+  companion object {
+    private val typefaceCache = mutableMapOf<String, Typeface>()
+
+    /** Cached typeface for font family + style (BOLD, ITALIC, BOLD_ITALIC) */
+    fun getTypeface(
+      fontFamily: String,
+      style: Int,
+    ): Typeface =
+      typefaceCache.getOrPut("$fontFamily|$style") {
+        val base =
+          fontFamily
+            .takeIf { it.isNotEmpty() }
+            ?.let { Typeface.create(it, Typeface.NORMAL) }
+            ?: Typeface.DEFAULT
+        Typeface.create(base, style)
+      }
+
+    /** Cached typeface using weight string (e.g., "bold", "700") */
+    fun getTypefaceWithWeight(
+      fontFamily: String,
+      fontWeight: String,
+    ): Typeface {
+      val style =
+        when (fontWeight.lowercase()) {
+          "bold", "700", "800", "900" -> Typeface.BOLD
+          else -> Typeface.NORMAL
+        }
+      return getTypeface(fontFamily, style)
+    }
+
+    /** Cached monospace typeface preserving bold/italic */
+    fun getMonospaceTypeface(currentStyle: Int): Typeface =
+      typefaceCache.getOrPut("monospace|$currentStyle") {
+        Typeface.create(Typeface.MONOSPACE, currentStyle)
+      }
+  }
+}

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

@@ -0,0 +1,25 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.SpoilerSpan
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class SpoilerRenderer : 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(
+        SpoilerSpan(factory.styleCache, blockStyle),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+}

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

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

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

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

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

@@ -0,0 +1,11 @@
+package com.swmansion.enriched.markdown.renderer
+
+import com.swmansion.enriched.markdown.spans.BaselineShiftSpan
+
+class SubscriptRenderer : BaselineShiftRenderer() {
+  override fun fontScale(factory: RendererFactory): Float = factory.styleCache.subscriptFontScale
+
+  override fun baselineOffsetScale(factory: RendererFactory): Float = -factory.styleCache.subscriptBaselineOffsetScale
+
+  override fun spanType(): BaselineShiftSpan.SpanType = BaselineShiftSpan.SpanType.SUBSCRIPT
+}

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

@@ -0,0 +1,11 @@
+package com.swmansion.enriched.markdown.renderer
+
+import com.swmansion.enriched.markdown.spans.BaselineShiftSpan
+
+class SuperscriptRenderer : BaselineShiftRenderer() {
+  override fun fontScale(factory: RendererFactory): Float = factory.styleCache.superscriptFontScale
+
+  override fun baselineOffsetScale(factory: RendererFactory): Float = factory.styleCache.superscriptBaselineOffsetScale
+
+  override fun spanType(): BaselineShiftSpan.SpanType = BaselineShiftSpan.SpanType.SUPERSCRIPT
+}

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

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

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

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

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

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

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

@@ -0,0 +1,127 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.text.Layout
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.markdown.renderer.BlockStyle
+import com.swmansion.enriched.markdown.renderer.SpanStyleCache
+import com.swmansion.enriched.markdown.utils.text.extensions.applyBlockStyleFont
+import com.swmansion.enriched.markdown.utils.text.extensions.applyColorPreserving
+
+abstract class BaseListSpan(
+  val depth: Int,
+  protected val context: Context,
+  protected val styleCache: SpanStyleCache,
+  protected val blockStyle: BlockStyle,
+  protected val marginLeft: Float,
+  protected val gapWidth: Float,
+) : MetricAffectingSpan(),
+  LeadingMarginSpan {
+  private var cachedText: CharSequence? = null
+  private var cachedHasDeeperSpanByPosition = mutableMapOf<Int, Boolean>()
+
+  protected abstract fun getMarkerWidth(): Float
+
+  override fun updateMeasureState(textPaint: TextPaint) = applyTextStyle(textPaint)
+
+  override fun updateDrawState(textPaint: TextPaint) = applyTextStyle(textPaint)
+
+  override fun getLeadingMargin(first: Boolean): Int =
+    if (depth == 0) {
+      val effectiveGap = gapWidth.coerceAtLeast(DEFAULT_MIN_GAP)
+      (getMarkerWidth() + effectiveGap).toInt()
+    } else {
+      marginLeft.toInt()
+    }
+
+  override fun drawLeadingMargin(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    if (!first || shouldSkipDrawing(text, start) || !hasContent(text, start, end)) return
+
+    // Only draw the marker on the true first line of this span.
+    // \n inside list item content creates inner paragraphs, each with first=true,
+    // but only the line at the span start should get a bullet/number.
+    if (text is Spanned && text.getSpanStart(this) != start) return
+
+    val originalStyle = paint.style
+    val originalColor = paint.color
+    drawMarker(canvas, paint, x, dir, top, baseline, bottom, layout, start)
+    paint.style = originalStyle
+    paint.color = originalColor
+  }
+
+  protected abstract fun drawMarker(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    layout: Layout?,
+    start: Int,
+  )
+
+  @SuppressLint("WrongConstant")
+  private fun applyTextStyle(textPaint: TextPaint) {
+    textPaint.textSize = blockStyle.fontSize
+
+    val preservedStyle = (textPaint.typeface?.style ?: 0) and BOLD_ITALIC_MASK
+    textPaint.applyBlockStyleFont(blockStyle, context)
+    if (preservedStyle != 0) {
+      textPaint.typeface?.let { base -> textPaint.typeface = Typeface.create(base, preservedStyle) }
+    }
+
+    textPaint.applyColorPreserving(blockStyle.color, *styleCache.colorsToPreserve)
+  }
+
+  companion object {
+    private const val BOLD_ITALIC_MASK = Typeface.BOLD or Typeface.ITALIC
+    private const val DEFAULT_MIN_GAP = 4f
+  }
+
+  private fun hasContent(
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+  ): Boolean {
+    if (text == null || end <= start) return false
+    return (start until end).any { !text[it].isWhitespace() }
+  }
+
+  private fun shouldSkipDrawing(
+    text: CharSequence?,
+    start: Int,
+  ): Boolean {
+    if (text !is Spanned) return false
+
+    if (cachedText !== text) {
+      cachedText = text
+      cachedHasDeeperSpanByPosition.clear()
+    }
+
+    return cachedHasDeeperSpanByPosition.getOrPut(start) {
+      val spans = text.getSpans(start, start + 1, BaseListSpan::class.java)
+      spans.any { it.depth > depth }
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import kotlin.math.roundToInt
+
+class BaselineShiftSpan(
+  private val fontScale: Float,
+  private val baselineOffsetScale: Float,
+  val spanType: SpanType,
+) : MetricAffectingSpan() {
+  enum class SpanType { SUPERSCRIPT, SUBSCRIPT }
+
+  override fun updateDrawState(tp: TextPaint) {
+    applyShift(tp)
+  }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    applyShift(tp)
+  }
+
+  private fun applyShift(tp: TextPaint) {
+    val originalTextSize = tp.textSize
+    tp.textSize = originalTextSize * fontScale
+    tp.baselineShift -= (originalTextSize * baselineOffsetScale).roundToInt()
+  }
+}