react-native-enriched-markdown 0.1.0 → 0.1.1

package/android/src/main/java/com/swmansion/enriched/markdown/styles/ParagraphStyle.kt

@@ -0,0 +1,29 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class ParagraphStyle(
+  override val fontSize: Float,
+  override val fontFamily: String,
+  override val fontWeight: String,
+  override val color: Int,
+  override val marginBottom: Float,
+  override val lineHeight: Float,
+) : BaseBlockStyle {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): ParagraphStyle {
+      val fontSize = parser.toPixelFromSP(map.getDouble("fontSize").toFloat())
+      val fontFamily = parser.parseString(map, "fontFamily")
+      val fontWeight = parser.parseString(map, "fontWeight", "normal")
+      val color = parser.parseColor(map, "color")
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      val lineHeightRaw = map.getDouble("lineHeight").toFloat()
+      val lineHeight = parser.toPixelFromSP(lineHeightRaw)
+
+      return ParagraphStyle(fontSize, fontFamily, fontWeight, color, marginBottom, lineHeight)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/styles/StrongStyle.kt

@@ -0,0 +1,17 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class StrongStyle(
+  val color: Int?,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): StrongStyle {
+      val color = parser.parseOptionalColor(map, "color")
+      return StrongStyle(color)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/styles/StyleConfig.kt

@@ -0,0 +1,180 @@
+package com.swmansion.enriched.markdown.styles
+
+import android.content.Context
+import android.content.res.AssetManager
+import android.graphics.Typeface
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.views.text.ReactTypefaceUtils.applyStyles
+import com.facebook.react.views.text.ReactTypefaceUtils.parseFontWeight
+
+/**
+ * Main style configuration class that parses and caches all markdown element styles.
+ * Uses lazy initialization to defer parsing until styles are actually needed,
+ * improving startup time for documents that don't use all markdown features.
+ */
+class StyleConfig(
+  private val style: ReadableMap,
+  context: Context,
+) {
+  private val styleParser = StyleParser(context)
+  private val assets: AssetManager = context.assets
+
+  val paragraphStyle: ParagraphStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("paragraph")) {
+        "Paragraph style not found. JS should always provide defaults."
+      }
+    ParagraphStyle.fromReadableMap(map, styleParser)
+  }
+
+  val headingStyles: Array<HeadingStyle?> by lazy {
+    Array(7) { index ->
+      if (index == 0) {
+        null
+      } else {
+        val levelKey = "h$index"
+        val map =
+          requireNotNull(style.getMap(levelKey)) {
+            "Style for $levelKey not found. JS should always provide defaults."
+          }
+        HeadingStyle.fromReadableMap(map, styleParser)
+      }
+    }
+  }
+
+  // Cache typefaces for heading levels (1-6) - lazily initialized after headingStyles
+  // Uses React Native's applyStyles to properly load custom fonts from assets
+  val headingTypefaces: Array<Typeface?> by lazy {
+    Array(7) { level ->
+      if (level == 0) {
+        null
+      } else {
+        val headingStyle = headingStyles[level]
+        val fontFamily = headingStyle?.fontFamily?.takeIf { it.isNotEmpty() }
+        val fontWeight = parseFontWeight(headingStyle?.fontWeight)
+
+        if (fontFamily != null) {
+          // Use applyStyles with null base typeface to load from assets via ReactFontManager
+          applyStyles(null, ReactConstants.UNSET, fontWeight, fontFamily, assets)
+        } else {
+          null
+        }
+      }
+    }
+  }
+
+  val linkStyle: LinkStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("link")) {
+        "Link style not found. JS should always provide defaults."
+      }
+    LinkStyle.fromReadableMap(map, styleParser)
+  }
+
+  val strongStyle: StrongStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("strong")) {
+        "Strong style not found. JS should always provide defaults."
+      }
+    StrongStyle.fromReadableMap(map, styleParser)
+  }
+
+  val emphasisStyle: EmphasisStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("em")) {
+        "Emphasis style not found. JS should always provide defaults."
+      }
+    EmphasisStyle.fromReadableMap(map, styleParser)
+  }
+
+  val codeStyle: CodeStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("code")) {
+        "Code style not found. JS should always provide defaults."
+      }
+    CodeStyle.fromReadableMap(map, styleParser)
+  }
+
+  val imageStyle: ImageStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("image")) {
+        "Image style not found. JS should always provide defaults."
+      }
+    ImageStyle.fromReadableMap(map, styleParser)
+  }
+
+  val inlineImageStyle: InlineImageStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("inlineImage")) {
+        "InlineImage style not found. JS should always provide defaults."
+      }
+    InlineImageStyle.fromReadableMap(map, styleParser)
+  }
+
+  val blockquoteStyle: BlockquoteStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("blockquote")) {
+        "Blockquote style not found. JS should always provide defaults."
+      }
+    BlockquoteStyle.fromReadableMap(map, styleParser)
+  }
+
+  val listStyle: ListStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("list")) {
+        "List style not found. JS should always provide defaults."
+      }
+    ListStyle.fromReadableMap(map, styleParser)
+  }
+
+  val codeBlockStyle: CodeBlockStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("codeBlock")) {
+        "CodeBlock style not found. JS should always provide defaults."
+      }
+    CodeBlockStyle.fromReadableMap(map, styleParser)
+  }
+
+  val thematicBreakStyle: ThematicBreakStyle by lazy {
+    val map =
+      requireNotNull(style.getMap("thematicBreak")) {
+        "ThematicBreak style not found. JS should always provide defaults."
+      }
+    ThematicBreakStyle.fromReadableMap(map, styleParser)
+  }
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is StyleConfig) return false
+
+    return paragraphStyle == other.paragraphStyle &&
+      headingStyles.contentEquals(other.headingStyles) &&
+      linkStyle == other.linkStyle &&
+      strongStyle == other.strongStyle &&
+      emphasisStyle == other.emphasisStyle &&
+      codeStyle == other.codeStyle &&
+      imageStyle == other.imageStyle &&
+      inlineImageStyle == other.inlineImageStyle &&
+      blockquoteStyle == other.blockquoteStyle &&
+      listStyle == other.listStyle &&
+      codeBlockStyle == other.codeBlockStyle &&
+      thematicBreakStyle == other.thematicBreakStyle
+  }
+
+  override fun hashCode(): Int {
+    var result = paragraphStyle.hashCode()
+    result = 31 * result + headingStyles.contentHashCode()
+    result = 31 * result + linkStyle.hashCode()
+    result = 31 * result + strongStyle.hashCode()
+    result = 31 * result + emphasisStyle.hashCode()
+    result = 31 * result + codeStyle.hashCode()
+    result = 31 * result + imageStyle.hashCode()
+    result = 31 * result + inlineImageStyle.hashCode()
+    result = 31 * result + blockquoteStyle.hashCode()
+    result = 31 * result + listStyle.hashCode()
+    result = 31 * result + codeBlockStyle.hashCode()
+    result = 31 * result + thematicBreakStyle.hashCode()
+    return result
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/styles/StyleParser.kt

@@ -0,0 +1,75 @@
+package com.swmansion.enriched.markdown.styles
+
+import android.content.Context
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.PixelUtil
+
+/**
+ * Helper class for parsing style values from ReadableMap.
+ * Provides common parsing utilities used by all style factory functions.
+ */
+class StyleParser(
+  private val context: Context,
+) {
+  fun parseOptionalColor(
+    map: ReadableMap,
+    key: String,
+  ): Int? {
+    if (!map.hasKey(key) || map.isNull(key)) {
+      return null
+    }
+    val colorValue = map.getDouble(key)
+    return ColorPropConverter.getColor(colorValue, context)
+  }
+
+  fun parseColor(
+    map: ReadableMap,
+    key: String,
+  ): Int =
+    parseOptionalColor(map, key)
+      ?: throw IllegalArgumentException("Color key '$key' is missing, null, or invalid")
+
+  fun parseOptionalDouble(
+    map: ReadableMap,
+    key: String,
+    default: Double = 0.0,
+  ): Double =
+    if (map.hasKey(key) && !map.isNull(key)) {
+      map.getDouble(key)
+    } else {
+      default
+    }
+
+  fun parseOptionalInt(
+    map: ReadableMap,
+    key: String,
+    default: Int = 0,
+  ): Int =
+    if (map.hasKey(key) && !map.isNull(key)) {
+      map.getInt(key)
+    } else {
+      default
+    }
+
+  fun parseString(
+    map: ReadableMap,
+    key: String,
+    default: String = "",
+  ): String = map.getString(key) ?: default
+
+  fun parseBoolean(
+    map: ReadableMap,
+    key: String,
+    default: Boolean = false,
+  ): Boolean =
+    if (map.hasKey(key) && !map.isNull(key)) {
+      map.getBoolean(key)
+    } else {
+      default
+    }
+
+  fun toPixelFromSP(value: Float): Float = PixelUtil.toPixelFromSP(value)
+
+  fun toPixelFromDIP(value: Float): Float = PixelUtil.toPixelFromDIP(value)
+}

package/android/src/main/java/com/swmansion/enriched/markdown/styles/ThematicBreakStyle.kt

@@ -0,0 +1,23 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class ThematicBreakStyle(
+  val color: Int,
+  val height: Float,
+  val marginTop: Float,
+  val marginBottom: Float,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): ThematicBreakStyle {
+      val color = parser.parseColor(map, "color")
+      val height = parser.toPixelFromDIP(map.getDouble("height").toFloat())
+      val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      return ThematicBreakStyle(color, height, marginTop, marginBottom)
+    }
+  }
+}

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

@@ -0,0 +1,91 @@
+package com.swmansion.enriched.markdown.utils
+
+import android.content.res.Resources
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.drawable.Drawable
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.core.graphics.drawable.toDrawable
+import java.net.URL
+import java.util.concurrent.Executors
+
+/**
+ * Custom Drawable that loads images asynchronously from URLs.
+ */
+class AsyncDrawable(
+  private val url: String,
+) : Drawable() {
+  // 1. Use a shared companion executor to avoid thread leakage per instance
+  companion object {
+    private val sharedExecutor = Executors.newFixedThreadPool(4)
+    private val mainHandler = Handler(Looper.getMainLooper())
+  }
+
+  var internalDrawable: Drawable = Color.TRANSPARENT.toDrawable()
+
+  // 2. Track loading state more granularly
+  var isLoaded = false
+    private set
+
+  var onLoaded: (() -> Unit)? = null
+
+  init {
+    load()
+  }
+
+  private fun load() {
+    sharedExecutor.execute {
+      try {
+        // 3. Proper Resource Management: Use 'use' to close the stream automatically
+        val bitmap =
+          URL(url).openStream().use {
+            BitmapFactory.decodeStream(it)
+          }
+
+        mainHandler.post {
+          bitmap?.let {
+            val drawable = it.toDrawable(Resources.getSystem())
+            drawable.bounds = bounds
+            internalDrawable = drawable
+          }
+          isLoaded = true
+          onLoaded?.invoke()
+          invalidateSelf() // 4. Critical: Tell the system to redraw
+        }
+      } catch (e: Exception) {
+        Log.e("AsyncDrawable", "Failed to load image from: $url", e)
+        mainHandler.post {
+          isLoaded = true
+          onLoaded?.invoke()
+        }
+      }
+    }
+  }
+
+  override fun draw(canvas: Canvas) = internalDrawable.draw(canvas)
+
+  override fun setAlpha(alpha: Int) {
+    internalDrawable.alpha = alpha
+  }
+
+  override fun setColorFilter(colorFilter: ColorFilter?) {
+    internalDrawable.colorFilter = colorFilter
+  }
+
+  @Deprecated("Deprecated in Java")
+  override fun getOpacity(): Int = internalDrawable.opacity
+
+  override fun setBounds(
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int,
+  ) {
+    super.setBounds(left, top, right, bottom)
+    internalDrawable.setBounds(left, top, right, bottom)
+  }
+}