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

package/android/src/main/java/com/swmansion/enriched/markdown/spoiler/SpoilerOverlayDrawer.kt

@@ -0,0 +1,152 @@
+package com.swmansion.enriched.markdown.spoiler
+
+import android.graphics.Canvas
+import android.text.Spanned
+import android.widget.TextView
+import com.swmansion.enriched.markdown.spans.SpoilerSpan
+import com.swmansion.enriched.markdown.styles.SpoilerStyle
+import java.lang.ref.WeakReference
+
+class SpoilerOverlayDrawer(
+  textView: TextView,
+) {
+  private val textViewReference = WeakReference(textView)
+  val animator = SpoilerAnimator(textView)
+
+  private var strategy: SpoilerStrategy = createStrategy(SpoilerOverlay.PARTICLES)
+  private var currentMode: SpoilerOverlay = SpoilerOverlay.PARTICLES
+
+  private val activeKeys = mutableSetOf<SegmentKey>()
+
+  private var cachedStyle: SpoilerStyle? = null
+
+  var spoilerOverlay: SpoilerOverlay
+    get() = currentMode
+    set(value) {
+      if (currentMode == value) return
+      strategy.stop()
+      currentMode = value
+      strategy = createStrategy(value)
+      cachedStyle?.let { strategy.applyStyle(it) }
+      textViewReference.get()?.invalidate()
+    }
+
+  fun registerSpans(spans: Array<SpoilerSpan>) {
+    if (spans.isEmpty()) return
+    val first = spans[0]
+    val style =
+      SpoilerStyle(
+        first.styleCache.spoilerColor,
+        first.styleCache.spoilerParticleDensity,
+        first.styleCache.spoilerParticleSpeed,
+        first.styleCache.spoilerSolidBorderRadius,
+      )
+    cachedStyle = style
+    strategy.applyStyle(style)
+  }
+
+  fun draw(canvas: Canvas) {
+    val ctx = buildContext() ?: return
+
+    activeKeys.clear()
+
+    for (span in ctx.spans) {
+      if (span.revealed) continue
+      val spanStart = ctx.text.getSpanStart(span)
+      val spanEnd = ctx.text.getSpanEnd(span)
+      if (spanStart < 0 || spanEnd < 0 || spanStart >= spanEnd) continue
+
+      val spanIdentity = System.identityHashCode(span)
+      val firstLine = ctx.layout.getLineForOffset(spanStart)
+      val lastLine = ctx.layout.getLineForOffset(spanEnd)
+
+      for (line in firstLine..lastLine) {
+        val segmentStart = maxOf(spanStart, ctx.layout.getLineStart(line))
+        val segmentEnd = minOf(spanEnd, ctx.layout.getLineEnd(line))
+        if (segmentStart >= segmentEnd) continue
+
+        val rect =
+          computeSegmentRect(
+            ctx.layout,
+            line,
+            segmentStart,
+            segmentEnd,
+            ctx.fontMetrics,
+            ctx.paddingLeft,
+            ctx.paddingTop,
+          ) ?: continue
+        val key = SegmentKey(spanIdentity, line)
+        activeKeys.add(key)
+
+        strategy.drawSegment(canvas, ctx, key, rect)
+      }
+    }
+
+    strategy.pruneStaleSegments(activeKeys)
+  }
+
+  fun revealSpan(
+    span: SpoilerSpan,
+    onAllComplete: () -> Unit,
+  ) {
+    val ctx = buildContext()
+    if (ctx == null) {
+      span.markRevealed()
+      onAllComplete()
+      return
+    }
+    span.markRevealing()
+    strategy.revealSpan(span, ctx) {
+      span.markRevealed()
+      textViewReference.get()?.invalidate()
+      onAllComplete()
+    }
+  }
+
+  fun stop() {
+    animator.stop()
+    strategy.stop()
+  }
+
+  private fun buildContext(): SpoilerDrawContext? {
+    val textView = textViewReference.get() ?: return null
+    val layout = textView.layout ?: return null
+    val text = textView.text as? Spanned ?: return null
+    val spans = text.getSpans(0, text.length, SpoilerSpan::class.java)
+    if (spans.isEmpty()) return null
+    return SpoilerDrawContext(
+      textView = textView,
+      layout = layout,
+      text = text,
+      spans = spans,
+      paddingLeft = textView.totalPaddingLeft.toFloat(),
+      paddingTop = textView.totalPaddingTop.toFloat(),
+      fontMetrics = layout.paint.fontMetrics,
+      backgroundColor = SpoilerDrawContext.resolveBackgroundColor(textView),
+    )
+  }
+
+  private fun createStrategy(mode: SpoilerOverlay): SpoilerStrategy = mode.createStrategy(animator)
+
+  companion object {
+    fun setupIfNeeded(
+      textView: TextView,
+      styledText: CharSequence,
+      existing: SpoilerOverlayDrawer?,
+      spoilerOverlay: SpoilerOverlay = SpoilerOverlay.PARTICLES,
+    ): SpoilerOverlayDrawer? {
+      if (styledText !is Spanned) return tearDown(existing)
+      val spans = styledText.getSpans(0, styledText.length, SpoilerSpan::class.java)
+      if (spans.isEmpty()) return tearDown(existing)
+      val drawer = existing ?: SpoilerOverlayDrawer(textView)
+      drawer.spoilerOverlay = spoilerOverlay
+      drawer.registerSpans(spans)
+      return drawer
+    }
+
+    private fun tearDown(existing: SpoilerOverlayDrawer?): Nothing? {
+      existing?.stop()
+      return null
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/spoiler/SpoilerParticleDrawable.kt

@@ -0,0 +1,237 @@
+package com.swmansion.enriched.markdown.spoiler
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import kotlin.math.cos
+import kotlin.math.max
+import kotlin.math.sin
+import kotlin.random.Random
+
+// Uses a flat FloatArray (struct-of-arrays) to avoid GC pressure.
+class SpoilerParticleDrawable(
+  particleColor: Int,
+  particleDensity: Float,
+  particleSpeed: Float,
+) {
+  private var particleData = FloatArray(INITIAL_CAPACITY * STRIDE)
+  private var particleCount = 0
+
+  private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+  private val colorRed = Color.red(particleColor)
+  private val colorGreen = Color.green(particleColor)
+  private val colorBlue = Color.blue(particleColor)
+
+  private var width = 0f
+  private var height = 0f
+  private var primaryBirthRate = 0f
+  private var secondaryBirthRate = 0f
+  private var accumulatedPrimaryBirths = 0f
+  private var accumulatedSecondaryBirths = 0f
+
+  private val densityFactor = particleDensity / BASE_PARTICLE_DENSITY
+  private val speedFactor = particleSpeed / BASE_PARTICLE_SPEED
+
+  private var isRevealing = false
+  private var revealStartTime = -1L
+  private var revealCallback: (() -> Unit)? = null
+
+  var overallAlpha = 1f
+    private set
+  var revealFinished = false
+    private set
+
+  fun setSize(
+    newWidth: Float,
+    newHeight: Float,
+  ) {
+    val wasEmpty = width <= 0f || height <= 0f
+    if (newWidth == width && newHeight == height) return
+    width = newWidth
+    height = newHeight
+    val area = newWidth * newHeight
+    primaryBirthRate = max(3f, area * PRIMARY_DOT.densityFactor * densityFactor)
+    secondaryBirthRate = max(1.5f, area * SECONDARY_DOT.densityFactor * densityFactor)
+
+    if (wasEmpty && newWidth > 0f && newHeight > 0f && !isRevealing && particleCount == 0) {
+      seedInitialParticles()
+    }
+  }
+
+  fun startReveal(onComplete: () -> Unit) {
+    if (isRevealing) return
+    isRevealing = true
+    revealStartTime = -1L
+    revealCallback = onComplete
+
+    for (index in 0 until particleCount) {
+      val base = index * STRIDE
+      particleData[base + VELOCITY_X] *= REVEAL_VELOCITY_MULTIPLIER
+      particleData[base + VELOCITY_Y] *= REVEAL_VELOCITY_MULTIPLIER
+      particleData[base + ALPHA_SPEED] *= REVEAL_ALPHA_SPEED_MULTIPLIER
+    }
+  }
+
+  fun update(
+    deltaTime: Float,
+    currentTimeMs: Long,
+  ) {
+    if (revealFinished) return
+
+    if (!isRevealing) spawnParticles(deltaTime)
+    updateAndCompact(deltaTime)
+
+    if (isRevealing) {
+      if (revealStartTime < 0L) revealStartTime = currentTimeMs
+      val progress = ((currentTimeMs - revealStartTime).toFloat() / REVEAL_DURATION_MS).coerceIn(0f, 1f)
+      overallAlpha = (1f - progress) * (1f - progress)
+
+      if (progress >= 1f) {
+        revealFinished = true
+        particleCount = 0
+        revealCallback?.invoke()
+        revealCallback = null
+      }
+    }
+  }
+
+  fun draw(
+    canvas: Canvas,
+    offsetX: Float,
+    offsetY: Float,
+  ) {
+    if (width <= 0 || height <= 0 || particleCount == 0) return
+
+    canvas.save()
+    canvas.clipRect(offsetX, offsetY, offsetX + width, offsetY + height)
+
+    for (index in 0 until particleCount) {
+      val base = index * STRIDE
+      val alpha = (particleData[base + PARTICLE_ALPHA] * overallAlpha * 255f).toInt().coerceIn(0, 255)
+      if (alpha <= 0) continue
+
+      paint.color = Color.argb(alpha, colorRed, colorGreen, colorBlue)
+      canvas.drawCircle(
+        offsetX + particleData[base + POSITION_X],
+        offsetY + particleData[base + POSITION_Y],
+        DOT_RADIUS * particleData[base + PARTICLE_SCALE],
+        paint,
+      )
+    }
+
+    canvas.restore()
+  }
+
+  private fun updateAndCompact(deltaTime: Float) {
+    var writeIndex = 0
+    for (readIndex in 0 until particleCount) {
+      val readBase = readIndex * STRIDE
+      val age = particleData[readBase + PARTICLE_AGE] + deltaTime
+      val alpha = (particleData[readBase + PARTICLE_ALPHA] + particleData[readBase + ALPHA_SPEED] * deltaTime).coerceIn(0f, 1f)
+      if (age >= particleData[readBase + PARTICLE_LIFETIME] || alpha <= 0f) continue
+
+      val writeBase = writeIndex * STRIDE
+      if (writeBase != readBase) System.arraycopy(particleData, readBase, particleData, writeBase, STRIDE)
+      particleData[writeBase + POSITION_X] += particleData[writeBase + VELOCITY_X] * deltaTime
+      particleData[writeBase + POSITION_Y] += particleData[writeBase + VELOCITY_Y] * deltaTime
+      particleData[writeBase + PARTICLE_ALPHA] = alpha
+      particleData[writeBase + PARTICLE_AGE] = age
+      writeIndex++
+    }
+    particleCount = writeIndex
+  }
+
+  // Pre-populates particles so the field looks established on the first frame,
+  // matching iOS CAEmitterLayer which renders immediately.
+  private fun seedInitialParticles() {
+    val frameDeltaTime = 16f / 1000f
+    repeat(SEED_FRAMES) {
+      spawnParticles(frameDeltaTime)
+      for (index in 0 until particleCount) {
+        val base = index * STRIDE
+        particleData[base + PARTICLE_AGE] += frameDeltaTime
+        particleData[base + POSITION_X] += particleData[base + VELOCITY_X] * frameDeltaTime
+        particleData[base + POSITION_Y] += particleData[base + VELOCITY_Y] * frameDeltaTime
+        particleData[base + PARTICLE_ALPHA] =
+          (particleData[base + PARTICLE_ALPHA] + particleData[base + ALPHA_SPEED] * frameDeltaTime).coerceIn(0f, 1f)
+      }
+    }
+    updateAndCompact(0f)
+  }
+
+  private fun spawnParticles(deltaTime: Float) {
+    accumulatedPrimaryBirths += primaryBirthRate * deltaTime
+    accumulatedSecondaryBirths += secondaryBirthRate * deltaTime
+    while (accumulatedPrimaryBirths >= 1f) {
+      accumulatedPrimaryBirths -= 1f
+      emitParticle(PRIMARY_DOT)
+    }
+    while (accumulatedSecondaryBirths >= 1f) {
+      accumulatedSecondaryBirths -= 1f
+      emitParticle(SECONDARY_DOT)
+    }
+  }
+
+  private fun emitParticle(type: DotType) {
+    ensureCapacity(particleCount + 1)
+    val base = particleCount * STRIDE
+    val angle = Random.nextFloat() * TWO_PI
+    val velocity = type.velocity * speedFactor * (1f + (Random.nextFloat() - 0.5f) * VELOCITY_RANGE * 2f)
+
+    particleData[base + POSITION_X] = Random.nextFloat() * width
+    particleData[base + POSITION_Y] = Random.nextFloat() * height
+    particleData[base + VELOCITY_X] = cos(angle) * velocity
+    particleData[base + VELOCITY_Y] = sin(angle) * velocity
+    particleData[base + PARTICLE_ALPHA] = (1f - ALPHA_RANGE + Random.nextFloat() * ALPHA_RANGE * 2f).coerceIn(0f, 1f)
+    particleData[base + ALPHA_SPEED] = type.alphaSpeed
+    particleData[base + PARTICLE_SCALE] = type.scale * (1f + (Random.nextFloat() - 0.5f) * SCALE_RANGE * 2f)
+    particleData[base + PARTICLE_LIFETIME] = type.lifetime * (1f + (Random.nextFloat() - 0.5f) * LIFETIME_RANGE * 2f)
+    particleData[base + PARTICLE_AGE] = 0f
+    particleCount++
+  }
+
+  private fun ensureCapacity(needed: Int) {
+    val requiredLength = needed * STRIDE
+    if (requiredLength <= particleData.size) return
+    particleData = particleData.copyOf((particleData.size * 2).coerceAtLeast(requiredLength))
+  }
+
+  private class DotType(
+    val lifetime: Float,
+    val velocity: Float,
+    val scale: Float,
+    val alphaSpeed: Float,
+    val densityFactor: Float,
+  )
+
+  companion object {
+    private const val DOT_RADIUS = 3f
+    private const val REVEAL_VELOCITY_MULTIPLIER = 10f
+    private const val REVEAL_ALPHA_SPEED_MULTIPLIER = 6f
+    private const val SEED_FRAMES = 30
+    private const val INITIAL_CAPACITY = 64
+    private val TWO_PI = (Math.PI * 2).toFloat()
+
+    private const val LIFETIME_RANGE = 0.3f
+    private const val VELOCITY_RANGE = 0.5f
+    private const val SCALE_RANGE = 0.3f
+    private const val ALPHA_RANGE = 0.2f
+
+    private val PRIMARY_DOT = DotType(lifetime = 1.6f, velocity = 8f, scale = 0.25f, alphaSpeed = -0.25f, densityFactor = 0.013f)
+    private val SECONDARY_DOT = DotType(lifetime = 1.2f, velocity = 12f, scale = 0.18f, alphaSpeed = -0.3f, densityFactor = 0.007f)
+
+    private const val POSITION_X = 0
+    private const val POSITION_Y = 1
+    private const val VELOCITY_X = 2
+    private const val VELOCITY_Y = 3
+    private const val PARTICLE_ALPHA = 4
+    private const val ALPHA_SPEED = 5
+    private const val PARTICLE_SCALE = 6
+    private const val PARTICLE_LIFETIME = 7
+    private const val PARTICLE_AGE = 8
+    private const val STRIDE = 9
+
+    private const val BASE_PARTICLE_DENSITY = 8f
+    private const val BASE_PARTICLE_SPEED = 20f
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/spoiler/SpoilerStrategy.kt

@@ -0,0 +1,53 @@
+package com.swmansion.enriched.markdown.spoiler
+
+import android.graphics.Canvas
+import com.swmansion.enriched.markdown.spans.SpoilerSpan
+import com.swmansion.enriched.markdown.styles.SpoilerStyle
+
+interface SpoilerStrategy {
+  fun applyStyle(style: SpoilerStyle)
+
+  fun drawSegment(
+    canvas: Canvas,
+    context: SpoilerDrawContext,
+    key: SegmentKey,
+    rect: SegmentRect,
+  )
+
+  fun pruneStaleSegments(activeKeys: Set<SegmentKey>)
+
+  fun revealSpan(
+    span: SpoilerSpan,
+    context: SpoilerDrawContext,
+    onAllComplete: () -> Unit,
+  )
+
+  fun stop()
+}
+
+fun revealSegments(
+  span: SpoilerSpan,
+  segmentKeys: Set<SegmentKey>,
+  onAllComplete: () -> Unit,
+  cleanup: (List<SegmentKey>) -> Unit,
+  onSegment: (SegmentKey, onSegmentComplete: () -> Unit) -> Unit,
+) {
+  val spanIdentity = System.identityHashCode(span)
+  val keys = segmentKeys.filter { it.spanIdentity == spanIdentity }
+
+  if (keys.isEmpty()) {
+    onAllComplete()
+    return
+  }
+
+  val remaining = intArrayOf(keys.size)
+  for (key in keys) {
+    onSegment(key) {
+      remaining[0]--
+      if (remaining[0] <= 0) {
+        cleanup(keys)
+        onAllComplete()
+      }
+    }
+  }
+}

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

@@ -0,0 +1,11 @@
+package com.swmansion.enriched.markdown.styles
+
+interface BaseBlockStyle {
+  val fontSize: Float
+  val fontFamily: String
+  val fontWeight: String
+  val color: Int
+  val marginTop: Float
+  val marginBottom: Float
+  val lineHeight: Float
+}

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

@@ -0,0 +1,51 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class BlockquoteStyle(
+  override val fontSize: Float,
+  override val fontFamily: String,
+  override val fontWeight: String,
+  override val color: Int,
+  override val marginTop: Float,
+  override val marginBottom: Float,
+  override val lineHeight: Float,
+  val borderColor: Int,
+  val borderWidth: Float,
+  val gapWidth: Float,
+  val backgroundColor: Int?,
+) : BaseBlockStyle {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): BlockquoteStyle {
+      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 marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      val lineHeightRaw = map.getDouble("lineHeight").toFloat()
+      val lineHeight = parser.toPixelFromSP(lineHeightRaw)
+      val borderColor = parser.parseColor(map, "borderColor")
+      val borderWidth = parser.toPixelFromDIP(map.getDouble("borderWidth").toFloat())
+      val gapWidth = parser.toPixelFromDIP(map.getDouble("gapWidth").toFloat())
+      val backgroundColor = parser.parseOptionalColor(map, "backgroundColor")
+
+      return BlockquoteStyle(
+        fontSize,
+        fontFamily,
+        fontWeight,
+        color,
+        marginTop,
+        marginBottom,
+        lineHeight,
+        borderColor,
+        borderWidth,
+        gapWidth,
+        backgroundColor,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,54 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class CodeBlockStyle(
+  override val fontSize: Float,
+  override val fontFamily: String,
+  override val fontWeight: String,
+  override val color: Int,
+  override val marginTop: Float,
+  override val marginBottom: Float,
+  override val lineHeight: Float,
+  val backgroundColor: Int,
+  val borderColor: Int,
+  val borderRadius: Float,
+  val borderWidth: Float,
+  val padding: Float,
+) : BaseBlockStyle {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): CodeBlockStyle {
+      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 marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      val lineHeightRaw = map.getDouble("lineHeight").toFloat()
+      val lineHeight = parser.toPixelFromSP(lineHeightRaw)
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      val borderColor = parser.parseColor(map, "borderColor")
+      val borderRadius = parser.toPixelFromDIP(map.getDouble("borderRadius").toFloat())
+      val borderWidth = parser.toPixelFromDIP(map.getDouble("borderWidth").toFloat())
+      val padding = parser.toPixelFromDIP(map.getDouble("padding").toFloat())
+
+      return CodeBlockStyle(
+        fontSize,
+        fontFamily,
+        fontWeight,
+        color,
+        marginTop,
+        marginBottom,
+        lineHeight,
+        backgroundColor,
+        borderColor,
+        borderRadius,
+        borderWidth,
+        padding,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class CodeStyle(
+  val fontFamily: String,
+  val fontSize: Float,
+  val color: Int,
+  val backgroundColor: Int,
+  val borderColor: Int,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): CodeStyle {
+      val fontFamily = parser.parseString(map, "fontFamily")
+      val fontSizeRaw = parser.parseOptionalDouble(map, "fontSize").toFloat()
+      val fontSize = if (fontSizeRaw > 0) parser.toPixelFromSP(fontSizeRaw) else 0f
+      val color = parser.parseColor(map, "color")
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      val borderColor = parser.parseColor(map, "borderColor")
+      return CodeStyle(fontFamily, fontSize, color, backgroundColor, borderColor)
+    }
+  }
+}

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

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

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

@@ -0,0 +1,33 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class HeadingStyle(
+  override val fontSize: Float,
+  override val fontFamily: String,
+  override val fontWeight: String,
+  override val color: Int,
+  override val marginTop: Float,
+  override val marginBottom: Float,
+  override val lineHeight: Float,
+  val textAlign: TextAlignment,
+) : BaseBlockStyle {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): HeadingStyle {
+      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 marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      val lineHeightRaw = map.getDouble("lineHeight").toFloat()
+      val lineHeight = parser.toPixelFromSP(lineHeightRaw)
+      val textAlign = parser.parseTextAlign(map, "textAlign")
+
+      return HeadingStyle(fontSize, fontFamily, fontWeight, color, marginTop, marginBottom, lineHeight, textAlign)
+    }
+  }
+}

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

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

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

@@ -0,0 +1,23 @@
+package com.swmansion.enriched.markdown.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class ImageStyle(
+  val height: Float,
+  val borderRadius: Float,
+  val marginTop: Float,
+  val marginBottom: Float,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): ImageStyle {
+      val height = parser.toPixelFromDIP(map.getDouble("height").toFloat())
+      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)
+    }
+  }
+}