@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.9

package/android/src/main/java/com/renderrichtext/renderer/SpanStyleCache.kt

@@ -0,0 +1,143 @@
+package com.renderrichtext.renderer
+
+import android.content.res.AssetManager
+import android.graphics.Typeface
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.views.text.ReactTypefaceUtils.applyStyles
+import com.renderrichtext.styles.LinkVariantEntry
+import com.renderrichtext.styles.StyleConfig
+
+/** Shared style cache for spans to avoid redundant calculations. */
+class SpanStyleCache(
+  style: StyleConfig,
+) {
+  private val assetManager: AssetManager = style.assetManager
+
+  // 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 factoidColor: Int = style.factoidStyle.color
+  val factoidBackgroundColor: Int = style.factoidStyle.backgroundColor
+  val factoidBorderColor: Int = style.factoidStyle.borderColor
+  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 && it != paragraphColor }
+        ?.let { add(it) }
+      style.emphasisStyle.color
+        ?.takeIf { it != 0 && it != paragraphColor }
+        ?.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 && it != paragraphColor }
+        ?.let { add(it) }
+      style.factoidStyle.color
+        .takeIf { it != 0 && it != paragraphColor }
+        ?.let { add(it) }
+      style.taskListStyle.checkedTextColor
+        .takeIf { it != 0 && it != paragraphColor }
+        ?.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
+  }
+
+  /**
+   * Cached typeface for font family + style (BOLD, ITALIC, BOLD_ITALIC).
+   *
+   * Loads the base custom font at its NORMAL weight (via applyStyles/ReactFontManager)
+   * so the bundled assets/fonts file resolves, then synthesizes bold/italic on that real
+   * typeface. Requesting bold/italic directly makes ReactFontManager look for `_bold`/
+   * `_italic` asset variants that single-file custom fonts don't have — and it then falls
+   * back to a default system face, dropping the custom font entirely.
+   */
+  fun getTypeface(
+    fontFamily: String,
+    style: Int,
+  ): Typeface =
+    typefaceCache.getOrPut("family|$fontFamily|$style") {
+      val base =
+        applyStyles(
+          null,
+          ReactConstants.UNSET,
+          ReactConstants.UNSET,
+          fontFamily.takeIf { it.isNotEmpty() },
+          assetManager,
+        )
+      if (style == Typeface.NORMAL) base else Typeface.create(base, style)
+    }
+
+  companion object {
+    private val typefaceCache = mutableMapOf<String, Typeface>()
+
+    /** 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/renderrichtext/renderer/StrikethroughRenderer.kt

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

package/android/src/main/java/com/renderrichtext/renderer/StrongRenderer.kt

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

package/android/src/main/java/com/renderrichtext/renderer/TextRenderer.kt

@@ -0,0 +1,31 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.TextSpan
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class TextRenderer : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((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/renderrichtext/renderer/ThematicBreakRenderer.kt

@@ -0,0 +1,46 @@
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.ThematicBreakSpan
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class ThematicBreakRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((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/renderrichtext/renderer/UnderlineRenderer.kt

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

package/android/src/main/java/com/renderrichtext/spans/BaseListSpan.kt

@@ -0,0 +1,164 @@
+package com.renderrichtext.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.renderrichtext.renderer.BlockStyle
+import com.renderrichtext.renderer.SpanStyleCache
+import com.renderrichtext.utils.text.extensions.applyBlockStyleFont
+import com.renderrichtext.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,
+  internal val drawsMarker: Boolean = true,
+  internal val ancestorMarkerOffset: Float = 0f,
+  internal val parentMarkerWidth: Float? = null,
+) : MetricAffectingSpan(),
+  LeadingMarginSpan {
+  private var cachedText: CharSequence? = null
+  private var cachedHasDeeperSpanByPosition = mutableMapOf<Int, Boolean>()
+
+  val markerFontMetrics: Paint.FontMetrics by lazy {
+    TextPaint()
+      .apply {
+        applyBlockStyleFont(blockStyle, context)
+        textSize = blockStyle.fontSize
+      }.fontMetrics
+  }
+
+  protected abstract fun getMarkerWidth(): Float
+
+  /** How far an ordered list widened this item's column past the one short lists reserve. */
+  internal open val markerExtraWidth: Float = 0f
+
+  /** This item's marker column without [markerExtraWidth]; a nested item measures its indent against it. */
+  internal open val baselineMarkerWidth: Float get() = getMarkerWidth()
+
+  override fun updateMeasureState(textPaint: TextPaint) = applyTextStyle(textPaint)
+
+  override fun updateDrawState(textPaint: TextPaint) = applyTextStyle(textPaint)
+
+  override fun getLeadingMargin(first: Boolean): Int {
+    val effectiveGap = gapWidth.coerceAtLeast(DEFAULT_MIN_GAP)
+    if (depth == 0) return (getMarkerWidth() + effectiveGap).toInt()
+
+    // Subtract truncated absolute indents, each measured from its own item's column, so neither mixed
+    // columns nor fractional margins accumulate rounding. The widenings are whole pixels and add unchanged.
+    val markerWidth = baselineMarkerWidth
+    val parentWidth = parentMarkerWidth ?: markerWidth
+    val indent = (depth * marginLeft + markerWidth + effectiveGap).toInt()
+    val parentIndent = ((depth - 1) * marginLeft + parentWidth + effectiveGap).toInt()
+    return indent - parentIndent + markerExtraWidth.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 (!drawsMarker) return
+    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
+
+    drawMarkerAt(canvas, paint, x, dir, top, baseline, bottom, layout, start)
+  }
+
+  fun drawMarkerAt(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    layout: Layout?,
+    start: Int,
+  ) {
+    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/renderrichtext/spans/BaselineShiftSpan.kt

@@ -0,0 +1,27 @@
+package com.renderrichtext.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()
+  }
+}