react-native-enriched 0.2.1 → 0.4.0

package/android/src/main/java/com/swmansion/enriched/textinput/spans/EnrichedInputUnorderedListSpan.kt

@@ -0,0 +1,14 @@
+package com.swmansion.enriched.textinput.spans
+
+import com.swmansion.enriched.common.spans.EnrichedUnorderedListSpan
+import com.swmansion.enriched.textinput.spans.interfaces.EnrichedInputSpan
+import com.swmansion.enriched.textinput.styles.HtmlStyle
+
+class EnrichedInputUnorderedListSpan(
+  htmlStyle: HtmlStyle,
+) : EnrichedUnorderedListSpan(htmlStyle),
+  EnrichedInputSpan {
+  override val dependsOnHtmlStyle: Boolean = true
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedInputUnorderedListSpan = EnrichedInputUnorderedListSpan(htmlStyle)
+}

package/android/src/main/java/com/swmansion/enriched/textinput/spans/EnrichedSpans.kt

@@ -0,0 +1,241 @@
+package com.swmansion.enriched.textinput.spans
+
+import com.swmansion.enriched.textinput.styles.HtmlStyle
+
+interface ISpanConfig {
+  val clazz: Class<*>
+}
+
+data class BaseSpanConfig(
+  override val clazz: Class<*>,
+) : ISpanConfig
+
+data class ParagraphSpanConfig(
+  override val clazz: Class<*>,
+  val isContinuous: Boolean,
+) : ISpanConfig
+
+data class ListSpanConfig(
+  override val clazz: Class<*>,
+  val shortcut: String?,
+) : ISpanConfig
+
+data class StylesMergingConfig(
+  // styles that should be removed when we apply specific style
+  val conflictingStyles: Array<String> = emptyArray(),
+  // styles that should block setting specific style
+  val blockingStyles: Array<String> = emptyArray(),
+)
+
+object EnrichedSpans {
+  // inline styles
+  const val BOLD = "bold"
+  const val ITALIC = "italic"
+  const val UNDERLINE = "underline"
+  const val STRIKETHROUGH = "strikethrough"
+  const val INLINE_CODE = "inline_code"
+
+  // paragraph styles
+  const val H1 = "h1"
+  const val H2 = "h2"
+  const val H3 = "h3"
+  const val H4 = "h4"
+  const val H5 = "h5"
+  const val H6 = "h6"
+  const val BLOCK_QUOTE = "block_quote"
+  const val CODE_BLOCK = "code_block"
+
+  // list styles
+  const val UNORDERED_LIST = "unordered_list"
+  const val ORDERED_LIST = "ordered_list"
+  const val CHECKBOX_LIST = "checkbox_list"
+
+  // parametrized styles
+  const val LINK = "link"
+  const val IMAGE = "image"
+  const val MENTION = "mention"
+
+  val inlineSpans: Map<String, BaseSpanConfig> =
+    mapOf(
+      BOLD to BaseSpanConfig(EnrichedInputBoldSpan::class.java),
+      ITALIC to BaseSpanConfig(EnrichedInputItalicSpan::class.java),
+      UNDERLINE to BaseSpanConfig(EnrichedInputUnderlineSpan::class.java),
+      STRIKETHROUGH to BaseSpanConfig(EnrichedInputStrikeThroughSpan::class.java),
+      INLINE_CODE to BaseSpanConfig(EnrichedInputInlineCodeSpan::class.java),
+    )
+
+  val paragraphSpans: Map<String, ParagraphSpanConfig> =
+    mapOf(
+      H1 to ParagraphSpanConfig(EnrichedInputH1Span::class.java, false),
+      H2 to ParagraphSpanConfig(EnrichedInputH2Span::class.java, false),
+      H3 to ParagraphSpanConfig(EnrichedInputH3Span::class.java, false),
+      H4 to ParagraphSpanConfig(EnrichedInputH4Span::class.java, false),
+      H5 to ParagraphSpanConfig(EnrichedInputH5Span::class.java, false),
+      H6 to ParagraphSpanConfig(EnrichedInputH6Span::class.java, false),
+      BLOCK_QUOTE to ParagraphSpanConfig(EnrichedInputBlockQuoteSpan::class.java, true),
+      CODE_BLOCK to ParagraphSpanConfig(EnrichedInputCodeBlockSpan::class.java, true),
+    )
+
+  val listSpans: Map<String, ListSpanConfig> =
+    mapOf(
+      UNORDERED_LIST to ListSpanConfig(EnrichedInputUnorderedListSpan::class.java, "- "),
+      ORDERED_LIST to ListSpanConfig(EnrichedInputOrderedListSpan::class.java, "1. "),
+      CHECKBOX_LIST to ListSpanConfig(EnrichedInputCheckboxListSpan::class.java, null),
+    )
+
+  val parametrizedStyles: Map<String, BaseSpanConfig> =
+    mapOf(
+      LINK to BaseSpanConfig(EnrichedInputLinkSpan::class.java),
+      IMAGE to BaseSpanConfig(EnrichedInputImageSpan::class.java),
+      MENTION to BaseSpanConfig(EnrichedInputMentionSpan::class.java),
+    )
+
+  val allSpans: Map<String, ISpanConfig> = inlineSpans + paragraphSpans + listSpans + parametrizedStyles
+
+  fun getMergingConfigForStyle(
+    style: String,
+    htmlStyle: HtmlStyle,
+  ): StylesMergingConfig? =
+    when (style) {
+      BOLD -> {
+        val blockingStyles = mutableListOf(CODE_BLOCK)
+        if (htmlStyle.h1Bold) blockingStyles.add(H1)
+        if (htmlStyle.h2Bold) blockingStyles.add(H2)
+        if (htmlStyle.h3Bold) blockingStyles.add(H3)
+        if (htmlStyle.h4Bold) blockingStyles.add(H4)
+        if (htmlStyle.h5Bold) blockingStyles.add(H5)
+        if (htmlStyle.h6Bold) blockingStyles.add(H6)
+        StylesMergingConfig(blockingStyles = blockingStyles.toTypedArray())
+      }
+
+      ITALIC -> {
+        StylesMergingConfig(
+          blockingStyles = arrayOf(CODE_BLOCK),
+        )
+      }
+
+      UNDERLINE -> {
+        StylesMergingConfig(
+          blockingStyles = arrayOf(CODE_BLOCK),
+        )
+      }
+
+      STRIKETHROUGH -> {
+        StylesMergingConfig(
+          blockingStyles = arrayOf(CODE_BLOCK),
+        )
+      }
+
+      INLINE_CODE -> {
+        StylesMergingConfig(
+          conflictingStyles = arrayOf(MENTION, LINK),
+          blockingStyles = arrayOf(CODE_BLOCK),
+        )
+      }
+
+      H1 -> {
+        val conflictingStyles = mutableListOf(H2, H3, H4, H5, H6, ORDERED_LIST, UNORDERED_LIST, CHECKBOX_LIST, BLOCK_QUOTE, CODE_BLOCK)
+        if (htmlStyle.h1Bold) conflictingStyles.add(BOLD)
+        StylesMergingConfig(conflictingStyles = conflictingStyles.toTypedArray())
+      }
+
+      H2 -> {
+        val conflictingStyles = mutableListOf(H1, H3, H4, H5, H6, ORDERED_LIST, UNORDERED_LIST, CHECKBOX_LIST, BLOCK_QUOTE, CODE_BLOCK)
+        if (htmlStyle.h2Bold) conflictingStyles.add(BOLD)
+        StylesMergingConfig(conflictingStyles = conflictingStyles.toTypedArray())
+      }
+
+      H3 -> {
+        val conflictingStyles = mutableListOf(H1, H2, H4, H5, H6, ORDERED_LIST, UNORDERED_LIST, CHECKBOX_LIST, BLOCK_QUOTE, CODE_BLOCK)
+        if (htmlStyle.h3Bold) conflictingStyles.add(BOLD)
+        StylesMergingConfig(conflictingStyles = conflictingStyles.toTypedArray())
+      }
+
+      H4 -> {
+        val conflictingStyles = mutableListOf(H1, H2, H3, H5, H6, ORDERED_LIST, UNORDERED_LIST, CHECKBOX_LIST, BLOCK_QUOTE, CODE_BLOCK)
+        if (htmlStyle.h4Bold) conflictingStyles.add(BOLD)
+        StylesMergingConfig(conflictingStyles = conflictingStyles.toTypedArray())
+      }
+
+      H5 -> {
+        val conflictingStyles = mutableListOf(H1, H2, H3, H4, H6, ORDERED_LIST, UNORDERED_LIST, CHECKBOX_LIST, BLOCK_QUOTE, CODE_BLOCK)
+        if (htmlStyle.h5Bold) conflictingStyles.add(BOLD)
+        StylesMergingConfig(conflictingStyles = conflictingStyles.toTypedArray())
+      }
+
+      H6 -> {
+        val conflictingStyles = mutableListOf(H1, H2, H3, H4, H5, ORDERED_LIST, UNORDERED_LIST, CHECKBOX_LIST, BLOCK_QUOTE, CODE_BLOCK)
+        if (htmlStyle.h6Bold) conflictingStyles.add(BOLD)
+        StylesMergingConfig(conflictingStyles = conflictingStyles.toTypedArray())
+      }
+
+      BLOCK_QUOTE -> {
+        StylesMergingConfig(
+          conflictingStyles = arrayOf(H1, H2, H3, H4, H5, H6, CODE_BLOCK, ORDERED_LIST, UNORDERED_LIST, CHECKBOX_LIST),
+        )
+      }
+
+      CODE_BLOCK -> {
+        StylesMergingConfig(
+          conflictingStyles =
+            arrayOf(
+              H1,
+              H2,
+              H3,
+              H4,
+              H5,
+              H6,
+              BOLD,
+              ITALIC,
+              UNDERLINE,
+              STRIKETHROUGH,
+              UNORDERED_LIST,
+              ORDERED_LIST,
+              CHECKBOX_LIST,
+              BLOCK_QUOTE,
+              INLINE_CODE,
+            ),
+        )
+      }
+
+      UNORDERED_LIST -> {
+        StylesMergingConfig(
+          conflictingStyles = arrayOf(H1, H2, H3, H4, H5, H6, ORDERED_LIST, CHECKBOX_LIST, CODE_BLOCK, BLOCK_QUOTE),
+        )
+      }
+
+      ORDERED_LIST -> {
+        StylesMergingConfig(
+          conflictingStyles = arrayOf(H1, H2, H3, H4, H5, H6, UNORDERED_LIST, CHECKBOX_LIST, CODE_BLOCK, BLOCK_QUOTE),
+        )
+      }
+
+      CHECKBOX_LIST -> {
+        StylesMergingConfig(
+          conflictingStyles = arrayOf(H1, H2, H3, H4, H5, H6, UNORDERED_LIST, ORDERED_LIST, CODE_BLOCK, BLOCK_QUOTE),
+        )
+      }
+
+      LINK -> {
+        StylesMergingConfig(
+          blockingStyles = arrayOf(INLINE_CODE, CODE_BLOCK, MENTION),
+        )
+      }
+
+      IMAGE -> {
+        StylesMergingConfig()
+      }
+
+      MENTION -> {
+        StylesMergingConfig(
+          blockingStyles = arrayOf(INLINE_CODE, CODE_BLOCK, LINK),
+        )
+      }
+
+      else -> {
+        null
+      }
+    }
+
+  fun isTypeContinuous(type: Class<*>): Boolean = paragraphSpans.values.find { it.clazz == type }?.isContinuous == true
+}

package/android/src/main/java/com/swmansion/enriched/textinput/spans/interfaces/EnrichedInputSpan.kt

@@ -0,0 +1,10 @@
+package com.swmansion.enriched.textinput.spans.interfaces
+
+import com.swmansion.enriched.common.spans.interfaces.EnrichedSpan
+import com.swmansion.enriched.textinput.styles.HtmlStyle
+
+interface EnrichedInputSpan : EnrichedSpan {
+  val dependsOnHtmlStyle: Boolean
+
+  fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedInputSpan
+}

package/android/src/main/java/com/swmansion/enriched/{styles → textinput/styles}/HtmlStyle.kt

@@ -1,4 +1,4 @@
-package com.swmansion.enriched.styles
+package com.swmansion.enriched.textinput.styles
 
 import android.graphics.Color
 import com.facebook.react.bridge.ColorPropConverter
@@ -6,54 +6,70 @@ import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.views.text.ReactTypefaceUtils.parseFontWeight
-import com.swmansion.enriched.EnrichedTextInputView
+import com.swmansion.enriched.common.EnrichedStyle
+import com.swmansion.enriched.common.MentionStyle
+import com.swmansion.enriched.textinput.EnrichedTextInputView
 import kotlin.Float
 import kotlin.Int
 import kotlin.String
 import kotlin.math.ceil
 
-class HtmlStyle {
+class HtmlStyle : EnrichedStyle {
   private var style: ReadableMap? = null
   private var view: EnrichedTextInputView? = null
 
   // Default values are ignored as they are specified on the JS side.
   // They are specified only because they are required by the constructor.
   // JS passes them as a prop - so they are initialized after the constructor is called.
-  var h1FontSize: Int = 72
-  var h1Bold: Boolean = false
+  override var h1FontSize: Int = 72
+  override var h1Bold: Boolean = false
 
-  var h2FontSize: Int = 64
-  var h2Bold: Boolean = false
+  override var h2FontSize: Int = 64
+  override var h2Bold: Boolean = false
 
-  var h3FontSize: Int = 56
-  var h3Bold: Boolean = false
+  override var h3FontSize: Int = 56
+  override var h3Bold: Boolean = false
 
-  var blockquoteColor: Int? = null
-  var blockquoteBorderColor: Int = Color.BLACK
-  var blockquoteStripeWidth: Int = 2
-  var blockquoteGapWidth: Int = 16
+  override var h4FontSize: Int = 48
+  override var h4Bold: Boolean = false
 
-  var olGapWidth: Int = 16
-  var olMarginLeft: Int = 24
-  var olMarkerFontWeight: Int? = null
-  var olMarkerColor: Int? = null
+  override var h5FontSize: Int = 40
+  override var h5Bold: Boolean = false
 
-  var ulGapWidth: Int = 16
-  var ulMarginLeft: Int = 24
-  var ulBulletSize: Int = 8
-  var ulBulletColor: Int = Color.BLACK
+  override var h6FontSize: Int = 32
+  override var h6Bold: Boolean = false
 
-  var aColor: Int = Color.BLACK
-  var aUnderline: Boolean = true
+  override var blockquoteColor: Int? = null
+  override var blockquoteBorderColor: Int = Color.BLACK
+  override var blockquoteStripeWidth: Int = 2
+  override var blockquoteGapWidth: Int = 16
 
-  var codeBlockColor: Int = Color.BLACK
-  var codeBlockBackgroundColor: Int = Color.BLACK
-  var codeBlockRadius: Float = 4f
+  override var olGapWidth: Int = 16
+  override var olMarginLeft: Int = 24
+  override var olMarkerFontWeight: Int? = null
+  override var olMarkerColor: Int? = null
 
-  var inlineCodeColor: Int = Color.BLACK
-  var inlineCodeBackgroundColor: Int = Color.BLACK
+  override var ulGapWidth: Int = 16
+  override var ulMarginLeft: Int = 24
+  override var ulBulletSize: Int = 8
+  override var ulBulletColor: Int = Color.BLACK
 
-  var mentionsStyle: MutableMap<String, MentionStyle> = mutableMapOf()
+  override var ulCheckboxBoxSize: Int = 50
+  override var ulCheckboxGapWidth: Int = 16
+  override var ulCheckboxMarginLeft: Int = 24
+  override var ulCheckboxBoxColor: Int = Color.BLACK
+
+  override var aColor: Int = Color.BLACK
+  override var aUnderline: Boolean = true
+
+  override var codeBlockColor: Int = Color.BLACK
+  override var codeBlockBackgroundColor: Int = Color.BLACK
+  override var codeBlockRadius: Float = 4f
+
+  override var inlineCodeColor: Int = Color.BLACK
+  override var inlineCodeBackgroundColor: Int = Color.BLACK
+
+  override var mentionsStyle: MutableMap<String, MentionStyle> = mutableMapOf()
 
   constructor(view: EnrichedTextInputView?, style: ReadableMap?) {
     this.view = view
@@ -77,6 +93,18 @@ class HtmlStyle {
     h3FontSize = parseFloat(h3Style, "fontSize").toInt()
     h3Bold = h3Style?.getBoolean("bold") == true
 
+    val h4Style = style.getMap("h4")
+    h4FontSize = parseFloat(h4Style, "fontSize").toInt()
+    h4Bold = h4Style?.getBoolean("bold") == true
+
+    val h5Style = style.getMap("h5")
+    h5FontSize = parseFloat(h5Style, "fontSize").toInt()
+    h5Bold = h5Style?.getBoolean("bold") == true
+
+    val h6Style = style.getMap("h6")
+    h6FontSize = parseFloat(h6Style, "fontSize").toInt()
+    h6Bold = h6Style?.getBoolean("bold") == true
+
     val blockquoteStyle = style.getMap("blockquote")
     blockquoteColor = parseOptionalColor(blockquoteStyle, "color")
     blockquoteBorderColor = parseColor(blockquoteStyle, "borderColor")
@@ -97,6 +125,12 @@ class HtmlStyle {
     ulMarginLeft = parseFloat(ulStyle, "marginLeft").toInt()
     ulBulletSize = parseFloat(ulStyle, "bulletSize").toInt()
 
+    val ulCheckboxStyle = style.getMap("ulCheckbox")
+    ulCheckboxBoxSize = parseFloat(ulCheckboxStyle, "boxSize").toInt()
+    ulCheckboxGapWidth = parseFloat(ulCheckboxStyle, "gapWidth").toInt()
+    ulCheckboxMarginLeft = parseFloat(ulCheckboxStyle, "marginLeft").toInt()
+    ulCheckboxBoxColor = parseColor(ulCheckboxStyle, "boxColor")
+
     val aStyle = style.getMap("a")
     aColor = parseColor(aStyle, "color")
     aUnderline = parseIsUnderline(aStyle)
@@ -114,19 +148,29 @@ class HtmlStyle {
     mentionsStyle = parseMentionsStyle(mentionStyle)
   }
 
-  private fun parseFloat(map: ReadableMap?, key: String): Float {
+  private fun parseFloat(
+    map: ReadableMap?,
+    key: String,
+  ): Float {
     val safeMap = ensureValueIsSet(map, key)
 
     val value = safeMap.getDouble(key)
     return ceil(PixelUtil.toPixelFromSP(value))
   }
 
-  private fun parseColorWithOpacity(map: ReadableMap?, key: String, opacity: Int): Int {
+  private fun parseColorWithOpacity(
+    map: ReadableMap?,
+    key: String,
+    opacity: Int,
+  ): Int {
     val color = parseColor(map, key)
     return withOpacity(color, opacity)
   }
 
-  private fun parseOptionalColor(map: ReadableMap?, key: String): Int? {
+  private fun parseOptionalColor(
+    map: ReadableMap?,
+    key: String,
+  ): Int? {
     if (map == null) return null
     if (!map.hasKey(key)) return null
     if (map.isNull(key)) return null
@@ -134,7 +178,10 @@ class HtmlStyle {
     return parseColor(map, key)
   }
 
-  private fun parseColor(map: ReadableMap?, key: String): Int {
+  private fun parseColor(
+    map: ReadableMap?,
+    key: String,
+  ): Int {
     val safeMap = ensureValueIsSet(map, key)
 
     val color = safeMap.getDouble(key)
@@ -146,7 +193,10 @@ class HtmlStyle {
     return parsedColor
   }
 
-  private fun withOpacity(color: Int, alpha: Int): Int {
+  private fun withOpacity(
+    color: Int,
+    alpha: Int,
+  ): Int {
     // Do not apply opacity to transparent color
     if (Color.alpha(color) == 0) return color
     val a = alpha.coerceIn(0, 255)
@@ -164,14 +214,20 @@ class HtmlStyle {
     throw Error("Specified textDecorationLine value is not supported: $underline. Supported values are 'underline' and 'none'.")
   }
 
-  private fun calculateOlMarginLeft(view: EnrichedTextInputView?, userMargin: Int): Int {
+  private fun calculateOlMarginLeft(
+    view: EnrichedTextInputView?,
+    userMargin: Int,
+  ): Int {
     val fontSize = view?.fontSize?.toInt() ?: 0
     val leadMargin = fontSize / 2
 
     return leadMargin + userMargin
   }
 
-  private fun ensureValueIsSet(map: ReadableMap?, key: String): ReadableMap {
+  private fun ensureValueIsSet(
+    map: ReadableMap?,
+    key: String,
+  ): ReadableMap {
     if (map == null) throw Error("Style map cannot be null")
 
     if (!map.hasKey(key)) throw Error("Style map must contain key: $key")
@@ -186,24 +242,27 @@ class HtmlStyle {
 
     val parsedMentionsStyle: MutableMap<String, MentionStyle> = mutableMapOf()
 
-     val iterator = mentionsStyle.keySetIterator()
-        while (iterator.hasNextKey()) {
-          val key = iterator.nextKey()
-          val value = mentionsStyle.getMap(key)
+    val iterator = mentionsStyle.keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      val value = mentionsStyle.getMap(key)
 
-          if (value == null) throw Error("Mention style for key '$key' cannot be null")
+      if (value == null) throw Error("Mention style for key '$key' cannot be null")
 
-          val color = parseColor(value, "color")
-          val backgroundColor = parseColorWithOpacity(value, "backgroundColor", 80)
-          val isUnderline = parseIsUnderline(value)
-          val parsedStyle = MentionStyle(color, backgroundColor, isUnderline)
-          parsedMentionsStyle.put(key, parsedStyle)
-        }
+      val color = parseColor(value, "color")
+      val backgroundColor = parseColorWithOpacity(value, "backgroundColor", 80)
+      val isUnderline = parseIsUnderline(value)
+      val parsedStyle = MentionStyle(color, backgroundColor, isUnderline)
+      parsedMentionsStyle.put(key, parsedStyle)
+    }
 
     return parsedMentionsStyle
   }
 
-  private fun parseOptionalFontWeight(map: ReadableMap?, key: String): Int? {
+  private fun parseOptionalFontWeight(
+    map: ReadableMap?,
+    key: String,
+  ): Int? {
     if (map == null) return null
     if (!map.hasKey(key)) return null
     if (map.isNull(key)) return null
@@ -222,6 +281,12 @@ class HtmlStyle {
       h2Bold == other.h2Bold &&
       h3FontSize == other.h3FontSize &&
       h3Bold == other.h3Bold &&
+      h4FontSize == other.h4FontSize &&
+      h4Bold == other.h4Bold &&
+      h5FontSize == other.h5FontSize &&
+      h5Bold == other.h5Bold &&
+      h6FontSize == other.h6FontSize &&
+      h6Bold == other.h6Bold &&
 
       blockquoteColor == other.blockquoteColor &&
       blockquoteBorderColor == other.blockquoteBorderColor &&
@@ -238,6 +303,11 @@ class HtmlStyle {
       ulBulletSize == other.ulBulletSize &&
       ulBulletColor == other.ulBulletColor &&
 
+      ulCheckboxBoxSize == other.ulCheckboxBoxSize &&
+      ulCheckboxGapWidth == other.ulCheckboxGapWidth &&
+      ulCheckboxMarginLeft == other.ulCheckboxMarginLeft &&
+      ulCheckboxBoxColor == other.ulCheckboxBoxColor &&
+
       aColor == other.aColor &&
       aUnderline == other.aUnderline &&
 
@@ -251,7 +321,6 @@ class HtmlStyle {
       mentionsStyle == other.mentionsStyle
   }
 
-
   override fun hashCode(): Int {
     var result = h1FontSize.hashCode()
     result = 31 * result + h1Bold.hashCode()
@@ -259,6 +328,12 @@ class HtmlStyle {
     result = 31 * result + h2Bold.hashCode()
     result = 31 * result + h3FontSize.hashCode()
     result = 31 * result + h3Bold.hashCode()
+    result = 31 * result + h4FontSize.hashCode()
+    result = 31 * result + h4Bold.hashCode()
+    result = 31 * result + h5FontSize.hashCode()
+    result = 31 * result + h5Bold.hashCode()
+    result = 31 * result + h6FontSize.hashCode()
+    result = 31 * result + h6Bold.hashCode()
 
     result = 31 * result + (blockquoteColor ?: 0)
     result = 31 * result + blockquoteBorderColor.hashCode()
@@ -275,6 +350,11 @@ class HtmlStyle {
     result = 31 * result + ulBulletSize.hashCode()
     result = 31 * result + ulBulletColor.hashCode()
 
+    result = 31 * result + ulCheckboxBoxSize.hashCode()
+    result = 31 * result + ulCheckboxGapWidth.hashCode()
+    result = 31 * result + ulCheckboxMarginLeft.hashCode()
+    result = 31 * result + ulCheckboxBoxColor.hashCode()
+
     result = 31 * result + aColor.hashCode()
     result = 31 * result + aUnderline.hashCode()
 
@@ -289,12 +369,4 @@ class HtmlStyle {
 
     return result
   }
-
-  companion object {
-    data class MentionStyle(
-      val color: Int,
-      val backgroundColor: Int,
-      val underline: Boolean
-    )
-  }
 }

package/android/src/main/java/com/swmansion/enriched/{styles → textinput/styles}/InlineStyles.kt

@@ -1,13 +1,20 @@
-package com.swmansion.enriched.styles
+package com.swmansion.enriched.textinput.styles
 
 import android.text.Editable
 import android.text.Spannable
-import com.swmansion.enriched.EnrichedTextInputView
-import com.swmansion.enriched.spans.EnrichedSpans
-import com.swmansion.enriched.utils.getSafeSpanBoundaries
-
-class InlineStyles(private val view: EnrichedTextInputView) {
-  private fun <T>setSpan(spannable: Spannable, type: Class<T>, start: Int, end: Int) {
+import com.swmansion.enriched.textinput.EnrichedTextInputView
+import com.swmansion.enriched.textinput.spans.EnrichedSpans
+import com.swmansion.enriched.textinput.utils.getSafeSpanBoundaries
+
+class InlineStyles(
+  private val view: EnrichedTextInputView,
+) {
+  private fun <T> setSpan(
+    spannable: Spannable,
+    type: Class<T>,
+    start: Int,
+    end: Int,
+  ) {
     val previousSpanStart = (start - 1).coerceAtLeast(0)
     val previousSpanEnd = previousSpanStart + 1
     val nextSpanStart = (end + 1).coerceAtMost(spannable.length)
@@ -37,7 +44,12 @@ class InlineStyles(private val view: EnrichedTextInputView) {
     spannable.setSpan(span, safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
   }
 
-  private fun <T>setAndMergeSpans(spannable: Spannable, type: Class<T>, start: Int, end: Int) {
+  private fun <T> setAndMergeSpans(
+    spannable: Spannable,
+    type: Class<T>,
+    start: Int,
+    end: Int,
+  ) {
     val spans = spannable.getSpans(start, end, type)
 
     // No spans setup for current selection, means we just need to assign new span
@@ -89,7 +101,10 @@ class InlineStyles(private val view: EnrichedTextInputView) {
     }
   }
 
-  fun afterTextChanged(s: Editable, endCursorPosition: Int) {
+  fun afterTextChanged(
+    s: Editable,
+    endCursorPosition: Int,
+  ) {
     for ((style, config) in EnrichedSpans.inlineSpans) {
       val start = view.spanState?.getStart(style) ?: continue
       var end = endCursorPosition
@@ -128,7 +143,11 @@ class InlineStyles(private val view: EnrichedTextInputView) {
     view.selection.validateStyles()
   }
 
-  fun removeStyle(name: String, start: Int, end: Int): Boolean {
+  fun removeStyle(
+    name: String,
+    start: Int,
+    end: Int,
+  ): Boolean {
     val config = EnrichedSpans.inlineSpans[name] ?: return false
     val spannable = view.text as Spannable
     val spans = spannable.getSpans(start, end, config.clazz)
@@ -141,7 +160,5 @@ class InlineStyles(private val view: EnrichedTextInputView) {
     return true
   }
 
-  fun getStyleRange(): Pair<Int, Int> {
-    return view.selection?.getInlineSelection() ?: Pair(0, 0)
-  }
+  fun getStyleRange(): Pair<Int, Int> = view.selection?.getInlineSelection() ?: Pair(0, 0)
 }