react-native-enriched-markdown-scaffold 0.7.4-scaffold.7 → 0.7.4-scaffold.9

package/android/build.gradle

@@ -67,6 +67,10 @@ android {
       }
     }
   }
+
+  testOptions {
+    unitTests.includeAndroidResources = true
+  }
 }
 
 repositories {
@@ -85,6 +89,7 @@ dependencies {
   if (enableMath) {
     implementation("io.github.erweixin:ratex-android:0.1.10")
   }
+  testImplementation "junit:junit:4.13.2"
 }
 
 react {

package/android/generated/java/com/facebook/react/viewmanagers/EnrichedMarkdownTextInputManagerDelegate.java

@@ -44,6 +44,9 @@ public class EnrichedMarkdownTextInputManagerDelegate<T extends View, U extends
       case "scrollEnabled":
         mViewManager.setScrollEnabled(view, value == null ? false : (boolean) value);
         break;
+      case "blockSyntax":
+        mViewManager.setBlockSyntax(view, value == null ? false : (boolean) value);
+        break;
       case "autoCapitalize":
         mViewManager.setAutoCapitalize(view, value == null ? null : (String) value);
         break;

package/android/generated/java/com/facebook/react/viewmanagers/EnrichedMarkdownTextInputManagerInterface.java

@@ -22,6 +22,7 @@ public interface EnrichedMarkdownTextInputManagerInterface<T extends View> exten
   void setEditable(T view, boolean value);
   void setAutoFocus(T view, boolean value);
   void setScrollEnabled(T view, boolean value);
+  void setBlockSyntax(T view, boolean value);
   void setAutoCapitalize(T view, @Nullable String value);
   void setMultiline(T view, boolean value);
   void setCursorColor(T view, @Nullable Integer value);

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.cpp

@@ -144,6 +144,7 @@ EnrichedMarkdownTextInputProps::EnrichedMarkdownTextInputProps(
     editable(convertRawProp(context, rawProps, "editable", sourceProps.editable, {false})),
     autoFocus(convertRawProp(context, rawProps, "autoFocus", sourceProps.autoFocus, {false})),
     scrollEnabled(convertRawProp(context, rawProps, "scrollEnabled", sourceProps.scrollEnabled, {false})),
+    blockSyntax(convertRawProp(context, rawProps, "blockSyntax", sourceProps.blockSyntax, {false})),
     autoCapitalize(convertRawProp(context, rawProps, "autoCapitalize", sourceProps.autoCapitalize, {})),
     multiline(convertRawProp(context, rawProps, "multiline", sourceProps.multiline, {false})),
     cursorColor(convertRawProp(context, rawProps, "cursorColor", sourceProps.cursorColor, {})),
@@ -202,6 +203,10 @@ folly::dynamic EnrichedMarkdownTextInputProps::getDiffProps(
     result["scrollEnabled"] = scrollEnabled;
   }
     
+  if (blockSyntax != oldProps->blockSyntax) {
+    result["blockSyntax"] = blockSyntax;
+  }
+    
   if (autoCapitalize != oldProps->autoCapitalize) {
     result["autoCapitalize"] = autoCapitalize;
   }

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/Props.h

@@ -1534,6 +1534,7 @@ struct EnrichedMarkdownMarkdownStyleMathStruct {
   Float marginTop{0.0};
   Float marginBottom{0.0};
   std::string textAlign{};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -1548,6 +1549,7 @@ struct EnrichedMarkdownMarkdownStyleMathStruct {
     result["marginTop"] = marginTop;
     result["marginBottom"] = marginBottom;
     result["textAlign"] = textAlign;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -1584,6 +1586,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_textAlign != map.end()) {
     fromRawValue(context, tmp_textAlign->second, result.textAlign);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownMarkdownStyleMathStruct &value) {
@@ -1599,6 +1605,7 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownMarkdownStyleMathSt
 struct EnrichedMarkdownMarkdownStyleInlineMathStruct {
   SharedColor color{};
   Float paddingVertical{0.0};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -1608,6 +1615,7 @@ struct EnrichedMarkdownMarkdownStyleInlineMathStruct {
     folly::dynamic result = folly::dynamic::object();
     result["color"] = ::facebook::react::toDynamic(color);
     result["paddingVertical"] = paddingVertical;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -1624,6 +1632,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_paddingVertical != map.end()) {
     fromRawValue(context, tmp_paddingVertical->second, result.paddingVertical);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownMarkdownStyleInlineMathStruct &value) {
@@ -2810,6 +2822,7 @@ struct EnrichedMarkdownTextInputMarkdownStyleMathStruct {
   Float paddingVertical{0.0};
   SharedColor selectedBackgroundColor{};
   SharedColor selectedBorderColor{};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -2827,6 +2840,7 @@ struct EnrichedMarkdownTextInputMarkdownStyleMathStruct {
     result["paddingVertical"] = paddingVertical;
     result["selectedBackgroundColor"] = ::facebook::react::toDynamic(selectedBackgroundColor);
     result["selectedBorderColor"] = ::facebook::react::toDynamic(selectedBorderColor);
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -2875,6 +2889,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_selectedBorderColor != map.end()) {
     fromRawValue(context, tmp_selectedBorderColor->second, result.selectedBorderColor);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownTextInputMarkdownStyleMathStruct &value) {
@@ -2898,6 +2916,7 @@ struct EnrichedMarkdownTextInputMarkdownStyleMathBlockStruct {
   Float paddingVertical{0.0};
   SharedColor selectedBackgroundColor{};
   SharedColor selectedBorderColor{};
+  std::string fontWeight{};
   Float marginTop{0.0};
   Float marginBottom{0.0};
   std::string alignment{};
@@ -2918,6 +2937,7 @@ struct EnrichedMarkdownTextInputMarkdownStyleMathBlockStruct {
     result["paddingVertical"] = paddingVertical;
     result["selectedBackgroundColor"] = ::facebook::react::toDynamic(selectedBackgroundColor);
     result["selectedBorderColor"] = ::facebook::react::toDynamic(selectedBorderColor);
+    result["fontWeight"] = fontWeight;
     result["marginTop"] = marginTop;
     result["marginBottom"] = marginBottom;
     result["alignment"] = alignment;
@@ -2969,6 +2989,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_selectedBorderColor != map.end()) {
     fromRawValue(context, tmp_selectedBorderColor->second, result.selectedBorderColor);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
   auto tmp_marginTop = map.find("marginTop");
   if (tmp_marginTop != map.end()) {
     fromRawValue(context, tmp_marginTop->second, result.marginTop);
@@ -3335,6 +3359,7 @@ class EnrichedMarkdownTextInputProps final : public ViewProps {
   bool editable{false};
   bool autoFocus{false};
   bool scrollEnabled{false};
+  bool blockSyntax{false};
   std::string autoCapitalize{};
   bool multiline{false};
   SharedColor cursorColor{};
@@ -4878,6 +4903,7 @@ struct EnrichedMarkdownTextMarkdownStyleMathStruct {
   Float marginTop{0.0};
   Float marginBottom{0.0};
   std::string textAlign{};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -4892,6 +4918,7 @@ struct EnrichedMarkdownTextMarkdownStyleMathStruct {
     result["marginTop"] = marginTop;
     result["marginBottom"] = marginBottom;
     result["textAlign"] = textAlign;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -4928,6 +4955,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_textAlign != map.end()) {
     fromRawValue(context, tmp_textAlign->second, result.textAlign);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownTextMarkdownStyleMathStruct &value) {
@@ -4943,6 +4974,7 @@ static inline folly::dynamic toDynamic(const EnrichedMarkdownTextMarkdownStyleMa
 struct EnrichedMarkdownTextMarkdownStyleInlineMathStruct {
   SharedColor color{};
   Float paddingVertical{0.0};
+  std::string fontWeight{};
 
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -4952,6 +4984,7 @@ struct EnrichedMarkdownTextMarkdownStyleInlineMathStruct {
     folly::dynamic result = folly::dynamic::object();
     result["color"] = ::facebook::react::toDynamic(color);
     result["paddingVertical"] = paddingVertical;
+    result["fontWeight"] = fontWeight;
     return result;
   }
 #endif
@@ -4968,6 +5001,10 @@ static inline void fromRawValue(const PropsParserContext& context, const RawValu
   if (tmp_paddingVertical != map.end()) {
     fromRawValue(context, tmp_paddingVertical->second, result.paddingVertical);
   }
+  auto tmp_fontWeight = map.find("fontWeight");
+  if (tmp_fontWeight != map.end()) {
+    fromRawValue(context, tmp_fontWeight->second, result.fontWeight);
+  }
 }
 
 static inline std::string toString(const EnrichedMarkdownTextMarkdownStyleInlineMathStruct &value) {

package/android/src/main/java/com/swmansion/enriched/markdown/input/EnrichedMarkdownTextInputManager.kt

@@ -170,6 +170,14 @@ class EnrichedMarkdownTextInputManager :
     view?.isVerticalScrollBarEnabled = value
   }
 
+  @ReactProp(name = "blockSyntax", defaultBoolean = true)
+  override fun setBlockSyntax(
+    view: EnrichedMarkdownTextInputView?,
+    value: Boolean,
+  ) {
+    view?.blockSyntax = value
+  }
+
   @ReactProp(name = "autoCapitalize")
   override fun setAutoCapitalize(
     view: EnrichedMarkdownTextInputView?,

package/android/src/main/java/com/swmansion/enriched/markdown/input/EnrichedMarkdownTextInputView.kt

@@ -97,6 +97,17 @@ class EnrichedMarkdownTextInputView(
   private var detectScrollMovement = false
   var scrollEnabled: Boolean = true
 
+  // The markdown last handed over by JS, kept so `blockSyntax` can re-parse it. @ReactProp
+  // setters fire in undefined order, so `defaultValue` regularly lands before the flag does.
+  private var lastMarkdownFromJS: String? = null
+
+  var blockSyntax: Boolean = true
+    set(value) {
+      if (field == value) return
+      field = value
+      lastMarkdownFromJS?.let { setValueFromJS(it) }
+    }
+
   private var mentionIndicators: LinkedHashSet<String> = linkedSetOf()
   private var activeMentionIndicator: String? = null
   private var activeMentionStart = -1
@@ -634,7 +645,8 @@ class EnrichedMarkdownTextInputView(
   }
 
   fun setValueFromJS(markdown: String) {
-    val parsed = InputParser.parseToPlainTextAndRanges(markdown)
+    lastMarkdownFromJS = markdown
+    val parsed = InputParser.parseToPlainTextAndRanges(markdown, blockSyntax)
     blockEmitting = true
     try {
       runAsATransaction {

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/BlockSyntaxSentinel.kt

@@ -0,0 +1,69 @@
+package com.swmansion.enriched.markdown.input.formatting
+
+/**
+ * Hides block-level markdown structure from md4c so a document parses as a single
+ * `Paragraph`. Used by `blockSyntax = false` on `EnrichedMarkdownTextInput`.
+ *
+ * Every newline is swapped for a vertical tab (`0x0B`) and one more is prepended.
+ * md4c treats VT as ordinary whitespace, never as a line break, so no line ever
+ * starts at a position where a list marker, `#`, `>` or an indented code block can
+ * be recognised — including line 1, which is what the leading sentinel is for.
+ * Inline syntax (`$...$`, `**...**`, links) still parses normally.
+ *
+ * The transform is 1:1 in characters *and* in UTF-8 bytes (VT and `\n` are both one
+ * of each), so offsets coming back out of the parser only need a flat -1 shift for
+ * the leading sentinel. iOS relies on the same property to keep its byte-to-UTF16
+ * map valid.
+ */
+internal object BlockSyntaxSentinel {
+  const val SENTINEL = '\u000B'
+
+  /**
+   * `\r\n` / `\r` collapse to `\n` (md4c normalizes line endings this way regardless,
+   * so this is pre-existing lossiness, not a new one), and any `0x0B` already present
+   * is dropped — leaving it in would make [decode] silently turn it into a newline.
+   */
+  fun canonicalize(markdown: String): String {
+    val out = StringBuilder(markdown.length)
+    var i = 0
+    while (i < markdown.length) {
+      when (markdown[i]) {
+        '\r' -> {
+          out.append('\n')
+          if (i + 1 < markdown.length && markdown[i + 1] == '\n') i++
+        }
+
+        SENTINEL -> {}
+
+        else -> {
+          out.append(markdown[i])
+        }
+      }
+      i++
+    }
+    return out.toString()
+  }
+
+  /** Prepends one sentinel and replaces every `\n` with one. Length grows by exactly 1. */
+  fun encode(canonical: String): String {
+    val out = StringBuilder(canonical.length + 1)
+    out.append(SENTINEL)
+    for (c in canonical) out.append(if (c == '\n') SENTINEL else c)
+    return out.toString()
+  }
+
+  /**
+   * Reverses [encode] on the parser's plain text. Returns `null` when the leading
+   * sentinel is missing — the caller then falls back to the canonical source with no
+   * ranges rather than emitting text shifted by an offset that no longer holds.
+   */
+  fun decode(plainText: String): String? {
+    if (plainText.isEmpty() || plainText[0] != SENTINEL) return null
+    val out = StringBuilder(plainText.length - 1)
+    for (i in 1 until plainText.length) {
+      val c = plainText[i]
+      out.append(if (c == SENTINEL) '\n' else c)
+    }
+    return out.toString()
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/formatting/InputParser.kt

@@ -22,19 +22,73 @@ object InputParser {
   // A source paragraph break: a newline followed by one or more blank lines.
   private val PARAGRAPH_BREAK_RE = Regex("\\n[ \\t]*(?:\\n[ \\t]*)+")
 
-  fun parseToPlainTextAndRanges(markdown: String): ParseResult {
+  fun parseToPlainTextAndRanges(
+    markdown: String,
+    blockSyntax: Boolean = true,
+  ): ParseResult {
     if (markdown.isEmpty()) {
       return ParseResult("", emptyList())
     }
 
-    val completed = InputRemend.complete(markdown)
+    if (!blockSyntax) {
+      return parseWithoutBlockSyntax(markdown)
+    }
+
+    return parseCompleted(InputRemend.complete(markdown), markdown, blockSeparators = true)
+  }
+
+  /**
+   * Parses with every block construct hidden behind [BlockSyntaxSentinel], so the whole
+   * document lands in one `Paragraph` and list markers, `#`, `>` and friends stay in the
+   * text verbatim. `InputRemend` is skipped as well: its speculative closing delimiters
+   * are the other source of characters the serializer cannot replay.
+   */
+  private fun parseWithoutBlockSyntax(markdown: String): ParseResult {
+    val canonical = BlockSyntaxSentinel.canonicalize(markdown)
+    if (canonical.isEmpty()) {
+      return ParseResult("", emptyList())
+    }
+
+    // No block separators: the encoded text has no newline for md4c to drop, so every
+    // newline the replay would add is spurious. `$$...$$` is the case that proves it —
+    // md4c reports display math as a top-level block even mid-line under the sentinel.
+    val parsed = parseCompleted(BlockSyntaxSentinel.encode(canonical), canonical, blockSeparators = false)
+    val decoded =
+      BlockSyntaxSentinel.decode(parsed.plainText)
+        ?: return ParseResult(canonical, emptyList())
+
+    // Only the leading sentinel is removed, so every offset shifts by exactly one.
+    val ranges =
+      parsed.formattingRanges.mapNotNull { range ->
+        val start = range.start - 1
+        val end = range.end - 1
+        if (start < 0 || end > decoded.length || end <= start) {
+          null
+        } else {
+          FormattingRange(range.type, start, end, range.url)
+        }
+      }
+    val atoms =
+      parsed.mathAtoms.mapNotNull { atom ->
+        val position = atom.position - 1
+        if (position < 0 || position >= decoded.length) null else atom.copy(position = position)
+      }
+
+    return ParseResult(decoded, ranges, atoms)
+  }
+
+  private fun parseCompleted(
+    completed: String,
+    fallback: String,
+    blockSeparators: Boolean,
+  ): ParseResult {
     val flags =
       Md4cFlags(
         underline = true,
         latexMath = FeatureFlags.IS_MATH_ENABLED,
         permissiveAutolinks = false,
       )
-    val ast = Parser.shared.parseMarkdown(completed, flags) ?: return ParseResult(markdown, emptyList())
+    val ast = Parser.shared.parseMarkdown(completed, flags) ?: return ParseResult(fallback, emptyList())
 
     val plainText = StringBuilder()
     val ranges = mutableListOf<FormattingRange>()
@@ -43,14 +97,18 @@ object InputParser {
     // md4c collapses any blank-line run into a single break, unlike iOS which keeps them.
     // Re-read the real runs so each break replays its original number of newlines.
     val blankRuns =
-      ArrayDeque(
-        PARAGRAPH_BREAK_RE
-          .findAll(completed.trim())
-          .map { match -> match.value.count { it == '\n' } }
-          .toList(),
-      )
+      if (blockSeparators) {
+        ArrayDeque(
+          PARAGRAPH_BREAK_RE
+            .findAll(completed.trim())
+            .map { match -> match.value.count { it == '\n' } }
+            .toList(),
+        )
+      } else {
+        ArrayDeque()
+      }
 
-    walkNode(ast, plainText, ranges, mathAtoms, ArrayDeque(), blankRuns)
+    walkNode(ast, plainText, ranges, mathAtoms, ArrayDeque(), blankRuns, blockSeparators)
 
     return ParseResult(plainText.toString(), ranges, mathAtoms)
   }
@@ -62,6 +120,7 @@ object InputParser {
     mathAtoms: MutableList<MathAtom>,
     activeStyles: ArrayDeque<ActiveStyle>,
     blankRuns: ArrayDeque<Int>,
+    blockSeparators: Boolean,
   ) {
     if (node.type == NodeType.LatexMathInline || node.type == NodeType.LatexMathDisplay) {
       val latex = extractLatex(node)
@@ -92,10 +151,10 @@ object InputParser {
 
     for ((index, child) in node.children.withIndex()) {
       // Keep the source's blank lines between top-level blocks (md4c drops them, iOS keeps them).
-      if (index > 0 && child.type.isTopLevelBlock() && plainText.isNotEmpty()) {
+      if (blockSeparators && index > 0 && child.type.isTopLevelBlock() && plainText.isNotEmpty()) {
         plainText.append("\n".repeat(blankRuns.removeFirstOrNull() ?: 2))
       }
-      walkNode(child, plainText, ranges, mathAtoms, activeStyles, blankRuns)
+      walkNode(child, plainText, ranges, mathAtoms, activeStyles, blankRuns, blockSeparators)
     }
 
     if (styleType != null) {

package/android/src/main/java/com/swmansion/enriched/markdown/input/layout/InputMeasurementStore.kt

@@ -99,7 +99,10 @@ object InputMeasurementStore {
     // invisible characters and over-estimates the height into extra lines, until the next text
     // change forces a re-measure. Parsing first matches what the editor actually renders.
     val markdown = props?.getString("defaultValue") ?: props?.getString("placeholder") ?: "I"
-    val text = InputParser.parseToPlainTextAndRanges(markdown).plainText
+    // Must read the same flag the view parses with, or the measured height and the
+    // rendered height disagree: `blockSyntax = false` keeps list markers and `#` as text.
+    val blockSyntax = if (props?.hasKey("blockSyntax") == true) props.getBoolean("blockSyntax") else true
+    val text = InputParser.parseToPlainTextAndRanges(markdown, blockSyntax).plainText
     val fontSize = props?.getDouble("fontSize")?.toFloat() ?: 16f
     val spSize = kotlin.math.ceil(PixelUtil.toPixelFromSP(fontSize).toDouble()).toFloat()
 

package/android/src/main/java/com/swmansion/enriched/markdown/input/model/MathChipStyle.kt

@@ -13,6 +13,7 @@ open class MathChipStyle(
   val paddingVertical: Float,
   val selectedBackgroundColor: Int?,
   val selectedBorderColor: Int?,
+  val fontWeight: String = "normal",
 ) {
   open fun isBlock(): Boolean = false
 }
@@ -28,6 +29,7 @@ class MathBlockStyle(
   paddingVertical: Float,
   selectedBackgroundColor: Int?,
   selectedBorderColor: Int?,
+  fontWeight: String = "normal",
   val marginTop: Float,
   val marginBottom: Float,
   val alignment: Layout.Alignment,
@@ -42,6 +44,7 @@ class MathBlockStyle(
     paddingVertical,
     selectedBackgroundColor,
     selectedBorderColor,
+    fontWeight,
   ) {
   override fun isBlock(): Boolean = true
 }

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

@@ -5,6 +5,7 @@ import com.facebook.react.bridge.ReadableMap
 data class InlineMathStyle(
   val color: Int,
   val paddingVertical: Float,
+  val fontWeight: String,
 ) {
   companion object {
     fun fromReadableMap(
@@ -13,7 +14,8 @@ data class InlineMathStyle(
     ): InlineMathStyle {
       val color = parser.parseColor(map, "color")
       val paddingVertical = parser.toPixelFromDIP(map.getDouble("paddingVertical").toFloat())
-      return InlineMathStyle(color, paddingVertical)
+      val fontWeight = parser.parseString(map, "fontWeight", "normal")
+      return InlineMathStyle(color, paddingVertical, fontWeight)
     }
   }
 }

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

@@ -0,0 +1,25 @@
+package com.swmansion.enriched.markdown.styles
+
+/**
+ * Weight a formula can actually be typeset at.
+ *
+ * The style model keeps `fontWeight` as a [String], the way every other
+ * `fontWeight` prop in the codebase does, so a value like `"600"` survives as
+ * far as the renderer. This enum is the narrowing step at that last hop — see
+ * `ratexTypefaceLoader`, the only caller — so adding a third weight is a
+ * compile error at the draw site rather than a value that silently falls back
+ * to regular. Mirrors ENRMMathFontWeight.h on iOS.
+ */
+enum class MathFontWeight {
+  NORMAL,
+  BOLD,
+  ;
+
+  companion object {
+    fun fromString(value: String): MathFontWeight =
+      when (value.lowercase()) {
+        "bold" -> BOLD
+        else -> NORMAL
+      }
+  }
+}

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

@@ -10,6 +10,7 @@ data class MathStyle(
   val marginTop: Float,
   val marginBottom: Float,
   val textAlign: String,
+  val fontWeight: String,
 ) {
   companion object {
     fun fromReadableMap(
@@ -23,7 +24,17 @@ data class MathStyle(
       val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
       val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
       val textAlign = parser.parseString(map, "textAlign", "center")
-      return MathStyle(fontSize, color, backgroundColor, padding, marginTop, marginBottom, textAlign)
+      val fontWeight = parser.parseString(map, "fontWeight", "normal")
+      return MathStyle(
+        fontSize,
+        color,
+        backgroundColor,
+        padding,
+        marginTop,
+        marginBottom,
+        textAlign,
+        fontWeight,
+      )
     }
   }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/utils/input/MarkdownStyleParser.kt

@@ -76,6 +76,8 @@ object MarkdownStyleParser {
       if (mathMap?.hasKey("selectedBackgroundColor") == true) mathMap.getInt("selectedBackgroundColor") else null
     val selectedBorderColor =
       if (mathMap?.hasKey("selectedBorderColor") == true) mathMap.getInt("selectedBorderColor") else null
+    val fontWeight =
+      (if (mathMap?.hasKey("fontWeight") == true) mathMap.getString("fontWeight") else null) ?: "normal"
 
     return MathChipStyle(
       color = color,
@@ -88,6 +90,7 @@ object MarkdownStyleParser {
       paddingVertical = paddingVertical,
       selectedBackgroundColor = nullIfTransparent(selectedBackgroundColor),
       selectedBorderColor = nullIfTransparent(selectedBorderColor),
+      fontWeight = fontWeight,
     )
   }
 
@@ -143,6 +146,12 @@ object MarkdownStyleParser {
       } else {
         inlineFallback.selectedBorderColor
       }
+    val fontWeight =
+      if (mathBlockMap?.hasKey("fontWeight") == true) {
+        mathBlockMap.getString("fontWeight") ?: "normal"
+      } else {
+        inlineFallback.fontWeight
+      }
     val marginTop =
       PixelUtil.toPixelFromDIP(
         if (mathBlockMap?.hasKey("marginTop") == true) mathBlockMap.getDouble("marginTop").toFloat() else 8f,
@@ -170,6 +179,7 @@ object MarkdownStyleParser {
       paddingVertical = paddingVertical,
       selectedBackgroundColor = nullIfTransparent(selectedBackgroundColor),
       selectedBorderColor = nullIfTransparent(selectedBorderColor),
+      fontWeight = fontWeight,
       marginTop = marginTop,
       marginBottom = marginBottom,
       alignment = alignment,

package/android/src/math/java/com/swmansion/enriched/markdown/renderer/MathInlineRenderer.kt

@@ -36,6 +36,7 @@ class MathInlineRenderer(
         fontSize = blockStyle.fontSize,
         textColor = config.style.inlineMathStyle.color,
         paddingVertical = config.style.inlineMathStyle.paddingVertical,
+        fontWeight = config.style.inlineMathStyle.fontWeight,
       )
 
     builder.setSpan(span, start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)

package/android/src/math/java/com/swmansion/enriched/markdown/spans/MathChipSpan.kt

@@ -66,7 +66,7 @@ class MathChipSpan(
           displayMode = displayMode,
           color = style.color,
         )
-      val renderer = RaTeXRenderer(displayList, style.fontSize) { RaTeXFontLoader.getTypeface(it) }
+      val renderer = RaTeXRenderer(displayList, style.fontSize, ratexTypefaceLoader(style.fontWeight))
       formulaWidth = renderer.widthPx
       formulaAscent = renderer.heightPx
       formulaDescent = renderer.depthPx

package/android/src/math/java/com/swmansion/enriched/markdown/spans/MathInlineSpan.kt

@@ -6,7 +6,6 @@ import android.graphics.Canvas
 import android.graphics.Paint
 import android.text.style.ReplacementSpan
 import io.ratex.RaTeXEngine
-import io.ratex.RaTeXFontLoader
 import io.ratex.RaTeXRenderer
 import kotlin.math.ceil
 
@@ -16,6 +15,7 @@ class MathInlineSpan(
   internal val fontSize: Float,
   private val textColor: Int,
   private val paddingVertical: Float,
+  private val fontWeight: String = "normal",
 ) : ReplacementSpan() {
   private var cachedBitmap: Bitmap? = null
   private var cachedWidth = 0
@@ -29,7 +29,7 @@ class MathInlineSpan(
 
     try {
       val displayList = RaTeXEngine.parseBlocking(latex, displayMode = false, color = textColor)
-      val renderer = RaTeXRenderer(displayList, fontSize) { RaTeXFontLoader.getTypeface(it) }
+      val renderer = RaTeXRenderer(displayList, fontSize, ratexTypefaceLoader(fontWeight))
 
       cachedWidth = renderer.widthPx.toInt().coerceAtLeast(1)
       mathAscent = renderer.heightPx