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

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

@@ -0,0 +1,184 @@
+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.uimanager.PixelUtil
+import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
+import com.swmansion.enriched.markdown.input.model.InputLinkVariantStyle
+import com.swmansion.enriched.markdown.input.model.MathBlockStyle
+import com.swmansion.enriched.markdown.input.model.MathChipStyle
+
+object MarkdownStyleParser {
+  fun parse(map: ReadableMap): InputFormatterStyle {
+    val strongMap = map.getMap("strong")
+    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 math = parseMathStyle(mathMap)
+    val mathBlock = parseMathBlockStyle(mathBlockMap, math)
+
+    return InputFormatterStyle(
+      boldColor = if (strongMap?.hasKey("color") == true) strongMap.getInt("color") else null,
+      italicColor = if (emMap?.hasKey("color") == true) emMap.getInt("color") else null,
+      linkColor = linkMap!!.getInt("color"),
+      linkUnderline = linkMap.getBoolean("underline"),
+      linkBackgroundColor = linkMap.getInt("backgroundColor"),
+      linkVariants = parseLinkVariants(map),
+      spoilerColor = spoilerMap!!.getInt("color"),
+      spoilerBackgroundColor = spoilerMap.getInt("backgroundColor"),
+      math = math,
+      mathBlock = mathBlock,
+    )
+  }
+
+  private fun parseLinkVariants(map: ReadableMap): List<InputLinkVariantStyle> {
+    if (!map.hasKey("linkVariants")) return emptyList()
+    val variants = map.getArray("linkVariants") ?: return emptyList()
+    return (0 until variants.size()).mapNotNull { index ->
+      val variant = variants.getMap(index) ?: return@mapNotNull null
+      InputLinkVariantStyle(
+        pattern = variant.getString("pattern") ?: return@mapNotNull null,
+        color = variant.getInt("color"),
+        underline = variant.getBoolean("underline"),
+        backgroundColor = variant.getInt("backgroundColor"),
+      )
+    }
+  }
+
+  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
+    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
+    val borderWidth =
+      PixelUtil.toPixelFromDIP(
+        if (mathMap?.hasKey("borderWidth") == true) mathMap.getDouble("borderWidth").toFloat() else 0f,
+      )
+    val borderRadius =
+      PixelUtil.toPixelFromDIP(
+        if (mathMap?.hasKey("borderRadius") == true) mathMap.getDouble("borderRadius").toFloat() else 0f,
+      )
+    val paddingHorizontal =
+      PixelUtil.toPixelFromDIP(
+        if (mathMap?.hasKey("paddingHorizontal") == true) mathMap.getDouble("paddingHorizontal").toFloat() else 0f,
+      )
+    val paddingVertical =
+      PixelUtil.toPixelFromDIP(
+        if (mathMap?.hasKey("paddingVertical") == true) mathMap.getDouble("paddingVertical").toFloat() else 0f,
+      )
+    val selectedBackgroundColor =
+      if (mathMap?.hasKey("selectedBackgroundColor") == true) mathMap.getInt("selectedBackgroundColor") else null
+    val selectedBorderColor =
+      if (mathMap?.hasKey("selectedBorderColor") == true) mathMap.getInt("selectedBorderColor") else null
+
+    return MathChipStyle(
+      color = color,
+      fontSize = fontSize,
+      backgroundColor = nullIfTransparent(backgroundColor),
+      borderColor = nullIfTransparent(borderColor),
+      borderWidth = borderWidth,
+      borderRadius = borderRadius,
+      paddingHorizontal = paddingHorizontal,
+      paddingVertical = paddingVertical,
+      selectedBackgroundColor = nullIfTransparent(selectedBackgroundColor),
+      selectedBorderColor = nullIfTransparent(selectedBorderColor),
+    )
+  }
+
+  private fun parseMathBlockStyle(
+    mathBlockMap: ReadableMap?,
+    inlineFallback: MathChipStyle,
+  ): MathChipStyle {
+    val color = if (mathBlockMap?.hasKey("color") == true) mathBlockMap.getInt("color") else inlineFallback.color
+    val fontSizeSp =
+      if (mathBlockMap?.hasKey("fontSize") == true) mathBlockMap.getDouble("fontSize").toFloat() else 20f
+    val fontSize = PixelUtil.toPixelFromSP(fontSizeSp)
+    val backgroundColor =
+      if (mathBlockMap?.hasKey("backgroundColor") == true) {
+        mathBlockMap.getInt("backgroundColor")
+      } else {
+        inlineFallback.backgroundColor
+      }
+    val borderColor =
+      if (mathBlockMap?.hasKey("borderColor") == true) {
+        mathBlockMap.getInt("borderColor")
+      } else {
+        inlineFallback.borderColor
+      }
+    val borderWidth =
+      if (mathBlockMap?.hasKey("borderWidth") == true) {
+        PixelUtil.toPixelFromDIP(mathBlockMap.getDouble("borderWidth").toFloat())
+      } else {
+        inlineFallback.borderWidth
+      }
+    val borderRadius =
+      if (mathBlockMap?.hasKey("borderRadius") == true) {
+        PixelUtil.toPixelFromDIP(mathBlockMap.getDouble("borderRadius").toFloat())
+      } else {
+        inlineFallback.borderRadius
+      }
+    val paddingHorizontal =
+      PixelUtil.toPixelFromDIP(
+        if (mathBlockMap?.hasKey("paddingHorizontal") == true) mathBlockMap.getDouble("paddingHorizontal").toFloat() else 12f,
+      )
+    val paddingVertical =
+      PixelUtil.toPixelFromDIP(
+        if (mathBlockMap?.hasKey("paddingVertical") == true) mathBlockMap.getDouble("paddingVertical").toFloat() else 8f,
+      )
+    val selectedBackgroundColor =
+      if (mathBlockMap?.hasKey("selectedBackgroundColor") == true) {
+        mathBlockMap.getInt("selectedBackgroundColor")
+      } else {
+        inlineFallback.selectedBackgroundColor
+      }
+    val selectedBorderColor =
+      if (mathBlockMap?.hasKey("selectedBorderColor") == true) {
+        mathBlockMap.getInt("selectedBorderColor")
+      } else {
+        inlineFallback.selectedBorderColor
+      }
+    val marginTop =
+      PixelUtil.toPixelFromDIP(
+        if (mathBlockMap?.hasKey("marginTop") == true) mathBlockMap.getDouble("marginTop").toFloat() else 8f,
+      )
+    val marginBottom =
+      PixelUtil.toPixelFromDIP(
+        if (mathBlockMap?.hasKey("marginBottom") == true) mathBlockMap.getDouble("marginBottom").toFloat() else 8f,
+      )
+    val alignmentRaw = if (mathBlockMap?.hasKey("alignment") == true) mathBlockMap.getString("alignment") else null
+    val alignment =
+      when (alignmentRaw) {
+        "left" -> Layout.Alignment.ALIGN_NORMAL
+        "right" -> Layout.Alignment.ALIGN_OPPOSITE
+        else -> Layout.Alignment.ALIGN_CENTER
+      }
+
+    return MathBlockStyle(
+      color = color,
+      fontSize = fontSize,
+      backgroundColor = nullIfTransparent(backgroundColor),
+      borderColor = nullIfTransparent(borderColor),
+      borderWidth = borderWidth,
+      borderRadius = borderRadius,
+      paddingHorizontal = paddingHorizontal,
+      paddingVertical = paddingVertical,
+      selectedBackgroundColor = nullIfTransparent(selectedBackgroundColor),
+      selectedBorderColor = nullIfTransparent(selectedBorderColor),
+      marginTop = marginTop,
+      marginBottom = marginBottom,
+      alignment = alignment,
+    )
+  }
+
+  private fun nullIfTransparent(color: Int?): Int? {
+    if (color == null) return null
+    if (Color.alpha(color) == 0) return null
+    return color
+  }
+}

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

@@ -0,0 +1,53 @@
+package com.swmansion.enriched.markdown.utils.text
+
+import android.graphics.Bitmap
+import android.util.LruCache
+
+object ImageCache {
+  private const val ORIGINAL_CACHE_SIZE = 20 * 1024 * 1024
+  private const val PROCESSED_CACHE_SIZE = 30 * 1024 * 1024
+
+  private val originalCache = bitmapLruCache(ORIGINAL_CACHE_SIZE)
+  private val processedCache = bitmapLruCache(PROCESSED_CACHE_SIZE)
+
+  fun getOriginal(url: String): Bitmap? = originalCache.get(url)
+
+  fun putOriginal(
+    url: String,
+    bitmap: Bitmap,
+  ) {
+    originalCache.put(url, bitmap)
+  }
+
+  fun getProcessed(
+    url: String,
+    width: Int,
+    height: Int,
+    borderRadius: Int,
+  ): Bitmap? = processedCache.get(processedKey(url, width, height, borderRadius))
+
+  fun putProcessed(
+    url: String,
+    width: Int,
+    height: Int,
+    borderRadius: Int,
+    bitmap: Bitmap,
+  ) {
+    processedCache.put(processedKey(url, width, height, borderRadius), bitmap)
+  }
+
+  private fun processedKey(
+    url: String,
+    width: Int,
+    height: Int,
+    borderRadius: Int,
+  ): String = "${url}_w${width}_h${height}_r$borderRadius"
+
+  private fun bitmapLruCache(maxSize: Int): LruCache<String, Bitmap> =
+    object : LruCache<String, Bitmap>(maxSize) {
+      override fun sizeOf(
+        key: String,
+        value: Bitmap,
+      ): Int = value.byteCount
+    }
+}

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

@@ -0,0 +1,156 @@
+package com.swmansion.enriched.markdown.utils.text
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import okhttp3.Cache
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import java.io.File
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+
+object ImageDownloader {
+  private const val TAG = "ImageDownloader"
+  private const val DISK_CACHE_SIZE = 100L * 1024 * 1024
+  private const val TIMEOUT = 15L
+
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  @Volatile
+  private var client: OkHttpClient? = null
+  private var maxTargetWidth: Int = 0
+
+  private val inFlight = HashMap<String, MutableList<(Bitmap?) -> Unit>>()
+
+  private fun getClient(context: Context): OkHttpClient =
+    client ?: synchronized(this) {
+      client ?: buildClient(context).also {
+        client = it
+        maxTargetWidth = context.applicationContext.resources.displayMetrics.widthPixels
+      }
+    }
+
+  private fun buildClient(context: Context): OkHttpClient {
+    val cacheDir = File(context.applicationContext.cacheDir, "enrm_image_cache")
+    return OkHttpClient
+      .Builder()
+      .cache(Cache(cacheDir, DISK_CACHE_SIZE))
+      .connectTimeout(TIMEOUT, TimeUnit.SECONDS)
+      .readTimeout(TIMEOUT, TimeUnit.SECONDS)
+      .build()
+  }
+
+  fun download(
+    context: Context,
+    url: String,
+    callback: (Bitmap?) -> Unit,
+  ) {
+    ImageCache.getOriginal(url)?.let {
+      callback(it)
+      return
+    }
+
+    synchronized(inFlight) {
+      val existing = inFlight[url]
+      if (existing != null) {
+        existing.add(callback)
+        return
+      }
+      inFlight[url] = mutableListOf(callback)
+    }
+
+    val request = Request.Builder().url(url).build()
+    getClient(context).newCall(request).enqueue(
+      object : Callback {
+        override fun onResponse(
+          call: Call,
+          response: Response,
+        ) {
+          val bitmap =
+            response.use {
+              try {
+                val bytes = it.body?.bytes() ?: return@use null
+                decodeDownsampled(bytes, maxTargetWidth)
+              } catch (_: OutOfMemoryError) {
+                Log.e(TAG, "OOM decoding image: $url")
+                null
+              } catch (e: Exception) {
+                Log.e(TAG, "Failed to decode image: $url", e)
+                null
+              }
+            }
+
+          bitmap?.let { ImageCache.putOriginal(url, it) }
+          dispatchCallbacks(url, bitmap)
+        }
+
+        override fun onFailure(
+          call: Call,
+          e: IOException,
+        ) {
+          Log.e(TAG, "Failed to download image: $url", e)
+          dispatchCallbacks(url, null)
+        }
+      },
+    )
+  }
+
+  private fun decodeDownsampled(
+    bytes: ByteArray,
+    targetWidth: Int,
+  ): Bitmap? {
+    val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeByteArray(bytes, 0, bytes.size, opts)
+    return decodeWithSampleSize(opts, targetWidth) {
+      BitmapFactory.decodeByteArray(bytes, 0, bytes.size, it)
+    }
+  }
+
+  fun decodeFileDownsampled(
+    context: Context,
+    path: String,
+  ): Bitmap? {
+    val targetWidth = context.resources.displayMetrics.widthPixels
+    val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeFile(path, opts)
+    return decodeWithSampleSize(opts, targetWidth) {
+      BitmapFactory.decodeFile(path, it)
+    }
+  }
+
+  private inline fun decodeWithSampleSize(
+    opts: BitmapFactory.Options,
+    targetWidth: Int,
+    decode: (BitmapFactory.Options) -> Bitmap?,
+  ): Bitmap? {
+    if (opts.outWidth <= 0 || opts.outHeight <= 0) return null
+    opts.inSampleSize = calculateInSampleSize(opts.outWidth, targetWidth)
+    opts.inJustDecodeBounds = false
+    return decode(opts)
+  }
+
+  private fun calculateInSampleSize(
+    srcWidth: Int,
+    reqWidth: Int,
+  ): Int {
+    if (srcWidth in 0..reqWidth) return 1
+    return Integer.highestOneBit(srcWidth / reqWidth)
+  }
+
+  private fun dispatchCallbacks(
+    url: String,
+    bitmap: Bitmap?,
+  ) {
+    val callbacks = synchronized(inFlight) { inFlight.remove(url) } ?: return
+    mainHandler.post {
+      callbacks.forEach { it(bitmap) }
+    }
+  }
+}

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

@@ -0,0 +1,84 @@
+package com.swmansion.enriched.markdown.utils.text
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.ValueAnimator
+import android.text.Spannable
+import android.view.animation.LinearInterpolator
+import android.widget.TextView
+import com.swmansion.enriched.markdown.spans.FadeInSpan
+import com.swmansion.enriched.markdown.utils.common.isReducedMotionEnabled
+import java.lang.ref.WeakReference
+
+class TailFadeInAnimator(
+  textView: TextView,
+) {
+  private val viewRef = WeakReference(textView)
+
+  private val activeAnimations = mutableMapOf<FadeInSpan, ValueAnimator>()
+
+  fun animate(
+    tailStart: Int,
+    tailEnd: Int,
+  ) {
+    if (tailEnd <= tailStart) return
+
+    val textView = viewRef.get() ?: return
+    val spannable = textView.text as? Spannable ?: return
+
+    if (isReducedMotionEnabled(textView.context)) return
+
+    val fadeSpan = FadeInSpan().apply { alpha = 0f }
+    spannable.setSpan(fadeSpan, tailStart, tailEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+
+    val animator =
+      ValueAnimator.ofFloat(0f, 1f).apply {
+        duration = FADE_DURATION_MS
+        interpolator = LinearInterpolator()
+
+        addUpdateListener { anim ->
+          fadeSpan.alpha = anim.animatedValue as Float
+          val tv = viewRef.get() ?: return@addUpdateListener
+          val currentSpannable = tv.text as? Spannable ?: return@addUpdateListener
+
+          val end = minOf(tailEnd, currentSpannable.length)
+          if (end > tailStart) {
+            currentSpannable.setSpan(fadeSpan, tailStart, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+          }
+          tv.invalidate()
+        }
+
+        addListener(
+          object : AnimatorListenerAdapter() {
+            override fun onAnimationEnd(animation: Animator) {
+              cleanup(fadeSpan)
+            }
+
+            override fun onAnimationCancel(animation: Animator) {
+              cleanup(fadeSpan)
+            }
+          },
+        )
+      }
+
+    activeAnimations[fadeSpan] = animator
+    animator.start()
+  }
+
+  private fun cleanup(span: FadeInSpan) {
+    activeAnimations.remove(span)
+    val spannable = viewRef.get()?.text as? Spannable ?: return
+    span.alpha = 1f
+    spannable.removeSpan(span)
+  }
+
+  fun cancelAll() {
+    val spans = activeAnimations.keys.toList()
+    spans.forEach { activeAnimations[it]?.cancel() }
+    activeAnimations.clear()
+  }
+
+  companion object {
+    private const val FADE_DURATION_MS = 150L
+  }
+}