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

package/android/src/math/java/com/swmansion/enriched/markdown/input/math/MathChipControllerImpl.kt

@@ -0,0 +1,217 @@
+package com.swmansion.enriched.markdown.input.math
+
+import android.content.Context
+import android.text.Editable
+import android.text.Layout
+import android.text.Spanned
+import android.text.style.AlignmentSpan
+import com.swmansion.enriched.markdown.input.model.MathAtom
+import com.swmansion.enriched.markdown.input.model.MathBlockStyle
+import com.swmansion.enriched.markdown.input.model.MathChipStyle
+import com.swmansion.enriched.markdown.spans.MathChipSpan
+
+class MathChipControllerImpl(
+  private val context: Context,
+) : MathChipController {
+  private val attachmentChar: Char = ''
+  override var blockWidthSupplier: (() -> Int)? = null
+    set(value) {
+      field = value
+      // No active span tracking — refreshAll covers the case where existing
+      // spans need to see the new supplier. View calls refresh after wiring.
+    }
+
+  override fun applyAtoms(
+    editable: Editable,
+    atoms: List<MathAtom>,
+    inlineStyle: MathChipStyle,
+    blockStyle: MathChipStyle,
+  ) {
+    for (atom in atoms) {
+      if (atom.position < 0 || atom.position >= editable.length) continue
+      if (editable[atom.position] != attachmentChar) continue
+      val style = if (atom.displayMode) blockStyle else inlineStyle
+      val span = MathChipSpan(context, atom.latex, atom.displayMode, style, blockWidthSupplier)
+      editable.setSpan(
+        span,
+        atom.position,
+        atom.position + 1,
+        Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
+      )
+      applyAlignmentIfNeeded(editable, atom.position, atom.displayMode, style)
+    }
+  }
+
+  override fun insertChip(
+    editable: Editable,
+    position: Int,
+    latex: String,
+    displayMode: Boolean,
+    style: MathChipStyle,
+  ) {
+    if (position < 0 || position >= editable.length) return
+    if (editable[position] != attachmentChar) return
+    removeAlignmentSpans(editable, position)
+    val span = MathChipSpan(context, latex, displayMode, style, blockWidthSupplier)
+    editable.setSpan(span, position, position + 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+    applyAlignmentIfNeeded(editable, position, displayMode, style)
+  }
+
+  override fun updateChip(
+    editable: Editable,
+    position: Int,
+    latex: String,
+    displayMode: Boolean,
+    style: MathChipStyle,
+  ): MathChipController.UpdateResult {
+    if (position < 0 || position >= editable.length) {
+      return MathChipController.UpdateResult(modeChanged = false, applied = false)
+    }
+    val spans = editable.getSpans(position, position + 1, MathChipSpan::class.java)
+    val span =
+      spans.firstOrNull()
+        ?: return MathChipController.UpdateResult(modeChanged = false, applied = false)
+    val modeChanged = span.displayMode != displayMode
+    span.latex = latex
+    span.displayMode = displayMode
+    span.style = style
+    span.invalidateRender()
+
+    if (modeChanged) {
+      removeAlignmentSpans(editable, position)
+      applyAlignmentIfNeeded(editable, position, displayMode, style)
+    }
+    return MathChipController.UpdateResult(modeChanged = modeChanged, applied = true)
+  }
+
+  override fun removeChip(
+    editable: Editable,
+    position: Int,
+  ): Boolean {
+    if (position < 0 || position >= editable.length) return false
+    val spans = editable.getSpans(position, position + 1, MathChipSpan::class.java)
+    if (spans.isEmpty()) return false
+    removeAlignmentSpans(editable, position)
+    editable.delete(position, position + 1)
+    return true
+  }
+
+  override fun chipRangeAt(
+    spanned: Spanned,
+    position: Int,
+  ): IntRange? {
+    if (position < 0 || position >= spanned.length) return null
+    val spans = spanned.getSpans(position, position + 1, MathChipSpan::class.java)
+    val span = spans.firstOrNull() ?: return null
+    val start = spanned.getSpanStart(span)
+    val end = spanned.getSpanEnd(span)
+    if (start < 0 || end <= start) return null
+    return start until end
+  }
+
+  override fun refreshAll(
+    editable: Editable,
+    inlineStyle: MathChipStyle,
+    blockStyle: MathChipStyle,
+  ) {
+    val spans = editable.getSpans(0, editable.length, MathChipSpan::class.java)
+    for (span in spans) {
+      val start = editable.getSpanStart(span)
+      if (start < 0) continue
+      val newStyle = if (span.displayMode) blockStyle else inlineStyle
+      span.style = newStyle
+      span.blockWidthSupplier = blockWidthSupplier
+      span.invalidateRender()
+      removeAlignmentSpans(editable, start)
+      applyAlignmentIfNeeded(editable, start, span.displayMode, newStyle)
+    }
+  }
+
+  override fun chipAt(
+    spanned: Spanned,
+    position: Int,
+  ): MathChipController.ChipInfo? {
+    if (position < 0 || position >= spanned.length) return null
+    val spans = spanned.getSpans(position, position + 1, MathChipSpan::class.java)
+    val span = spans.firstOrNull() ?: return null
+    val start = spanned.getSpanStart(span)
+    return MathChipController.ChipInfo(
+      position = start,
+      latex = span.latex,
+      displayMode = span.displayMode,
+      isSelected = span.isSelected,
+    )
+  }
+
+  override fun allChips(spanned: Spanned): List<MathChipController.ChipInfo> {
+    if (spanned.length == 0) return emptyList()
+    val spans = spanned.getSpans(0, spanned.length, MathChipSpan::class.java)
+    return spans
+      .mapNotNull { span ->
+        val start = spanned.getSpanStart(span)
+        if (start < 0) return@mapNotNull null
+        MathChipController.ChipInfo(
+          position = start,
+          latex = span.latex,
+          displayMode = span.displayMode,
+          isSelected = span.isSelected,
+        )
+      }.sortedBy { it.position }
+  }
+
+  override fun setSelected(
+    spanned: Spanned,
+    position: Int,
+    selected: Boolean,
+  ): Boolean {
+    if (position < 0 || position >= spanned.length) return false
+    val spans = spanned.getSpans(position, position + 1, MathChipSpan::class.java)
+    val span = spans.firstOrNull() ?: return false
+    if (span.isSelected == selected) return false
+    span.isSelected = selected
+    span.invalidateRender()
+    return true
+  }
+
+  override fun clearAllSelections(spanned: Spanned): Boolean {
+    if (spanned.length == 0) return false
+    val spans = spanned.getSpans(0, spanned.length, MathChipSpan::class.java)
+    var changed = false
+    for (span in spans) {
+      if (span.isSelected) {
+        span.isSelected = false
+        span.invalidateRender()
+        changed = true
+      }
+    }
+    return changed
+  }
+
+  private fun applyAlignmentIfNeeded(
+    editable: Editable,
+    position: Int,
+    displayMode: Boolean,
+    style: MathChipStyle,
+  ) {
+    if (!displayMode) return
+    val blockStyle = style as? MathBlockStyle ?: return
+    if (blockStyle.alignment == Layout.Alignment.ALIGN_NORMAL) return
+    editable.setSpan(
+      AlignmentSpan.Standard(blockStyle.alignment),
+      position,
+      position + 1,
+      Spanned.SPAN_PARAGRAPH,
+    )
+  }
+
+  private fun removeAlignmentSpans(
+    editable: Editable,
+    position: Int,
+  ) {
+    val end = (position + 1).coerceAtMost(editable.length)
+    val spans = editable.getSpans(position, end, AlignmentSpan::class.java)
+    for (span in spans) {
+      editable.removeSpan(span)
+    }
+  }
+}

package/android/src/math/java/com/swmansion/enriched/markdown/renderer/MathInlineRenderer.kt

@@ -0,0 +1,47 @@
+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.MathInlineSpan
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import io.ratex.RaTeXFontLoader
+
+class MathInlineRenderer(
+  private val config: RendererConfig,
+  private val context: Context,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    RaTeXFontLoader.ensureLoaded(context)
+
+    val latex = extractLatex(node)
+    if (latex.isEmpty()) return
+
+    val blockStyle = factory.blockStyleContext.requireBlockStyle()
+
+    val start = builder.length
+    builder.append("\uFFFC")
+    val end = builder.length
+
+    val span =
+      MathInlineSpan(
+        context = context,
+        latex = latex,
+        fontSize = blockStyle.fontSize,
+        textColor = config.style.inlineMathStyle.color,
+      )
+
+    builder.setSpan(span, start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+  }
+
+  private fun extractLatex(node: MarkdownASTNode): String {
+    if (!node.content.isNullOrEmpty()) return node.content!!
+    return node.children.mapNotNull { it.content }.joinToString("")
+  }
+}

package/android/src/math/java/com/swmansion/enriched/markdown/spans/MathChipSpan.kt

@@ -0,0 +1,208 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.Layout
+import android.text.style.ReplacementSpan
+import com.swmansion.enriched.markdown.input.model.MathBlockStyle
+import com.swmansion.enriched.markdown.input.model.MathChipStyle
+import io.ratex.RaTeXEngine
+import io.ratex.RaTeXFontLoader
+import io.ratex.RaTeXRenderer
+import kotlin.math.ceil
+
+/**
+ * ReplacementSpan rendering a single LaTeX formula inside the input as an
+ * atomic chip. Backed by RaTeX bitmap rendering. Inline and block variants
+ * share this span — the [displayMode] flag toggles which RaTeX path runs.
+ */
+class MathChipSpan(
+  private val context: Context,
+  internal var latex: String,
+  internal var displayMode: Boolean,
+  internal var style: MathChipStyle,
+  /**
+   * Returns the row width available for a block chip's full-bleed background.
+   * For inline chips the supplier is unused — they wrap to formula width.
+   * The supplier is queried from getSize/draw, so the TextView's current
+   * measured width is read late, not captured at span creation.
+   */
+  internal var blockWidthSupplier: (() -> Int)? = null,
+) : ReplacementSpan() {
+  private var formulaBitmap: Bitmap? = null
+  private var formulaWidth: Float = 0f
+  private var formulaAscent: Float = 0f
+  private var formulaDescent: Float = 0f
+  private var renderFailed: Boolean = false
+
+  var isSelected: Boolean = false
+    set(value) {
+      if (field != value) {
+        field = value
+      }
+    }
+
+  fun invalidateRender() {
+    formulaBitmap?.recycle()
+    formulaBitmap = null
+    formulaWidth = 0f
+    formulaAscent = 0f
+    formulaDescent = 0f
+    renderFailed = false
+  }
+
+  private fun prepareFormula() {
+    if (formulaBitmap != null && !formulaBitmap!!.isRecycled) return
+    if (renderFailed) return
+
+    RaTeXFontLoader.ensureLoaded(context)
+
+    try {
+      val displayList =
+        RaTeXEngine.parseBlocking(
+          latex,
+          displayMode = displayMode,
+          color = style.color,
+        )
+      val renderer = RaTeXRenderer(displayList, style.fontSize) { RaTeXFontLoader.getTypeface(it) }
+      formulaWidth = renderer.widthPx
+      formulaAscent = renderer.heightPx
+      formulaDescent = renderer.depthPx
+
+      val width = ceil(formulaWidth).toInt().coerceAtLeast(1)
+      val height = ceil(formulaAscent + formulaDescent).toInt().coerceAtLeast(1)
+      val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+      renderer.draw(Canvas(bitmap))
+      formulaBitmap = bitmap
+    } catch (_: Throwable) {
+      renderFailed = true
+      val estimatedHeight = style.fontSize * 1.2f
+      formulaWidth = (style.fontSize * latex.length.coerceAtLeast(1) * 0.6f)
+      formulaAscent = estimatedHeight * 0.7f
+      formulaDescent = estimatedHeight * 0.3f
+    }
+  }
+
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int {
+    prepareFormula()
+
+    val intrinsicWidth = formulaWidth + style.paddingHorizontal * 2f
+    val totalWidth = chipWidth(intrinsicWidth)
+    val marginTop = (style as? MathBlockStyle)?.marginTop ?: 0f
+    val marginBottom = (style as? MathBlockStyle)?.marginBottom ?: 0f
+
+    fm?.apply {
+      val ascentPx = ceil(formulaAscent + style.paddingVertical + marginTop).toInt()
+      ascent = -ascentPx
+      top = ascent
+      descent = ceil(formulaDescent + style.paddingVertical + marginBottom).toInt()
+      bottom = descent
+    }
+
+    return ceil(totalWidth).toInt()
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) {
+    prepareFormula()
+
+    val intrinsicWidth = formulaWidth + style.paddingHorizontal * 2f
+    val totalWidth = chipWidth(intrinsicWidth)
+    val chipTop = y - formulaAscent - style.paddingVertical
+    val chipBottom = y + formulaDescent + style.paddingVertical
+    val chipLeft = x
+    val chipRight = x + totalWidth
+
+    val bg =
+      if (isSelected) {
+        style.selectedBackgroundColor ?: style.backgroundColor
+      } else {
+        style.backgroundColor
+      }
+    if (bg != null && bg != 0) {
+      val bgPaint =
+        Paint(Paint.ANTI_ALIAS_FLAG).apply {
+          color = bg
+          this.style = Paint.Style.FILL
+        }
+      canvas.drawRoundRect(
+        chipLeft,
+        chipTop,
+        chipRight,
+        chipBottom,
+        style.borderRadius,
+        style.borderRadius,
+        bgPaint,
+      )
+    }
+
+    val border =
+      if (isSelected) {
+        style.selectedBorderColor ?: style.borderColor
+      } else {
+        style.borderColor
+      }
+    val borderWidth = style.borderWidth
+    if (border != null && border != 0 && borderWidth > 0f) {
+      val borderPaint =
+        Paint(Paint.ANTI_ALIAS_FLAG).apply {
+          color = border
+          this.style = Paint.Style.STROKE
+          strokeWidth = borderWidth
+        }
+      val inset = borderWidth / 2f
+      canvas.drawRoundRect(
+        chipLeft + inset,
+        chipTop + inset,
+        chipRight - inset,
+        chipBottom - inset,
+        style.borderRadius,
+        style.borderRadius,
+        borderPaint,
+      )
+    }
+
+    formulaBitmap?.let { bitmap ->
+      val blockStyle = style as? MathBlockStyle
+      val bmpX =
+        if (blockStyle != null && totalWidth > intrinsicWidth) {
+          val slack = totalWidth - formulaWidth - style.paddingHorizontal * 2f
+          val offset =
+            when (blockStyle.alignment) {
+              Layout.Alignment.ALIGN_CENTER -> slack / 2f
+              Layout.Alignment.ALIGN_OPPOSITE -> slack
+              else -> 0f
+            }
+          chipLeft + style.paddingHorizontal + offset
+        } else {
+          chipLeft + style.paddingHorizontal
+        }
+      val bmpY = chipTop + style.paddingVertical
+      canvas.drawBitmap(bitmap, bmpX, bmpY, paint)
+    }
+  }
+
+  private fun chipWidth(intrinsicWidth: Float): Float {
+    if (!displayMode) return intrinsicWidth
+    val rowWidth = blockWidthSupplier?.invoke()?.toFloat() ?: return intrinsicWidth
+    if (rowWidth <= 0f) return intrinsicWidth
+    return maxOf(rowWidth, intrinsicWidth)
+  }
+}

package/android/src/math/java/com/swmansion/enriched/markdown/spans/MathInlinePlaceholderSpan.kt

@@ -0,0 +1,41 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.style.ReplacementSpan
+import kotlin.math.roundToInt
+
+/** Holds pre-computed math metrics for background-thread measurement. */
+class MathInlinePlaceholderSpan(
+  private val metrics: MathMetrics,
+) : ReplacementSpan() {
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int {
+    fm?.apply {
+      ascent = -metrics.ascent.roundToInt()
+      top = ascent
+      descent = metrics.descent.roundToInt()
+      bottom = descent
+    }
+    return metrics.width
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) {
+    // Never displayed — measurement only.
+  }
+}

package/android/src/math/java/com/swmansion/enriched/markdown/spans/MathInlineSpan.kt

@@ -0,0 +1,92 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.style.ReplacementSpan
+import io.ratex.RaTeXEngine
+import io.ratex.RaTeXFontLoader
+import io.ratex.RaTeXRenderer
+import kotlin.math.ceil
+
+class MathInlineSpan(
+  private val context: Context,
+  internal val latex: String,
+  internal val fontSize: Float,
+  private val textColor: Int,
+) : ReplacementSpan() {
+  private var cachedBitmap: Bitmap? = null
+  private var cachedWidth = 0
+  private var mathAscent = 0f
+  private var mathDescent = 0f
+  private var renderFailed = false
+
+  private fun prepareResources() {
+    if (cachedBitmap != null && !cachedBitmap!!.isRecycled) return
+    if (renderFailed) return
+
+    try {
+      val displayList = RaTeXEngine.parseBlocking(latex, displayMode = false, color = textColor)
+      val renderer = RaTeXRenderer(displayList, fontSize) { RaTeXFontLoader.getTypeface(it) }
+
+      cachedWidth = renderer.widthPx.toInt().coerceAtLeast(1)
+      mathAscent = renderer.heightPx
+      mathDescent = renderer.depthPx
+
+      val bitmap =
+        Bitmap.createBitmap(
+          cachedWidth,
+          ceil(renderer.totalHeightPx).toInt().coerceAtLeast(1),
+          Bitmap.Config.ARGB_8888,
+        )
+
+      renderer.draw(Canvas(bitmap))
+      cachedBitmap = bitmap
+    } catch (_: Exception) {
+      renderFailed = true
+      val estimatedHeight = fontSize * 1.2f
+      cachedWidth = (fontSize * latex.length * 0.6f).toInt().coerceAtLeast(1)
+      mathAscent = estimatedHeight * 0.7f
+      mathDescent = estimatedHeight * 0.3f
+    }
+  }
+
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int {
+    prepareResources()
+
+    fm?.apply {
+      val ascentPx = ceil(mathAscent).toInt()
+      ascent = -ascentPx
+      top = ascent
+      descent = (cachedBitmap?.height ?: ceil(mathAscent + mathDescent).toInt()) - ascentPx
+      bottom = descent
+    }
+
+    return cachedWidth
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) {
+    prepareResources()
+    cachedBitmap?.let {
+      val bitmapY = y - ceil(mathAscent)
+      canvas.drawBitmap(it, x, bitmapY, paint)
+    }
+  }
+}

package/android/src/math/java/com/swmansion/enriched/markdown/spans/MathMeasureHelper.kt

@@ -0,0 +1,57 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.content.Context
+import android.util.Log
+import io.ratex.RaTeXEngine
+import io.ratex.RaTeXFontLoader
+import io.ratex.RaTeXRenderer
+
+object MathMeasureHelper {
+  @JvmStatic
+  fun measure(
+    context: Context,
+    requests: List<MathMeasureRequest>,
+  ): List<MathMetrics> {
+    if (requests.isEmpty()) return emptyList()
+
+    RaTeXFontLoader.ensureLoaded(context)
+
+    return requests.map { request ->
+      runCatching { measureSingle(context, request) }.getOrElse { estimateFallback(request) }
+    }
+  }
+
+  private fun measureSingle(
+    context: Context,
+    request: MathMeasureRequest,
+  ): MathMetrics {
+    val displayList =
+      RaTeXEngine.parseBlocking(
+        request.latex,
+        displayMode = request.mode == MathRenderMode.Display,
+      )
+
+    val renderer =
+      RaTeXRenderer(displayList, request.fontSize) {
+        RaTeXFontLoader.getTypeface(it)
+      }
+
+    return MathMetrics(
+      renderer.widthPx.toInt(),
+      renderer.heightPx,
+      renderer.depthPx,
+    )
+  }
+
+  private fun estimateFallback(request: MathMeasureRequest): MathMetrics {
+    val h = request.fontSize * 1.4f
+    return MathMetrics(
+      width =
+        (request.fontSize * request.latex.length * 0.5f)
+          .coerceIn(request.fontSize, request.fontSize * 20f)
+          .toInt(),
+      ascent = h * 0.7f,
+      descent = h * 0.3f,
+    )
+  }
+}