react-native-jet-markdown 0.2.0-beta.7

package/android/src/main/java/com/jetmarkdown/render/spans/MarkdownLineHeightSpan.kt

@@ -0,0 +1,59 @@
+package com.jetmarkdown.render.spans
+
+import android.graphics.Paint
+import android.text.TextPaint
+import android.text.style.LineHeightSpan
+import android.text.style.MetricAffectingSpan
+import kotlin.math.ceil
+import kotlin.math.floor
+
+/**
+ * React Native's lineHeight semantics: the line box is exactly [heightPx]
+ * tall with glyphs centered (mirrors RN's CustomLineHeightSpan). Extends
+ * MetricAffectingSpan (a no-op there) so DynamicLayout — the editor —
+ * reflows when the span is attached; plain LineHeightSpan is not an
+ * UpdateLayout span.
+ */
+open class MarkdownLineHeightSpan(private val heightPx: Int) :
+  MetricAffectingSpan(),
+  LineHeightSpan {
+  override fun updateMeasureState(paint: TextPaint) = Unit
+
+  override fun updateDrawState(paint: TextPaint) = Unit
+
+  override fun chooseHeight(
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    lineHeight: Int,
+    fm: Paint.FontMetricsInt,
+  ) {
+    if (fm.descent > heightPx) {
+      // Show as much descent as possible.
+      fm.descent = minOf(heightPx, fm.descent)
+      fm.bottom = fm.descent
+      fm.ascent = 0
+      fm.top = 0
+    } else if (-fm.ascent + fm.descent > heightPx) {
+      // Keep the descent, crop the ascent.
+      fm.bottom = fm.descent
+      fm.ascent = -heightPx + fm.descent
+      fm.top = fm.ascent
+    } else if (-fm.ascent + fm.bottom > heightPx) {
+      // Crop the additional bottom padding.
+      fm.top = fm.ascent
+      fm.bottom = fm.ascent + heightPx
+    } else if (-fm.top + fm.bottom > heightPx) {
+      // Crop the additional top padding.
+      fm.top = fm.bottom - heightPx
+    } else {
+      // Center the glyphs in the taller line box.
+      val extra = (heightPx - (-fm.top + fm.bottom)) / 2.0
+      fm.top -= ceil(extra).toInt()
+      fm.bottom += floor(extra).toInt()
+      fm.ascent = fm.top
+      fm.descent = fm.bottom
+    }
+  }
+}

package/android/src/main/java/com/jetmarkdown/render/spans/RunSpan.kt

@@ -0,0 +1,40 @@
+package com.jetmarkdown.render.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+
+/**
+ * One span per text run carrying the fully-resolved attributes, applied to
+ * both measurement and drawing so StaticLayout heights stay exact.
+ */
+class RunSpan(
+  private val typeface: Typeface,
+  private val textSizePx: Float,
+  private val color: Int,
+  private val baselineShiftPx: Int,
+  private val fontFeatureSettings: String?,
+  private val underline: Boolean,
+  private val strikethrough: Boolean,
+) : MetricAffectingSpan() {
+
+  override fun updateMeasureState(paint: TextPaint) {
+    applyMetrics(paint)
+  }
+
+  override fun updateDrawState(paint: TextPaint) {
+    applyMetrics(paint)
+    paint.color = color
+    paint.isUnderlineText = underline
+    paint.isStrikeThruText = strikethrough
+  }
+
+  private fun applyMetrics(paint: TextPaint) {
+    paint.typeface = typeface
+    paint.textSize = textSizePx
+    paint.baselineShift += baselineShiftPx
+    if (fontFeatureSettings != null) {
+      paint.fontFeatureSettings = fontFeatureSettings
+    }
+  }
+}

package/android/src/main/java/com/jetmarkdown/style/Fonts.kt

@@ -0,0 +1,34 @@
+package com.jetmarkdown.style
+
+import android.content.Context
+import android.graphics.Typeface
+import android.os.Build
+import com.facebook.react.common.assets.ReactFontManager
+
+/**
+ * Typeface resolution that understands React Native custom fonts.
+ * Typeface.create() only knows system families; fonts registered through
+ * RN/Expo (assets/fonts, expo-font) resolve via ReactFontManager — the same
+ * path RN's own <Text> uses.
+ */
+object Fonts {
+  fun resolve(context: Context?, family: String?, weight: Int, italic: Boolean): Typeface {
+    val style = when {
+      weight >= 600 && italic -> Typeface.BOLD_ITALIC
+      weight >= 600 -> Typeface.BOLD
+      italic -> Typeface.ITALIC
+      else -> Typeface.NORMAL
+    }
+    val base = when {
+      family == null -> Typeface.DEFAULT
+      context != null ->
+        ReactFontManager.getInstance().getTypeface(family, style, context.assets)
+      else -> Typeface.create(family, style)
+    }
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      Typeface.create(base, weight, italic)
+    } else {
+      Typeface.create(base, style)
+    }
+  }
+}

package/android/src/main/java/com/jetmarkdown/style/LayoutStyleSpec.kt

@@ -0,0 +1,71 @@
+package com.jetmarkdown.style
+
+import com.jetmarkdown.style.TextStyleSpec.Companion.optColor
+import org.json.JSONObject
+
+/** One element's box style from stylesJson (dp values). */
+class LayoutStyleSpec(
+  val backgroundColor: Int?,
+  val paddingLeft: Float,
+  val paddingRight: Float,
+  val paddingTop: Float,
+  val paddingBottom: Float,
+  val borderRadius: Float,
+  val borderLeftColor: Int?,
+  val borderLeftWidth: Float,
+  val borderRightColor: Int?,
+  val borderRightWidth: Float,
+  val borderTopColor: Int?,
+  val borderTopWidth: Float,
+  val borderBottomColor: Int?,
+  val borderBottomWidth: Float,
+) {
+  /** Converts dp values to px; colors unchanged. */
+  fun scaled(density: Float): LayoutStyleSpec = LayoutStyleSpec(
+    backgroundColor = backgroundColor,
+    paddingLeft = paddingLeft * density,
+    paddingRight = paddingRight * density,
+    paddingTop = paddingTop * density,
+    paddingBottom = paddingBottom * density,
+    borderRadius = borderRadius * density,
+    borderLeftColor = borderLeftColor,
+    borderLeftWidth = borderLeftWidth * density,
+    borderRightColor = borderRightColor,
+    borderRightWidth = borderRightWidth * density,
+    borderTopColor = borderTopColor,
+    borderTopWidth = borderTopWidth * density,
+    borderBottomColor = borderBottomColor,
+    borderBottomWidth = borderBottomWidth * density,
+  )
+
+  companion object {
+    val EMPTY = LayoutStyleSpec(null, 0f, 0f, 0f, 0f, 0f, null, 0f, null, 0f, null, 0f, null, 0f)
+
+    fun from(json: JSONObject?, defaults: LayoutStyleSpec = EMPTY): LayoutStyleSpec {
+      if (json == null) {
+        return defaults
+      }
+      return LayoutStyleSpec(
+        backgroundColor = json.optColor("backgroundColor") ?: defaults.backgroundColor,
+        paddingLeft = json.optDp("paddingLeft", defaults.paddingLeft),
+        paddingRight = json.optDp("paddingRight", defaults.paddingRight),
+        paddingTop = json.optDp("paddingTop", defaults.paddingTop),
+        paddingBottom = json.optDp("paddingBottom", defaults.paddingBottom),
+        borderRadius = json.optDp("borderRadius", defaults.borderRadius),
+        borderLeftColor = json.optColor("borderLeftColor") ?: defaults.borderLeftColor,
+        borderLeftWidth = json.optDp("borderLeftWidth", defaults.borderLeftWidth),
+        borderRightColor = json.optColor("borderRightColor") ?: defaults.borderRightColor,
+        borderRightWidth = json.optDp("borderRightWidth", defaults.borderRightWidth),
+        borderTopColor = json.optColor("borderTopColor") ?: defaults.borderTopColor,
+        borderTopWidth = json.optDp("borderTopWidth", defaults.borderTopWidth),
+        borderBottomColor = json.optColor("borderBottomColor") ?: defaults.borderBottomColor,
+        borderBottomWidth = json.optDp("borderBottomWidth", defaults.borderBottomWidth),
+      )
+    }
+
+    private fun JSONObject.optDp(key: String, fallback: Float): Float {
+      val value = optDouble(key)
+      return if (value.isNaN()) fallback else value.toFloat()
+    }
+  }
+}

package/android/src/main/java/com/jetmarkdown/style/PlatformColorResolver.kt

@@ -0,0 +1,77 @@
+package com.jetmarkdown.style
+
+import android.content.Context
+import android.util.TypedValue
+import java.lang.ref.WeakReference
+import org.json.JSONObject
+
+/**
+ * Resolves React Native platform-color descriptors ({"resource_paths":
+ * ["@color/x", "?attr/y", ...]}) against the current theme. The context is
+ * registered by the view managers (a ThemedReactContext, so ?attr lookups
+ * see the activity theme) and held weakly.
+ */
+object PlatformColorResolver {
+  @Volatile private var contextRef: WeakReference<Context>? = null
+
+  fun install(context: Context) {
+    contextRef = WeakReference(context)
+  }
+
+  /** The registered themed context (font/color resolution off-view). */
+  fun current(): Context? = contextRef?.get()
+
+  /** Night-mode bit of the registered context; part of style cache keys. */
+  fun appearanceKey(): Int {
+    val context = contextRef?.get() ?: return 0
+    return context.resources.configuration.uiMode and
+      android.content.res.Configuration.UI_MODE_NIGHT_MASK
+  }
+
+  fun resolve(json: JSONObject): Int? {
+    val paths = json.optJSONArray("resource_paths") ?: return null
+    val context = contextRef?.get() ?: return null
+    for (index in 0 until paths.length()) {
+      val resolved = resolvePath(context, paths.optString(index, ""))
+      if (resolved != null) {
+        return resolved
+      }
+    }
+    return null
+  }
+
+  private fun resolvePath(context: Context, path: String): Int? {
+    if (path.isEmpty()) {
+      return null
+    }
+    if (path.startsWith("?")) {
+      val name = path.removePrefix("?").removePrefix("attr/")
+      val attrId = context.resources.getIdentifier(name, "attr", context.packageName)
+      if (attrId == 0) {
+        return null
+      }
+      val out = TypedValue()
+      if (!context.theme.resolveAttribute(attrId, out, true)) {
+        return null
+      }
+      if (out.type in TypedValue.TYPE_FIRST_COLOR_INT..TypedValue.TYPE_LAST_COLOR_INT) {
+        return out.data
+      }
+      return runCatching {
+        context.resources.getColor(out.resourceId, context.theme)
+      }.getOrNull()
+    }
+    if (path.startsWith("@")) {
+      // "@color/name" or "@android:color/name".
+      val spec = path.removePrefix("@")
+      val pkg = if (spec.contains(":")) spec.substringBefore(":") else context.packageName
+      val name = spec.substringAfter(":").removePrefix("color/")
+      val id = context.resources.getIdentifier(name, "color", pkg)
+      if (id == 0) {
+        return null
+      }
+      return runCatching { context.resources.getColor(id, context.theme) }.getOrNull()
+    }
+    return null
+  }
+}

package/android/src/main/java/com/jetmarkdown/style/StyleConfig.kt

@@ -0,0 +1,80 @@
+package com.jetmarkdown.style
+
+import com.jetmarkdown.style.TextStyleSpec.Companion.optColor
+import java.util.regex.Pattern
+import org.json.JSONObject
+
+class MentionVariant(val pattern: Pattern, val style: TextStyleSpec?)
+
+/**
+ * Parsed stylesJson with defaults, cached per JSON string.
+ */
+class StyleConfig private constructor(private val root: JSONObject) {
+  private val main: JSONObject? = root.optJSONObject("main")
+  private val textStyles = HashMap<String, TextStyleSpec?>()
+
+  // Container style-prop gap wins; the styles prop (defaultStyles.gap)
+  // supplies the themed value; unstyled floor is 0.
+  val gap: Float = main.optFloatOr("gap", root.optFloatOr("gap", 0f))
+  val paddingLeft: Float = main.optFloatOr("paddingLeft", 0f)
+  val paddingRight: Float = main.optFloatOr("paddingRight", 0f)
+  val paddingTop: Float = main.optFloatOr("paddingTop", 0f)
+  val paddingBottom: Float = main.optFloatOr("paddingBottom", 0f)
+  val backgroundColor: Int? = main?.optColor("backgroundColor")
+
+  /** Ordered longest-pattern-first; a link whose URL matches is a mention. */
+  val mentionVariants: List<MentionVariant> = buildList {
+    val variants = root.optJSONObject("mention")?.optJSONArray("variants") ?: return@buildList
+    for (i in 0 until variants.length()) {
+      val pair = variants.optJSONArray(i) ?: continue
+      val patternString = pair.optString(0, "")
+      if (patternString.isEmpty()) {
+        continue
+      }
+      val pattern = runCatching { Pattern.compile(patternString) }.getOrNull() ?: continue
+      add(MentionVariant(pattern, TextStyleSpec.from(pair.optJSONObject(1))))
+    }
+  }
+
+  /** Raw JSON section for an element key (layout parsing). */
+  fun rawSection(key: String): JSONObject? = root.optJSONObject(key)
+
+  /** User style for an element key; null when not provided. */
+  fun textStyleFor(key: String): TextStyleSpec? {
+    synchronized(textStyles) {
+      if (textStyles.containsKey(key)) {
+        return textStyles[key]
+      }
+      val style = TextStyleSpec.from(root.optJSONObject(key))
+      textStyles[key] = style
+      return style
+    }
+  }
+
+
+  companion object {
+    private val cache = HashMap<String, StyleConfig>()
+
+    fun from(stylesJson: String): StyleConfig {
+      // Platform colors resolve against the current theme; a dark-mode flip
+      // must not serve configs holding light-resolved ints.
+      val cacheKey = "${PlatformColorResolver.appearanceKey()}\u001f$stylesJson"
+      synchronized(cache) {
+        cache[cacheKey]?.let { return it }
+        val config = StyleConfig(
+          runCatching { JSONObject(stylesJson.ifEmpty { "{}" }) }.getOrElse { JSONObject() }
+        )
+        if (cache.size > 16) {
+          cache.clear()
+        }
+        cache[cacheKey] = config
+        return config
+      }
+    }
+
+    private fun JSONObject?.optFloatOr(key: String, fallback: Float): Float {
+      val value = this?.optDouble(key) ?: return fallback
+      return if (value.isNaN()) fallback else value.toFloat()
+    }
+  }
+}

package/android/src/main/java/com/jetmarkdown/style/TextStyleSpec.kt

@@ -0,0 +1,61 @@
+package com.jetmarkdown.style
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** One element's text style from stylesJson; null fields inherit. */
+class TextStyleSpec(
+  val fontSize: Float?,
+  val fontWeight: Int?,
+  val fontFamily: String?,
+  val lineHeight: Float?,
+  val color: Int?,
+  val fontVariant: List<String>?,
+  val textDecorationColor: Int?,
+  val textDecorationLine: String?,
+  val textDecorationStyle: String?,
+  val backgroundColor: Int?,
+) {
+  companion object {
+    fun from(json: JSONObject?): TextStyleSpec? {
+      if (json == null) {
+        return null
+      }
+      return TextStyleSpec(
+        fontSize = json.optNumber("fontSize"),
+        fontWeight = when (val weight = json.optString("fontWeight", "")) {
+          "" -> null
+          "bold" -> 700
+          "normal" -> 400
+          else -> weight.toIntOrNull()?.takeIf { it in 100..900 }
+        },
+        fontFamily = json.optString("fontFamily", "").ifEmpty { null },
+        lineHeight = json.optNumber("lineHeight"),
+        color = json.optColor("color"),
+        fontVariant = (json.optJSONArray("fontVariant"))?.toStringList(),
+        textDecorationColor = json.optColor("textDecorationColor"),
+        textDecorationLine = json.optString("textDecorationLine", "").ifEmpty { null },
+        textDecorationStyle = json.optString("textDecorationStyle", "").ifEmpty { null },
+        backgroundColor = json.optColor("backgroundColor"),
+      )
+    }
+
+    private fun JSONObject.optNumber(key: String): Float? {
+      val value = optDouble(key)
+      return if (value.isNaN()) null else value.toFloat()
+    }
+
+    internal fun JSONObject.optColor(key: String): Int? {
+      if (!has(key)) {
+        return null
+      }
+      // Platform colors arrive as {"resource_paths": [...]} descriptors.
+      optJSONObject(key)?.let { return PlatformColorResolver.resolve(it) }
+      val value = optLong(key, Long.MIN_VALUE)
+      return if (value == Long.MIN_VALUE) null else value.toInt()
+    }
+
+    private fun JSONArray.toStringList(): List<String> =
+      (0 until length()).mapNotNull { optString(it, null) }
+  }
+}