react-native-enriched-markdown 0.1.0 → 0.1.1

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,203 @@
+#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::Code:
+      return 8;
+    case NodeType::Image:
+      return 9;
+    case NodeType::Blockquote:
+      return 10;
+    case NodeType::UnorderedList:
+      return 11;
+    case NodeType::OrderedList:
+      return 12;
+    case NodeType::ListItem:
+      return 13;
+    case NodeType::CodeBlock:
+      return 14;
+    case NodeType::ThematicBreak:
+      return 15;
+    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) {
+  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 {
+    // Parse markdown using C++ MD4CParser
+    MD4CParser parser;
+    auto ast = parser.parse(std::string(markdownStr));
+
+    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,153 @@
+package com.swmansion.enriched.markdown
+
+import android.content.Context
+import android.graphics.Color
+import android.os.Handler
+import android.os.Looper
+import android.text.method.LinkMovementMethod
+import android.util.AttributeSet
+import android.util.Log
+import androidx.appcompat.widget.AppCompatTextView
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.markdown.events.LinkPressEvent
+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.createSelectionActionModeCallback
+import java.util.concurrent.Executors
+
+/**
+ * EnrichedMarkdownText that handles Markdown parsing and rendering on a background thread.
+ * Utilizes PrecomputedText for smoother UI updates on supported Android versions.
+ */
+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
+
+    // Background processing tools
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val executor = Executors.newSingleThreadExecutor()
+    private var currentRenderId = 0L
+
+    val layoutManager = EnrichedMarkdownTextLayoutManager(this)
+
+    var markdownStyle: StyleConfig? = null
+      private set
+
+    var currentMarkdown: String = ""
+      private set
+
+    init {
+      setBackgroundColor(Color.TRANSPARENT)
+      includeFontPadding = false // Must match setIncludePad(false) in MeasurementStore
+      movementMethod = LinkMovementMethod.getInstance()
+      setTextIsSelectable(true)
+      customSelectionActionModeCallback = createSelectionActionModeCallback(this)
+    }
+
+    fun setMarkdownContent(markdown: String) {
+      if (currentMarkdown == markdown) return
+      currentMarkdown = markdown
+      scheduleRender()
+    }
+
+    fun setMarkdownStyle(style: ReadableMap?) {
+      val newStyle = style?.let { StyleConfig(it, context) }
+      if (markdownStyle == newStyle) return
+
+      markdownStyle = newStyle
+      scheduleRender()
+    }
+
+    private fun scheduleRender() {
+      val style = markdownStyle ?: return
+      val markdown = currentMarkdown
+      val renderId = ++currentRenderId
+      val scheduleStart = System.currentTimeMillis()
+
+      executor.execute {
+        try {
+          // 1. Parse Markdown → AST (C++ md4c parser)
+          val parseStart = System.currentTimeMillis()
+          val ast =
+            parser.parseMarkdown(markdown) ?: 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)
+          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, "└──────────────────────────────────────────────")
+
+          mainHandler.post {
+            if (renderId == currentRenderId) {
+              applyRenderedText(styledText)
+              Log.i(TAG, "✅ Total time to display: ${System.currentTimeMillis() - scheduleStart}ms")
+            }
+          }
+        } catch (e: Exception) {
+          Log.e(TAG, "❌ Render failed: ${e.message}", e)
+          mainHandler.post { if (renderId == currentRenderId) text = "" }
+        }
+      }
+    }
+
+    private fun applyRenderedText(styledText: CharSequence) {
+      // Sets the text. If it's PrecomputedText, the UI thread skips the measure pass.
+      text = styledText
+
+      // LinkMovementMethod check (setText can sometimes reset it)
+      if (movementMethod !is LinkMovementMethod) {
+        movementMethod = LinkMovementMethod.getInstance()
+      }
+
+      // Register ImageSpans from the collector
+      renderer.getCollectedImageSpans().forEach { span ->
+        span.registerTextView(this)
+      }
+
+      layoutManager.invalidateLayout()
+    }
+
+    fun setIsSelectable(selectable: Boolean) {
+      if (isTextSelectable == selectable) return
+      setTextIsSelectable(selectable)
+      movementMethod = LinkMovementMethod.getInstance()
+      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 setOnLinkPressCallback(callback: (String) -> Unit) {
+      onLinkPressCallback = callback
+    }
+
+    companion object {
+      private const val TAG = "EnrichedMarkdownMeasure"
+    }
+  }

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

@@ -0,0 +1,30 @@
+package com.swmansion.enriched.markdown
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.StateWrapper
+
+class EnrichedMarkdownTextLayoutManager(
+  private val view: EnrichedMarkdownText,
+) {
+  private var forceHeightRecalculationCounter: Int = 0
+
+  var stateWrapper: StateWrapper? = null
+
+  fun invalidateLayout() {
+    val text = view.text
+    val paint = view.paint
+
+    val needUpdate = MeasurementStore.store(view.id, text, paint)
+    if (!needUpdate) return
+
+    val counter = forceHeightRecalculationCounter
+    forceHeightRecalculationCounter++
+    val state = Arguments.createMap()
+    state.putInt("forceHeightRecalculationCounter", counter)
+    stateWrapper?.updateState(state)
+  }
+
+  fun releaseMeasurementStore() {
+    MeasurementStore.release(view.id)
+  }
+}

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

@@ -0,0 +1,119 @@
+package com.swmansion.enriched.markdown
+
+import android.content.Context
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.EnrichedMarkdownTextManagerDelegate
+import com.facebook.react.viewmanagers.EnrichedMarkdownTextManagerInterface
+import com.facebook.yoga.YogaMeasureMode
+import com.swmansion.enriched.markdown.events.LinkPressEvent
+
+@ReactModule(name = EnrichedMarkdownTextManager.NAME)
+class EnrichedMarkdownTextManager :
+  SimpleViewManager<EnrichedMarkdownText>(),
+  EnrichedMarkdownTextManagerInterface<EnrichedMarkdownText> {
+  private val mDelegate: ViewManagerDelegate<EnrichedMarkdownText> = EnrichedMarkdownTextManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<EnrichedMarkdownText>? = mDelegate
+
+  override fun getName(): String = NAME
+
+  override fun createViewInstance(reactContext: ThemedReactContext): EnrichedMarkdownText = EnrichedMarkdownText(reactContext)
+
+  override fun onDropViewInstance(view: EnrichedMarkdownText) {
+    super.onDropViewInstance(view)
+    view.layoutManager.releaseMeasurementStore()
+  }
+
+  override fun updateState(
+    view: EnrichedMarkdownText,
+    props: ReactStylesDiffMap?,
+    stateWrapper: StateWrapper?,
+  ): Any? {
+    view.layoutManager.stateWrapper = stateWrapper
+    return super.updateState(view, props, stateWrapper)
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
+    val map = mutableMapOf<String, Any>()
+    map.put(LinkPressEvent.EVENT_NAME, mapOf("registrationName" to LinkPressEvent.EVENT_NAME))
+    return map
+  }
+
+  @ReactProp(name = "markdown")
+  override fun setMarkdown(
+    view: EnrichedMarkdownText?,
+    markdown: String?,
+  ) {
+    view?.setOnLinkPressCallback { url ->
+      emitOnLinkPress(view, url)
+    }
+
+    view?.setMarkdownContent(markdown ?: "No markdown content")
+  }
+
+  @ReactProp(name = "markdownStyle")
+  override fun setMarkdownStyle(
+    view: EnrichedMarkdownText?,
+    style: com.facebook.react.bridge.ReadableMap?,
+  ) {
+    view?.setMarkdownStyle(style)
+  }
+
+  @ReactProp(name = "isSelectable", defaultBoolean = true)
+  override fun setIsSelectable(
+    view: EnrichedMarkdownText?,
+    selectable: Boolean,
+  ) {
+    view?.setIsSelectable(selectable)
+  }
+
+  override fun setPadding(
+    view: EnrichedMarkdownText,
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int,
+  ) {
+    super.setPadding(view, left, top, right, bottom)
+    view.setPadding(left, top, right, bottom)
+  }
+
+  private fun emitOnLinkPress(
+    view: EnrichedMarkdownText,
+    url: String,
+  ) {
+    val context = view.context as com.facebook.react.bridge.ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    val event = LinkPressEvent(surfaceId, view.id, url)
+
+    eventDispatcher?.dispatchEvent(event)
+  }
+
+  override fun measure(
+    context: Context,
+    localData: ReadableMap?,
+    props: ReadableMap?,
+    state: ReadableMap?,
+    width: Float,
+    widthMode: YogaMeasureMode?,
+    height: Float,
+    heightMode: YogaMeasureMode?,
+    attachmentsPositions: FloatArray?,
+  ): Long {
+    val id = localData?.getInt("viewTag")
+    return MeasurementStore.getMeasureById(context, id, width, height, heightMode, props)
+  }
+
+  companion object {
+    const val NAME = "EnrichedMarkdownText"
+  }
+}