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

package/android/src/main/baseline-prof.txt

@@ -1,4 +1,4 @@
-# Baseline Profile for react-native-enriched-markdown
+# Baseline Profile for react-native-enriched-markdown-scaffold
 # These classes will be AOT compiled during app install
 # to improve cold start performance.
 

package/android/src/main/cpp/jni-adapter.cpp

@@ -1,7 +1,10 @@
+#include "CodeBlockHighlighter.hpp"
+#include "CodeBlockLanguages.hpp"
 #include "MD4CParser.hpp"
 #include <android/log.h>
 #include <jni.h>
 #include <string>
+#include <vector>
 
 using namespace Markdown;
 
@@ -72,6 +75,8 @@ static jint nodeTypeToJavaOrdinal(NodeType type) {
       return 28;
     case NodeType::Highlight:
       return 29;
+    case NodeType::SoftBreak:
+      return 30;
     default:
       return 0;
   }
@@ -228,6 +233,10 @@ JNIEXPORT jobject JNICALL Java_com_swmansion_enriched_markdown_parser_Parser_nat
         if (permissiveAutolinksField) {
           md4cFlags.permissiveAutolinks = env->GetBooleanField(flags, permissiveAutolinksField) == JNI_TRUE;
         }
+        jfieldID hardSoftBreaksField = env->GetFieldID(flagsClass, "hardSoftBreaks", "Z");
+        if (hardSoftBreaksField) {
+          md4cFlags.hardSoftBreaks = env->GetBooleanField(flags, hardSoftBreaksField) == JNI_TRUE;
+        }
         env->DeleteLocalRef(flagsClass);
       }
     }
@@ -261,4 +270,69 @@ JNIEXPORT jobject JNICALL Java_com_swmansion_enriched_markdown_parser_Parser_nat
   }
 }
 
+JNIEXPORT jstring JNICALL Java_com_swmansion_enriched_markdown_utils_common_CodeBlockNode_nativeDisplayLanguageName(
+    JNIEnv *env, jobject /* this */, jstring language) {
+  if (!language) {
+    return nullptr;
+  }
+  const char *languageStr = env->GetStringUTFChars(language, nullptr);
+  if (!languageStr) {
+    return nullptr;
+  }
+  std::string display = displayNameForLanguage(languageStr);
+  env->ReleaseStringUTFChars(language, languageStr);
+  return env->NewStringUTF(display.c_str());
+}
+
+// Returns highlight tokens as (start, end, type) int triplets with UTF-16
+// offsets, or null when highlighting is unavailable. See
+// cpp/highlight/CodeBlockHighlighter.hpp for the seam contract.
+JNIEXPORT jintArray JNICALL Java_com_swmansion_enriched_markdown_utils_common_CodeBlockHighlighter_nativeHighlightCode(
+    JNIEnv *env, jobject /* this */, jstring code, jstring language) {
+  if (!code) {
+    return nullptr;
+  }
+
+  const char *codeStr = env->GetStringUTFChars(code, nullptr);
+  if (!codeStr) {
+    return nullptr;
+  }
+  const char *languageStr = language ? env->GetStringUTFChars(language, nullptr) : nullptr;
+
+  std::vector<HighlightToken> tokens;
+  try {
+    tokens = highlightCode(codeStr, languageStr ? languageStr : "");
+  } catch (const std::exception &e) {
+    LOGE("Exception during highlighting: %s", e.what());
+    tokens.clear();
+  } catch (...) {
+    LOGE("Unknown exception during highlighting");
+    tokens.clear();
+  }
+
+  env->ReleaseStringUTFChars(code, codeStr);
+  if (languageStr) {
+    env->ReleaseStringUTFChars(language, languageStr);
+  }
+
+  if (tokens.empty()) {
+    return nullptr;
+  }
+
+  std::vector<jint> flat;
+  flat.reserve(tokens.size() * 3);
+  for (const auto &token : tokens) {
+    flat.push_back(static_cast<jint>(token.start));
+    flat.push_back(static_cast<jint>(token.end));
+    flat.push_back(static_cast<jint>(token.type));
+  }
+
+  jintArray result = env->NewIntArray(static_cast<jsize>(flat.size()));
+  if (!result) {
+    return nullptr;
+  }
+  env->SetIntArrayRegion(result, 0, static_cast<jsize>(flat.size()), flat.data());
+  return result;
+}
+
 } // extern "C"

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

@@ -9,13 +9,16 @@ 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
@@ -27,11 +30,15 @@ import com.swmansion.enriched.markdown.utils.common.splitASTIntoSegments
 import com.swmansion.enriched.markdown.utils.text.TailFadeInAnimator
 import com.swmansion.enriched.markdown.utils.text.view.SelectionMenuConfig
 import com.swmansion.enriched.markdown.utils.text.view.applySelectionColors
+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 +69,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,7 +91,9 @@ 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()
@@ -89,6 +103,7 @@ class EnrichedMarkdown
     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 spoilerOverlay: SpoilerOverlay = SpoilerOverlay.PARTICLES
@@ -99,6 +114,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 +132,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 +140,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 +180,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 +190,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 +213,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 +293,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,19 +310,27 @@ 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()
     }
 
     private fun pushCopyLabelsToBlockSegments() {
       val copyLabel = selectionMenuConfig.copyLabel
       val copyAsMarkdownLabel = selectionMenuConfig.copyAsMarkdownLabel
+      val menuOptions = BlockMenuOptions.from(selectionMenuConfig)
       segmentViews.forEach { view ->
         when {
           view is TableContainerView -> {
             view.copyLabel = copyLabel
             view.copyAsMarkdownLabel = copyAsMarkdownLabel
+            view.menuOptions = menuOptions
+          }
+
+          view is CodeBlockContainerView -> {
+            view.copyLabel = copyLabel
+            view.copyAsMarkdownLabel = copyAsMarkdownLabel
+            view.menuOptions = menuOptions
           }
 
           isMathContainerView(view) -> {
@@ -255,6 +339,9 @@ class EnrichedMarkdown
               view.javaClass
                 .getMethod("setCopyAsMarkdownLabel", String::class.java)
                 .invoke(view, copyAsMarkdownLabel)
+              view.javaClass
+                .getMethod("setMenuOptions", BlockMenuOptions::class.java)
+                .invoke(view, menuOptions)
             }
           }
         }
@@ -292,7 +379,10 @@ class EnrichedMarkdown
 
     private fun recreateStyleConfig() {
       markdownStyleMap?.let {
-        markdownStyle = StyleConfig(it, context, allowFontScaling, maxFontSizeMultiplier)
+        markdownStyle =
+          StyleConfig(it, context, allowFontScaling, maxFontSizeMultiplier).also { config ->
+            config.imageRequestHeaders = imageRequestHeaders
+          }
       }
     }
 
@@ -305,26 +395,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 +431,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 +477,14 @@ class EnrichedMarkdown
       segmentSignatures.clear()
       segmentSignatures.addAll(result.signatures)
 
+      // 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 +507,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 +520,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 +551,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 +568,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 +596,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)
         }
@@ -514,9 +634,26 @@ class EnrichedMarkdown
       onLinkLongPress = onLinkLongPressCallback
       copyLabel = this@EnrichedMarkdown.selectionMenuConfig.copyLabel
       copyAsMarkdownLabel = this@EnrichedMarkdown.selectionMenuConfig.copyAsMarkdownLabel
+      contextMenuHidden = this@EnrichedMarkdown.contextMenuHidden
+      menuOptions = BlockMenuOptions.from(this@EnrichedMarkdown.selectionMenuConfig)
       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.from(this@EnrichedMarkdown.selectionMenuConfig)
+      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 +676,10 @@ class EnrichedMarkdown
         resolvedClass
           .getMethod("setCopyAsMarkdownLabel", String::class.java)
           .invoke(view, selectionMenuConfig.copyAsMarkdownLabel)
+        resolvedClass
+          .getMethod("setMenuOptions", BlockMenuOptions::class.java)
+          .invoke(view, BlockMenuOptions.from(selectionMenuConfig))
+        setMathContextMenuHidden(view)
         resolvedClass.getMethod("applyLatex", String::class.java).invoke(view, segment.latex)
         view
       } catch (e: Exception) {
@@ -566,10 +707,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,9 +742,23 @@ 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) {

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

@@ -5,6 +5,7 @@ import android.graphics.Canvas
 import android.os.Build
 import android.text.Layout
 import android.util.AttributeSet
+import android.view.ActionMode
 import android.view.MotionEvent
 import com.swmansion.enriched.markdown.accessibility.AccessibilityLabels
 import com.swmansion.enriched.markdown.accessibility.AccessibleMarkdownTextView
@@ -41,6 +42,12 @@ class EnrichedMarkdownInternalText
         checkboxTouchHelper.onCheckboxTap = value
       }
 
+    var enableTaskListItemToggle: Boolean
+      get() = checkboxTouchHelper.isEnabled
+      set(value) {
+        checkboxTouchHelper.isEnabled = value
+      }
+
     override val segmentMarginBottom: Int get() = lastElementMarginBottom.toInt()
 
     override var spoilerOverlayDrawer: SpoilerOverlayDrawer? = null
@@ -49,6 +56,14 @@ class EnrichedMarkdownInternalText
     private var contextMenuItemTexts: List<String> = emptyList()
     private var onContextMenuItemPress: ((itemText: String, selectedText: String, selectionStart: Int, selectionEnd: Int) -> Unit)? = null
     var selectionMenuConfig: SelectionMenuConfig = SelectionMenuConfig()
+    private var activeActionMode: ActionMode? = null
+    var contextMenuHidden: Boolean = false
+      set(value) {
+        if (field == value) return
+        field = value
+        // See EnrichedMarkdownText.setContextMenuHidden.
+        activeActionMode?.invalidate()
+      }
     var accessibilityLabels: AccessibilityLabels = AccessibilityLabels()
       set(value) {
         field = value
@@ -62,6 +77,8 @@ class EnrichedMarkdownInternalText
           this,
           getCustomItemTexts = { contextMenuItemTexts },
           getSelectionMenuConfig = { selectionMenuConfig },
+          isContextMenuHidden = { contextMenuHidden },
+          onActionModeChanged = { activeActionMode = it },
           onCustomItemPress = { itemText, selectedText, start, end ->
             onContextMenuItemPress?.invoke(itemText, selectedText, start, end)
           },