react-native-enriched-html 0.0.0 → 1.1.0-nightly-20260617-3dfd09072

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

@@ -0,0 +1,29 @@
+package com.swmansion.enriched.common.spans
+
+import android.text.TextPaint
+import android.text.style.ClickableSpan
+import android.view.View
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan
+
+open class EnrichedLinkSpan(
+  private val url: String,
+  private val enrichedStyle: EnrichedStyle,
+  private val isManual: Boolean,
+) : ClickableSpan(),
+  EnrichedInlineSpan {
+  override fun onClick(view: View) {
+    // Do nothing, links inside the input are not clickable.
+    // We are using `ClickableSpan` to allow the text to be styled as a link.
+  }
+
+  override fun updateDrawState(textPaint: TextPaint) {
+    super.updateDrawState(textPaint)
+    textPaint.color = enrichedStyle.aColor
+    textPaint.isUnderlineText = enrichedStyle.aUnderline
+  }
+
+  fun getUrl(): String = url
+
+  fun getIsManual(): Boolean = isManual
+}

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

@@ -0,0 +1,35 @@
+package com.swmansion.enriched.common.spans
+
+import android.text.TextPaint
+import android.text.style.ClickableSpan
+import android.view.View
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan
+
+open class EnrichedMentionSpan(
+  private val text: String,
+  private val indicator: String,
+  private val attributes: Map<String, String>,
+  private val enrichedStyle: EnrichedStyle,
+) : ClickableSpan(),
+  EnrichedInlineSpan {
+  override fun onClick(view: View) {
+    // Do nothing. Mentions inside the input are not clickable.
+    // We are using `ClickableSpan` to allow the text to be styled as a clickable element.
+  }
+
+  override fun updateDrawState(textPaint: TextPaint) {
+    super.updateDrawState(textPaint)
+
+    val mentionsStyle = enrichedStyle.mentionsStyle[indicator] ?: return
+    textPaint.color = mentionsStyle.color
+    textPaint.bgColor = mentionsStyle.backgroundColor
+    textPaint.isUnderlineText = mentionsStyle.underline
+  }
+
+  fun getAttributes(): Map<String, String> = attributes
+
+  fun getText(): String = text
+
+  fun getIndicator(): String = indicator
+}

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

@@ -0,0 +1,79 @@
+package com.swmansion.enriched.common.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.os.Build
+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.EnrichedParagraphSpan
+
+open class EnrichedOrderedListSpan(
+  var index: Int,
+  private val enrichedStyle: EnrichedStyle,
+) : MetricAffectingSpan(),
+  LeadingMarginSpan,
+  EnrichedParagraphSpan {
+  override fun updateMeasureState(p0: TextPaint) {
+    // Do nothing, but inform layout that this span affects text metrics
+  }
+
+  override fun updateDrawState(p0: TextPaint?) {
+    // Do nothing, but inform layout that this span affects text metrics
+  }
+
+  override fun getLeadingMargin(first: Boolean): Int = enrichedStyle.olMarginLeft + enrichedStyle.olGapWidth
+
+  override fun drawLeadingMargin(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    t: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    if (first) {
+      val text = "$index."
+      val width = paint.measureText(text)
+
+      val yPosition = baseline.toFloat()
+      val xPosition = (enrichedStyle.olMarginLeft + x - width / 2) * dir
+
+      val originalColor = paint.color
+      val originalTypeface = paint.typeface
+
+      paint.color = enrichedStyle.olMarkerColor ?: originalColor
+      paint.typeface = getTypeface(enrichedStyle.olMarkerFontWeight, originalTypeface)
+      canvas.drawText(text, xPosition, yPosition, paint)
+
+      paint.color = originalColor
+      paint.typeface = originalTypeface
+    }
+  }
+
+  private fun getTypeface(
+    fontWeight: Int?,
+    originalTypeface: Typeface,
+  ): Typeface =
+    if (fontWeight == null) {
+      originalTypeface
+    } else if (Build.VERSION.SDK_INT >= 28) {
+      Typeface.create(originalTypeface, fontWeight, false)
+    } else {
+      // Fallback for API < 28: only bold/normal supported
+      if (fontWeight == Typeface.BOLD) {
+        Typeface.create(originalTypeface, Typeface.BOLD)
+      } else {
+        Typeface.create(originalTypeface, Typeface.NORMAL)
+      }
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.swmansion.enriched.common.spans
+
+import android.text.style.StrikethroughSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan
+
+@Suppress("UNUSED_PARAMETER")
+open class EnrichedStrikeThroughSpan(
+  private val enrichedStyle: EnrichedStyle,
+) : StrikethroughSpan(),
+  EnrichedInlineSpan

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

@@ -0,0 +1,11 @@
+package com.swmansion.enriched.common.spans
+
+import android.text.style.UnderlineSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan
+
+@Suppress("UNUSED_PARAMETER")
+open class EnrichedUnderlineSpan(
+  private val enrichedStyle: EnrichedStyle,
+) : UnderlineSpan(),
+  EnrichedInlineSpan

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

@@ -0,0 +1,62 @@
+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.MetricAffectingSpan
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.spans.interfaces.EnrichedParagraphSpan
+
+// https://android.googlesource.com/platform/frameworks/base/+/refs/heads/main/core/java/android/text/style/BulletSpan.java
+open class EnrichedUnorderedListSpan(
+  private val enrichedStyle: EnrichedStyle,
+) : MetricAffectingSpan(),
+  LeadingMarginSpan,
+  EnrichedParagraphSpan {
+  override fun updateMeasureState(p0: TextPaint) {
+    // Do nothing, but inform layout that this span affects text metrics
+  }
+
+  override fun updateDrawState(p0: TextPaint?) {
+    // Do nothing, but inform layout that this span affects text metrics
+  }
+
+  override fun getLeadingMargin(p0: Boolean): Int = enrichedStyle.ulBulletSize + enrichedStyle.ulGapWidth + enrichedStyle.ulMarginLeft
+
+  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) {
+      val style = paint.style
+      val oldColor = paint.color
+      paint.color = enrichedStyle.ulBulletColor
+      paint.style = Paint.Style.FILL
+
+      val bulletRadius = enrichedStyle.ulBulletSize / 2f
+      val fm = paint.fontMetricsInt
+      val yPosition = baseline + (fm.ascent + fm.descent) / 2f
+      val xPosition = x + dir * bulletRadius + enrichedStyle.ulMarginLeft
+
+      canvas.drawCircle(xPosition, yPosition, bulletRadius, paint)
+
+      paint.color = oldColor
+      paint.style = style
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+package com.swmansion.enriched.common.spans.interfaces
+
+interface EnrichedBlockSpan :
+  EnrichedSpan,
+  EnrichedZeroWidthSpaceSpan

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

@@ -0,0 +1,3 @@
+package com.swmansion.enriched.common.spans.interfaces
+
+interface EnrichedHeadingSpan : EnrichedParagraphSpan

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

@@ -0,0 +1,3 @@
+package com.swmansion.enriched.common.spans.interfaces
+
+interface EnrichedInlineSpan : EnrichedSpan

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

@@ -0,0 +1,5 @@
+package com.swmansion.enriched.common.spans.interfaces
+
+interface EnrichedParagraphSpan :
+  EnrichedSpan,
+  EnrichedZeroWidthSpaceSpan

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

@@ -0,0 +1,3 @@
+package com.swmansion.enriched.common.spans.interfaces
+
+interface EnrichedSpan

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

@@ -0,0 +1,4 @@
+package com.swmansion.enriched.common.spans.interfaces
+
+// Spans that are prefixed with zero-width space (\u200B) to ensure that they are visible even when empty.
+interface EnrichedZeroWidthSpaceSpan

package/android/src/main/java/com/swmansion/enriched/text/EnrichedTextMovementMethod.kt

@@ -0,0 +1,75 @@
+package com.swmansion.enriched.text
+
+import android.text.Selection
+import android.text.Spannable
+import android.text.method.LinkMovementMethod
+import android.view.MotionEvent
+import android.widget.TextView
+import com.swmansion.enriched.text.spans.interfaces.EnrichedTextClickableSpan
+
+class EnrichedTextMovementMethod : LinkMovementMethod() {
+  override fun onTouchEvent(
+    widget: TextView,
+    buffer: Spannable,
+    event: MotionEvent,
+  ): Boolean {
+    val action = event.action
+
+    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_CANCEL) {
+      val x = (event.x - widget.totalPaddingLeft + widget.scrollX).toInt()
+      val y = (event.y - widget.totalPaddingTop + widget.scrollY).toInt()
+
+      val layout = widget.layout
+      val line = layout.getLineForVertical(y)
+      val off = layout.getOffsetForHorizontal(line, x.toFloat())
+
+      val inLineBounds = x >= layout.getLineLeft(line) && x <= layout.getLineRight(line)
+      val links =
+        if (inLineBounds) {
+          buffer.getSpans(off, off, EnrichedTextClickableSpan::class.java)
+        } else {
+          emptyArray()
+        }
+
+      if (links.isNotEmpty()) {
+        val link = links[0]
+
+        when (action) {
+          MotionEvent.ACTION_DOWN -> {
+            link.isPressed = true
+            Selection.setSelection(buffer, buffer.getSpanStart(link), buffer.getSpanEnd(link))
+          }
+
+          MotionEvent.ACTION_UP -> {
+            link.onClick(widget)
+            link.isPressed = false
+            Selection.removeSelection(buffer)
+          }
+
+          MotionEvent.ACTION_CANCEL -> {
+            link.isPressed = false
+            Selection.removeSelection(buffer)
+          }
+        }
+
+        widget.invalidate()
+        return true
+      } else {
+        val allSpans = buffer.getSpans(0, buffer.length, EnrichedTextClickableSpan::class.java)
+        allSpans.forEach { it.isPressed = false }
+        Selection.removeSelection(buffer)
+        widget.invalidate()
+      }
+    }
+    return false
+  }
+
+  companion object {
+    private var instance: EnrichedTextMovementMethod? = null
+
+    fun getInstance(): EnrichedTextMovementMethod {
+      if (instance == null) instance = EnrichedTextMovementMethod()
+      return instance!!
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/text/EnrichedTextSpanFactory.kt

@@ -0,0 +1,83 @@
+package com.swmansion.enriched.text
+
+import com.swmansion.enriched.common.parser.EnrichedSpanFactory
+import com.swmansion.enriched.text.spans.EnrichedTextAlignmentSpan
+import com.swmansion.enriched.text.spans.EnrichedTextBlockQuoteSpan
+import com.swmansion.enriched.text.spans.EnrichedTextBoldSpan
+import com.swmansion.enriched.text.spans.EnrichedTextCheckboxListSpan
+import com.swmansion.enriched.text.spans.EnrichedTextCodeBlockSpan
+import com.swmansion.enriched.text.spans.EnrichedTextH1Span
+import com.swmansion.enriched.text.spans.EnrichedTextH2Span
+import com.swmansion.enriched.text.spans.EnrichedTextH3Span
+import com.swmansion.enriched.text.spans.EnrichedTextH4Span
+import com.swmansion.enriched.text.spans.EnrichedTextH5Span
+import com.swmansion.enriched.text.spans.EnrichedTextH6Span
+import com.swmansion.enriched.text.spans.EnrichedTextImageSpan
+import com.swmansion.enriched.text.spans.EnrichedTextInlineCodeSpan
+import com.swmansion.enriched.text.spans.EnrichedTextItalicSpan
+import com.swmansion.enriched.text.spans.EnrichedTextLinkSpan
+import com.swmansion.enriched.text.spans.EnrichedTextMentionSpan
+import com.swmansion.enriched.text.spans.EnrichedTextOrderedListSpan
+import com.swmansion.enriched.text.spans.EnrichedTextStrikeThroughSpan
+import com.swmansion.enriched.text.spans.EnrichedTextUnderlineSpan
+import com.swmansion.enriched.text.spans.EnrichedTextUnorderedListSpan
+
+class EnrichedTextSpanFactory : EnrichedSpanFactory<EnrichedTextStyle> {
+  override fun createAlignmentSpan(cssValue: String) = EnrichedTextAlignmentSpan(cssValue)
+
+  override fun createBoldSpan(style: EnrichedTextStyle) = EnrichedTextBoldSpan(style)
+
+  override fun createItalicSpan(style: EnrichedTextStyle) = EnrichedTextItalicSpan(style)
+
+  override fun createUnderlineSpan(style: EnrichedTextStyle) = EnrichedTextUnderlineSpan(style)
+
+  override fun createStrikeThroughSpan(style: EnrichedTextStyle) = EnrichedTextStrikeThroughSpan(style)
+
+  override fun createInlineCodeSpan(style: EnrichedTextStyle) = EnrichedTextInlineCodeSpan(style)
+
+  override fun createLinkSpan(
+    url: String,
+    style: EnrichedTextStyle,
+  ) = EnrichedTextLinkSpan(url, style)
+
+  override fun createMentionSpan(
+    text: String,
+    indicator: String,
+    attributes: Map<String, String>,
+    style: EnrichedTextStyle,
+  ) = EnrichedTextMentionSpan(text, indicator, attributes, style)
+
+  override fun createImageSpan(
+    source: String,
+    width: Int,
+    height: Int,
+  ) = EnrichedTextImageSpan.createEnrichedImageSpan(source, width, height)
+
+  override fun createH1Span(style: EnrichedTextStyle) = EnrichedTextH1Span(style)
+
+  override fun createH2Span(style: EnrichedTextStyle) = EnrichedTextH2Span(style)
+
+  override fun createH3Span(style: EnrichedTextStyle) = EnrichedTextH3Span(style)
+
+  override fun createH4Span(style: EnrichedTextStyle) = EnrichedTextH4Span(style)
+
+  override fun createH5Span(style: EnrichedTextStyle) = EnrichedTextH5Span(style)
+
+  override fun createH6Span(style: EnrichedTextStyle) = EnrichedTextH6Span(style)
+
+  override fun createOrderedListSpan(
+    index: Int,
+    style: EnrichedTextStyle,
+  ) = EnrichedTextOrderedListSpan(index, style)
+
+  override fun createUnorderedListSpan(style: EnrichedTextStyle) = EnrichedTextUnorderedListSpan(style)
+
+  override fun createCheckboxListSpan(
+    isChecked: Boolean,
+    style: EnrichedTextStyle,
+  ) = EnrichedTextCheckboxListSpan(isChecked, style)
+
+  override fun createBlockQuoteSpan(style: EnrichedTextStyle) = EnrichedTextBlockQuoteSpan(style)
+
+  override fun createCodeBlockSpan(style: EnrichedTextStyle) = EnrichedTextCodeBlockSpan(style)
+}

package/android/src/main/java/com/swmansion/enriched/text/EnrichedTextStyle.kt

@@ -0,0 +1,202 @@
+package com.swmansion.enriched.text
+
+import android.graphics.Color
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.views.text.ReactTypefaceUtils.parseFontWeight
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.MentionStyle
+import com.swmansion.enriched.common.pixelFromSpOrDp
+import kotlin.math.ceil
+
+data class EnrichedTextStyle(
+  // Headings
+  override val h1FontSize: Int,
+  override val h1Bold: Boolean,
+  override val h2FontSize: Int,
+  override val h2Bold: Boolean,
+  override val h3FontSize: Int,
+  override val h3Bold: Boolean,
+  override val h4FontSize: Int,
+  override val h4Bold: Boolean,
+  override val h5FontSize: Int,
+  override val h5Bold: Boolean,
+  override val h6FontSize: Int,
+  override val h6Bold: Boolean,
+  // Blockquote
+  override val blockquoteColor: Int?,
+  override val blockquoteBorderColor: Int,
+  override val blockquoteStripeWidth: Int,
+  override val blockquoteGapWidth: Int,
+  // Ordered List
+  override val olGapWidth: Int,
+  override val olMarginLeft: Int,
+  override val olMarkerFontWeight: Int?,
+  override val olMarkerColor: Int?,
+  // Unordered List
+  override val ulGapWidth: Int,
+  override val ulMarginLeft: Int,
+  override val ulBulletSize: Int,
+  override val ulBulletColor: Int,
+  // Checkbox List
+  override val ulCheckboxBoxColor: Int,
+  override val ulCheckboxBoxSize: Int,
+  override val ulCheckboxGapWidth: Int,
+  override val ulCheckboxMarginLeft: Int,
+  // Links
+  override val aColor: Int,
+  override val aUnderline: Boolean,
+  val aPressColor: Int,
+  // Code Blocks
+  override val codeBlockColor: Int,
+  override val codeBlockBackgroundColor: Int,
+  override val codeBlockRadius: Float,
+  // Inline Code
+  override val inlineCodeColor: Int,
+  override val inlineCodeBackgroundColor: Int,
+  // Mentions
+  override val mentionsStyle: Map<String, MentionStyle>,
+) : EnrichedStyle {
+  companion object {
+    fun fromReadableMap(
+      context: ReactContext,
+      fontSize: Int,
+      map: ReadableMap,
+      allowFontScaling: Boolean,
+    ): EnrichedTextStyle {
+      val h1 = map.getMap("h1")
+      val h2 = map.getMap("h2")
+      val h3 = map.getMap("h3")
+      val h4 = map.getMap("h4")
+      val h5 = map.getMap("h5")
+      val h6 = map.getMap("h6")
+      val blockquote = map.getMap("blockquote")
+      val orderedList = map.getMap("ol")
+      val unorderedList = map.getMap("ul")
+      val checkboxList = map.getMap("ulCheckbox")
+      val link = map.getMap("a")
+      val codeblock = map.getMap("codeblock")
+      val inlineCode = map.getMap("code")
+      val mentions = map.getMap("mention")
+
+      return EnrichedTextStyle(
+        h1FontSize = parseFloat(h1, "fontSize", allowFontScaling).toInt(),
+        h1Bold = h1?.getBoolean("bold") ?: false,
+        h2FontSize = parseFloat(h2, "fontSize", allowFontScaling).toInt(),
+        h2Bold = h2?.getBoolean("bold") ?: false,
+        h3FontSize = parseFloat(h3, "fontSize", allowFontScaling).toInt(),
+        h3Bold = h3?.getBoolean("bold") ?: false,
+        h4FontSize = parseFloat(h4, "fontSize", allowFontScaling).toInt(),
+        h4Bold = h4?.getBoolean("bold") ?: false,
+        h5FontSize = parseFloat(h5, "fontSize", allowFontScaling).toInt(),
+        h5Bold = h5?.getBoolean("bold") ?: false,
+        h6FontSize = parseFloat(h6, "fontSize", allowFontScaling).toInt(),
+        h6Bold = h6?.getBoolean("bold") ?: false,
+        blockquoteColor = parseOptionalColor(context, blockquote, "color"),
+        blockquoteBorderColor = parseColor(context, blockquote, "borderColor"),
+        blockquoteStripeWidth = parseFloat(blockquote, "borderWidth", allowFontScaling).toInt(),
+        blockquoteGapWidth = parseFloat(blockquote, "gapWidth", allowFontScaling).toInt(),
+        olGapWidth = parseFloat(orderedList, "gapWidth", allowFontScaling).toInt(),
+        olMarginLeft = calculateOlMarginLeft(fontSize, parseFloat(orderedList, "marginLeft", allowFontScaling).toInt()),
+        olMarkerFontWeight = parseOptionalFontWeight(orderedList, "markerFontWeight"),
+        olMarkerColor = parseOptionalColor(context, orderedList, "markerColor"),
+        ulGapWidth = parseFloat(unorderedList, "gapWidth", allowFontScaling).toInt(),
+        ulMarginLeft = parseFloat(unorderedList, "marginLeft", allowFontScaling).toInt(),
+        ulBulletSize = parseFloat(unorderedList, "bulletSize", allowFontScaling).toInt(),
+        ulBulletColor = parseColor(context, unorderedList, "bulletColor"),
+        ulCheckboxBoxColor = parseColor(context, checkboxList, "boxColor"),
+        ulCheckboxBoxSize = parseFloat(checkboxList, "boxSize", allowFontScaling).toInt(),
+        ulCheckboxGapWidth = parseFloat(checkboxList, "gapWidth", allowFontScaling).toInt(),
+        ulCheckboxMarginLeft = parseFloat(checkboxList, "marginLeft", allowFontScaling).toInt(),
+        aColor = parseColor(context, link, "color"),
+        aUnderline = parseIsUnderline(link),
+        aPressColor = parseColor(context, link, "pressColor"),
+        codeBlockColor = parseColor(context, codeblock, "color"),
+        codeBlockBackgroundColor = parseColorWithOpacity(context, codeblock, "backgroundColor", 80),
+        codeBlockRadius = parseFloat(codeblock, "borderRadius", allowFontScaling),
+        inlineCodeColor = parseColor(context, inlineCode, "color"),
+        inlineCodeBackgroundColor = parseColorWithOpacity(context, inlineCode, "backgroundColor", 80),
+        mentionsStyle = parseMentionsStyle(context, mentions),
+      )
+    }
+
+    private fun parseFloat(
+      map: ReadableMap?,
+      key: String,
+      allowFontScaling: Boolean,
+    ): Float {
+      if (map == null || !map.hasKey(key) || map.isNull(key)) return 0f
+      return ceil(pixelFromSpOrDp(map.getDouble(key), allowFontScaling))
+    }
+
+    private fun parseColor(
+      context: ReactContext,
+      map: ReadableMap?,
+      key: String,
+    ): Int {
+      val colorDouble = map?.getDouble(key) ?: throw Error("Key $key is missing or null")
+      return ColorPropConverter.getColor(colorDouble, context) ?: Color.BLACK
+    }
+
+    private fun parseOptionalColor(
+      context: ReactContext,
+      map: ReadableMap?,
+      key: String,
+    ): Int? {
+      if (map == null || !map.hasKey(key) || map.isNull(key)) return null
+      return ColorPropConverter.getColor(map.getDouble(key), context)
+    }
+
+    private fun parseColorWithOpacity(
+      context: ReactContext,
+      map: ReadableMap?,
+      key: String,
+      opacity: Int,
+    ): Int {
+      val color = parseColor(context, map, key)
+      if (Color.alpha(color) != 255) return color
+      return (color and 0x00FFFFFF) or (opacity.coerceIn(0, 255) shl 24)
+    }
+
+    private fun parseIsUnderline(map: ReadableMap?): Boolean = map?.getString("textDecorationLine") == "underline"
+
+    private fun parseOptionalFontWeight(
+      map: ReadableMap?,
+      key: String,
+    ): Int? {
+      val weight = map?.getString(key) ?: return null
+      return parseFontWeight(weight)
+    }
+
+    private fun calculateOlMarginLeft(
+      fontSize: Int,
+      userMargin: Int,
+    ): Int {
+      val leadMargin = fontSize / 2
+      return leadMargin + userMargin
+    }
+
+    private fun parseMentionsStyle(
+      context: ReactContext,
+      map: ReadableMap?,
+    ): Map<String, MentionStyle> {
+      val result = mutableMapOf<String, MentionStyle>()
+      val iterator = map?.keySetIterator() ?: return result
+      while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+        val value = map.getMap(key) ?: continue
+
+        result[key] =
+          MentionStyle(
+            color = parseColor(context, value, "color"),
+            backgroundColor = parseColorWithOpacity(context, value, "backgroundColor", 80),
+            underline = parseIsUnderline(value),
+            pressColor = parseColor(context, value, "pressColor"),
+            pressBackgroundColor = parseColorWithOpacity(context, value, "pressBackgroundColor", 80),
+          )
+      }
+      return result
+    }
+  }
+}