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

package/android/src/main/java/com/renderrichtext/utils/text/span/BlockSpacing.kt

@@ -1,142 +1,142 @@
-package com.renderrichtext.utils.text.span
-
-import android.text.SpannableStringBuilder
-import com.renderrichtext.spans.CodeBlockSpan
-import com.renderrichtext.spans.ImageSpan
-import com.renderrichtext.spans.LineHeightSpan
-import com.renderrichtext.spans.LinkPillSpan
-import com.renderrichtext.spans.MarginBottomSpan
-import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
-import android.text.style.LineHeightSpan as AndroidLineHeightSpan
-
-fun createLineHeightSpan(lineHeight: Float): AndroidLineHeightSpan = LineHeightSpan(lineHeight)
-
-/** The line height floor that link pills ask of their paragraph. */
-private class LinkPillLineHeightSpan(
-  height: Float,
-) : AndroidLineHeightSpan by LineHeightSpan(height)
-
-/**
- * Raises the line height of every paragraph in [start]..[end] to the largest
- * `pill.lineHeight` among its link pills. A line grows to fit a pill on its own, but only
- * that line and only to the pill's box, so pills on consecutive lines touch. A style that
- * sets `pill.lineHeight` gets a floor for the whole paragraph instead, which keeps its
- * lines even and the pills apart.
- *
- * Nested blocks set line height over ranges that overlap, so a paragraph that already
- * has its floor is left alone. [spanFlags] are those of the block's own line height span:
- * line height spans apply in order, and the floor has to come before the spans that add a
- * margin to a line, or it would swallow that margin.
- */
-fun applyLinkPillLineHeight(
-  builder: SpannableStringBuilder,
-  start: Int,
-  end: Int,
-  spanFlags: Int = SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
-) {
-  val heights = HashMap<Int, Float>()
-  for (pill in builder.getSpans(start, end, LinkPillSpan::class.java)) {
-    val pillStart = builder.getSpanStart(pill)
-    // getSpans also returns a pill that only touches the range.
-    if (pill.lineHeight <= 0 || pillStart < start || pillStart >= end) continue
-    val paragraphStart = builder.lastIndexOf('\n', pillStart - 1).let { if (it < start) start else it + 1 }
-    heights[paragraphStart] = maxOf(heights[paragraphStart] ?: 0f, pill.lineHeight)
-  }
-  for ((paragraphStart, height) in heights) {
-    val paragraphEnd = builder.indexOf('\n', paragraphStart).let { if (it < 0 || it >= end) end else it + 1 }
-    // getSpans also returns the floor of a neighbouring paragraph, which only touches this one.
-    val hasFloor =
-      builder
-        .getSpans(paragraphStart, paragraphEnd, LinkPillLineHeightSpan::class.java)
-        .any { builder.getSpanStart(it) <= paragraphStart && builder.getSpanEnd(it) > paragraphStart }
-    if (hasFloor) continue
-    builder.setSpan(LinkPillLineHeightSpan(height), paragraphStart, paragraphEnd, spanFlags)
-  }
-}
-
-/**
- * Applies [LineHeightSpan] to [start]..[end] but skips ranges occupied by
- * block [ImageSpan]s (and their trailing '\n') and by [CodeBlockSpan]s —
- * both of these apply their own font-metric adjustments that a fixed
- * line height would override.
- */
-fun applyLineHeightSkippingImages(
-  builder: SpannableStringBuilder,
-  start: Int,
-  end: Int,
-  lineHeight: Float,
-  spanFlags: Int = SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
-) {
-  val blockImageRanges =
-    builder
-      .getSpans(start, end, ImageSpan::class.java)
-      .filter { !it.isInline }
-      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
-
-  val codeBlockRanges =
-    builder
-      .getSpans(start, end, CodeBlockSpan::class.java)
-      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
-
-  val excludedRanges = (blockImageRanges + codeBlockRanges).sortedBy { it.first }
-
-  var pos = start
-  for ((exStart, exEnd) in excludedRanges) {
-    if (pos < exStart) {
-      builder.setSpan(
-        createLineHeightSpan(lineHeight),
-        pos,
-        exStart,
-        spanFlags,
-      )
-    }
-    val skipEnd = if (exEnd < end && builder[exEnd] == '\n') exEnd + 1 else exEnd
-    pos = maxOf(pos, skipEnd)
-  }
-  if (pos < end) {
-    builder.setSpan(
-      createLineHeightSpan(lineHeight),
-      pos,
-      end,
-      spanFlags,
-    )
-  }
-  applyLinkPillLineHeight(builder, start, end, spanFlags)
-}
-
-fun applyMarginTop(
-  builder: SpannableStringBuilder,
-  insertionPoint: Int,
-  marginTop: Float,
-) {
-  if (marginTop <= 0) return
-
-  // Insert a newline character to act as a vertical spacer
-  builder.insert(insertionPoint, "\n")
-
-  // Apply MarginBottomSpan to the spacer character to create the gap before the content
-  builder.setSpan(
-    MarginBottomSpan(marginTop),
-    insertionPoint,
-    insertionPoint + 1,
-    SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
-  )
-}
-
-fun applyMarginBottom(
-  builder: SpannableStringBuilder,
-  marginBottom: Float,
-) {
-  val spacerStart = builder.length
-  builder.append("\n")
-  // Always create a MarginBottomSpan, even when marginBottom = 0.
-  // This ensures removeTrailingMargin can correctly identify the LAST element's
-  // margin value. Without a span on the last element, it would pick up a previous
-  // element's span (e.g. blockquote with marginBottom: 16) and use that wrong value.
-  builder.setSpan(
-    MarginBottomSpan(marginBottom),
-    spacerStart,
-    builder.length,
-    SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
-  )
-}
+package com.renderrichtext.utils.text.span
+
+import android.text.SpannableStringBuilder
+import com.renderrichtext.spans.CodeBlockSpan
+import com.renderrichtext.spans.ImageSpan
+import com.renderrichtext.spans.LineHeightSpan
+import com.renderrichtext.spans.LinkPillSpan
+import com.renderrichtext.spans.MarginBottomSpan
+import com.renderrichtext.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import android.text.style.LineHeightSpan as AndroidLineHeightSpan
+
+fun createLineHeightSpan(lineHeight: Float): AndroidLineHeightSpan = LineHeightSpan(lineHeight)
+
+/** The line height floor that link pills ask of their paragraph. */
+private class LinkPillLineHeightSpan(
+  height: Float,
+) : AndroidLineHeightSpan by LineHeightSpan(height)
+
+/**
+ * Raises the line height of every paragraph in [start]..[end] to the largest
+ * `pill.lineHeight` among its link pills. A line grows to fit a pill on its own, but only
+ * that line and only to the pill's box, so pills on consecutive lines touch. A style that
+ * sets `pill.lineHeight` gets a floor for the whole paragraph instead, which keeps its
+ * lines even and the pills apart.
+ *
+ * Nested blocks set line height over ranges that overlap, so a paragraph that already
+ * has its floor is left alone. [spanFlags] are those of the block's own line height span:
+ * line height spans apply in order, and the floor has to come before the spans that add a
+ * margin to a line, or it would swallow that margin.
+ */
+fun applyLinkPillLineHeight(
+  builder: SpannableStringBuilder,
+  start: Int,
+  end: Int,
+  spanFlags: Int = SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+) {
+  val heights = HashMap<Int, Float>()
+  for (pill in builder.getSpans(start, end, LinkPillSpan::class.java)) {
+    val pillStart = builder.getSpanStart(pill)
+    // getSpans also returns a pill that only touches the range.
+    if (pill.lineHeight <= 0 || pillStart < start || pillStart >= end) continue
+    val paragraphStart = builder.lastIndexOf('\n', pillStart - 1).let { if (it < start) start else it + 1 }
+    heights[paragraphStart] = maxOf(heights[paragraphStart] ?: 0f, pill.lineHeight)
+  }
+  for ((paragraphStart, height) in heights) {
+    val paragraphEnd = builder.indexOf('\n', paragraphStart).let { if (it < 0 || it >= end) end else it + 1 }
+    // getSpans also returns the floor of a neighbouring paragraph, which only touches this one.
+    val hasFloor =
+      builder
+        .getSpans(paragraphStart, paragraphEnd, LinkPillLineHeightSpan::class.java)
+        .any { builder.getSpanStart(it) <= paragraphStart && builder.getSpanEnd(it) > paragraphStart }
+    if (hasFloor) continue
+    builder.setSpan(LinkPillLineHeightSpan(height), paragraphStart, paragraphEnd, spanFlags)
+  }
+}
+
+/**
+ * Applies [LineHeightSpan] to [start]..[end] but skips ranges occupied by
+ * block [ImageSpan]s (and their trailing '\n') and by [CodeBlockSpan]s —
+ * both of these apply their own font-metric adjustments that a fixed
+ * line height would override.
+ */
+fun applyLineHeightSkippingImages(
+  builder: SpannableStringBuilder,
+  start: Int,
+  end: Int,
+  lineHeight: Float,
+  spanFlags: Int = SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+) {
+  val blockImageRanges =
+    builder
+      .getSpans(start, end, ImageSpan::class.java)
+      .filter { !it.isInline }
+      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+
+  val codeBlockRanges =
+    builder
+      .getSpans(start, end, CodeBlockSpan::class.java)
+      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+
+  val excludedRanges = (blockImageRanges + codeBlockRanges).sortedBy { it.first }
+
+  var pos = start
+  for ((exStart, exEnd) in excludedRanges) {
+    if (pos < exStart) {
+      builder.setSpan(
+        createLineHeightSpan(lineHeight),
+        pos,
+        exStart,
+        spanFlags,
+      )
+    }
+    val skipEnd = if (exEnd < end && builder[exEnd] == '\n') exEnd + 1 else exEnd
+    pos = maxOf(pos, skipEnd)
+  }
+  if (pos < end) {
+    builder.setSpan(
+      createLineHeightSpan(lineHeight),
+      pos,
+      end,
+      spanFlags,
+    )
+  }
+  applyLinkPillLineHeight(builder, start, end, spanFlags)
+}
+
+fun applyMarginTop(
+  builder: SpannableStringBuilder,
+  insertionPoint: Int,
+  marginTop: Float,
+) {
+  if (marginTop <= 0) return
+
+  // Insert a newline character to act as a vertical spacer
+  builder.insert(insertionPoint, "\n")
+
+  // Apply MarginBottomSpan to the spacer character to create the gap before the content
+  builder.setSpan(
+    MarginBottomSpan(marginTop),
+    insertionPoint,
+    insertionPoint + 1,
+    SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+  )
+}
+
+fun applyMarginBottom(
+  builder: SpannableStringBuilder,
+  marginBottom: Float,
+) {
+  val spacerStart = builder.length
+  builder.append("\n")
+  // Always create a MarginBottomSpan, even when marginBottom = 0.
+  // This ensures removeTrailingMargin can correctly identify the LAST element's
+  // margin value. Without a span on the last element, it would pick up a previous
+  // element's span (e.g. blockquote with marginBottom: 16) and use that wrong value.
+  builder.setSpan(
+    MarginBottomSpan(marginBottom),
+    spacerStart,
+    builder.length,
+    SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+  )
+}

package/android/src/main/java/com/renderrichtext/utils/text/span/SpanFlags.kt

@@ -1,43 +1,43 @@
-package com.renderrichtext.utils.text.span
-
-import android.text.SpannableString
-import android.text.Spanned
-
-const val SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE = SpannableString.SPAN_EXCLUSIVE_EXCLUSIVE
-
-/**
- * `SPAN_EXCLUSIVE_EXCLUSIVE` with the maximum span priority.
- *
- * Higher-priority spans are iterated — and therefore applied and drawn — first,
- * so lower-priority spans over the same range override them. Use this for a
- * block span set after its children that must not override the inline spans
- * inside it (e.g. [HeadingSpan]), or for a container background that must sit
- * under inline pill/chip backgrounds (e.g. [BlockquoteSpan]).
- */
-const val SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE_PRIORITY =
-  Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or Spanned.SPAN_PRIORITY
-
-/**
- * `SPAN_EXCLUSIVE_EXCLUSIVE` with the maximum span priority, for a block-wide
- * LineHeightSpan (e.g. a blockquote's uniform line height) that must be iterated
- * BEFORE the per-block [MarginBottomSpan]s it overlaps. LineHeightSpans are
- * applied in iteration order and higher priority iterates first, so this span
- * sets the base line height and the lower-priority margin span then adds its gap
- * on top instead of being normalized away. Without it a line-height pass applied
- * after the margins (e.g. in BlockquoteTextRenderer.postProcess) would erase them
- * and clip the first line's ascent.
- */
-const val SPAN_FLAGS_LINE_HEIGHT_PRIORITY =
-  Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or Spanned.SPAN_PRIORITY
-
-/**
- * `SPAN_EXCLUSIVE_EXCLUSIVE` with a span priority just above the default.
- *
- * List item spans are set after the item's children, so at the default
- * priority they apply after inline spans such as `CodeSpan` and replace their
- * font and size. This priority applies them first, while staying below
- * [SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE_PRIORITY] so a blockquote still draws its
- * leading margin before a list's.
- */
-const val SPAN_FLAGS_LIST_ITEM =
-  Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or (1 shl Spanned.SPAN_PRIORITY_SHIFT)
+package com.renderrichtext.utils.text.span
+
+import android.text.SpannableString
+import android.text.Spanned
+
+const val SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE = SpannableString.SPAN_EXCLUSIVE_EXCLUSIVE
+
+/**
+ * `SPAN_EXCLUSIVE_EXCLUSIVE` with the maximum span priority.
+ *
+ * Higher-priority spans are iterated — and therefore applied and drawn — first,
+ * so lower-priority spans over the same range override them. Use this for a
+ * block span set after its children that must not override the inline spans
+ * inside it (e.g. [HeadingSpan]), or for a container background that must sit
+ * under inline pill/chip backgrounds (e.g. [BlockquoteSpan]).
+ */
+const val SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE_PRIORITY =
+  Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or Spanned.SPAN_PRIORITY
+
+/**
+ * `SPAN_EXCLUSIVE_EXCLUSIVE` with the maximum span priority, for a block-wide
+ * LineHeightSpan (e.g. a blockquote's uniform line height) that must be iterated
+ * BEFORE the per-block [MarginBottomSpan]s it overlaps. LineHeightSpans are
+ * applied in iteration order and higher priority iterates first, so this span
+ * sets the base line height and the lower-priority margin span then adds its gap
+ * on top instead of being normalized away. Without it a line-height pass applied
+ * after the margins (e.g. in BlockquoteTextRenderer.postProcess) would erase them
+ * and clip the first line's ascent.
+ */
+const val SPAN_FLAGS_LINE_HEIGHT_PRIORITY =
+  Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or Spanned.SPAN_PRIORITY
+
+/**
+ * `SPAN_EXCLUSIVE_EXCLUSIVE` with a span priority just above the default.
+ *
+ * List item spans are set after the item's children, so at the default
+ * priority they apply after inline spans such as `CodeSpan` and replace their
+ * font and size. This priority applies them first, while staying below
+ * [SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE_PRIORITY] so a blockquote still draws its
+ * leading margin before a list's.
+ */
+const val SPAN_FLAGS_LIST_ITEM =
+  Spanned.SPAN_EXCLUSIVE_EXCLUSIVE or (1 shl Spanned.SPAN_PRIORITY_SHIFT)

package/android/src/main/java/com/renderrichtext/utils/text/span/WidthAwareSpans.kt

@@ -1,30 +1,30 @@
-package com.renderrichtext.utils.text.span
-
-import android.text.Spanned
-import com.renderrichtext.spans.ImageSpan
-import com.renderrichtext.spans.LinkPillSpan
-
-/**
- * Primes every span whose size depends on the layout width (pills, images). Call it
- * before building any layout over [text]. [includeImages] is off for a visible text
- * view, whose image spans size themselves from the view they are registered with.
- *
- * Returns true when a pill's width limit changed, i.e. an existing layout is stale.
- */
-fun prepareWidthAwareSpans(
-  text: CharSequence?,
-  widthPx: Int,
-  includeImages: Boolean = true,
-): Boolean {
-  val spanned = text as? Spanned ?: return false
-  // widthPx == 1 is the coerceAtLeast(1) fallback for a not-yet-measured view. Priming
-  // with it would squeeze pills on screen to a sliver until the next real measure.
-  if (widthPx <= 1) return false
-  val pillsChanged = LinkPillSpan.prepareForMeasurement(spanned, widthPx)
-  if (includeImages) {
-    spanned
-      .getSpans(0, spanned.length, ImageSpan::class.java)
-      .forEach { it.prepareForMeasurement(spanned, widthPx) }
-  }
-  return pillsChanged
-}
+package com.renderrichtext.utils.text.span
+
+import android.text.Spanned
+import com.renderrichtext.spans.ImageSpan
+import com.renderrichtext.spans.LinkPillSpan
+
+/**
+ * Primes every span whose size depends on the layout width (pills, images). Call it
+ * before building any layout over [text]. [includeImages] is off for a visible text
+ * view, whose image spans size themselves from the view they are registered with.
+ *
+ * Returns true when a pill's width limit changed, i.e. an existing layout is stale.
+ */
+fun prepareWidthAwareSpans(
+  text: CharSequence?,
+  widthPx: Int,
+  includeImages: Boolean = true,
+): Boolean {
+  val spanned = text as? Spanned ?: return false
+  // widthPx == 1 is the coerceAtLeast(1) fallback for a not-yet-measured view. Priming
+  // with it would squeeze pills on screen to a sliver until the next real measure.
+  if (widthPx <= 1) return false
+  val pillsChanged = LinkPillSpan.prepareForMeasurement(spanned, widthPx)
+  if (includeImages) {
+    spanned
+      .getSpans(0, spanned.length, ImageSpan::class.java)
+      .forEach { it.prepareForMeasurement(spanned, widthPx) }
+  }
+  return pillsChanged
+}

package/android/src/main/java/com/renderrichtext/utils/text/view/CodeBlockPressHost.kt

@@ -1,15 +1,15 @@
-package com.renderrichtext.utils.text.view
-
-/**
- * Implemented by the commonmark host view so [LinkLongPressMovementMethod] can
- * gate and dispatch taps landing on a code block span. GFM uses a separate
- * CodeBlockContainerView, so its host walk resolves to none.
- */
-interface CodeBlockPressHost {
-  val codeBlockPressEnabled: Boolean
-
-  fun emitOnCodeBlockPress(
-    code: String,
-    language: String,
-  )
-}
+package com.renderrichtext.utils.text.view
+
+/**
+ * Implemented by the commonmark host view so [LinkLongPressMovementMethod] can
+ * gate and dispatch taps landing on a code block span. GFM uses a separate
+ * CodeBlockContainerView, so its host walk resolves to none.
+ */
+interface CodeBlockPressHost {
+  val codeBlockPressEnabled: Boolean
+
+  fun emitOnCodeBlockPress(
+    code: String,
+    language: String,
+  )
+}

package/android/src/main/java/com/renderrichtext/utils/text/view/ImagePressHost.kt

@@ -1,19 +1,19 @@
-package com.renderrichtext.utils.text.view
-
-/**
- * Implemented by the React-tagged host views (EnrichedTiptapText and the GFM
- * EnrichedTiptap container) so [LinkLongPressMovementMethod] can gate and
- * dispatch image taps without knowing which flavor owns the tapped TextView.
- *
- * In GFM the tapped TextView is an internal segment child, so the movement
- * method walks up to the nearest host - the same routing ImageSpan uses for its
- * box-height notifications.
- */
-interface ImagePressHost {
-  val imagePressEnabled: Boolean
-
-  fun emitOnImagePress(
-    url: String,
-    altText: String,
-  )
-}
+package com.renderrichtext.utils.text.view
+
+/**
+ * Implemented by the React-tagged host views (EnrichedTiptapText and the GFM
+ * EnrichedTiptap container) so [LinkLongPressMovementMethod] can gate and
+ * dispatch image taps without knowing which flavor owns the tapped TextView.
+ *
+ * In GFM the tapped TextView is an internal segment child, so the movement
+ * method walks up to the nearest host - the same routing ImageSpan uses for its
+ * box-height notifications.
+ */
+interface ImagePressHost {
+  val imagePressEnabled: Boolean
+
+  fun emitOnImagePress(
+    url: String,
+    altText: String,
+  )
+}