react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/SegmentReconciler.kt

@@ -0,0 +1,118 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import android.view.View
+
+data class ReconciliationResult(
+  val views: List<View>,
+  val signatures: List<Long>,
+  val viewsToRemove: List<View>,
+  val viewsToAttach: List<View>,
+)
+
+object SegmentReconciler {
+  fun reconcile(
+    currentViews: List<View>,
+    currentSignatures: List<Long>,
+    renderedSegments: List<RenderedSegment>,
+    reset: Boolean,
+    matchesKind: (View, RenderedSegment) -> Boolean,
+    createView: (RenderedSegment) -> View,
+    updateView: (View, RenderedSegment) -> Unit,
+  ): ReconciliationResult {
+    val resetRemovals = if (reset) currentViews else emptyList()
+    val sourceViews = if (reset) emptyList() else currentViews
+    val sourceSignatures = if (reset) emptyList() else currentSignatures
+
+    val signatureToIndices = HashMap<Long, ArrayDeque<Int>>(sourceSignatures.size)
+    for ((index, signature) in sourceSignatures.withIndex()) {
+      signatureToIndices.getOrPut(signature) { ArrayDeque() }.addLast(index)
+    }
+
+    val remainingNextSignatureCounts = HashMap<Long, Int>(renderedSegments.size)
+    for (segment in renderedSegments) {
+      val signature = segment.signature
+      remainingNextSignatureCounts[signature] = (remainingNextSignatureCounts[signature] ?: 0) + 1
+    }
+
+    val nextViews = ArrayList<View>(renderedSegments.size)
+    val nextSignatures = ArrayList<Long>(renderedSegments.size)
+    val reusedViews = HashSet<View>(sourceViews.size)
+    val viewsToAttach = mutableListOf<View>()
+
+    for ((index, segment) in renderedSegments.withIndex()) {
+      val existingView = sourceViews.getOrNull(index)
+      val existingSignature = sourceSignatures.getOrNull(index)
+      val nextSignature = segment.signature
+
+      val remaining = remainingNextSignatureCounts.getOrDefault(nextSignature, 0)
+      if (remaining > 1) {
+        remainingNextSignatureCounts[nextSignature] = remaining - 1
+      } else {
+        remainingNextSignatureCounts.remove(nextSignature)
+      }
+
+      var view: View? = null
+
+      // 1. Exact positional match: same index, same kind, same signature.
+      if (existingView != null &&
+        existingView !in reusedViews &&
+        matchesKind(existingView, segment) &&
+        existingSignature == nextSignature
+      ) {
+        view = existingView
+      }
+
+      // 2. Signature-based fallback: find an unused view with exact same signature.
+      if (view == null) {
+        val candidateIndices = signatureToIndices[nextSignature]
+        if (candidateIndices != null) {
+          while (candidateIndices.isNotEmpty()) {
+            val candidateIdx = candidateIndices.removeFirst()
+            val candidate = sourceViews[candidateIdx]
+            if (candidate !in reusedViews && matchesKind(candidate, segment)) {
+              view = candidate
+              break
+            }
+          }
+        }
+      }
+
+      // 3. Same-kind positional update. If the old signature appears later in
+      // the new list, leave the view available for that exact reuse instead.
+      if (view == null &&
+        existingView != null &&
+        existingView !in reusedViews &&
+        matchesKind(existingView, segment) &&
+        (existingSignature == null || (remainingNextSignatureCounts[existingSignature] ?: 0) == 0)
+      ) {
+        updateView(existingView, segment)
+        view = existingView
+      }
+
+      // 4. No reusable view found — create a new one.
+      if (view == null) {
+        view = createView(segment)
+        viewsToAttach.add(view)
+      }
+
+      nextViews.add(view)
+      nextSignatures.add(nextSignature)
+      reusedViews.add(view)
+    }
+
+    val viewsToRemove = ArrayList<View>(resetRemovals.size + sourceViews.size)
+    viewsToRemove.addAll(resetRemovals)
+    for (view in sourceViews) {
+      if (view !in reusedViews) {
+        viewsToRemove.add(view)
+      }
+    }
+
+    return ReconciliationResult(
+      views = nextViews,
+      signatures = nextSignatures,
+      viewsToRemove = viewsToRemove,
+      viewsToAttach = viewsToAttach,
+    )
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/SegmentSignature.kt

@@ -0,0 +1,78 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+
+/** FNV-1a 64-bit hashing. Constants match the iOS implementation for cross-platform parity. */
+object SegmentSignature {
+  // FNV-1a 64-bit constants (same as iOS)
+  private const val FNV_OFFSET_BASIS = -3750763034362895579L // 14695981039346656037 as signed Long
+  private const val FNV_PRIME = 1099511628211L
+
+  internal const val TEXT_KIND_SALT = 0x7465787400000000L // "text"
+  internal const val TABLE_KIND_SALT = 0x7461626C00000000L // "tabl"
+  internal const val MATH_KIND_SALT = 0x6D61746800000000L // "math"
+
+  private fun fnvMixByte(
+    hash: Long,
+    byte: Byte,
+  ): Long {
+    var result = hash xor (byte.toLong() and 0xFF)
+    result *= FNV_PRIME
+    return result
+  }
+
+  private fun fnvMixLong(
+    hash: Long,
+    value: Long,
+  ): Long {
+    var result = hash
+    var remaining = value
+    for (i in 0 until 8) {
+      result = fnvMixByte(result, (remaining and 0xFF).toByte())
+      remaining = remaining ushr 8
+    }
+    return result
+  }
+
+  internal fun fnvMixString(
+    hash: Long,
+    string: String?,
+  ): Long {
+    if (string == null) return hash
+    var result = hash
+    val bytes = string.toByteArray(Charsets.UTF_8)
+    for (byte in bytes) {
+      result = fnvMixByte(result, byte)
+    }
+    return result
+  }
+
+  fun signatureForNode(node: MarkdownASTNode?): Long {
+    if (node == null) return FNV_OFFSET_BASIS
+
+    var hash = FNV_OFFSET_BASIS
+    hash = fnvMixLong(hash, node.type.ordinal.toLong())
+    hash = fnvMixString(hash, node.content)
+
+    if (node.attributes.isNotEmpty()) {
+      for (key in node.attributes.keys.sorted()) {
+        hash = fnvMixString(hash, key)
+        hash = fnvMixString(hash, node.attributes[key])
+      }
+    }
+
+    for (child in node.children) {
+      hash = fnvMixLong(hash, signatureForNode(child))
+    }
+
+    return hash
+  }
+
+  fun signatureForNodes(nodes: List<MarkdownASTNode>): Long {
+    var hash = FNV_OFFSET_BASIS
+    for (node in nodes) {
+      hash = fnvMixLong(hash, signatureForNode(node))
+    }
+    return hash
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/StreamingMarkdownFilter.kt

@@ -0,0 +1,142 @@
+package com.swmansion.enriched.markdown.utils.common
+
+enum class TableStreamingMode {
+  HIDDEN,
+  PROGRESSIVE,
+}
+
+/**
+ * Pre-parse filter that hides incomplete trailing tables and block math
+ * during streaming. A table is considered complete only after a blank
+ * separator line follows it; a block math (`$$`) is complete only when
+ * a closing `$$` exists.
+ */
+object StreamingMarkdownFilter {
+  fun renderableMarkdownForStreaming(
+    markdown: String,
+    tableMode: TableStreamingMode = TableStreamingMode.PROGRESSIVE,
+  ): String {
+    val lines = markdown.split("\n")
+    val afterMath = removePendingStreamingMathBlock(markdown, lines)
+    val linesForTable = if (afterMath.length == markdown.length) lines else afterMath.split("\n")
+    return removePendingStreamingTableBlock(afterMath, linesForTable, tableMode)
+  }
+
+  private fun removePendingStreamingMathBlock(
+    markdown: String,
+    lines: List<String>,
+  ): String {
+    var lastUnclosedDelimiterIndex = -1
+
+    for (i in lines.indices) {
+      if (lineIsBlockMathDelimiter(lines[i])) {
+        lastUnclosedDelimiterIndex = if (lastUnclosedDelimiterIndex == -1) i else -1
+      }
+    }
+
+    if (lastUnclosedDelimiterIndex == -1) return markdown
+
+    val offsets = buildLineOffsets(lines)
+    return markdown.substring(0, offsets[lastUnclosedDelimiterIndex])
+  }
+
+  private fun removePendingStreamingTableBlock(
+    markdown: String,
+    lines: List<String>,
+    tableMode: TableStreamingMode,
+  ): String {
+    var lastNonBlankLineIndex = -1
+
+    for (i in lines.indices.reversed()) {
+      if (!lineIsBlank(lines[i])) {
+        lastNonBlankLineIndex = i
+        break
+      }
+    }
+
+    if (lastNonBlankLineIndex == -1) return markdown
+
+    if (lastNonBlankLineIndex + 1 < lines.size - 1) return markdown
+
+    var blockStartIndex = lastNonBlankLineIndex
+    while (blockStartIndex > 0 && !lineIsBlank(lines[blockStartIndex - 1])) {
+      blockStartIndex--
+    }
+
+    var blockLooksLikeTable = false
+    for (i in blockStartIndex..lastNonBlankLineIndex) {
+      if (!lineLooksLikeTableRow(lines[i])) return markdown
+      blockLooksLikeTable = true
+    }
+
+    if (!blockLooksLikeTable) return markdown
+
+    val offsets = buildLineOffsets(lines)
+
+    if (tableMode == TableStreamingMode.PROGRESSIVE) {
+      val tableLineCount = lastNonBlankLineIndex - blockStartIndex + 1
+
+      if (tableLineCount < 2 || !lineLooksLikeTableSeparator(lines[blockStartIndex + 1])) {
+        return markdown.substring(0, offsets[blockStartIndex])
+      }
+
+      if (tableLineCount > 2) {
+        val lastRow = lines[lastNonBlankLineIndex]
+        val lastRowTrimmed = lastRow.trim()
+        val headerRow = lines[blockStartIndex]
+        if (!lastRowTrimmed.endsWith("|") || pipeCount(lastRow) < pipeCount(headerRow)) {
+          return markdown.substring(0, offsets[lastNonBlankLineIndex])
+        }
+      }
+
+      return markdown
+    }
+
+    return markdown.substring(0, offsets[blockStartIndex])
+  }
+
+  private fun lineIsBlank(line: String): Boolean = line.isBlank()
+
+  private fun lineIsBlockMathDelimiter(line: String): Boolean = line.trim() == "$$"
+
+  private fun lineLooksLikeTableRow(line: String): Boolean {
+    val trimmed = line.trim()
+    return trimmed.startsWith("|")
+  }
+
+  private fun lineLooksLikeTableSeparator(line: String): Boolean {
+    val trimmed = line.trim()
+    if (trimmed.isEmpty()) return false
+    if (trimmed[0] != '|') return false
+    var hasTripleDash = false
+    var dashRun = 0
+    for (ch in trimmed) {
+      if (ch == '-') {
+        dashRun++
+        if (dashRun >= 3) hasTripleDash = true
+      } else {
+        dashRun = 0
+        if (ch != '|' && ch != ':' && ch != ' ') return false
+      }
+    }
+    return hasTripleDash
+  }
+
+  private fun pipeCount(line: String): Int {
+    var count = 0
+    for (ch in line) {
+      if (ch == '|') count++
+    }
+    return count
+  }
+
+  private fun buildLineOffsets(lines: List<String>): IntArray {
+    val offsets = IntArray(lines.size)
+    var currentOffset = 0
+    for (i in lines.indices) {
+      offsets[i] = currentOffset
+      currentOffset += lines[i].length + 1
+    }
+    return offsets
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/layout/RTLUtils.kt

@@ -0,0 +1,6 @@
+package com.swmansion.enriched.markdown.utils.common.layout
+
+import android.content.res.Resources
+import android.view.View
+
+fun Resources.isLayoutRTL(): Boolean = configuration.layoutDirection == View.LAYOUT_DIRECTION_RTL

package/android/src/main/java/com/swmansion/enriched/markdown/utils/common/serialization/MarkdownASTSerializer.kt

@@ -0,0 +1,115 @@
+package com.swmansion.enriched.markdown.utils.common.serialization
+
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode.NodeType
+
+object MarkdownASTSerializer {
+  fun serializeNode(node: MarkdownASTNode): String {
+    val buffer = StringBuilder()
+    appendNode(node, buffer)
+    return buffer.toString()
+  }
+
+  fun serializeChildren(node: MarkdownASTNode): String {
+    val buffer = StringBuilder()
+    for (child in node.children) {
+      appendNode(child, buffer)
+    }
+    return buffer.toString()
+  }
+
+  private fun appendNode(
+    node: MarkdownASTNode,
+    buffer: StringBuilder,
+  ) {
+    when (node.type) {
+      NodeType.Text -> {
+        buffer.append(node.content)
+      }
+
+      NodeType.LineBreak -> {
+        buffer.append("\n")
+      }
+
+      NodeType.Strong -> {
+        buffer.append("**")
+        appendChildren(node, buffer)
+        buffer.append("**")
+      }
+
+      NodeType.Emphasis -> {
+        buffer.append("*")
+        appendChildren(node, buffer)
+        buffer.append("*")
+      }
+
+      NodeType.Strikethrough -> {
+        buffer.append("~~")
+        appendChildren(node, buffer)
+        buffer.append("~~")
+      }
+
+      NodeType.Underline -> {
+        buffer.append("__")
+        appendChildren(node, buffer)
+        buffer.append("__")
+      }
+
+      NodeType.Superscript -> {
+        buffer.append("^")
+        appendChildren(node, buffer)
+        buffer.append("^")
+      }
+
+      NodeType.Subscript -> {
+        buffer.append("~")
+        appendChildren(node, buffer)
+        buffer.append("~")
+      }
+
+      NodeType.Highlight -> {
+        buffer.append("==")
+        appendChildren(node, buffer)
+        buffer.append("==")
+      }
+
+      NodeType.Code -> {
+        buffer.append("`")
+        appendChildren(node, buffer)
+        buffer.append("`")
+      }
+
+      NodeType.Link -> {
+        val url = node.getAttribute("url") ?: ""
+        buffer.append("[")
+        appendChildren(node, buffer)
+        buffer.append("](")
+        buffer.append(url)
+        buffer.append(")")
+      }
+
+      NodeType.Image -> {
+        val alt = node.getAttribute("alt") ?: ""
+        val url = node.getAttribute("url") ?: ""
+        buffer.append("![")
+        buffer.append(alt)
+        buffer.append("](")
+        buffer.append(url)
+        buffer.append(")")
+      }
+
+      else -> {
+        appendChildren(node, buffer)
+      }
+    }
+  }
+
+  private fun appendChildren(
+    node: MarkdownASTNode,
+    buffer: StringBuilder,
+  ) {
+    for (child in node.children) {
+      appendNode(child, buffer)
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+package com.swmansion.enriched.markdown.utils.input
+
+import android.text.InputType
+import android.widget.EditText
+
+object AutoCapitalizeUtils {
+  fun apply(
+    editText: EditText,
+    flagName: String?,
+  ) {
+    val flag =
+      when (flagName) {
+        "none" -> InputType.TYPE_NULL
+        "sentences" -> InputType.TYPE_TEXT_FLAG_CAP_SENTENCES
+        "words" -> InputType.TYPE_TEXT_FLAG_CAP_WORDS
+        "characters" -> InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS
+        else -> InputType.TYPE_NULL
+      }
+
+    editText.inputType = (
+      editText.inputType and
+        InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS.inv() and
+        InputType.TYPE_TEXT_FLAG_CAP_WORDS.inv() and
+        InputType.TYPE_TEXT_FLAG_CAP_SENTENCES.inv()
+    ) or if (flag == InputType.TYPE_NULL) 0 else flag
+  }
+}

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

@@ -0,0 +1,77 @@
+package com.swmansion.enriched.markdown.utils.input
+
+import android.view.View
+import com.facebook.react.uimanager.BackgroundStyleApplicator
+import com.facebook.react.uimanager.LengthPercentage
+import com.facebook.react.uimanager.LengthPercentageType
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.ViewProps
+import com.facebook.react.uimanager.style.BorderRadiusProp
+import com.facebook.react.uimanager.style.BorderStyle
+import com.facebook.react.uimanager.style.LogicalEdge
+
+object BorderPropsApplicator {
+  private val RADIUS_PROPS =
+    mapOf(
+      ViewProps.BORDER_RADIUS to BorderRadiusProp.BORDER_RADIUS,
+      ViewProps.BORDER_TOP_LEFT_RADIUS to BorderRadiusProp.BORDER_TOP_LEFT_RADIUS,
+      ViewProps.BORDER_TOP_RIGHT_RADIUS to BorderRadiusProp.BORDER_TOP_RIGHT_RADIUS,
+      ViewProps.BORDER_BOTTOM_RIGHT_RADIUS to BorderRadiusProp.BORDER_BOTTOM_RIGHT_RADIUS,
+      ViewProps.BORDER_BOTTOM_LEFT_RADIUS to BorderRadiusProp.BORDER_BOTTOM_LEFT_RADIUS,
+    )
+
+  private val WIDTH_PROPS =
+    mapOf(
+      ViewProps.BORDER_WIDTH to LogicalEdge.ALL,
+      ViewProps.BORDER_LEFT_WIDTH to LogicalEdge.LEFT,
+      ViewProps.BORDER_RIGHT_WIDTH to LogicalEdge.RIGHT,
+      ViewProps.BORDER_TOP_WIDTH to LogicalEdge.TOP,
+      ViewProps.BORDER_BOTTOM_WIDTH to LogicalEdge.BOTTOM,
+    )
+
+  private val COLOR_PROPS =
+    mapOf(
+      "borderColor" to LogicalEdge.ALL,
+      "borderLeftColor" to LogicalEdge.LEFT,
+      "borderRightColor" to LogicalEdge.RIGHT,
+      "borderTopColor" to LogicalEdge.TOP,
+      "borderBottomColor" to LogicalEdge.BOTTOM,
+    )
+
+  fun apply(
+    view: View,
+    props: ReactStylesDiffMap,
+  ) {
+    for ((propName, radiusProp) in RADIUS_PROPS) {
+      if (props.hasKey(propName)) {
+        val value = props.getFloat(propName, Float.NaN)
+        val radius = if (value.isNaN()) null else LengthPercentage(value, LengthPercentageType.POINT)
+        BackgroundStyleApplicator.setBorderRadius(view, radiusProp, radius)
+      }
+    }
+
+    for ((propName, edge) in WIDTH_PROPS) {
+      if (props.hasKey(propName)) {
+        val value = props.getFloat(propName, Float.NaN)
+        BackgroundStyleApplicator.setBorderWidth(view, edge, value)
+      }
+    }
+
+    for ((propName, edge) in COLOR_PROPS) {
+      if (props.hasKey(propName)) {
+        if (props.isNull(propName)) {
+          BackgroundStyleApplicator.setBorderColor(view, edge, null)
+        } else {
+          val color = props.getInt(propName, 0)
+          BackgroundStyleApplicator.setBorderColor(view, edge, color)
+        }
+      }
+    }
+
+    if (props.hasKey("borderStyle")) {
+      val styleStr = props.getString("borderStyle")
+      val parsed = styleStr?.let { BorderStyle.fromString(it) }
+      BackgroundStyleApplicator.setBorderStyle(view, parsed)
+    }
+  }
+}