react-native-enriched-markdown 0.1.0 → 0.2.0

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/events/LinkPressEvent.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 LinkPressEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val url: String,
+) : Event<LinkPressEvent>(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 = "onLinkPress"
+  }
+}

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

@@ -0,0 +1,31 @@
+package com.swmansion.enriched.markdown.parser
+
+data class MarkdownASTNode(
+  val type: NodeType,
+  val content: String = "",
+  val attributes: Map<String, String> = emptyMap(),
+  val children: List<MarkdownASTNode> = emptyList(),
+) {
+  enum class NodeType {
+    Document,
+    Paragraph,
+    Text,
+    Link,
+    Heading,
+    LineBreak,
+    Strong,
+    Emphasis,
+    Strikethrough,
+    Underline,
+    Code,
+    Image,
+    Blockquote,
+    UnorderedList,
+    OrderedList,
+    ListItem,
+    CodeBlock,
+    ThematicBreak,
+  }
+
+  fun getAttribute(key: String): String? = attributes[key]
+}

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

@@ -0,0 +1,62 @@
+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 {
+      try {
+        // Library name must follow react_codegen_<ComponentName> convention
+        // required by React Native Fabric's CMake build system.
+        // md4c parser is bundled in the same shared library to avoid
+        // multiple library loading and complex linking dependencies.
+        System.loadLibrary("react_codegen_EnrichedMarkdownTextSpec")
+      } catch (e: UnsatisfiedLinkError) {
+        Log.e("MarkdownParser", "Failed to load native library", e)
+      }
+    }
+
+    @JvmStatic
+    private external fun nativeParseMarkdown(
+      markdown: String,
+      flags: Md4cFlags,
+    ): MarkdownASTNode?
+
+    /**
+     * Shared parser instance. Parser is stateless and thread-safe, so it can be reused
+     * across all EnrichedMarkdownText instances to avoid unnecessary allocations.
+     */
+    val shared: Parser = Parser()
+  }
+
+  fun parseMarkdown(
+    markdown: String,
+    flags: Md4cFlags = Md4cFlags.DEFAULT,
+  ): MarkdownASTNode? {
+    if (markdown.isBlank()) {
+      return null
+    }
+
+    try {
+      val ast = nativeParseMarkdown(markdown, flags)
+
+      if (ast != null) {
+        return ast
+      } else {
+        Log.w("MarkdownParser", "Native parser returned null")
+        return null
+      }
+    } catch (e: Exception) {
+      Log.e("MarkdownParser", "MD4C parsing failed: ${e.message}", e)
+      return null
+    }
+  }
+}

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

@@ -0,0 +1,166 @@
+package com.swmansion.enriched.markdown.renderer
+
+import com.swmansion.enriched.markdown.styles.BaseBlockStyle
+import com.swmansion.enriched.markdown.styles.BlockquoteStyle
+import com.swmansion.enriched.markdown.styles.CodeBlockStyle
+import com.swmansion.enriched.markdown.styles.HeadingStyle
+import com.swmansion.enriched.markdown.styles.ListStyle
+import com.swmansion.enriched.markdown.styles.ParagraphStyle
+
+enum class BlockType {
+  NONE,
+  PARAGRAPH,
+  HEADING,
+  BLOCKQUOTE,
+  UNORDERED_LIST,
+  ORDERED_LIST,
+  CODE_BLOCK,
+}
+
+data class BlockStyle(
+  val fontSize: Float,
+  val fontFamily: String,
+  val fontWeight: String,
+  val color: Int,
+)
+
+private class MutableBlockStyle {
+  var fontSize: Float = 0f
+  var fontFamily: String = ""
+  var fontWeight: String = ""
+  var color: Int = 0
+  var isDirty: Boolean = false
+
+  fun updateFrom(style: BaseBlockStyle) {
+    fontSize = style.fontSize
+    fontFamily = style.fontFamily
+    fontWeight = style.fontWeight
+    color = style.color
+    isDirty = true
+  }
+
+  fun toImmutable(): BlockStyle = BlockStyle(fontSize, fontFamily, fontWeight, color)
+
+  fun clear() {
+    isDirty = false
+  }
+}
+
+class BlockStyleContext {
+  var currentBlockType = BlockType.NONE
+    private set
+
+  private val mutableBlockStyle = MutableBlockStyle()
+  private var cachedBlockStyle: BlockStyle? = null
+  private var currentHeadingLevel = 0
+
+  var blockquoteDepth = 0
+  var listDepth = 0
+  var listType: ListType? = null
+  var listItemNumber = 0
+
+  // Optimization: ArrayDeque is more efficient for stack operations than MutableList
+  private val orderedListItemNumbers = ArrayDeque<Int>()
+
+  enum class ListType { UNORDERED, ORDERED }
+
+  private fun updateBlockStyle(
+    type: BlockType,
+    style: BaseBlockStyle,
+    headingLevel: Int = 0,
+  ) {
+    currentBlockType = type
+    currentHeadingLevel = headingLevel
+    // Update mutable style in place - no allocation here
+    mutableBlockStyle.updateFrom(style)
+    // Invalidate cached immutable copy
+    cachedBlockStyle = null
+  }
+
+  // Unified Setters
+  fun setParagraphStyle(style: ParagraphStyle) = updateBlockStyle(BlockType.PARAGRAPH, style)
+
+  fun setHeadingStyle(
+    style: HeadingStyle,
+    level: Int,
+  ) = updateBlockStyle(BlockType.HEADING, style, level)
+
+  fun setBlockquoteStyle(style: BlockquoteStyle) = updateBlockStyle(BlockType.BLOCKQUOTE, style)
+
+  fun setUnorderedListStyle(style: ListStyle) {
+    listType = ListType.UNORDERED
+    updateBlockStyle(BlockType.UNORDERED_LIST, style)
+  }
+
+  fun setOrderedListStyle(style: ListStyle) {
+    listType = ListType.ORDERED
+    updateBlockStyle(BlockType.ORDERED_LIST, style)
+  }
+
+  fun setCodeBlockStyle(style: CodeBlockStyle) = updateBlockStyle(BlockType.CODE_BLOCK, style)
+
+  // List State Management
+  fun isInsideBlockElement(): Boolean = blockquoteDepth > 0 || listDepth > 0
+
+  fun incrementListItemNumber() {
+    listItemNumber++
+  }
+
+  fun resetListItemNumber() {
+    listItemNumber = 0
+  }
+
+  // Using ArrayDeque methods for clarity: addLast/removeLast
+  fun pushOrderedListItemNumber() {
+    orderedListItemNumbers.addLast(listItemNumber)
+  }
+
+  fun popOrderedListItemNumber() {
+    if (orderedListItemNumbers.isNotEmpty()) {
+      listItemNumber = orderedListItemNumbers.removeLast()
+    }
+  }
+
+  fun clearListStyle() {
+    // Only trigger full reset when we have completely exited all nested lists
+    if (listDepth == 0) {
+      reset()
+    }
+  }
+
+  private fun reset() {
+    clearBlockStyle()
+    listType = null
+    listItemNumber = 0
+    orderedListItemNumbers.clear()
+  }
+
+  fun requireBlockStyle(): BlockStyle {
+    if (!mutableBlockStyle.isDirty) {
+      throw IllegalStateException(
+        "BlockStyle is null. Inline renderers must be used within a block context.",
+      )
+    }
+    // Create immutable copy only when needed, cache for reuse within same block
+    return cachedBlockStyle ?: mutableBlockStyle.toImmutable().also { cachedBlockStyle = it }
+  }
+
+  fun clearBlockStyle() {
+    currentBlockType = BlockType.NONE
+    mutableBlockStyle.clear()
+    cachedBlockStyle = null
+    currentHeadingLevel = 0
+  }
+
+  fun resetForNewRender() {
+    currentBlockType = BlockType.NONE
+    mutableBlockStyle.clear()
+    cachedBlockStyle = null
+    currentHeadingLevel = 0
+    blockquoteDepth = 0
+    listDepth = 0
+    listType = null
+    listItemNumber = 0
+    orderedListItemNumbers.clear()
+  }
+}

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

@@ -0,0 +1,84 @@
+package com.swmansion.enriched.markdown.renderer
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.spans.BlockquoteSpan
+import com.swmansion.enriched.markdown.utils.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.applyMarginBottom
+import com.swmansion.enriched.markdown.utils.applyMarginTop
+import com.swmansion.enriched.markdown.utils.createLineHeightSpan
+
+class BlockquoteRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  override fun render(
+    node: MarkdownASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val start = builder.length
+    val style = config.style.blockquoteStyle
+    val context = factory.blockStyleContext
+    val depth = context.blockquoteDepth
+
+    // Track depth to handle nested indentation levels
+    context.blockquoteDepth = depth + 1
+    context.setBlockquoteStyle(style)
+
+    try {
+      factory.renderChildren(node, builder, onLinkPress, onLinkLongPress)
+    } finally {
+      context.clearBlockStyle()
+      context.blockquoteDepth = depth
+    }
+
+    if (builder.length == start) return
+    val end = builder.length
+
+    // Find immediately nested quotes to exclude them from this level's line-height/margins
+    val nestedRanges =
+      builder
+        .getSpans(start, end, BlockquoteSpan::class.java)
+        .filter { it.depth == depth + 1 }
+        .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+        .sortedBy { it.first }
+
+    // The Accent Bar Span covers the full range for visual continuity
+    builder.setSpan(
+      BlockquoteSpan(style, depth, factory.context, factory.styleCache),
+      start,
+      end,
+      SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+    )
+
+    // Apply styling only to segments that are NOT nested quotes
+    applySpansExcludingNested(builder, nestedRanges, start, end, createLineHeightSpan(style.lineHeight))
+
+    // Margins are only applied by the outermost (root) quote
+    if (depth == 0) {
+      applyMarginTop(builder, start, style.marginTop)
+      applyMarginBottom(builder, style.marginBottom)
+    }
+  }
+
+  private fun applySpansExcludingNested(
+    builder: SpannableStringBuilder,
+    nestedRanges: List<Pair<Int, Int>>,
+    start: Int,
+    end: Int,
+    span: Any,
+  ) {
+    var currentPos = start
+    for ((nestedStart, nestedEnd) in nestedRanges) {
+      if (currentPos < nestedStart) {
+        builder.setSpan(span, currentPos, nestedStart, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+      }
+      currentPos = nestedEnd
+    }
+    if (currentPos < end) {
+      builder.setSpan(span, currentPos, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+    }
+  }
+}