react-native-enriched-html 0.0.0 → 1.0.0

package/android/src/main/java/com/swmansion/enriched/common/parser/EnrichedSpanFactory.kt

@@ -0,0 +1,82 @@
+package com.swmansion.enriched.common.parser
+
+import com.swmansion.enriched.common.spans.EnrichedAlignmentSpan
+import com.swmansion.enriched.common.spans.EnrichedBlockQuoteSpan
+import com.swmansion.enriched.common.spans.EnrichedBoldSpan
+import com.swmansion.enriched.common.spans.EnrichedCheckboxListSpan
+import com.swmansion.enriched.common.spans.EnrichedCodeBlockSpan
+import com.swmansion.enriched.common.spans.EnrichedH1Span
+import com.swmansion.enriched.common.spans.EnrichedH2Span
+import com.swmansion.enriched.common.spans.EnrichedH3Span
+import com.swmansion.enriched.common.spans.EnrichedH4Span
+import com.swmansion.enriched.common.spans.EnrichedH5Span
+import com.swmansion.enriched.common.spans.EnrichedH6Span
+import com.swmansion.enriched.common.spans.EnrichedImageSpan
+import com.swmansion.enriched.common.spans.EnrichedInlineCodeSpan
+import com.swmansion.enriched.common.spans.EnrichedItalicSpan
+import com.swmansion.enriched.common.spans.EnrichedLinkSpan
+import com.swmansion.enriched.common.spans.EnrichedMentionSpan
+import com.swmansion.enriched.common.spans.EnrichedOrderedListSpan
+import com.swmansion.enriched.common.spans.EnrichedStrikeThroughSpan
+import com.swmansion.enriched.common.spans.EnrichedUnderlineSpan
+import com.swmansion.enriched.common.spans.EnrichedUnorderedListSpan
+
+interface EnrichedSpanFactory<T> {
+  fun createAlignmentSpan(cssValue: String): EnrichedAlignmentSpan
+
+  fun createBoldSpan(style: T): EnrichedBoldSpan
+
+  fun createItalicSpan(style: T): EnrichedItalicSpan
+
+  fun createUnderlineSpan(style: T): EnrichedUnderlineSpan
+
+  fun createStrikeThroughSpan(style: T): EnrichedStrikeThroughSpan
+
+  fun createInlineCodeSpan(style: T): EnrichedInlineCodeSpan
+
+  fun createLinkSpan(
+    url: String,
+    style: T,
+  ): EnrichedLinkSpan
+
+  fun createMentionSpan(
+    text: String,
+    indicator: String,
+    attributes: Map<String, String>,
+    style: T,
+  ): EnrichedMentionSpan
+
+  fun createImageSpan(
+    source: String,
+    width: Int,
+    height: Int,
+  ): EnrichedImageSpan
+
+  fun createH1Span(style: T): EnrichedH1Span
+
+  fun createH2Span(style: T): EnrichedH2Span
+
+  fun createH3Span(style: T): EnrichedH3Span
+
+  fun createH4Span(style: T): EnrichedH4Span
+
+  fun createH5Span(style: T): EnrichedH5Span
+
+  fun createH6Span(style: T): EnrichedH6Span
+
+  fun createOrderedListSpan(
+    index: Int,
+    style: T,
+  ): EnrichedOrderedListSpan
+
+  fun createUnorderedListSpan(style: T): EnrichedUnorderedListSpan
+
+  fun createCheckboxListSpan(
+    isChecked: Boolean,
+    style: T,
+  ): EnrichedCheckboxListSpan
+
+  fun createBlockQuoteSpan(style: T): EnrichedBlockQuoteSpan
+
+  fun createCodeBlockSpan(style: T): EnrichedCodeBlockSpan
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedAlignmentSpan.kt

@@ -0,0 +1,19 @@
+package com.swmansion.enriched.common.spans
+
+import android.text.Layout
+import android.text.style.AlignmentSpan
+import com.swmansion.enriched.common.spans.interfaces.EnrichedZeroWidthSpaceSpan
+
+open class EnrichedAlignmentSpan(
+  val cssValue: String,
+) : AlignmentSpan.Standard(cssValueToLayoutAlignment(cssValue)),
+  EnrichedZeroWidthSpaceSpan {
+  companion object {
+    fun cssValueToLayoutAlignment(cssValue: String): Layout.Alignment =
+      when (cssValue) {
+        "center" -> Layout.Alignment.ALIGN_CENTER
+        "right" -> Layout.Alignment.ALIGN_OPPOSITE
+        else -> Layout.Alignment.ALIGN_NORMAL
+      }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedBlockQuoteSpan.kt

@@ -0,0 +1,53 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.Layout
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedBlockSpan
+
+// https://android.googlesource.com/platform/frameworks/base/+/refs/heads/main/core/java/android/text/style/QuoteSpan.java
+open class EnrichedBlockQuoteSpan(
+  private val enrichedStyle: EnrichedStyle,
+) : MetricAffectingSpan(),
+  LeadingMarginSpan,
+  EnrichedBlockSpan {
+  override fun updateMeasureState(p0: TextPaint) {
+    // Do nothing, but inform layout that this span affects text metrics
+  }
+
+  override fun getLeadingMargin(p0: Boolean): Int = enrichedStyle.blockquoteStripeWidth + enrichedStyle.blockquoteGapWidth
+
+  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?,
+  ) {
+    val style = p.style
+    val color = p.color
+    p.style = Paint.Style.FILL
+    p.color = enrichedStyle.blockquoteBorderColor
+    c.drawRect(x.toFloat(), top.toFloat(), x + dir * enrichedStyle.blockquoteStripeWidth.toFloat(), bottom.toFloat(), p)
+    p.style = style
+    p.color = color
+  }
+
+  override fun updateDrawState(textPaint: TextPaint?) {
+    val color = enrichedStyle.blockquoteColor
+    if (color != null) {
+      textPaint?.color = color
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedBoldSpan.kt

@@ -0,0 +1,12 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Typeface
+import android.text.style.StyleSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan
+
+@Suppress("UNUSED_PARAMETER")
+open class EnrichedBoldSpan(
+  enrichedStyle: EnrichedStyle,
+) : StyleSpan(Typeface.BOLD),
+  EnrichedInlineSpan

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedCheckboxListSpan.kt

@@ -0,0 +1,92 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.Layout
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+import android.text.style.LineHeightSpan
+import android.text.style.MetricAffectingSpan
+import androidx.core.graphics.withTranslation
+import com.swmansion.enriched.common.CheckboxDrawable
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedParagraphSpan
+import com.swmansion.enriched.textinput.styles.HtmlStyle
+
+open class EnrichedCheckboxListSpan(
+  open var isChecked: Boolean,
+  private val enrichedStyle: EnrichedStyle,
+) : MetricAffectingSpan(),
+  LineHeightSpan,
+  LeadingMarginSpan,
+  EnrichedParagraphSpan {
+  private val checkboxDrawable =
+    CheckboxDrawable(enrichedStyle.ulCheckboxBoxSize, enrichedStyle.ulCheckboxBoxColor, isChecked).apply {
+      setBounds(0, 0, enrichedStyle.ulCheckboxBoxSize, enrichedStyle.ulCheckboxBoxSize)
+    }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    // Do nothing, but inform layout that this span affects text metrics
+  }
+
+  override fun updateDrawState(tp: TextPaint) {
+    // Do nothing, but inform layout that this span affects text metrics
+  }
+
+  // Include checkbox size in text measurements to avoid clipping
+  override fun chooseHeight(
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    v: Int,
+    fm: Paint.FontMetricsInt,
+  ) {
+    val checkboxSize = enrichedStyle.ulCheckboxBoxSize
+    val currentLineHeight = fm.descent - fm.ascent
+
+    if (checkboxSize > currentLineHeight) {
+      val extraSpace = checkboxSize - currentLineHeight
+      val halfExtra = extraSpace / 2
+
+      fm.ascent -= halfExtra
+      fm.descent += (extraSpace - halfExtra)
+
+      fm.top -= halfExtra
+      fm.bottom += (extraSpace - halfExtra)
+    }
+  }
+
+  override fun getLeadingMargin(first: Boolean): Int =
+    enrichedStyle.ulCheckboxBoxSize + enrichedStyle.ulCheckboxMarginLeft + enrichedStyle.ulCheckboxGapWidth
+
+  override fun drawLeadingMargin(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    val spannedText = text as Spanned
+
+    if (spannedText.getSpanStart(this) == start) {
+      checkboxDrawable.update(isChecked)
+
+      val fm = paint.fontMetricsInt
+      val textCenter = baseline + (fm.ascent + fm.descent) / 2f
+      val drawableTop = textCenter - (enrichedStyle.ulCheckboxBoxSize / 2f)
+
+      canvas.withTranslation(x.toFloat() + enrichedStyle.ulCheckboxMarginLeft, drawableTop) {
+        checkboxDrawable.draw(this)
+      }
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedCodeBlockSpan.kt

@@ -0,0 +1,81 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.graphics.Typeface
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LineBackgroundSpan
+import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedBlockSpan
+
+open class EnrichedCodeBlockSpan(
+  private val enrichedStyle: EnrichedStyle,
+) : MetricAffectingSpan(),
+  LineBackgroundSpan,
+  EnrichedBlockSpan {
+  override fun updateDrawState(paint: TextPaint) {
+    paint.typeface = Typeface.MONOSPACE
+    paint.color = enrichedStyle.codeBlockColor
+  }
+
+  override fun updateMeasureState(paint: TextPaint) {
+    paint.typeface = Typeface.MONOSPACE
+  }
+
+  override fun drawBackground(
+    canvas: Canvas,
+    p: Paint,
+    left: Int,
+    right: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    lineNum: Int,
+  ) {
+    if (text !is Spanned) {
+      return
+    }
+
+    val previousColor = p.color
+    p.color = enrichedStyle.codeBlockBackgroundColor
+
+    val radius = enrichedStyle.codeBlockRadius
+
+    val spanStart = text.getSpanStart(this)
+    val spanEnd = text.getSpanEnd(this)
+    val isFirstLineOfSpan = start == spanStart
+    val isLastLineOfSpan = end == spanEnd || (spanEnd + 1 == end && text[spanEnd] == '\n')
+
+    val path = Path()
+    val radii = floatArrayOf(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f)
+
+    if (isFirstLineOfSpan) {
+      // Top-Left and Top-Right corners
+      radii[0] = radius
+      radii[1] = radius
+      radii[2] = radius
+      radii[3] = radius
+    }
+
+    if (isLastLineOfSpan) {
+      // Bottom-Right and Bottom-Left corners
+      radii[4] = radius
+      radii[5] = radius
+      radii[6] = radius
+      radii[7] = radius
+    }
+
+    val rect = RectF(left.toFloat(), top.toFloat(), right.toFloat(), bottom.toFloat())
+
+    path.addRoundRect(rect, radii, Path.Direction.CW)
+    canvas.drawPath(path, p)
+    p.color = previousColor
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedH1Span.kt

@@ -0,0 +1,20 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.AbsoluteSizeSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedHeadingSpan
+
+open class EnrichedH1Span(
+  private val enrichedStyle: EnrichedStyle,
+) : AbsoluteSizeSpan(enrichedStyle.h1FontSize),
+  EnrichedHeadingSpan {
+  override fun updateDrawState(tp: TextPaint) {
+    super.updateDrawState(tp)
+    val bold = enrichedStyle.h1Bold
+    if (bold) {
+      tp.typeface = Typeface.create(tp.typeface, Typeface.BOLD)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedH2Span.kt

@@ -0,0 +1,20 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.AbsoluteSizeSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedHeadingSpan
+
+open class EnrichedH2Span(
+  private val enrichedStyle: EnrichedStyle,
+) : AbsoluteSizeSpan(enrichedStyle.h2FontSize),
+  EnrichedHeadingSpan {
+  override fun updateDrawState(tp: TextPaint) {
+    super.updateDrawState(tp)
+    val bold = enrichedStyle.h2Bold
+    if (bold) {
+      tp.typeface = Typeface.create(tp.typeface, Typeface.BOLD)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedH3Span.kt

@@ -0,0 +1,20 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.AbsoluteSizeSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedHeadingSpan
+
+open class EnrichedH3Span(
+  private val enrichedStyle: EnrichedStyle,
+) : AbsoluteSizeSpan(enrichedStyle.h3FontSize),
+  EnrichedHeadingSpan {
+  override fun updateDrawState(tp: TextPaint) {
+    super.updateDrawState(tp)
+    val bold = enrichedStyle.h3Bold
+    if (bold) {
+      tp.typeface = Typeface.create(tp.typeface, Typeface.BOLD)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedH4Span.kt

@@ -0,0 +1,21 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.AbsoluteSizeSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedHeadingSpan
+import com.swmansion.enriched.textinput.styles.HtmlStyle
+
+open class EnrichedH4Span(
+  private val enrichedStyle: EnrichedStyle,
+) : AbsoluteSizeSpan(enrichedStyle.h4FontSize),
+  EnrichedHeadingSpan {
+  override fun updateDrawState(tp: TextPaint) {
+    super.updateDrawState(tp)
+    val bold = enrichedStyle.h4Bold
+    if (bold) {
+      tp.typeface = Typeface.create(tp.typeface, Typeface.BOLD)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedH5Span.kt

@@ -0,0 +1,20 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.AbsoluteSizeSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedHeadingSpan
+
+open class EnrichedH5Span(
+  private val enrichedStyle: EnrichedStyle,
+) : AbsoluteSizeSpan(enrichedStyle.h5FontSize),
+  EnrichedHeadingSpan {
+  override fun updateDrawState(tp: TextPaint) {
+    super.updateDrawState(tp)
+    val bold = enrichedStyle.h5Bold
+    if (bold) {
+      tp.typeface = Typeface.create(tp.typeface, Typeface.BOLD)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedH6Span.kt

@@ -0,0 +1,20 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.AbsoluteSizeSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedHeadingSpan
+
+open class EnrichedH6Span(
+  private val enrichedStyle: EnrichedStyle,
+) : AbsoluteSizeSpan(enrichedStyle.h6FontSize),
+  EnrichedHeadingSpan {
+  override fun updateDrawState(tp: TextPaint) {
+    super.updateDrawState(tp)
+    val bold = enrichedStyle.h6Bold
+    if (bold) {
+      tp.typeface = Typeface.create(tp.typeface, Typeface.BOLD)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedImageSpan.kt

@@ -0,0 +1,185 @@
+package com.swmansion.enriched.common.spans
+
+import android.content.res.Resources
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.ImageDecoder
+import android.graphics.Paint
+import android.graphics.drawable.AnimatedImageDrawable
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.text.Spannable
+import android.text.style.ImageSpan
+import android.util.Log
+import androidx.core.graphics.drawable.toDrawable
+import androidx.core.graphics.withSave
+import com.swmansion.enriched.common.AsyncDrawable
+import com.swmansion.enriched.common.ForceRedrawSpan
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan
+import java.io.File
+
+open class EnrichedImageSpan :
+  ImageSpan,
+  EnrichedInlineSpan {
+  private var width: Int = 0
+  private var height: Int = 0
+
+  constructor(drawable: Drawable, source: String, width: Int, height: Int) : super(drawable, source, ALIGN_BASELINE) {
+    this.width = width
+    this.height = height
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) {
+    val drawable = drawable
+    canvas.withSave {
+      val transY = bottom - drawable.bounds.bottom - paint.fontMetricsInt.descent
+      translate(x, transY.toFloat())
+      drawable.draw(this)
+    }
+  }
+
+  override fun getDrawable(): Drawable {
+    val drawable = super.getDrawable()
+    val scale = Resources.getSystem().displayMetrics.density
+
+    drawable.setBounds(0, 0, (width * scale).toInt(), (height * scale).toInt())
+    return drawable
+  }
+
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int {
+    val d = drawable
+    val rect = d.bounds
+
+    if (fm != null) {
+      val imageHeight = rect.bottom - rect.top
+
+      // We want the image bottom to sit on the baseline (0).
+      // Therefore, the image top will be at: -imageHeight.
+      val targetTop = -imageHeight
+
+      // Expand the line UPWARDS if the image is taller than the current font
+      if (targetTop < fm.ascent) {
+        fm.ascent = targetTop
+        fm.top = targetTop
+      }
+    }
+
+    return rect.right
+  }
+
+  private fun registerDrawableLoadCallback(
+    d: AsyncDrawable,
+    text: Spannable?,
+  ) {
+    d.onLoaded = onLoaded@{
+      val spannable = text
+
+      if (spannable == null) {
+        return@onLoaded
+      }
+      // Ensure we are on the Main Thread before modifying the Spannable
+      Handler(Looper.getMainLooper()).post {
+        val start = spannable.getSpanStart(this@EnrichedImageSpan)
+        val end = spannable.getSpanEnd(this@EnrichedImageSpan)
+
+        if (start != -1 && end != -1) {
+          // trick for adding empty span to force redraw when image is loaded
+          val redrawSpan = ForceRedrawSpan()
+          spannable.setSpan(redrawSpan, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+          spannable.removeSpan(redrawSpan)
+        }
+      }
+    }
+  }
+
+  fun observeAsyncDrawableLoaded(text: Spannable?) {
+    val d = drawable
+
+    if (d !is AsyncDrawable) {
+      return
+    }
+
+    registerDrawableLoadCallback(d, text)
+
+    // If it's already loaded (race condition), run logic immediately
+    if (d.isLoaded) {
+      d.onLoaded?.invoke()
+    }
+  }
+
+  fun getWidth(): Int = width
+
+  fun getHeight(): Int = height
+
+  companion object {
+    fun prepareDrawableForImage(
+      src: String,
+      width: Int,
+      height: Int,
+    ): Drawable? {
+      var cleanPath = src
+
+      if (cleanPath.startsWith("http://") || cleanPath.startsWith("https://")) {
+        return AsyncDrawable(cleanPath)
+      }
+
+      if (cleanPath.startsWith("file://")) {
+        cleanPath = cleanPath.substring(7)
+      }
+
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
+        return try {
+          val bitmap = BitmapFactory.decodeFile(cleanPath) ?: return null
+          val drawable = bitmap.toDrawable(Resources.getSystem())
+          drawable.setBounds(0, 0, bitmap.width, bitmap.height)
+          return drawable
+        } catch (e: Exception) {
+          Log.e("EnrichedImageSpan", "Failed to load legacy image: $cleanPath", e)
+          null
+        }
+      }
+
+      return try {
+        val file = File(cleanPath)
+        val source = ImageDecoder.createSource(file)
+
+        val density = Resources.getSystem().displayMetrics.density
+        val targetWidthPx = (width * density).toInt()
+        val targetHeightPx = (height * density).toInt()
+
+        val drawable =
+          ImageDecoder.decodeDrawable(source) { decoder, info, source ->
+            decoder.setTargetSize(targetWidthPx, targetHeightPx)
+          }
+
+        if (drawable is AnimatedImageDrawable) {
+          drawable.setBounds(0, 0, drawable.intrinsicWidth, drawable.intrinsicHeight)
+          drawable.repeatCount = AnimatedImageDrawable.REPEAT_INFINITE
+          drawable.start()
+        }
+        drawable
+      } catch (e: Exception) {
+        Log.e("EnrichedImageSpan", "Failed to load image: $cleanPath", e)
+        null
+      }
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedInlineCodeSpan.kt

@@ -0,0 +1,24 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan
+
+open class EnrichedInlineCodeSpan(
+  private val enrichedStyle: EnrichedStyle,
+) : MetricAffectingSpan(),
+  EnrichedInlineSpan {
+  override fun updateDrawState(textPaint: TextPaint) {
+    val typeface = Typeface.create(Typeface.MONOSPACE, Typeface.NORMAL)
+    textPaint.typeface = typeface
+    textPaint.color = enrichedStyle.inlineCodeColor
+    textPaint.bgColor = enrichedStyle.inlineCodeBackgroundColor
+  }
+
+  override fun updateMeasureState(textPaint: TextPaint) {
+    val typeface = Typeface.create(Typeface.MONOSPACE, Typeface.NORMAL)
+    textPaint.typeface = typeface
+  }
+}

package/android/src/main/java/com/swmansion/enriched/common/spans/EnrichedItalicSpan.kt

@@ -0,0 +1,12 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Typeface
+import android.text.style.StyleSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan
+
+@Suppress("UNUSED_PARAMETER")
+open class EnrichedItalicSpan(
+  private val enrichedStyle: EnrichedStyle,
+) : StyleSpan(Typeface.ITALIC),
+  EnrichedInlineSpan