react-native-enriched 0.3.0 → 0.4.1

package/android/src/main/java/com/swmansion/enriched/{utils → common/parser}/EnrichedParser.java

@@ -1,6 +1,5 @@
-package com.swmansion.enriched.utils;
+package com.swmansion.enriched.common.parser;
 
-import android.graphics.drawable.Drawable;
 import android.text.Editable;
 import android.text.Layout;
 import android.text.Spannable;
@@ -9,29 +8,29 @@ import android.text.Spanned;
 import android.text.TextUtils;
 import android.text.style.AlignmentSpan;
 import android.text.style.ParagraphStyle;
-import com.swmansion.enriched.spans.EnrichedBlockQuoteSpan;
-import com.swmansion.enriched.spans.EnrichedBoldSpan;
-import com.swmansion.enriched.spans.EnrichedCodeBlockSpan;
-import com.swmansion.enriched.spans.EnrichedH1Span;
-import com.swmansion.enriched.spans.EnrichedH2Span;
-import com.swmansion.enriched.spans.EnrichedH3Span;
-import com.swmansion.enriched.spans.EnrichedH4Span;
-import com.swmansion.enriched.spans.EnrichedH5Span;
-import com.swmansion.enriched.spans.EnrichedH6Span;
-import com.swmansion.enriched.spans.EnrichedImageSpan;
-import com.swmansion.enriched.spans.EnrichedInlineCodeSpan;
-import com.swmansion.enriched.spans.EnrichedItalicSpan;
-import com.swmansion.enriched.spans.EnrichedLinkSpan;
-import com.swmansion.enriched.spans.EnrichedMentionSpan;
-import com.swmansion.enriched.spans.EnrichedOrderedListSpan;
-import com.swmansion.enriched.spans.EnrichedStrikeThroughSpan;
-import com.swmansion.enriched.spans.EnrichedUnderlineSpan;
-import com.swmansion.enriched.spans.EnrichedUnorderedListSpan;
-import com.swmansion.enriched.spans.interfaces.EnrichedBlockSpan;
-import com.swmansion.enriched.spans.interfaces.EnrichedInlineSpan;
-import com.swmansion.enriched.spans.interfaces.EnrichedParagraphSpan;
-import com.swmansion.enriched.spans.interfaces.EnrichedZeroWidthSpaceSpan;
-import com.swmansion.enriched.styles.HtmlStyle;
+import com.swmansion.enriched.common.EnrichedConstants;
+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;
+import com.swmansion.enriched.common.spans.interfaces.EnrichedBlockSpan;
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan;
+import com.swmansion.enriched.common.spans.interfaces.EnrichedParagraphSpan;
+import com.swmansion.enriched.common.spans.interfaces.EnrichedZeroWidthSpaceSpan;
 import java.io.IOException;
 import java.io.StringReader;
 import java.util.HashMap;
@@ -54,16 +53,6 @@ import org.xml.sax.XMLReader;
  */
 public class EnrichedParser {
   /** Retrieves images for HTML <img> tags. */
-  public interface ImageGetter {
-    /**
-     * This method is called when the HTML parser encounters an &lt;img&gt; tag. The <code>source
-     * </code> argument is the string from the "src" attribute; the return value should be a
-     * Drawable representation of the image or <code>null</code> for a generic replacement image.
-     * Make sure you call setBounds() on your Drawable if it doesn't already have its bounds set.
-     */
-    Drawable getDrawable(String source);
-  }
-
   private EnrichedParser() {}
 
   /**
@@ -74,15 +63,7 @@ public class EnrichedParser {
     private static final HTMLSchema schema = new HTMLSchema();
   }
 
-  /**
-   * Returns displayable styled text from the provided HTML string. Any &lt;img&gt; tags in the HTML
-   * will use the specified ImageGetter to request a representation of the image (use null if you
-   * don't want this) and the specified TagHandler to handle unknown tags (specify null if you don't
-   * want this).
-   *
-   * <p>This uses TagSoup to handle real HTML, including all of the brokenness found in the wild.
-   */
-  public static Spanned fromHtml(String source, HtmlStyle style, ImageGetter imageGetter) {
+  public static <T> Spanned fromHtml(String source, T style, EnrichedSpanFactory<T> spanFactory) {
     Parser parser = new Parser();
     try {
       parser.setProperty(Parser.schemaProperty, HtmlParser.schema);
@@ -91,7 +72,7 @@ public class EnrichedParser {
       throw new RuntimeException(e);
     }
     HtmlToSpannedConverter converter =
-        new HtmlToSpannedConverter(source, style, imageGetter, parser);
+        new HtmlToSpannedConverter(source, style, parser, spanFactory);
     return converter.convert();
   }
 
@@ -156,6 +137,8 @@ public class EnrichedParser {
         return "ul";
       } else if (span instanceof EnrichedOrderedListSpan) {
         return "ol";
+      } else if (span instanceof EnrichedCheckboxListSpan) {
+        return "ul data-type=\"checkbox\"";
       } else if (span instanceof EnrichedH1Span) {
         return "h1";
       } else if (span instanceof EnrichedH2Span) {
@@ -177,6 +160,8 @@ public class EnrichedParser {
   private static void withinBlock(StringBuilder out, Spanned text, int start, int end) {
     boolean isInUlList = false;
     boolean isInOlList = false;
+    boolean isInCheckboxList = false;
+
     int next;
     for (int i = start; i <= end; i = next) {
       next = TextUtils.indexOf(text, '\n', i, end);
@@ -192,6 +177,10 @@ public class EnrichedParser {
           // Current paragraph is no longer a list item; close the previously opened list
           isInOlList = false;
           out.append("</ol>\n");
+        } else if (isInCheckboxList) {
+          // Current paragraph is no longer a list item; close the previously opened list
+          isInCheckboxList = false;
+          out.append("</ul>\n");
         }
         out.append("<br>\n");
       } else {
@@ -200,6 +189,7 @@ public class EnrichedParser {
         String tag = getBlockTag(paragraphStyles);
         boolean isUlListItem = tag.equals("ul");
         boolean isOlListItem = tag.equals("ol");
+        boolean isCheckboxListItem = tag.equals("ul data-type=\"checkbox\"");
 
         if (isInUlList && !isUlListItem) {
           // Current paragraph is no longer a list item; close the previously opened list
@@ -209,6 +199,10 @@ public class EnrichedParser {
           // Current paragraph is no longer a list item; close the previously opened list
           isInOlList = false;
           out.append("</ol>\n");
+        } else if (isInCheckboxList && !isCheckboxListItem) {
+          // Current paragraph is no longer a list item; close the previously opened list
+          isInCheckboxList = false;
+          out.append("</ul>\n");
         }
 
         if (isUlListItem && !isInUlList) {
@@ -219,14 +213,27 @@ public class EnrichedParser {
           // Current paragraph is the first item in a list
           isInOlList = true;
           out.append("<ol").append(">\n");
+        } else if (isCheckboxListItem && !isInCheckboxList) {
+          // Current paragraph is the first item in a list
+          isInCheckboxList = true;
+          out.append("<ul data-type=\"checkbox\">\n");
         }
 
-        boolean isList = isUlListItem || isOlListItem;
+        boolean isList = isUlListItem || isOlListItem || isCheckboxListItem;
         String tagType = isList ? "li" : tag;
-        out.append("<");
 
+        out.append("<");
         out.append(tagType);
 
+        if (isCheckboxListItem) {
+          EnrichedCheckboxListSpan[] checkboxSpans =
+              text.getSpans(i, next, EnrichedCheckboxListSpan.class);
+          if (checkboxSpans.length > 0) {
+            boolean isChecked = checkboxSpans[0].isChecked();
+            if (isChecked) out.append(" checked");
+          }
+        }
+
         out.append(">");
         withinParagraph(out, text, i, next);
         out.append("</");
@@ -238,6 +245,9 @@ public class EnrichedParser {
         } else if (next == end && isInOlList) {
           isInOlList = false;
           out.append("</ol>\n");
+        } else if (next == end && isInCheckboxList) {
+          isInCheckboxList = false;
+          out.append("</ul>\n");
         }
       }
       next++;
@@ -370,23 +380,24 @@ public class EnrichedParser {
   }
 }
 
-class HtmlToSpannedConverter implements ContentHandler {
-  private final HtmlStyle mStyle;
+class HtmlToSpannedConverter<T> implements ContentHandler {
+  private final EnrichedSpanFactory<T> mSpanFactory;
+  private final T mStyle;
   private final String mSource;
   private final XMLReader mReader;
   private final SpannableStringBuilder mSpannableStringBuilder;
-  private final EnrichedParser.ImageGetter mImageGetter;
   private static Integer currentOrderedListItemIndex = 0;
   private static Boolean isInOrderedList = false;
+  private static Boolean isInCheckboxList = false;
   private static Boolean isEmptyTag = false;
 
   public HtmlToSpannedConverter(
-      String source, HtmlStyle style, EnrichedParser.ImageGetter imageGetter, Parser parser) {
+      String source, T style, Parser parser, EnrichedSpanFactory<T> spanFactory) {
     mStyle = style;
     mSource = source;
     mSpannableStringBuilder = new SpannableStringBuilder();
-    mImageGetter = imageGetter;
     mReader = parser;
+    mSpanFactory = spanFactory;
   }
 
   public Spanned convert() {
@@ -454,6 +465,8 @@ class HtmlToSpannedConverter implements ContentHandler {
       startBlockElement(mSpannableStringBuilder);
     } else if (tag.equalsIgnoreCase("ul")) {
       isInOrderedList = false;
+      String dataType = attributes.getValue("", "data-type");
+      isInCheckboxList = "checkbox".equals(dataType);
       startBlockElement(mSpannableStringBuilder);
     } else if (tag.equalsIgnoreCase("ol")) {
       isInOrderedList = true;
@@ -461,7 +474,7 @@ class HtmlToSpannedConverter implements ContentHandler {
       startBlockElement(mSpannableStringBuilder);
     } else if (tag.equalsIgnoreCase("li")) {
       isEmptyTag = true;
-      startLi(mSpannableStringBuilder);
+      startLi(mSpannableStringBuilder, attributes);
     } else if (tag.equalsIgnoreCase("b")) {
       start(mSpannableStringBuilder, new Bold());
     } else if (tag.equalsIgnoreCase("i")) {
@@ -493,7 +506,7 @@ class HtmlToSpannedConverter implements ContentHandler {
     } else if (tag.equalsIgnoreCase("h6")) {
       startHeading(mSpannableStringBuilder, 6);
     } else if (tag.equalsIgnoreCase("img")) {
-      startImg(mSpannableStringBuilder, attributes, mImageGetter);
+      startImg(mSpannableStringBuilder, attributes, mSpanFactory);
     } else if (tag.equalsIgnoreCase("code")) {
       start(mSpannableStringBuilder, new Code());
     } else if (tag.equalsIgnoreCase("mention")) {
@@ -509,37 +522,40 @@ class HtmlToSpannedConverter implements ContentHandler {
     } else if (tag.equalsIgnoreCase("ul")) {
       endBlockElement(mSpannableStringBuilder);
     } else if (tag.equalsIgnoreCase("li")) {
-      endLi(mSpannableStringBuilder, mStyle);
+      endLi(mSpannableStringBuilder, mStyle, mSpanFactory);
     } else if (tag.equalsIgnoreCase("b")) {
-      end(mSpannableStringBuilder, Bold.class, new EnrichedBoldSpan(mStyle));
+      end(mSpannableStringBuilder, Bold.class, mSpanFactory.createBoldSpan(mStyle));
     } else if (tag.equalsIgnoreCase("i")) {
-      end(mSpannableStringBuilder, Italic.class, new EnrichedItalicSpan(mStyle));
+      end(mSpannableStringBuilder, Italic.class, mSpanFactory.createItalicSpan(mStyle));
     } else if (tag.equalsIgnoreCase("blockquote")) {
-      endBlockquote(mSpannableStringBuilder, mStyle);
+      endBlockquote(mSpannableStringBuilder, mStyle, mSpanFactory);
     } else if (tag.equalsIgnoreCase("codeblock")) {
-      endCodeBlock(mSpannableStringBuilder, mStyle);
+      endCodeBlock(mSpannableStringBuilder, mStyle, mSpanFactory);
     } else if (tag.equalsIgnoreCase("a")) {
-      endA(mSpannableStringBuilder, mStyle);
+      endA(mSpannableStringBuilder, mStyle, mSpanFactory);
     } else if (tag.equalsIgnoreCase("u")) {
-      end(mSpannableStringBuilder, Underline.class, new EnrichedUnderlineSpan(mStyle));
+      end(mSpannableStringBuilder, Underline.class, mSpanFactory.createUnderlineSpan(mStyle));
     } else if (tag.equalsIgnoreCase("s")) {
-      end(mSpannableStringBuilder, Strikethrough.class, new EnrichedStrikeThroughSpan(mStyle));
+      end(
+          mSpannableStringBuilder,
+          Strikethrough.class,
+          mSpanFactory.createStrikeThroughSpan(mStyle));
     } else if (tag.equalsIgnoreCase("h1")) {
-      endHeading(mSpannableStringBuilder, mStyle, 1);
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 1);
     } else if (tag.equalsIgnoreCase("h2")) {
-      endHeading(mSpannableStringBuilder, mStyle, 2);
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 2);
     } else if (tag.equalsIgnoreCase("h3")) {
-      endHeading(mSpannableStringBuilder, mStyle, 3);
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 3);
     } else if (tag.equalsIgnoreCase("h4")) {
-      endHeading(mSpannableStringBuilder, mStyle, 4);
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 4);
     } else if (tag.equalsIgnoreCase("h5")) {
-      endHeading(mSpannableStringBuilder, mStyle, 5);
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 5);
     } else if (tag.equalsIgnoreCase("h6")) {
-      endHeading(mSpannableStringBuilder, mStyle, 6);
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 6);
     } else if (tag.equalsIgnoreCase("code")) {
-      end(mSpannableStringBuilder, Code.class, new EnrichedInlineCodeSpan(mStyle));
+      end(mSpannableStringBuilder, Code.class, mSpanFactory.createInlineCodeSpan(mStyle));
     } else if (tag.equalsIgnoreCase("mention")) {
-      endMention(mSpannableStringBuilder, mStyle);
+      endMention(mSpannableStringBuilder, mStyle, mSpanFactory);
     }
   }
 
@@ -578,26 +594,31 @@ class HtmlToSpannedConverter implements ContentHandler {
     text.append('\n');
   }
 
-  private void startLi(Editable text) {
+  private void startLi(Editable text, Attributes attributes) {
     startBlockElement(text);
 
     if (isInOrderedList) {
       currentOrderedListItemIndex++;
-      start(text, new List("ol", currentOrderedListItemIndex));
+      start(text, new List("ordered", currentOrderedListItemIndex, false));
+    } else if (isInCheckboxList) {
+      String isChecked = attributes.getValue("", "checked");
+      start(text, new List("checked", 0, "checked".equals(isChecked)));
     } else {
-      start(text, new List("ul", 0));
+      start(text, new List("unordered", 0, false));
     }
   }
 
-  private static void endLi(Editable text, HtmlStyle style) {
+  private static <T> void endLi(Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     endBlockElement(text);
 
     List l = getLast(text, List.class);
     if (l != null) {
-      if (l.mType.equals("ol")) {
-        setParagraphSpanFromMark(text, l, new EnrichedOrderedListSpan(l.mIndex, style));
+      if (l.mType.equals("ordered")) {
+        setParagraphSpanFromMark(text, l, spanFactory.createOrderedListSpan(l.mIndex, style));
+      } else if (l.mType.equals("checked")) {
+        setParagraphSpanFromMark(text, l, spanFactory.createCheckboxListSpan(l.mChecked, style));
       } else {
-        setParagraphSpanFromMark(text, l, new EnrichedUnorderedListSpan(style));
+        setParagraphSpanFromMark(text, l, spanFactory.createUnorderedListSpan(style));
       }
     }
 
@@ -609,10 +630,11 @@ class HtmlToSpannedConverter implements ContentHandler {
     start(text, new Blockquote());
   }
 
-  private static void endBlockquote(Editable text, HtmlStyle style) {
+  private static <T> void endBlockquote(
+      Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     endBlockElement(text);
     Blockquote last = getLast(text, Blockquote.class);
-    setParagraphSpanFromMark(text, last, new EnrichedBlockQuoteSpan(style));
+    setParagraphSpanFromMark(text, last, spanFactory.createBlockQuoteSpan(style));
   }
 
   private void startCodeBlock(Editable text) {
@@ -620,10 +642,10 @@ class HtmlToSpannedConverter implements ContentHandler {
     start(text, new CodeBlock());
   }
 
-  private static void endCodeBlock(Editable text, HtmlStyle style) {
+  private static <T> void endCodeBlock(Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     endBlockElement(text);
     CodeBlock last = getLast(text, CodeBlock.class);
-    setParagraphSpanFromMark(text, last, new EnrichedCodeBlockSpan(style));
+    setParagraphSpanFromMark(text, last, spanFactory.createCodeBlockSpan(style));
   }
 
   private void startHeading(Editable text, int level) {
@@ -653,33 +675,34 @@ class HtmlToSpannedConverter implements ContentHandler {
     }
   }
 
-  private static void endHeading(Editable text, HtmlStyle style, int level) {
+  private static <T> void endHeading(
+      Editable text, T style, EnrichedSpanFactory<T> spanFactory, int level) {
     endBlockElement(text);
 
     switch (level) {
       case 1:
         H1 lastH1 = getLast(text, H1.class);
-        setParagraphSpanFromMark(text, lastH1, new EnrichedH1Span(style));
+        setParagraphSpanFromMark(text, lastH1, spanFactory.createH1Span(style));
         break;
       case 2:
         H2 lastH2 = getLast(text, H2.class);
-        setParagraphSpanFromMark(text, lastH2, new EnrichedH2Span(style));
+        setParagraphSpanFromMark(text, lastH2, spanFactory.createH2Span(style));
         break;
       case 3:
         H3 lastH3 = getLast(text, H3.class);
-        setParagraphSpanFromMark(text, lastH3, new EnrichedH3Span(style));
+        setParagraphSpanFromMark(text, lastH3, spanFactory.createH3Span(style));
         break;
       case 4:
         H4 lastH4 = getLast(text, H4.class);
-        setParagraphSpanFromMark(text, lastH4, new EnrichedH4Span(style));
+        setParagraphSpanFromMark(text, lastH4, spanFactory.createH4Span(style));
         break;
       case 5:
         H5 lastH5 = getLast(text, H5.class);
-        setParagraphSpanFromMark(text, lastH5, new EnrichedH5Span(style));
+        setParagraphSpanFromMark(text, lastH5, spanFactory.createH5Span(style));
         break;
       case 6:
         H6 lastH6 = getLast(text, H6.class);
-        setParagraphSpanFromMark(text, lastH6, new EnrichedH6Span(style));
+        setParagraphSpanFromMark(text, lastH6, spanFactory.createH6Span(style));
         break;
       default:
         throw new IllegalArgumentException("Unsupported heading level: " + level);
@@ -745,18 +768,19 @@ class HtmlToSpannedConverter implements ContentHandler {
     }
   }
 
-  private static void startImg(
-      Editable text, Attributes attributes, EnrichedParser.ImageGetter img) {
+  private static <T> void startImg(
+      Editable text, Attributes attributes, EnrichedSpanFactory<T> spanFactory) {
     String src = attributes.getValue("", "src");
     String width = attributes.getValue("", "width");
     String height = attributes.getValue("", "height");
 
     int len = text.length();
-    EnrichedImageSpan span =
-        EnrichedImageSpan.Companion.createEnrichedImageSpan(
-            src, Integer.parseInt(width), Integer.parseInt(height));
     text.append("");
-    text.setSpan(span, len, text.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+    text.setSpan(
+        spanFactory.createImageSpan(src, Integer.parseInt(width), Integer.parseInt(height)),
+        len,
+        text.length(),
+        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
   }
 
   private static void startA(Editable text, Attributes attributes) {
@@ -764,11 +788,11 @@ class HtmlToSpannedConverter implements ContentHandler {
     start(text, new Href(href));
   }
 
-  private void endA(Editable text, HtmlStyle style) {
+  private static <T> void endA(Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     Href h = getLast(text, Href.class);
     if (h != null) {
       if (h.mHref != null) {
-        setSpanFromMark(text, h, new EnrichedLinkSpan(h.mHref, style));
+        setSpanFromMark(text, h, spanFactory.createLinkSpan(h.mHref, style));
       }
     }
   }
@@ -789,13 +813,14 @@ class HtmlToSpannedConverter implements ContentHandler {
     start(mention, new Mention(indicator, text, attributesMap));
   }
 
-  private void endMention(Editable text, HtmlStyle style) {
+  private static <T> void endMention(Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     Mention m = getLast(text, Mention.class);
 
     if (m == null) return;
     if (m.mText == null) return;
 
-    setSpanFromMark(text, m, new EnrichedMentionSpan(m.mText, m.mIndicator, m.mAttributes, style));
+    setSpanFromMark(
+        text, m, spanFactory.createMentionSpan(m.mText, m.mIndicator, m.mAttributes, style));
   }
 
   public void setDocumentLocator(Locator locator) {}
@@ -884,10 +909,12 @@ class HtmlToSpannedConverter implements ContentHandler {
   private static class List {
     public int mIndex;
     public String mType;
+    public boolean mChecked;
 
-    public List(String type, int index) {
+    public List(String type, int index, boolean checked) {
       mType = type;
       mIndex = index;
+      mChecked = checked;
     }
   }
 

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

@@ -0,0 +1,79 @@
+package com.swmansion.enriched.common.parser
+
+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 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/{spans → common/spans}/EnrichedBlockQuoteSpan.kt

@@ -1,4 +1,4 @@
-package com.swmansion.enriched.spans
+package com.swmansion.enriched.common.spans
 
 import android.graphics.Canvas
 import android.graphics.Paint
@@ -6,22 +6,20 @@ import android.text.Layout
 import android.text.TextPaint
 import android.text.style.LeadingMarginSpan
 import android.text.style.MetricAffectingSpan
-import com.swmansion.enriched.spans.interfaces.EnrichedBlockSpan
-import com.swmansion.enriched.styles.HtmlStyle
+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
-class EnrichedBlockQuoteSpan(
-  private val htmlStyle: HtmlStyle,
+open class EnrichedBlockQuoteSpan(
+  private val enrichedStyle: EnrichedStyle,
 ) : MetricAffectingSpan(),
   LeadingMarginSpan,
   EnrichedBlockSpan {
-  override val dependsOnHtmlStyle: Boolean = true
-
   override fun updateMeasureState(p0: TextPaint) {
     // Do nothing, but inform layout that this span affects text metrics
   }
 
-  override fun getLeadingMargin(p0: Boolean): Int = htmlStyle.blockquoteStripeWidth + htmlStyle.blockquoteGapWidth
+  override fun getLeadingMargin(p0: Boolean): Int = enrichedStyle.blockquoteStripeWidth + enrichedStyle.blockquoteGapWidth
 
   override fun drawLeadingMargin(
     c: Canvas,
@@ -40,18 +38,16 @@ class EnrichedBlockQuoteSpan(
     val style = p.style
     val color = p.color
     p.style = Paint.Style.FILL
-    p.color = htmlStyle.blockquoteBorderColor
-    c.drawRect(x.toFloat(), top.toFloat(), x + dir * htmlStyle.blockquoteStripeWidth.toFloat(), bottom.toFloat(), p)
+    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 = htmlStyle.blockquoteColor
+    val color = enrichedStyle.blockquoteColor
     if (color != null) {
       textPaint?.color = color
     }
   }
-
-  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedBlockQuoteSpan = EnrichedBlockQuoteSpan(htmlStyle)
 }

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