react-native-enriched-markdown-scaffold 0.7.4-scaffold.8 → 1.0.2-scaffold.1

package/android/src/main/java/com/swmansion/enriched/markdown/spans/ImageSpan.kt

@@ -7,6 +7,7 @@ import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.Path
 import android.graphics.drawable.Drawable
+import android.net.Uri
 import android.os.Build
 import android.text.Spannable
 import android.text.Spanned
@@ -17,9 +18,12 @@ import androidx.core.graphics.createBitmap
 import androidx.core.graphics.drawable.toDrawable
 import androidx.core.graphics.withClip
 import androidx.core.graphics.withSave
+import com.swmansion.enriched.markdown.EnrichedMarkdown
+import com.swmansion.enriched.markdown.EnrichedMarkdownText
 import com.swmansion.enriched.markdown.styles.StyleConfig
 import com.swmansion.enriched.markdown.utils.text.ImageCache
 import com.swmansion.enriched.markdown.utils.text.ImageDownloader
+import com.swmansion.enriched.markdown.utils.text.LocalImageLoader
 import java.lang.ref.WeakReference
 import java.util.concurrent.Executors
 import android.text.style.ImageSpan as AndroidImageSpan
@@ -39,36 +43,84 @@ class ImageSpan(
   AndroidLineHeightSpan {
   private var loadedDrawable: Drawable? = null
   private val height: Int = if (isInline) styleConfig.inlineImageStyle.size.toInt() else styleConfig.imageStyle.height.toInt()
-  private val borderRadiusPx: Int = (styleConfig.imageStyle.borderRadius * context.resources.displayMetrics.density).toInt()
+
+  private val borderRadiusPx: Int = styleConfig.imageStyle.borderRadius.toInt()
+  private val maxHeightPx: Int = if (isInline) 0 else styleConfig.imageStyle.maxHeight.toInt()
+  private val aspectRatio: Float = if (isInline) 0f else styleConfig.imageStyle.aspectRatio
+  private val resizeMode: String = if (isInline) "" else styleConfig.imageStyle.resizeMode
+
+  // so legacy always implies a fixed height box.
+  private val legacySizing: Boolean = resizeMode.isEmpty()
+
+  private val dynamicBoxHeight: Boolean = !isInline && (maxHeightPx > 0 || aspectRatio > 0f)
+
+  private var boxHeight: Int =
+    when {
+      isInline -> height
+      maxHeightPx > 0 -> maxHeightPx
+      else -> height
+    }
+
+  private val requestHeaders: Map<String, String> = styleConfig.imageRequestHeaders
+  private val requestKey: String = ImageCache.requestKey(imageUrl, requestHeaders)
 
   private var cachedWidth: Int = 0
   private var viewRef: WeakReference<TextView>? = null
   private var sourceDrawable: Drawable? = null
 
+  private fun intrinsicImageSize(): Pair<Int, Int> {
+    sourceDrawable?.let { return it.intrinsicWidth to it.intrinsicHeight }
+    val cached = ImageCache.getOriginal(imageUrl) ?: return 0 to 0
+    return cached.width to cached.height
+  }
+
+  // Sizing precedence: aspectRatio > maxHeight > height. Returns the legacy fixed
+  // height when no new knob is set.
+  private fun resolveBoxHeight(targetWidth: Int): Int {
+    if (isInline) return height
+    if (aspectRatio > 0f && targetWidth > 0) {
+      return (targetWidth / aspectRatio).toInt().coerceAtLeast(1)
+    }
+    if (maxHeightPx > 0) {
+      val (intrinsicWidth, intrinsicHeight) = intrinsicImageSize()
+      if (targetWidth > 0 && intrinsicWidth > 0 && intrinsicHeight > 0) {
+        val fitted = targetWidth.toFloat() * intrinsicHeight / intrinsicWidth
+        return minOf(maxHeightPx.toFloat(), fitted).toInt().coerceAtLeast(1)
+      }
+      return maxHeightPx
+    }
+    return height
+  }
+
+  fun prepareForMeasurement(
+    text: Spanned,
+    widthPx: Int,
+  ) {
+    if (!dynamicBoxHeight || widthPx <= 0) return
+    val available = availableWidthIn(text, widthPx)
+    if (available > 0) boxHeight = resolveBoxHeight(available)
+  }
+
   init {
     loadImage()
   }
 
   private fun loadImage() {
-    if (imageUrl.startsWith("http")) {
-      ImageDownloader.download(context, imageUrl) { bitmap ->
+    val scheme = Uri.parse(imageUrl).scheme?.lowercase()
+    if (scheme == "http" || scheme == "https") {
+      ImageDownloader.download(context, imageUrl, requestHeaders) { bitmap ->
         if (bitmap != null) {
           sourceDrawable = bitmap.toDrawable(context.resources)
           wrapAndAssignDrawable()
         }
       }
     } else {
-      val path = imageUrl.removePrefix("file://")
-      try {
-        val cached = ImageCache.getOriginal(imageUrl)
-        val bitmap = cached ?: ImageDownloader.decodeFileDownsampled(context, path)
-        if (bitmap != null) {
-          if (cached == null) ImageCache.putOriginal(imageUrl, bitmap)
-          sourceDrawable = bitmap.toDrawable(context.resources)
-          wrapAndAssignDrawable()
-        }
-      } catch (e: Exception) {
-        Log.w(TAG, "Failed to load local image: $path", e)
+      val cached = ImageCache.getOriginal(imageUrl)
+      val bitmap = cached ?: LocalImageLoader.load(context, imageUrl)
+      if (bitmap != null) {
+        if (cached == null) ImageCache.putOriginal(imageUrl, bitmap)
+        sourceDrawable = bitmap.toDrawable(context.resources)
+        wrapAndAssignDrawable()
       }
     }
   }
@@ -83,21 +135,26 @@ class ImageSpan(
         available.coerceAtLeast(0)
       }
 
-    val cachedBitmap = ImageCache.getProcessed(imageUrl, targetWidth, height, borderRadiusPx)
+    boxHeight = resolveBoxHeight(targetWidth)
+
+    val cachedBitmap = ImageCache.getProcessed(requestKey, targetWidth, boxHeight, borderRadiusPx, resizeMode)
+
     if (cachedBitmap != null) {
       loadedDrawable =
         cachedBitmap.toDrawable(context.resources).apply {
-          setBounds(0, 0, targetWidth, height)
+          setBounds(0, 0, targetWidth, boxHeight)
         }
     } else {
       loadedDrawable =
         ScaledImageDrawable(
           imageDrawable = base,
           targetWidth = targetWidth,
-          targetHeight = height,
+          targetHeight = boxHeight,
           borderRadius = borderRadiusPx,
           isBlockImage = !isInline,
-          cacheKey = CacheKey(imageUrl, targetWidth, height, borderRadiusPx),
+          resizeMode = resizeMode,
+          legacySizing = legacySizing,
+          cacheKey = CacheKey(requestKey, targetWidth, boxHeight, borderRadiusPx, resizeMode),
         )
     }
     requestReflow()
@@ -116,6 +173,22 @@ class ImageSpan(
       view.invalidate()
       view.requestLayout()
     }
+    notifyBoxHeightMayHaveChanged(view)
+  }
+
+  // With maxHeight/aspectRatio the box height can change after the image loads
+  // (maxHeight fitted, aspectRatio at a late width). The React container height
+  // was measured with the pre-load value, so ask the owning component to
+  // re-measure; it only propagates when the stored height actually changed.
+  private fun notifyBoxHeightMayHaveChanged(view: TextView) {
+    if (!dynamicBoxHeight) return
+    if (view is EnrichedMarkdownText) {
+      view.layoutManager.invalidateLayout()
+      return
+    }
+    var parent = view.parent
+    while (parent != null && parent !is EnrichedMarkdown) parent = parent.parent
+    parent?.onImageLayoutChanged()
   }
 
   fun registerTextView(view: TextView) {
@@ -137,12 +210,27 @@ class ImageSpan(
     cachedWidth = newWidth
     if (sourceDrawable != null) {
       wrapAndAssignDrawable()
+      return
+    }
+    if (dynamicBoxHeight) {
+      val newBoxHeight = resolveBoxHeight(newWidth)
+      if (newBoxHeight != boxHeight) {
+        boxHeight = newBoxHeight
+        requestReflow()
+      }
     }
   }
 
   private fun getAvailableWidth(view: TextView): Int {
     val baseWidth = (view.layout?.width ?: view.width).coerceAtLeast(0)
     val text = view.text as? Spanned ?: return baseWidth
+    return availableWidthIn(text, baseWidth)
+  }
+
+  private fun availableWidthIn(
+    text: Spanned,
+    baseWidth: Int,
+  ): Int {
     val start = text.getSpanStart(this).takeIf { it >= 0 } ?: return baseWidth
     val end = text.getSpanEnd(this).coerceAtLeast(start)
     // Subtract leading margins (list bullet/indent, blockquote bar) that consume
@@ -159,7 +247,7 @@ class ImageSpan(
     val drawable = loadedDrawable ?: transparentDrawable
     if (drawable !is ScaledImageDrawable) {
       val drawableWidth = if (isInline) height else cachedWidth.takeIf { it > 0 } ?: drawable.intrinsicWidth
-      drawable.setBounds(0, 0, drawableWidth.coerceAtLeast(0), height.coerceAtLeast(0))
+      drawable.setBounds(0, 0, drawableWidth.coerceAtLeast(0), boxHeight.coerceAtLeast(0))
     }
     return drawable
   }
@@ -182,8 +270,8 @@ class ImageSpan(
   ) {
     if (fm == null || isInline) return
     val currentLineHeight = fm.descent - fm.ascent
-    if (height > currentLineHeight) {
-      val extraHeight = height - currentLineHeight
+    if (boxHeight > currentLineHeight) {
+      val extraHeight = boxHeight - currentLineHeight
       fm.descent += extraHeight
       fm.bottom += extraHeight
     }
@@ -217,6 +305,7 @@ class ImageSpan(
     val width: Int,
     val height: Int,
     val borderRadius: Int,
+    val resizeMode: String,
   )
 
   private class ScaledImageDrawable(
@@ -225,6 +314,8 @@ class ImageSpan(
     private val targetHeight: Int,
     private val borderRadius: Int,
     isBlockImage: Boolean,
+    private val resizeMode: String = "",
+    private val legacySizing: Boolean = true,
     private val cacheKey: CacheKey? = null,
   ) : Drawable() {
     private val clipPath: Path?
@@ -235,14 +326,26 @@ class ImageSpan(
       val intrinsicWidth = imageDrawable.intrinsicWidth
       val intrinsicHeight = imageDrawable.intrinsicHeight
 
+      // New sizing needs a clip to the box so cropping
+      // modes don't spill over neighbouring lines.
+      val clipToBox = isBlockImage && !legacySizing
+
       val (scaledWidth, scaledHeight) =
         if (intrinsicWidth > 0 && intrinsicHeight > 0) {
-          if (isBlockImage) {
-            val scale = targetWidth.toFloat() / intrinsicWidth
-            targetWidth to (intrinsicHeight * scale).toInt()
-          } else {
-            val scale = minOf(targetWidth.toFloat() / intrinsicWidth, targetHeight.toFloat() / intrinsicHeight)
-            (intrinsicWidth * scale).toInt() to (intrinsicHeight * scale).toInt()
+          when {
+            !isBlockImage -> {
+              val scale = minOf(targetWidth.toFloat() / intrinsicWidth, targetHeight.toFloat() / intrinsicHeight)
+              (intrinsicWidth * scale).toInt() to (intrinsicHeight * scale).toInt()
+            }
+
+            legacySizing -> {
+              val scale = targetWidth.toFloat() / intrinsicWidth
+              targetWidth to (intrinsicHeight * scale).toInt()
+            }
+
+            else -> {
+              resizeModeSize(intrinsicWidth, intrinsicHeight)
+            }
           }
         } else {
           targetWidth to targetHeight
@@ -252,26 +355,53 @@ class ImageSpan(
       val top = (targetHeight - scaledHeight) / 2
       imageDrawable.setBounds(left, top, left + scaledWidth, top + scaledHeight)
 
+      val clipLeft = maxOf(0, left).toFloat()
+      val clipTop = maxOf(0, top).toFloat()
+      val clipRight = minOf(targetWidth, left + scaledWidth).toFloat()
+      val clipBottom = minOf(targetHeight, top + scaledHeight).toFloat()
       clipPath =
-        if (borderRadius > 0) {
-          val clipLeft = maxOf(0, left).toFloat()
-          val clipTop = maxOf(0, top).toFloat()
-          val clipRight = minOf(targetWidth, left + scaledWidth).toFloat()
-          val clipBottom = minOf(targetHeight, top + scaledHeight).toFloat()
-          Path().apply {
-            addRoundRect(
-              clipLeft,
-              clipTop,
-              clipRight,
-              clipBottom,
-              borderRadius.toFloat(),
-              borderRadius.toFloat(),
-              Path.Direction.CW,
-            )
+        when {
+          borderRadius > 0 -> {
+            Path().apply {
+              addRoundRect(
+                clipLeft,
+                clipTop,
+                clipRight,
+                clipBottom,
+                borderRadius.toFloat(),
+                borderRadius.toFloat(),
+                Path.Direction.CW,
+              )
+            }
           }
-        } else {
-          null
+
+          clipToBox -> {
+            Path().apply {
+              addRect(clipLeft, clipTop, clipRight, clipBottom, Path.Direction.CW)
+            }
+          }
+
+          else -> {
+            null
+          }
+        }
+    }
+
+    private fun resizeModeSize(
+      intrinsicWidth: Int,
+      intrinsicHeight: Int,
+    ): Pair<Int, Int> {
+      if (resizeMode == "stretch") return targetWidth to targetHeight
+      val widthScale = targetWidth.toFloat() / intrinsicWidth
+      val heightScale = targetHeight.toFloat() / intrinsicHeight
+      val scale =
+        when (resizeMode) {
+          "contain" -> minOf(widthScale, heightScale)
+          "center" -> minOf(1f, minOf(widthScale, heightScale))
+          "none" -> 1f
+          else -> maxOf(widthScale, heightScale) // cover (default)
         }
+      return (intrinsicWidth * scale).toInt() to (intrinsicHeight * scale).toInt()
     }
 
     override fun draw(canvas: Canvas) {
@@ -303,7 +433,14 @@ class ImageSpan(
           } else {
             source.draw(offscreen)
           }
-          ImageCache.putProcessed(cachedKey.url, cachedKey.width, cachedKey.height, cachedKey.borderRadius, bitmap)
+          ImageCache.putProcessed(
+            cachedKey.url,
+            cachedKey.width,
+            cachedKey.height,
+            cachedKey.borderRadius,
+            cachedKey.resizeMode,
+            bitmap,
+          )
         } catch (_: OutOfMemoryError) {
           Log.e("ScaledImageDrawable", "OOM caching bitmap ${width}x$height")
         }
@@ -328,7 +465,6 @@ class ImageSpan(
   }
 
   companion object {
-    private const val TAG = "ImageSpan"
     private val transparentDrawable by lazy { Color.TRANSPARENT.toDrawable() }
     private val cacheExecutor = Executors.newSingleThreadExecutor()
   }

package/android/src/main/java/com/swmansion/enriched/markdown/spans/ListItemSpacingSpan.kt

@@ -0,0 +1,33 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Paint
+import android.text.Spanned
+import android.text.style.LineHeightSpan
+
+/**
+ * Adds vertical spacing between list items using LineHeightSpan.
+ *
+ * Attached over the newline that separates two items; extends only the line
+ * ending at that newline so the gap appears below the preceding item.
+ *
+ * @param spacing The spacing in pixels to add below the line (0 = no spacing)
+ */
+class ListItemSpacingSpan(
+  val spacing: Float,
+) : LineHeightSpan {
+  override fun chooseHeight(
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    lineHeight: Int,
+    fm: Paint.FontMetricsInt,
+  ) {
+    val spanEnd = (text as? Spanned)?.getSpanEnd(this) ?: return
+    if (end != spanEnd) return
+
+    val spacingPixels = spacing.toInt()
+    fm.descent += spacingPixels
+    fm.bottom += spacingPixels
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/spans/ListMarkerAnchorSpan.kt

@@ -0,0 +1,38 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.Layout
+import android.text.Spanned
+import android.text.style.LeadingMarginSpan
+
+// Draws a list marker on a line owned by another block (code block, nested
+// sublist) without contributing any margin of its own.
+class ListMarkerAnchorSpan(
+  internal val marker: BaseListSpan,
+) : LeadingMarginSpan {
+  override fun getLeadingMargin(first: Boolean): Int = 0
+
+  override fun drawLeadingMargin(
+    c: Canvas,
+    p: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    if (!first) return
+    if (text is Spanned && text.getSpanStart(this) != start) return
+
+    // Pass the paragraph origin: drawMarker reconstructs its offset from depth,
+    // matching the x its own span would receive on a plain text line.
+    val originX = if (dir > 0) 0 else layout?.width ?: 0
+    marker.drawMarkerAt(c, p, originX, dir, top, baseline, bottom, layout, start)
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/spans/OrderedListSpan.kt

@@ -18,6 +18,7 @@ class OrderedListSpan(
   depth: Int,
   context: Context,
   styleCache: SpanStyleCache,
+  drawsMarker: Boolean = true,
 ) : BaseListSpan(
     depth = depth,
     context = context,
@@ -31,6 +32,7 @@ class OrderedListSpan(
       ),
     marginLeft = listStyle.marginLeft,
     gapWidth = listStyle.gapWidth,
+    drawsMarker = drawsMarker,
   ) {
   companion object {
     private val sharedMarkerPaint = TextPaint().apply { isAntiAlias = true }

package/android/src/main/java/com/swmansion/enriched/markdown/spans/StrongSpan.kt

@@ -31,7 +31,7 @@ class StrongSpan(
     tp.typeface =
       if (styleCache.strongFontFamily.isNotEmpty()) {
         val resolvedStyle = if (styleCache.strongFontWeight == "normal") Typeface.NORMAL else style
-        SpanStyleCache.getTypeface(styleCache.strongFontFamily, resolvedStyle)
+        styleCache.getTypeface(styleCache.strongFontFamily, resolvedStyle)
       } else {
         Typeface.create(currentTypeface, style)
       }

package/android/src/main/java/com/swmansion/enriched/markdown/spans/TaskListSpan.kt

@@ -19,6 +19,7 @@ class TaskListSpan(
   styleCache: SpanStyleCache,
   val taskIndex: Int,
   val isChecked: Boolean,
+  drawsMarker: Boolean = true,
 ) : BaseListSpan(
     depth = depth,
     context = context,
@@ -32,6 +33,7 @@ class TaskListSpan(
       ),
     marginLeft = listStyle.marginLeft,
     gapWidth = listStyle.gapWidth,
+    drawsMarker = drawsMarker,
   ) {
   private val checkboxSize = taskStyle.checkboxSize
   private val markerColumnWidth = listStyle.effectiveMarkerWidth(checkboxSize)
@@ -69,8 +71,7 @@ class TaskListSpan(
     layout: Layout?,
     start: Int,
   ) {
-    val fontMetrics = paint.fontMetrics
-    val capHeight = -fontMetrics.ascent * CAP_HEIGHT_RATIO
+    val capHeight = -markerFontMetrics.ascent * CAP_HEIGHT_RATIO
     val centerY = baseline - capHeight / HALF_DIVISOR
     // Right-align the checkbox inside the reserved marker column so it hugs
     // the gap before the text. At the default (markerColumnWidth ==

package/android/src/main/java/com/swmansion/enriched/markdown/spans/UnorderedListSpan.kt

@@ -13,6 +13,7 @@ class UnorderedListSpan(
   depth: Int,
   context: Context,
   styleCache: SpanStyleCache,
+  drawsMarker: Boolean = true,
 ) : BaseListSpan(
     depth = depth,
     context = context,
@@ -26,6 +27,7 @@ class UnorderedListSpan(
       ),
     marginLeft = listStyle.marginLeft,
     gapWidth = listStyle.gapWidth,
+    drawsMarker = drawsMarker,
   ) {
   companion object {
     private val sharedBulletPaint =
@@ -64,8 +66,7 @@ class UnorderedListSpan(
     // visually flush-left when the column width equals the bullet radius
     // (the default).
     val bulletX = x + (depth * marginLeft + markerColumnWidth) * dir
-    val fontMetrics = paint.fontMetrics
-    val bulletY = baseline + (fontMetrics.ascent + fontMetrics.descent) / 2f
+    val bulletY = baseline + (markerFontMetrics.ascent + markerFontMetrics.descent) / 2f
 
     when (depth) {
       0 -> {

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

@@ -14,6 +14,8 @@ data class BlockquoteStyle(
   val borderWidth: Float,
   val gapWidth: Float,
   val backgroundColor: Int?,
+  val borderRadius: Float,
+  val padding: Float,
 ) : BaseBlockStyle {
   companion object {
     fun fromReadableMap(
@@ -32,6 +34,8 @@ data class BlockquoteStyle(
       val borderWidth = parser.toPixelFromDIP(map.getDouble("borderWidth").toFloat())
       val gapWidth = parser.toPixelFromDIP(map.getDouble("gapWidth").toFloat())
       val backgroundColor = parser.parseOptionalColor(map, "backgroundColor")
+      val borderRadius = parser.toPixelFromDIP(map.getDouble("borderRadius").toFloat())
+      val padding = parser.toPixelFromDIP(map.getDouble("padding").toFloat())
 
       return BlockquoteStyle(
         fontSize,
@@ -45,6 +49,8 @@ data class BlockquoteStyle(
         borderWidth,
         gapWidth,
         backgroundColor,
+        borderRadius,
+        padding,
       )
     }
   }

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

@@ -15,8 +15,27 @@ data class CodeBlockStyle(
   val borderRadius: Float,
   val borderWidth: Float,
   val padding: Float,
+  val syntaxColors: List<Int>,
 ) : BaseBlockStyle {
   companion object {
+    private val SYNTAX_COLOR_KEYS =
+      listOf(
+        "keyword",
+        "operatorColor",
+        "punctuation",
+        "string",
+        "number",
+        "constant",
+        "comment",
+        "function",
+        "type",
+        "variable",
+        "property",
+        "tag",
+        "attribute",
+        "embedded",
+      )
+
     fun fromReadableMap(
       map: ReadableMap,
       parser: StyleParser,
@@ -35,6 +54,12 @@ data class CodeBlockStyle(
       val borderWidth = parser.toPixelFromDIP(map.getDouble("borderWidth").toFloat())
       val padding = parser.toPixelFromDIP(map.getDouble("padding").toFloat())
 
+      val syntaxMap = map.getMap("syntaxColors")
+      val syntaxColors =
+        SYNTAX_COLOR_KEYS.map { key ->
+          syntaxMap?.let { parser.parseOptionalColor(it, key) } ?: color
+        }
+
       return CodeBlockStyle(
         fontSize,
         fontFamily,
@@ -48,6 +73,7 @@ data class CodeBlockStyle(
         borderRadius,
         borderWidth,
         padding,
+        syntaxColors,
       )
     }
   }

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

@@ -4,6 +4,9 @@ import com.facebook.react.bridge.ReadableMap
 
 data class ImageStyle(
   val height: Float,
+  val maxHeight: Float,
+  val aspectRatio: Float,
+  val resizeMode: String,
   val borderRadius: Float,
   val marginTop: Float,
   val marginBottom: Float,
@@ -14,10 +17,13 @@ data class ImageStyle(
       parser: StyleParser,
     ): ImageStyle {
       val height = parser.toPixelFromDIP(map.getDouble("height").toFloat())
+      val maxHeight = parser.toPixelFromDIP(map.getDouble("maxHeight").toFloat())
+      val aspectRatio = map.getDouble("aspectRatio").toFloat()
+      val resizeMode = map.getString("resizeMode") ?: ""
       val borderRadius = parser.toPixelFromDIP(map.getDouble("borderRadius").toFloat())
       val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
       val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
-      return ImageStyle(height, borderRadius, marginTop, marginBottom)
+      return ImageStyle(height, maxHeight, aspectRatio, resizeMode, borderRadius, marginTop, marginBottom)
     }
   }
 }

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

@@ -17,6 +17,7 @@ data class ListStyle(
   val markerFontWeight: String,
   val gapWidth: Float,
   val marginLeft: Float,
+  val itemSpacing: Float,
 ) : BaseBlockStyle {
   fun effectiveMarkerWidth(naturalWidth: Float): Float = naturalWidth.coerceAtLeast(markerMinWidth)
 
@@ -34,12 +35,13 @@ data class ListStyle(
       val lineHeightRaw = map.getDouble("lineHeight").toFloat()
       val lineHeight = parser.toPixelFromSP(lineHeightRaw)
       val bulletColor = parser.parseColor(map, "bulletColor")
-      val bulletSize = parser.toPixelFromDIP(map.getDouble("bulletSize").toFloat())
+      val bulletSize = parser.toPixelFromSP(map.getDouble("bulletSize").toFloat())
       val markerMinWidth = parser.toPixelFromDIP(map.getDouble("markerMinWidth").toFloat().coerceAtLeast(0f))
       val markerColor = parser.parseColor(map, "markerColor")
       val markerFontWeight = parser.parseString(map, "markerFontWeight", "normal")
       val gapWidth = parser.toPixelFromDIP(map.getDouble("gapWidth").toFloat())
       val marginLeft = parser.toPixelFromDIP(map.getDouble("marginLeft").toFloat())
+      val itemSpacing = parser.toPixelFromDIP(map.getDouble("itemSpacing").toFloat().coerceAtLeast(0f))
 
       return ListStyle(
         fontSize,
@@ -56,6 +58,7 @@ data class ListStyle(
         markerFontWeight,
         gapWidth,
         marginLeft,
+        itemSpacing,
       )
     }
   }