react-native-enriched-markdown-scaffold 0.6.0-scaffold.8 → 0.7.4-scaffold.10

package/android/src/main/java/com/swmansion/enriched/markdown/input/toolbar/InputContextMenu.kt

@@ -14,12 +14,34 @@ import com.swmansion.enriched.markdown.input.formatting.MarkdownSerializer
 import com.swmansion.enriched.markdown.input.model.FormattingRange
 import com.swmansion.enriched.markdown.input.model.StyleType
 
-// TODO: Wrap all user-facing strings for localization support.
+data class InputSelectionMenuConfig(
+  val format: Boolean = true,
+  val formatLabel: String = "",
+  val copyAsMarkdown: Boolean = true,
+  val copyAsMarkdownLabel: String = "",
+)
+
+data class FormatMenuConfig(
+  val bold: Boolean = true,
+  val boldLabel: String = "",
+  val italic: Boolean = true,
+  val italicLabel: String = "",
+  val underline: Boolean = true,
+  val underlineLabel: String = "",
+  val strikethrough: Boolean = true,
+  val strikethroughLabel: String = "",
+  val spoiler: Boolean = true,
+  val spoilerLabel: String = "",
+  val link: Boolean = true,
+  val linkLabel: String = "",
+)
 
 class InputContextMenu(
   private val view: EnrichedMarkdownTextInputView,
 ) {
   private var customItemTexts: List<String> = emptyList()
+  var selectionMenuConfig: InputSelectionMenuConfig = InputSelectionMenuConfig()
+  var formatMenuConfig: FormatMenuConfig = FormatMenuConfig()
 
   fun setContextMenuItems(items: List<String>) {
     customItemTexts = items
@@ -42,13 +64,20 @@ class InputContextMenu(
           menu.removeGroup(FORMAT_MENU_GROUP_ID)
           menu.removeGroup(CUSTOM_MENU_GROUP_ID)
 
-          val formatSubMenu = menu.addSubMenu(FORMAT_MENU_GROUP_ID, MENU_FORMAT_ID, 100, "Format")
-          FORMAT_ITEMS.forEachIndexed { index, (title, _) ->
-            formatSubMenu.add(Menu.NONE, MENU_FORMAT_ITEM_BASE + index, index, title)
+          if (selectionMenuConfig.format) {
+            val formatSubMenu =
+              menu.addSubMenu(FORMAT_MENU_GROUP_ID, MENU_FORMAT_ID, 100, selectionMenuConfig.formatLabel)
+            FORMAT_ITEMS.forEachIndexed { index, (styleType, labelOf) ->
+              if (isFormatItemVisible(styleType)) {
+                formatSubMenu.add(Menu.NONE, MENU_FORMAT_ITEM_BASE + index, index, labelOf(formatMenuConfig))
+              }
+            }
           }
 
           if (view.selectionStart < view.selectionEnd) {
-            menu.add(FORMAT_MENU_GROUP_ID, MENU_COPY_MARKDOWN_ID, 101, "Copy as Markdown")
+            if (selectionMenuConfig.copyAsMarkdown) {
+              menu.add(FORMAT_MENU_GROUP_ID, MENU_COPY_MARKDOWN_ID, 101, selectionMenuConfig.copyAsMarkdownLabel)
+            }
 
             customItemTexts.forEachIndexed { index, text ->
               menu
@@ -74,7 +103,7 @@ class InputContextMenu(
 
           val formatIndex = itemId - MENU_FORMAT_ITEM_BASE
           if (formatIndex in FORMAT_ITEMS.indices) {
-            applyFormat(FORMAT_ITEMS[formatIndex].second)
+            applyFormat(FORMAT_ITEMS[formatIndex].first)
             mode.finish()
             return true
           }
@@ -96,6 +125,16 @@ class InputContextMenu(
       }
   }
 
+  private fun isFormatItemVisible(styleType: StyleType): Boolean =
+    when (styleType) {
+      StyleType.BOLD -> formatMenuConfig.bold
+      StyleType.ITALIC -> formatMenuConfig.italic
+      StyleType.UNDERLINE -> formatMenuConfig.underline
+      StyleType.STRIKETHROUGH -> formatMenuConfig.strikethrough
+      StyleType.SPOILER -> formatMenuConfig.spoiler
+      StyleType.LINK -> formatMenuConfig.link
+    }
+
   private fun applyFormat(styleType: StyleType) {
     val start = view.selectionStart
     val end = view.selectionEnd
@@ -168,14 +207,16 @@ class InputContextMenu(
     private const val CUSTOM_MENU_GROUP_ID = 2000
     private const val MENU_CUSTOM_BASE = 2001
 
-    private val FORMAT_ITEMS =
+    // Order here defines submenu order and the index used by
+    // `MENU_FORMAT_ITEM_BASE + index` when handling clicks.
+    private val FORMAT_ITEMS: List<Pair<StyleType, (FormatMenuConfig) -> String>> =
       listOf(
-        "Bold" to StyleType.BOLD,
-        "Italic" to StyleType.ITALIC,
-        "Underline" to StyleType.UNDERLINE,
-        "Strikethrough" to StyleType.STRIKETHROUGH,
-        "Spoiler" to StyleType.SPOILER,
-        "Link" to StyleType.LINK,
+        StyleType.BOLD to { it.boldLabel },
+        StyleType.ITALIC to { it.italicLabel },
+        StyleType.UNDERLINE to { it.underlineLabel },
+        StyleType.STRIKETHROUGH to { it.strikethroughLabel },
+        StyleType.SPOILER to { it.spoilerLabel },
+        StyleType.LINK to { it.linkLabel },
       )
   }
 }

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

@@ -41,3 +41,20 @@ data class MarkdownASTNode(
 
   fun getAttribute(key: String): String? = attributes[key]
 }
+
+// A node type that md4c emits as a standalone block stacked vertically, as opposed to an inline span.
+internal fun MarkdownASTNode.NodeType.isTopLevelBlock(): Boolean =
+  when (this) {
+    MarkdownASTNode.NodeType.Paragraph,
+    MarkdownASTNode.NodeType.Heading,
+    MarkdownASTNode.NodeType.Blockquote,
+    MarkdownASTNode.NodeType.UnorderedList,
+    MarkdownASTNode.NodeType.OrderedList,
+    MarkdownASTNode.NodeType.CodeBlock,
+    MarkdownASTNode.NodeType.ThematicBreak,
+    MarkdownASTNode.NodeType.Table,
+    MarkdownASTNode.NodeType.LatexMathDisplay,
+    -> true
+
+    else -> false
+  }

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

@@ -40,6 +40,7 @@ class HeadingRenderer(
         HeadingSpan(
           level,
           config.style,
+          factory.styleCache,
         ),
         start,
         end,

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

@@ -52,10 +52,10 @@ class SpanStyleCache(
     val paragraphColor = style.paragraphStyle.color
     return buildList {
       style.strongStyle.color
-        ?.takeIf { it != 0 }
+        ?.takeIf { it != 0 && it != paragraphColor }
         ?.let { add(it) }
       style.emphasisStyle.color
-        ?.takeIf { it != 0 }
+        ?.takeIf { it != 0 && it != paragraphColor }
         ?.let { add(it) }
       style.linkStyle.color
         .takeIf { it != 0 && it != paragraphColor }
@@ -68,10 +68,10 @@ class SpanStyleCache(
       style
         .codeStyle
         .color
-        .takeIf { it != 0 }
+        .takeIf { it != 0 && it != paragraphColor }
         ?.let { add(it) }
       style.taskListStyle.checkedTextColor
-        .takeIf { it != 0 }
+        .takeIf { it != 0 && it != paragraphColor }
         ?.let { add(it) }
     }.toIntArray()
   }

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

@@ -4,11 +4,14 @@ import android.annotation.SuppressLint
 import android.graphics.Typeface
 import android.text.TextPaint
 import android.text.style.MetricAffectingSpan
+import com.swmansion.enriched.markdown.renderer.SpanStyleCache
 import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.utils.text.extensions.applyColorPreserving
 
 class HeadingSpan(
   val level: Int,
   styleConfig: StyleConfig,
+  private val styleCache: SpanStyleCache,
 ) : MetricAffectingSpan() {
   private val fontSize: Float = styleConfig.headingStyles[level]!!.fontSize
   private val color: Int = styleConfig.headingStyles[level]!!.color
@@ -16,7 +19,11 @@ class HeadingSpan(
 
   override fun updateDrawState(tp: TextPaint) {
     applyHeadingStyle(tp)
-    tp.color = color
+    // Inline spans (link, code, strong/em with their own color) are attached to the range
+    // BEFORE this block span, and TextLine replays every CharacterStyle in insertion order,
+    // so an unconditional `tp.color = color` here would repaint them. Same guard used by
+    // BlockquoteSpan, BaseListSpan, CodeBlockSpan, StrongSpan and EmphasisSpan.
+    tp.applyColorPreserving(color, *styleCache.colorsToPreserve)
   }
 
   override fun updateMeasureState(tp: TextPaint) {

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

@@ -1,6 +1,8 @@
 package com.swmansion.enriched.markdown.spans
 
 import android.graphics.Paint
+import android.text.Spanned
+import android.text.style.ReplacementSpan
 import kotlin.math.ceil
 import kotlin.math.floor
 import android.text.style.LineHeightSpan as AndroidLineHeightSpan
@@ -18,10 +20,34 @@ class LineHeightSpan(
     v: Int,
     fm: Paint.FontMetricsInt?,
   ) {
-    if (fm == null) return
+    if (fm == null || lineHeight <= 0) return
 
     val leading = lineHeight - ((-fm.ascent) + fm.descent)
+
+    // A ReplacementSpan on this line — inline math, or the placeholder MeasurementStore
+    // swaps in to measure it off the main thread — reports its own metrics from getSize().
+    // Shrinking those back down to the configured line height cuts the line box below what
+    // the span actually draws, and can drive descent negative so the next line starts above
+    // this one's baseline. Those lines are expanded only, never compressed; every other line
+    // keeps the exact clamp it had before. The lookup only runs on the rare negative-leading
+    // path, so the common case stays allocation-free.
+    if (leading <= 0 && hasSelfMeasuringSpan(text, start, end)) return
+
     fm.ascent -= ceil(leading / 2.0f).toInt()
     fm.descent += floor(leading / 2.0f).toInt()
   }
+
+  /**
+   * Images are excluded on purpose. Block images already keep this span off their range via
+   * `applyLineHeightSkippingImages`, and inline ones never touch the metrics at all, so
+   * letting them through here would change image layout instead of math layout.
+   */
+  private fun hasSelfMeasuringSpan(
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+  ): Boolean {
+    val spanned = text as? Spanned ?: return false
+    return spanned.getSpans(start, end, ReplacementSpan::class.java).any { it !is ImageSpan }
+  }
 }

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

@@ -4,6 +4,8 @@ import com.facebook.react.bridge.ReadableMap
 
 data class InlineMathStyle(
   val color: Int,
+  val paddingVertical: Float,
+  val fontWeight: String,
 ) {
   companion object {
     fun fromReadableMap(
@@ -11,7 +13,9 @@ data class InlineMathStyle(
       parser: StyleParser,
     ): InlineMathStyle {
       val color = parser.parseColor(map, "color")
-      return InlineMathStyle(color)
+      val paddingVertical = parser.toPixelFromDIP(map.getDouble("paddingVertical").toFloat())
+      val fontWeight = parser.parseString(map, "fontWeight", "normal")
+      return InlineMathStyle(color, paddingVertical, fontWeight)
     }
   }
 }

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

@@ -0,0 +1,25 @@
+package com.swmansion.enriched.markdown.styles
+
+/**
+ * Weight a formula can actually be typeset at.
+ *
+ * The style model keeps `fontWeight` as a [String], the way every other
+ * `fontWeight` prop in the codebase does, so a value like `"600"` survives as
+ * far as the renderer. This enum is the narrowing step at that last hop — see
+ * `ratexTypefaceLoader`, the only caller — so adding a third weight is a
+ * compile error at the draw site rather than a value that silently falls back
+ * to regular. Mirrors ENRMMathFontWeight.h on iOS.
+ */
+enum class MathFontWeight {
+  NORMAL,
+  BOLD,
+  ;
+
+  companion object {
+    fun fromString(value: String): MathFontWeight =
+      when (value.lowercase()) {
+        "bold" -> BOLD
+        else -> NORMAL
+      }
+  }
+}

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

@@ -10,6 +10,7 @@ data class MathStyle(
   val marginTop: Float,
   val marginBottom: Float,
   val textAlign: String,
+  val fontWeight: String,
 ) {
   companion object {
     fun fromReadableMap(
@@ -23,7 +24,17 @@ data class MathStyle(
       val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
       val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
       val textAlign = parser.parseString(map, "textAlign", "center")
-      return MathStyle(fontSize, color, backgroundColor, padding, marginTop, marginBottom, textAlign)
+      val fontWeight = parser.parseString(map, "fontWeight", "normal")
+      return MathStyle(
+        fontSize,
+        color,
+        backgroundColor,
+        padding,
+        marginTop,
+        marginBottom,
+        textAlign,
+        fontWeight,
+      )
     }
   }
 }

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

@@ -4,6 +4,7 @@ import android.view.View
 import com.facebook.react.bridge.ReadableArray
 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.LinkLongPressEvent
 import com.swmansion.enriched.markdown.events.LinkPressEvent
@@ -81,11 +82,11 @@ 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),
   )
 
 fun parseContextMenuItems(value: ReadableArray?): List<String> =
@@ -94,7 +95,36 @@ fun parseContextMenuItems(value: ReadableArray?): List<String> =
 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")),
   )
 }
+
+fun parseAccessibilityLabels(value: ReadableMap?): AccessibilityLabels {
+  if (value == null) return AccessibilityLabels()
+  val list = value.getMap("list")
+  val blockquote = value.getMap("blockquote")
+  val table = value.getMap("table")
+  val math = value.getMap("math")
+  val rotor = value.getMap("rotor")
+  return AccessibilityLabels(
+    bulletPoint = list?.getString("bulletPoint") ?: "",
+    nestedBulletPoint = list?.getString("nestedBulletPoint") ?: "",
+    orderedItem = list?.getString("orderedItem") ?: "",
+    nestedOrderedItem = list?.getString("nestedOrderedItem") ?: "",
+    blockquote = blockquote?.getString("quote") ?: "",
+    nestedBlockquote = blockquote?.getString("nestedQuote") ?: "",
+    tableRow = table?.getString("row") ?: "",
+    mathEquation = math?.getString("equation") ?: "",
+    rotorHeadings = rotor?.getString("headings") ?: "",
+    rotorLinks = rotor?.getString("links") ?: "",
+    rotorImages = rotor?.getString("images") ?: "",
+  )
+}
+
+private fun parseStringList(value: ReadableArray?): List<String> = (0 until (value?.size() ?: 0)).mapNotNull { value?.getString(it) }

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

@@ -76,6 +76,8 @@ object MarkdownStyleParser {
       if (mathMap?.hasKey("selectedBackgroundColor") == true) mathMap.getInt("selectedBackgroundColor") else null
     val selectedBorderColor =
       if (mathMap?.hasKey("selectedBorderColor") == true) mathMap.getInt("selectedBorderColor") else null
+    val fontWeight =
+      (if (mathMap?.hasKey("fontWeight") == true) mathMap.getString("fontWeight") else null) ?: "normal"
 
     return MathChipStyle(
       color = color,
@@ -88,6 +90,7 @@ object MarkdownStyleParser {
       paddingVertical = paddingVertical,
       selectedBackgroundColor = nullIfTransparent(selectedBackgroundColor),
       selectedBorderColor = nullIfTransparent(selectedBorderColor),
+      fontWeight = fontWeight,
     )
   }
 
@@ -143,6 +146,12 @@ object MarkdownStyleParser {
       } else {
         inlineFallback.selectedBorderColor
       }
+    val fontWeight =
+      if (mathBlockMap?.hasKey("fontWeight") == true) {
+        mathBlockMap.getString("fontWeight") ?: "normal"
+      } else {
+        inlineFallback.fontWeight
+      }
     val marginTop =
       PixelUtil.toPixelFromDIP(
         if (mathBlockMap?.hasKey("marginTop") == true) mathBlockMap.getDouble("marginTop").toFloat() else 8f,
@@ -170,6 +179,7 @@ object MarkdownStyleParser {
       paddingVertical = paddingVertical,
       selectedBackgroundColor = nullIfTransparent(selectedBackgroundColor),
       selectedBorderColor = nullIfTransparent(selectedBorderColor),
+      fontWeight = fontWeight,
       marginTop = marginTop,
       marginBottom = marginBottom,
       alignment = alignment,

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/extensions/SpannableExtensions.kt

@@ -14,8 +14,16 @@ fun SpannableStringBuilder.isInlineImage(): Boolean {
   return lastChar != '\n' && lastChar != '\u200B'
 }
 
-/** Swaps MathInlineSpans for MathInlinePlaceholderSpans safe for background-thread measurement. */
-fun SpannableString.replaceMathSpansWithPlaceholders(context: Context) {
+/**
+ * Swaps MathInlineSpans for MathInlinePlaceholderSpans safe for background-thread measurement.
+ *
+ * [paddingVertical] must be the same `inlineMath.paddingVertical` (in px) the real spans were
+ * built with, or the measured line box won't match the drawn one.
+ */
+fun SpannableString.replaceMathSpansWithPlaceholders(
+  context: Context,
+  paddingVertical: Float,
+) {
   if (!FeatureFlags.IS_MATH_ENABLED) return
 
   try {
@@ -42,7 +50,7 @@ fun SpannableString.replaceMathSpansWithPlaceholders(context: Context) {
     @Suppress("UNCHECKED_CAST")
     val results = measureMethod.invoke(null, context, requests) as? List<MathMetrics> ?: return
 
-    val placeholderCtor = placeholderClass.getConstructor(MathMetrics::class.java)
+    val placeholderCtor = placeholderClass.getConstructor(MathMetrics::class.java, Float::class.javaPrimitiveType)
 
     mathSpans.forEachIndexed { i, oldSpan ->
       val metrics = results.getOrNull(i) ?: return@forEachIndexed
@@ -53,7 +61,7 @@ fun SpannableString.replaceMathSpansWithPlaceholders(context: Context) {
 
       if (start != -1 && end != -1) {
         removeSpan(oldSpan)
-        val newSpan = placeholderCtor.newInstance(metrics)
+        val newSpan = placeholderCtor.newInstance(metrics, paddingVertical)
         setSpan(newSpan, start, end, flags)
       }
     }

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/view/LinkEvents.kt

@@ -26,18 +26,40 @@ fun View.emitLinkLongPressEvent(url: String) {
 /**
  * Cancels the JS touch for an active link tap, preventing parent
  * Pressable/TouchableOpacity from firing onPress for the same tap.
+ *
+ * Also requests that parent ViewGroups do not intercept subsequent touch
+ * events in this gesture. This is necessary for react-native-gesture-handler's
+ * Pressable, which intercepts at the native ViewGroup level and would otherwise
+ * steal the gesture before ACTION_UP reaches the TextView.
  */
 fun TextView.cancelJSTouchForLinkTap(event: MotionEvent) {
   val currentMovementMethod = movementMethod
   if (currentMovementMethod is LinkLongPressMovementMethod && currentMovementMethod.isLinkTouchActive) {
+    parent?.requestDisallowInterceptTouchEvent(true)
     NativeGestureUtil.notifyNativeGestureStarted(this, event)
   }
 }
 
+/**
+ * Re-allows parent ViewGroups to intercept touch events once the link
+ * touch is no longer active (slop exceeded, gesture ended, or cancelled).
+ * This restores normal scrolling behavior for parent ScrollView/RecyclerView.
+ *
+ * Must be called after [LinkLongPressMovementMethod.onTouchEvent] has
+ * processed the event, since that is where [isLinkTouchActive] is updated.
+ */
+fun TextView.reallowParentInterceptIfLinkReleased() {
+  val currentMovementMethod = movementMethod
+  if (currentMovementMethod is LinkLongPressMovementMethod && !currentMovementMethod.isLinkTouchActive) {
+    parent?.requestDisallowInterceptTouchEvent(false)
+  }
+}
+
 /**
  * Cancels the JS touch unconditionally, preventing parent
  * Pressable/TouchableOpacity from firing onPress for the same gesture.
  */
 fun View.cancelJSTouchForCheckboxTap(event: MotionEvent) {
+  parent?.requestDisallowInterceptTouchEvent(true)
   NativeGestureUtil.notifyNativeGestureStarted(this, event)
 }

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/view/SelectionActionMode.kt

@@ -25,8 +25,30 @@ private const val MENU_ITEM_CUSTOM_GROUP = 2001
 data class SelectionMenuConfig(
   val copyAsMarkdown: Boolean = true,
   val copyImageUrl: Boolean = true,
+  val copyLabel: String = "",
+  val copyAsMarkdownLabel: String = "",
+  val copyImageUrlLabel: String = "",
+  val copyImageUrlsLabel: String = "",
+  // Plural templates indexed by image count (0..100). Empty when no pluralLabels
+  // are set; counts > 100 use copyImageUrlsLabel (the "other" form).
+  val copyImageUrlPluralTemplates: List<String> = emptyList(),
 )
 
+/**
+ * Resolves the "Copy Image URL(s)" menu title for the given image count. Uses the
+ * precomputed plural templates when present (counts > 100 use the "other" form),
+ * otherwise the singular/`{count}` templates. All labels are resolved JS-side.
+ */
+private fun SelectionMenuConfig.imageUrlsTitle(count: Int): String {
+  val template =
+    when {
+      copyImageUrlPluralTemplates.isNotEmpty() && count in 0..100 -> copyImageUrlPluralTemplates[count]
+      count == 1 -> copyImageUrlLabel
+      else -> copyImageUrlsLabel
+    }
+  return template.replace("{count}", count.toString())
+}
+
 /**
  * Creates an ActionMode.Callback that adds custom copy options and
  * overrides the default "Copy" action to include HTML for rich text support.
@@ -56,12 +78,24 @@ fun createSelectionActionModeCallback(
 
       val selectionMenuConfig = getSelectionMenuConfig()
 
+      // The system Copy item is added by the platform; relabel it so it
+      // matches the rest of the localized menu (iOS rebuilds the menu so
+      // gets this for free; Android only intercepts the click).
+      if (selectionMenuConfig.copyLabel.isNotEmpty()) {
+        menu.findItem(android.R.id.copy)?.title = selectionMenuConfig.copyLabel
+      }
+
       if (
         selectionMenuConfig.copyAsMarkdown &&
         textView.selectionStart >= 0 &&
         textView.selectionEnd > textView.selectionStart
       ) {
-        menu.add(Menu.NONE, MENU_ITEM_COPY_MARKDOWN, Menu.NONE, "Copy as Markdown")
+        menu.add(
+          Menu.NONE,
+          MENU_ITEM_COPY_MARKDOWN,
+          Menu.NONE,
+          selectionMenuConfig.copyAsMarkdownLabel,
+        )
       }
 
       if (textView.selectionStart >= 0 && textView.selectionEnd > textView.selectionStart) {
@@ -80,12 +114,7 @@ fun createSelectionActionModeCallback(
           emptyList()
         }
       if (imageUrls.isNotEmpty()) {
-        val title =
-          if (imageUrls.size == 1) {
-            "Copy Image URL"
-          } else {
-            "Copy ${imageUrls.size} Image URLs"
-          }
+        val title = selectionMenuConfig.imageUrlsTitle(imageUrls.size)
         menu.add(Menu.NONE, MENU_ITEM_COPY_IMAGE_URL, Menu.NONE, title)
       }