react-native-enriched-markdown-scaffold 1.0.2-scaffold.3 → 1.0.2-scaffold.5

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

@@ -5,9 +5,6 @@ import android.graphics.Paint
 import android.graphics.Path
 import android.graphics.RectF
 import android.text.Spanned
-import android.text.StaticLayout
-import android.text.TextPaint
-import android.text.style.LeadingMarginSpan
 import android.text.style.LineBackgroundSpan
 import com.swmansion.enriched.markdown.styles.StyleConfig
 import kotlin.math.max
@@ -73,14 +70,6 @@ class CodeBackgroundSpan(
     drawShapes(canvas, isFirst, isLast)
   }
 
-  /**
-   * Returns the x position of [index] relative to the line's left edge, including any
-   * leading margin. The measuring StaticLayout is built from a subSequence that keeps
-   * all spans, so LeadingMarginSpans (lists, blockquotes) are already applied to
-   * getPrimaryHorizontal; adding the margin again on top would shift the background
-   * right by the indent. The margin is only added explicitly in the early-return case,
-   * where no layout is built.
-   */
   private fun getHorizontalOffset(
     text: CharSequence,
     lineStart: Int,
@@ -88,105 +77,30 @@ class CodeBackgroundSpan(
     index: Int,
     paint: Paint,
     leadingMargin: Int,
-  ): Float {
-    if (index <= lineStart) return leadingMargin.toFloat()
-    val lineText = text.subSequence(lineStart, lineEnd)
-    val textPaint = paint as? TextPaint ?: TextPaint(paint)
-    val layout = StaticLayout.Builder.obtain(lineText, 0, lineText.length, textPaint, 10000).build()
-    return layout.getPrimaryHorizontal(index - lineStart)
-  }
+  ): Float = InlineChipPainter.horizontalOffset(text, lineStart, lineEnd, index, paint, leadingMargin)
 
   private fun drawShapes(
     canvas: Canvas,
     isFirst: Boolean,
     isLast: Boolean,
   ) {
-    val radii = createRadii(isFirst, isLast)
-
-    path.reset()
-    path.addRoundRect(rect, radii, Path.Direction.CW)
-    canvas.drawPath(path, sharedBackgroundPaint)
-
-    if (isFirst && isLast) {
-      canvas.drawPath(path, sharedBorderPaint)
-    } else {
-      drawOpenBorders(canvas, isFirst, isLast)
-    }
-  }
-
-  private fun drawOpenBorders(
-    canvas: Canvas,
-    isFirst: Boolean,
-    isLast: Boolean,
-  ) {
-    val r = CORNER_RADIUS
-    path.reset()
-
-    if (isFirst) {
-      path.moveTo(rect.right, rect.top)
-      path.lineTo(rect.left + r, rect.top)
-      path.quadTo(rect.left, rect.top, rect.left, rect.top + r)
-      path.lineTo(rect.left, rect.bottom - r)
-      path.quadTo(rect.left, rect.bottom, rect.left + r, rect.bottom)
-      path.lineTo(rect.right, rect.bottom)
-    } else if (isLast) {
-      path.moveTo(rect.left, rect.top)
-      path.lineTo(rect.right - r, rect.top)
-      path.quadTo(rect.right, rect.top, rect.right, rect.top + r)
-      path.lineTo(rect.right, rect.bottom - r)
-      path.quadTo(rect.right, rect.bottom, rect.right - r, rect.bottom)
-      path.lineTo(rect.left, rect.bottom)
-    } else {
-      path.moveTo(rect.left, rect.top)
-      path.lineTo(rect.right, rect.top)
-      path.moveTo(rect.left, rect.bottom)
-      path.lineTo(rect.right, rect.bottom)
-    }
-    canvas.drawPath(path, sharedBorderPaint)
-  }
-
-  private fun createRadii(
-    isFirst: Boolean,
-    isLast: Boolean,
-  ) = when {
-    isFirst && isLast -> {
-      floatArrayOf(
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-        CORNER_RADIUS,
-      )
-    }
-
-    isFirst -> {
-      floatArrayOf(CORNER_RADIUS, CORNER_RADIUS, 0f, 0f, 0f, 0f, CORNER_RADIUS, CORNER_RADIUS)
-    }
-
-    isLast -> {
-      floatArrayOf(0f, 0f, CORNER_RADIUS, CORNER_RADIUS, CORNER_RADIUS, CORNER_RADIUS, 0f, 0f)
-    }
-
-    else -> {
-      floatArrayOf(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f)
-    }
+    InlineChipPainter.draw(
+      canvas,
+      rect,
+      path,
+      CORNER_RADIUS,
+      sharedBackgroundPaint,
+      sharedBorderPaint,
+      isFirst,
+      isLast,
+      strokeInset = false,
+    )
   }
 
   private fun leadingMarginAt(
     text: Spanned,
     lineStart: Int,
-  ): Int {
-    if (lineStart >= text.length) return 0
-    val spans = text.getSpans(lineStart, lineStart + 1, LeadingMarginSpan::class.java)
-    var margin = 0
-    for (span in spans) {
-      margin += span.getLeadingMargin(false)
-    }
-    return margin
-  }
+  ): Int = InlineChipPainter.leadingMarginAt(text, lineStart)
 
   private fun adjustBottomForMargin(
     text: Spanned,

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

@@ -0,0 +1,140 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.Spanned
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+
+/**
+ * Shared geometry and drawing for inline "chips" painted from a [android.text.style.LineBackgroundSpan]
+ * (inline code, link chips). For a chip that wraps, only the outer ends are rounded and the border
+ * stays open where a fragment is cut.
+ */
+internal object InlineChipPainter {
+  /**
+   * Returns the x position of [index] relative to the line's left edge, including any
+   * leading margin. The measuring StaticLayout is built from a subSequence that keeps
+   * all spans, so LeadingMarginSpans (lists, blockquotes) are already applied to
+   * getPrimaryHorizontal; adding the margin again on top would shift the background
+   * right by the indent. The margin is only added explicitly in the early-return case,
+   * where no layout is built.
+   */
+  fun horizontalOffset(
+    text: CharSequence,
+    lineStart: Int,
+    lineEnd: Int,
+    index: Int,
+    paint: Paint,
+    leadingMargin: Int,
+  ): Float {
+    if (index <= lineStart) return leadingMargin.toFloat()
+    val lineText = text.subSequence(lineStart, lineEnd)
+    val textPaint = paint as? TextPaint ?: TextPaint(paint)
+    val layout = StaticLayout.Builder.obtain(lineText, 0, lineText.length, textPaint, 10000).build()
+    return layout.getPrimaryHorizontal(index - lineStart)
+  }
+
+  fun leadingMarginAt(
+    text: Spanned,
+    lineStart: Int,
+  ): Int {
+    if (lineStart >= text.length) return 0
+    val spans = text.getSpans(lineStart, lineStart + 1, LeadingMarginSpan::class.java)
+    var margin = 0
+    for (span in spans) {
+      margin += span.getLeadingMargin(false)
+    }
+    return margin
+  }
+
+  /**
+   * Fills [rect] and strokes its border. [strokeInset] keeps a closed border inside [rect]
+   * (link chips); otherwise it is centered on the edge (inline code, kept for pixel parity).
+   * [path] is caller-owned scratch space to avoid per-draw allocations.
+   */
+  fun draw(
+    canvas: Canvas,
+    rect: RectF,
+    path: Path,
+    cornerRadius: Float,
+    backgroundPaint: Paint?,
+    borderPaint: Paint?,
+    isFirst: Boolean,
+    isLast: Boolean,
+    strokeInset: Boolean,
+  ) {
+    val r = minOf(maxOf(cornerRadius, 0f), minOf(rect.width(), rect.height()) / 2f)
+
+    if (backgroundPaint != null) {
+      path.reset()
+      path.addRoundRect(rect, radii(r, isFirst, isLast), Path.Direction.CW)
+      canvas.drawPath(path, backgroundPaint)
+    }
+
+    if (borderPaint == null || borderPaint.strokeWidth <= 0f) return
+
+    path.reset()
+    if (isFirst && isLast) {
+      if (strokeInset) {
+        val inset = borderPaint.strokeWidth / 2f
+        val insetRect = RectF(rect.left + inset, rect.top + inset, rect.right - inset, rect.bottom - inset)
+        path.addRoundRect(insetRect, radii(maxOf(r - inset, 0f), true, true), Path.Direction.CW)
+      } else {
+        path.addRoundRect(rect, radii(r, true, true), Path.Direction.CW)
+      }
+    } else {
+      val inset = if (strokeInset) borderPaint.strokeWidth / 2f else 0f
+      addOpenBorder(path, rect, r, inset, isFirst, isLast)
+    }
+    canvas.drawPath(path, borderPaint)
+  }
+
+  private fun addOpenBorder(
+    path: Path,
+    rect: RectF,
+    r: Float,
+    inset: Float,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) {
+    val left = rect.left + inset
+    val top = rect.top + inset
+    val right = rect.right - inset
+    val bottom = rect.bottom - inset
+
+    if (isFirst) {
+      path.moveTo(rect.right, top)
+      path.lineTo(left + r, top)
+      path.quadTo(left, top, left, top + r)
+      path.lineTo(left, bottom - r)
+      path.quadTo(left, bottom, left + r, bottom)
+      path.lineTo(rect.right, bottom)
+    } else if (isLast) {
+      path.moveTo(rect.left, top)
+      path.lineTo(right - r, top)
+      path.quadTo(right, top, right, top + r)
+      path.lineTo(right, bottom - r)
+      path.quadTo(right, bottom, right - r, bottom)
+      path.lineTo(rect.left, bottom)
+    } else {
+      path.moveTo(rect.left, top)
+      path.lineTo(rect.right, top)
+      path.moveTo(rect.left, bottom)
+      path.lineTo(rect.right, bottom)
+    }
+  }
+
+  private fun radii(
+    r: Float,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ): FloatArray {
+    val left = if (isFirst) r else 0f
+    val right = if (isLast) r else 0f
+    return floatArrayOf(left, left, right, right, right, right, left, left)
+  }
+}

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

@@ -0,0 +1,177 @@
+package com.swmansion.enriched.markdown.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LineBackgroundSpan
+import android.text.style.ReplacementSpan
+import com.swmansion.enriched.markdown.styles.LinkChipStyle
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+/**
+ * Reserves a link's `paddingHorizontal` at one outer edge. It covers one [LinkSpacers.CHAR]
+ * inserted by `LinkRenderer`: U+00A0 is line-break class GL, so a break is allowed before it
+ * after a space but never after it, and never before it after a non-space — the spacer always
+ * travels with the link's first (or last) glyph, never orphaned at a wrap.
+ *
+ * Layout-only: every text exit point strips spacers by this span ([LinkSpacers.strip]).
+ */
+class LinkSpacerSpan(
+  private val width: Float,
+) : ReplacementSpan() {
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?,
+  ): Int {
+    // Keep the line metrics of the surrounding text.
+    if (fm != null) paint.getFontMetricsInt(fm)
+    return width.roundToInt()
+  }
+
+  override fun draw(
+    canvas: Canvas,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    x: Float,
+    top: Int,
+    y: Int,
+    bottom: Int,
+    paint: Paint,
+  ) = Unit
+}
+
+object LinkSpacers {
+  const val CHAR = '\u00A0'
+
+  /** [text] without link spacers (returns [text] itself when it has none). */
+  fun strip(text: CharSequence): CharSequence {
+    if (text !is Spanned) return text
+    val spacers = text.getSpans(0, text.length, LinkSpacerSpan::class.java)
+    if (spacers.isEmpty()) return text
+    val builder = SpannableStringBuilder(text)
+    spacers
+      .map { builder.getSpanStart(it) to builder.getSpanEnd(it) }
+      .filter { (start, end) -> start in 0 until end }
+      .sortedByDescending { it.first }
+      .forEach { (start, end) -> builder.delete(start, end) }
+    return builder
+  }
+
+  /** True when [start, end) lies inside a spacer (a segment exporters must skip). */
+  fun isSpacer(
+    text: Spanned,
+    start: Int,
+    end: Int,
+  ): Boolean = end > start && text.getSpans(start, end, LinkSpacerSpan::class.java).isNotEmpty()
+}
+
+/**
+ * Paints a link chip (background + border) behind the link glyphs. One instance per link,
+ * spanning the link including its spacers, so the chip already covers `paddingHorizontal`.
+ * Vertically the chip spans the link font's ascent..descent ± `paddingVertical`; the vertical
+ * padding only bleeds into the surrounding line spacing and never changes the line box.
+ */
+class LinkChipBackgroundSpan(
+  val chip: LinkChipStyle,
+) : LineBackgroundSpan {
+  private val rect = RectF()
+  private val path = Path()
+  private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+  private val borderPaint =
+    Paint(Paint.ANTI_ALIAS_FLAG).apply {
+      style = Paint.Style.STROKE
+      strokeJoin = Paint.Join.ROUND
+      strokeCap = Paint.Cap.ROUND
+    }
+
+  override fun drawBackground(
+    canvas: Canvas,
+    p: Paint,
+    left: Int,
+    right: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    lineNum: Int,
+  ) {
+    if (!chip.isVisible || text !is Spanned) return
+
+    val spanStart = text.getSpanStart(this)
+    val spanEnd = text.getSpanEnd(this)
+    if (spanStart !in 0 until spanEnd || spanEnd <= start || spanStart >= end) return
+
+    val isFirst = spanStart >= start
+    val isLast = spanEnd <= end
+
+    val leadingMargin = InlineChipPainter.leadingMarginAt(text, start)
+    val fragmentStart = max(spanStart, start)
+    val fragmentEnd = trimTrailingWhitespace(text, fragmentStart, min(spanEnd, end))
+    val startX = InlineChipPainter.horizontalOffset(text, start, end, fragmentStart, p, leadingMargin) + left
+    val endX = InlineChipPainter.horizontalOffset(text, start, end, fragmentEnd, p, leadingMargin) + left
+
+    val (ascent, descent) = linkFontMetrics(text, spanStart, spanEnd, p)
+    rect.set(
+      min(startX, endX),
+      baseline + ascent - chip.paddingVertical,
+      max(startX, endX),
+      baseline + descent + chip.paddingVertical,
+    )
+
+    backgroundPaint.color = chip.backgroundColor
+    borderPaint.color = chip.borderColor
+    borderPaint.strokeWidth = chip.borderWidth
+    InlineChipPainter.draw(
+      canvas,
+      rect,
+      path,
+      chip.borderRadius,
+      backgroundPaint.takeIf { android.graphics.Color.alpha(chip.backgroundColor) > 0 },
+      borderPaint.takeIf { android.graphics.Color.alpha(chip.borderColor) > 0 && chip.borderWidth > 0f },
+      isFirst,
+      isLast,
+      strokeInset = true,
+    )
+  }
+
+  companion object {
+    /** A wrapped fragment ends before the whitespace the line break hangs. */
+    fun trimTrailingWhitespace(
+      text: CharSequence,
+      start: Int,
+      end: Int,
+    ): Int {
+      var index = end
+      while (index > start && text[index - 1] != LinkSpacers.CHAR && text[index - 1].isWhitespace()) index--
+      return index
+    }
+
+    /**
+     * Ascent/descent of the link's own font: [LinkSpan] sets its size and typeface at draw
+     * time only, so the base paint [p] alone would report the paragraph's metrics.
+     */
+    fun linkFontMetrics(
+      text: Spanned,
+      spanStart: Int,
+      spanEnd: Int,
+      p: Paint,
+    ): Pair<Float, Float> {
+      val paint = TextPaint(p)
+      text.getSpans(spanStart, spanEnd, LinkSpan::class.java).firstOrNull()?.updateDrawState(paint)
+      val metrics = paint.fontMetrics
+      return metrics.ascent to metrics.descent
+    }
+  }
+}

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

@@ -1,7 +1,6 @@
 package com.swmansion.enriched.markdown.spans
 
 import android.content.Context
-import android.graphics.Color
 import android.text.TextPaint
 import android.text.style.ClickableSpan
 import android.view.View
@@ -57,10 +56,6 @@ class LinkSpan(
 
     textPaint.color = variant?.color ?: styleCache.linkColor
     textPaint.isUnderlineText = variant?.underline ?: styleCache.linkUnderline
-
-    val backgroundColor = variant?.backgroundColor ?: styleCache.linkBackgroundColor
-    if (Color.alpha(backgroundColor) > 0) {
-      textPaint.bgColor = backgroundColor
-    }
+    // The background is painted as a chip by LinkChipBackgroundSpan.
   }
 }

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

@@ -7,6 +7,7 @@ data class LinkStyle(
   val color: Int,
   val underline: Boolean,
   val backgroundColor: Int,
+  val chip: LinkChipStyle,
 ) {
   companion object {
     fun fromReadableMap(
@@ -17,7 +18,41 @@ data class LinkStyle(
       val color = parser.parseColor(map, "color")
       val underline = map.getBoolean("underline")
       val backgroundColor = parser.parseColor(map, "backgroundColor")
-      return LinkStyle(fontFamily, color, underline, backgroundColor)
+      return LinkStyle(fontFamily, color, underline, backgroundColor, LinkChipStyle.fromReadableMap(map, parser, backgroundColor))
     }
   }
 }
+
+/**
+ * Chip ("box") properties of a link, in pixels. Never inherited from the base link
+ * style by variants — the JS normalizer fills missing values with 0 / transparent.
+ */
+data class LinkChipStyle(
+  val backgroundColor: Int,
+  val borderColor: Int,
+  val borderRadius: Float,
+  val borderWidth: Float,
+  val paddingHorizontal: Float,
+  val paddingVertical: Float,
+) {
+  val isVisible: Boolean
+    get() =
+      android.graphics.Color.alpha(backgroundColor) > 0 ||
+        (android.graphics.Color.alpha(borderColor) > 0 && borderWidth > 0f)
+
+  companion object {
+    fun fromReadableMap(
+      map: ReadableMap,
+      parser: StyleParser,
+      backgroundColor: Int,
+    ): LinkChipStyle =
+      LinkChipStyle(
+        backgroundColor = backgroundColor,
+        borderColor = parser.parseOptionalColor(map, "borderColor") ?: 0,
+        borderRadius = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderRadius").toFloat()),
+        borderWidth = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "borderWidth").toFloat()),
+        paddingHorizontal = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingHorizontal").toFloat()),
+        paddingVertical = parser.toPixelFromDIP(parser.parseOptionalDouble(map, "paddingVertical").toFloat()),
+      )
+  }
+}

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

@@ -13,17 +13,21 @@ data class LinkVariantEntry(
   val color: Int,
   val underline: Boolean,
   val backgroundColor: Int,
+  val chip: LinkChipStyle,
 ) {
   companion object {
     fun fromReadableMap(
       map: ReadableMap,
       parser: StyleParser,
-    ): LinkVariantEntry =
-      LinkVariantEntry(
+    ): LinkVariantEntry {
+      val backgroundColor = parser.parseColor(map, "backgroundColor")
+      return LinkVariantEntry(
         pattern = map.getString("pattern") ?: "",
         color = parser.parseColor(map, "color"),
         underline = parser.parseBoolean(map, "underline"),
-        backgroundColor = parser.parseColor(map, "backgroundColor"),
+        backgroundColor = backgroundColor,
+        chip = LinkChipStyle.fromReadableMap(map, parser, backgroundColor),
       )
+    }
   }
 }

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

@@ -8,11 +8,15 @@ import com.swmansion.enriched.markdown.accessibility.AccessibilityLabels
 import com.swmansion.enriched.markdown.events.ContextMenuItemPressEvent
 import com.swmansion.enriched.markdown.events.CopyPressEvent
 import com.swmansion.enriched.markdown.events.CopyRequestEvent
+import com.swmansion.enriched.markdown.events.LinkLayoutEvent
 import com.swmansion.enriched.markdown.events.LinkLongPressEvent
 import com.swmansion.enriched.markdown.events.LinkPressEvent
+import com.swmansion.enriched.markdown.events.SelectionChangeEvent
 import com.swmansion.enriched.markdown.events.TaskListItemPressEvent
 import com.swmansion.enriched.markdown.parser.Md4cFlags
+import com.swmansion.enriched.markdown.utils.text.view.LinkLayoutFragment
 import com.swmansion.enriched.markdown.utils.text.view.SelectionMenuConfig
+import com.swmansion.enriched.markdown.utils.text.view.SelectionSnapshot
 
 fun markdownEventTypeConstants(): MutableMap<String, Any> {
   val map = mutableMapOf<String, Any>()
@@ -27,9 +31,33 @@ fun markdownEventTypeConstants(): MutableMap<String, Any> {
     mapOf("registrationName" to CopyRequestEvent.EVENT_NAME)
   map[ContextMenuItemPressEvent.EVENT_NAME] =
     mapOf("registrationName" to ContextMenuItemPressEvent.EVENT_NAME)
+  map[LinkLayoutEvent.EVENT_NAME] =
+    mapOf("registrationName" to LinkLayoutEvent.EVENT_NAME)
+  map[SelectionChangeEvent.EVENT_NAME] =
+    mapOf("registrationName" to SelectionChangeEvent.EVENT_NAME)
   return map
 }
 
+fun emitLinkLayout(
+  view: View,
+  fragments: List<LinkLayoutFragment>,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(LinkLayoutEvent(surfaceId, view.id, fragments))
+}
+
+fun emitSelectionChange(
+  view: View,
+  snapshot: SelectionSnapshot,
+) {
+  val context = view.context as com.facebook.react.bridge.ReactContext
+  val surfaceId = UIManagerHelper.getSurfaceId(context)
+  val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+  eventDispatcher?.dispatchEvent(SelectionChangeEvent(surfaceId, view.id, snapshot))
+}
+
 fun emitLinkPress(
   view: View,
   url: String,

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/conversion/HTMLGenerator.kt

@@ -12,6 +12,7 @@ import com.swmansion.enriched.markdown.spans.EmphasisSpan
 import com.swmansion.enriched.markdown.spans.HeadingSpan
 import com.swmansion.enriched.markdown.spans.HighlightSpan
 import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacers
 import com.swmansion.enriched.markdown.spans.LinkSpan
 import com.swmansion.enriched.markdown.spans.OrderedListSpan
 import com.swmansion.enriched.markdown.spans.StrikethroughSpan
@@ -676,7 +677,7 @@ object HTMLGenerator {
           val segmentEnd = minOf(text.nextSpanTransition(i, end, Any::class.java), end)
           val segmentText = text.subSequence(i, segmentEnd).toString()
 
-          if (segmentText.isNotEmpty() && segmentText != "\n") {
+          if (segmentText.isNotEmpty() && segmentText != "\n" && !LinkSpacers.isSpacer(text, i, segmentEnd)) {
             appendStyledSegment(html, text, i, segmentEnd, segmentText, styles, isCodeBlock)
           }
           i = segmentEnd

package/android/src/main/java/com/swmansion/enriched/markdown/utils/text/conversion/MarkdownExtractor.kt

@@ -12,6 +12,7 @@ import com.swmansion.enriched.markdown.spans.EmphasisSpan
 import com.swmansion.enriched.markdown.spans.HeadingSpan
 import com.swmansion.enriched.markdown.spans.HighlightSpan
 import com.swmansion.enriched.markdown.spans.ImageSpan
+import com.swmansion.enriched.markdown.spans.LinkSpacers
 import com.swmansion.enriched.markdown.spans.LinkSpan
 import com.swmansion.enriched.markdown.spans.OrderedListSpan
 import com.swmansion.enriched.markdown.spans.StrikethroughSpan
@@ -55,6 +56,11 @@ object MarkdownExtractor {
     var i = start
     while (i < end) {
       val nextTransition = spannable.nextSpanTransition(i, end, Any::class.java)
+      // Link spacers only reserve layout space for chip padding.
+      if (LinkSpacers.isSpacer(spannable, i, nextTransition)) {
+        i = nextTransition
+        continue
+      }
       val segmentText = spannable.subSequence(i, nextTransition).toString()
 
       val handled =