react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

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

@@ -14,12 +14,15 @@ import com.swmansion.enriched.markdown.input.events.OnContextMenuItemPressEvent
 import com.swmansion.enriched.markdown.input.events.OnEndMentionEvent
 import com.swmansion.enriched.markdown.input.events.OnInputBlurEvent
 import com.swmansion.enriched.markdown.input.events.OnInputFocusEvent
+import com.swmansion.enriched.markdown.input.events.OnInputKeyPressEvent
 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
 import com.swmansion.enriched.markdown.input.formatting.MarkdownSerializer
+import com.swmansion.enriched.markdown.input.model.BlockType
 import com.swmansion.enriched.markdown.input.model.CaretRect
 import com.swmansion.enriched.markdown.input.model.StyleType
 
@@ -27,10 +30,25 @@ class InputEventEmitter(
   private val view: EnrichedMarkdownTextInputView,
 ) {
   private var prevState: Map<StyleType, Boolean> = emptyMap()
+  private var prevHeadingLevel: Int = 0
+  private var prevUnorderedList: Pair<Boolean, Int> = false to 0
+  private var prevOrderedList: Pair<Boolean, Int> = false to 0
   private var prevCaretRect: CaretRect? = null
 
   fun emitChangeText() {
-    val plainText = view.text?.toString() ?: ""
+    // The empty-list-line ZWSP anchor is an internal editing detail — never leak
+    // it to JS. Both output paths (plain text here, markdown) funnel through the
+    // same MarkdownSerializer.stripZwsp choke point.
+    //
+    // A math chip's U+FFFC placeholder is deliberately NOT stripped, and expanding it
+    // to `$latex$` here would be worse. This string has to stay index-compatible with
+    // the buffer: onChangeSelection, onChangeCaretRect and insertMath/updateMath/
+    // removeMath all speak buffer offsets, where a chip is exactly one character.
+    // Strip or expand it and every offset JS holds points at the wrong place. iOS
+    // lands in the same spot for free (an NSTextAttachment *is* U+FFFC in the string),
+    // so keeping it is also what makes the two platforms agree. Documented in
+    // docs/API_REFERENCE.md under onChangeText.
+    val plainText = MarkdownSerializer.stripZwsp(view.text?.toString() ?: "")
     dispatch(OnChangeTextEvent(surfaceId(), view.id, plainText))
   }
 
@@ -51,9 +69,19 @@ class InputEventEmitter(
       StyleType.entries.associateWith { style ->
         isStyleEffectivelyActive(style, pos)
       }
+    val headingLevel = view.headingLevelAtCursor()
+    val unorderedList = view.listStateAtCursor(BlockType.UNORDERED_LIST_ITEM)
+    val orderedList = view.listStateAtCursor(BlockType.ORDERED_LIST_ITEM)
 
-    if (current == prevState) return
+    if (current == prevState && headingLevel == prevHeadingLevel && unorderedList == prevUnorderedList &&
+      orderedList == prevOrderedList
+    ) {
+      return
+    }
     prevState = current
+    prevHeadingLevel = headingLevel
+    prevUnorderedList = unorderedList
+    prevOrderedList = orderedList
 
     dispatch(
       OnChangeStateEvent(
@@ -65,10 +93,19 @@ class InputEventEmitter(
         current[StyleType.STRIKETHROUGH] ?: false,
         current[StyleType.SPOILER] ?: false,
         current[StyleType.LINK] ?: false,
+        headingLevel,
+        unorderedList.first,
+        unorderedList.second,
+        orderedList.first,
+        orderedList.second,
       ),
     )
   }
 
+  fun emitKeyPress(key: String) {
+    dispatch(OnInputKeyPressEvent(surfaceId(), view.id, key))
+  }
+
   fun emitFocus() {
     dispatch(OnInputFocusEvent(surfaceId(), view.id))
   }
@@ -99,6 +136,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))
   }
@@ -169,6 +213,8 @@ class InputEventEmitter(
         isStyleEffectivelyActive(type, selectionStart)
       }
 
+    val contextMenuListState = view.listStateAtCursor(BlockType.UNORDERED_LIST_ITEM)
+    val contextMenuOrderedState = view.listStateAtCursor(BlockType.ORDERED_LIST_ITEM)
     dispatch(
       OnContextMenuItemPressEvent(
         surfaceId(),
@@ -183,6 +229,11 @@ class InputEventEmitter(
         isStrikethrough = isActive(StyleType.STRIKETHROUGH),
         isSpoiler = isActive(StyleType.SPOILER),
         isLink = isActive(StyleType.LINK),
+        headingLevel = view.headingLevelAtCursor(),
+        isUnorderedList = contextMenuListState.first,
+        unorderedListDepth = contextMenuListState.second,
+        isOrderedList = contextMenuOrderedState.first,
+        orderedListDepth = contextMenuOrderedState.second,
       ),
     )
   }
@@ -198,8 +249,18 @@ class InputEventEmitter(
       )
 
   private fun serializeToMarkdown(): String {
-    val editable = view.text ?: return ""
-    return MarkdownSerializer.serialize(editable, view.allFormattingRangesForSerialization(), view.mathChipController)
+    val plainText = view.text?.toString() ?: ""
+    // Each block resolves its markdown line prefix through its registered handler.
+    // With no block handlers registered the provider returns "" for every block
+    // and output equals the inline-only serialization.
+    return MarkdownSerializer.serialize(
+      plainText,
+      view.mathChipsForSerialization(),
+      view.allFormattingRangesForSerialization(),
+      view.blockStore.allRanges,
+    ) { blockRange ->
+      view.formatter.handlerForBlock(blockRange.type)?.markdownLinePrefix(blockRange) ?: ""
+    }
   }
 
   private fun surfaceId(): Int {
@@ -208,7 +269,7 @@ class InputEventEmitter(
   }
 
   private fun dispatch(event: Event<*>) {
-    if (view.blockEmitting) return
+    if (view.editSession.shouldSuppressEvents) return
     val reactContext = view.context as? ReactContext ?: return
     val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)
     dispatcher?.dispatchEvent(event)

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 {
@@ -101,9 +103,9 @@ object InputMeasurementStore {
     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 = if (props?.hasKey("blockSyntax") == true) props.getBoolean("blockSyntax") else true
+    val blockSyntax = props.getBooleanOrDefault("blockSyntax", true)
     val text = InputParser.parseToPlainTextAndRanges(markdown, blockSyntax).plainText
-    val fontSize = props?.getDouble("fontSize")?.toFloat() ?: 16f
+    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/BlockRange.kt

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.input.model
+
+/**
+ * A block-level element occupying a paragraph/line range. Mirrors [FormattingRange]
+ * but for block scope: the range always covers whole lines.
+ *
+ * Deliberately NOT a data class: [start]/[end] mutate as edits shift ranges, so
+ * value-based equals/hashCode would silently break set/map lookups. Identity
+ * semantics are the safe default for a mutable model.
+ *
+ * @property type the block kind (PARAGRAPH is the implicit default).
+ * @property start inclusive start offset, in plain-text characters.
+ * @property end exclusive end offset, in plain-text characters.
+ * @property level generic integer payload, 0 by default. Headings use it for the
+ *   H-level (1-6); list items use it for nesting depth.
+ * @property ordinal 1-based position of an ordered list item among its adjacent
+ *   siblings at the same depth; recomputed by the store's list-metadata pass.
+ */
+class BlockRange(
+  val type: BlockType,
+  override var start: Int,
+  override var end: Int,
+  var level: Int = 0,
+  var ordinal: Int = 1,
+) : MutableRangeBounds {
+  val length: Int get() = end - start
+}

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

@@ -0,0 +1,48 @@
+package com.swmansion.enriched.markdown.input.model
+
+/**
+ * Block-level (paragraph-scoped) element types. A block covers whole lines,
+ * unlike inline styles ([StyleType]) which cover character ranges.
+ *
+ * PARAGRAPH is the default: every line is a paragraph until a block handler
+ * claims it. Concrete block types (headings, list items, etc.) are appended
+ * here as their handlers are added — each new case must have a matching
+ * [com.swmansion.enriched.markdown.input.styles.BlockHandler] registered in
+ * [com.swmansion.enriched.markdown.input.formatting.InputFormatter].
+ */
+enum class BlockType {
+  PARAGRAPH,
+  HEADING_1,
+  HEADING_2,
+  HEADING_3,
+  HEADING_4,
+  HEADING_5,
+  HEADING_6,
+  UNORDERED_LIST_ITEM,
+  ORDERED_LIST_ITEM,
+  ;
+
+  companion object {
+    /** The six heading block types, indexable by level via [forHeadingLevel]. */
+    val HEADINGS: List<BlockType> =
+      listOf(HEADING_1, HEADING_2, HEADING_3, HEADING_4, HEADING_5, HEADING_6)
+
+    /** List-item block types; nesting depth rides in the range's level payload. */
+    val LIST_ITEMS: Set<BlockType> = setOf(UNORDERED_LIST_ITEM, ORDERED_LIST_ITEM)
+
+    /**
+     * Block types whose emptied line persists as a zero-length anchor (an emptied
+     * heading stays a heading, an emptied list item keeps its marker) until toggled off.
+     */
+    val ANCHORED: Set<BlockType> = HEADINGS.toSet() + LIST_ITEMS
+
+    /**
+     * Maps an H-level (1-6) to its [BlockType], or null when out of range. Used by
+     * the parser to turn an AST heading node's `level` attribute into a block type.
+     */
+    fun forHeadingLevel(level: Int): BlockType? = HEADINGS.getOrNull(level - 1)
+  }
+}
+
+/** Maximum bullet-list nesting depth (0-based), so indent can't run away unbounded. */
+const val MAX_LIST_DEPTH = 5

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

@@ -1,10 +1,15 @@
 package com.swmansion.enriched.markdown.input.model
 
-data class FormattingRange(
+/**
+ * Deliberately NOT a data class: [start]/[end] mutate as edits shift ranges, so
+ * value-based equals/hashCode would silently break set/map lookups. Identity
+ * semantics are the safe default for a mutable model.
+ */
+class FormattingRange(
   val type: StyleType,
-  var start: Int,
-  var end: Int,
+  override var start: Int,
+  override var end: Int,
   var url: String? = null,
-) {
+) : MutableRangeBounds {
   val length: Int get() = end - start
 }

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

@@ -9,8 +9,45 @@ data class InputFormatterStyle(
   val linkVariants: List<InputLinkVariantStyle>,
   val spoilerColor: Int,
   val spoilerBackgroundColor: Int,
-  val math: MathChipStyle,
-  val mathBlock: MathChipStyle,
+  /**
+   * Inline chip style (`markdownStyle.inlineMath`). NOTE for anyone porting
+   * pre-rename fork code: this used to be called `math`. The field now named
+   * `math` is the **block** style — the two swapped meaning, and both are
+   * chip styles, so a stale read compiles clean and styles the wrong chip.
+   */
+  val inlineMath: MathChipStyle,
+  /** Block chip style (`markdownStyle.math`). Narrowed to [MathBlockStyle] so
+   * passing the inline style where block fields are needed is a compile error. */
+  val math: MathBlockStyle,
+  /** Per-level heading styling, indexed 0..5 for H1..H6. Always length 6. */
+  val headings: List<InputHeadingStyle>,
+  /**
+   * Extra vertical spacing (dp) above each list item, from `markdownStyle.list.itemSpacing`.
+   * Kept in dp (not px) so this stays a pure style value; the list block handlers convert
+   * to px with the display density they hold.
+   */
+  val listItemSpacing: Float = 0f,
+) {
+  /**
+   * Resolves the heading style for an H-level (1-6), clamping out-of-range levels
+   * to the nearest valid level so a malformed parse can never crash the formatter.
+   */
+  fun headingStyle(level: Int): InputHeadingStyle = headings[(level - 1).coerceIn(0, headings.size - 1)]
+}
+
+/**
+ * Resolved per-level heading style for the input editor.
+ *
+ * @property fontSizePx font size in pixels (already converted from the SP prop),
+ *   or null to leave the base text size unchanged.
+ * @property fontWeight parsed font weight (e.g. [android.graphics.Typeface.BOLD]),
+ *   or [com.facebook.react.common.ReactConstants.UNSET] when unspecified.
+ * @property color text color, or null to keep the editor's default color.
+ */
+data class InputHeadingStyle(
+  val fontSizePx: Float?,
+  val fontWeight: Int,
+  val color: Int?,
 )
 
 data class InputLinkVariantStyle(

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

@@ -1,5 +1,25 @@
 package com.swmansion.enriched.markdown.input.model
 
+/**
+ * U+FFFC OBJECT REPLACEMENT CHARACTER — the one character a math chip occupies in
+ * the editor's plain text. Everything about a formula (its LaTeX, its display mode)
+ * lives on the span, never in the buffer, so the chip stays atomic for the caret,
+ * the IME and every range in the stores.
+ *
+ * Single source of truth on purpose: the parser writes it, the serializer expands
+ * it back to `$…$`, and the view inserts it. A second copy of this literal is a
+ * silent round-trip break waiting to happen.
+ */
+const val OBJECT_REPLACEMENT: Char = ''
+
+/**
+ * A math formula parsed out of markdown, ready to be turned into a chip span.
+ *
+ * @property position offset of the [OBJECT_REPLACEMENT] placeholder in the parsed
+ *   plain text.
+ * @property latex the formula source, without its `$`/`$$` delimiters.
+ * @property displayMode true for `$$…$$` (block chip), false for `$…$` (inline chip).
+ */
 data class MathAtom(
   val position: Int,
   val latex: String,

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

@@ -32,7 +32,7 @@ class MathBlockStyle(
   fontWeight: String = "normal",
   val marginTop: Float,
   val marginBottom: Float,
-  val alignment: Layout.Alignment,
+  val textAlign: Layout.Alignment,
 ) : MathChipStyle(
     color,
     fontSize,

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

@@ -0,0 +1,11 @@
+package com.swmansion.enriched.markdown.input.model
+
+/**
+ * Mutable `[start, end)` character bounds shared by the stored range models so
+ * [com.swmansion.enriched.markdown.input.formatting.RangeEditAdjustment] can
+ * shift/clip any range kind after a text edit.
+ */
+interface MutableRangeBounds {
+  var start: Int
+  var end: Int
+}

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

@@ -0,0 +1,82 @@
+package com.swmansion.enriched.markdown.input.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.Layout
+import android.text.Spanned
+import android.text.style.LeadingMarginSpan
+import com.swmansion.enriched.markdown.input.formatting.MarkdownSpan
+
+/**
+ * Bullet list item span: reserves a per-depth leading margin and draws the marker
+ * glyph (dot / ring / square, capped at square for depth 2+) on the item's first line.
+ * Mirrors the readonly renderer's bullet. Tagged [MarkdownSpan] for formatter
+ * cleanup.
+ */
+class InputBulletSpan(
+  val depth: Int,
+  density: Float,
+) : LeadingMarginSpan,
+  MarkdownSpan {
+  private val indentPerDepth = INDENT_PER_DEPTH_DP * density
+  private val markerWidth = MARKER_WIDTH_DP * density
+
+  override fun getLeadingMargin(first: Boolean): Int = (depth * indentPerDepth + markerWidth).toInt()
+
+  override fun drawLeadingMargin(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    if (!first) return
+    // Wrapped continuation lines also report first=true; draw only on the visual
+    // line where this span actually begins.
+    if (text is Spanned && text.getSpanStart(this) != start) return
+
+    // Bullet size tracks the text size (~30%), with a small floor so it stays visible.
+    val size = (paint.textSize * BULLET_SIZE_RATIO).coerceAtLeast(MIN_BULLET_PX)
+    val radius = size / 2f
+    val centerX = x + (depth * indentPerDepth + markerWidth * 0.5f) * dir
+    val fm = paint.fontMetrics
+    val centerY = baseline + (fm.ascent + fm.descent) / 2f
+
+    val originalStyle = paint.style
+    val originalStrokeWidth = paint.strokeWidth
+    when (if (depth >= 2) 2 else depth) {
+      0 -> {
+        paint.style = Paint.Style.FILL
+        canvas.drawCircle(centerX, centerY, radius, paint)
+      }
+
+      1 -> {
+        paint.style = Paint.Style.STROKE
+        paint.strokeWidth = (size * RING_STROKE_RATIO).coerceAtLeast(1f)
+        canvas.drawCircle(centerX, centerY, radius - paint.strokeWidth / 2f, paint)
+      }
+
+      else -> {
+        paint.style = Paint.Style.FILL
+        canvas.drawRect(centerX - radius, centerY - radius, centerX + radius, centerY + radius, paint)
+      }
+    }
+    paint.style = originalStyle
+    paint.strokeWidth = originalStrokeWidth
+  }
+
+  companion object {
+    private const val INDENT_PER_DEPTH_DP = 18f
+    private const val MARKER_WIDTH_DP = 18f
+    private const val BULLET_SIZE_RATIO = 0.3f
+    private const val MIN_BULLET_PX = 4f
+    private const val RING_STROKE_RATIO = 0.15f
+  }
+}

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

@@ -0,0 +1,58 @@
+package com.swmansion.enriched.markdown.input.spans
+
+import android.annotation.SuppressLint
+import android.graphics.Typeface
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import com.facebook.react.common.ReactConstants
+import com.swmansion.enriched.markdown.input.formatting.MarkdownSpan
+import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
+
+/**
+ * Sizes and optionally weights/colors a heading line per [InputFormatterStyle.headingStyle].
+ * Preserves inline bold/italic via [BOLD_ITALIC_MASK] so emphasis composes with heading weight.
+ * Tagged [MarkdownSpan] for formatter cleanup.
+ */
+class InputHeadingSpan(
+  val level: Int,
+  style: InputFormatterStyle,
+) : MetricAffectingSpan(),
+  MarkdownSpan {
+  private val resolved = style.headingStyle(level)
+
+  override fun updateDrawState(tp: TextPaint) {
+    applyHeadingStyle(tp)
+    resolved.color?.let { tp.color = it }
+  }
+
+  override fun updateMeasureState(tp: TextPaint) {
+    applyHeadingStyle(tp)
+  }
+
+  @SuppressLint("WrongConstant") // Result of mask is always valid: 0, 1, 2, or 3
+  private fun applyHeadingStyle(tp: TextPaint) {
+    resolved.fontSizePx?.let { tp.textSize = it }
+
+    if (resolved.fontWeight != ReactConstants.UNSET) {
+      // Fold the configured heading weight into whatever bold/italic an inline span
+      // already applied, so heading weight and inline emphasis compose instead of
+      // one clobbering the other.
+      val inlineStyle = (tp.typeface?.style ?: 0) and BOLD_ITALIC_MASK
+      val headingBold = if (resolved.fontWeight >= BOLD_WEIGHT_THRESHOLD) Typeface.BOLD else 0
+      val combined = inlineStyle or headingBold
+      tp.typeface =
+        if (combined != 0) {
+          Typeface.create(tp.typeface, combined)
+        } else {
+          tp.typeface
+        }
+    }
+  }
+
+  companion object {
+    private const val BOLD_ITALIC_MASK = Typeface.BOLD or Typeface.ITALIC
+
+    // React Native treats weights >= 700 as bold.
+    private const val BOLD_WEIGHT_THRESHOLD = 700
+  }
+}

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

@@ -0,0 +1,37 @@
+package com.swmansion.enriched.markdown.input.spans
+
+import android.graphics.Paint
+import android.text.Spanned
+import android.text.style.LineHeightSpan
+import com.swmansion.enriched.markdown.input.formatting.MarkdownSpan
+
+/**
+ * Adds [spacingPx] of vertical space above a bullet item (counterpart to iOS
+ * `paragraphSpacingBefore`). Tagged [MarkdownSpan] for formatter cleanup.
+ *
+ * StaticLayout treats a LineHeightSpan as paragraph-scoped: [chooseHeight] runs
+ * for every wrapped line of the item regardless of the span's character range,
+ * and the FontMetricsInt is reused across those calls, so an unguarded relative
+ * adjustment compounds line after line (progressively growing gaps). Guard to
+ * the single line that contains the span start so only the item's first visual
+ * line is spaced, exactly once.
+ */
+class InputListItemSpacingSpan(
+  val spacingPx: Int,
+) : LineHeightSpan,
+  MarkdownSpan {
+  override fun chooseHeight(
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    spanstartv: Int,
+    lineHeight: Int,
+    fm: Paint.FontMetricsInt?,
+  ) {
+    if (fm == null || spacingPx <= 0 || text !is Spanned) return
+    val spanStart = text.getSpanStart(this)
+    if (spanStart < start || spanStart >= end) return
+    fm.ascent -= spacingPx
+    fm.top -= spacingPx
+  }
+}

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

@@ -0,0 +1,63 @@
+package com.swmansion.enriched.markdown.input.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.text.Layout
+import android.text.Spanned
+import android.text.style.LeadingMarginSpan
+import com.swmansion.enriched.markdown.input.formatting.MarkdownSpan
+
+/**
+ * Ordered list item span: reserves the same per-depth leading margin as
+ * [InputBulletSpan] and draws the item's number ("3.") right-aligned before the
+ * text column. The ordinal comes from the block store's list-metadata pass.
+ * Tagged [MarkdownSpan] for formatter cleanup.
+ */
+class InputOrderedListMarkerSpan(
+  val depth: Int,
+  private val ordinal: Int,
+  density: Float,
+) : LeadingMarginSpan,
+  MarkdownSpan {
+  private val indentPerDepth = INDENT_PER_DEPTH_DP * density
+  private val markerWidth = MARKER_WIDTH_DP * density
+  private val markerGap = MARKER_GAP_DP * density
+
+  override fun getLeadingMargin(first: Boolean): Int = (depth * indentPerDepth + markerWidth).toInt()
+
+  override fun drawLeadingMargin(
+    canvas: Canvas,
+    paint: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    if (!first) return
+    // Wrapped continuation lines also report first=true; draw only on the visual
+    // line where this span actually begins.
+    if (text is Spanned && text.getSpanStart(this) != start) return
+
+    // RTL (dir < 0) mirrors the marker to the trailing side and flips the label
+    // to ".3", matching the readonly renderer's OrderedListSpan.
+    val label = if (dir < 0) ".$ordinal" else "$ordinal."
+    val originalAlign = paint.textAlign
+    paint.textAlign = if (dir < 0) Paint.Align.LEFT else Paint.Align.RIGHT
+    val markerEdge = x + (depth * indentPerDepth + markerWidth - markerGap) * dir
+    canvas.drawText(label, markerEdge, baseline.toFloat(), paint)
+    paint.textAlign = originalAlign
+  }
+
+  companion object {
+    // Geometry mirrors InputBulletSpan so ordered and bullet items align.
+    private const val INDENT_PER_DEPTH_DP = 18f
+    private const val MARKER_WIDTH_DP = 18f
+    private const val MARKER_GAP_DP = 4f
+  }
+}

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

@@ -0,0 +1,54 @@
+package com.swmansion.enriched.markdown.input.styles
+
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
+import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
+
+/**
+ * A block handler owns how its [BlockType] styles its paragraph and how it
+ * serializes to a markdown line prefix. Mirrors [StyleHandler] for the inline
+ * pipeline. Parser recognition is NOT handler-driven: it lives in
+ * [com.swmansion.enriched.markdown.input.formatting.InputParser]'s central
+ * `nodeTypeToBlockType` map, exactly as `nodeTypeToStyleType` does for inline
+ * styles — a new block type adds one entry there plus one handler here.
+ *
+ * Block spans are paragraph-scoped and applied over the block's whole line range
+ * by [com.swmansion.enriched.markdown.input.formatting.InputFormatter]. Unlike
+ * inline [StyleHandler.createSpans] (which returns `CharacterStyle`), a block
+ * handler returns `List<Any>` so it can mix character spans (a heading's
+ * metric/size span) with paragraph spans (a list item's `LeadingMarginSpan` and
+ * line-spacing span).
+ *
+ * These signatures are designed to cover headings AND list items.
+ */
+interface BlockHandler {
+  val blockType: BlockType
+
+  /**
+   * Whether Enter continues the block onto the next line (a list item) rather
+   * than ending it (a heading). Keeps Enter behavior handler-driven.
+   */
+  val continuesOnNewline: Boolean
+    get() = false
+
+  /**
+   * Spans to apply over the block's line range. Returned spans are tagged with
+   * [com.swmansion.enriched.markdown.input.formatting.MarkdownSpan] so the
+   * formatter can clean up only spans it created. A heading raises the font
+   * size; a list item sets a leading margin and a marker. May be empty.
+   */
+  fun createSpans(
+    blockRange: BlockRange,
+    style: InputFormatterStyle,
+  ): List<Any>
+
+  /** Span classes this handler produces, for cleanup/identity (mirrors [StyleHandler.spanClasses]). */
+  fun spanClasses(): List<Class<*>>
+
+  /**
+   * Markdown prefix prepended to each line of the block during serialization,
+   * e.g. `"# "` for an H1 or `"- "` for a bullet. Returns `""` when the block
+   * needs no prefix. Owning the marker here replaces a central serializer switch.
+   */
+  fun markdownLinePrefix(blockRange: BlockRange): String
+}