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

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

@@ -0,0 +1,335 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.text.Spannable
+import android.text.Spanned
+import android.text.style.LeadingMarginSpan
+import android.util.Log
+import android.widget.TextView
+import androidx.core.graphics.createBitmap
+import androidx.core.graphics.drawable.toDrawable
+import androidx.core.graphics.withClip
+import androidx.core.graphics.withSave
+import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.utils.text.ImageCache
+import com.swmansion.enriched.markdown.utils.text.ImageDownloader
+import java.lang.ref.WeakReference
+import java.util.concurrent.Executors
+import android.text.style.ImageSpan as AndroidImageSpan
+import android.text.style.LineHeightSpan as AndroidLineHeightSpan
+
+class ImageSpan(
+  private val context: Context,
+  val imageUrl: String,
+  styleConfig: StyleConfig,
+  val isInline: Boolean = false,
+  val altText: String = "",
+) : AndroidImageSpan(
+    Color.TRANSPARENT.toDrawable(),
+    imageUrl,
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) ALIGN_CENTER else ALIGN_BASELINE,
+  ),
+  AndroidLineHeightSpan {
+  private var loadedDrawable: Drawable? = null
+  private val height: Int = if (isInline) styleConfig.inlineImageStyle.size.toInt() else styleConfig.imageStyle.height.toInt()
+  private val borderRadiusPx: Int = (styleConfig.imageStyle.borderRadius * context.resources.displayMetrics.density).toInt()
+
+  private var cachedWidth: Int = 0
+  private var viewRef: WeakReference<TextView>? = null
+  private var sourceDrawable: Drawable? = null
+
+  init {
+    loadImage()
+  }
+
+  private fun loadImage() {
+    if (imageUrl.startsWith("http")) {
+      ImageDownloader.download(context, imageUrl) { bitmap ->
+        if (bitmap != null) {
+          sourceDrawable = bitmap.toDrawable(context.resources)
+          wrapAndAssignDrawable()
+        }
+      }
+    } else {
+      val path = imageUrl.removePrefix("file://")
+      try {
+        val cached = ImageCache.getOriginal(imageUrl)
+        val bitmap = cached ?: ImageDownloader.decodeFileDownsampled(context, path)
+        if (bitmap != null) {
+          if (cached == null) ImageCache.putOriginal(imageUrl, bitmap)
+          sourceDrawable = bitmap.toDrawable(context.resources)
+          wrapAndAssignDrawable()
+        }
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to load local image: $path", e)
+      }
+    }
+  }
+
+  private fun wrapAndAssignDrawable() {
+    val base = sourceDrawable ?: return
+    val targetWidth =
+      if (isInline) {
+        height
+      } else {
+        val available = viewRef?.get()?.let { getAvailableWidth(it) } ?: cachedWidth
+        available.coerceAtLeast(0)
+      }
+
+    val cachedBitmap = ImageCache.getProcessed(imageUrl, targetWidth, height, borderRadiusPx)
+    if (cachedBitmap != null) {
+      loadedDrawable =
+        cachedBitmap.toDrawable(context.resources).apply {
+          setBounds(0, 0, targetWidth, height)
+        }
+    } else {
+      loadedDrawable =
+        ScaledImageDrawable(
+          imageDrawable = base,
+          targetWidth = targetWidth,
+          targetHeight = height,
+          borderRadius = borderRadiusPx,
+          isBlockImage = !isInline,
+          cacheKey = CacheKey(imageUrl, targetWidth, height, borderRadiusPx),
+        )
+    }
+    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) {
+        text.setSpan(this, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+      }
+    } else {
+      view.invalidate()
+      view.requestLayout()
+    }
+  }
+
+  fun registerTextView(view: TextView) {
+    viewRef = WeakReference(view)
+    if (!isInline) {
+      val availableWidth = getAvailableWidth(view)
+      if (availableWidth > 0) {
+        updateWidthAndRecreate(availableWidth)
+      }
+      view.post {
+        val postWidth = getAvailableWidth(view)
+        if (postWidth != cachedWidth) updateWidthAndRecreate(postWidth)
+      }
+    }
+  }
+
+  private fun updateWidthAndRecreate(newWidth: Int) {
+    if (newWidth <= 0 || cachedWidth == newWidth) return
+    cachedWidth = newWidth
+    if (sourceDrawable != null) {
+      wrapAndAssignDrawable()
+    }
+  }
+
+  private fun getAvailableWidth(view: TextView): Int {
+    val baseWidth = (view.layout?.width ?: view.width).coerceAtLeast(0)
+    val text = view.text as? Spanned ?: return baseWidth
+    val start = text.getSpanStart(this).takeIf { it >= 0 } ?: return baseWidth
+    val end = text.getSpanEnd(this).coerceAtLeast(start)
+    // Subtract leading margins (list bullet/indent, blockquote bar) that consume
+    // horizontal space on the image's line. first=true is correct because a block
+    // image sits on its own line — the "first line" from the layout's perspective.
+    val totalMargin =
+      text
+        .getSpans(start, end, LeadingMarginSpan::class.java)
+        .sumOf { it.getLeadingMargin(true) }
+    return (baseWidth - totalMargin).coerceAtLeast(0)
+  }
+
+  override fun getDrawable(): Drawable {
+    val drawable = loadedDrawable ?: transparentDrawable
+    if (drawable !is ScaledImageDrawable) {
+      val drawableWidth = if (isInline) height else cachedWidth.takeIf { it > 0 } ?: drawable.intrinsicWidth
+      drawable.setBounds(0, 0, drawableWidth.coerceAtLeast(0), height.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)
+    }
+  }
+
+  private data class CacheKey(
+    val url: String,
+    val width: Int,
+    val height: Int,
+    val borderRadius: Int,
+  )
+
+  private class ScaledImageDrawable(
+    private val imageDrawable: Drawable,
+    private val targetWidth: Int,
+    private val targetHeight: Int,
+    private val borderRadius: Int,
+    isBlockImage: Boolean,
+    private val cacheKey: CacheKey? = null,
+  ) : Drawable() {
+    private val clipPath: Path?
+    private var hasCached = false
+
+    init {
+      setBounds(0, 0, targetWidth, targetHeight)
+      val intrinsicWidth = imageDrawable.intrinsicWidth
+      val intrinsicHeight = imageDrawable.intrinsicHeight
+
+      val (scaledWidth, scaledHeight) =
+        if (intrinsicWidth > 0 && intrinsicHeight > 0) {
+          if (isBlockImage) {
+            val scale = targetWidth.toFloat() / intrinsicWidth
+            targetWidth to (intrinsicHeight * scale).toInt()
+          } else {
+            val scale = minOf(targetWidth.toFloat() / intrinsicWidth, targetHeight.toFloat() / intrinsicHeight)
+            (intrinsicWidth * scale).toInt() to (intrinsicHeight * scale).toInt()
+          }
+        } else {
+          targetWidth to targetHeight
+        }
+
+      val left = (targetWidth - scaledWidth) / 2
+      val top = (targetHeight - scaledHeight) / 2
+      imageDrawable.setBounds(left, top, left + scaledWidth, top + scaledHeight)
+
+      clipPath =
+        if (borderRadius > 0) {
+          val clipLeft = maxOf(0, left).toFloat()
+          val clipTop = maxOf(0, top).toFloat()
+          val clipRight = minOf(targetWidth, left + scaledWidth).toFloat()
+          val clipBottom = minOf(targetHeight, top + scaledHeight).toFloat()
+          Path().apply {
+            addRoundRect(
+              clipLeft,
+              clipTop,
+              clipRight,
+              clipBottom,
+              borderRadius.toFloat(),
+              borderRadius.toFloat(),
+              Path.Direction.CW,
+            )
+          }
+        } else {
+          null
+        }
+    }
+
+    override fun draw(canvas: Canvas) {
+      if (clipPath != null) {
+        canvas.withSave {
+          clipPath(clipPath)
+          imageDrawable.draw(canvas)
+        }
+      } else {
+        imageDrawable.draw(canvas)
+      }
+      scheduleCacheBitmap()
+    }
+
+    private fun scheduleCacheBitmap() {
+      if (hasCached || cacheKey == null || targetWidth <= 0 || targetHeight <= 0) return
+      hasCached = true
+      val cachedKey = cacheKey
+      val width = targetWidth
+      val height = targetHeight
+      val path = clipPath
+      val source = imageDrawable
+      cacheExecutor.execute {
+        try {
+          val bitmap = createBitmap(width, height)
+          val offscreen = Canvas(bitmap)
+          if (path != null) {
+            offscreen.withClip(path) { source.draw(this) }
+          } else {
+            source.draw(offscreen)
+          }
+          ImageCache.putProcessed(cachedKey.url, cachedKey.width, cachedKey.height, cachedKey.borderRadius, bitmap)
+        } catch (_: OutOfMemoryError) {
+          Log.e("ScaledImageDrawable", "OOM caching bitmap ${width}x$height")
+        }
+      }
+    }
+
+    override fun setAlpha(alpha: Int) {
+      imageDrawable.alpha = alpha
+    }
+
+    override fun setColorFilter(colorFilter: android.graphics.ColorFilter?) {
+      imageDrawable.colorFilter = colorFilter
+    }
+
+    @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 TAG = "ImageSpan"
+    private val transparentDrawable by lazy { Color.TRANSPARENT.toDrawable() }
+    private val cacheExecutor = Executors.newSingleThreadExecutor()
+  }
+}

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

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Paint
+import kotlin.math.ceil
+import kotlin.math.floor
+import android.text.style.LineHeightSpan as AndroidLineHeightSpan
+
+class LineHeightSpan(
+  height: Float,
+) : AndroidLineHeightSpan {
+  private val lineHeight: Int = ceil(height.toDouble()).toInt()
+
+  override fun chooseHeight(
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    v: Int,
+    fm: Paint.FontMetricsInt?,
+  ) {
+    if (fm == null) return
+
+    val leading = lineHeight - ((-fm.ascent) + fm.descent)
+    fm.ascent -= ceil(leading / 2.0f).toInt()
+    fm.descent += floor(leading / 2.0f).toInt()
+  }
+}

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

@@ -0,0 +1,66 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.content.Context
+import android.graphics.Color
+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.text.extensions.applyBlockStyleFont
+
+class LinkSpan(
+  val url: String,
+  private val onLinkPress: ((String) -> Unit)?,
+  private val onLinkLongPress: ((String) -> Unit)?,
+  private val styleCache: SpanStyleCache,
+  private val blockStyle: BlockStyle,
+  private val context: Context,
+) : ClickableSpan() {
+  @Volatile
+  private var longPressTriggered = false
+
+  override fun onClick(widget: View) {
+    if (longPressTriggered) {
+      longPressTriggered = false
+      return
+    }
+
+    onLinkPress?.invoke(url) ?: (widget as? EnrichedMarkdownText)?.emitOnLinkPress(url)
+  }
+
+  fun onLongClick(widget: View): Boolean {
+    longPressTriggered = true
+
+    (widget as? EnrichedMarkdownText)?.emitOnLinkLongPress(url)
+
+    onLinkLongPress?.invoke(url)
+
+    return true
+  }
+
+  override fun updateDrawState(textPaint: TextPaint) {
+    super.updateDrawState(textPaint)
+
+    textPaint.textSize = blockStyle.fontSize
+
+    val variant = styleCache.resolvedVariantForUrl(url)
+
+    val fontFamily = styleCache.linkFontFamily
+    if (fontFamily.isNotEmpty()) {
+      val overriddenBlockStyle = blockStyle.copy(fontFamily = fontFamily)
+      textPaint.applyBlockStyleFont(overriddenBlockStyle, context)
+    } else {
+      textPaint.applyBlockStyleFont(blockStyle, context)
+    }
+
+    textPaint.color = variant?.color ?: styleCache.linkColor
+    textPaint.isUnderlineText = variant?.underline ?: styleCache.linkUnderline
+
+    val backgroundColor = variant?.backgroundColor ?: styleCache.linkBackgroundColor
+    if (Color.alpha(backgroundColor) > 0) {
+      textPaint.bgColor = backgroundColor
+    }
+  }
+}

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

@@ -0,0 +1,76 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Paint
+import android.text.style.LineHeightSpan
+
+/**
+ * Adds bottom margin to a block element (paragraphs/headings) using LineHeightSpan.
+ *
+ * For spacer lines (single newline), sets the line height to exactly marginBottom.
+ * For regular lines, adds marginBottom only at paragraph boundaries to preserve lineHeight.
+ *
+ * @param marginBottom The margin in pixels to add below the block (0 = no margin)
+ */
+class MarginBottomSpan(
+  val marginBottom: Float,
+) : LineHeightSpan {
+  override fun chooseHeight(
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    lineHeight: Int,
+    fm: Paint.FontMetricsInt,
+  ) {
+    // Only process lines that end with a newline
+    if (end <= start || text[end - 1] != '\n') {
+      return
+    }
+
+    val marginPixels = marginBottom.toInt()
+
+    // Handle spacer lines (single newline character)
+    if (end - start == 1 && text[start] == '\n') {
+      if (hasContentAfter(text, end)) {
+        // Set line height to exactly marginBottom for spacer lines
+        fm.top = 0
+        fm.ascent = 0
+        fm.descent = marginPixels
+        fm.bottom = marginPixels
+      } else {
+        // No content after - collapse the spacer line to zero height
+        fm.top = 0
+        fm.ascent = 0
+        fm.descent = 0
+        fm.bottom = 0
+      }
+      return
+    }
+
+    // For regular lines, add spacing only if there's content after
+    if (hasContentAfter(text, end)) {
+      fm.descent += marginPixels
+      fm.bottom += marginPixels
+    }
+  }
+
+  /**
+   * Checks if there's non-newline content after the given position.
+   * Used to determine if spacing should be applied (between items) or skipped (after last item).
+   */
+  private fun hasContentAfter(
+    text: CharSequence,
+    pos: Int,
+  ): Boolean {
+    if (pos >= text.length) return false
+
+    // If the next character is a newline, check the character after that
+    if (text[pos] == '\n') {
+      val nextPos = pos + 1
+      if (nextPos >= text.length) return false
+      return text[nextPos] != '\n' // Non-newline = content exists
+    }
+
+    return true // Non-newline content immediately after
+  }
+}

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

@@ -0,0 +1,18 @@
+package com.swmansion.enriched.markdown.spans
+
+enum class MathRenderMode {
+  Text,
+  Display,
+}
+
+data class MathMeasureRequest(
+  val fontSize: Float,
+  val latex: String,
+  val mode: MathRenderMode = MathRenderMode.Text,
+)
+
+data class MathMetrics(
+  val width: Int,
+  val ascent: Float,
+  val descent: Float,
+)

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

@@ -0,0 +1,85 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.text.Layout
+import android.text.TextPaint
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.views.text.ReactTypefaceUtils.applyStyles
+import com.facebook.react.views.text.ReactTypefaceUtils.parseFontWeight
+import com.swmansion.enriched.markdown.renderer.BlockStyle
+import com.swmansion.enriched.markdown.renderer.SpanStyleCache
+import com.swmansion.enriched.markdown.styles.ListStyle
+
+class OrderedListSpan(
+  private val listStyle: ListStyle,
+  depth: Int,
+  context: Context,
+  styleCache: SpanStyleCache,
+) : BaseListSpan(
+    depth = depth,
+    context = context,
+    styleCache = styleCache,
+    blockStyle =
+      BlockStyle(
+        fontSize = listStyle.fontSize,
+        fontFamily = listStyle.fontFamily,
+        fontWeight = listStyle.fontWeight,
+        color = listStyle.color,
+      ),
+    marginLeft = listStyle.marginLeft,
+    gapWidth = listStyle.gapWidth,
+  ) {
+  companion object {
+    private val sharedMarkerPaint = TextPaint().apply { isAntiAlias = true }
+  }
+
+  private val markerTypeface: Typeface =
+    run {
+      val fontFamily = listStyle.fontFamily.takeIf { it.isNotEmpty() }
+      val fontWeight = parseFontWeight(listStyle.markerFontWeight)
+      applyStyles(null, ReactConstants.UNSET, fontWeight, fontFamily, context.assets)
+    }
+
+  private fun configureMarkerPaint(): TextPaint =
+    sharedMarkerPaint.apply {
+      textSize = listStyle.fontSize
+      color = listStyle.markerColor
+      typeface = markerTypeface
+    }
+
+  override fun getMarkerWidth(): Float {
+    val paint = configureMarkerPaint()
+    return listStyle.effectiveMarkerWidth(paint.measureText("99."))
+  }
+
+  var itemNumber: Int = 1
+    private set
+
+  override fun drawMarker(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    layout: Layout?,
+    start: Int,
+  ) {
+    val markerPaint = configureMarkerPaint()
+    val text = if (dir < 0) ".$itemNumber" else "$itemNumber."
+    val textWidth = markerPaint.measureText(text)
+
+    val markerRightEdge = x + (depth * marginLeft + getMarkerWidth()) * dir
+    val markerX = if (dir > 0) markerRightEdge - textWidth else markerRightEdge
+
+    canvas.drawText(text, markerX, baseline.toFloat(), markerPaint)
+  }
+
+  fun setItemNumber(number: Int) {
+    itemNumber = number
+  }
+}

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

@@ -0,0 +1,33 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.markdown.renderer.BlockStyle
+import com.swmansion.enriched.markdown.renderer.SpanStyleCache
+
+class SpoilerSpan(
+  val styleCache: SpanStyleCache,
+  val blockStyle: BlockStyle,
+) : MetricAffectingSpan() {
+  var revealed = false
+    private set
+  var revealing = false
+    private set
+
+  fun markRevealing() {
+    revealing = true
+  }
+
+  fun markRevealed() {
+    revealed = true
+    revealing = false
+  }
+
+  override fun updateDrawState(tp: TextPaint) {
+    tp.textSize = blockStyle.fontSize
+  }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    tp.textSize = blockStyle.fontSize
+  }
+}

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

@@ -0,0 +1,12 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.text.TextPaint
+import android.text.style.CharacterStyle
+
+class StrikethroughSpan(
+  private val strikethroughColor: Int,
+) : CharacterStyle() {
+  override fun updateDrawState(tp: TextPaint) {
+    tp.isStrikeThruText = true
+  }
+}

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

@@ -0,0 +1,39 @@
+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.text.extensions.applyColorPreserving
+
+class StrongSpan(
+  private val styleCache: SpanStyleCache,
+  private val blockStyle: BlockStyle,
+) : MetricAffectingSpan() {
+  private val strongColor = styleCache.getStrongColorFor(blockStyle.color)
+
+  override fun updateDrawState(tp: TextPaint) {
+    applyStrongStyle(tp)
+    tp.applyColorPreserving(strongColor, *styleCache.colorsToPreserve)
+  }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    applyStrongStyle(tp)
+  }
+
+  private fun applyStrongStyle(tp: TextPaint) {
+    tp.textSize = blockStyle.fontSize
+
+    val currentTypeface = tp.typeface ?: Typeface.DEFAULT
+    val isItalic = (currentTypeface.style) and Typeface.ITALIC != 0
+    val style = if (isItalic) Typeface.BOLD_ITALIC else Typeface.BOLD
+    tp.typeface =
+      if (styleCache.strongFontFamily.isNotEmpty()) {
+        val resolvedStyle = if (styleCache.strongFontWeight == "normal") Typeface.NORMAL else style
+        SpanStyleCache.getTypeface(styleCache.strongFontFamily, resolvedStyle)
+      } else {
+        Typeface.create(currentTypeface, style)
+      }
+  }
+}