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

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

@@ -0,0 +1,18 @@
+package com.renderrichtext.utils.common
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.os.Build
+
+/**
+ * Returns true when the user has asked the system to minimise motion.
+ *
+ * On API 26+ delegates to [ValueAnimator.areAnimatorsEnabled], which covers
+ * the "Remove animations" accessibility setting, the "Animator duration scale"
+ * developer toggle, and Battery Saver mode. Older API levels do not expose an
+ * equivalent flag, hence the fall back to allowing animations.
+ */
+fun isReducedMotionEnabled(context: Context): Boolean {
+  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false
+  return !ValueAnimator.areAnimatorsEnabled()
+}

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

@@ -0,0 +1,28 @@
+package com.renderrichtext.utils.common
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+fun ReadableMap?.getBooleanOrDefault(
+  key: String,
+  default: Boolean,
+): Boolean = if (this?.hasKey(key) == true) getBoolean(key) else default
+
+fun ReadableMap?.getFloatOrDefault(
+  key: String,
+  default: Float,
+): Float = if (this?.hasKey(key) == true) getDouble(key).toFloat() else default
+
+fun ReadableMap?.getIntOrDefault(
+  key: String,
+  default: Int,
+): Int = if (this?.hasKey(key) == true) getDouble(key).toInt() else default
+
+fun ReadableMap?.getStringOrDefault(
+  key: String,
+  default: String,
+): 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/renderrichtext/utils/common/TiptapViewManagerUtils.kt

@@ -0,0 +1,242 @@
+package com.renderrichtext.utils.common
+
+import android.view.View
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.renderrichtext.accessibility.AccessibilityLabels
+import com.renderrichtext.events.CodeBlockPressEvent
+import com.renderrichtext.events.FactoidPressEvent
+import com.renderrichtext.events.MentionLongPressEvent
+import com.renderrichtext.events.MentionPressEvent
+import com.renderrichtext.events.ContextMenuItemPressEvent
+import com.renderrichtext.events.CopyPressEvent
+import com.renderrichtext.events.LatexErrorEvent
+import com.renderrichtext.events.LinkLongPressEvent
+import com.renderrichtext.events.LinkPressEvent
+import com.renderrichtext.events.TaskListItemPressEvent
+import com.renderrichtext.parser.Md4cFlags
+import com.renderrichtext.styles.LinkPillContent
+import com.renderrichtext.utils.text.view.SelectionMenuConfig
+
+fun tiptapEventTypeConstants(): MutableMap<String, Any> {
+  val map = mutableMapOf<String, Any>()
+  map[LinkPressEvent.EVENT_NAME] = mapOf("registrationName" to LinkPressEvent.EVENT_NAME)
+  map[FactoidPressEvent.EVENT_NAME] = mapOf("registrationName" to FactoidPressEvent.EVENT_NAME)
+  map[MentionPressEvent.EVENT_NAME] = mapOf("registrationName" to MentionPressEvent.EVENT_NAME)
+  map[MentionLongPressEvent.EVENT_NAME] =
+    mapOf("registrationName" to MentionLongPressEvent.EVENT_NAME)
+  map[LinkLongPressEvent.EVENT_NAME] =
+    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[CodeBlockPressEvent.EVENT_NAME] =
+    mapOf("registrationName" to CodeBlockPressEvent.EVENT_NAME)
+  map[ContextMenuItemPressEvent.EVENT_NAME] =
+    mapOf("registrationName" to ContextMenuItemPressEvent.EVENT_NAME)
+  map[LatexErrorEvent.EVENT_NAME] =
+    mapOf("registrationName" to LatexErrorEvent.EVENT_NAME)
+  return map
+}
+
+fun emitMentionPress(
+  view: View,
+  mentionId: String,
+  label: 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(MentionPressEvent(surfaceId, view.id, mentionId, label))
+}
+
+fun emitMentionLongPress(
+  view: View,
+  mentionId: String,
+  label: 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(MentionLongPressEvent(surfaceId, view.id, mentionId, label))
+}
+
+fun emitFactoidPress(
+  view: View,
+  factoidId: 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(FactoidPressEvent(surfaceId, view.id, factoidId))
+}
+
+fun emitLinkPress(
+  view: View,
+  url: 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(LinkPressEvent(surfaceId, view.id, url))
+}
+
+fun emitLinkLongPress(
+  view: View,
+  url: 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(LinkLongPressEvent(surfaceId, view.id, url))
+}
+
+fun emitTaskListItemPress(
+  view: View,
+  taskIndex: Int,
+  checked: Boolean,
+  itemText: 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(
+    TaskListItemPressEvent(surfaceId, view.id, taskIndex, checked, itemText),
+  )
+}
+
+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 emitLatexError(
+  view: View,
+  source: String,
+  message: String?,
+  displayMode: Boolean,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(
+    LatexErrorEvent(surfaceId, view.id, source, message, displayMode),
+  )
+}
+
+fun emitCodeBlockPress(
+  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(
+    CodeBlockPressEvent(surfaceId, view.id, code, language),
+  )
+}
+
+fun emitContextMenuItemPress(
+  view: View,
+  itemText: String,
+  selectedText: String,
+  selectionStart: Int,
+  selectionEnd: Int,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(
+    ContextMenuItemPressEvent(
+      surfaceId,
+      view.id,
+      itemText,
+      selectedText,
+      selectionStart,
+      selectionEnd,
+    ),
+  )
+}
+
+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,
+    hardSoftBreaks = flags?.getBoolean("hardSoftBreaks") ?: false,
+    preserveBlankLines = flags?.getBoolean("preserveBlankLines") ?: false,
+    admonitions = flags?.getBoolean("admonitions") ?: true,
+  )
+
+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 parseLinkPillContent(value: ReadableArray?): Map<String, LinkPillContent> =
+  (0 until (value?.size() ?: 0))
+    .mapNotNull { index ->
+      val entry = value?.getMap(index) ?: return@mapNotNull null
+      val url = entry.getString("url") ?: return@mapNotNull null
+      url to LinkPillContent.fromReadableMap(entry)
+    }.toMap()
+
+fun parseSelectionMenuConfig(value: ReadableMap?): SelectionMenuConfig {
+  if (value == null) return SelectionMenuConfig()
+  return SelectionMenuConfig(
+    copyAsTiptap = value.getBoolean("copyAsTiptap"),
+    copyImageUrl = value.getBoolean("copyImageUrl"),
+    copyLabel = value.getString("copyLabel") ?: "",
+    copyAsTiptapLabel = value.getString("copyAsTiptapLabel") ?: "",
+    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 codeBlock = value.getMap("codeBlock")
+  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") ?: "",
+    codeBlockWrap = codeBlock?.getString("wrap") ?: "",
+    codeBlockUnwrap = codeBlock?.getString("unwrap") ?: "",
+    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/renderrichtext/utils/common/layout/RTLUtils.kt

@@ -0,0 +1,6 @@
+package com.renderrichtext.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/renderrichtext/utils/common/serialization/TiptapASTSerializer.kt

@@ -0,0 +1,368 @@
+package com.renderrichtext.utils.common.serialization
+
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.parser.TiptapASTNode.NodeType
+import com.renderrichtext.parser.isTopLevelBlock
+import com.renderrichtext.utils.common.CodeBlockNode
+
+object TiptapASTSerializer {
+  fun serializeNode(node: TiptapASTNode): String {
+    val buffer = StringBuilder()
+    appendNode(node, buffer)
+    return buffer.toString()
+  }
+
+  fun serializeChildren(node: TiptapASTNode): String {
+    val buffer = StringBuilder()
+    for (child in node.children) {
+      appendNode(child, buffer)
+    }
+    return buffer.toString()
+  }
+
+  /**
+   * Serializes a Blockquote or Admonition node back to tiptap, including
+   * the `> ` prefix on every line and `> [!TYPE]` header for admonitions.
+   */
+  fun serializeBlockquote(node: TiptapASTNode): String {
+    val sb = StringBuilder()
+    val isAdmonition = node.type == NodeType.Admonition
+    if (isAdmonition) {
+      val type = node.getAttribute("admonitionType")?.takeIf { it.isNotEmpty() } ?: "note"
+      sb.append("> [!${type.uppercase(java.util.Locale.ROOT)}]\n")
+    }
+    val body = serializeBlockChildren(node)
+    for (line in body.trimEnd('\n').split("\n")) {
+      sb.append("> ")
+      sb.append(line)
+      sb.append("\n")
+    }
+    return sb.toString()
+  }
+
+  /**
+   * Extracts the plain text content of an AST node recursively.
+   * Inserts newlines between block-level children and handles soft/hard breaks.
+   */
+  fun plainText(node: TiptapASTNode): String {
+    val buffer = StringBuilder()
+    appendPlainText(node, buffer)
+    return buffer.toString().trim()
+  }
+
+  private fun appendPlainText(
+    node: TiptapASTNode,
+    buffer: StringBuilder,
+  ) {
+    when (node.type) {
+      NodeType.SoftBreak -> {
+        buffer.append("\n")
+      }
+
+      NodeType.LineBreak -> {
+        buffer.append("\n")
+      }
+
+      NodeType.Mention -> {
+        val name = node.getAttribute("label").orEmpty().ifBlank { node.getAttribute("id").orEmpty() }
+        buffer.append('@')
+        buffer.append(name)
+      }
+
+      NodeType.BlankLine -> {
+        val count = node.getAttribute("count")?.toIntOrNull() ?: 0
+        repeat(count) { buffer.append("\n") }
+      }
+
+      NodeType.Paragraph -> {
+        for (child in node.children) {
+          appendPlainText(child, buffer)
+        }
+        buffer.append("\n")
+      }
+
+      NodeType.Heading -> {
+        for (child in node.children) {
+          appendPlainText(child, buffer)
+        }
+        buffer.append("\n")
+      }
+
+      else -> {
+        buffer.append(node.content)
+        for (child in node.children) {
+          appendPlainText(child, buffer)
+        }
+      }
+    }
+  }
+
+  // -- Block-level serialization --------------------------------------------------
+
+  private fun serializeBlockChildren(node: TiptapASTNode): String {
+    val buffer = StringBuilder()
+    val children = node.children
+    for ((index, child) in children.withIndex()) {
+      appendBlockNode(child, buffer)
+      if (index < children.size - 1 && child.type.isTopLevelBlock()) {
+        buffer.append("\n")
+      }
+    }
+    return buffer.toString()
+  }
+
+  private fun appendBlockNode(
+    node: TiptapASTNode,
+    buffer: StringBuilder,
+  ) {
+    when (node.type) {
+      NodeType.Paragraph -> {
+        appendChildren(node, buffer)
+        buffer.append("\n")
+      }
+
+      NodeType.Heading -> {
+        val level = (node.getAttribute("level") ?: "1").toIntOrNull() ?: 1
+        buffer.append("#".repeat(level))
+        buffer.append(" ")
+        appendChildren(node, buffer)
+        buffer.append("\n")
+      }
+
+      NodeType.CodeBlock -> {
+        val code = CodeBlockNode.extractCode(node)
+        val language = CodeBlockNode.language(node)
+        val fenceChar = CodeBlockNode.fenceChar(node)
+        buffer.append(CodeBlockNode.fencedTiptap(code, language, fenceChar))
+        buffer.append("\n")
+      }
+
+      NodeType.Blockquote, NodeType.Admonition -> {
+        buffer.append(serializeBlockquote(node))
+      }
+
+      NodeType.ThematicBreak -> {
+        buffer.append("---\n")
+      }
+
+      NodeType.BlankLine -> {
+        val count = node.getAttribute("count")?.toIntOrNull() ?: 0
+        repeat(count) { buffer.append("\n") }
+      }
+
+      NodeType.Table -> {
+        appendTableTiptap(node, buffer)
+      }
+
+      NodeType.UnorderedList -> {
+        appendListTiptap(node, buffer, ordered = false)
+      }
+
+      NodeType.OrderedList -> {
+        appendListTiptap(node, buffer, ordered = true)
+      }
+
+      NodeType.LatexMathDisplay -> {
+        buffer.append("$$\n")
+        appendChildren(node, buffer)
+        buffer.append("\n$$\n")
+      }
+
+      else -> {
+        appendChildren(node, buffer)
+      }
+    }
+  }
+
+  // Table tiptap reconstruction from raw AST nodes. This parallels
+  // TableContainerView.buildTiptapFromRows() which works from processed
+  // TableCellData; both must produce the same pipe-table format.
+  private fun appendTableTiptap(
+    node: TiptapASTNode,
+    buffer: StringBuilder,
+  ) {
+    var headerDone = false
+    for (section in node.children) {
+      for (row in section.children) {
+        if (row.type != NodeType.TableRow) continue
+        val cells = row.children.map { serializeChildren(it) }
+        buffer.append("| ")
+        buffer.append(cells.joinToString(" | "))
+        buffer.append(" |\n")
+        if (!headerDone && row.children.any { it.type == NodeType.TableHeaderCell }) {
+          val sep =
+            row.children.map { cell ->
+              when (cell.getAttribute("align")) {
+                "center" -> ":---:"
+                "right" -> "---:"
+                else -> "---"
+              }
+            }
+          buffer.append("| ")
+          buffer.append(sep.joinToString(" | "))
+          buffer.append(" |\n")
+          headerDone = true
+        }
+      }
+    }
+  }
+
+  private fun appendListTiptap(
+    node: TiptapASTNode,
+    buffer: StringBuilder,
+    ordered: Boolean,
+  ) {
+    var number =
+      if (ordered) {
+        node.getAttribute("start")?.toIntOrNull()?.coerceAtLeast(0) ?: 1
+      } else {
+        1
+      }
+    for (item in node.children) {
+      if (item.type != NodeType.ListItem) continue
+      val prefix = if (ordered) "$number. " else "- "
+      val content = serializeBlockChildren(item).trimEnd('\n')
+      val lines = content.split("\n")
+      lines.forEachIndexed { lineIdx, line ->
+        if (lineIdx == 0) {
+          buffer.append(prefix)
+        } else {
+          buffer.append(" ".repeat(prefix.length))
+        }
+        buffer.append(line)
+        buffer.append("\n")
+      }
+      if (ordered) number++
+    }
+  }
+
+  // -- Inline serialization -------------------------------------------------------
+
+  private fun appendNode(
+    node: TiptapASTNode,
+    buffer: StringBuilder,
+  ) {
+    when (node.type) {
+      NodeType.Text -> {
+        buffer.append(node.content)
+      }
+
+      NodeType.LineBreak -> {
+        buffer.append("\\\n")
+      }
+
+      NodeType.SoftBreak -> {
+        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.LatexMathInline -> {
+        buffer.append("\$")
+        appendChildren(node, buffer)
+        buffer.append("\$")
+      }
+
+      NodeType.Code -> {
+        buffer.append("`")
+        appendChildren(node, buffer)
+        buffer.append("`")
+      }
+
+      NodeType.Link -> {
+        if (node.getAttribute("recognizedLink") == "true") {
+          appendChildren(node, buffer)
+          return
+        }
+        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(")")
+      }
+
+      NodeType.Mention -> {
+        val name = node.getAttribute("label").orEmpty().ifBlank { node.getAttribute("id").orEmpty() }
+        buffer.append('@')
+        buffer.append(name)
+      }
+
+      NodeType.Video -> {
+        val url = node.getAttribute("url") ?: ""
+        if (url.contains('"')) {
+          buffer.append("<video src='")
+          buffer.append(url)
+          buffer.append("' />")
+        } else {
+          buffer.append("<video src=\"")
+          buffer.append(url)
+          buffer.append("\" />")
+        }
+      }
+
+      else -> {
+        appendChildren(node, buffer)
+      }
+    }
+  }
+
+  private fun appendChildren(
+    node: TiptapASTNode,
+    buffer: StringBuilder,
+  ) {
+    for (child in node.children) {
+      appendNode(child, buffer)
+    }
+  }
+}