react-native-enriched-markdown 0.1.0 → 0.1.1

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

@@ -0,0 +1,85 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.graphics.Typeface
+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 strongColor: Int? = style.strongStyle.color
+  val emphasisColor: Int? = style.emphasisStyle.color
+  val linkColor: Int = style.linkStyle.color
+  val linkUnderline: Boolean = style.linkStyle.underline
+  val codeColor: Int = style.codeStyle.color
+
+  private fun buildColorsToPreserve(style: StyleConfig): IntArray =
+    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 }
+        ?.let { add(it) }
+      style
+        .codeStyle
+        .color
+        .takeIf { it != 0 }
+        ?.let { add(it) }
+    }.toIntArray()
+
+  fun getStrongColorFor(blockColor: Int): Int = strongColor ?: blockColor
+
+  fun getEmphasisColorFor(
+    blockColor: Int,
+    currentColor: Int,
+  ): Int =
+    if (currentColor == blockColor) {
+      emphasisColor ?: blockColor
+    } else {
+      currentColor
+    }
+
+  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/StrongRenderer.kt

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

package/android/src/main/java/com/swmansion/enriched/markdown/renderer/TextRenderer.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.TextSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class TextRenderer : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((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,44 @@
+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.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class ThematicBreakRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((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/spans/BaseListSpan.kt

@@ -0,0 +1,136 @@
+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.applyBlockStyleFont
+import com.swmansion.enriched.markdown.utils.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 {
+  // Cache for shouldSkipDrawing to avoid repeated getSpans() calls during draw passes
+  private var cachedText: CharSequence? = null
+  private var cachedHasDeeperSpanByPosition = mutableMapOf<Int, Boolean>()
+
+  protected abstract fun getMarkerWidth(): Float
+
+  // --- MetricAffectingSpan Implementation ---
+
+  override fun updateMeasureState(tp: TextPaint) = applyTextStyle(tp)
+
+  override fun updateDrawState(tp: TextPaint) = applyTextStyle(tp)
+
+  // --- LeadingMarginSpan Implementation ---
+
+  override fun getLeadingMargin(first: Boolean): Int {
+    // Root items: just marker width + gap (flush to left edge)
+    // Nested items: add marginLeft for each nesting level
+    return if (depth == 0) {
+      val effectiveGap = gapWidth.coerceAtLeast(DEFAULT_MIN_GAP)
+      (getMarkerWidth() + effectiveGap).toInt()
+    } else {
+      marginLeft.toInt()
+    }
+  }
+
+  protected fun getEffectiveGapWidth(): Float = gapWidth.coerceAtLeast(DEFAULT_MIN_GAP)
+
+  override fun drawLeadingMargin(
+    c: Canvas,
+    p: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    // Draw only on the first line of paragraphs that have content and are not nested deeper
+    if (!first || shouldSkipDrawing(text, start) || !hasContent(text, start, end)) return
+
+    val originalStyle = p.style
+    val originalColor = p.color
+    drawMarker(c, p, x, dir, top, baseline, bottom, layout, start)
+    p.style = originalStyle
+    p.color = originalColor
+  }
+
+  protected abstract fun drawMarker(
+    c: Canvas,
+    p: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    layout: Layout?,
+    start: Int,
+  )
+
+  @SuppressLint("WrongConstant") // Result of mask is always valid: 0, 1, 2, or 3
+  private fun applyTextStyle(tp: TextPaint) {
+    tp.textSize = blockStyle.fontSize
+
+    val preservedStyle = (tp.typeface?.style ?: 0) and BOLD_ITALIC_MASK
+    tp.applyBlockStyleFont(blockStyle, context)
+    if (preservedStyle != 0) {
+      tp.typeface?.let { base -> tp.typeface = Typeface.create(base, preservedStyle) }
+    }
+
+    tp.applyColorPreserving(blockStyle.color, *styleCache.colorsToPreserve)
+  }
+
+  companion object {
+    private const val BOLD_ITALIC_MASK = Typeface.BOLD or Typeface.ITALIC // 3
+    private const val DEFAULT_MIN_GAP = 4f
+  }
+
+  // --- Helper Methods ---
+
+  private fun hasContent(
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+  ): Boolean {
+    if (text == null || end <= start) return false
+    // Check if there is at least one non-whitespace character in the range
+    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/BlockquoteSpan.kt

@@ -0,0 +1,135 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+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.styles.BlockquoteStyle
+import com.swmansion.enriched.markdown.utils.applyBlockStyleFont
+import com.swmansion.enriched.markdown.utils.applyColorPreserving
+
+class BlockquoteSpan(
+  private val blockquoteStyle: BlockquoteStyle,
+  val depth: Int,
+  private val context: Context,
+  private val styleCache: SpanStyleCache,
+) : MetricAffectingSpan(),
+  LeadingMarginSpan {
+  private val levelSpacing: Float = blockquoteStyle.borderWidth + blockquoteStyle.gapWidth
+  private val blockStyle =
+    BlockStyle(
+      fontSize = blockquoteStyle.fontSize,
+      fontFamily = blockquoteStyle.fontFamily,
+      fontWeight = blockquoteStyle.fontWeight,
+      color = blockquoteStyle.color,
+    )
+
+  // Cache for shouldSkipDrawing to avoid repeated getSpans() calls during draw passes
+  private var cachedText: CharSequence? = null
+  private var cachedMaxDepthByPosition = mutableMapOf<Int, Int>()
+
+  override fun updateMeasureState(tp: TextPaint) = applyTextStyle(tp)
+
+  override fun updateDrawState(tp: TextPaint) = applyTextStyle(tp)
+
+  override fun getLeadingMargin(first: Boolean): Int = levelSpacing.toInt()
+
+  override fun drawLeadingMargin(
+    c: Canvas,
+    p: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    // Essential check from original: only the deepest span draws to prevent over-rendering background
+    if (shouldSkipDrawing(text, start)) return
+
+    drawBackground(c, top, bottom, layout)
+
+    val borderPaint = configureBorderPaint()
+    val borderTop = top.toFloat()
+    val borderBottom = bottom.toFloat()
+    val containerLeft = layout?.getLineLeft(0) ?: 0f
+
+    for (level in 0..depth) {
+      val borderX = containerLeft + (levelSpacing * level * dir)
+      val borderRight = borderX + (blockquoteStyle.borderWidth * dir)
+      c.drawRect(borderX, borderTop, borderRight, borderBottom, borderPaint)
+    }
+  }
+
+  @SuppressLint("WrongConstant") // Result of mask is always valid: 0, 1, 2, or 3
+  private fun applyTextStyle(tp: TextPaint) {
+    tp.textSize = blockStyle.fontSize
+    val preserved = (tp.typeface?.style ?: 0) and BOLD_ITALIC_MASK
+    tp.applyBlockStyleFont(blockStyle, context)
+    if (preserved != 0) {
+      tp.typeface = Typeface.create(tp.typeface ?: Typeface.DEFAULT, preserved)
+    }
+    tp.applyColorPreserving(blockStyle.color, *styleCache.colorsToPreserve)
+  }
+
+  companion object {
+    private const val BOLD_ITALIC_MASK = Typeface.BOLD or Typeface.ITALIC
+
+    private val sharedBorderPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+    private val sharedBackgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+  }
+
+  private fun configureBorderPaint(): Paint =
+    sharedBorderPaint.apply {
+      color = blockquoteStyle.borderColor
+    }
+
+  private fun configureBackgroundPaint(bgColor: Int): Paint =
+    sharedBackgroundPaint.apply {
+      color = bgColor
+    }
+
+  private fun shouldSkipDrawing(
+    text: CharSequence?,
+    start: Int,
+  ): Boolean {
+    if (text !is Spanned) return false
+
+    if (cachedText !== text) {
+      cachedText = text
+      cachedMaxDepthByPosition.clear()
+    }
+
+    val maxDepth =
+      cachedMaxDepthByPosition.getOrPut(start) {
+        val spans = text.getSpans(start, start + 1, BlockquoteSpan::class.java)
+        spans.maxOfOrNull { it.depth } ?: -1
+      }
+
+    return maxDepth > depth
+  }
+
+  private fun drawBackground(
+    c: Canvas,
+    top: Int,
+    bottom: Int,
+    layout: Layout?,
+  ) {
+    val bgColor = blockquoteStyle.backgroundColor?.takeIf { it != Color.TRANSPARENT } ?: return
+    val backgroundPaint = configureBackgroundPaint(bgColor)
+    c.drawRect(0f, top.toFloat(), layout?.width?.toFloat() ?: 0f, bottom.toFloat(), backgroundPaint)
+  }
+}

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

@@ -0,0 +1,180 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.Spanned
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.text.style.LineBackgroundSpan
+import com.swmansion.enriched.markdown.styles.StyleConfig
+import kotlin.math.max
+import kotlin.math.min
+
+class CodeBackgroundSpan(
+  private val styleConfig: StyleConfig,
+) : LineBackgroundSpan {
+  companion object {
+    private const val CORNER_RADIUS = 6.0f
+    private const val BORDER_WIDTH = 1.0f
+
+    private val sharedBackgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+    private val sharedBorderPaint =
+      Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = Paint.Style.STROKE
+        strokeWidth = BORDER_WIDTH
+        strokeJoin = Paint.Join.ROUND
+        strokeCap = Paint.Cap.ROUND
+      }
+  }
+
+  // Reusable drawing objects per instance
+  private val rect = RectF()
+  private val path = Path()
+
+  override fun drawBackground(
+    canvas: Canvas,
+    p: Paint,
+    left: Int,
+    right: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    lineNum: Int,
+  ) {
+    if (text !is Spanned) return
+
+    val spanStart = text.getSpanStart(this)
+    val spanEnd = text.getSpanEnd(this)
+    if (spanStart !in 0 until spanEnd) return
+
+    // 1. Determine relative positioning
+    val isFirst = spanStart >= start
+    val isLast = spanEnd <= end
+
+    // 2. Calculate coordinates
+    val finalBottom = adjustBottomForMargin(text, end, bottom)
+    val startX = if (isFirst) getHorizontalOffset(text, start, end, spanStart, p) + left else left.toFloat()
+    val endX = if (isLast) getHorizontalOffset(text, start, end, spanEnd, p) + left else right.toFloat()
+
+    rect.set(min(startX, endX), top.toFloat(), max(startX, endX), finalBottom.toFloat())
+
+    // 3. Apply Style
+    val codeStyle = styleConfig.codeStyle
+    sharedBackgroundPaint.color = codeStyle.backgroundColor
+    sharedBorderPaint.color = codeStyle.borderColor
+
+    drawShapes(canvas, isFirst, isLast)
+  }
+
+  private fun getHorizontalOffset(
+    text: CharSequence,
+    lineStart: Int,
+    lineEnd: Int,
+    index: Int,
+    paint: Paint,
+  ): Float {
+    if (index <= lineStart) return 0f
+    val lineText = text.subSequence(lineStart, lineEnd)
+    val textPaint = paint as? TextPaint ?: TextPaint(paint)
+    val layout = StaticLayout.Builder.obtain(lineText, 0, lineText.length, textPaint, 10000).build()
+    return layout.getPrimaryHorizontal(index - lineStart)
+  }
+
+  private fun drawShapes(
+    canvas: Canvas,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) {
+    val radii = createRadii(isFirst, isLast)
+
+    path.reset()
+    path.addRoundRect(rect, radii, Path.Direction.CW)
+    canvas.drawPath(path, sharedBackgroundPaint)
+
+    if (isFirst && isLast) {
+      canvas.drawPath(path, sharedBorderPaint)
+    } else {
+      drawOpenBorders(canvas, isFirst, isLast)
+    }
+  }
+
+  private fun drawOpenBorders(
+    canvas: Canvas,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) {
+    val r = CORNER_RADIUS
+    path.reset()
+
+    if (isFirst) {
+      path.moveTo(rect.right, rect.top)
+      path.lineTo(rect.left + r, rect.top)
+      path.quadTo(rect.left, rect.top, rect.left, rect.top + r)
+      path.lineTo(rect.left, rect.bottom - r)
+      path.quadTo(rect.left, rect.bottom, rect.left + r, rect.bottom)
+      path.lineTo(rect.right, rect.bottom)
+    } else if (isLast) {
+      path.moveTo(rect.left, rect.top)
+      path.lineTo(rect.right - r, rect.top)
+      path.quadTo(rect.right, rect.top, rect.right, rect.top + r)
+      path.lineTo(rect.right, rect.bottom - r)
+      path.quadTo(rect.right, rect.bottom, rect.right - r, rect.bottom)
+      path.lineTo(rect.left, rect.bottom)
+    } else {
+      path.moveTo(rect.left, rect.top)
+      path.lineTo(rect.right, rect.top)
+      path.moveTo(rect.left, rect.bottom)
+      path.lineTo(rect.right, rect.bottom)
+    }
+    canvas.drawPath(path, sharedBorderPaint)
+  }
+
+  private fun createRadii(
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) = when {
+    isFirst && isLast -> {
+      floatArrayOf(
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+      )
+    }
+
+    isFirst -> {
+      floatArrayOf(CORNER_RADIUS, CORNER_RADIUS, 0f, 0f, 0f, 0f, CORNER_RADIUS, CORNER_RADIUS)
+    }
+
+    isLast -> {
+      floatArrayOf(0f, 0f, CORNER_RADIUS, CORNER_RADIUS, CORNER_RADIUS, CORNER_RADIUS, 0f, 0f)
+    }
+
+    else -> {
+      floatArrayOf(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f)
+    }
+  }
+
+  private fun adjustBottomForMargin(
+    text: Spanned,
+    lineEnd: Int,
+    bottom: Int,
+  ): Int {
+    if (lineEnd <= 0 || lineEnd > text.length || text[lineEnd - 1] != '\n') return bottom
+    val marginSpans = text.getSpans(lineEnd - 1, lineEnd, MarginBottomSpan::class.java)
+    var adjusted = bottom
+    for (span in marginSpans) {
+      if (text.getSpanEnd(span) == lineEnd) adjusted -= span.marginBottom.toInt()
+    }
+    return adjusted
+  }
+}