react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

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

@@ -0,0 +1,501 @@
+package com.swmansion.enriched.markdown.views
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.graphics.Typeface
+import android.text.Layout
+import android.text.SpannableString
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.text.style.AlignmentSpan
+import android.text.style.MetricAffectingSpan
+import android.view.Gravity
+import android.view.View
+import android.widget.FrameLayout
+import android.widget.HorizontalScrollView
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode.NodeType
+import com.swmansion.enriched.markdown.renderer.Renderer
+import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.styles.TableStyle
+import com.swmansion.enriched.markdown.utils.common.layout.isLayoutRTL
+import com.swmansion.enriched.markdown.utils.common.serialization.MarkdownASTSerializer
+import com.swmansion.enriched.markdown.utils.text.conversion.HTMLGenerator
+import com.swmansion.enriched.markdown.utils.text.extensions.replaceMathSpansWithPlaceholders
+import com.swmansion.enriched.markdown.utils.text.view.LinkLongPressMovementMethod
+import com.swmansion.enriched.markdown.views.ContextMenuPopup
+import kotlin.math.ceil
+import kotlin.math.max
+import kotlin.math.min
+
+class TableContainerView(
+  context: Context,
+  private val styleConfig: StyleConfig,
+) : FrameLayout(context),
+  BlockSegmentView {
+  private val tableStyle: TableStyle = styleConfig.tableStyle
+
+  override val segmentMarginTop: Int get() = tableStyle.marginTop.toInt()
+  override val segmentMarginBottom: Int get() = tableStyle.marginBottom.toInt()
+  private val density = resources.displayMetrics.density
+  private val isRtl = resources.isLayoutRTL()
+
+  var allowFontScaling = true
+  var maxFontSizeMultiplier = 0f
+  var onLinkPress: ((String) -> Unit)? = null
+  var onLinkLongPress: ((String) -> Unit)? = null
+
+  private val scrollView =
+    HorizontalScrollView(context).apply {
+      isHorizontalScrollBarEnabled = true
+      overScrollMode = View.OVER_SCROLL_NEVER
+      addView(GridContainerView(context))
+    }
+  private val gridContainer get() = scrollView.getChildAt(0) as GridContainerView
+
+  val rowCount: Int get() = rows.size
+
+  fun animateNewRows(
+    previousRowCount: Int,
+    durationMs: Long,
+  ) {
+    if (rowCount <= previousRowCount) return
+    val grid = gridContainer
+    val childCount = grid.childCount
+    if (childCount == 0 || rowCount == 0) return
+
+    val colCount = childCount / rowCount
+    if (colCount == 0) return
+
+    val firstNewCellIndex = previousRowCount * colCount
+    for (i in firstNewCellIndex until childCount) {
+      val cell = grid.getChildAt(i) ?: continue
+      cell.alpha = 0f
+      cell
+        .animate()
+        .alpha(1f)
+        .setDuration(durationMs)
+        .start()
+    }
+  }
+
+  private var rows: List<List<TableCellData>> = emptyList()
+  private var columnCount = 0
+  private var columnWidths = emptyList<Float>()
+  private var rowHeights = emptyList<Float>()
+  private var totalTableWidth = 0f
+  private var totalTableHeight = 0f
+  private var tableMarkdown = ""
+
+  init {
+    addView(scrollView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT))
+  }
+
+  fun applyTableNode(tableNode: MarkdownASTNode) {
+    rows =
+      tableNode.children.flatMap { section ->
+        val isSectionHead = section.type == NodeType.TableHead
+        section.children.filter { it.type == NodeType.TableRow }.map { row ->
+          row.children.map { cell ->
+            val isHeader = isSectionHead || cell.type == NodeType.TableHeaderCell
+            val align = textAlignmentFromString(cell.getAttribute("align"))
+            TableCellData(
+              attributedText = renderCellNode(cell, isHeader, align),
+              plainText = extractPlainText(cell),
+              markdownText = MarkdownASTSerializer.serializeChildren(cell),
+              isHeader = isHeader,
+              alignment = align,
+            )
+          }
+        }
+      }
+
+    columnCount = rows.maxOfOrNull { it.size } ?: 0
+    tableMarkdown = buildMarkdownFromRows()
+
+    val (widths, heights) = computeTableDimensions(rows.map { row -> row.map { it.attributedText } }, styleConfig, context)
+    columnWidths = widths
+    rowHeights = heights
+    totalTableWidth = columnWidths.sum() + tableStyle.borderWidth
+    totalTableHeight = rowHeights.sum() + tableStyle.borderWidth
+
+    renderGrid()
+  }
+
+  private fun renderCellNode(
+    node: MarkdownASTNode,
+    isHeader: Boolean,
+    alignment: Layout.Alignment,
+  ): SpannableString {
+    val root = MarkdownASTNode(NodeType.Document, children = listOf(MarkdownASTNode(NodeType.Paragraph, children = node.children)))
+    val cellParagraphStyle = styleConfig.tableCellParagraphStyle(tableStyle, isHeader)
+    return styleConfig
+      .withParagraphOverride(cellParagraphStyle) {
+        Renderer().apply { configure(styleConfig, context) }.renderDocument(root, onLinkPress, onLinkLongPress)
+      }.apply {
+        if (isNotEmpty()) {
+          if (isHeader) setSpan(HeaderTypefaceSpan(styleConfig.tableHeaderTypeface ?: Typeface.DEFAULT_BOLD), 0, length, 33)
+          if (alignment != Layout.Alignment.ALIGN_NORMAL) setSpan(AlignmentSpan.Standard(alignment), 0, length, 33)
+        }
+      }
+  }
+
+  private fun extractPlainText(node: MarkdownASTNode): String = node.content + node.children.joinToString("") { extractPlainText(it) }
+
+  private fun textAlignmentFromString(align: String?): Layout.Alignment =
+    when (align) {
+      "center" -> Layout.Alignment.ALIGN_CENTER
+      "right" -> if (isRtl) Layout.Alignment.ALIGN_NORMAL else Layout.Alignment.ALIGN_OPPOSITE
+      "left" -> if (isRtl) Layout.Alignment.ALIGN_OPPOSITE else Layout.Alignment.ALIGN_NORMAL
+      else -> Layout.Alignment.ALIGN_NORMAL
+    }
+
+  private fun renderGrid() {
+    gridContainer.removeAllViews()
+    gridContainer.configure(totalTableWidth, totalTableHeight, tableStyle)
+
+    var yOffset = 0f
+    var bodyRowIndex = 0
+
+    rows.forEachIndexed { rowIndex, row ->
+      val rowHeight = rowHeights[rowIndex]
+      val isHeaderRow = row.firstOrNull()?.isHeader == true
+      val rowBg =
+        when {
+          isHeaderRow -> tableStyle.headerBackgroundColor
+          bodyRowIndex % 2 == 0 -> tableStyle.rowEvenBackgroundColor
+          else -> tableStyle.rowOddBackgroundColor
+        }
+
+      var xOffset = if (isRtl) totalTableWidth - tableStyle.borderWidth else 0f
+      for (col in 0 until columnCount) {
+        val columnWidth = columnWidths[col]
+
+        val cellX =
+          if (isRtl) {
+            xOffset -= columnWidth
+            xOffset
+          } else {
+            xOffset
+          }
+
+        val cellBg =
+          CellBackgroundView(context).apply {
+            configure(rowBg, tableStyle.borderColor, tableStyle.borderWidth)
+            setOnLongClickListener { view ->
+              showContextMenu(view)
+              true
+            }
+          }
+
+        gridContainer.addView(
+          cellBg,
+          LayoutParams(ceil(columnWidth + tableStyle.borderWidth).toInt(), ceil(rowHeight + tableStyle.borderWidth).toInt()).apply {
+            leftMargin = ceil(cellX).toInt()
+            topMargin = ceil(yOffset).toInt()
+          },
+        )
+
+        if (col < row.size) addTextToCell(cellBg, row[col], columnWidth, rowHeight)
+        if (!isRtl) xOffset += columnWidth
+      }
+      if (!isHeaderRow) bodyRowIndex++
+      yOffset += rowHeight
+    }
+    gridContainer.layoutParams = LayoutParams(ceil(totalTableWidth).toInt(), ceil(totalTableHeight).toInt())
+  }
+
+  private fun addTextToCell(
+    container: CellBackgroundView,
+    data: TableCellData,
+    width: Float,
+    height: Float,
+  ) {
+    val cellTextView =
+      CellTextView(context).apply {
+        text = data.attributedText
+        textSize = tableStyle.fontSize / resources.displayMetrics.scaledDensity
+        typeface = if (data.isHeader) styleConfig.tableHeaderTypeface else styleConfig.tableTypeface
+        setTextColor(if (data.isHeader) tableStyle.headerTextColor else tableStyle.color)
+        gravity =
+          when (data.alignment) {
+            Layout.Alignment.ALIGN_CENTER -> Gravity.CENTER_HORIZONTAL
+            Layout.Alignment.ALIGN_OPPOSITE -> Gravity.END
+            else -> Gravity.START
+          }
+        setOnLongClickListener { view ->
+          showContextMenu(view)
+          true
+        }
+      }
+    val horizontalPadding = tableStyle.cellPaddingHorizontal
+    val verticalPadding = tableStyle.cellPaddingVertical
+    container.addView(
+      cellTextView,
+      LayoutParams(
+        (width - horizontalPadding * 2).toInt().coerceAtLeast(1),
+        (height - verticalPadding * 2).toInt().coerceAtLeast(1),
+      ).apply {
+        leftMargin = ceil(horizontalPadding).toInt()
+        topMargin = ceil(verticalPadding).toInt()
+      },
+    )
+  }
+
+  override fun onMeasure(
+    widthSpec: Int,
+    heightSpec: Int,
+  ) {
+    val measuredWidth = MeasureSpec.getSize(widthSpec)
+    val measuredHeight = ceil(totalTableHeight).toInt()
+    scrollView.measure(
+      MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY),
+    )
+    setMeasuredDimension(measuredWidth, measuredHeight)
+  }
+
+  override fun onLayout(
+    changed: Boolean,
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int,
+  ) {
+    scrollView.layout(0, 0, right - left, bottom - top)
+    val viewWidth = right - left
+    scrollView.isHorizontalScrollBarEnabled = totalTableWidth > viewWidth
+
+    if (isRtl && totalTableWidth > viewWidth) {
+      scrollView.scrollTo((totalTableWidth - viewWidth).toInt(), 0)
+    }
+  }
+
+  private fun showContextMenu(anchor: View) {
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+    ContextMenuPopup.show(anchor, this) {
+      item(ContextMenuPopup.Icon.COPY, "Copy") {
+        val plainText = rows.joinToString("\n") { row -> row.joinToString("\t") { it.plainText } }
+        if (plainText.isNotEmpty()) {
+          val displayMetrics = context.resources.displayMetrics
+          val tableRows =
+            rows.map { row ->
+              row.map { cell -> Triple(cell.attributedText as CharSequence, cell.isHeader, cell.alignment) }
+            }
+          val html = HTMLGenerator.generateTableHTML(tableRows, styleConfig, displayMetrics.scaledDensity, displayMetrics.density)
+          clipboard.setPrimaryClip(ClipData.newHtmlText("Table", plainText, html))
+        }
+      }
+      item(ContextMenuPopup.Icon.DOCUMENT, "Copy as Markdown") {
+        if (tableMarkdown.isNotEmpty()) clipboard.setPrimaryClip(ClipData.newPlainText("Table", tableMarkdown))
+      }
+    }
+  }
+
+  private fun buildMarkdownFromRows(): String =
+    rows.joinToString("") { row ->
+      val line = "| ${row.joinToString(" | ") { it.markdownText }} |\n"
+      if (row.firstOrNull()?.isHeader == true) {
+        val sep = "| ${row.joinToString(" | ") {
+          when (it.alignment) {
+            Layout.Alignment.ALIGN_CENTER -> ":---:"
+            Layout.Alignment.ALIGN_OPPOSITE -> "---:"
+            else -> "---"
+          }
+        }} |\n"
+        line + sep
+      } else {
+        line
+      }
+    }
+
+  companion object {
+    private class HeaderTypefaceSpan(
+      private val typeface: Typeface,
+    ) : MetricAffectingSpan() {
+      override fun updateDrawState(paint: TextPaint) {
+        paint.typeface = typeface
+      }
+
+      override fun updateMeasureState(paint: TextPaint) {
+        paint.typeface = typeface
+      }
+    }
+
+    private fun computeTableDimensions(
+      texts: List<List<CharSequence>>,
+      config: StyleConfig,
+      context: Context,
+    ): Pair<List<Float>, List<Float>> {
+      val style = config.tableStyle
+      val density = context.resources.displayMetrics.density
+      val (minColumnWidth, maxColumnWidth) = 60f * density to 300f * density
+      val (horizontalPadding, verticalPadding) = style.cellPaddingHorizontal * 2 to style.cellPaddingVertical * 2
+      val paint =
+        TextPaint(Paint.ANTI_ALIAS_FLAG).apply {
+          textSize = style.fontSize
+          typeface = config.tableTypeface
+        }
+
+      val columnWidths = FloatArray(texts.maxOfOrNull { it.size } ?: 0)
+      texts.forEach { row ->
+        row.forEachIndexed { colIndex, cellText ->
+          val layout =
+            StaticLayout.Builder
+              .obtain(cellText, 0, cellText.length, paint, maxColumnWidth.toInt())
+              .setIncludePad(false)
+              .build()
+          val textWidth: Float = (0 until layout.lineCount).maxOfOrNull { line -> layout.getLineWidth(line) } ?: 0f
+          columnWidths[colIndex] =
+            max(columnWidths[colIndex], min(max(ceil(textWidth) + horizontalPadding, minColumnWidth), maxColumnWidth + horizontalPadding))
+        }
+      }
+
+      val rowHeights =
+        texts.map { row ->
+          row
+            .mapIndexed { colIndex, cellText ->
+              val layout =
+                StaticLayout.Builder
+                  .obtain(
+                    cellText,
+                    0,
+                    cellText.length,
+                    paint,
+                    (columnWidths[colIndex] - horizontalPadding).toInt().coerceAtLeast(1),
+                  ).setIncludePad(false)
+                  .build()
+              ceil(layout.height.toFloat()) + verticalPadding
+            }.maxOfOrNull { it } ?: 0f
+        }
+      return columnWidths.toList() to rowHeights
+    }
+
+    fun measureTableNodeHeight(
+      node: MarkdownASTNode,
+      config: StyleConfig,
+      context: Context,
+    ): Float {
+      val tableStyle = config.tableStyle
+      val headerTypeface = config.tableHeaderTypeface ?: Typeface.DEFAULT_BOLD
+      val texts =
+        node.children.flatMap { section ->
+          section.children.filter { it.type == NodeType.TableRow }.map { row ->
+            row.children.map { cell ->
+              val isHeader = section.type == NodeType.TableHead || cell.type == NodeType.TableHeaderCell
+              val paragraph = MarkdownASTNode(NodeType.Paragraph, children = cell.children)
+              val cellParagraphStyle = config.tableCellParagraphStyle(tableStyle, isHeader)
+              val styledText =
+                config.withParagraphOverride(cellParagraphStyle) {
+                  Renderer()
+                    .apply { configure(config, context) }
+                    .renderDocument(MarkdownASTNode(NodeType.Document, children = listOf(paragraph)), null, null)
+                }
+              styledText.replaceMathSpansWithPlaceholders(context)
+              if (isHeader && styledText.isNotEmpty()) {
+                styledText.setSpan(HeaderTypefaceSpan(headerTypeface), 0, styledText.length, 33)
+              }
+              styledText
+            }
+          }
+        }
+      if (texts.isEmpty()) return 0f
+      val (_, heights) = computeTableDimensions(texts, config, context)
+      return heights.sum() + tableStyle.borderWidth
+    }
+  }
+
+  private class GridContainerView(
+    context: Context,
+  ) : FrameLayout(context) {
+    private var radius = 0f
+    private val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE }
+    private val path = Path()
+    private val rect = RectF()
+
+    init {
+      layoutDirection = View.LAYOUT_DIRECTION_LTR
+    }
+
+    fun configure(
+      tableWidth: Float,
+      tableHeight: Float,
+      style: TableStyle,
+    ) {
+      radius = style.borderRadius
+      paint.color = style.borderColor
+      paint.strokeWidth = style.borderWidth
+    }
+
+    override fun dispatchDraw(canvas: Canvas) {
+      rect.set(0f, 0f, width.toFloat(), height.toFloat())
+      if (radius > 0f) {
+        path.apply {
+          reset()
+          addRoundRect(rect, radius, radius, Path.Direction.CW)
+        }
+        canvas.save()
+        canvas.clipPath(path)
+        super.dispatchDraw(canvas)
+        canvas.restore()
+        val halfStroke = paint.strokeWidth / 2
+        rect.inset(halfStroke, halfStroke)
+        canvas.drawRoundRect(rect, radius, radius, paint)
+      } else {
+        super.dispatchDraw(canvas)
+        canvas.drawRect(rect, paint)
+      }
+    }
+  }
+
+  private class CellBackgroundView(
+    context: Context,
+  ) : FrameLayout(context) {
+    private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG)
+    private val borderPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE }
+
+    fun configure(
+      backgroundColor: Int,
+      borderColor: Int,
+      borderWidth: Float,
+    ) {
+      backgroundPaint.color = backgroundColor
+      borderPaint.color = borderColor
+      borderPaint.strokeWidth = borderWidth
+    }
+
+    override fun dispatchDraw(canvas: Canvas) {
+      canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), backgroundPaint)
+      if (borderPaint.strokeWidth > 0f) {
+        val halfStroke = borderPaint.strokeWidth / 2
+        canvas.drawRect(halfStroke, halfStroke, width.toFloat() - halfStroke, height.toFloat() - halfStroke, borderPaint)
+      }
+      super.dispatchDraw(canvas)
+    }
+  }
+
+  private class CellTextView(
+    context: Context,
+  ) : androidx.appcompat.widget.AppCompatTextView(context) {
+    init {
+      setPadding(0, 0, 0, 0)
+      includeFontPadding = false
+      movementMethod = LinkLongPressMovementMethod.createInstance()
+      layoutDirection = View.LAYOUT_DIRECTION_LOCALE
+      textDirection = View.TEXT_DIRECTION_LOCALE
+    }
+  }
+
+  private data class TableCellData(
+    val attributedText: SpannableString,
+    val plainText: String,
+    val markdownText: String,
+    val isHeader: Boolean,
+    val alignment: Layout.Alignment,
+  )
+}

package/android/src/main/jni/CMakeLists.txt

@@ -0,0 +1,70 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+set(LIB_LITERAL EnrichedMarkdownTextSpec)
+set(LIB_TARGET_NAME react_codegen_${LIB_LITERAL})
+
+set(LIB_ANDROID_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
+set(LIB_ANDROID_GENERATED_JNI_DIR ${LIB_ANDROID_DIR}/generated/jni)
+set(LIB_ANDROID_GENERATED_COMPONENTS_DIR ${LIB_ANDROID_GENERATED_JNI_DIR}/react/renderer/components/${LIB_LITERAL})
+
+set(CPP_ROOT "${LIB_ANDROID_DIR}/../cpp")
+set(ANDROID_CPP_DIR "${LIB_ANDROID_DIR}/src/main/cpp")
+
+file(GLOB MD4C_SOURCES "${CPP_ROOT}/md4c/*.c")
+file(GLOB PARSER_SOURCES "${CPP_ROOT}/parser/*.cpp")
+
+# md4c is C code, build as separate static library with C flags
+add_library(md4c_lib STATIC ${MD4C_SOURCES})
+target_include_directories(md4c_lib PUBLIC ${CPP_ROOT}/md4c)
+target_compile_definitions(md4c_lib PRIVATE MD4C_USE_UTF8=1)
+set_target_properties(md4c_lib PROPERTIES
+  C_STANDARD 11
+  C_STANDARD_REQUIRED ON
+)
+
+file(GLOB LIB_CODEGEN_SRCS CONFIGURE_DEPENDS ${LIB_ANDROID_GENERATED_JNI_DIR}/*.cpp ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}/*.cpp)
+file(GLOB LIB_CUSTOM_JNI_SRCS CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/react/renderer/components/${LIB_LITERAL}/*.cpp)
+
+add_library(
+  ${LIB_TARGET_NAME}
+  SHARED
+  ${LIB_CODEGEN_SRCS}
+  ${LIB_CUSTOM_JNI_SRCS}
+  ${PARSER_SOURCES}
+  ${ANDROID_CPP_DIR}/jni-adapter.cpp
+)
+
+target_include_directories(
+  ${LIB_TARGET_NAME}
+  PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}/react/renderer/components/${LIB_LITERAL}
+  ${LIB_ANDROID_GENERATED_JNI_DIR}
+  ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}
+  ${CPP_ROOT}/md4c
+  ${CPP_ROOT}/parser
+)
+
+target_compile_definitions(${LIB_TARGET_NAME} PRIVATE MD4C_USE_UTF8=1)
+
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+find_library(LOG_LIB log)
+
+target_link_libraries(
+  ${LIB_TARGET_NAME}
+  ${LOG_LIB}
+  md4c_lib
+  fbjni::fbjni
+  ReactAndroid::jsi
+  ReactAndroid::reactnative
+)
+
+target_include_directories(
+  ${CMAKE_PROJECT_NAME}
+  PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_compile_reactnative_options(${LIB_TARGET_NAME} PRIVATE)

package/android/src/main/jni/EnrichedMarkdownTextSpec.cpp

@@ -0,0 +1,21 @@
+/**
+ * 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: GenerateModuleJniCpp.js
+ */
+
+#include "EnrichedMarkdownTextSpec.h"
+
+namespace facebook::react {
+
+std::shared_ptr<TurboModule> EnrichedMarkdownTextSpec_ModuleProvider(const std::string &moduleName,
+                                                                     const JavaTurboModule::InitParams &params) {
+
+  return nullptr;
+}
+
+} // namespace facebook::react

package/android/src/main/jni/EnrichedMarkdownTextSpec.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+#include <react/renderer/components/EnrichedMarkdownTextSpec/ComponentDescriptors.h>
+
+namespace facebook::react {
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> EnrichedMarkdownTextSpec_ModuleProvider(const std::string &moduleName,
+                                                                     const JavaTurboModule::InitParams &params);
+
+} // namespace facebook::react

package/android/src/main/jni/react/renderer/components/EnrichedMarkdownTextSpec/ComponentDescriptors.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "MarkdownContainerMeasurementManager.h"
+#include "MarkdownContainerShadowNode.h"
+#include "MarkdownTextInputMeasurementManager.h"
+#include "MarkdownTextInputShadowNode.h"
+#include "MarkdownTextMeasurementManager.h"
+#include "MarkdownTextShadowNode.h"
+
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+class EnrichedMarkdownComponentDescriptor final : public ConcreteComponentDescriptor<MarkdownContainerShadowNode> {
+public:
+  EnrichedMarkdownComponentDescriptor(const ComponentDescriptorParameters &parameters)
+      : ConcreteComponentDescriptor(parameters),
+        measurementsManager_(std::make_shared<MarkdownContainerMeasurementManager>(contextContainer_)) {}
+
+  void adopt(ShadowNode &shadowNode) const override {
+    ConcreteComponentDescriptor::adopt(shadowNode);
+    auto &containerShadowNode = static_cast<MarkdownContainerShadowNode &>(shadowNode);
+    containerShadowNode.setMeasurementsManager(measurementsManager_);
+  }
+
+private:
+  const std::shared_ptr<MarkdownContainerMeasurementManager> measurementsManager_;
+};
+
+class EnrichedMarkdownTextComponentDescriptor final : public ConcreteComponentDescriptor<MarkdownTextShadowNode> {
+public:
+  EnrichedMarkdownTextComponentDescriptor(const ComponentDescriptorParameters &parameters)
+      : ConcreteComponentDescriptor(parameters),
+        measurementsManager_(std::make_shared<MarkdownTextMeasurementManager>(contextContainer_)) {}
+
+  void adopt(ShadowNode &shadowNode) const override {
+    ConcreteComponentDescriptor::adopt(shadowNode);
+    auto &markdownTextShadowNode = static_cast<MarkdownTextShadowNode &>(shadowNode);
+    markdownTextShadowNode.setMeasurementsManager(measurementsManager_);
+  }
+
+private:
+  const std::shared_ptr<MarkdownTextMeasurementManager> measurementsManager_;
+};
+
+class EnrichedMarkdownTextInputComponentDescriptor final
+    : public ConcreteComponentDescriptor<MarkdownTextInputShadowNode> {
+public:
+  EnrichedMarkdownTextInputComponentDescriptor(const ComponentDescriptorParameters &parameters)
+      : ConcreteComponentDescriptor(parameters),
+        measurementsManager_(std::make_shared<MarkdownTextInputMeasurementManager>(contextContainer_)) {}
+
+  void adopt(ShadowNode &shadowNode) const override {
+    ConcreteComponentDescriptor::adopt(shadowNode);
+    auto &inputShadowNode = static_cast<MarkdownTextInputShadowNode &>(shadowNode);
+    inputShadowNode.setMeasurementsManager(measurementsManager_);
+  }
+
+private:
+  const std::shared_ptr<MarkdownTextInputMeasurementManager> measurementsManager_;
+};
+
+void EnrichedMarkdownTextSpec_registerComponentDescriptorsFromCodegen(
+    std::shared_ptr<const ComponentDescriptorProviderRegistry> registry);
+
+} // namespace facebook::react

package/android/src/main/jni/react/renderer/components/EnrichedMarkdownTextSpec/MarkdownContainerComponentDescriptor.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "MarkdownContainerMeasurementManager.h"
+#include "MarkdownContainerShadowNode.h"
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+class MarkdownContainerComponentDescriptor final : public ConcreteComponentDescriptor<MarkdownContainerShadowNode> {
+public:
+  MarkdownContainerComponentDescriptor(const ComponentDescriptorParameters &parameters)
+      : ConcreteComponentDescriptor(parameters),
+        measurementsManager_(std::make_shared<MarkdownContainerMeasurementManager>(contextContainer_)) {}
+
+  void adopt(ShadowNode &shadowNode) const override {
+    ConcreteComponentDescriptor::adopt(shadowNode);
+    auto &containerShadowNode = static_cast<MarkdownContainerShadowNode &>(shadowNode);
+    containerShadowNode.setMeasurementsManager(measurementsManager_);
+  }
+
+private:
+  const std::shared_ptr<MarkdownContainerMeasurementManager> measurementsManager_;
+};
+
+} // namespace facebook::react