react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/android/src/main/java/com/swmansion/enriched/markdown/utils/input/MarkdownStyleParser.kt

@@ -3,8 +3,11 @@ package com.swmansion.enriched.markdown.utils.input
 import android.graphics.Color
 import android.text.Layout
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.ReactConstants
 import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.views.text.ReactTypefaceUtils
 import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
+import com.swmansion.enriched.markdown.input.model.InputHeadingStyle
 import com.swmansion.enriched.markdown.input.model.InputLinkVariantStyle
 import com.swmansion.enriched.markdown.input.model.MathBlockStyle
 import com.swmansion.enriched.markdown.input.model.MathChipStyle
@@ -15,11 +18,12 @@ object MarkdownStyleParser {
     val emMap = map.getMap("em")
     val linkMap = map.getMap("link")
     val spoilerMap = map.getMap("spoiler")
-    val mathMap = map.getMap("math")
-    val mathBlockMap = map.getMap("mathBlock")
+    val inlineMathMap = map.getMap("inlineMath")
+    val blockMathMap = map.getMap("math")
 
-    val math = parseMathStyle(mathMap)
-    val mathBlock = parseMathBlockStyle(mathBlockMap, math)
+    val inlineMath = parseInlineMathStyle(inlineMathMap)
+    val math = parseBlockMathStyle(blockMathMap, inlineMath)
+    val listMap = map.getMap("list")
 
     return InputFormatterStyle(
       boldColor = if (strongMap?.hasKey("color") == true) strongMap.getInt("color") else null,
@@ -30,11 +34,37 @@ object MarkdownStyleParser {
       linkVariants = parseLinkVariants(map),
       spoilerColor = spoilerMap!!.getInt("color"),
       spoilerBackgroundColor = spoilerMap.getInt("backgroundColor"),
+      inlineMath = inlineMath,
       math = math,
-      mathBlock = mathBlock,
+      headings = parseHeadings(map),
+      listItemSpacing =
+        if (listMap?.hasKey("itemSpacing") == true) listMap.getDouble("itemSpacing").toFloat() else 0f,
     )
   }
 
+  // Mirrors the readonly renderer's h1..h6 markdownStyle. fontSize arrives in SP
+  // (matching the JS prop) and is converted to px so the input span can size text
+  // identically to the read view.
+  private fun parseHeadings(map: ReadableMap): List<InputHeadingStyle> =
+    (1..6).map { level ->
+      val headingMap = map.getMap("h$level")
+      InputHeadingStyle(
+        fontSizePx =
+          if (headingMap?.hasKey("fontSize") == true) {
+            PixelUtil.toPixelFromSP(headingMap.getDouble("fontSize"))
+          } else {
+            null
+          },
+        fontWeight =
+          if (headingMap?.hasKey("fontWeight") == true) {
+            ReactTypefaceUtils.parseFontWeight(headingMap.getString("fontWeight"))
+          } else {
+            ReactConstants.UNSET
+          },
+        color = if (headingMap?.hasKey("color") == true) headingMap.getInt("color") else null,
+      )
+    }
+
   private fun parseLinkVariants(map: ReadableMap): List<InputLinkVariantStyle> {
     if (!map.hasKey("linkVariants")) return emptyList()
     val variants = map.getArray("linkVariants") ?: return emptyList()
@@ -49,35 +79,35 @@ object MarkdownStyleParser {
     }
   }
 
-  private fun parseMathStyle(mathMap: ReadableMap?): MathChipStyle {
-    val color = if (mathMap?.hasKey("color") == true) mathMap.getInt("color") else Color.BLACK
-    val fontSizeSp = if (mathMap?.hasKey("fontSize") == true) mathMap.getDouble("fontSize").toFloat() else 16f
+  private fun parseInlineMathStyle(styleMap: ReadableMap?): MathChipStyle {
+    val color = if (styleMap?.hasKey("color") == true) styleMap.getInt("color") else Color.BLACK
+    val fontSizeSp = if (styleMap?.hasKey("fontSize") == true) styleMap.getDouble("fontSize").toFloat() else 16f
     val fontSize = PixelUtil.toPixelFromSP(fontSizeSp)
     val backgroundColor =
-      if (mathMap?.hasKey("backgroundColor") == true) mathMap.getInt("backgroundColor") else null
-    val borderColor = if (mathMap?.hasKey("borderColor") == true) mathMap.getInt("borderColor") else null
+      if (styleMap?.hasKey("backgroundColor") == true) styleMap.getInt("backgroundColor") else null
+    val borderColor = if (styleMap?.hasKey("borderColor") == true) styleMap.getInt("borderColor") else null
     val borderWidth =
       PixelUtil.toPixelFromDIP(
-        if (mathMap?.hasKey("borderWidth") == true) mathMap.getDouble("borderWidth").toFloat() else 0f,
+        if (styleMap?.hasKey("borderWidth") == true) styleMap.getDouble("borderWidth").toFloat() else 0f,
       )
     val borderRadius =
       PixelUtil.toPixelFromDIP(
-        if (mathMap?.hasKey("borderRadius") == true) mathMap.getDouble("borderRadius").toFloat() else 0f,
+        if (styleMap?.hasKey("borderRadius") == true) styleMap.getDouble("borderRadius").toFloat() else 0f,
       )
     val paddingHorizontal =
       PixelUtil.toPixelFromDIP(
-        if (mathMap?.hasKey("paddingHorizontal") == true) mathMap.getDouble("paddingHorizontal").toFloat() else 0f,
+        if (styleMap?.hasKey("paddingHorizontal") == true) styleMap.getDouble("paddingHorizontal").toFloat() else 0f,
       )
     val paddingVertical =
       PixelUtil.toPixelFromDIP(
-        if (mathMap?.hasKey("paddingVertical") == true) mathMap.getDouble("paddingVertical").toFloat() else 0f,
+        if (styleMap?.hasKey("paddingVertical") == true) styleMap.getDouble("paddingVertical").toFloat() else 0f,
       )
     val selectedBackgroundColor =
-      if (mathMap?.hasKey("selectedBackgroundColor") == true) mathMap.getInt("selectedBackgroundColor") else null
+      if (styleMap?.hasKey("selectedBackgroundColor") == true) styleMap.getInt("selectedBackgroundColor") else null
     val selectedBorderColor =
-      if (mathMap?.hasKey("selectedBorderColor") == true) mathMap.getInt("selectedBorderColor") else null
+      if (styleMap?.hasKey("selectedBorderColor") == true) styleMap.getInt("selectedBorderColor") else null
     val fontWeight =
-      (if (mathMap?.hasKey("fontWeight") == true) mathMap.getString("fontWeight") else null) ?: "normal"
+      (if (styleMap?.hasKey("fontWeight") == true) styleMap.getString("fontWeight") else null) ?: "normal"
 
     return MathChipStyle(
       color = color,
@@ -94,75 +124,75 @@ object MarkdownStyleParser {
     )
   }
 
-  private fun parseMathBlockStyle(
-    mathBlockMap: ReadableMap?,
+  private fun parseBlockMathStyle(
+    styleMap: ReadableMap?,
     inlineFallback: MathChipStyle,
-  ): MathChipStyle {
-    val color = if (mathBlockMap?.hasKey("color") == true) mathBlockMap.getInt("color") else inlineFallback.color
+  ): MathBlockStyle {
+    val color = if (styleMap?.hasKey("color") == true) styleMap.getInt("color") else inlineFallback.color
     val fontSizeSp =
-      if (mathBlockMap?.hasKey("fontSize") == true) mathBlockMap.getDouble("fontSize").toFloat() else 20f
+      if (styleMap?.hasKey("fontSize") == true) styleMap.getDouble("fontSize").toFloat() else 20f
     val fontSize = PixelUtil.toPixelFromSP(fontSizeSp)
     val backgroundColor =
-      if (mathBlockMap?.hasKey("backgroundColor") == true) {
-        mathBlockMap.getInt("backgroundColor")
+      if (styleMap?.hasKey("backgroundColor") == true) {
+        styleMap.getInt("backgroundColor")
       } else {
         inlineFallback.backgroundColor
       }
     val borderColor =
-      if (mathBlockMap?.hasKey("borderColor") == true) {
-        mathBlockMap.getInt("borderColor")
+      if (styleMap?.hasKey("borderColor") == true) {
+        styleMap.getInt("borderColor")
       } else {
         inlineFallback.borderColor
       }
     val borderWidth =
-      if (mathBlockMap?.hasKey("borderWidth") == true) {
-        PixelUtil.toPixelFromDIP(mathBlockMap.getDouble("borderWidth").toFloat())
+      if (styleMap?.hasKey("borderWidth") == true) {
+        PixelUtil.toPixelFromDIP(styleMap.getDouble("borderWidth").toFloat())
       } else {
         inlineFallback.borderWidth
       }
     val borderRadius =
-      if (mathBlockMap?.hasKey("borderRadius") == true) {
-        PixelUtil.toPixelFromDIP(mathBlockMap.getDouble("borderRadius").toFloat())
+      if (styleMap?.hasKey("borderRadius") == true) {
+        PixelUtil.toPixelFromDIP(styleMap.getDouble("borderRadius").toFloat())
       } else {
         inlineFallback.borderRadius
       }
     val paddingHorizontal =
       PixelUtil.toPixelFromDIP(
-        if (mathBlockMap?.hasKey("paddingHorizontal") == true) mathBlockMap.getDouble("paddingHorizontal").toFloat() else 12f,
+        if (styleMap?.hasKey("paddingHorizontal") == true) styleMap.getDouble("paddingHorizontal").toFloat() else 12f,
       )
     val paddingVertical =
       PixelUtil.toPixelFromDIP(
-        if (mathBlockMap?.hasKey("paddingVertical") == true) mathBlockMap.getDouble("paddingVertical").toFloat() else 8f,
+        if (styleMap?.hasKey("paddingVertical") == true) styleMap.getDouble("paddingVertical").toFloat() else 8f,
       )
     val selectedBackgroundColor =
-      if (mathBlockMap?.hasKey("selectedBackgroundColor") == true) {
-        mathBlockMap.getInt("selectedBackgroundColor")
+      if (styleMap?.hasKey("selectedBackgroundColor") == true) {
+        styleMap.getInt("selectedBackgroundColor")
       } else {
         inlineFallback.selectedBackgroundColor
       }
     val selectedBorderColor =
-      if (mathBlockMap?.hasKey("selectedBorderColor") == true) {
-        mathBlockMap.getInt("selectedBorderColor")
+      if (styleMap?.hasKey("selectedBorderColor") == true) {
+        styleMap.getInt("selectedBorderColor")
       } else {
         inlineFallback.selectedBorderColor
       }
     val fontWeight =
-      if (mathBlockMap?.hasKey("fontWeight") == true) {
-        mathBlockMap.getString("fontWeight") ?: "normal"
+      if (styleMap?.hasKey("fontWeight") == true) {
+        styleMap.getString("fontWeight") ?: "normal"
       } else {
         inlineFallback.fontWeight
       }
     val marginTop =
       PixelUtil.toPixelFromDIP(
-        if (mathBlockMap?.hasKey("marginTop") == true) mathBlockMap.getDouble("marginTop").toFloat() else 8f,
+        if (styleMap?.hasKey("marginTop") == true) styleMap.getDouble("marginTop").toFloat() else 8f,
       )
     val marginBottom =
       PixelUtil.toPixelFromDIP(
-        if (mathBlockMap?.hasKey("marginBottom") == true) mathBlockMap.getDouble("marginBottom").toFloat() else 8f,
+        if (styleMap?.hasKey("marginBottom") == true) styleMap.getDouble("marginBottom").toFloat() else 8f,
       )
-    val alignmentRaw = if (mathBlockMap?.hasKey("alignment") == true) mathBlockMap.getString("alignment") else null
-    val alignment =
-      when (alignmentRaw) {
+    val textAlignRaw = if (styleMap?.hasKey("textAlign") == true) styleMap.getString("textAlign") else null
+    val textAlign =
+      when (textAlignRaw) {
         "left" -> Layout.Alignment.ALIGN_NORMAL
         "right" -> Layout.Alignment.ALIGN_OPPOSITE
         else -> Layout.Alignment.ALIGN_CENTER
@@ -182,7 +212,7 @@ object MarkdownStyleParser {
       fontWeight = fontWeight,
       marginTop = marginTop,
       marginBottom = marginBottom,
-      alignment = alignment,
+      textAlign = textAlign,
     )
   }
 

package/android/src/main/java/com/swmansion/enriched/markdown/utils/input/PasteTextUtils.kt

@@ -0,0 +1,20 @@
+package com.swmansion.enriched.markdown.utils.input
+
+/**
+ * The pure half of the paste interception path. A `ClipData` cannot be built on
+ * the JVM, so the joining rule lives here where a unit test can reach it; the
+ * two call sites (context menu and `onReceiveContent`) only extract the items.
+ */
+object PasteTextUtils {
+  /**
+   * Flattens a clip's items into one string. A clip regularly carries more than
+   * one item — reading only `getItemAt(0)` silently drops items 2..n. Items
+   * without text (a URI or intent) are skipped, and the rest join on newlines,
+   * which is what the platform's own paste does.
+   */
+  fun joinClipTexts(texts: List<CharSequence?>): String =
+    texts
+      .mapNotNull { it?.toString() }
+      .filter { it.isNotEmpty() }
+      .joinToString("\n")
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/ImageCache.kt

@@ -2,6 +2,7 @@ package com.swmansion.enriched.markdown.utils.text
 
 import android.graphics.Bitmap
 import android.util.LruCache
+import java.security.MessageDigest
 
 object ImageCache {
   private const val ORIGINAL_CACHE_SIZE = 20 * 1024 * 1024
@@ -10,6 +11,25 @@ object ImageCache {
   private val originalCache = bitmapLruCache(ORIGINAL_CACHE_SIZE)
   private val processedCache = bitmapLruCache(PROCESSED_CACHE_SIZE)
 
+  /**
+   * Cache identity for a remote image request. Returns the URL itself when no
+   * headers are set; otherwise appends a SHA-256 digest of the sorted header
+   * pairs, so the same URL fetched with different headers is cached and
+   * deduplicated separately without embedding header values in the key.
+   */
+  fun requestKey(
+    url: String,
+    headers: Map<String, String>,
+  ): String {
+    if (headers.isEmpty()) return url
+    val joined =
+      headers.entries
+        .sortedBy { it.key }
+        .joinToString(separator = "\n") { "${it.key}:${it.value}" }
+    val digest = MessageDigest.getInstance("SHA-256").digest(joined.toByteArray())
+    return url + "|" + digest.joinToString(separator = "") { "%02x".format(it) }
+  }
+
   fun getOriginal(url: String): Bitmap? = originalCache.get(url)
 
   fun putOriginal(
@@ -24,16 +44,18 @@ object ImageCache {
     width: Int,
     height: Int,
     borderRadius: Int,
-  ): Bitmap? = processedCache.get(processedKey(url, width, height, borderRadius))
+    resizeMode: String,
+  ): Bitmap? = processedCache.get(processedKey(url, width, height, borderRadius, resizeMode))
 
   fun putProcessed(
     url: String,
     width: Int,
     height: Int,
     borderRadius: Int,
+    resizeMode: String,
     bitmap: Bitmap,
   ) {
-    processedCache.put(processedKey(url, width, height, borderRadius), bitmap)
+    processedCache.put(processedKey(url, width, height, borderRadius, resizeMode), bitmap)
   }
 
   private fun processedKey(
@@ -41,7 +63,8 @@ object ImageCache {
     width: Int,
     height: Int,
     borderRadius: Int,
-  ): String = "${url}_w${width}_h${height}_r$borderRadius"
+    resizeMode: String,
+  ): String = "${url}_w${width}_h${height}_r${borderRadius}_m$resizeMode"
 
   private fun bitmapLruCache(maxSize: Int): LruCache<String, Bitmap> =
     object : LruCache<String, Bitmap>(maxSize) {

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/ImageDownloader.kt

@@ -50,23 +50,31 @@ object ImageDownloader {
   fun download(
     context: Context,
     url: String,
+    headers: Map<String, String> = emptyMap(),
     callback: (Bitmap?) -> Unit,
   ) {
-    ImageCache.getOriginal(url)?.let {
+    val requestKey = ImageCache.requestKey(url, headers)
+
+    ImageCache.getOriginal(requestKey)?.let {
       callback(it)
       return
     }
 
     synchronized(inFlight) {
-      val existing = inFlight[url]
+      val existing = inFlight[requestKey]
       if (existing != null) {
         existing.add(callback)
         return
       }
-      inFlight[url] = mutableListOf(callback)
+      inFlight[requestKey] = mutableListOf(callback)
     }
 
-    val request = Request.Builder().url(url).build()
+    val request =
+      Request
+        .Builder()
+        .url(url)
+        .apply { headers.forEach { (name, value) -> addHeader(name, value) } }
+        .build()
     getClient(context).newCall(request).enqueue(
       object : Callback {
         override fun onResponse(
@@ -87,8 +95,8 @@ object ImageDownloader {
               }
             }
 
-          bitmap?.let { ImageCache.putOriginal(url, it) }
-          dispatchCallbacks(url, bitmap)
+          bitmap?.let { ImageCache.putOriginal(requestKey, it) }
+          dispatchCallbacks(requestKey, bitmap)
         }
 
         override fun onFailure(
@@ -96,7 +104,7 @@ object ImageDownloader {
           e: IOException,
         ) {
           Log.e(TAG, "Failed to download image: $url", e)
-          dispatchCallbacks(url, null)
+          dispatchCallbacks(requestKey, null)
         }
       },
     )
@@ -113,6 +121,11 @@ object ImageDownloader {
     }
   }
 
+  fun decodeBytesDownsampled(
+    context: Context,
+    bytes: ByteArray,
+  ): Bitmap? = decodeDownsampled(bytes, context.resources.displayMetrics.widthPixels)
+
   fun decodeFileDownsampled(
     context: Context,
     path: String,
@@ -145,10 +158,10 @@ object ImageDownloader {
   }
 
   private fun dispatchCallbacks(
-    url: String,
+    requestKey: String,
     bitmap: Bitmap?,
   ) {
-    val callbacks = synchronized(inFlight) { inFlight.remove(url) } ?: return
+    val callbacks = synchronized(inFlight) { inFlight.remove(requestKey) } ?: return
     mainHandler.post {
       callbacks.forEach { it(bitmap) }
     }

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/LocalImageLoader.kt

@@ -0,0 +1,161 @@
+package com.swmansion.enriched.markdown.utils.text
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.net.Uri
+import android.util.Base64
+import android.util.Log
+import java.io.FileNotFoundException
+import java.io.InputStream
+
+/**
+ * Loads markdown images from non-network sources (issue #377).
+ *
+ * React Native's asset system produces different URI shapes for the same
+ * `require('./img.png')` depending on environment, and none of them are plain
+ * file paths in a bundled app:
+ * - Metro dev server: `http://host:8081/assets/...` (handled by [ImageDownloader])
+ * - Release APK: a bare drawable resource name, e.g. `src_assets_logo`
+ *   (RN's `AssetSourceResolver.resourceIdentifierWithoutScale`)
+ * - Sideloaded JS bundle: `file:///.../drawable-xhdpi/src_assets_logo.png`
+ * - expo-updates embedded assets: `file:///android_res/drawable/<name>.png`
+ * - expo-asset downloads: percent-encoded `file://` paths in the cache dir
+ *
+ * Resolution mirrors RN core: `ImageSource.computeUri` treats a scheme-less
+ * source as a resource name, and `ResourceDrawableIdHelper` normalizes names
+ * by lowercasing, replacing `-` with `_`, and accepting numeric resource ids. The
+ * `android_res`/`android_asset` and drawable/raw lookups follow expo-asset's
+ * `ResourceAsset.kt`. `content://`, `asset://`, `res://` and `data:` URIs are
+ * supported for parity with RN's Fresco pipeline. All decodes are downsampled
+ * to screen width like the network path.
+ */
+object LocalImageLoader {
+  private const val TAG = "LocalImageLoader"
+  private const val ASSET_PATH_PREFIX = "/android_asset/"
+  private const val RES_PATH_PREFIX = "/android_res/"
+  private const val BASE64_MARKER = "base64,"
+
+  fun load(
+    context: Context,
+    source: String,
+  ): Bitmap? =
+    try {
+      val uri = Uri.parse(source)
+      when (uri.scheme?.lowercase()) {
+        null -> {
+          if (source.startsWith('/')) {
+            ImageDownloader.decodeFileDownsampled(context, source)
+          } else {
+            decodeResourceByName(context, source)
+          }
+        }
+
+        "file" -> {
+          loadFileUri(context, uri)
+        }
+
+        "asset" -> {
+          decodeStream(context) { context.assets.open(schemelessPath(uri)) }
+        }
+
+        "content" -> {
+          decodeStream(context) {
+            context.contentResolver.openInputStream(uri) ?: throw FileNotFoundException(source)
+          }
+        }
+
+        "res" -> {
+          decodeResourceByName(context, schemelessPath(uri))
+        }
+
+        "data" -> {
+          decodeDataUri(context, source)
+        }
+
+        else -> {
+          Log.w(TAG, "Unsupported image URI scheme: $source")
+          null
+        }
+      }
+    } catch (_: OutOfMemoryError) {
+      Log.e(TAG, "OOM loading local image: $source")
+      null
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to load local image: $source", e)
+      null
+    }
+
+  private fun loadFileUri(
+    context: Context,
+    uri: Uri,
+  ): Bitmap? {
+    val path = uri.path ?: return null
+    return when {
+      path.startsWith(ASSET_PATH_PREFIX) -> {
+        decodeStream(context) { context.assets.open(path.removePrefix(ASSET_PATH_PREFIX)) }
+      }
+
+      path.startsWith(RES_PATH_PREFIX) -> {
+        decodeAndroidRes(context, uri)
+      }
+
+      else -> {
+        ImageDownloader.decodeFileDownsampled(context, path)
+      }
+    }
+  }
+
+  /**
+   * Resolves `file:///android_res/<dir>[-qualifier]/<file>[.<ext>]` by stripping
+   * density qualifiers and the file extension, then looking the resource up by name.
+   */
+  private fun decodeAndroidRes(
+    context: Context,
+    uri: Uri,
+  ): Bitmap? {
+    val segments = uri.pathSegments
+    if (segments.size < 3) return null
+    val directory = segments[1].substringBefore('-')
+    val name = segments[2].substringBeforeLast('.')
+    val resId = context.resources.getIdentifier(name, directory, context.packageName)
+    if (resId == 0) {
+      Log.w(TAG, "No $directory resource named: $name")
+      return null
+    }
+    return decodeStream(context) { context.resources.openRawResource(resId) }
+  }
+
+  private fun decodeResourceByName(
+    context: Context,
+    name: String,
+  ): Bitmap? {
+    if (name.isEmpty()) return null
+    val normalized = name.lowercase().replace('-', '_')
+    val resId =
+      normalized.toIntOrNull()
+        ?: context.resources.getIdentifier(normalized, "drawable", context.packageName).takeIf { it != 0 }
+        ?: context.resources.getIdentifier(normalized, "raw", context.packageName)
+    if (resId == 0) {
+      Log.w(TAG, "No drawable or raw resource named: $normalized")
+      return null
+    }
+    return decodeStream(context) { context.resources.openRawResource(resId) }
+  }
+
+  private fun decodeDataUri(
+    context: Context,
+    source: String,
+  ): Bitmap? {
+    val marker = source.indexOf(BASE64_MARKER)
+    if (marker == -1) return null
+    val bytes = Base64.decode(source.substring(marker + BASE64_MARKER.length), Base64.DEFAULT)
+    return ImageDownloader.decodeBytesDownsampled(context, bytes)
+  }
+
+  private inline fun decodeStream(
+    context: Context,
+    open: () -> InputStream,
+  ): Bitmap? = open().use { ImageDownloader.decodeBytesDownsampled(context, it.readBytes()) }
+
+  private fun schemelessPath(uri: Uri): String = (uri.host.orEmpty() + uri.path.orEmpty()).trimStart('/')
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/extensions/TextPaintExtensions.kt

@@ -7,6 +7,7 @@ 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.styles.CodeBlockStyle
 
 fun TextPaint.applyColorPreserving(
   color: Int,
@@ -51,3 +52,25 @@ fun TextPaint.applyBlockStyleFont(
   typefaceCache[cacheKey] = newTypeface
   this.typeface = newTypeface
 }
+
+/**
+ * Code block text sizing and font, shared by both flavors (CodeBlockSpan for
+ * commonmark, CodeBlockContainerView for github) so the code always renders
+ * and measures with the same paint. Color is applied by the callers: the span
+ * needs color preserving, the view colors via the text view.
+ */
+fun TextPaint.applyCodeBlockTextStyle(
+  style: CodeBlockStyle,
+  context: Context,
+) {
+  textSize = style.fontSize
+  applyBlockStyleFont(
+    BlockStyle(
+      fontSize = style.fontSize,
+      fontFamily = style.fontFamily,
+      fontWeight = style.fontWeight,
+      color = style.color,
+    ),
+    context,
+  )
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/interaction/CheckboxTouchHelper.kt

@@ -12,6 +12,12 @@ class CheckboxTouchHelper(
 ) {
   var onCheckboxTap: ((taskIndex: Int, checked: Boolean, itemText: String) -> Unit)? = null
 
+  /**
+   * When false, checkbox taps are ignored: hit-testing is skipped and no
+   * gesture is consumed, so the tap falls through to the text view unchanged.
+   */
+  var isEnabled: Boolean = true
+
   private var touchDownX = 0f
   private var touchDownY = 0f
   private var pendingHit: TaskListHitTestResult? = null
@@ -19,6 +25,7 @@ class CheckboxTouchHelper(
 
   /** Returns `true` if the event was consumed by a checkbox gesture. */
   fun onTouchEvent(event: MotionEvent): Boolean {
+    if (!isEnabled) return false
     when (event.actionMasked) {
       MotionEvent.ACTION_DOWN -> {
         val hit = TaskListTapUtils.hitTest(textView, event.x, event.y) ?: return false