react-native-enriched-markdown 0.1.0 → 0.2.0

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/ShadowNodes.cpp

@@ -0,0 +1,17 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeCpp.js
+ */
+
+#include "ShadowNodes.h"
+
+namespace facebook::react {
+
+extern const char EnrichedMarkdownTextComponentName[] = "EnrichedMarkdownText";
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/ShadowNodes.h

@@ -0,0 +1,32 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeH.js
+ */
+
+#pragma once
+
+#include "EventEmitters.h"
+#include "Props.h"
+#include "States.h"
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char EnrichedMarkdownTextComponentName[];
+
+/*
+ * `ShadowNode` for <EnrichedMarkdownText> component.
+ */
+using EnrichedMarkdownTextShadowNode = ConcreteViewShadowNode<
+    EnrichedMarkdownTextComponentName,
+    EnrichedMarkdownTextProps,
+    EnrichedMarkdownTextEventEmitter,
+    EnrichedMarkdownTextState>;
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/States.cpp

@@ -0,0 +1,16 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateCpp.js
+ */
+#include "States.h"
+
+namespace facebook::react {
+
+
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/EnrichedMarkdownTextSpec/States.h

@@ -0,0 +1,20 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateH.js
+ */
+#pragma once
+
+#include <react/renderer/core/StateData.h>
+#ifdef RN_SERIALIZABLE_STATE
+#include <folly/dynamic.h>
+#endif
+
+namespace facebook::react {
+
+using EnrichedMarkdownTextState = StateData;
+
+} // namespace facebook::react

package/android/gradle.properties

@@ -0,0 +1,5 @@
+EnrichedMarkdown_kotlinVersion=2.0.21
+EnrichedMarkdown_minSdkVersion=24
+EnrichedMarkdown_targetSdkVersion=34
+EnrichedMarkdown_compileSdkVersion=35
+EnrichedMarkdown_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,65 @@
+# Baseline Profile for react-native-enriched-markdown
+# These classes will be AOT compiled during app install
+# to improve cold start performance.
+
+# Core View and Rendering
+Lcom/swmansion/enriched/markdown/EnrichedMarkdownText;
+Lcom/swmansion/enriched/markdown/EnrichedMarkdownTextManager;
+Lcom/swmansion/enriched/markdown/EnrichedMarkdownTextLayoutManager;
+
+# Renderer Classes
+Lcom/swmansion/enriched/markdown/renderer/Renderer;
+Lcom/swmansion/enriched/markdown/renderer/RendererFactory;
+Lcom/swmansion/enriched/markdown/renderer/RendererConfig;
+Lcom/swmansion/enriched/markdown/renderer/BlockStyleContext;
+Lcom/swmansion/enriched/markdown/renderer/BlockStyle;
+Lcom/swmansion/enriched/markdown/renderer/SpanStyleCache;
+Lcom/swmansion/enriched/markdown/renderer/NodeRenderer;
+Lcom/swmansion/enriched/markdown/renderer/TextRenderer;
+Lcom/swmansion/enriched/markdown/renderer/ParagraphRenderer;
+Lcom/swmansion/enriched/markdown/renderer/HeadingRenderer;
+Lcom/swmansion/enriched/markdown/renderer/StrongRenderer;
+Lcom/swmansion/enriched/markdown/renderer/EmphasisRenderer;
+Lcom/swmansion/enriched/markdown/renderer/LinkRenderer;
+Lcom/swmansion/enriched/markdown/renderer/ListRenderer;
+Lcom/swmansion/enriched/markdown/renderer/ListItemRenderer;
+Lcom/swmansion/enriched/markdown/renderer/BlockquoteRenderer;
+Lcom/swmansion/enriched/markdown/renderer/CodeBlockRenderer;
+Lcom/swmansion/enriched/markdown/renderer/CodeRenderer;
+Lcom/swmansion/enriched/markdown/renderer/ImageRenderer;
+Lcom/swmansion/enriched/markdown/renderer/LineBreakRenderer;
+Lcom/swmansion/enriched/markdown/renderer/DocumentRenderer;
+
+# Spans
+Lcom/swmansion/enriched/markdown/spans/StrongSpan;
+Lcom/swmansion/enriched/markdown/spans/EmphasisSpan;
+Lcom/swmansion/enriched/markdown/spans/CodeSpan;
+Lcom/swmansion/enriched/markdown/spans/TextSpan;
+Lcom/swmansion/enriched/markdown/spans/HeadingSpan;
+Lcom/swmansion/enriched/markdown/spans/LinkSpan;
+Lcom/swmansion/enriched/markdown/spans/LineHeightSpan;
+Lcom/swmansion/enriched/markdown/spans/MarginBottomSpan;
+Lcom/swmansion/enriched/markdown/spans/BaseListSpan;
+Lcom/swmansion/enriched/markdown/spans/UnorderedListSpan;
+Lcom/swmansion/enriched/markdown/spans/OrderedListSpan;
+Lcom/swmansion/enriched/markdown/spans/BlockquoteSpan;
+Lcom/swmansion/enriched/markdown/spans/CodeBlockSpan;
+Lcom/swmansion/enriched/markdown/spans/CodeBackgroundSpan;
+Lcom/swmansion/enriched/markdown/spans/ImageSpan;
+
+# Style Configuration
+Lcom/swmansion/enriched/markdown/styles/StyleConfig;
+Lcom/swmansion/enriched/markdown/styles/ParagraphStyle;
+Lcom/swmansion/enriched/markdown/styles/HeadingStyle;
+Lcom/swmansion/enriched/markdown/styles/ListStyle;
+Lcom/swmansion/enriched/markdown/styles/BlockquoteStyle;
+Lcom/swmansion/enriched/markdown/styles/CodeBlockStyle;
+Lcom/swmansion/enriched/markdown/styles/CodeStyle;
+
+# Parser
+Lcom/swmansion/enriched/markdown/parser/Parser;
+Lcom/swmansion/enriched/markdown/parser/MarkdownASTNode;
+Lcom/swmansion/enriched/markdown/parser/MarkdownASTNode$NodeType;
+
+# Utilities
+Lcom/swmansion/enriched/markdown/utils/UtilsKt;

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

@@ -0,0 +1,220 @@
+#include "MD4CParser.hpp"
+#include <android/log.h>
+#include <jni.h>
+#include <string>
+
+using namespace Markdown;
+
+#define ENRICHEDMARKDOWN_LOG_TAG "EnrichedMarkdownJNI"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, ENRICHEDMARKDOWN_LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, ENRICHEDMARKDOWN_LOG_TAG, __VA_ARGS__)
+
+// Helper function to convert C++ NodeType to Kotlin enum ordinal
+static jint nodeTypeToJavaOrdinal(NodeType type) {
+  switch (type) {
+    case NodeType::Document:
+      return 0;
+    case NodeType::Paragraph:
+      return 1;
+    case NodeType::Text:
+      return 2;
+    case NodeType::Link:
+      return 3;
+    case NodeType::Heading:
+      return 4;
+    case NodeType::LineBreak:
+      return 5;
+    case NodeType::Strong:
+      return 6;
+    case NodeType::Emphasis:
+      return 7;
+    case NodeType::Strikethrough:
+      return 8;
+    case NodeType::Underline:
+      return 9;
+    case NodeType::Code:
+      return 10;
+    case NodeType::Image:
+      return 11;
+    case NodeType::Blockquote:
+      return 12;
+    case NodeType::UnorderedList:
+      return 13;
+    case NodeType::OrderedList:
+      return 14;
+    case NodeType::ListItem:
+      return 15;
+    case NodeType::CodeBlock:
+      return 16;
+    case NodeType::ThematicBreak:
+      return 17;
+    default:
+      return 0;
+  }
+}
+
+// Helper function to create a Kotlin MarkdownASTNode object from C++ AST node
+static jobject createJavaNode(JNIEnv *env, std::shared_ptr<MarkdownASTNode> node) {
+  if (!node) {
+    return nullptr;
+  }
+
+  // Find the MarkdownASTNode class
+  jclass nodeClass = env->FindClass("com/swmansion/enriched/markdown/parser/MarkdownASTNode");
+  if (!nodeClass) {
+    LOGE("Failed to find MarkdownASTNode class");
+    return nullptr;
+  }
+
+  // Find the NodeType enum class
+  jclass nodeTypeClass = env->FindClass("com/swmansion/enriched/markdown/parser/MarkdownASTNode$NodeType");
+  if (!nodeTypeClass) {
+    LOGE("Failed to find NodeType enum class");
+    return nullptr;
+  }
+
+  // Get the enum values array
+  jmethodID valuesMethod = env->GetStaticMethodID(
+      nodeTypeClass, "values", "()[Lcom/swmansion/enriched/markdown/parser/MarkdownASTNode$NodeType;");
+  if (!valuesMethod) {
+    LOGE("Failed to find NodeType.values() method");
+    return nullptr;
+  }
+
+  jobjectArray enumValues = (jobjectArray)env->CallStaticObjectMethod(nodeTypeClass, valuesMethod);
+  if (!enumValues) {
+    LOGE("Failed to get NodeType enum values");
+    return nullptr;
+  }
+
+  // Get the enum value for this node type
+  jint ordinal = nodeTypeToJavaOrdinal(node->type);
+  jobject nodeTypeEnum = env->GetObjectArrayElement(enumValues, ordinal);
+  if (!nodeTypeEnum) {
+    LOGE("Failed to get NodeType enum value at index %d", ordinal);
+    return nullptr;
+  }
+
+  // Create content string
+  jstring contentStr = env->NewStringUTF(node->content.c_str());
+  if (!contentStr && !node->content.empty()) {
+    LOGE("Failed to create content string");
+    return nullptr;
+  }
+
+  // Create attributes HashMap
+  jclass mapClass = env->FindClass("java/util/HashMap");
+  jmethodID mapInit = env->GetMethodID(mapClass, "<init>", "(I)V");
+  jmethodID mapPut = env->GetMethodID(mapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+
+  jobject attributesMap = env->NewObject(mapClass, mapInit, static_cast<jint>(node->attributes.size()));
+
+  for (const auto &pair : node->attributes) {
+    jstring key = env->NewStringUTF(pair.first.c_str());
+    jstring value = env->NewStringUTF(pair.second.c_str());
+    env->CallObjectMethod(attributesMap, mapPut, key, value);
+    env->DeleteLocalRef(key);
+    env->DeleteLocalRef(value);
+  }
+
+  // Create children ArrayList
+  jclass listClass = env->FindClass("java/util/ArrayList");
+  jmethodID listInit = env->GetMethodID(listClass, "<init>", "(I)V");
+  jmethodID listAdd = env->GetMethodID(listClass, "add", "(Ljava/lang/Object;)Z");
+
+  jobject childrenList = env->NewObject(listClass, listInit, static_cast<jint>(node->children.size()));
+
+  for (const auto &child : node->children) {
+    jobject childObj = createJavaNode(env, child);
+    if (childObj) {
+      env->CallBooleanMethod(childrenList, listAdd, childObj);
+      env->DeleteLocalRef(childObj);
+    }
+  }
+
+  // Find the MarkdownASTNode constructor
+  // Constructor signature: (Lcom/swmansion/enriched/markdown/parser/MarkdownASTNode$NodeType;Ljava/lang/String;Ljava/util/Map;Ljava/util/List;)V
+  jmethodID constructor = env->GetMethodID(nodeClass, "<init>",
+                                           "(Lcom/swmansion/enriched/markdown/parser/MarkdownASTNode$NodeType;Ljava/"
+                                           "lang/String;Ljava/util/Map;Ljava/util/List;)V");
+  if (!constructor) {
+    LOGE("Failed to find MarkdownASTNode constructor");
+    return nullptr;
+  }
+
+  // Create the Kotlin MarkdownASTNode object
+  jobject javaNode = env->NewObject(nodeClass, constructor, nodeTypeEnum, contentStr, attributesMap, childrenList);
+
+  // Clean up local references
+  env->DeleteLocalRef(nodeTypeClass);
+  env->DeleteLocalRef(enumValues);
+  env->DeleteLocalRef(nodeTypeEnum);
+  if (contentStr)
+    env->DeleteLocalRef(contentStr);
+  env->DeleteLocalRef(attributesMap);
+  env->DeleteLocalRef(childrenList);
+
+  return javaNode;
+}
+
+extern "C" {
+
+JNIEXPORT jobject JNICALL Java_com_swmansion_enriched_markdown_parser_Parser_nativeParseMarkdown(JNIEnv *env,
+                                                                                                 jobject /* this */,
+                                                                                                 jstring markdown,
+                                                                                                 jobject flags) {
+  if (!markdown) {
+    LOGE("Markdown string is null");
+    return nullptr;
+  }
+
+  const char *markdownStr = env->GetStringUTFChars(markdown, nullptr);
+  if (!markdownStr) {
+    LOGE("Failed to get UTF-8 chars from markdown string");
+    return nullptr;
+  }
+
+  try {
+    // Extract flags from Kotlin Md4cFlags data class
+    Md4cFlags md4cFlags;
+    if (flags) {
+      jclass flagsClass = env->GetObjectClass(flags);
+      if (flagsClass) {
+        jfieldID underlineField = env->GetFieldID(flagsClass, "underline", "Z");
+        if (underlineField) {
+          md4cFlags.underline = env->GetBooleanField(flags, underlineField) == JNI_TRUE;
+        }
+        env->DeleteLocalRef(flagsClass);
+      }
+    }
+
+    MD4CParser parser;
+    auto ast = parser.parse(std::string(markdownStr), md4cFlags);
+
+    env->ReleaseStringUTFChars(markdown, markdownStr);
+
+    if (!ast) {
+      LOGE("Parser returned null AST");
+      return nullptr;
+    }
+
+    // Convert C++ AST to Kotlin MarkdownASTNode object
+    jobject javaNode = createJavaNode(env, ast);
+
+    if (!javaNode) {
+      LOGE("Failed to create Java node from AST");
+    }
+
+    return javaNode;
+  } catch (const std::exception &e) {
+    env->ReleaseStringUTFChars(markdown, markdownStr);
+    LOGE("Exception during parsing: %s", e.what());
+    return nullptr;
+  } catch (...) {
+    env->ReleaseStringUTFChars(markdown, markdownStr);
+    LOGE("Unknown exception during parsing");
+    return nullptr;
+  }
+}
+
+} // extern "C"

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

@@ -0,0 +1,270 @@
+package com.swmansion.enriched.markdown
+
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.Color
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.text.Layout
+import android.util.AttributeSet
+import android.util.Log
+import androidx.appcompat.widget.AppCompatTextView
+import androidx.core.view.ViewCompat
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.markdown.accessibility.MarkdownAccessibilityHelper
+import com.swmansion.enriched.markdown.events.LinkLongPressEvent
+import com.swmansion.enriched.markdown.events.LinkPressEvent
+import com.swmansion.enriched.markdown.parser.Md4cFlags
+import com.swmansion.enriched.markdown.parser.Parser
+import com.swmansion.enriched.markdown.renderer.Renderer
+import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.utils.LinkLongPressMovementMethod
+import com.swmansion.enriched.markdown.utils.createSelectionActionModeCallback
+import java.util.concurrent.Executors
+
+/**
+ * EnrichedMarkdownText that handles Markdown parsing and rendering on a background thread.
+ * View starts invisible and becomes visible after render completes to avoid layout shift.
+ */
+class EnrichedMarkdownText
+  @JvmOverloads
+  constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0,
+  ) : AppCompatTextView(context, attrs, defStyleAttr) {
+    private val parser = Parser.shared
+    private val renderer = Renderer()
+    private var onLinkPressCallback: ((String) -> Unit)? = null
+    private var onLinkLongPressCallback: ((String) -> Unit)? = null
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val executor = Executors.newSingleThreadExecutor()
+    private var currentRenderId = 0L
+
+    val layoutManager = EnrichedMarkdownTextLayoutManager(this)
+
+    // Accessibility helper for TalkBack support
+    private val accessibilityHelper = MarkdownAccessibilityHelper(this)
+
+    var markdownStyle: StyleConfig? = null
+      private set
+
+    var currentMarkdown: String = ""
+      private set
+
+    var md4cFlags: Md4cFlags = Md4cFlags.DEFAULT
+      private set
+
+    private var lastKnownFontScale: Float = context.resources.configuration.fontScale
+    private var markdownStyleMap: ReadableMap? = null
+
+    private var allowFontScaling: Boolean = true
+    private var maxFontSizeMultiplier: Float = 0f
+    private var allowTrailingMargin: Boolean = false
+
+    init {
+      setBackgroundColor(Color.TRANSPARENT)
+      includeFontPadding = false // Must match setIncludePad(false) in MeasurementStore
+      movementMethod = LinkLongPressMovementMethod.createInstance()
+      setTextIsSelectable(true)
+      customSelectionActionModeCallback = createSelectionActionModeCallback(this)
+      isVerticalScrollBarEnabled = false
+      isHorizontalScrollBarEnabled = false
+
+      // Set up accessibility for TalkBack
+      // This enables virtual view hierarchy for semantic navigation (headings, links, etc.)
+      ViewCompat.setAccessibilityDelegate(this, accessibilityHelper)
+    }
+
+    fun setMarkdownContent(markdown: String) {
+      if (currentMarkdown == markdown) return
+      currentMarkdown = markdown
+      scheduleRender()
+    }
+
+    fun setMarkdownStyle(style: ReadableMap?) {
+      markdownStyleMap = style
+      // Register font scaling settings when style is set (view should have ID by now)
+      updateMeasurementStoreFontScaling()
+      val newStyle = style?.let { StyleConfig(it, context, allowFontScaling, maxFontSizeMultiplier) }
+      if (markdownStyle == newStyle) return
+      markdownStyle = newStyle
+      updateJustificationMode(newStyle)
+      scheduleRender()
+    }
+
+    override fun onConfigurationChanged(newConfig: Configuration) {
+      super.onConfigurationChanged(newConfig)
+
+      if (!allowFontScaling) {
+        return
+      }
+
+      val newFontScale = newConfig.fontScale
+      if (newFontScale != lastKnownFontScale) {
+        lastKnownFontScale = newFontScale
+        recreateStyleConfig()
+        scheduleRenderIfNeeded()
+      }
+    }
+
+    fun setMd4cFlags(flags: Md4cFlags) {
+      if (md4cFlags == flags) return
+      md4cFlags = flags
+      scheduleRenderIfNeeded()
+    }
+
+    fun setAllowFontScaling(allow: Boolean) {
+      if (allowFontScaling == allow) return
+      allowFontScaling = allow
+      updateMeasurementStoreFontScaling()
+      recreateStyleConfig()
+      scheduleRenderIfNeeded()
+    }
+
+    fun setMaxFontSizeMultiplier(multiplier: Float) {
+      if (maxFontSizeMultiplier == multiplier) return
+      maxFontSizeMultiplier = multiplier
+      updateMeasurementStoreFontScaling()
+      recreateStyleConfig()
+      scheduleRenderIfNeeded()
+    }
+
+    fun setAllowTrailingMargin(allow: Boolean) {
+      if (allowTrailingMargin == allow) return
+      allowTrailingMargin = allow
+      scheduleRenderIfNeeded()
+    }
+
+    private fun updateMeasurementStoreFontScaling() {
+      MeasurementStore.updateFontScalingSettings(id, allowFontScaling, maxFontSizeMultiplier)
+    }
+
+    private fun scheduleRenderIfNeeded() {
+      if (currentMarkdown.isNotEmpty()) {
+        scheduleRender()
+      }
+    }
+
+    private fun recreateStyleConfig() {
+      markdownStyleMap?.let { styleMap ->
+        markdownStyle = StyleConfig(styleMap, context, allowFontScaling, maxFontSizeMultiplier)
+        updateJustificationMode(markdownStyle)
+      }
+    }
+
+    private fun updateJustificationMode(style: StyleConfig?) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        justificationMode =
+          if (style?.needsJustify == true) {
+            Layout.JUSTIFICATION_MODE_INTER_WORD
+          } else {
+            Layout.JUSTIFICATION_MODE_NONE
+          }
+      }
+    }
+
+    private fun scheduleRender() {
+      val style = markdownStyle ?: return
+      val markdown = currentMarkdown
+      if (markdown.isEmpty()) return
+
+      val renderId = ++currentRenderId
+
+      executor.execute {
+        try {
+          // 1. Parse Markdown → AST (C++ md4c parser)
+          val parseStart = System.currentTimeMillis()
+          val ast =
+            parser.parseMarkdown(markdown, md4cFlags) ?: run {
+              mainHandler.post { if (renderId == currentRenderId) text = "" }
+              return@execute
+            }
+          val parseTime = System.currentTimeMillis() - parseStart
+
+          // 2. Render AST → Spannable
+          val renderStart = System.currentTimeMillis()
+          renderer.configure(style, context)
+          val styledText = renderer.renderDocument(ast, onLinkPressCallback, onLinkLongPressCallback)
+          val renderTime = System.currentTimeMillis() - renderStart
+
+          Log.i(TAG, "┌──────────────────────────────────────────────")
+          Log.i(TAG, "│ 📝 Input: ${markdown.length} chars of Markdown")
+          Log.i(TAG, "│ ⚡ md4c (C++ native): ${parseTime}ms → ${ast.children.size} AST nodes")
+          Log.i(TAG, "│ 🎨 Spannable render: ${renderTime}ms → ${styledText.length} styled chars")
+          Log.i(TAG, "└──────────────────────────────────────────────")
+
+          // 3. Apply to view on main thread
+          mainHandler.post {
+            if (renderId == currentRenderId) {
+              applyRenderedText(styledText)
+            }
+          }
+        } catch (e: Exception) {
+          Log.e(TAG, "❌ Render failed: ${e.message}", e)
+          mainHandler.post { if (renderId == currentRenderId) text = "" }
+        }
+      }
+    }
+
+    private fun applyRenderedText(styledText: CharSequence) {
+      text = styledText
+
+      // setText on a selectable TextView can reset movementMethod, so re-apply if needed
+      if (movementMethod !is LinkLongPressMovementMethod) {
+        movementMethod = LinkLongPressMovementMethod.createInstance()
+      }
+
+      // Register ImageSpans from the collector
+      renderer.getCollectedImageSpans().forEach { span ->
+        span.registerTextView(this)
+      }
+
+      layoutManager.invalidateLayout()
+
+      // Update accessibility items for TalkBack navigation
+      accessibilityHelper.invalidateAccessibilityItems()
+    }
+
+    fun setIsSelectable(selectable: Boolean) {
+      if (isTextSelectable == selectable) return
+      setTextIsSelectable(selectable)
+      movementMethod = LinkLongPressMovementMethod.createInstance()
+      if (!selectable && !isClickable) isClickable = true
+    }
+
+    fun emitOnLinkPress(url: String) {
+      val reactContext = context as? com.facebook.react.bridge.ReactContext ?: return
+      val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+      val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+
+      dispatcher?.dispatchEvent(
+        LinkPressEvent(surfaceId, id, url),
+      )
+    }
+
+    fun emitOnLinkLongPress(url: String) {
+      val reactContext = context as? com.facebook.react.bridge.ReactContext ?: return
+      val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+      val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+
+      dispatcher?.dispatchEvent(
+        LinkLongPressEvent(surfaceId, id, url),
+      )
+    }
+
+    fun setOnLinkPressCallback(callback: (String) -> Unit) {
+      onLinkPressCallback = callback
+    }
+
+    fun setOnLinkLongPressCallback(callback: (String) -> Unit) {
+      onLinkLongPressCallback = callback
+    }
+
+    companion object {
+      private const val TAG = "EnrichedMarkdownMeasure"
+    }
+  }

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

@@ -0,0 +1,15 @@
+package com.swmansion.enriched.markdown
+
+class EnrichedMarkdownTextLayoutManager(
+  private val view: EnrichedMarkdownText,
+) {
+  fun invalidateLayout() {
+    val text = view.text
+    val paint = view.paint
+    MeasurementStore.store(view.id, text, paint)
+  }
+
+  fun releaseMeasurementStore() {
+    MeasurementStore.release(view.id)
+  }
+}