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

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

@@ -20,7 +20,8 @@ class StyleConfig(
   maxFontSizeMultiplier: Float,
 ) {
   private val styleParser = StyleParser(context, allowFontScaling, maxFontSizeMultiplier)
-  private val assets: AssetManager = context.assets
+  internal val assetManager: AssetManager = context.assets
+  private val assets: AssetManager get() = assetManager
 
   private var paragraphStyleOverride: ParagraphStyle? = null
 
@@ -89,8 +90,12 @@ class StyleConfig(
         val fontWeight = parseFontWeight(headingStyle?.fontWeight)
 
         if (fontFamily != null) {
-          // Use applyStyles with null base typeface to load from assets via ReactFontManager
-          applyStyles(null, ReactConstants.UNSET, fontWeight, fontFamily, assets)
+          // Load the base font at NORMAL so the assets/fonts file resolves, then apply the
+          // weight on the real typeface. Requesting the weight up front makes ReactFontManager
+          // look for a `_bold` asset variant that single-file custom fonts lack and silently
+          // fall back to a default system face. See SpanStyleCache.getTypeface.
+          val base = applyStyles(null, ReactConstants.UNSET, ReactConstants.UNSET, fontFamily, assets)
+          applyStyles(base, ReactConstants.UNSET, fontWeight, null, assets)
         } else {
           null
         }
@@ -161,6 +166,8 @@ class StyleConfig(
     ImageStyle.fromReadableMap(map, styleParser)
   }
 
+  var imageRequestHeaders: Map<String, String> = emptyMap()
+
   val inlineImageStyle: InlineImageStyle by lazy {
     val map =
       requireNotNull(style.getMap("inlineImage")) {
@@ -332,7 +339,8 @@ class StyleConfig(
       spoilerStyle == other.spoilerStyle &&
       superscriptStyle == other.superscriptStyle &&
       subscriptStyle == other.subscriptStyle &&
-      highlightStyle == other.highlightStyle
+      highlightStyle == other.highlightStyle &&
+      imageRequestHeaders == other.imageRequestHeaders
   }
 
   override fun hashCode(): Int {
@@ -359,6 +367,7 @@ class StyleConfig(
     result = 31 * result + superscriptStyle.hashCode()
     result = 31 * result + subscriptStyle.hashCode()
     result = 31 * result + highlightStyle.hashCode()
+    result = 31 * result + imageRequestHeaders.hashCode()
     return result
   }
 }

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

@@ -20,6 +20,8 @@ data class TableStyle(
   val borderRadius: Float,
   val cellPaddingHorizontal: Float,
   val cellPaddingVertical: Float,
+  val horizontalOverflow: Float,
+  val align: String,
 ) : BaseBlockStyle {
   companion object {
     fun fromReadableMap(
@@ -44,6 +46,8 @@ data class TableStyle(
       val borderRadius = parser.toPixelFromDIP(map.getDouble("borderRadius").toFloat())
       val cellPaddingHorizontal = parser.toPixelFromDIP(map.getDouble("cellPaddingHorizontal").toFloat())
       val cellPaddingVertical = parser.toPixelFromDIP(map.getDouble("cellPaddingVertical").toFloat())
+      val horizontalOverflow = parser.toPixelFromDIP(map.getDouble("horizontalOverflow").toFloat())
+      val align = parser.parseString(map, "align")
 
       return TableStyle(
         fontSize = fontSize,
@@ -63,6 +67,8 @@ data class TableStyle(
         borderRadius = borderRadius,
         cellPaddingHorizontal = cellPaddingHorizontal,
         cellPaddingVertical = cellPaddingVertical,
+        horizontalOverflow = horizontalOverflow,
+        align = align,
       )
     }
   }

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

@@ -0,0 +1,90 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import android.text.Spannable
+import android.text.style.ForegroundColorSpan
+import android.util.Log
+import com.swmansion.enriched.markdown.styles.CodeBlockStyle
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+/**
+ * Mirror of HighlightTokenType in cpp/highlight/CodeBlockHighlighter.hpp.
+ * Values cross the JNI boundary as ordinals, the same way
+ * MarkdownASTNode.NodeType does; keep the declaration order in sync.
+ */
+enum class HighlightTokenType {
+  Keyword,
+  Operator,
+  Punctuation,
+  String,
+  Number,
+  Constant,
+  Comment,
+  Function,
+  Type,
+  Variable,
+  Property,
+  Tag,
+  Attribute,
+  Embedded,
+}
+
+/**
+ * Platform adapter over the shared C++ syntax highlighting seam
+ * (core/cpp/highlight/CodeBlockHighlighter.hpp).
+ *
+ * The native call returns semantic tokens as (start, end, type) int triplets
+ * with UTF-16 offsets into the code string, or null when highlighting is
+ * unavailable (module compiled out, unknown language, parse failure). The
+ * adapter applies token colors in place as ForegroundColorSpans onto the
+ * plain styled code, so highlighting can never change text metrics and the
+ * measured block height stays valid. When highlighting is unavailable the
+ * spannable is left untouched and renders as plain text.
+ */
+object CodeBlockHighlighter {
+  init {
+    try {
+      System.loadLibrary("react_codegen_EnrichedMarkdownTextSpec")
+    } catch (e: UnsatisfiedLinkError) {
+      Log.e("CodeBlockHighlighter", "Failed to load native library", e)
+    }
+  }
+
+  private external fun nativeHighlightCode(
+    code: String,
+    language: String,
+  ): IntArray?
+
+  /**
+   * Applies token colors onto [target]. Token offsets are relative to [code];
+   * [offset] is where that code begins in [target] (0 for the github container
+   * view which highlights the code string itself, contentStart for the
+   * commonmark flavor which renders code inline). A no-op when highlighting is
+   * unavailable, so the plain rendering is preserved.
+   */
+  fun highlight(
+    target: Spannable,
+    code: String,
+    language: String?,
+    style: CodeBlockStyle,
+    offset: Int = 0,
+  ) {
+    val tokens =
+      try {
+        nativeHighlightCode(code, language.orEmpty())
+      } catch (e: UnsatisfiedLinkError) {
+        null
+      } ?: return
+
+    val colors = style.syntaxColors
+    var i = 0
+    while (i + 2 < tokens.size) {
+      val start = offset + tokens[i]
+      val end = offset + tokens[i + 1]
+      val type = HighlightTokenType.entries.getOrNull(tokens[i + 2])
+      if (type != null && type.ordinal < colors.size && tokens[i] >= 0 && end > start && end <= target.length) {
+        target.setSpan(ForegroundColorSpan(colors[type.ordinal]), start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+      }
+      i += 3
+    }
+  }
+}

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

@@ -0,0 +1,57 @@
+package com.swmansion.enriched.markdown.utils.common
+
+import android.util.Log
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+
+/**
+ * Shared code block node semantics, used by both markdown flavors so the
+ * meaning of a CodeBlock AST node (its text, language, fence) is defined in
+ * one place. Language display names come from the shared C++ core
+ * (cpp/highlight/CodeBlockLanguages.hpp) so all platforms label fences
+ * identically; when the native library is unavailable the raw fence string
+ * is shown instead.
+ */
+object CodeBlockNode {
+  init {
+    try {
+      System.loadLibrary("react_codegen_EnrichedMarkdownTextSpec")
+    } catch (e: UnsatisfiedLinkError) {
+      Log.e("CodeBlockNode", "Failed to load native library", e)
+    }
+  }
+
+  private external fun nativeDisplayLanguageName(language: String): String?
+
+  fun extractCode(node: MarkdownASTNode): String {
+    val builder = StringBuilder()
+
+    fun append(current: MarkdownASTNode) {
+      builder.append(current.content)
+      current.children.forEach { append(it) }
+    }
+    append(node)
+    return builder.toString().trimEnd('\n')
+  }
+
+  fun language(node: MarkdownASTNode): String? = node.getAttribute("language")?.takeIf { it.isNotEmpty() }
+
+  fun fenceChar(node: MarkdownASTNode): String = node.getAttribute("fenceChar")?.takeIf { it.isNotEmpty() } ?: "`"
+
+  fun fencedMarkdown(
+    code: String,
+    language: String?,
+    fenceChar: String,
+  ): String {
+    val fence = fenceChar.repeat(3)
+    return "$fence${language.orEmpty()}\n$code\n$fence"
+  }
+
+  fun displayLanguageName(language: String?): String {
+    if (language.isNullOrEmpty()) return ""
+    return try {
+      nativeDisplayLanguageName(language)
+    } catch (e: UnsatisfiedLinkError) {
+      null
+    } ?: language
+  }
+}

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

@@ -4,4 +4,5 @@ import com.swmansion.enriched.markdown.BuildConfig
 
 object FeatureFlags {
   const val IS_MATH_ENABLED: Boolean = BuildConfig.ENABLE_MATH
+  const val IS_CODE_HIGHLIGHT_ENABLED: Boolean = BuildConfig.ENABLE_CODE_HIGHLIGHT
 }

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

@@ -15,6 +15,10 @@ sealed interface MarkdownSegment {
     val latex: String,
     val node: MarkdownASTNode,
   ) : MarkdownSegment
+
+  data class CodeBlock(
+    val node: MarkdownASTNode,
+  ) : MarkdownSegment
 }
 
 fun splitASTIntoSegments(root: MarkdownASTNode): List<MarkdownSegment> {
@@ -46,6 +50,11 @@ fun splitASTIntoSegments(root: MarkdownASTNode): List<MarkdownSegment> {
         segments.add(MarkdownSegment.Math(latex, child))
       }
 
+      MarkdownASTNode.NodeType.CodeBlock -> {
+        flushTextNodes()
+        segments.add(MarkdownSegment.CodeBlock(child))
+      }
+
       else -> {
         currentTextNodes.add(child)
       }

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

@@ -6,6 +6,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.UIManagerHelper
 import com.swmansion.enriched.markdown.accessibility.AccessibilityLabels
 import com.swmansion.enriched.markdown.events.ContextMenuItemPressEvent
+import com.swmansion.enriched.markdown.events.CopyPressEvent
 import com.swmansion.enriched.markdown.events.LinkLongPressEvent
 import com.swmansion.enriched.markdown.events.LinkPressEvent
 import com.swmansion.enriched.markdown.events.TaskListItemPressEvent
@@ -19,6 +20,8 @@ fun markdownEventTypeConstants(): MutableMap<String, Any> {
     mapOf("registrationName" to LinkLongPressEvent.EVENT_NAME)
   map[TaskListItemPressEvent.EVENT_NAME] =
     mapOf("registrationName" to TaskListItemPressEvent.EVENT_NAME)
+  map[CopyPressEvent.EVENT_NAME] =
+    mapOf("registrationName" to CopyPressEvent.EVENT_NAME)
   map[ContextMenuItemPressEvent.EVENT_NAME] =
     mapOf("registrationName" to ContextMenuItemPressEvent.EVENT_NAME)
   return map
@@ -58,6 +61,19 @@ fun emitTaskListItemPress(
   )
 }
 
+fun emitCopyPress(
+  view: View,
+  code: String,
+  language: String,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(
+    CopyPressEvent(surfaceId, view.id, code, language),
+  )
+}
+
 fun emitContextMenuItemPress(
   view: View,
   itemText: String,
@@ -82,26 +98,40 @@ fun emitContextMenuItemPress(
 
 fun parseMd4cFlags(flags: ReadableMap?): Md4cFlags =
   Md4cFlags(
-    underline = flags?.getBoolean("underline") ?: false,
-    latexMath = FeatureFlags.IS_MATH_ENABLED && (flags?.getBoolean("latexMath") ?: true),
-    superscript = flags?.getBoolean("superscript") ?: false,
-    subscript = flags?.getBoolean("subscript") ?: false,
-    highlight = flags?.getBoolean("highlight") ?: false,
+    underline = flags.getBooleanOrDefault("underline", false),
+    latexMath = FeatureFlags.IS_MATH_ENABLED && flags.getBooleanOrDefault("latexMath", true),
+    superscript = flags.getBooleanOrDefault("superscript", false),
+    subscript = flags.getBooleanOrDefault("subscript", false),
+    highlight = flags.getBooleanOrDefault("highlight", false),
+    hardSoftBreaks = flags.getBooleanOrDefault("hardSoftBreaks", false),
   )
 
 fun parseContextMenuItems(value: ReadableArray?): List<String> =
   (0 until (value?.size() ?: 0)).mapNotNull { value?.getMap(it)?.getString("text") }
 
+fun parseImageRequestHeaders(value: ReadableArray?): Map<String, String> =
+  (0 until (value?.size() ?: 0))
+    .mapNotNull { index ->
+      val header = value?.getMap(index) ?: return@mapNotNull null
+      val name = header.getString("name") ?: return@mapNotNull null
+      val headerValue = header.getString("value") ?: return@mapNotNull null
+      name to headerValue
+    }.toMap()
+
 fun parseSelectionMenuConfig(value: ReadableMap?): SelectionMenuConfig {
   if (value == null) return SelectionMenuConfig()
   return SelectionMenuConfig(
-    copyAsMarkdown = value.getBoolean("copyAsMarkdown"),
-    copyImageUrl = value.getBoolean("copyImageUrl"),
+    copyAsMarkdown = value.getBooleanOrDefault("copyAsMarkdown", true),
+    copyImageUrl = value.getBooleanOrDefault("copyImageUrl", true),
     copyLabel = value.getString("copyLabel") ?: "",
     copyAsMarkdownLabel = value.getString("copyAsMarkdownLabel") ?: "",
     copyImageUrlLabel = value.getString("copyImageUrlLabel") ?: "",
     copyImageUrlsLabel = value.getString("copyImageUrlsLabel") ?: "",
     copyImageUrlPluralTemplates = parseStringList(value.getArray("copyImageUrlPluralTemplates")),
+    copyEnabled = value.getBooleanOrDefault("copyEnabled", true),
+    copyFormatMarkdown = value.getBooleanOrDefault("copyFormatMarkdown", false),
+    systemItemsNone = value.getBooleanOrDefault("systemItemsNone", false),
+    codeBlockCopyButton = value.getBooleanOrDefault("codeBlockCopyButton", true),
   )
 }
 

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

@@ -1,5 +1,6 @@
 package com.swmansion.enriched.markdown.utils.common
 
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 
 fun ReadableMap?.getBooleanOrDefault(
@@ -18,3 +19,5 @@ fun ReadableMap?.getStringOrDefault(
 ): String = if (this?.hasKey(key) == true) getString(key) ?: default else default
 
 fun ReadableMap?.getMapOrNull(key: String): ReadableMap? = if (this?.hasKey(key) == true) getMap(key) else null
+
+fun ReadableMap?.getArrayOrNull(key: String): ReadableArray? = if (this?.hasKey(key) == true) getArray(key) else null

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

@@ -27,6 +27,11 @@ sealed interface RenderedSegment {
     val latex: String,
     override val signature: Long,
   ) : RenderedSegment
+
+  data class CodeBlock(
+    val node: MarkdownASTNode,
+    override val signature: Long,
+  ) : RenderedSegment
 }
 
 object MarkdownSegmentRenderer {
@@ -53,6 +58,11 @@ object MarkdownSegmentRenderer {
           signature = SegmentSignature.fnvMixString(signature, segment.latex)
           RenderedSegment.Math(segment.latex, signature)
         }
+
+        is MarkdownSegment.CodeBlock -> {
+          val signature = SegmentSignature.signatureForNode(segment.node) xor SegmentSignature.CODE_BLOCK_KIND_SALT
+          RenderedSegment.CodeBlock(segment.node, signature)
+        }
       }
     }
 

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

@@ -11,6 +11,7 @@ object SegmentSignature {
   internal const val TEXT_KIND_SALT = 0x7465787400000000L // "text"
   internal const val TABLE_KIND_SALT = 0x7461626C00000000L // "tabl"
   internal const val MATH_KIND_SALT = 0x6D61746800000000L // "math"
+  internal const val CODE_BLOCK_KIND_SALT = 0x63626C6B00000000L // "cblk"
 
   private fun fnvMixByte(
     hash: Long,

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

@@ -5,23 +5,101 @@ enum class TableStreamingMode {
   PROGRESSIVE,
 }
 
+enum class CodeBlockStreamingMode {
+  HIDDEN,
+  PROGRESSIVE,
+}
+
+/**
+ * Filtered markdown plus whether it ends inside a still-open fenced code block
+ * (the trailing block whose highlighting/copy chrome the renderer defers).
+ */
+data class StreamingFilterResult(
+  val markdown: String,
+  val endsInsideOpenCodeFence: Boolean,
+)
+
 /**
- * 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.
+ * Pre-parse filter that hides incomplete trailing tables, block math and code
+ * blocks while streaming. An open fenced code block is handled first so its
+ * body (which may hold `$$` or `|` lines) is not mistaken for a pending
+ * math/table block: HIDDEN truncates it, PROGRESSIVE keeps it and only filters
+ * the region before it. endsInsideOpenCodeFence flags that trailing open block.
  */
 object StreamingMarkdownFilter {
   fun renderableMarkdownForStreaming(
     markdown: String,
     tableMode: TableStreamingMode = TableStreamingMode.PROGRESSIVE,
-  ): String {
+    codeBlockMode: CodeBlockStreamingMode = CodeBlockStreamingMode.PROGRESSIVE,
+  ): StreamingFilterResult {
     val lines = markdown.split("\n")
+    val openFenceIndex = findOpenCodeFenceLineIndex(lines)
+
+    if (openFenceIndex == -1) {
+      return StreamingFilterResult(removePendingTablesAndMath(markdown, tableMode, lines), false)
+    }
+
+    val fenceOffset = buildLineOffsets(lines)[openFenceIndex]
+    val head = markdown.substring(0, fenceOffset)
+    if (codeBlockMode == CodeBlockStreamingMode.HIDDEN) {
+      return StreamingFilterResult(removePendingTablesAndMath(head, tableMode), false)
+    }
+    val tail = markdown.substring(fenceOffset)
+    return StreamingFilterResult(removePendingTablesAndMath(head, tableMode) + tail, true)
+  }
+
+  private fun removePendingTablesAndMath(
+    markdown: String,
+    tableMode: TableStreamingMode,
+    lines: List<String> = markdown.split("\n"),
+  ): String {
     val afterMath = removePendingStreamingMathBlock(markdown, lines)
     val linesForTable = if (afterMath.length == markdown.length) lines else afterMath.split("\n")
     return removePendingStreamingTableBlock(afterMath, linesForTable, tableMode)
   }
 
+  private class FenceMarker(
+    val char: Char,
+    val length: Int,
+    val info: String,
+  )
+
+  private fun parseFenceMarker(line: String): FenceMarker? {
+    var i = 0
+    while (i < line.length && line[i] == ' ' && i < 3) i++
+    if (i >= line.length) return null
+    val ch = line[i]
+    if (ch != '`' && ch != '~') return null
+    var runLength = 0
+    while (i < line.length && line[i] == ch) {
+      i++
+      runLength++
+    }
+    if (runLength < 3) return null
+    val info = line.substring(i)
+    if (ch == '`' && info.contains('`')) return null
+    return FenceMarker(ch, runLength, info)
+  }
+
+  private fun findOpenCodeFenceLineIndex(lines: List<String>): Int {
+    var openIndex = -1
+    var openChar = ' '
+    var openLength = 0
+    for (i in lines.indices) {
+      val marker = parseFenceMarker(lines[i])
+      if (openIndex == -1) {
+        if (marker != null) {
+          openIndex = i
+          openChar = marker.char
+          openLength = marker.length
+        }
+      } else if (marker != null && marker.char == openChar && marker.length >= openLength && marker.info.isBlank()) {
+        openIndex = -1
+      }
+    }
+    return openIndex
+  }
+
   private fun removePendingStreamingMathBlock(
     markdown: String,
     lines: List<String>,

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

@@ -28,6 +28,10 @@ object MarkdownASTSerializer {
       }
 
       NodeType.LineBreak -> {
+        buffer.append("\\\n")
+      }
+
+      NodeType.SoftBreak -> {
         buffer.append("\n")
       }