react-native-enriched-markdown 0.1.0 → 0.1.1

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

@@ -0,0 +1,196 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.Layout
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+import android.text.style.LineBackgroundSpan
+import android.text.style.MetricAffectingSpan
+import androidx.core.graphics.withSave
+import com.swmansion.enriched.markdown.renderer.BlockStyle
+import com.swmansion.enriched.markdown.renderer.SpanStyleCache
+import com.swmansion.enriched.markdown.styles.CodeBlockStyle
+import com.swmansion.enriched.markdown.utils.applyBlockStyleFont
+import com.swmansion.enriched.markdown.utils.applyColorPreserving
+
+class CodeBlockSpan(
+  private val codeBlockStyle: CodeBlockStyle,
+  private val context: Context,
+  private val styleCache: SpanStyleCache,
+) : MetricAffectingSpan(),
+  LineBackgroundSpan,
+  LeadingMarginSpan {
+  private val blockStyle =
+    BlockStyle(
+      fontSize = codeBlockStyle.fontSize,
+      fontFamily = codeBlockStyle.fontFamily,
+      fontWeight = codeBlockStyle.fontWeight,
+      color = codeBlockStyle.color,
+    )
+
+  private val path = Path()
+  private val rect = RectF()
+  private val arcRect = RectF()
+  private val radiiArray = FloatArray(8)
+
+  companion object {
+    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
+        strokeCap = Paint.Cap.BUTT
+        strokeJoin = Paint.Join.ROUND
+      }
+  }
+
+  private fun configureBackgroundPaint(): Paint =
+    sharedBackgroundPaint.apply {
+      color = codeBlockStyle.backgroundColor
+    }
+
+  private fun configureBorderPaint(): Paint =
+    sharedBorderPaint.apply {
+      strokeWidth = codeBlockStyle.borderWidth
+      color = codeBlockStyle.borderColor
+    }
+
+  override fun getLeadingMargin(first: Boolean): Int = codeBlockStyle.padding.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?,
+  ) { /* Leading margin is handled by getLeadingMargin */ }
+
+  override fun updateMeasureState(tp: TextPaint) = applyTextStyle(tp)
+
+  override fun updateDrawState(tp: TextPaint) = applyTextStyle(tp)
+
+  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
+
+    val isFirstLine = start == spanStart
+    val isLastLine = end == spanEnd || (spanEnd <= end && (spanEnd == text.length || text[spanEnd - 1] == '\n'))
+
+    val inset = codeBlockStyle.borderWidth / 2f
+
+    rect.set(
+      left.toFloat() + inset,
+      top.toFloat() + (if (isFirstLine) inset else 0f),
+      right.toFloat() - inset,
+      bottom.toFloat() - (if (isLastLine) inset else 0f),
+    )
+
+    val radius = codeBlockStyle.borderRadius
+    val adjRadius = if (radius > inset) radius - inset else radius
+
+    // Reset and fill radii array based on boundary state
+    radiiArray.fill(0f)
+    if (isFirstLine) {
+      radiiArray[0] = adjRadius
+      radiiArray[1] = adjRadius // Top-Left
+      radiiArray[2] = adjRadius
+      radiiArray[3] = adjRadius // Top-Right
+    }
+    if (isLastLine) {
+      radiiArray[4] = adjRadius
+      radiiArray[5] = adjRadius // Bottom-Right
+      radiiArray[6] = adjRadius
+      radiiArray[7] = adjRadius // Bottom-Left
+    }
+
+    path.reset()
+    path.addRoundRect(rect, radiiArray, Path.Direction.CW)
+
+    val backgroundPaint = configureBackgroundPaint()
+    val borderPaint = configureBorderPaint()
+
+    canvas.withSave {
+      drawPath(path, backgroundPaint)
+
+      if (codeBlockStyle.borderWidth > 0) {
+        val bLeft = rect.left
+        val bRight = rect.right
+        val bTop = rect.top
+        val bBottom = rect.bottom
+
+        when {
+          // Case: Single-line code block
+          isFirstLine && isLastLine -> {
+            drawPath(path, borderPaint)
+          }
+
+          // Case: Top of a multi-line block
+          isFirstLine -> {
+            drawLine(bLeft + adjRadius, bTop, bRight - adjRadius, bTop, borderPaint)
+            drawLine(bLeft, bTop + adjRadius, bLeft, bBottom, borderPaint)
+            drawLine(bRight, bTop + adjRadius, bRight, bBottom, borderPaint)
+
+            arcRect.set(bLeft, bTop, bLeft + 2 * adjRadius, bTop + 2 * adjRadius)
+            drawArc(arcRect, 180f, 90f, false, borderPaint)
+
+            arcRect.set(bRight - 2 * adjRadius, bTop, bRight, bTop + 2 * adjRadius)
+            drawArc(arcRect, 270f, 90f, false, borderPaint)
+          }
+
+          // Case: Bottom of a multi-line block
+          isLastLine -> {
+            drawLine(bLeft + adjRadius, bBottom, bRight - adjRadius, bBottom, borderPaint)
+            drawLine(bLeft, bTop, bLeft, bBottom - adjRadius, borderPaint)
+            drawLine(bRight, bTop, bRight, bBottom - adjRadius, borderPaint)
+
+            arcRect.set(bLeft, bBottom - 2 * adjRadius, bLeft + 2 * adjRadius, bBottom)
+            drawArc(arcRect, 90f, 90f, false, borderPaint)
+
+            arcRect.set(bRight - 2 * adjRadius, bBottom - 2 * adjRadius, bRight, bBottom)
+            drawArc(arcRect, 0f, 90f, false, borderPaint)
+          }
+
+          // Case: Middle lines only need vertical sides
+          else -> {
+            drawLine(bLeft, bTop, bLeft, bBottom, borderPaint)
+            drawLine(bRight, bTop, bRight, bBottom, borderPaint)
+          }
+        }
+      }
+    }
+  }
+
+  private fun applyTextStyle(tp: TextPaint) {
+    tp.textSize = blockStyle.fontSize
+
+    tp.applyBlockStyleFont(blockStyle, context)
+
+    tp.applyColorPreserving(blockStyle.color, *styleCache.colorsToPreserve)
+  }
+}

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

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.markdown.renderer.BlockStyle
+import com.swmansion.enriched.markdown.renderer.SpanStyleCache
+
+class CodeSpan(
+  private val styleCache: SpanStyleCache,
+  private val blockStyle: BlockStyle,
+) : MetricAffectingSpan() {
+  override fun updateDrawState(tp: TextPaint) {
+    applyMonospacedFont(tp)
+    tp.color = styleCache.codeColor
+  }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    applyMonospacedFont(tp)
+  }
+
+  private fun applyMonospacedFont(paint: TextPaint) {
+    paint.textSize = blockStyle.fontSize * 0.85f
+    val preservedStyle = (paint.typeface?.style ?: 0) and (Typeface.BOLD or Typeface.ITALIC)
+    paint.typeface = SpanStyleCache.getMonospaceTypeface(preservedStyle)
+  }
+}

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

@@ -0,0 +1,34 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+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.applyColorPreserving
+
+class EmphasisSpan(
+  private val styleCache: SpanStyleCache,
+  private val blockStyle: BlockStyle,
+) : MetricAffectingSpan() {
+  override fun updateDrawState(tp: TextPaint) {
+    applyEmphasisStyle(tp)
+    applyEmphasisColor(tp)
+  }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    applyEmphasisStyle(tp)
+  }
+
+  private fun applyEmphasisStyle(tp: TextPaint) {
+    val currentTypeface = tp.typeface ?: Typeface.DEFAULT
+    val isBold = (currentTypeface.style) and Typeface.BOLD != 0
+    val style = if (isBold) Typeface.BOLD_ITALIC else Typeface.ITALIC
+    tp.typeface = Typeface.create(currentTypeface, style)
+  }
+
+  private fun applyEmphasisColor(tp: TextPaint) {
+    val colorToUse = styleCache.getEmphasisColorFor(blockStyle.color, tp.color)
+    tp.applyColorPreserving(colorToUse, *styleCache.colorsToPreserve)
+  }
+}

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

@@ -0,0 +1,38 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.annotation.SuppressLint
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.markdown.styles.StyleConfig
+
+class HeadingSpan(
+  val level: Int,
+  styleConfig: StyleConfig,
+) : MetricAffectingSpan() {
+  private val fontSize: Float = styleConfig.headingStyles[level]!!.fontSize
+  private val color: Int = styleConfig.headingStyles[level]!!.color
+  private val cachedTypeface: Typeface? = styleConfig.headingTypefaces[level]
+
+  override fun updateDrawState(tp: TextPaint) {
+    applyHeadingStyle(tp)
+    tp.color = color
+  }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    applyHeadingStyle(tp)
+  }
+
+  @SuppressLint("WrongConstant") // Result of mask is always valid: 0, 1, 2, or 3
+  private fun applyHeadingStyle(tp: TextPaint) {
+    tp.textSize = fontSize
+    cachedTypeface?.let { base ->
+      val preserved = (tp.typeface?.style ?: 0) and BOLD_ITALIC_MASK
+      tp.typeface = if (preserved != 0) Typeface.create(base, preserved) else base
+    }
+  }
+
+  companion object {
+    private const val BOLD_ITALIC_MASK = Typeface.BOLD or Typeface.ITALIC
+  }
+}

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

@@ -0,0 +1,320 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.content.Context
+import android.content.res.Resources
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.text.Spannable
+import android.util.Log
+import androidx.core.graphics.drawable.toDrawable
+import androidx.core.graphics.withSave
+import com.swmansion.enriched.markdown.EnrichedMarkdownText
+import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.utils.AsyncDrawable
+import java.lang.ref.WeakReference
+import android.text.style.ImageSpan as AndroidImageSpan
+import android.text.style.LineHeightSpan as AndroidLineHeightSpan
+
+/**
+ * Custom ImageSpan for rendering markdown images.
+ * Handles both inline and block images with async loading support.
+ */
+class ImageSpan(
+  context: Context,
+  val imageUrl: String,
+  styleConfig: StyleConfig,
+  val isInline: Boolean = false,
+) : AndroidImageSpan(
+    createInitialDrawable(styleConfig, imageUrl, isInline),
+    imageUrl,
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) ALIGN_CENTER else ALIGN_BASELINE,
+  ),
+  AndroidLineHeightSpan {
+  private var loadedDrawable: Drawable? = null
+  private val imageStyle = styleConfig.imageStyle
+  private val height: Int = if (isInline) calculateInlineImageSize(styleConfig) else imageStyle.height.toInt()
+  private val borderRadiusPx: Int = (imageStyle.borderRadius * context.resources.displayMetrics.density).toInt()
+
+  private var cachedWidth: Int = MINIMUM_VALID_DIMENSION
+  private val initialDrawable: Drawable = super.getDrawable()
+  private var viewRef: WeakReference<EnrichedMarkdownText>? = null
+
+  init {
+    setupLoadingLogic()
+  }
+
+  private fun setupLoadingLogic() {
+    val d = initialDrawable
+    if (d is AsyncDrawable) {
+      // Set up the callback immediately. If already loaded, it triggers next frame.
+      d.onLoaded = { handleImageLoaded(d) }
+      if (d.isLoaded) handleImageLoaded(d)
+    } else if (d.intrinsicWidth > 0) {
+      // Local file or resource
+      wrapAndAssignDrawable(d)
+    }
+  }
+
+  private fun handleImageLoaded(asyncDrawable: AsyncDrawable) {
+    val rawDrawable = asyncDrawable.internalDrawable
+    wrapAndAssignDrawable(rawDrawable)
+  }
+
+  private fun wrapAndAssignDrawable(base: Drawable) {
+    val view = viewRef?.get()
+    val targetWidth =
+      if (isInline) {
+        height
+      } else {
+        val available = view?.let { getAvailableWidth(it) } ?: cachedWidth
+        available.coerceAtLeast(MINIMUM_VALID_DIMENSION)
+      }
+
+    loadedDrawable =
+      ScaledImageDrawable(
+        imageDrawable = base,
+        targetWidth = targetWidth,
+        targetHeight = height,
+        borderRadius = borderRadiusPx,
+        isBlockImage = !isInline,
+      )
+    requestReflow()
+  }
+
+  private fun requestReflow() {
+    val view = viewRef?.get() ?: return
+    val text = view.text
+    if (text is Spannable) {
+      val start = text.getSpanStart(this)
+      val end = text.getSpanEnd(this)
+      if (start != -1 && end != -1) {
+        // Notifying the spannable that the span changed triggers a re-layout
+        text.setSpan(this, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+      }
+    } else {
+      view.invalidate()
+      view.requestLayout()
+    }
+  }
+
+  fun registerTextView(view: EnrichedMarkdownText) {
+    viewRef = WeakReference(view)
+    if (!isInline) {
+      val availableWidth = getAvailableWidth(view)
+      if (availableWidth > MINIMUM_VALID_DIMENSION) {
+        updateWidthAndRecreate(availableWidth)
+      }
+      // Ensure we catch the width after the first layout pass
+      view.post {
+        val postWidth = getAvailableWidth(view)
+        if (postWidth != cachedWidth) updateWidthAndRecreate(postWidth)
+      }
+    }
+  }
+
+  private fun updateWidthAndRecreate(newWidth: Int) {
+    if (newWidth <= MINIMUM_VALID_DIMENSION || cachedWidth == newWidth) return
+    cachedWidth = newWidth
+
+    // If we already have a loaded source, recreate the scaled wrapper with new width
+    val base = (initialDrawable as? AsyncDrawable)?.internalDrawable ?: initialDrawable
+    if (base.intrinsicWidth > 0) {
+      wrapAndAssignDrawable(base)
+    }
+  }
+
+  private fun getAvailableWidth(view: EnrichedMarkdownText): Int = view.layout?.width ?: view.width
+
+  override fun getDrawable(): Drawable {
+    val drawable = loadedDrawable ?: initialDrawable
+    if (drawable !is ScaledImageDrawable) {
+      val dWidth = if (isInline) height else cachedWidth.takeIf { it > 0 } ?: drawable.intrinsicWidth
+      val dHeight = if (isInline) height else height
+      drawable.setBounds(0, 0, dWidth.coerceAtLeast(0), dHeight.coerceAtLeast(0))
+    }
+    return drawable
+  }
+
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int = getDrawable().bounds.right
+
+  override fun chooseHeight(
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    lineHeight: Int,
+    fm: Paint.FontMetricsInt?,
+  ) {
+    if (fm == null || isInline) return
+    val currentLineHeight = fm.descent - fm.ascent
+    if (height > currentLineHeight) {
+      val extraHeight = height - currentLineHeight
+      fm.descent += extraHeight
+      fm.bottom += extraHeight
+    }
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) {
+    val drawable = getDrawable()
+    canvas.withSave {
+      if (isInline) {
+        val imageHeight = drawable.bounds.height()
+        translate(x, (y - imageHeight + (imageHeight * 0.1f)))
+      } else {
+        translate(x, top.toFloat())
+      }
+      drawable.draw(this)
+    }
+  }
+
+  // --- Helper Classes ---
+
+  private class ScaledImageDrawable(
+    private val imageDrawable: Drawable,
+    private val targetWidth: Int,
+    private val targetHeight: Int,
+    private val borderRadius: Int,
+    isBlockImage: Boolean,
+  ) : Drawable() {
+    private val clipPath: Path? =
+      if (borderRadius > 0) {
+        Path().apply {
+          addRoundRect(
+            0f,
+            0f,
+            targetWidth.toFloat(),
+            targetHeight.toFloat(),
+            borderRadius.toFloat(),
+            borderRadius.toFloat(),
+            Path.Direction.CW,
+          )
+        }
+      } else {
+        null
+      }
+
+    init {
+      setBounds(0, 0, targetWidth, targetHeight)
+      val iW = imageDrawable.intrinsicWidth
+      val iH = imageDrawable.intrinsicHeight
+
+      val (sW, sH) =
+        if (iW > 0 && iH > 0) {
+          if (isBlockImage) {
+            val scale = targetWidth.toFloat() / iW
+            targetWidth to (iH * scale).toInt()
+          } else {
+            val scale = minOf(targetWidth.toFloat() / iW, targetHeight.toFloat() / iH)
+            (iW * scale).toInt() to (iH * scale).toInt()
+          }
+        } else {
+          targetWidth to targetHeight
+        }
+
+      val left = (targetWidth - sW) / 2
+      val top = (targetHeight - sH) / 2
+      imageDrawable.setBounds(left, top, left + sW, top + sH)
+    }
+
+    override fun draw(canvas: Canvas) {
+      if (clipPath != null) {
+        canvas.withSave {
+          clipPath(clipPath)
+          imageDrawable.draw(canvas)
+        }
+      } else {
+        imageDrawable.draw(canvas)
+      }
+    }
+
+    override fun setAlpha(alpha: Int) {
+      imageDrawable.alpha = alpha
+    }
+
+    override fun setColorFilter(cf: android.graphics.ColorFilter?) {
+      imageDrawable.colorFilter = cf
+    }
+
+    @Suppress("DEPRECATION")
+    @Deprecated("Deprecated in Java")
+    override fun getOpacity(): Int = imageDrawable.opacity
+
+    override fun getIntrinsicWidth(): Int = targetWidth
+
+    override fun getIntrinsicHeight(): Int = targetHeight
+  }
+
+  companion object {
+    private const val MINIMUM_VALID_DIMENSION = 0
+
+    private fun calculateInlineImageSize(style: StyleConfig): Int = style.inlineImageStyle.size.toInt()
+
+    private fun createInitialDrawable(
+      style: StyleConfig,
+      url: String,
+      isInline: Boolean,
+    ): Drawable {
+      val imgStyle = style.imageStyle
+      val size = if (isInline) calculateInlineImageSize(style) else imgStyle.height.toInt()
+
+      return prepareDrawable(url, size, size) ?: PlaceholderDrawable(size, size)
+    }
+
+    private fun prepareDrawable(
+      src: String,
+      tw: Int,
+      th: Int,
+    ): Drawable? {
+      if (src.startsWith("http")) {
+        return AsyncDrawable(src).apply { setBounds(0, 0, tw, th) }
+      }
+      val path = src.removePrefix("file://")
+      return try {
+        BitmapFactory.decodeFile(path)?.toDrawable(Resources.getSystem())?.apply {
+          setBounds(0, 0, intrinsicWidth, intrinsicHeight)
+        }
+      } catch (e: Exception) {
+        Log.w("ImageSpan", "Failed to load local image: $path", e)
+        null
+      }
+    }
+
+    private class PlaceholderDrawable(
+      private val w: Int,
+      private val h: Int,
+    ) : Drawable() {
+      override fun draw(canvas: Canvas) {}
+
+      override fun setAlpha(alpha: Int) {}
+
+      override fun setColorFilter(cf: android.graphics.ColorFilter?) {}
+
+      @Deprecated("Deprecated in Java")
+      override fun getOpacity(): Int = android.graphics.PixelFormat.TRANSLUCENT
+
+      override fun getIntrinsicWidth(): Int = w
+
+      override fun getIntrinsicHeight(): Int = h
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Paint
+import kotlin.math.ceil
+import kotlin.math.roundToInt
+import android.text.style.LineHeightSpan as AndroidLineHeightSpan
+
+/**
+ * Custom LineHeightSpan for Android API levels below 29.
+ * Matches LineHeightSpan.Standard behavior for consistent rendering across all API levels.
+ */
+class LineHeightSpan(
+  private val lineHeight: Float,
+) : AndroidLineHeightSpan {
+  override fun chooseHeight(
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    lineHeight: Int,
+    fm: Paint.FontMetricsInt?,
+  ) {
+    if (fm == null) return
+
+    val targetHeight = ceil(this.lineHeight.toDouble()).toInt()
+    val originHeight = fm.descent - fm.ascent
+
+    if (originHeight <= 0) {
+      return
+    }
+
+    val ratio = targetHeight.toFloat() / originHeight
+    fm.descent = (fm.descent * ratio).roundToInt()
+    fm.ascent = fm.descent - targetHeight
+  }
+}

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

@@ -0,0 +1,37 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.content.Context
+import android.text.TextPaint
+import android.text.style.ClickableSpan
+import android.view.View
+import com.swmansion.enriched.markdown.EnrichedMarkdownText
+import com.swmansion.enriched.markdown.renderer.BlockStyle
+import com.swmansion.enriched.markdown.renderer.SpanStyleCache
+import com.swmansion.enriched.markdown.utils.applyBlockStyleFont
+
+class LinkSpan(
+  val url: String,
+  private val onLinkPress: ((String) -> Unit)?,
+  private val styleCache: SpanStyleCache,
+  private val blockStyle: BlockStyle,
+  private val context: Context,
+) : ClickableSpan() {
+  override fun onClick(widget: View) {
+    if (onLinkPress != null) {
+      onLinkPress(url)
+    } else if (widget is EnrichedMarkdownText) {
+      // Emit event directly from view (enriched pattern)
+      widget.emitOnLinkPress(url)
+    }
+  }
+
+  override fun updateDrawState(textPaint: TextPaint) {
+    super.updateDrawState(textPaint)
+
+    textPaint.textSize = blockStyle.fontSize
+    textPaint.applyBlockStyleFont(blockStyle, context)
+
+    textPaint.color = styleCache.linkColor
+    textPaint.isUnderlineText = styleCache.linkUnderline
+  }
+}