@mathers101/react-native-render-rich-text 0.1.10 → 0.1.14

package/android/src/main/java/com/renderrichtext/renderer/LinkRenderer.kt

@@ -1,90 +1,90 @@
-package com.renderrichtext.renderer
-
-import android.text.SpannableStringBuilder
-import android.text.TextPaint
-import android.text.style.ReplacementSpan
-import com.renderrichtext.parser.TiptapASTNode
-import com.renderrichtext.spans.FactoidPaddingSpan
-import com.renderrichtext.spans.LinkPillSpan
-import com.renderrichtext.spans.LinkSpan
-import com.renderrichtext.spans.SpoilerSpan
-import com.renderrichtext.spans.stripFactoidPadding
-import com.renderrichtext.utils.text.extensions.applyBlockStyleFont
-import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
-
-class LinkRenderer(
-  private val config: RendererConfig,
-) : NodeRenderer {
-  // Reused to resolve each pill's typeface; a renderer serves one render at a time.
-  private val fontProbe = TextPaint()
-
-  override fun render(
-    node: TiptapASTNode,
-    builder: SpannableStringBuilder,
-    onLinkPress: ((String) -> Unit)?,
-    onLinkLongPress: ((String) -> Unit)?,
-    onFactoidPress: ((String) -> Unit)?,
-    factory: RendererFactory,
-  ) {
-    val url = node.getAttribute("url") ?: return
-    val recognizedLink = node.getAttribute("recognizedLink") == "true"
-
-    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress) }) { start, end, blockStyle ->
-      val variant = factory.styleCache.resolvedVariantForUrl(url)
-      if (variant?.pill != null && canPresentAsPill(builder, start, end)) {
-        val fontFamily = variant.fontFamily.ifEmpty { factory.styleCache.linkFontFamily }.ifEmpty { blockStyle.fontFamily }
-        val font = fontProbe.apply { applyBlockStyleFont(blockStyle.copy(fontFamily = fontFamily), factory.context) }
-        val pill =
-          LinkPillSpan(
-            variant,
-            font.typeface,
-            blockStyle.fontSize,
-            builder.subSequence(start, end).stripFactoidPadding(),
-            factory.context,
-            config.style.linkPillContent[url],
-            config.style.imageRequestHeaders,
-            followsRunTypeface = variant.fontFamily.isEmpty() && factory.styleCache.linkFontFamily.isEmpty(),
-          )
-        // Set directly, not deferred: the pill measures with its own font, so it does not
-        // need to come after the block spans, and a late insertion makes the builder re-sort.
-        builder.setSpan(pill, start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
-        factory.runAfterRender { text -> pill.resolveLeadingMargin(text, text.getSpanStart(pill), text.getSpanEnd(pill)) }
-      }
-      builder.setSpan(
-        LinkSpan(
-          url,
-          onLinkPress,
-          onLinkLongPress,
-          factory.styleCache,
-          blockStyle,
-          factory.context,
-          recognizedLink = recognizedLink,
-          keepsCodeFont = recognizedLink && node.children.any { it.type == TiptapASTNode.NodeType.Code },
-        ),
-        start,
-        end,
-        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
-      )
-    }
-  }
-
-  /**
-   * A pill replaces one unbroken run. Links that already hold a replacement (image,
-   * math) or span a line break stay ordinary links: a replacement straddling two
-   * paragraphs would be drawn once per paragraph. So do links holding a spoiler,
-   * whose hidden text the label would show. Factoid padding only reserves a gap.
-   */
-  private fun canPresentAsPill(
-    builder: SpannableStringBuilder,
-    start: Int,
-    end: Int,
-  ): Boolean {
-    if (builder.getSpans(start, end, ReplacementSpan::class.java).any { it !is FactoidPaddingSpan }) return false
-    if (builder.getSpans(start, end, SpoilerSpan::class.java).isNotEmpty()) return false
-    for (index in start until end) {
-      val char = builder[index]
-      if (char == '\n' || char == '\r' || char == '\u2028' || char == '\u2029') return false
-    }
-    return true
-  }
-}
+package com.renderrichtext.renderer
+
+import android.text.SpannableStringBuilder
+import android.text.TextPaint
+import android.text.style.ReplacementSpan
+import com.renderrichtext.parser.TiptapASTNode
+import com.renderrichtext.spans.FactoidPaddingSpan
+import com.renderrichtext.spans.LinkPillSpan
+import com.renderrichtext.spans.LinkSpan
+import com.renderrichtext.spans.SpoilerSpan
+import com.renderrichtext.spans.stripFactoidPadding
+import com.renderrichtext.utils.text.extensions.applyBlockStyleFont
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+
+class LinkRenderer(
+  private val config: RendererConfig,
+) : NodeRenderer {
+  // Reused to resolve each pill's typeface; a renderer serves one render at a time.
+  private val fontProbe = TextPaint()
+
+  override fun render(
+    node: TiptapASTNode,
+    builder: SpannableStringBuilder,
+    onLinkPress: ((String) -> Unit)?,
+    onLinkLongPress: ((String) -> Unit)?,
+    onFactoidPress: ((String) -> Unit)?,
+    factory: RendererFactory,
+  ) {
+    val url = node.getAttribute("url") ?: return
+    val recognizedLink = node.getAttribute("recognizedLink") == "true"
+
+    factory.renderWithSpan(builder, { factory.renderChildren(node, builder, onLinkPress, onLinkLongPress, onFactoidPress) }) { start, end, blockStyle ->
+      val variant = factory.styleCache.resolvedVariantForUrl(url)
+      if (variant?.pill != null && canPresentAsPill(builder, start, end)) {
+        val fontFamily = variant.fontFamily.ifEmpty { factory.styleCache.linkFontFamily }.ifEmpty { blockStyle.fontFamily }
+        val font = fontProbe.apply { applyBlockStyleFont(blockStyle.copy(fontFamily = fontFamily), factory.context) }
+        val pill =
+          LinkPillSpan(
+            variant,
+            font.typeface,
+            blockStyle.fontSize,
+            builder.subSequence(start, end).stripFactoidPadding(),
+            factory.context,
+            config.style.linkPillContent[url],
+            config.style.imageRequestHeaders,
+            followsRunTypeface = variant.fontFamily.isEmpty() && factory.styleCache.linkFontFamily.isEmpty(),
+          )
+        // Set directly, not deferred: the pill measures with its own font, so it does not
+        // need to come after the block spans, and a late insertion makes the builder re-sort.
+        builder.setSpan(pill, start, end, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+        factory.runAfterRender { text -> pill.resolveLeadingMargin(text, text.getSpanStart(pill), text.getSpanEnd(pill)) }
+      }
+      builder.setSpan(
+        LinkSpan(
+          url,
+          onLinkPress,
+          onLinkLongPress,
+          factory.styleCache,
+          blockStyle,
+          factory.context,
+          recognizedLink = recognizedLink,
+          keepsCodeFont = recognizedLink && node.children.any { it.type == TiptapASTNode.NodeType.Code },
+        ),
+        start,
+        end,
+        SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+      )
+    }
+  }
+
+  /**
+   * A pill replaces one unbroken run. Links that already hold a replacement (image,
+   * math) or span a line break stay ordinary links: a replacement straddling two
+   * paragraphs would be drawn once per paragraph. So do links holding a spoiler,
+   * whose hidden text the label would show. Factoid padding only reserves a gap.
+   */
+  private fun canPresentAsPill(
+    builder: SpannableStringBuilder,
+    start: Int,
+    end: Int,
+  ): Boolean {
+    if (builder.getSpans(start, end, ReplacementSpan::class.java).any { it !is FactoidPaddingSpan }) return false
+    if (builder.getSpans(start, end, SpoilerSpan::class.java).isNotEmpty()) return false
+    for (index in start until end) {
+      val char = builder[index]
+      if (char == '\n' || char == '\r' || char == '\u2028' || char == '\u2029') return false
+    }
+    return true
+  }
+}

package/android/src/main/java/com/renderrichtext/renderer/ListContextManager.kt

@@ -1,109 +1,109 @@
-package com.renderrichtext.renderer
-
-import com.renderrichtext.styles.ListStyle
-
-/**
- * Manages list context transitions (entering/exiting lists, handling nesting, etc.).
- * Centralizes logic for managing list depth, item numbers, and parent context restoration.
- *
- * Key concepts:
- * - **listDepth**: Tracks nesting level (0 = top-level, 1 = first nested, etc.)
- * - **Stack-based numbering**: Pushes parent's item number when entering nested ordered lists,
- *   allowing each level to maintain its own counter while preserving parent's position.
- * - **Parent context restoration**: Restores parent list's style when exiting nested lists
- *   so subsequent parent items render correctly.
- * - **Marker column**: An ordered list widens its `99.` column to fit its widest marker, and a
- *   nested list inherits the widening of the item it sits in.
- */
-class ListContextManager(
-  private val context: BlockStyleContext,
-) {
-  /**
-   * Captures the state when entering a list, needed for proper restoration when exiting.
-   * This ensures we can restore the exact parent context even after nested lists modify it.
-   */
-  data class ListEntryState(
-    val previousDepth: Int,
-    val parentListType: BlockStyleContext.ListType?,
-    val wasNestedInOrderedList: Boolean,
-    val previousMarkerExtra: Float,
-    val previousMarkerOffset: Float,
-  )
-
-  /**
-   * Enters a list context. Handles:
-   * - Saving parent list item numbers to stack (for ordered lists) before resetting counter
-   * - Incrementing list depth
-   * - Setting the appropriate list style
-   * - Resetting item number for the new list
-   * - Widening the marker column by [markerExtraWidth] and shifting a nested list by its parent item's widening
-   */
-  fun enterList(
-    listType: BlockStyleContext.ListType,
-    style: ListStyle,
-    startNumber: Int = 1,
-    markerExtraWidth: Float = 0f,
-  ): ListEntryState {
-    val previousDepth = context.listDepth
-    val isNested = previousDepth > 0
-    val parentListType = if (isNested) context.listType else null
-    val parentIsOrdered = parentListType == BlockStyleContext.ListType.ORDERED
-
-    // Push parent's item number to stack before resetting for nested list.
-    // Even if entering an unordered list, we need to save if parent is ordered.
-    if (isNested && parentIsOrdered) {
-      context.pushOrderedListItemNumber()
-    }
-
-    context.listDepth = previousDepth + 1
-    when (listType) {
-      BlockStyleContext.ListType.ORDERED -> {
-        context.setOrderedListStyle(style)
-      }
-
-      BlockStyleContext.ListType.UNORDERED -> {
-        context.setUnorderedListStyle(style)
-      }
-    }
-    context.resetListItemNumber(startNumber)
-
-    val previousMarkerExtra = context.listMarkerExtra
-    val previousMarkerOffset = context.ancestorMarkerOffset
-    if (isNested) {
-      context.ancestorMarkerOffset += context.listItemMarkerExtra
-    }
-    context.listMarkerExtra = markerExtraWidth
-
-    return ListEntryState(
-      previousDepth = previousDepth,
-      parentListType = parentListType,
-      wasNestedInOrderedList = isNested && parentIsOrdered,
-      previousMarkerExtra = previousMarkerExtra,
-      previousMarkerOffset = previousMarkerOffset,
-    )
-  }
-
-  /**
-   * Exits a list context. Handles:
-   * - Popping current list block style from stack
-   * - Decrementing list depth back to previousDepth
-   * - Restoring parent list item numbers from stack (if applicable)
-   * - Restoring parent list metadata (if nested) so subsequent parent items render correctly
-   * - Restoring the parent list's marker column and offset
-   */
-  fun exitList(entryState: ListEntryState) {
-    context.listDepth = entryState.previousDepth
-    context.clearListStyle()
-
-    if (entryState.wasNestedInOrderedList) {
-      context.popOrderedListItemNumber()
-    }
-
-    if (entryState.previousDepth > 0) {
-      context.listType = entryState.parentListType
-    }
-
-    context.listMarkerExtra = entryState.previousMarkerExtra
-    context.ancestorMarkerOffset = entryState.previousMarkerOffset
-  }
-}
+package com.renderrichtext.renderer
+
+import com.renderrichtext.styles.ListStyle
+
+/**
+ * Manages list context transitions (entering/exiting lists, handling nesting, etc.).
+ * Centralizes logic for managing list depth, item numbers, and parent context restoration.
+ *
+ * Key concepts:
+ * - **listDepth**: Tracks nesting level (0 = top-level, 1 = first nested, etc.)
+ * - **Stack-based numbering**: Pushes parent's item number when entering nested ordered lists,
+ *   allowing each level to maintain its own counter while preserving parent's position.
+ * - **Parent context restoration**: Restores parent list's style when exiting nested lists
+ *   so subsequent parent items render correctly.
+ * - **Marker column**: An ordered list widens its `99.` column to fit its widest marker, and a
+ *   nested list inherits the widening of the item it sits in.
+ */
+class ListContextManager(
+  private val context: BlockStyleContext,
+) {
+  /**
+   * Captures the state when entering a list, needed for proper restoration when exiting.
+   * This ensures we can restore the exact parent context even after nested lists modify it.
+   */
+  data class ListEntryState(
+    val previousDepth: Int,
+    val parentListType: BlockStyleContext.ListType?,
+    val wasNestedInOrderedList: Boolean,
+    val previousMarkerExtra: Float,
+    val previousMarkerOffset: Float,
+  )
+
+  /**
+   * Enters a list context. Handles:
+   * - Saving parent list item numbers to stack (for ordered lists) before resetting counter
+   * - Incrementing list depth
+   * - Setting the appropriate list style
+   * - Resetting item number for the new list
+   * - Widening the marker column by [markerExtraWidth] and shifting a nested list by its parent item's widening
+   */
+  fun enterList(
+    listType: BlockStyleContext.ListType,
+    style: ListStyle,
+    startNumber: Int = 1,
+    markerExtraWidth: Float = 0f,
+  ): ListEntryState {
+    val previousDepth = context.listDepth
+    val isNested = previousDepth > 0
+    val parentListType = if (isNested) context.listType else null
+    val parentIsOrdered = parentListType == BlockStyleContext.ListType.ORDERED
+
+    // Push parent's item number to stack before resetting for nested list.
+    // Even if entering an unordered list, we need to save if parent is ordered.
+    if (isNested && parentIsOrdered) {
+      context.pushOrderedListItemNumber()
+    }
+
+    context.listDepth = previousDepth + 1
+    when (listType) {
+      BlockStyleContext.ListType.ORDERED -> {
+        context.setOrderedListStyle(style)
+      }
+
+      BlockStyleContext.ListType.UNORDERED -> {
+        context.setUnorderedListStyle(style)
+      }
+    }
+    context.resetListItemNumber(startNumber)
+
+    val previousMarkerExtra = context.listMarkerExtra
+    val previousMarkerOffset = context.ancestorMarkerOffset
+    if (isNested) {
+      context.ancestorMarkerOffset += context.listItemMarkerExtra
+    }
+    context.listMarkerExtra = markerExtraWidth
+
+    return ListEntryState(
+      previousDepth = previousDepth,
+      parentListType = parentListType,
+      wasNestedInOrderedList = isNested && parentIsOrdered,
+      previousMarkerExtra = previousMarkerExtra,
+      previousMarkerOffset = previousMarkerOffset,
+    )
+  }
+
+  /**
+   * Exits a list context. Handles:
+   * - Popping current list block style from stack
+   * - Decrementing list depth back to previousDepth
+   * - Restoring parent list item numbers from stack (if applicable)
+   * - Restoring parent list metadata (if nested) so subsequent parent items render correctly
+   * - Restoring the parent list's marker column and offset
+   */
+  fun exitList(entryState: ListEntryState) {
+    context.listDepth = entryState.previousDepth
+    context.clearListStyle()
+
+    if (entryState.wasNestedInOrderedList) {
+      context.popOrderedListItemNumber()
+    }
+
+    if (entryState.previousDepth > 0) {
+      context.listType = entryState.parentListType
+    }
+
+    context.listMarkerExtra = entryState.previousMarkerExtra
+    context.ancestorMarkerOffset = entryState.previousMarkerOffset
+  }
+}