react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.10

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

@@ -9,29 +9,44 @@ import android.util.AttributeSet
 import android.util.Log
 import android.view.View
 import android.widget.FrameLayout
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.StateWrapper
 import com.swmansion.enriched.markdown.accessibility.AccessibilityLabels
 import com.swmansion.enriched.markdown.parser.Md4cFlags
 import com.swmansion.enriched.markdown.parser.Parser
 import com.swmansion.enriched.markdown.spoiler.SpoilerOverlay
 import com.swmansion.enriched.markdown.styles.StyleConfig
 import com.swmansion.enriched.markdown.utils.common.BreakStrategyUtils
+import com.swmansion.enriched.markdown.utils.common.CodeBlockStreamingMode
 import com.swmansion.enriched.markdown.utils.common.FeatureFlags
 import com.swmansion.enriched.markdown.utils.common.MarkdownSegmentRenderer
 import com.swmansion.enriched.markdown.utils.common.RenderedSegment
 import com.swmansion.enriched.markdown.utils.common.SegmentReconciler
 import com.swmansion.enriched.markdown.utils.common.StreamingMarkdownFilter
 import com.swmansion.enriched.markdown.utils.common.TableStreamingMode
+import com.swmansion.enriched.markdown.utils.common.emitLinkLayout
+import com.swmansion.enriched.markdown.utils.common.emitSelectionChange
 import com.swmansion.enriched.markdown.utils.common.isReducedMotionEnabled
 import com.swmansion.enriched.markdown.utils.common.splitASTIntoSegments
 import com.swmansion.enriched.markdown.utils.text.TailFadeInAnimator
+import com.swmansion.enriched.markdown.utils.text.view.LinkLayoutCollector
+import com.swmansion.enriched.markdown.utils.text.view.LinkLayoutFragment
+import com.swmansion.enriched.markdown.utils.text.view.SelectionChangeReporter
 import com.swmansion.enriched.markdown.utils.text.view.SelectionMenuConfig
+import com.swmansion.enriched.markdown.utils.text.view.SelectionRect
+import com.swmansion.enriched.markdown.utils.text.view.SelectionSnapshot
 import com.swmansion.enriched.markdown.utils.text.view.applySelectionColors
+import com.swmansion.enriched.markdown.utils.text.view.currentTextSelection
+import com.swmansion.enriched.markdown.views.BlockMenuOptions
 import com.swmansion.enriched.markdown.views.BlockSegmentView
+import com.swmansion.enriched.markdown.views.CodeBlockContainerView
 import com.swmansion.enriched.markdown.views.TableContainerView
 import java.util.EnumSet
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
+import kotlin.math.ceil
+import kotlin.math.max
 
 class EnrichedMarkdown
   @JvmOverloads
@@ -62,7 +77,12 @@ class EnrichedMarkdown
     private val dirtyFlags = EnumSet.noneOf(DirtyFlag::class.java)
     var streamingAnimation: Boolean = false
 
+    // used to force a Yoga re-measure when a block image resolves its box height
+    var stateWrapper: StateWrapper? = null
+    private var forceHeightRecalculationCounter = 0
+
     var tableStreamingMode: TableStreamingMode = TableStreamingMode.PROGRESSIVE
+    var codeBlockStreamingMode: CodeBlockStreamingMode = CodeBlockStreamingMode.PROGRESSIVE
     private var renderPending: Boolean = false
 
     var currentMarkdown: String = ""
@@ -79,18 +99,39 @@ class EnrichedMarkdown
     private var allowFontScaling: Boolean = true
     private var maxFontSizeMultiplier: Float = 0f
     private var allowTrailingMargin: Boolean = false
+    private var imageRequestHeaders: Map<String, String> = emptyMap()
     private var selectable: Boolean = true
+    private var contextMenuHidden: Boolean = false
     private var selectionColor: Int? = null
     private var selectionHandleColor: Int? = null
     private var selectionMenuConfig = SelectionMenuConfig()
     private var accessibilityLabels = AccessibilityLabels()
     private var textBreakStrategy: String = BreakStrategyUtils.DEFAULT_STRATEGY
+    private var linkLayoutEnabled = false
+    private var lastLinkLayout: List<LinkLayoutFragment>? = null
+
+    // At most one segment holds a selection; a new one clears the previous.
+    private var selectionOwner: EnrichedMarkdownInternalText? = null
+
+    // A block long-pressed while contextMenuHidden is on, reported as the selection.
+    private class ActiveBlock(
+      val view: View,
+      val source: String,
+      val markdown: String,
+      val text: String,
+    )
+
+    private var activeBlock: ActiveBlock? = null
+    private val selectionReporter =
+      SelectionChangeReporter(this, ::selectionSnapshot) { snapshot -> emitSelectionChange(this, snapshot) }
 
     private var onLinkPressCallback: ((String) -> Unit)? = null
     private var onLinkLongPressCallback: ((String) -> Unit)? = null
     private var onTaskListItemPressCallback: ((Int, Boolean, String) -> Unit)? = null
+    private var onCopyPressCallback: ((String, String) -> Unit)? = null
     private var contextMenuItemTexts: List<String> = emptyList()
     var onContextMenuItemPressCallback: ((itemText: String, selectedText: String, selectionStart: Int, selectionEnd: Int) -> Unit)? = null
+    var onCopyRequestCallback: ((source: String, markdown: String, text: String, whole: Boolean) -> Unit)? = null
     var spoilerOverlay: SpoilerOverlay = SpoilerOverlay.PARTICLES
       set(value) {
         if (field == value) return
@@ -99,6 +140,14 @@ class EnrichedMarkdown
           it.spoilerOverlay = value
         }
       }
+    var enableTaskListItemToggle: Boolean = true
+      set(value) {
+        if (field == value) return
+        field = value
+        segmentViews.filterIsInstance<EnrichedMarkdownInternalText>().forEach {
+          it.enableTaskListItemToggle = value
+        }
+      }
 
     fun setMarkdownContent(markdown: String) {
       if (currentMarkdown == markdown) return
@@ -109,6 +158,7 @@ class EnrichedMarkdown
     fun setMarkdownStyle(style: ReadableMap?) {
       markdownStyleMap = style
       val newConfig = style?.let { StyleConfig(it, context, allowFontScaling, maxFontSizeMultiplier) }
+      newConfig?.imageRequestHeaders = imageRequestHeaders
       if (markdownStyle == newConfig) return
       markdownStyle = newConfig
       dirtyFlags += DirtyFlag.RECREATE_SEGMENTS
@@ -116,8 +166,18 @@ class EnrichedMarkdown
       renderPending = true
     }
 
+    fun setImageRequestHeaders(headers: Map<String, String>) {
+      if (imageRequestHeaders == headers) return
+      imageRequestHeaders = headers
+      markdownStyle?.imageRequestHeaders = headers
+      dirtyFlags += DirtyFlag.RECREATE_SEGMENTS
+      renderPending = true
+    }
+
     fun commitProps() {
       MeasurementStore.updateStreamingTableMode(id, tableStreamingMode)
+      MeasurementStore.updateStreamingCodeBlockMode(id, codeBlockStreamingMode)
+      MeasurementStore.updateFontScalingSettings(id, allowFontScaling, maxFontSizeMultiplier)
       if (renderPending) {
         renderPending = false
         scheduleRenderIfNeeded()
@@ -146,6 +206,7 @@ class EnrichedMarkdown
     fun setAllowFontScaling(allow: Boolean) {
       if (allowFontScaling == allow) return
       allowFontScaling = allow
+      MeasurementStore.updateFontScalingSettings(id, allowFontScaling, maxFontSizeMultiplier)
       recreateStyleConfig()
       dirtyFlags += DirtyFlag.RECREATE_SEGMENTS
       dirtyFlags += DirtyFlag.FORCE_HEIGHT
@@ -155,6 +216,7 @@ class EnrichedMarkdown
     fun setMaxFontSizeMultiplier(multiplier: Float) {
       if (maxFontSizeMultiplier == multiplier) return
       maxFontSizeMultiplier = multiplier
+      MeasurementStore.updateFontScalingSettings(id, allowFontScaling, maxFontSizeMultiplier)
       recreateStyleConfig()
       dirtyFlags += DirtyFlag.RECREATE_SEGMENTS
       dirtyFlags += DirtyFlag.FORCE_HEIGHT
@@ -177,6 +239,42 @@ class EnrichedMarkdown
       }
     }
 
+    fun setContextMenuHidden(value: Boolean) {
+      if (contextMenuHidden == value) return
+      contextMenuHidden = value
+      applyContextMenuHiddenToSegments()
+    }
+
+    /**
+     * Fans the flag out to every segment that owns a copy menu: text segments
+     * (floating ActionMode toolbar), tables, code blocks and math blocks (all use
+     * their own long-press popup, so none is covered by the ActionMode callback).
+     */
+    private fun applyContextMenuHiddenToSegments() {
+      segmentViews.forEach { view ->
+        when {
+          view is EnrichedMarkdownInternalText -> view.contextMenuHidden = contextMenuHidden
+          view is TableContainerView -> view.contextMenuHidden = contextMenuHidden
+          view is CodeBlockContainerView -> view.contextMenuHidden = contextMenuHidden
+          isMathContainerView(view) -> setMathContextMenuHidden(view)
+        }
+      }
+    }
+
+    /**
+     * MathContainerView lives in the optional `math` source set, so it is only
+     * reachable reflectively. The Kotlin `var` compiles to a setter taking a
+     * primitive boolean — `Boolean::class.java` would resolve to
+     * `java.lang.Boolean` and silently miss.
+     */
+    private fun setMathContextMenuHidden(view: View) {
+      runCatching {
+        view.javaClass
+          .getMethod("setContextMenuHidden", Boolean::class.javaPrimitiveType)
+          .invoke(view, contextMenuHidden)
+      }.onFailure { Log.e(TAG, "Failed to set contextMenuHidden on math view", it) }
+    }
+
     fun setSelectionColor(color: Int?) {
       if (selectionColor == color) return
       selectionColor = color
@@ -221,6 +319,10 @@ class EnrichedMarkdown
       onTaskListItemPressCallback = callback
     }
 
+    fun setOnCopyPressCallback(callback: ((code: String, language: String) -> Unit)?) {
+      onCopyPressCallback = callback
+    }
+
     fun setContextMenuItems(items: List<String>) {
       contextMenuItemTexts = items
       segmentViews.filterIsInstance<EnrichedMarkdownInternalText>().forEach {
@@ -234,8 +336,8 @@ class EnrichedMarkdown
       segmentViews.filterIsInstance<EnrichedMarkdownInternalText>().forEach {
         it.selectionMenuConfig = config
       }
-      // Table and math views cache the copy labels, so re-push them on update
-      // (e.g. a language change without a remount) to avoid stale labels.
+      // Block views cache the copy labels and menu options, so re-push them on
+      // update (e.g. a language change without a remount) to avoid stale values.
       pushCopyLabelsToBlockSegments()
     }
 
@@ -247,6 +349,13 @@ class EnrichedMarkdown
           view is TableContainerView -> {
             view.copyLabel = copyLabel
             view.copyAsMarkdownLabel = copyAsMarkdownLabel
+            view.menuOptions = blockMenuOptions("table")
+          }
+
+          view is CodeBlockContainerView -> {
+            view.copyLabel = copyLabel
+            view.copyAsMarkdownLabel = copyAsMarkdownLabel
+            view.menuOptions = blockMenuOptions("code")
           }
 
           isMathContainerView(view) -> {
@@ -255,6 +364,9 @@ class EnrichedMarkdown
               view.javaClass
                 .getMethod("setCopyAsMarkdownLabel", String::class.java)
                 .invoke(view, copyAsMarkdownLabel)
+              view.javaClass
+                .getMethod("setMenuOptions", BlockMenuOptions::class.java)
+                .invoke(view, blockMenuOptions("math"))
             }
           }
         }
@@ -281,6 +393,22 @@ class EnrichedMarkdown
       }
     }
 
+    private fun blockMenuOptions(source: String) =
+      BlockMenuOptions.from(selectionMenuConfig) { markdown, text ->
+        onCopyRequestCallback?.invoke(source, markdown, text, true)
+      }
+
+    // Segments only see their own text, so a selection is the whole component
+    // only when it spans the sole segment; the markdown is then the original.
+    private fun forwardSegmentCopyRequest(
+      markdown: String,
+      text: String,
+      fullSelection: Boolean,
+    ) {
+      val whole = fullSelection && segmentViews.size == 1 && currentMarkdown.isNotEmpty()
+      onCopyRequestCallback?.invoke("selection", if (whole) currentMarkdown else markdown, text, whole)
+    }
+
     private fun forwardContextMenuItemPress(
       itemText: String,
       selectedText: String,
@@ -290,9 +418,84 @@ class EnrichedMarkdown
       onContextMenuItemPressCallback?.invoke(itemText, selectedText, selectionStart, selectionEnd)
     }
 
+    fun setEmitSelectionChange(enabled: Boolean) {
+      selectionReporter.enabled = enabled
+    }
+
+    /** Clears the selection of every segment (and any active block) and reports `active: false`. */
+    fun clearSelection() {
+      val owner = selectionOwner
+      selectionOwner = null
+      activeBlock = null
+      owner?.clearSelection()
+      selectionReporter.flushNow()
+    }
+
+    private fun onSegmentSelectionChanged(
+      view: EnrichedMarkdownInternalText,
+      hasSelection: Boolean,
+    ) {
+      if (hasSelection) {
+        // Take ownership first so the previous owner's own "cleared" callback is ignored.
+        val previous = selectionOwner
+        selectionOwner = view
+        activeBlock = null
+        if (previous !== view) previous?.clearSelection()
+        selectionReporter.schedule()
+      } else if (selectionOwner === view) {
+        selectionReporter.onSelectionChanged(false)
+      }
+    }
+
+    private fun onBlockMenuSuppressed(
+      view: View,
+      source: String,
+      markdown: String,
+      text: String,
+    ) {
+      if (!selectionReporter.enabled) return
+      val previous = selectionOwner
+      selectionOwner = null
+      previous?.clearSelection()
+      activeBlock = ActiveBlock(view, source, markdown, text)
+      selectionReporter.forgetLastReported()
+      selectionReporter.flushNow()
+    }
+
+    private fun selectionSnapshot(): SelectionSnapshot {
+      activeBlock?.let { block ->
+        if (block.view.parent !== this) return SelectionSnapshot.INACTIVE
+        val rect =
+          SelectionRect.fromPx(
+            block.view.left.toFloat(),
+            block.view.top.toFloat(),
+            block.view.right.toFloat(),
+            block.view.bottom.toFloat(),
+          )
+        return SelectionSnapshot.block(block.source, block.markdown, block.text, rect)
+      }
+      val owner = selectionOwner?.takeIf { it.parent === this } ?: return SelectionSnapshot.INACTIVE
+      val selection = owner.currentTextSelection(owner.left, owner.top) ?: return SelectionSnapshot.INACTIVE
+      // Same rule as forwardSegmentCopyRequest.
+      val whole = selection.fullSelection && segmentViews.size == 1 && currentMarkdown.isNotEmpty()
+      return SelectionSnapshot(
+        active = true,
+        source = "selection",
+        text = selection.text,
+        markdown = if (whole) currentMarkdown else selection.markdown,
+        whole = whole,
+        rect = selection.rect,
+        startRect = selection.startRect,
+        endRect = selection.endRect,
+      )
+    }
+
     private fun recreateStyleConfig() {
       markdownStyleMap?.let {
-        markdownStyle = StyleConfig(it, context, allowFontScaling, maxFontSizeMultiplier)
+        markdownStyle =
+          StyleConfig(it, context, allowFontScaling, maxFontSizeMultiplier).also { config ->
+            config.imageRequestHeaders = imageRequestHeaders
+          }
       }
     }
 
@@ -305,26 +508,29 @@ class EnrichedMarkdown
       val markdown = currentMarkdown.takeIf { it.isNotEmpty() } ?: return
       val isStreaming = streamingAnimation
       val tableMode = tableStreamingMode
+      val codeBlockMode = codeBlockStreamingMode
 
       val renderId = ++currentRenderId
 
       executor.execute {
         try {
-          val renderableMarkdown =
+          val filtered =
             if (isStreaming) {
-              StreamingMarkdownFilter.renderableMarkdownForStreaming(markdown, tableMode)
+              StreamingMarkdownFilter.renderableMarkdownForStreaming(markdown, tableMode, codeBlockMode)
             } else {
-              markdown
+              null
             }
+          val renderableMarkdown = filtered?.markdown ?: markdown
+          val hasPendingCodeBlock = filtered?.endsInsideOpenCodeFence ?: false
 
           if (renderableMarkdown.isEmpty()) {
-            postToMain(renderId) { applyRenderedSegments(emptyList(), style) }
+            postToMain(renderId) { applyRenderedSegments(emptyList(), style, false) }
             return@execute
           }
 
           val ast =
             parser.parseMarkdown(renderableMarkdown, md4cFlags) ?: run {
-              postToMain(renderId) { applyRenderedSegments(emptyList(), style) }
+              postToMain(renderId) { applyRenderedSegments(emptyList(), style, false) }
               return@execute
             }
 
@@ -338,18 +544,25 @@ class EnrichedMarkdown
               onLinkLongPressCallback,
             )
 
-          postToMain(renderId) { applyRenderedSegments(renderedSegments, style) }
+          postToMain(renderId) { applyRenderedSegments(renderedSegments, style, hasPendingCodeBlock) }
         } catch (e: Exception) {
           Log.e(TAG, "Render failed", e)
-          postToMain(renderId) { applyRenderedSegments(emptyList(), style) }
+          postToMain(renderId) { applyRenderedSegments(emptyList(), style, false) }
         }
       }
     }
 
+    // Trailing code block whose closing fence hasn't streamed in yet, if any.
+    private var pendingCodeBlockSegment: RenderedSegment.CodeBlock? = null
+
     private fun applyRenderedSegments(
       renderedSegments: List<RenderedSegment>,
       style: StyleConfig,
+      hasPendingCodeBlock: Boolean,
     ) {
+      pendingCodeBlockSegment =
+        if (hasPendingCodeBlock) renderedSegments.lastOrNull() as? RenderedSegment.CodeBlock else null
+
       val reset = DirtyFlag.RECREATE_SEGMENTS in dirtyFlags
       val forceHeight = DirtyFlag.FORCE_HEIGHT in dirtyFlags
       dirtyFlags.clear()
@@ -377,6 +590,17 @@ class EnrichedMarkdown
       segmentSignatures.clear()
       segmentSignatures.addAll(result.signatures)
 
+      if (selectionOwner?.let { owner -> segmentViews.none { it === owner } } == true) selectionOwner = null
+      if (activeBlock?.let { block -> segmentViews.none { it === block.view } } == true) activeBlock = null
+
+      // A just-closed block has unchanged content, so the reconciler reuses it
+      // without an update; sync pending here to trigger its deferred highlight.
+      segmentViews.forEachIndexed { index, view ->
+        if (view is CodeBlockContainerView) {
+          view.pending = pendingCodeBlockSegment != null && index == segmentViews.size - 1
+        }
+      }
+
       val topologyChanged = result.viewsToAttach.isNotEmpty() || result.viewsToRemove.isNotEmpty()
 
       if (width > 0) {
@@ -399,6 +623,7 @@ class EnrichedMarkdown
         is RenderedSegment.Text -> view is EnrichedMarkdownInternalText
         is RenderedSegment.Table -> view is TableContainerView
         is RenderedSegment.Math -> isMathContainerView(view)
+        is RenderedSegment.CodeBlock -> view is CodeBlockContainerView
       }
 
     private fun isMathContainerView(view: View): Boolean = mathContainerClass?.isInstance(view) == true
@@ -411,6 +636,7 @@ class EnrichedMarkdown
         is RenderedSegment.Text -> createTextView(segment)
         is RenderedSegment.Table -> createTableView(segment, style)
         is RenderedSegment.Math -> createMathView(segment, style)
+        is RenderedSegment.CodeBlock -> createCodeBlockView(segment, style)
       }
 
     private fun updateSegmentView(
@@ -441,6 +667,13 @@ class EnrichedMarkdown
             ?.getMethod("applyLatex", String::class.java)
             ?.invoke(view, segment.latex)
         }
+
+        is RenderedSegment.CodeBlock -> {
+          (view as CodeBlockContainerView).apply {
+            pending = segment === pendingCodeBlockSegment
+            applyCodeBlockNode(segment.node)
+          }
+        }
       }
     }
 
@@ -451,7 +684,7 @@ class EnrichedMarkdown
       if (!streamingAnimation) return
       when (segment) {
         is RenderedSegment.Text -> animateTextViewTail(view as EnrichedMarkdownInternalText, 0)
-        is RenderedSegment.Table, is RenderedSegment.Math -> animateBlockViewFadeIn(view)
+        is RenderedSegment.Table, is RenderedSegment.Math, is RenderedSegment.CodeBlock -> animateBlockViewFadeIn(view)
       }
     }
 
@@ -479,9 +712,12 @@ class EnrichedMarkdown
     private fun createTextView(segment: RenderedSegment.Text) =
       EnrichedMarkdownInternalText(context).apply {
         spoilerOverlay = this@EnrichedMarkdown.spoilerOverlay
+        enableTaskListItemToggle = this@EnrichedMarkdown.enableTaskListItemToggle
         selectionMenuConfig = this@EnrichedMarkdown.selectionMenuConfig
+        contextMenuHidden = this@EnrichedMarkdown.contextMenuHidden
         accessibilityLabels = this@EnrichedMarkdown.accessibilityLabels
         setIsSelectable(selectable)
+        markdownStyle?.paragraphStyle?.fontSize?.let { setTextSize(android.util.TypedValue.COMPLEX_UNIT_PX, it) }
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
           breakStrategy = BreakStrategyUtils.resolveBreakStrategy(textBreakStrategy)
         }
@@ -495,6 +731,8 @@ class EnrichedMarkdown
         onTaskListItemPressCallback = { taskIndex, checked, itemText ->
           this@EnrichedMarkdown.onTaskListItemPressCallback?.invoke(taskIndex, checked, itemText)
         }
+        onCopyRequest = ::forwardSegmentCopyRequest
+        onSelectionChangedCallback = ::onSegmentSelectionChanged
 
         if (contextMenuItemTexts.isNotEmpty()) {
           setContextMenuItems(contextMenuItemTexts, ::forwardContextMenuItemPress)
@@ -514,9 +752,28 @@ class EnrichedMarkdown
       onLinkLongPress = onLinkLongPressCallback
       copyLabel = this@EnrichedMarkdown.selectionMenuConfig.copyLabel
       copyAsMarkdownLabel = this@EnrichedMarkdown.selectionMenuConfig.copyAsMarkdownLabel
+      contextMenuHidden = this@EnrichedMarkdown.contextMenuHidden
+      menuOptions = blockMenuOptions("table")
+      onMenuSuppressed = { markdown, text -> onBlockMenuSuppressed(this, "table", markdown, text) }
       applyTableNode(segment.node)
     }
 
+    private fun createCodeBlockView(
+      segment: RenderedSegment.CodeBlock,
+      style: StyleConfig,
+    ) = CodeBlockContainerView(context, style).apply {
+      copyLabel = this@EnrichedMarkdown.selectionMenuConfig.copyLabel
+      copyAsMarkdownLabel = this@EnrichedMarkdown.selectionMenuConfig.copyAsMarkdownLabel
+      contextMenuHidden = this@EnrichedMarkdown.contextMenuHidden
+      menuOptions = blockMenuOptions("code")
+      onMenuSuppressed = { markdown, text -> onBlockMenuSuppressed(this, "code", markdown, text) }
+      onCopyPress = { code, language ->
+        this@EnrichedMarkdown.onCopyPressCallback?.invoke(code, language)
+      }
+      pending = segment === pendingCodeBlockSegment
+      applyCodeBlockNode(segment.node)
+    }
+
     private fun createMathView(
       segment: RenderedSegment.Math,
       style: StyleConfig,
@@ -539,6 +796,16 @@ class EnrichedMarkdown
         resolvedClass
           .getMethod("setCopyAsMarkdownLabel", String::class.java)
           .invoke(view, selectionMenuConfig.copyAsMarkdownLabel)
+        resolvedClass
+          .getMethod("setMenuOptions", BlockMenuOptions::class.java)
+          .invoke(view, blockMenuOptions("math"))
+        setMathContextMenuHidden(view)
+        val onMenuSuppressed: (String, String) -> Unit = { markdown, text ->
+          onBlockMenuSuppressed(view, "math", markdown, text)
+        }
+        runCatching {
+          resolvedClass.getMethod("setOnMenuSuppressed", Function2::class.java).invoke(view, onMenuSuppressed)
+        }.onFailure { Log.e(TAG, "Failed to set onMenuSuppressed on math view", it) }
         resolvedClass.getMethod("applyLatex", String::class.java).invoke(view, segment.latex)
         view
       } catch (e: Exception) {
@@ -566,10 +833,31 @@ class EnrichedMarkdown
       layoutSegments()
     }
 
+    fun onImageLayoutChanged() {
+      if (width > 0) {
+        layoutSegments()
+        requestLayout()
+      }
+      MeasurementStore.invalidate(id)
+      val wrapper = stateWrapper ?: return
+      val state = Arguments.createMap()
+      state.putInt("forceHeightRecalculationCounter", ++forceHeightRecalculationCounter)
+      wrapper.updateState(state)
+    }
+
     private fun layoutSegments() {
       val containerWidth = width
       if (containerWidth <= 0) return
 
+      val needsOverhang =
+        segmentViews.any { view ->
+          view is TableContainerView &&
+            ceil(view.tableStyle.horizontalOverflow.toDouble()).toInt() > 0
+        }
+      if (clipChildren == needsOverhang) {
+        clipChildren = !needsOverhang
+      }
+
       var currentY = 0
       val lastIndex = segmentViews.lastIndex
       val widthSpec = MeasureSpec.makeMeasureSpec(containerWidth, MeasureSpec.EXACTLY)
@@ -580,15 +868,64 @@ class EnrichedMarkdown
         val shouldAddBottomMargin = index != lastIndex || allowTrailingMargin
 
         currentY += segment?.segmentMarginTop ?: 0
-        view.measure(widthSpec, heightSpec)
 
-        view.layout(0, currentY, containerWidth, currentY + view.measuredHeight)
+        val overhang =
+          if (view is TableContainerView) {
+            max(ceil(view.tableStyle.horizontalOverflow.toDouble()).toInt(), 0)
+          } else {
+            0
+          }
+
+        if (overhang > 0) {
+          val extendedWidth = containerWidth + overhang * 2
+          val extWidthSpec = MeasureSpec.makeMeasureSpec(extendedWidth, MeasureSpec.EXACTLY)
+          view.measure(extWidthSpec, heightSpec)
+          view.layout(-overhang, currentY, containerWidth + overhang, currentY + view.measuredHeight)
+        } else {
+          view.measure(widthSpec, heightSpec)
+          view.layout(0, currentY, containerWidth, currentY + view.measuredHeight)
+        }
         currentY += view.measuredHeight
 
         if (shouldAddBottomMargin) {
           currentY += segment?.segmentMarginBottom ?: 0
         }
       }
+
+      emitLinkLayoutIfNeeded()
+      // Segments may have moved or been replaced; re-read the selection (deduplicated).
+      if (selectionOwner != null || activeBlock != null) selectionReporter.schedule() else selectionReporter.flushNow()
+    }
+
+    fun setEmitLinkLayout(enabled: Boolean) {
+      if (linkLayoutEnabled == enabled) return
+      linkLayoutEnabled = enabled
+      lastLinkLayout = null
+      emitLinkLayoutIfNeeded()
+    }
+
+    /**
+     * Reports link rects of every text segment (offset by the segment's position) to JS for
+     * `renderLinkDecoration`. Tables are skipped: their cells scroll horizontally, so rects would
+     * go stale. Runs after each segment layout pass; deduplicated so an unchanged layout sends nothing.
+     */
+    private fun emitLinkLayoutIfNeeded() {
+      if (!linkLayoutEnabled || width <= 0) return
+      val fragments = mutableListOf<LinkLayoutFragment>()
+      var linkCount = 0
+      segmentViews.forEach { view ->
+        if (view is TableContainerView) {
+          linkCount += view.linkCount
+          return@forEach
+        }
+        if (view !is EnrichedMarkdownInternalText) return@forEach
+        val (segmentFragments, segmentLinks) = LinkLayoutCollector.collect(view, view.left, view.top, linkCount)
+        fragments += segmentFragments
+        linkCount += segmentLinks
+      }
+      if (fragments == lastLinkLayout) return
+      lastLinkLayout = fragments
+      emitLinkLayout(this, fragments)
     }
 
     private fun computeSegmentsTotalHeight(): Int {
@@ -606,6 +943,7 @@ class EnrichedMarkdown
     }
 
     fun cleanup() {
+      selectionReporter.cancel()
       executor.shutdownNow()
     }