react-native-enriched-markdown-scaffold 0.6.0-scaffold.8 → 0.7.4-scaffold.10

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

@@ -32,6 +32,8 @@ import com.swmansion.enriched.markdown.input.events.OnRequestMarkdownResultEvent
 import com.swmansion.enriched.markdown.input.events.OnStartMentionEvent
 import com.swmansion.enriched.markdown.input.layout.InputMeasurementStore
 import com.swmansion.enriched.markdown.input.model.StyleType
+import com.swmansion.enriched.markdown.input.toolbar.FormatMenuConfig
+import com.swmansion.enriched.markdown.input.toolbar.InputSelectionMenuConfig
 import com.swmansion.enriched.markdown.utils.input.BorderPropsApplicator
 import com.swmansion.enriched.markdown.utils.input.MarkdownStyleParser
 
@@ -55,6 +57,13 @@ class EnrichedMarkdownTextInputManager :
     stateWrapper: StateWrapper?,
   ): Any? {
     view.stateWrapper = stateWrapper
+    // Fabric applies props before it hands over the state wrapper, so every layout
+    // invalidation raised during the mount transaction was dropped. Replay it now that we can
+    // actually push state — otherwise the shadow node keeps the initialMeasure() estimate,
+    // which ignores math chips, until the first keystroke.
+    if (stateWrapper != null) {
+      view.layoutManager.flushPendingInvalidation()
+    }
     return super.updateState(view, props, stateWrapper)
   }
 
@@ -67,6 +76,11 @@ class EnrichedMarkdownTextInputManager :
     view.dismissActiveMention()
     super.onDropViewInstance(view)
     view.layoutManager.release()
+    // Unreachable while view recycling is off — it needs a `setupViewRecycling()` call from this
+    // constructor *and* ReactNativeFeatureFlags.enableViewRecycling(). Kept because the flush
+    // above turns a recycled view into a view that pushes state at mount: without this, it would
+    // push into the shadow node it was dropped from.
+    view.stateWrapper = null
   }
 
   override fun measure(
@@ -156,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?,
@@ -266,6 +288,52 @@ class EnrichedMarkdownTextInputManager :
     view.setContextMenuItems(items)
   }
 
+  @ReactProp(name = "selectionMenuConfig")
+  override fun setSelectionMenuConfig(
+    view: EnrichedMarkdownTextInputView?,
+    value: ReadableMap?,
+  ) {
+    if (view == null) return
+    view.contextMenu.selectionMenuConfig =
+      if (value == null) {
+        InputSelectionMenuConfig()
+      } else {
+        InputSelectionMenuConfig(
+          format = value.getBoolean("format"),
+          formatLabel = value.getString("formatLabel") ?: "",
+          copyAsMarkdown = value.getBoolean("copyAsMarkdown"),
+          copyAsMarkdownLabel = value.getString("copyAsMarkdownLabel") ?: "",
+        )
+      }
+  }
+
+  @ReactProp(name = "formatMenuConfig")
+  override fun setFormatMenuConfig(
+    view: EnrichedMarkdownTextInputView?,
+    value: ReadableMap?,
+  ) {
+    if (view == null) return
+    view.contextMenu.formatMenuConfig =
+      if (value == null) {
+        FormatMenuConfig()
+      } else {
+        FormatMenuConfig(
+          bold = value.getBoolean("bold"),
+          boldLabel = value.getString("boldLabel") ?: "",
+          italic = value.getBoolean("italic"),
+          italicLabel = value.getString("italicLabel") ?: "",
+          underline = value.getBoolean("underline"),
+          underlineLabel = value.getString("underlineLabel") ?: "",
+          strikethrough = value.getBoolean("strikethrough"),
+          strikethroughLabel = value.getString("strikethroughLabel") ?: "",
+          spoiler = value.getBoolean("spoiler"),
+          spoilerLabel = value.getString("spoilerLabel") ?: "",
+          link = value.getBoolean("link"),
+          linkLabel = value.getString("linkLabel") ?: "",
+        )
+      }
+  }
+
   @ReactProp(name = "linkRegex")
   override fun setLinkRegex(
     view: EnrichedMarkdownTextInputView?,
@@ -445,6 +513,10 @@ class EnrichedMarkdownTextInputManager :
     view?.removeMath(start)
   }
 
+  override fun copyToClipboard(view: EnrichedMarkdownTextInputView?) {
+    view?.copyToClipboard()
+  }
+
   override fun requestMarkdown(
     view: EnrichedMarkdownTextInputView?,
     requestId: Int,

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

@@ -1,5 +1,7 @@
 package com.swmansion.enriched.markdown.input
 
+import android.content.ClipData
+import android.content.ClipboardManager
 import android.content.Context
 import android.graphics.BlendMode
 import android.graphics.BlendModeColorFilter
@@ -44,6 +46,8 @@ import com.swmansion.enriched.markdown.input.toolbar.InputContextMenu
 import com.swmansion.enriched.markdown.utils.input.AutoCapitalizeUtils
 import kotlin.math.ceil
 
+private fun Char.isLineBreak(): Boolean = this == '\n' || this == '\r' || this == '\u0085' || this == '\u2028' || this == '\u2029'
+
 class EnrichedMarkdownTextInputView(
   context: Context,
 ) : AppCompatEditText(context) {
@@ -71,6 +75,7 @@ class EnrichedMarkdownTextInputView(
   var autoFocusRequested = false
   var stateWrapper: StateWrapper? = null
   val layoutManager = InputLayoutManager(this)
+  private var pendingAutoFocusKeyboard = false
 
   private var typefaceDirty = false
   private var fontFamilyValue: String? = null
@@ -92,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
@@ -176,6 +192,13 @@ class EnrichedMarkdownTextInputView(
     refreshAllMathChips()
   }
 
+  override fun onWindowFocusChanged(hasWindowFocus: Boolean) {
+    super.onWindowFocusChanged(hasWindowFocus)
+    // The autofocus keyboard request may run before the window has IME focus (e.g. while a modal is
+    // still presenting), where showSoftInput() is dropped.
+    showAutoFocusKeyboardIfPending()
+  }
+
   override fun clearFocus() {
     super.clearFocus()
     inputMethodManager?.hideSoftInputFromWindow(windowToken, 0)
@@ -312,6 +335,12 @@ class EnrichedMarkdownTextInputView(
     if (!isComponentReady || isDuringTransaction) return
 
     if (!isTextChanging) {
+      // Links (e.g. mentions) are atomic: snap a partial selection to the whole link, and a caret
+      // inside a link to its end. Returning lets the recursive onSelectionChanged emit for the result.
+      formattingStore.selectionAdjustedForAtomicLinks(selStart, selEnd)?.let { (newStart, newEnd) ->
+        setSelection(newStart, newEnd)
+        return
+      }
       if (didTextChangeRecently) {
         didTextChangeRecently = false
       } else {
@@ -345,8 +374,18 @@ class EnrichedMarkdownTextInputView(
     val rangeStart = if (preEditSelectionStart != preEditSelectionEnd) preEditSelectionStart else editStart
     val rangeEnd = rangeStart + insertedLength
 
-    for (style in pendingStyles) {
-      formattingStore.addRange(FormattingRange(style, rangeStart, rangeEnd))
+    // Skip applying pending styles when the insertion is only line breaks —
+    // a phantom range over a bare newline corrupts isStyleActive() at the boundary.
+    val currentText = text
+    val insertedHasGlyphContent =
+      currentText != null &&
+        rangeEnd <= currentText.length &&
+        (rangeStart until rangeEnd).any { !currentText[it].isLineBreak() }
+
+    if (insertedHasGlyphContent) {
+      for (style in pendingStyles) {
+        formattingStore.addRange(FormattingRange(style, rangeStart, rangeEnd))
+      }
     }
 
     for (style in pendingStyleRemovals) {
@@ -439,6 +478,16 @@ class EnrichedMarkdownTextInputView(
     }
   }
 
+  // Copies the input's plain text to the system clipboard without disturbing
+  // the current selection. Android's system clipboard round-trip is plain text
+  // only — inline styles are not preserved for external paste targets.
+  fun copyToClipboard() {
+    val content = text
+    if (content.isNullOrEmpty()) return
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return
+    clipboard.setPrimaryClip(ClipData.newPlainText(null, content))
+  }
+
   fun setLinkForSelection(url: String) {
     val selStart = selectionStart
     val selEnd = selectionEnd
@@ -596,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 {
@@ -670,8 +720,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
   }
@@ -810,18 +868,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,
@@ -831,13 +907,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
@@ -954,11 +1038,25 @@ class EnrichedMarkdownTextInputView(
     setSelection(selectionStart.coerceAtLeast(0))
   }
 
+  private fun showAutoFocusKeyboardIfPending() {
+    if (!pendingAutoFocusKeyboard || !hasWindowFocus()) return
+    pendingAutoFocusKeyboard = false
+    inputMethodManager?.showSoftInput(this, 0)
+  }
+
   fun afterUpdateTransaction() {
     updateTypeface()
     if (autoFocusRequested) {
       autoFocusRequested = false
-      requestFocusProgrammatically()
+      pendingAutoFocusKeyboard = true
+      post {
+        // afterUpdateTransaction runs before onAttachedToWindow, where requestFocus()/showSoftInput()
+        // are dropped and setTextIsSelectable(true) would reset the caret to 0. Defer to the next loop
+        // so focus sticks and the caret lands at end (matching iOS).
+        requestFocus()
+        setSelection(text?.length ?: 0)
+        showAutoFocusKeyboardIfPending()
+      }
     }
   }
 

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

@@ -34,6 +34,25 @@ class FormattingStore {
     end: Int,
   ): Boolean = ranges.any { it.type == type && it.start < end && it.end > start }
 
+  /**
+   * Snaps a selection so it never partially overlaps an atomic link: a partial selection expands to
+   * the whole link, a caret inside a link moves to its end. Returns the adjusted (start, end) or null.
+   */
+  fun selectionAdjustedForAtomicLinks(
+    start: Int,
+    end: Int,
+  ): Pair<Int, Int>? {
+    if (start != end) {
+      var newStart = start
+      var newEnd = end
+      rangeOfType(StyleType.LINK, newStart)?.let { newStart = minOf(newStart, it.start) }
+      if (newEnd > 0) rangeOfType(StyleType.LINK, newEnd - 1)?.let { newEnd = maxOf(newEnd, it.end) }
+      return if (newStart != start || newEnd != end) Pair(newStart, newEnd) else null
+    }
+    val link = rangeOfType(StyleType.LINK, start)
+    return if (link != null && start > link.start && start < link.end) Pair(link.end, link.end) else null
+  }
+
   fun addRange(newRange: FormattingRange) {
     var mergedStart = newRange.start
     var mergedEnd = newRange.end

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

@@ -7,6 +7,7 @@ import com.swmansion.enriched.markdown.parser.MarkdownASTNode
 import com.swmansion.enriched.markdown.parser.MarkdownASTNode.NodeType
 import com.swmansion.enriched.markdown.parser.Md4cFlags
 import com.swmansion.enriched.markdown.parser.Parser
+import com.swmansion.enriched.markdown.parser.isTopLevelBlock
 import com.swmansion.enriched.markdown.utils.common.FeatureFlags
 
 data class ParseResult(
@@ -18,25 +19,96 @@ data class ParseResult(
 object InputParser {
   private const val ATTACHMENT_CHAR = ''
 
-  fun parseToPlainTextAndRanges(markdown: String): ParseResult {
+  // 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,
+    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>()
     val mathAtoms = mutableListOf<MathAtom>()
 
-    walkNode(ast, plainText, ranges, mathAtoms, ArrayDeque())
+    // 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 =
+      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, blockSeparators)
 
     return ParseResult(plainText.toString(), ranges, mathAtoms)
   }
@@ -47,6 +119,8 @@ object InputParser {
     ranges: MutableList<FormattingRange>,
     mathAtoms: MutableList<MathAtom>,
     activeStyles: ArrayDeque<ActiveStyle>,
+    blankRuns: ArrayDeque<Int>,
+    blockSeparators: Boolean,
   ) {
     if (node.type == NodeType.LatexMathInline || node.type == NodeType.LatexMathDisplay) {
       val latex = extractLatex(node)
@@ -75,8 +149,12 @@ object InputParser {
       plainText.append("\n")
     }
 
-    for (child in node.children) {
-      walkNode(child, plainText, ranges, mathAtoms, activeStyles)
+    for ((index, child) in node.children.withIndex()) {
+      // Keep the source's blank lines between top-level blocks (md4c drops them, iOS keeps them).
+      if (blockSeparators && index > 0 && child.type.isTopLevelBlock() && plainText.isNotEmpty()) {
+        plainText.append("\n".repeat(blankRuns.removeFirstOrNull() ?: 2))
+      }
+      walkNode(child, plainText, ranges, mathAtoms, activeStyles, blankRuns, blockSeparators)
     }
 
     if (styleType != null) {

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

@@ -9,6 +9,7 @@ object InputRemend {
 
   private val DELIMITER_PAIRS =
     arrayOf(
+      DelimiterPair("***", "***", true),
       DelimiterPair("**", "**", true),
       DelimiterPair("*", "*", true),
       DelimiterPair("_", "_", true),

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

@@ -9,6 +9,9 @@ import com.facebook.react.bridge.ReadableMap
 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 {
@@ -93,8 +96,16 @@ object InputMeasurementStore {
     width: Float,
     props: ReadableMap?,
   ): Long {
-    val text = props?.getString("defaultValue") ?: props?.getString("placeholder") ?: "I"
-    val fontSize = props?.getDouble("fontSize")?.toFloat() ?: 16f
+    // Measure the rendered plain text, not the raw markdown. A mention link such as
+    // [Label](placeholder://x) hides its URL in the source, so measuring the markdown counts those
+    // 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"
+    // 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
 }