react-native-enriched-markdown-scaffold 0.7.4-scaffold.1 → 0.7.4-scaffold.11

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

@@ -20,6 +20,9 @@ import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputConnection
 import android.view.inputmethod.InputMethodManager
 import androidx.appcompat.widget.AppCompatEditText
+import androidx.core.view.ContentInfoCompat
+import androidx.core.view.OnReceiveContentListener
+import androidx.core.view.ViewCompat
 import com.facebook.react.common.ReactConstants
 import com.facebook.react.uimanager.BackgroundStyleApplicator
 import com.facebook.react.uimanager.PixelUtil
@@ -44,6 +47,7 @@ import com.swmansion.enriched.markdown.input.model.MathChipStyle
 import com.swmansion.enriched.markdown.input.model.StyleType
 import com.swmansion.enriched.markdown.input.toolbar.InputContextMenu
 import com.swmansion.enriched.markdown.utils.input.AutoCapitalizeUtils
+import com.swmansion.enriched.markdown.utils.input.PasteTextUtils
 import kotlin.math.ceil
 
 private fun Char.isLineBreak(): Boolean = this == '\n' || this == '\r' || this == '\u0085' || this == '\u2028' || this == '\u2029'
@@ -97,6 +101,36 @@ class EnrichedMarkdownTextInputView(
   private var detectScrollMovement = false
   var scrollEnabled: Boolean = true
 
+  // When on, a paste is reported to JS instead of inserted. Native never touches
+  // the buffer here (see resolvePaste): if JS dies mid-handler the paste is a
+  // visible no-op rather than a selection that silently vanished.
+  //
+  // The listener is installed only while the prop is on. Registering it
+  // unconditionally would route every consumer's paste through AppCompat's
+  // receive-content path even with the feature off, which is a behavior change
+  // nobody asked for.
+  var interceptPaste: Boolean = false
+    set(value) {
+      if (field == value) return
+      field = value
+      ViewCompat.setOnReceiveContentListener(
+        this,
+        if (value) PASTE_MIME_TYPES else null,
+        if (value) receiveContentListener else null,
+      )
+    }
+
+  // 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
@@ -477,6 +511,98 @@ class EnrichedMarkdownTextInputView(
     clipboard.setPrimaryClip(ClipData.newPlainText(null, content))
   }
 
+  // Paste arrives by two different routes and only the first one is a menu.
+  // `onTextContextMenuItem` covers the context menu and the hardware Ctrl+V /
+  // KEYCODE_PASTE shortcuts; drag-and-drop, autofill and IME `commitContent`
+  // reach the view through `onReceiveContent` instead. Hooking only one of them
+  // leaves the other pasting straight into the buffer with nobody intercepting.
+  override fun onTextContextMenuItem(id: Int): Boolean {
+    val isPaste = id == android.R.id.paste || id == android.R.id.pasteAsPlainText
+    if (isPaste && interceptPaste) {
+      val text = readClipboardText()
+      if (text.isNotEmpty()) {
+        eventEmitter.emitPaste(text, "")
+        // Stops super, which is what keeps this single-emit: AppCompat routes
+        // its own paste handling through the receive-content listener below.
+        return true
+      }
+      // Nothing textual in the clip: hand it to the platform, matching what the
+      // listener does with the items it does not claim. Both routes then decide
+      // from the same rule, so a clip never behaves differently depending on
+      // whether it came from the menu or from Ctrl+V.
+    }
+    return super.onTextContextMenuItem(id)
+  }
+
+  private val receiveContentListener =
+    OnReceiveContentListener { _, payload ->
+      // The listener also sees autofill, drag-and-drop, IME commitContent and
+      // PROCESS_TEXT. Without this filter an autofill would turn into a paste
+      // event — and a consumer would turn that into an attachment chip.
+      if (!interceptPaste || payload.source != ContentInfoCompat.SOURCE_CLIPBOARD) {
+        return@OnReceiveContentListener payload
+      }
+      val parts = payload.partition { it.text != null }
+      parts.first?.let { accepted ->
+        val clip = accepted.clip
+        val text = PasteTextUtils.joinClipTexts((0 until clip.itemCount).map { clip.getItemAt(it).text })
+        if (text.isNotEmpty()) {
+          eventEmitter.emitPaste(text, "")
+        }
+      }
+      // Hand back only what we did not claim, so the buffer stays untouched.
+      parts.second
+    }
+
+  private fun readClipboardText(): String {
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return ""
+    val clip = clipboard.primaryClip ?: return ""
+    // `text`, not `coerceToText`: the listener can only claim items that already
+    // carry text, and the two routes have to agree on what counts as a paste.
+    return PasteTextUtils.joinClipTexts((0 until clip.itemCount).map { clip.getItemAt(it).text })
+  }
+
+  /**
+   * Completes a paste reported through `onPaste`. `markdown` is accepted for
+   * parity with iOS but ignored here: Android's clipboard is plain text only
+   * (see `copyToClipboard`), so there is no flavor to restore.
+   *
+   * Resolving with an empty string and an empty selection is a zero-length edit
+   * — it still emits, which keeps the JS contract identical on both platforms.
+   */
+  fun resolvePaste(
+    pastedText: String,
+    @Suppress("UNUSED_PARAMETER") markdown: String,
+  ) {
+    val editable = text ?: return
+    val selStart = selectionStart.coerceAtLeast(0)
+    val selEnd = selectionEnd.coerceAtLeast(selStart)
+    val safeStart = selStart.coerceAtMost(editable.length)
+    val safeEnd = selEnd.coerceAtMost(editable.length)
+
+    isProcessingTextChange = true
+    try {
+      editable.replace(safeStart, safeEnd, pastedText)
+      formattingStore.adjustForEdit(safeStart, safeEnd - safeStart, pastedText.length)
+      lastProcessedText = editable.toString()
+      setSelection(safeStart + pastedText.length)
+    } finally {
+      isProcessingTextChange = false
+    }
+
+    applyFormatting()
+    // Parity with the un-intercepted paste, which reached the detectors through
+    // the text watcher: a pasted URL still autolinks.
+    detectorPipeline.processTextChange(editable, editable.toString(), safeStart, pastedText.length)
+    invalidate()
+    requestLayout()
+    eventEmitter.emitChangeText()
+    if (emitMarkdown) eventEmitter.emitChangeMarkdown()
+    eventEmitter.emitSelection(selectionStart, selectionEnd)
+    eventEmitter.emitState()
+    eventEmitter.emitCaretRectChangeIfNeeded()
+  }
+
   fun setLinkForSelection(url: String) {
     val selStart = selectionStart
     val selEnd = selectionEnd
@@ -634,7 +760,8 @@ class EnrichedMarkdownTextInputView(
   }
 
   fun setValueFromJS(markdown: String) {
-    val parsed = InputParser.parseToPlainTextAndRanges(markdown)
+    lastMarkdownFromJS = markdown
+    val parsed = InputParser.parseToPlainTextAndRanges(markdown, blockSyntax)
     blockEmitting = true
     try {
       runAsATransaction {
@@ -708,8 +835,16 @@ class EnrichedMarkdownTextInputView(
       }
       invalidate()
       requestLayout()
+      // Chips only reach the text here when `defaultValue` landed before `markdownStyle`
+      // (@ReactProp order is undefined). requestLayout() cannot change a height Fabric owns —
+      // the shadow tree has to re-measure text that now carries the spans.
+      layoutManager.invalidateLayout()
     } else if (mathStyleChanged) {
       refreshAllMathChips()
+      // A math font size / padding change resizes every chip, so the measured height moves.
+      // Colour-only changes end up here too; store() then measures the same size and skips
+      // the state update.
+      layoutManager.invalidateLayout()
     }
     return changed
   }
@@ -848,18 +983,36 @@ class EnrichedMarkdownTextInputView(
     return true
   }
 
-  private fun computeChipBounds(
+  /** Chip glyph rect in [Layout] coordinates — no padding, no scroll offset. */
+  private fun chipBoundsInLayout(
     layout: Layout,
     start: Int,
   ): Rect {
     val line = layout.getLineForOffset(start)
-    val xStart = (layout.getPrimaryHorizontal(start)).toInt() + totalPaddingLeft - scrollX
-    val xEnd = (layout.getPrimaryHorizontal(start + 1)).toInt() + totalPaddingLeft - scrollX
-    val top = layout.getLineTop(line) + totalPaddingTop - scrollY
-    val bottom = layout.getLineBottom(line) + totalPaddingTop - scrollY
-    return Rect(xStart, top, xEnd, bottom)
+    val xStart = layout.getPrimaryHorizontal(start).toInt()
+    val xEnd = layout.getPrimaryHorizontal(start + 1).toInt()
+    // Ordered, not raw start/end: in an RTL run xStart > xEnd, which would make an
+    // inverted Rect that contains() always rejects.
+    val left = xStart.coerceAtMost(xEnd)
+    var right = xStart.coerceAtLeast(xEnd)
+    if (right <= left) {
+      // A chip that is the last character has start + 1 == length, where some layouts
+      // report the same horizontal for both offsets. Fall back to the line's content edge
+      // so the rect keeps a real width instead of collapsing.
+      right = layout.getLineRight(line).toInt()
+    }
+    return Rect(left, layout.getLineTop(line), right, layout.getLineBottom(line))
   }
 
+  /** Chip glyph rect in view coordinates, for reporting to JS. */
+  private fun computeChipBounds(
+    layout: Layout,
+    start: Int,
+  ): Rect =
+    chipBoundsInLayout(layout, start).apply {
+      offset(totalPaddingLeft - scrollX, totalPaddingTop - scrollY)
+    }
+
   fun mathChipPositionAtTouch(
     x: Float,
     y: Float,
@@ -869,13 +1022,21 @@ class EnrichedMarkdownTextInputView(
     val layoutNow = layout ?: return -1
     val adjustedX = (x - totalPaddingLeft + scrollX).toInt()
     val adjustedY = (y - totalPaddingTop + scrollY).toInt()
-    if (adjustedY < 0) return -1
+    // getLineForVertical and getOffsetForHorizontal both clamp into the laid-out text, so
+    // a touch in the padding or in the blank space below the last line resolves onto the
+    // nearest character. Bound the touch to the text box, then require it to land inside
+    // the chip's own rect — otherwise a tap beside a chip reads as a tap on it.
+    if (adjustedY < 0 || adjustedY > layoutNow.height) return -1
     val line = layoutNow.getLineForVertical(adjustedY)
     val offset = layoutNow.getOffsetForHorizontal(line, adjustedX.toFloat())
-    if (offset < 0 || offset >= editable.length) return -1
+    if (offset < 0) return -1
     val candidates = intArrayOf(offset, offset - 1).filter { it in 0 until editable.length }
     for (candidate in candidates) {
       val range = controller.chipRangeAt(editable, candidate) ?: continue
+      // An empty rect means the layout could not give us the chip's extent; accept the
+      // candidate then, rather than making the chip untappable.
+      val bounds = chipBoundsInLayout(layoutNow, range.first)
+      if (!bounds.isEmpty && !bounds.contains(adjustedX, adjustedY)) continue
       return range.first
     }
     return -1
@@ -1109,6 +1270,10 @@ class EnrichedMarkdownTextInputView(
       .replace("(", "%28")
       .replace(")", "%29")
 
+  private companion object {
+    private val PASTE_MIME_TYPES = arrayOf("text/*")
+  }
+
   private data class MentionCandidate(
     val indicator: String,
     val start: Int,

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

@@ -0,0 +1,24 @@
+package com.swmansion.enriched.markdown.input.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnPasteEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val text: String,
+  private val markdown: String,
+) : Event<OnPasteEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putString("text", text)
+      putString("markdown", markdown)
+    }
+
+  companion object {
+    const val EVENT_NAME = "onPaste"
+  }
+}

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/InputEventEmitter.kt

@@ -16,6 +16,7 @@ import com.swmansion.enriched.markdown.input.events.OnInputBlurEvent
 import com.swmansion.enriched.markdown.input.events.OnInputFocusEvent
 import com.swmansion.enriched.markdown.input.events.OnLinkDetectedEvent
 import com.swmansion.enriched.markdown.input.events.OnMathPressEvent
+import com.swmansion.enriched.markdown.input.events.OnPasteEvent
 import com.swmansion.enriched.markdown.input.events.OnRequestCaretRectResultEvent
 import com.swmansion.enriched.markdown.input.events.OnRequestMarkdownResultEvent
 import com.swmansion.enriched.markdown.input.events.OnStartMentionEvent
@@ -99,6 +100,13 @@ class InputEventEmitter(
     dispatch(OnMathPressEvent(surfaceId(), view.id, latex, start, end, displayMode, x, y, width, height))
   }
 
+  fun emitPaste(
+    text: String,
+    markdown: String,
+  ) {
+    dispatch(OnPasteEvent(surfaceId(), view.id, text, markdown))
+  }
+
   fun emitStartMention(indicator: String) {
     dispatch(OnStartMentionEvent(surfaceId(), view.id, indicator))
   }

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

@@ -8,21 +8,49 @@ class InputLayoutManager(
 ) {
   private var forceHeightRecalculationCounter = 0
 
+  /**
+   * An invalidation that arrived before `stateWrapper` existed. Fabric applies every prop
+   * (and runs `onAfterUpdateTransaction`) inside `ViewManager.updateProperties`, which runs
+   * *before* `updateState` assigns the wrapper — so the whole mount transaction invalidates
+   * into the void. Without this flag the measurement store stays empty and Yoga keeps the
+   * `initialMeasure()` approximation until the next text/prop change.
+   */
+  private var pending = false
+
   fun invalidateLayout() {
-    if (view.stateWrapper == null) return
+    val stateWrapper = view.stateWrapper
+    if (stateWrapper == null) {
+      pending = true
+      return
+    }
+    pending = false
 
     val text = view.text
     val paint = view.paint
 
+    // First call for this view measures against cachedWidth = 0 and stores a throwaway size;
+    // Yoga immediately re-measures through getMeasureById() with the real width and overwrites
+    // it. The state update below is what makes that second pass happen.
     val needUpdate = InputMeasurementStore.store(view.id, text, paint)
     if (!needUpdate) return
 
     val state = Arguments.createMap()
     state.putInt("forceHeightRecalculationCounter", forceHeightRecalculationCounter++)
-    view.stateWrapper?.updateState(state)
+    stateWrapper.updateState(state)
+  }
+
+  /**
+   * Replays an invalidation that was dropped while `stateWrapper` was null. Called once the
+   * wrapper is assigned, i.e. after every prop of the mount transaction has been applied — so
+   * the text carries its math chips and the paint carries the resolved typeface/size.
+   */
+  fun flushPendingInvalidation() {
+    if (!pending) return
+    invalidateLayout()
   }
 
   fun release() {
+    pending = false
     InputMeasurementStore.release(view.id)
   }
 }

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

@@ -10,6 +10,8 @@ import com.facebook.react.uimanager.PixelUtil
 import com.facebook.yoga.YogaMeasureMode
 import com.facebook.yoga.YogaMeasureOutput
 import com.swmansion.enriched.markdown.input.formatting.InputParser
+import com.swmansion.enriched.markdown.utils.common.getBooleanOrDefault
+import com.swmansion.enriched.markdown.utils.common.getFloatOrDefault
 import java.util.concurrent.ConcurrentHashMap
 
 object InputMeasurementStore {
@@ -99,8 +101,11 @@ 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
-    val fontSize = props?.getDouble("fontSize")?.toFloat() ?: 16f
+    // 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 = props.getBooleanOrDefault("blockSyntax", true)
+    val text = InputParser.parseToPlainTextAndRanges(markdown, blockSyntax).plainText
+    val fontSize = props.getFloatOrDefault("fontSize", 16f)
     val spSize = kotlin.math.ceil(PixelUtil.toPixelFromSP(fontSize).toDouble()).toFloat()
 
     val defaultView = AppCompatEditText(context)

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/renderer/HeadingRenderer.kt

@@ -40,6 +40,7 @@ class HeadingRenderer(
         HeadingSpan(
           level,
           config.style,
+          factory.styleCache,
         ),
         start,
         end,

package/android/src/main/java/com/swmansion/enriched/markdown/spans/HeadingSpan.kt

@@ -4,11 +4,14 @@ import android.annotation.SuppressLint
 import android.graphics.Typeface
 import android.text.TextPaint
 import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.markdown.renderer.SpanStyleCache
 import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.utils.text.extensions.applyColorPreserving
 
 class HeadingSpan(
   val level: Int,
   styleConfig: StyleConfig,
+  private val styleCache: SpanStyleCache,
 ) : MetricAffectingSpan() {
   private val fontSize: Float = styleConfig.headingStyles[level]!!.fontSize
   private val color: Int = styleConfig.headingStyles[level]!!.color
@@ -16,7 +19,11 @@ class HeadingSpan(
 
   override fun updateDrawState(tp: TextPaint) {
     applyHeadingStyle(tp)
-    tp.color = color
+    // Inline spans (link, code, strong/em with their own color) are attached to the range
+    // BEFORE this block span, and TextLine replays every CharacterStyle in insertion order,
+    // so an unconditional `tp.color = color` here would repaint them. Same guard used by
+    // BlockquoteSpan, BaseListSpan, CodeBlockSpan, StrongSpan and EmphasisSpan.
+    tp.applyColorPreserving(color, *styleCache.colorsToPreserve)
   }
 
   override fun updateMeasureState(tp: TextPaint) {