@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.10

package/android/src/main/java/com/renderrichtext/styles/StyleParser.kt

@@ -0,0 +1,92 @@
+package com.renderrichtext.styles
+
+import android.content.Context
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.PixelUtil
+
+class StyleParser(
+  private val context: Context,
+  private val allowFontScaling: Boolean,
+  private val maxFontSizeMultiplier: Float,
+) {
+  fun parseOptionalColor(
+    map: ReadableMap,
+    key: String,
+  ): Int? {
+    if (!map.hasKey(key) || map.isNull(key)) {
+      return null
+    }
+    val colorValue = map.getDouble(key)
+    return ColorPropConverter.getColor(colorValue, context)
+  }
+
+  fun parseColor(
+    map: ReadableMap,
+    key: String,
+  ): Int =
+    parseOptionalColor(map, key)
+      ?: throw IllegalArgumentException("Color key '$key' is missing, null, or invalid")
+
+  fun parseOptionalDouble(
+    map: ReadableMap,
+    key: String,
+    default: Double = 0.0,
+  ): Double =
+    if (map.hasKey(key) && !map.isNull(key)) {
+      map.getDouble(key)
+    } else {
+      default
+    }
+
+  fun parseOptionalInt(
+    map: ReadableMap,
+    key: String,
+    default: Int = 0,
+  ): Int =
+    if (map.hasKey(key) && !map.isNull(key)) {
+      map.getInt(key)
+    } else {
+      default
+    }
+
+  fun parseString(
+    map: ReadableMap,
+    key: String,
+    default: String = "",
+  ): String = map.getString(key) ?: default
+
+  fun parseBoolean(
+    map: ReadableMap,
+    key: String,
+    default: Boolean = false,
+  ): Boolean =
+    if (map.hasKey(key) && !map.isNull(key)) {
+      map.getBoolean(key)
+    } else {
+      default
+    }
+
+  fun toPixelFromSP(value: Float): Float {
+    val metrics = context.resources.displayMetrics
+    val baseDensity = metrics.density
+
+    if (!allowFontScaling) {
+      return value * baseDensity
+    }
+
+    var fontScale = metrics.scaledDensity / baseDensity
+    if (maxFontSizeMultiplier >= 1.0f && fontScale > maxFontSizeMultiplier) {
+      fontScale = maxFontSizeMultiplier
+    }
+
+    return value * baseDensity * fontScale
+  }
+
+  fun toPixelFromDIP(value: Float): Float = PixelUtil.toPixelFromDIP(value)
+
+  fun parseTextAlign(
+    map: ReadableMap,
+    key: String,
+  ): TextAlignment = TextAlignment.fromString(parseString(map, key, "left"))
+}

package/android/src/main/java/com/renderrichtext/styles/SubscriptStyle.kt

@@ -0,0 +1,16 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class SubscriptStyle(
+  val fontScale: Float,
+  val baselineOffsetScale: Float,
+) {
+  companion object {
+    fun fromReadableMap(map: ReadableMap): SubscriptStyle =
+      SubscriptStyle(
+        fontScale = map.getDouble("fontScale").toFloat(),
+        baselineOffsetScale = map.getDouble("baselineOffsetScale").toFloat(),
+      )
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/SuperscriptStyle.kt

@@ -0,0 +1,16 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class SuperscriptStyle(
+  val fontScale: Float,
+  val baselineOffsetScale: Float,
+) {
+  companion object {
+    fun fromReadableMap(map: ReadableMap): SuperscriptStyle =
+      SuperscriptStyle(
+        fontScale = map.getDouble("fontScale").toFloat(),
+        baselineOffsetScale = map.getDouble("baselineOffsetScale").toFloat(),
+      )
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/TableStyle.kt

@@ -0,0 +1,75 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class TableStyle(
+  override val fontSize: Float,
+  override val fontFamily: String,
+  override val fontWeight: String,
+  override val color: Int,
+  override val marginTop: Float,
+  override val marginBottom: Float,
+  override val lineHeight: Float,
+  val headerFontFamily: String,
+  val headerBackgroundColor: Int,
+  val headerTextColor: Int,
+  val rowEvenBackgroundColor: Int,
+  val rowOddBackgroundColor: Int,
+  val borderColor: Int,
+  val borderWidth: Float,
+  val borderRadius: Float,
+  val cellPaddingHorizontal: Float,
+  val cellPaddingVertical: Float,
+  val horizontalOverflow: Float,
+  val align: String,
+) : BaseBlockStyle {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): TableStyle {
+      val fontSize = parser.toPixelFromSP(map.getDouble("fontSize").toFloat())
+      val fontFamily = parser.parseString(map, "fontFamily")
+      val fontWeight = parser.parseString(map, "fontWeight", "normal")
+      val color = parser.parseColor(map, "color")
+      val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      val lineHeightRaw = map.getDouble("lineHeight").toFloat()
+      val lineHeight = if (lineHeightRaw > 0f) parser.toPixelFromSP(lineHeightRaw) else 0f
+      val headerFontFamily = parser.parseString(map, "headerFontFamily")
+      val headerBackgroundColor = parser.parseColor(map, "headerBackgroundColor")
+      val headerTextColor = parser.parseColor(map, "headerTextColor")
+      val rowEvenBackgroundColor = parser.parseColor(map, "rowEvenBackgroundColor")
+      val rowOddBackgroundColor = parser.parseColor(map, "rowOddBackgroundColor")
+      val borderColor = parser.parseColor(map, "borderColor")
+      val borderWidth = parser.toPixelFromDIP(map.getDouble("borderWidth").toFloat())
+      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,
+        fontFamily = fontFamily,
+        fontWeight = fontWeight,
+        color = color,
+        marginTop = marginTop,
+        marginBottom = marginBottom,
+        lineHeight = lineHeight,
+        headerFontFamily = headerFontFamily,
+        headerBackgroundColor = headerBackgroundColor,
+        headerTextColor = headerTextColor,
+        rowEvenBackgroundColor = rowEvenBackgroundColor,
+        rowOddBackgroundColor = rowOddBackgroundColor,
+        borderColor = borderColor,
+        borderWidth = borderWidth,
+        borderRadius = borderRadius,
+        cellPaddingHorizontal = cellPaddingHorizontal,
+        cellPaddingVertical = cellPaddingVertical,
+        horizontalOverflow = horizontalOverflow,
+        align = align,
+      )
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/TaskListStyle.kt

@@ -0,0 +1,29 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class TaskListStyle(
+  val checkedColor: Int,
+  val borderColor: Int,
+  val checkboxSize: Float,
+  val checkboxBorderRadius: Float,
+  val checkmarkColor: Int,
+  val checkedTextColor: Int,
+  val checkedStrikethrough: Boolean,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): TaskListStyle =
+      TaskListStyle(
+        checkedColor = parser.parseColor(map, "checkedColor"),
+        borderColor = parser.parseColor(map, "borderColor"),
+        checkboxSize = parser.toPixelFromDIP(map.getDouble("checkboxSize").toFloat()),
+        checkboxBorderRadius = parser.toPixelFromDIP(map.getDouble("checkboxBorderRadius").toFloat()),
+        checkmarkColor = parser.parseColor(map, "checkmarkColor"),
+        checkedTextColor = parser.parseColor(map, "checkedTextColor"),
+        checkedStrikethrough = map.getBoolean("checkedStrikethrough"),
+      )
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/TextAlignment.kt

@@ -0,0 +1,32 @@
+package com.renderrichtext.styles
+
+import android.text.Layout
+
+enum class TextAlignment(
+  val layoutAlignment: Layout.Alignment,
+  val needsJustify: Boolean,
+) {
+  LEFT(Layout.Alignment.ALIGN_NORMAL, false),
+  CENTER(Layout.Alignment.ALIGN_CENTER, false),
+  RIGHT(Layout.Alignment.ALIGN_OPPOSITE, false),
+  JUSTIFY(Layout.Alignment.ALIGN_NORMAL, true),
+  AUTO(Layout.Alignment.ALIGN_NORMAL, false),
+  ;
+
+  /**
+   * Whether an AlignmentSpan is needed.
+   * Only CENTER and RIGHT need explicit spans; LEFT/AUTO use default, JUSTIFY is handled at TextView level.
+   */
+  val needsAlignmentSpan: Boolean get() = this == CENTER || this == RIGHT
+
+  companion object {
+    fun fromString(value: String): TextAlignment =
+      when (value.lowercase()) {
+        "center" -> CENTER
+        "right" -> RIGHT
+        "justify" -> JUSTIFY
+        "auto" -> AUTO
+        else -> LEFT
+      }
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/ThematicBreakStyle.kt

@@ -0,0 +1,23 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class ThematicBreakStyle(
+  val color: Int,
+  val height: Float,
+  val marginTop: Float,
+  val marginBottom: Float,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): ThematicBreakStyle {
+      val color = parser.parseColor(map, "color")
+      val height = parser.toPixelFromDIP(map.getDouble("height").toFloat())
+      val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      return ThematicBreakStyle(color, height, marginTop, marginBottom)
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/UnderlineStyle.kt

@@ -0,0 +1,17 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class UnderlineStyle(
+  val color: Int,
+) {
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): UnderlineStyle {
+      val color = parser.parseColor(map, "color")
+      return UnderlineStyle(color)
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/styles/VideoStyle.kt

@@ -0,0 +1,31 @@
+package com.renderrichtext.styles
+
+import com.facebook.react.bridge.ReadableMap
+
+data class VideoStyle(
+  val marginTop: Float,
+  val marginBottom: Float,
+  val borderRadius: Float,
+  val aspectRatio: Float,
+  val backgroundColor: Int,
+) {
+  /** Aspect ratio guaranteed to be positive. Falls back to 16:9 if the raw value is ≤ 0. */
+  val resolvedAspectRatio: Float
+    get() = if (aspectRatio > 0f) aspectRatio else DEFAULT_ASPECT_RATIO
+
+  companion object {
+    private const val DEFAULT_ASPECT_RATIO = 16f / 9f
+
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+    ): VideoStyle {
+      val marginTop = parser.toPixelFromDIP(map.getDouble("marginTop").toFloat())
+      val marginBottom = parser.toPixelFromDIP(map.getDouble("marginBottom").toFloat())
+      val borderRadius = parser.toPixelFromDIP(map.getDouble("borderRadius").toFloat())
+      val aspectRatio = map.getDouble("aspectRatio").toFloat()
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      return VideoStyle(marginTop, marginBottom, borderRadius, aspectRatio, backgroundColor)
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/utils/common/BorderStyleUtils.kt

@@ -0,0 +1,86 @@
+package com.renderrichtext.utils.common
+
+import android.view.View
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.uimanager.BackgroundStyleApplicator
+import com.facebook.react.uimanager.LengthPercentage
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.style.BorderRadiusProp
+import com.facebook.react.uimanager.style.BorderStyle
+import com.facebook.react.uimanager.style.LogicalEdge
+
+// BaseViewManagerDelegate (used by our SimpleViewManagers) ignores border
+// width/color/style and no-ops borderRadius, so `containerStyle` borders vanish on
+// Android. Replay them via BackgroundStyleApplicator like ReactViewManager does.
+// Call after super.updateProperties so the composite background drawable exists.
+fun applyReactBorderProps(
+  view: View,
+  props: ReactStylesDiffMap,
+) {
+  for ((name, edge) in BORDER_WIDTH_EDGES) {
+    if (!props.hasKey(name)) continue
+    val width = if (props.isNull(name)) null else props.getFloat(name, Float.NaN).takeUnless { it.isNaN() }
+    BackgroundStyleApplicator.setBorderWidth(view, edge, width)
+  }
+
+  if (BORDER_COLOR_EDGES.keys.any { props.hasKey(it) }) {
+    val rawProps = props.toMap()
+    for ((name, edge) in BORDER_COLOR_EDGES) {
+      if (!props.hasKey(name)) continue
+      val color = if (props.isNull(name)) null else ColorPropConverter.getColor(rawProps[name], view.context)
+      BackgroundStyleApplicator.setBorderColor(view, edge, color)
+    }
+  }
+
+  if (props.hasKey("borderStyle")) {
+    val style = if (props.isNull("borderStyle")) null else BorderStyle.fromString(props.getString("borderStyle") ?: "")
+    BackgroundStyleApplicator.setBorderStyle(view, style)
+  }
+
+  // Radius last, so the border drawable created above already exists and picks
+  // up the rounded corners.
+  for ((name, corner) in BORDER_RADIUS_PROPS) {
+    if (!props.hasKey(name)) continue
+    val radius = if (props.isNull(name)) null else LengthPercentage.setFromDynamic(props.getDynamic(name))
+    BackgroundStyleApplicator.setBorderRadius(view, corner, radius)
+  }
+}
+
+private val BORDER_WIDTH_EDGES =
+  linkedMapOf(
+    "borderWidth" to LogicalEdge.ALL,
+    "borderLeftWidth" to LogicalEdge.LEFT,
+    "borderRightWidth" to LogicalEdge.RIGHT,
+    "borderTopWidth" to LogicalEdge.TOP,
+    "borderBottomWidth" to LogicalEdge.BOTTOM,
+    "borderStartWidth" to LogicalEdge.START,
+    "borderEndWidth" to LogicalEdge.END,
+  )
+
+private val BORDER_COLOR_EDGES =
+  linkedMapOf(
+    "borderColor" to LogicalEdge.ALL,
+    "borderLeftColor" to LogicalEdge.LEFT,
+    "borderRightColor" to LogicalEdge.RIGHT,
+    "borderTopColor" to LogicalEdge.TOP,
+    "borderBottomColor" to LogicalEdge.BOTTOM,
+    "borderStartColor" to LogicalEdge.START,
+    "borderEndColor" to LogicalEdge.END,
+  )
+
+private val BORDER_RADIUS_PROPS =
+  linkedMapOf(
+    "borderRadius" to BorderRadiusProp.BORDER_RADIUS,
+    "borderTopLeftRadius" to BorderRadiusProp.BORDER_TOP_LEFT_RADIUS,
+    "borderTopRightRadius" to BorderRadiusProp.BORDER_TOP_RIGHT_RADIUS,
+    "borderBottomRightRadius" to BorderRadiusProp.BORDER_BOTTOM_RIGHT_RADIUS,
+    "borderBottomLeftRadius" to BorderRadiusProp.BORDER_BOTTOM_LEFT_RADIUS,
+    "borderTopStartRadius" to BorderRadiusProp.BORDER_TOP_START_RADIUS,
+    "borderTopEndRadius" to BorderRadiusProp.BORDER_TOP_END_RADIUS,
+    "borderBottomStartRadius" to BorderRadiusProp.BORDER_BOTTOM_START_RADIUS,
+    "borderBottomEndRadius" to BorderRadiusProp.BORDER_BOTTOM_END_RADIUS,
+    "borderEndEndRadius" to BorderRadiusProp.BORDER_END_END_RADIUS,
+    "borderEndStartRadius" to BorderRadiusProp.BORDER_END_START_RADIUS,
+    "borderStartEndRadius" to BorderRadiusProp.BORDER_START_END_RADIUS,
+    "borderStartStartRadius" to BorderRadiusProp.BORDER_START_START_RADIUS,
+  )

package/android/src/main/java/com/renderrichtext/utils/common/BreakStrategyUtils.kt

@@ -0,0 +1,32 @@
+package com.renderrichtext.utils.common
+
+import android.text.Layout
+
+/**
+ * Resolves a textBreakStrategy prop value (string) to the integer constant used
+ * by StaticLayout.Builder.setBreakStrategy() and TextView.setBreakStrategy().
+ *
+ * Stateless on purpose: textBreakStrategy is a per-view prop. Storage lives in
+ * [com.renderrichtext.MeasurementStore] (per viewId), and each
+ * view applies the resolved value to its own TextView. Both measurement and
+ * render paths must use the same value — mismatch causes measured line count
+ * to differ from the rendered line count, sizing the view incorrectly and
+ * causing ScrollingMovementMethod (inherited via LinkMovementMethod) to
+ * silently scroll the overflow.
+ *
+ * Note: call sites in StaticLayout.Builder suppress "WrongConstant" lint. This is
+ * intentional - Layout.BREAK_STRATEGY_SIMPLE and LineBreaker.BREAK_STRATEGY_SIMPLE
+ * are the same integer (0), but the @IntDef annotation on StaticLayout.Builder
+ * .setBreakStrategy() was changed from Layout.* to LineBreaker.* in API 29.
+ * The suppression is safe; the Layout.* constants share the same integer values.
+ */
+object BreakStrategyUtils {
+  const val DEFAULT_STRATEGY = "highQuality"
+
+  fun resolveBreakStrategy(strategy: String?): Int =
+    when (strategy) {
+      "simple" -> Layout.BREAK_STRATEGY_SIMPLE
+      "balanced" -> Layout.BREAK_STRATEGY_BALANCED
+      else -> Layout.BREAK_STRATEGY_HIGH_QUALITY
+    }
+}

package/android/src/main/java/com/renderrichtext/utils/common/CodeBlockHighlighter.kt

@@ -0,0 +1,36 @@
+package com.renderrichtext.utils.common
+
+import android.text.Spannable
+import com.renderrichtext.styles.CodeBlockStyle
+
+/**
+ * Syntax highlighting is not part of this library. Code blocks stay plain
+ * monospace; the language attribute is kept on the node and not colored.
+ */
+enum class HighlightTokenType {
+  Keyword,
+  Operator,
+  Punctuation,
+  String,
+  Number,
+  Constant,
+  Comment,
+  Function,
+  Type,
+  Variable,
+  Property,
+  Tag,
+  Attribute,
+  Embedded,
+}
+
+object CodeBlockHighlighter {
+  fun highlight(
+    target: Spannable,
+    code: String,
+    language: String?,
+    style: CodeBlockStyle,
+    offset: Int = 0,
+  ) {
+  }
+}

package/android/src/main/java/com/renderrichtext/utils/common/CodeBlockNode.kt

@@ -0,0 +1,42 @@
+package com.renderrichtext.utils.common
+
+import com.renderrichtext.parser.TiptapASTNode
+
+/**
+ * Shared code block node semantics, used by both tiptap 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 {
+  fun extractCode(node: TiptapASTNode): String {
+    val builder = StringBuilder()
+
+    fun append(current: TiptapASTNode) {
+      builder.append(current.content)
+      current.children.forEach { append(it) }
+    }
+    append(node)
+    return builder.toString().trimEnd('\n')
+  }
+
+  fun language(node: TiptapASTNode): String? = node.getAttribute("language")?.takeIf { it.isNotEmpty() }
+
+  fun fenceChar(node: TiptapASTNode): String = node.getAttribute("fenceChar")?.takeIf { it.isNotEmpty() } ?: "`"
+
+  fun fencedTiptap(
+    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 language
+  }
+}

package/android/src/main/java/com/renderrichtext/utils/common/EllipsizeUtils.kt

@@ -0,0 +1,27 @@
+package com.renderrichtext.utils.common
+
+import android.text.TextUtils.TruncateAt
+
+/**
+ * Resolves an ellipsizeMode prop value (string) to the TruncateAt used by
+ * StaticLayout.Builder.setEllipsize() and TextView.setEllipsize().
+ *
+ * "clip" maps to null: with maxLines set, the layout still truncates but draws
+ * no ellipsis glyph. Mirrors React Native's TextAttributeProps.getEllipsizeMode.
+ *
+ * Stateless like [BreakStrategyUtils]: the mode is a per-view prop stored per
+ * viewId in [com.renderrichtext.MeasurementStore]. Measurement and
+ * render paths must resolve the same value, or the measured line count diverges
+ * from the rendered one and the view is sized incorrectly.
+ */
+object EllipsizeUtils {
+  const val DEFAULT_MODE = "tail"
+
+  fun resolveTruncateAt(mode: String?): TruncateAt? =
+    when (mode) {
+      "head" -> TruncateAt.START
+      "middle" -> TruncateAt.MIDDLE
+      "clip" -> null
+      else -> TruncateAt.END
+    }
+}

package/android/src/main/java/com/renderrichtext/utils/common/EnrichedTiptapAncestorUtils.kt

@@ -0,0 +1,10 @@
+package com.renderrichtext.utils.common
+
+import android.view.View
+import com.renderrichtext.EnrichedTiptapText
+
+fun View.findEnrichedTiptapTextAncestor(): EnrichedTiptapText? {
+  var current: android.view.ViewParent? = parent
+  while (current != null && current !is EnrichedTiptapText) current = current.parent
+  return current as? EnrichedTiptapText
+}

package/android/src/main/java/com/renderrichtext/utils/common/FeatureFlags.kt

@@ -0,0 +1,9 @@
+package com.renderrichtext.utils.common
+
+import com.renderrichtext.BuildConfig
+
+object FeatureFlags {
+  const val IS_MATH_ENABLED: Boolean = BuildConfig.ENABLE_MATH
+  const val IS_VIDEO_ENABLED: Boolean = BuildConfig.ENABLE_VIDEO
+  const val IS_CODE_HIGHLIGHT_ENABLED: Boolean = BuildConfig.ENABLE_CODE_HIGHLIGHT
+}

package/android/src/main/java/com/renderrichtext/utils/common/LinkRecognitionProps.kt

@@ -0,0 +1,31 @@
+package com.renderrichtext.utils.common
+
+import com.facebook.react.bridge.ReadableMap
+
+data class LinkRecognition(
+  val text: LinkRegexConfig? = null,
+  val inlineCode: LinkRegexConfig? = null,
+) {
+  companion object {
+    val NONE = LinkRecognition()
+  }
+}
+
+internal fun parseLinkRecognition(map: ReadableMap?): LinkRecognition {
+  if (map == null) return LinkRecognition.NONE
+  return LinkRecognition(
+    text = parseLinkRegexConfig(map.getMapOrNull("text")),
+    inlineCode = parseLinkRegexConfig(map.getMapOrNull("inlineCode")),
+  )
+}
+
+internal fun parseLinkRegexConfig(map: ReadableMap?): LinkRegexConfig? {
+  if (map == null) return null
+  return LinkRegexConfig(
+    pattern = if (map.hasKey("pattern")) map.getString("pattern") ?: "" else "",
+    caseInsensitive = map.hasKey("caseInsensitive") && map.getBoolean("caseInsensitive"),
+    dotAll = map.hasKey("dotAll") && map.getBoolean("dotAll"),
+    isDisabled = !map.hasKey("isDisabled") || map.getBoolean("isDisabled"),
+    isDefault = map.hasKey("isDefault") && map.getBoolean("isDefault"),
+  )
+}

package/android/src/main/java/com/renderrichtext/utils/common/LinkRegexConfig.kt

@@ -0,0 +1,56 @@
+package com.renderrichtext.utils.common
+
+import java.util.regex.Pattern
+import java.util.regex.PatternSyntaxException
+
+/** A regex sent from JS. Equal configs share compiled patterns. */
+data class LinkRegexConfig(
+  val pattern: String,
+  val caseInsensitive: Boolean,
+  val dotAll: Boolean,
+  val isDisabled: Boolean,
+  val isDefault: Boolean,
+) {
+  private val isActive: Boolean
+    get() = !isDisabled && !isDefault && pattern.isNotEmpty()
+
+  /** Null when inactive or invalid. */
+  val compiled: Pattern?
+    get() = if (isActive) compiledPattern(pattern, flags) else null
+
+  /** Anchored to the whole string, for inline-code spans. */
+  val compiledWholeSpan: Pattern?
+    get() = if (isActive) compiledPattern("\\A(?:$pattern)\\z", flags) else null
+
+  private val flags: Int
+    get() = (if (caseInsensitive) Pattern.CASE_INSENSITIVE else 0) or (if (dotAll) Pattern.DOTALL else 0)
+
+  private companion object {
+    private const val MAX_CACHED_PATTERNS = 64
+    private val invalid = Pattern.compile("(?!)")
+
+    // Bounded LRU keyed by flags and source.
+    private val cache =
+      object : LinkedHashMap<String, Pattern>(MAX_CACHED_PATTERNS, 0.75f, true) {
+        override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, Pattern>): Boolean = size > MAX_CACHED_PATTERNS
+      }
+
+    @Synchronized
+    fun compiledPattern(
+      source: String,
+      flags: Int,
+    ): Pattern? {
+      val key = "$flags\u0000$source"
+      val cached = cache[key]
+      if (cached != null) return cached.takeUnless { it === invalid }
+      val compiled =
+        try {
+          Pattern.compile(source, flags)
+        } catch (_: PatternSyntaxException) {
+          invalid
+        }
+      cache[key] = compiled
+      return compiled.takeUnless { it === invalid }
+    }
+  }
+}