react-native-enriched-markdown 0.1.1 → 0.2.0

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

@@ -6,18 +6,28 @@ import android.graphics.text.LineBreaker
 import android.os.Build
 import android.text.StaticLayout
 import android.text.TextPaint
+import android.util.Log
 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.parser.Md4cFlags
+import com.swmansion.enriched.markdown.parser.Parser
+import com.swmansion.enriched.markdown.renderer.Renderer
+import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.utils.getBooleanOrDefault
+import com.swmansion.enriched.markdown.utils.getMapOrNull
+import com.swmansion.enriched.markdown.utils.getStringOrDefault
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.math.ceil
 
 /**
  * Manages text measurements for ShadowNode layout.
- * Initial estimate uses raw markdown; accurate measurement after rendering via store().
+ * Parses and renders markdown to Spannable at measure time for accurate height calculation.
  */
 object MeasurementStore {
+  private const val TAG = "MeasurementStore"
+
   private data class PaintParams(
     val typeface: Typeface,
     val fontSize: Float,
@@ -28,11 +38,41 @@ object MeasurementStore {
     val cachedSize: Long,
     val spannable: CharSequence?,
     val paintParams: PaintParams,
+    val markdownHash: Int,
   )
 
   private val data = ConcurrentHashMap<Int, MeasurementParams>()
 
+  // Store font scaling settings per view ID
+  private data class FontScalingSettings(
+    val allowFontScaling: Boolean = true,
+    val maxFontSizeMultiplier: Float = 0f,
+  )
+
+  private val fontScalingSettings = ConcurrentHashMap<Int, FontScalingSettings>()
+
+  private fun resolveFontScalingSettings(
+    viewId: Int?,
+    props: ReadableMap?,
+  ): FontScalingSettings {
+    val stored = viewId?.let { fontScalingSettings[it] }
+    return FontScalingSettings(
+      allowFontScaling =
+        props?.takeIf { it.hasKey("allowFontScaling") }?.getBoolean("allowFontScaling")
+          ?: stored?.allowFontScaling
+          ?: true,
+      maxFontSizeMultiplier =
+        props?.takeIf { it.hasKey("maxFontSizeMultiplier") }?.getDouble("maxFontSizeMultiplier")?.toFloat()
+          ?: stored?.maxFontSizeMultiplier
+          ?: 0f,
+    )
+  }
+
   private val measurePaint = TextPaint()
+  private val measureRenderer = Renderer()
+
+  @Volatile
+  private var lastKnownFontScale: Float = 1.0f
 
   /** Updates measurement with rendered Spannable. Returns true if height changed. */
   fun store(
@@ -43,10 +83,11 @@ object MeasurementStore {
     val cached = data[id]
     val width = cached?.cachedWidth ?: 0f
     val oldSize = cached?.cachedSize ?: 0L
+    val existingHash = cached?.markdownHash ?: 0
     val paintParams = PaintParams(paint.typeface ?: Typeface.DEFAULT, paint.textSize)
 
     val newSize = measure(width, spannable, paint)
-    data[id] = MeasurementParams(width, newSize, spannable, paintParams)
+    data[id] = MeasurementParams(width, newSize, spannable, paintParams, existingHash)
     return oldSize != newSize
   }
 
@@ -63,7 +104,13 @@ object MeasurementStore {
     heightMode: YogaMeasureMode?,
     props: ReadableMap?,
   ): Long {
-    val size = getMeasureByIdInternal(id, width, props)
+    // Early exit for empty markdown
+    val markdown = props.getStringOrDefault("markdown", "")
+    if (markdown.isEmpty()) {
+      return YogaMeasureOutput.make(PixelUtil.toDIPFromPixel(width), 0f)
+    }
+
+    val size = getMeasureByIdInternal(context, id, width, props)
     val resultHeight = YogaMeasureOutput.getHeight(size)
 
     if (heightMode === YogaMeasureMode.AT_MOST) {
@@ -78,47 +125,178 @@ object MeasurementStore {
     return size
   }
 
+  fun updateFontScalingSettings(
+    viewId: Int,
+    allowFontScaling: Boolean,
+    maxFontSizeMultiplier: Float,
+  ) {
+    fontScalingSettings[viewId] = FontScalingSettings(allowFontScaling, maxFontSizeMultiplier)
+  }
+
+  fun clearFontScalingSettings(viewId: Int) {
+    fontScalingSettings.remove(viewId)
+  }
+
   private fun getMeasureByIdInternal(
+    context: Context,
     id: Int?,
     width: Float,
     props: ReadableMap?,
   ): Long {
-    val safeId = id ?: return initialMeasure(null, width, props)
-    val cached = data[safeId] ?: return initialMeasure(safeId, width, props)
+    val (allowFontScaling, maxFontSizeMultiplier) = resolveFontScalingSettings(id, props)
 
-    // Width changed or not yet measured - re-measure with cached content
-    if (cached.cachedWidth != width || cached.cachedSize == 0L) {
+    val fontScale = checkAndUpdateFontScale(context, allowFontScaling, maxFontSizeMultiplier)
+
+    val safeId = id ?: return measureAndCache(context, null, width, props, allowFontScaling, fontScale, maxFontSizeMultiplier)
+    val cached = data[safeId] ?: return measureAndCache(context, safeId, width, props, allowFontScaling, fontScale, maxFontSizeMultiplier)
+
+    val currentHash = computePropsHash(props, allowFontScaling, fontScale, maxFontSizeMultiplier)
+
+    if (cached.markdownHash != currentHash) {
+      return measureAndCache(context, safeId, width, props, allowFontScaling, fontScale, maxFontSizeMultiplier)
+    }
+
+    // Width changed - re-measure with cached spannable
+    if (cached.cachedWidth != width) {
       val newSize = measure(width, cached.spannable, cached.paintParams)
-      data[safeId] = MeasurementParams(width, newSize, cached.spannable, cached.paintParams)
+      data[safeId] = cached.copy(cachedWidth = width, cachedSize = newSize)
       return newSize
     }
 
     return cached.cachedSize
   }
 
-  /** Fast estimate using raw markdown text. */
-  private fun initialMeasure(
+  private fun computePropsHash(
+    props: ReadableMap?,
+    allowFontScaling: Boolean,
+    fontScale: Float,
+    maxFontSizeMultiplier: Float,
+  ): Int {
+    val markdown = props.getStringOrDefault("markdown", "")
+    val styleMap = props.getMapOrNull("markdownStyle")
+    val md4cFlagsMap = props.getMapOrNull("md4cFlags")
+    val allowTrailingMargin = props.getBooleanOrDefault("allowTrailingMargin", false)
+    var result = markdown.hashCode()
+    result = 31 * result + (styleMap?.hashCode() ?: 0)
+    result = 31 * result + (md4cFlagsMap?.hashCode() ?: 0)
+    result = 31 * result + fontScale.toBits()
+    result = 31 * result + allowFontScaling.hashCode()
+    result = 31 * result + maxFontSizeMultiplier.toBits()
+    result = 31 * result + allowTrailingMargin.hashCode()
+    return result
+  }
+
+  private fun checkAndUpdateFontScale(
+    context: Context,
+    allowFontScaling: Boolean,
+    maxFontSizeMultiplier: Float,
+  ): Float {
+    if (!allowFontScaling) {
+      // Clear cache if we switched from scaling to non-scaling
+      if (lastKnownFontScale != 1.0f) {
+        lastKnownFontScale = 1.0f
+        data.clear()
+      }
+      return 1.0f
+    }
+
+    var currentFontScale = context.resources.configuration.fontScale
+
+    if (maxFontSizeMultiplier >= 1.0f && currentFontScale > maxFontSizeMultiplier) {
+      currentFontScale = maxFontSizeMultiplier
+    }
+    if (currentFontScale != lastKnownFontScale) {
+      lastKnownFontScale = currentFontScale
+      data.clear()
+    }
+    return currentFontScale
+  }
+
+  private fun measureAndCache(
+    context: Context,
     id: Int?,
     width: Float,
     props: ReadableMap?,
+    allowFontScaling: Boolean,
+    fontScale: Float,
+    maxFontSizeMultiplier: Float,
   ): Long {
-    val markdown = props?.getString("markdown")?.ifEmpty { "I" } ?: "I"
-    val fontSize = getInitialFontSize(props)
-    val paintParams = PaintParams(Typeface.DEFAULT, fontSize)
+    // 1. Extract Props & Setup
+    val markdown = props.getStringOrDefault("markdown", "")
+    val styleMap = props.getMapOrNull("markdownStyle")
+    val md4cFlags = Md4cFlags(underline = props.getMapOrNull("md4cFlags").getBooleanOrDefault("underline", false))
+
+    val fontSize = getInitialFontSize(styleMap, context, allowFontScaling, fontScale, maxFontSizeMultiplier)
+    val propsHash = computePropsHash(props, allowFontScaling, fontScale, maxFontSizeMultiplier)
+
+    // 2. Render & Measure
+    val spannable = tryRenderMarkdown(markdown, styleMap, context, md4cFlags, allowFontScaling, maxFontSizeMultiplier)
+    val textToMeasure = spannable ?: markdown
+    val (size, _) = measureWithLayout(width, textToMeasure, measurePaint)
 
-    val size = measure(width, markdown, paintParams)
+    // 3. Calculate Margin
+    val allowTrailingMargin = props.getBooleanOrDefault("allowTrailingMargin", false)
+    val marginBottom =
+      if (allowTrailingMargin && spannable != null) {
+        PixelUtil.toDIPFromPixel(measureRenderer.getLastElementMarginBottom())
+      } else {
+        0f
+      }
+
+    // 4. Finalize Height
+    val currentWidth = YogaMeasureOutput.getWidth(size)
+    val currentHeight = YogaMeasureOutput.getHeight(size)
+    val adjustedSize = YogaMeasureOutput.make(currentWidth, currentHeight + marginBottom)
 
     if (id != null) {
-      data[id] = MeasurementParams(width, size, markdown, paintParams)
+      data[id] = MeasurementParams(width, adjustedSize, textToMeasure, PaintParams(Typeface.DEFAULT, fontSize), propsHash)
     }
 
-    return size
+    return adjustedSize
   }
 
-  private fun getInitialFontSize(props: ReadableMap?): Float {
-    val styleMap = props?.getMap("markdownStyle")
-    val fontSize = styleMap?.getMap("paragraph")?.getDouble("fontSize")?.toFloat() ?: 16f
-    return ceil(PixelUtil.toPixelFromSP(fontSize))
+  private fun tryRenderMarkdown(
+    markdown: String,
+    styleMap: ReadableMap?,
+    context: Context,
+    md4cFlags: Md4cFlags,
+    allowFontScaling: Boolean,
+    maxFontSizeMultiplier: Float,
+  ): CharSequence? {
+    if (styleMap == null) return null
+
+    return try {
+      val ast = Parser.shared.parseMarkdown(markdown, md4cFlags) ?: return null
+      val style = StyleConfig(styleMap, context, allowFontScaling, maxFontSizeMultiplier)
+      measureRenderer.configure(style, context)
+      measureRenderer.renderDocument(ast, null)
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to render markdown for measurement, falling back to raw text", e)
+      null
+    }
+  }
+
+  private fun getInitialFontSize(
+    styleMap: ReadableMap?,
+    context: Context,
+    allowFontScaling: Boolean,
+    fontScale: Float,
+    maxFontSizeMultiplier: Float,
+  ): Float {
+    val fontSizeSp = styleMap?.getMap("paragraph")?.getDouble("fontSize")?.toFloat() ?: 16f
+    val density = context.resources.displayMetrics.density
+
+    if (!allowFontScaling) {
+      return ceil(fontSizeSp * density)
+    }
+
+    val cappedFontScale =
+      if (maxFontSizeMultiplier >= 1.0f && fontScale > maxFontSizeMultiplier) {
+        maxFontSizeMultiplier
+      } else {
+        fontScale
+      }
+    return ceil(fontSizeSp * cappedFontScale * density)
   }
 
   private fun measure(
@@ -157,9 +335,51 @@ object MeasurementStore {
     val layout = builder.build()
     val measuredHeight = layout.height.toFloat()
 
+    // Calculate actual content width (widest line)
+    val measuredWidth = (0 until layout.lineCount).maxOfOrNull { layout.getLineWidth(it) } ?: 0f
+
     return YogaMeasureOutput.make(
-      PixelUtil.toDIPFromPixel(maxWidth),
+      PixelUtil.toDIPFromPixel(ceil(measuredWidth)),
       PixelUtil.toDIPFromPixel(measuredHeight),
     )
   }
+
+  /**
+   * Measures text and returns both the size and the layout for calculating last line descent.
+   */
+  private fun measureWithLayout(
+    maxWidth: Float,
+    text: CharSequence?,
+    paint: TextPaint,
+  ): Pair<Long, StaticLayout> {
+    val content = text ?: ""
+    val widthPx = ceil(maxWidth).toInt().coerceAtLeast(1)
+
+    val layout =
+      StaticLayout.Builder
+        .obtain(content, 0, content.length, paint, widthPx)
+        .setIncludePad(false)
+        .setLineSpacing(0f, 1f)
+        .apply {
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            setBreakStrategy(LineBreaker.BREAK_STRATEGY_HIGH_QUALITY)
+          }
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            setUseLineSpacingFromFallbacks(true)
+          }
+        }.build()
+
+    // Find the widest line to get the actual content width
+    val maxLineWidth =
+      (0 until layout.lineCount)
+        .maxOfOrNull { layout.getLineWidth(it) } ?: 0f
+
+    val size =
+      YogaMeasureOutput.make(
+        PixelUtil.toDIPFromPixel(ceil(maxLineWidth)),
+        PixelUtil.toDIPFromPixel(layout.height.toFloat()),
+      )
+
+    return size to layout
+  }
 }

package/android/src/main/java/com/swmansion/enriched/markdown/accessibility/MarkdownAccessibilityHelper.kt

@@ -0,0 +1,279 @@
+package com.swmansion.enriched.markdown.accessibility
+
+import android.graphics.Rect
+import android.os.Bundle
+import android.text.Spanned
+import android.widget.TextView
+import androidx.core.view.accessibility.AccessibilityNodeInfoCompat
+import androidx.customview.widget.ExploreByTouchHelper
+import com.swmansion.enriched.markdown.spans.BaseListSpan
+import com.swmansion.enriched.markdown.spans.HeadingSpan
+import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.LinkSpan
+import com.swmansion.enriched.markdown.spans.OrderedListSpan
+import com.swmansion.enriched.markdown.spans.UnorderedListSpan
+
+class MarkdownAccessibilityHelper(
+  private val textView: TextView,
+) : ExploreByTouchHelper(textView) {
+  private var accessibilityItems: List<AccessibilityItem> = emptyList()
+  private var needsRebuild = false
+  private var lastLayoutHashCode = 0
+
+  data class AccessibilityItem(
+    val id: Int,
+    val text: String,
+    val start: Int,
+    val end: Int,
+    val headingLevel: Int = 0,
+    val linkUrl: String? = null,
+    val listInfo: ListItemInfo? = null,
+    val imageAltText: String? = null,
+  ) {
+    val isHeading get() = headingLevel > 0
+    val isLink get() = linkUrl != null
+    val isListItem get() = listInfo != null
+    val isImage get() = imageAltText != null
+  }
+
+  data class ListItemInfo(
+    val isOrdered: Boolean,
+    val itemNumber: Int,
+    val depth: Int,
+  )
+
+  private data class SpanRange(
+    val start: Int,
+    val end: Int,
+    val headingLevel: Int = 0,
+    val linkUrl: String? = null,
+    val imageAltText: String? = null,
+  )
+
+  fun invalidateAccessibilityItems() {
+    needsRebuild = true
+    rebuildIfNeeded()
+    invalidateRoot()
+  }
+
+  private fun rebuildIfNeeded() {
+    val layout = textView.layout ?: return
+    if (needsRebuild || lastLayoutHashCode != layout.hashCode()) {
+      accessibilityItems = buildAccessibilityItems()
+      needsRebuild = false
+      lastLayoutHashCode = layout.hashCode()
+    }
+  }
+
+  private fun buildAccessibilityItems(): List<AccessibilityItem> {
+    val spanned = textView.text as? Spanned ?: return emptyList()
+    if (spanned.isEmpty()) return emptyList()
+
+    val items = mutableListOf<AccessibilityItem>()
+    var nextId = 0
+
+    // Consolidated span collection using functional mapping
+    val semanticSpans =
+      (
+        spanned.getSpans(0, spanned.length, HeadingSpan::class.java).map {
+          SpanRange(spanned.getSpanStart(it), spanned.getSpanEnd(it), headingLevel = it.level)
+        } +
+          spanned.getSpans(0, spanned.length, LinkSpan::class.java).map {
+            SpanRange(spanned.getSpanStart(it), spanned.getSpanEnd(it), linkUrl = it.url)
+          } +
+          spanned.getSpans(0, spanned.length, ImageSpan::class.java).map {
+            SpanRange(spanned.getSpanStart(it), spanned.getSpanEnd(it), imageAltText = it.altText)
+          }
+      ).sortedBy { it.start }
+
+    var currentPos = 0
+    for (span in semanticSpans) {
+      if (span.start < currentPos) continue
+
+      if (currentPos < span.start) {
+        nextId = addTextSegments(items, spanned, currentPos, span.start, nextId)
+      }
+
+      val content = span.imageAltText?.ifEmpty { "Image" } ?: spanned.substring(span.start, span.end).trim()
+
+      if (content.isNotEmpty()) {
+        val listContext =
+          if (span.headingLevel > 0 || span.imageAltText != null) {
+            null
+          } else {
+            getListInfoAt(spanned, span.start, span.linkUrl == null)
+          }
+        items.add(
+          AccessibilityItem(
+            nextId++,
+            content,
+            span.start,
+            span.end,
+            span.headingLevel,
+            span.linkUrl,
+            listContext,
+            span.imageAltText,
+          ),
+        )
+      }
+      currentPos = span.end
+    }
+
+    if (currentPos < spanned.length) addTextSegments(items, spanned, currentPos, spanned.length, nextId)
+    return items.ifEmpty { listOf(AccessibilityItem(0, spanned.toString().trim(), 0, spanned.length)) }
+  }
+
+  private fun getListInfoAt(
+    spanned: Spanned,
+    position: Int,
+    requireStart: Boolean,
+  ): ListItemInfo? {
+    val deepest = spanned.getSpans(position, position + 1, BaseListSpan::class.java).maxByOrNull { it.depth } ?: return null
+    if (requireStart) {
+      val start = spanned.getSpanStart(deepest)
+      val firstChar = (start until minOf(start + 10, spanned.length)).firstOrNull { !spanned[it].isWhitespace() } ?: start
+      if (position > firstChar + 1) return null
+    }
+    return ListItemInfo(deepest is OrderedListSpan, (deepest as? OrderedListSpan)?.itemNumber ?: 0, deepest.depth)
+  }
+
+  private fun addTextSegments(
+    items: MutableList<AccessibilityItem>,
+    spanned: Spanned,
+    start: Int,
+    end: Int,
+    startId: Int,
+  ): Int {
+    var cid = startId
+    val layout = textView.layout ?: return cid
+    for (line in layout.getLineForOffset(start)..layout.getLineForOffset(end)) {
+      val s = maxOf(start, layout.getLineStart(line))
+      val e = minOf(end, layout.getLineEnd(line))
+      if (s >= e) continue
+
+      val raw = spanned.substring(s, e)
+      val first = raw.indexOfFirst { !it.isWhitespace() }
+      if (first != -1) {
+        val last = raw.indexOfLast { !it.isWhitespace() }
+        val absoluteStart = s + first
+        items.add(
+          AccessibilityItem(cid++, raw.trim(), absoluteStart, s + last + 1, listInfo = getListInfoAt(spanned, absoluteStart, true)),
+        )
+      }
+    }
+    return cid
+  }
+
+  override fun getVirtualViewAt(
+    x: Float,
+    y: Float,
+  ): Int {
+    rebuildIfNeeded()
+    val offset = getOffsetForPosition(x, y)
+    return accessibilityItems
+      .filter { offset in it.start until it.end }
+      .minByOrNull {
+        when {
+          it.isLink -> 0
+          it.isImage -> 1
+          it.isHeading -> 2
+          it.isListItem -> 3
+          else -> 4
+        }
+      }?.id ?: HOST_ID
+  }
+
+  override fun getVisibleVirtualViews(ids: MutableList<Int>) {
+    rebuildIfNeeded()
+    accessibilityItems.forEach { ids.add(it.id) }
+  }
+
+  override fun onPopulateNodeForVirtualView(
+    id: Int,
+    node: AccessibilityNodeInfoCompat,
+  ) {
+    val item = accessibilityItems.find { it.id == id } ?: return
+    node.apply {
+      text = item.text
+      contentDescription = item.text
+      isFocusable = true
+      isScreenReaderFocusable = true
+      setBoundsInParent(getBoundsForRange(item.start, item.end))
+
+      item.listInfo?.let { info ->
+        setCollectionItemInfo(
+          AccessibilityNodeInfoCompat.CollectionItemInfoCompat.obtain(info.itemNumber - 1, 1, 0, 1, false, false),
+        )
+      }
+
+      val prefix = if (item.listInfo?.depth ?: 0 > 0) "nested " else ""
+      val listText = if (item.listInfo?.isOrdered == true) "list item ${item.listInfo.itemNumber}" else "bullet point"
+
+      when {
+        item.isHeading -> {
+          isHeading = true
+          contentDescription = "${item.text}, heading level ${item.headingLevel}"
+        }
+
+        item.isImage -> {
+          roleDescription = "image"
+        }
+
+        item.isLink -> {
+          isClickable = true
+          addAction(AccessibilityNodeInfoCompat.AccessibilityActionCompat.ACTION_CLICK)
+          roleDescription = item.listInfo?.let { "link, $prefix$listText" } ?: "link"
+        }
+
+        item.isListItem -> {
+          roleDescription = "$prefix$listText"
+        }
+      }
+    }
+  }
+
+  override fun onPerformActionForVirtualView(
+    id: Int,
+    action: Int,
+    args: Bundle?,
+  ): Boolean {
+    val item = accessibilityItems.find { it.id == id } ?: return false
+    if (action == AccessibilityNodeInfoCompat.ACTION_CLICK && item.isLink) {
+      (textView.text as? Spanned)?.getSpans(item.start, item.end, LinkSpan::class.java)?.firstOrNull()?.onClick(textView)
+        ?: return false
+      return true
+    }
+    return false
+  }
+
+  private fun getOffsetForPosition(
+    x: Float,
+    y: Float,
+  ): Int {
+    val layout = textView.layout ?: return 0
+    return layout.getOffsetForHorizontal(layout.getLineForVertical(y.toInt()).coerceIn(0, layout.lineCount - 1), x)
+  }
+
+  private fun getBoundsForRange(
+    start: Int,
+    end: Int,
+  ): Rect {
+    val layout = textView.layout ?: return Rect()
+    val line = layout.getLineForOffset(start)
+    val left = layout.getPrimaryHorizontal(start).toInt() + textView.paddingLeft
+    val right =
+      if (layout.getPrimaryHorizontal(end) <=
+        layout.getPrimaryHorizontal(start)
+      ) {
+        layout.getLineRight(line).toInt() + textView.paddingLeft
+      } else {
+        layout.getPrimaryHorizontal(end).toInt() + textView.paddingLeft
+      }
+    return Rect(
+      left,
+      layout.getLineTop(line) + textView.paddingTop,
+      right,
+      layout.getLineBottom(layout.getLineForOffset(end)) + textView.paddingTop,
+    )
+  }
+}

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

@@ -0,0 +1,23 @@
+package com.swmansion.enriched.markdown.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class LinkLongPressEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val url: String,
+) : Event<LinkLongPressEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap {
+    val eventData: WritableMap = Arguments.createMap()
+    eventData.putString("url", url)
+    return eventData
+  }
+
+  companion object {
+    const val EVENT_NAME: String = "onLinkLongPress"
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/parser/MarkdownASTNode.kt

@@ -15,6 +15,8 @@ data class MarkdownASTNode(
     LineBreak,
     Strong,
     Emphasis,
+    Strikethrough,
+    Underline,
     Code,
     Image,
     Blockquote,

package/android/src/main/java/com/swmansion/enriched/markdown/parser/Parser.kt

@@ -2,6 +2,14 @@ package com.swmansion.enriched.markdown.parser
 
 import android.util.Log
 
+data class Md4cFlags(
+  val underline: Boolean = false,
+) {
+  companion object {
+    val DEFAULT = Md4cFlags()
+  }
+}
+
 class Parser {
   companion object {
     init {
@@ -17,7 +25,10 @@ class Parser {
     }
 
     @JvmStatic
-    private external fun nativeParseMarkdown(markdown: String): MarkdownASTNode?
+    private external fun nativeParseMarkdown(
+      markdown: String,
+      flags: Md4cFlags,
+    ): MarkdownASTNode?
 
     /**
      * Shared parser instance. Parser is stateless and thread-safe, so it can be reused
@@ -26,13 +37,16 @@ class Parser {
     val shared: Parser = Parser()
   }
 
-  fun parseMarkdown(markdown: String): MarkdownASTNode? {
+  fun parseMarkdown(
+    markdown: String,
+    flags: Md4cFlags = Md4cFlags.DEFAULT,
+  ): MarkdownASTNode? {
     if (markdown.isBlank()) {
       return null
     }
 
     try {
-      val ast = nativeParseMarkdown(markdown)
+      val ast = nativeParseMarkdown(markdown, flags)
 
       if (ast != null) {
         return ast