@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.9

package/android/src/main/java/com/renderrichtext/utils/text/view/TextSelectionColors.kt

@@ -0,0 +1,48 @@
+package com.renderrichtext.utils.text.view
+
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.util.Log
+import android.widget.TextView
+import androidx.annotation.ColorInt
+import androidx.core.graphics.drawable.DrawableCompat
+
+private const val TAG = "TextSelectionColors"
+
+private typealias HandleGetter = (TextView) -> Drawable?
+private typealias HandleSetter = (TextView, Drawable) -> Unit
+
+/**
+ * Applies selection highlight and (where supported) handle tinting to a [TextView].
+ *
+ * Handle drawables are only tinted on API 29+ where the framework exposes getters;
+ * on older versions the handle theme defaults remain unchanged.
+ */
+fun TextView.applySelectionColors(
+  selectionColor: Int?,
+  selectionHandleColor: Int?,
+) {
+  selectionColor?.let { highlightColor = it }
+  selectionHandleColor?.let { applySelectionHandleTint(it) }
+}
+
+private fun TextView.applySelectionHandleTint(
+  @ColorInt color: Int,
+) {
+  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return
+
+  val handles: List<Pair<HandleGetter, HandleSetter>> =
+    listOf(
+      TextView::getTextSelectHandleLeft to { tv, d -> tv.setTextSelectHandleLeft(d) },
+      TextView::getTextSelectHandle to { tv, d -> tv.setTextSelectHandle(d) },
+      TextView::getTextSelectHandleRight to { tv, d -> tv.setTextSelectHandleRight(d) },
+    )
+
+  handles.forEach { (getter, setter) ->
+    try {
+      getter(this)?.mutate()?.also { DrawableCompat.setTint(it, color) }?.let { setter(this, it) }
+    } catch (e: LinkageError) {
+      Log.w(TAG, "Selection handle tint skipped: ${e.message}")
+    }
+  }
+}

package/android/src/main/java/com/renderrichtext/utils/text/view/TextViewSetup.kt

@@ -0,0 +1,119 @@
+package com.renderrichtext.utils.text.view
+
+import android.graphics.Color
+import android.os.Build
+import android.text.GetChars
+import android.text.Spannable
+import android.text.SpannableString
+import android.text.SpannableStringBuilder
+import android.view.textclassifier.TextClassifier
+import androidx.appcompat.widget.AppCompatTextView
+import androidx.core.view.ViewCompat
+import com.renderrichtext.accessibility.AccessibleTiptapTextView
+
+/**
+ * Adopts the renderer's buffer instead of copying it: the default factory's copy is
+ * quadratic in span count. Safe because each segment's buffer is owned by one view.
+ */
+private object NoCopySpannableFactory : Spannable.Factory() {
+  override fun newSpannable(source: CharSequence): Spannable =
+    when (source) {
+      is SpannableStringBuilder -> InsertionOrderedSpannable(source)
+      is Spannable -> source
+      else -> SpannableString(source)
+    }
+}
+
+/**
+ * Hides that [buffer] is a `SpannableStringBuilder`. Layout reads a builder's paragraph
+ * spans in position order rather than insertion order, which paints nested list margins
+ * outer-first and pushes nested checkboxes an indent right.
+ *
+ * Hiding the type has a price, and it is deliberate: every paragraph-span query from
+ * `Layout` now goes through the builder's sorted `getSpans` instead of the unsorted fast
+ * path the framework reserves for builders. The `layout` benchmark in the example app's
+ * `display-benchmark` covers that cost, so it is already accounted for. Do not
+ * "optimise" this wrapper away.
+ */
+private class InsertionOrderedSpannable(
+  private val buffer: SpannableStringBuilder,
+) : Spannable,
+  GetChars {
+  override val length: Int get() = buffer.length
+
+  override fun get(index: Int): Char = buffer[index]
+
+  override fun subSequence(
+    startIndex: Int,
+    endIndex: Int,
+  ): CharSequence = buffer.subSequence(startIndex, endIndex)
+
+  override fun getChars(
+    start: Int,
+    end: Int,
+    dest: CharArray,
+    destoff: Int,
+  ) = buffer.getChars(start, end, dest, destoff)
+
+  override fun <T : Any?> getSpans(
+    start: Int,
+    end: Int,
+    type: Class<T>,
+  ): Array<T> = buffer.getSpans(start, end, type)
+
+  override fun getSpanStart(tag: Any): Int = buffer.getSpanStart(tag)
+
+  override fun getSpanEnd(tag: Any): Int = buffer.getSpanEnd(tag)
+
+  override fun getSpanFlags(tag: Any): Int = buffer.getSpanFlags(tag)
+
+  override fun nextSpanTransition(
+    start: Int,
+    limit: Int,
+    type: Class<*>?,
+  ): Int = buffer.nextSpanTransition(start, limit, type)
+
+  override fun setSpan(
+    what: Any,
+    start: Int,
+    end: Int,
+    flags: Int,
+  ) = buffer.setSpan(what, start, end, flags)
+
+  override fun removeSpan(what: Any) = buffer.removeSpan(what)
+
+  override fun toString(): String = buffer.toString()
+}
+
+fun AccessibleTiptapTextView.setupAsTiptapTextView() {
+  setBackgroundColor(Color.TRANSPARENT)
+  setSpannableFactory(NoCopySpannableFactory)
+  includeFontPadding = false
+  movementMethod = LinkLongPressMovementMethod.createInstance()
+  setTextIsSelectable(true)
+  customSelectionActionModeCallback = createSelectionActionModeCallback(this)
+  // SmartSelectSprite crashes with "Center point is not inside any of the
+  // rectangles!" when Layout.getSelection returns empty rects near an
+  // ImageSpan (ReplacementSpan). NO_OP makes skipTextClassification() return
+  // true, bypassing the entire SmartSelectSprite code path. Regular text
+  // selection (long-press, handles, copy/paste) still works; only automatic
+  // entity detection (phone numbers, addresses) is disabled.
+  //
+  // TODO: Add an Android-only `enableSmartTextSelection` prop that skips this
+  // NO_OP override. This would let users who don't render images opt in to
+  // entity detection. The prop should default to false and its docs should
+  // warn that enabling it with tiptap containing images will crash.
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+    setTextClassifier(TextClassifier.NO_OP)
+  }
+  isVerticalScrollBarEnabled = false
+  isHorizontalScrollBarEnabled = false
+  ViewCompat.setAccessibilityDelegate(this, accessibilityHelper)
+}
+
+fun AppCompatTextView.applySelectableState(selectable: Boolean) {
+  if (isTextSelectable == selectable) return
+  setTextIsSelectable(selectable)
+  movementMethod = LinkLongPressMovementMethod.createInstance()
+  if (!selectable && !isClickable) isClickable = true
+}

package/android/src/main/java/com/renderrichtext/views/ContextMenuPopup.kt

@@ -0,0 +1,217 @@
+package com.renderrichtext.views
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.Paint
+import android.graphics.PixelFormat
+import android.graphics.RectF
+import android.graphics.Typeface
+import android.graphics.drawable.ColorDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.GradientDrawable
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.View
+import android.view.View.MeasureSpec
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.PopupWindow
+import android.widget.TextView
+import kotlin.math.roundToInt
+
+object ContextMenuPopup {
+  private var activePopup: PopupWindow? = null
+
+  fun dismiss() {
+    activePopup?.dismiss()
+  }
+
+  enum class Icon { COPY, DOCUMENT }
+
+  class Builder internal constructor() {
+    internal val items = mutableListOf<MenuItem>()
+
+    fun item(
+      icon: Icon,
+      label: String,
+      onClick: () -> Unit,
+    ) {
+      items.add(MenuItem(icon, label, onClick))
+    }
+  }
+
+  internal data class MenuItem(
+    val icon: Icon,
+    val label: String,
+    val onClick: () -> Unit,
+  )
+
+  private var density = 1f
+  private val Float.dp get() = (this * density).roundToInt()
+
+  fun show(
+    anchor: View,
+    parent: View,
+    block: Builder.() -> Unit,
+  ) {
+    activePopup?.dismiss()
+
+    val context = anchor.context
+    density = context.resources.displayMetrics.density
+    val builder = Builder().apply(block)
+    if (builder.items.isEmpty()) return
+
+    val container =
+      LinearLayout(context).apply {
+        orientation = LinearLayout.VERTICAL
+        elevation = 12f.dp.toFloat()
+        setPadding(4f.dp, 12f.dp, 4f.dp, 12f.dp)
+        background =
+          GradientDrawable().apply {
+            setColor(Color.WHITE)
+            cornerRadius = 14f.dp.toFloat()
+          }
+      }
+
+    builder.items.forEachIndexed { index, item ->
+      if (index > 0) container.addView(createDivider(context))
+      container.addView(createMenuItemView(context, item))
+    }
+
+    val popup =
+      PopupWindow(
+        container,
+        ViewGroup.LayoutParams.WRAP_CONTENT,
+        ViewGroup.LayoutParams.WRAP_CONTENT,
+        true,
+      ).apply {
+        elevation = 24f.dp.toFloat()
+        isOutsideTouchable = true
+        setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
+        setOnDismissListener {
+          activePopup = null
+        }
+      }
+
+    container.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED)
+
+    val location = IntArray(2).also { anchor.getLocationOnScreen(it) }
+    val centerX = location[0] + anchor.width / 2
+    val topY = location[1]
+
+    val screenW = context.resources.displayMetrics.widthPixels
+    val margin = 8f.dp
+
+    val x =
+      (centerX - container.measuredWidth / 2)
+        .coerceIn(margin, screenW - container.measuredWidth - margin)
+    val y =
+      (topY - container.measuredHeight - margin)
+        .coerceAtLeast(margin)
+
+    activePopup = popup
+    popup.showAtLocation(parent, Gravity.NO_GRAVITY, x, y)
+  }
+
+  private fun createMenuItemView(
+    context: Context,
+    item: MenuItem,
+  ) = LinearLayout(context).apply {
+    orientation = LinearLayout.HORIZONTAL
+    gravity = Gravity.CENTER_VERTICAL
+    setPadding(16f.dp, 0, 16f.dp, 0)
+    minimumHeight = 48f.dp
+    isClickable = true
+    isFocusable = true
+
+    val outValue = TypedValue()
+    context.theme.resolveAttribute(android.R.attr.selectableItemBackground, outValue, true)
+    foreground = context.getDrawable(outValue.resourceId)
+
+    addView(
+      ImageView(context).apply {
+        setImageDrawable(createIconDrawable(item.icon))
+        setColorFilter(Color.parseColor("#333333"))
+      },
+      LinearLayout.LayoutParams(20f.dp, 20f.dp),
+    )
+
+    addView(
+      TextView(context).apply {
+        text = item.label
+        textSize = 16f
+        setTextColor(Color.parseColor("#1C1C1E"))
+        typeface = Typeface.create("sans-serif-medium", Typeface.NORMAL)
+      },
+      LinearLayout
+        .LayoutParams(
+          ViewGroup.LayoutParams.WRAP_CONTENT,
+          ViewGroup.LayoutParams.WRAP_CONTENT,
+        ).apply { marginStart = 12f.dp },
+    )
+
+    setOnClickListener {
+      item.onClick()
+      dismiss()
+    }
+  }
+
+  private fun createDivider(context: Context) =
+    View(context).apply {
+      setBackgroundColor(Color.parseColor("#E5E5EA"))
+      layoutParams =
+        LinearLayout
+          .LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            1f.dp.coerceAtLeast(1),
+          ).apply {
+            setMargins(16f.dp, 0, 16f.dp, 0)
+          }
+    }
+
+  private fun createIconDrawable(icon: Icon): Drawable =
+    object : Drawable() {
+      private val paint =
+        Paint(Paint.ANTI_ALIAS_FLAG).apply {
+          style = Paint.Style.STROKE
+          strokeWidth = 1.5f * density
+          strokeJoin = Paint.Join.ROUND
+          strokeCap = Paint.Cap.ROUND
+          color = Color.parseColor("#333333")
+        }
+
+      private val copyGlyph = CopyGlyph()
+
+      // COPY mirrors SF Symbol doc.on.doc, DOCUMENT mirrors doc.text; the copy
+      // glyph is shared with the header button in CodeBlockContainerView.
+      override fun draw(canvas: Canvas) {
+        val u = bounds.width() / 24f
+        if (icon == Icon.COPY) {
+          copyGlyph.draw(canvas, bounds.width().toFloat(), paint)
+        } else {
+          canvas.drawRoundRect(RectF(5 * u, 3 * u, 19 * u, 21 * u), 2.5f * u, 2.5f * u, paint)
+          canvas.drawLine(8.5f * u, 9 * u, 15.5f * u, 9 * u, paint)
+          canvas.drawLine(8.5f * u, 12.5f * u, 15.5f * u, 12.5f * u, paint)
+          canvas.drawLine(8.5f * u, 16 * u, 13 * u, 16 * u, paint)
+        }
+      }
+
+      override fun getIntrinsicWidth() = 24f.dp
+
+      override fun getIntrinsicHeight() = 24f.dp
+
+      override fun setAlpha(alpha: Int) {
+        paint.alpha = alpha
+      }
+
+      override fun setColorFilter(colorFilter: ColorFilter?) {
+        paint.colorFilter = colorFilter
+      }
+
+      @Deprecated("Deprecated in Java")
+      override fun getOpacity() = PixelFormat.TRANSLUCENT
+    }
+}

package/android/src/main/java/com/renderrichtext/views/CopyGlyph.kt

@@ -0,0 +1,101 @@
+package com.renderrichtext.views
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+
+/**
+ * Draws the copy glyph so Android matches the SF Symbol doc.on.doc rendered on
+ * iOS: two portrait document pages with a folded (dog-eared) top-right corner,
+ * a front page in the lower-left laid over a back page in the upper-right.
+ *
+ * The back page is punched out where the front page (plus a hairline of
+ * clearance) covers it, so the front reads as sitting on top exactly as the SF
+ * Symbol does, instead of both outlines crossing. The clear is done inside an
+ * offscreen layer so the punched region reveals whatever background the drawable
+ * sits on, without the glyph needing to know that color.
+ *
+ * One instance is held per drawable rather than shared: the paths and clear
+ * paint are reused across draws to keep draw() allocation-free, and two drawables
+ * of different sizes must not share those buffers. All coordinates use a 24-unit
+ * grid scaled to the drawable width, matching the grid the iOS symbol is authored
+ * on.
+ */
+internal class CopyGlyph {
+  private val back = Path()
+  private val front = Path()
+  private val backFold = Path()
+  private val frontFold = Path()
+
+  // Color and colorFilter are irrelevant under PorterDuff.CLEAR; only the
+  // widened stroke (set per draw) matters, so this is configured once.
+  private val clearPaint =
+    Paint(Paint.ANTI_ALIAS_FLAG).apply {
+      style = Paint.Style.FILL_AND_STROKE
+      strokeJoin = Paint.Join.ROUND
+      strokeCap = Paint.Cap.ROUND
+      xfermode = PorterDuffXfermode(PorterDuff.Mode.CLEAR)
+    }
+
+  fun draw(
+    canvas: Canvas,
+    width: Float,
+    stroke: Paint,
+  ) {
+    val u = width / 24f
+    val fold = 4f * u
+    val corner = 2f * u
+
+    buildPage(back, 9 * u, 1 * u, 20 * u, 17 * u, fold, corner)
+    buildPage(front, 3 * u, 7 * u, 14 * u, 23 * u, fold, corner)
+    buildFold(backFold, 20 * u, 1 * u, fold)
+    buildFold(frontFold, 14 * u, 7 * u, fold)
+    clearPaint.strokeWidth = stroke.strokeWidth * 3f
+
+    val saved = canvas.saveLayer(0f, 0f, width, width, null)
+    canvas.drawPath(back, stroke)
+    canvas.drawPath(backFold, stroke)
+    canvas.drawPath(front, clearPaint)
+    canvas.drawPath(front, stroke)
+    canvas.drawPath(frontFold, stroke)
+    canvas.restoreToCount(saved)
+  }
+
+  // A page outline whose top-right corner is cut back by fold, with the other
+  // three corners rounded by corner.
+  private fun buildPage(
+    path: Path,
+    l: Float,
+    t: Float,
+    r: Float,
+    b: Float,
+    fold: Float,
+    corner: Float,
+  ) {
+    path.rewind()
+    path.moveTo(l, t + corner)
+    path.quadTo(l, t, l + corner, t)
+    path.lineTo(r - fold, t)
+    path.lineTo(r, t + fold)
+    path.lineTo(r, b - corner)
+    path.quadTo(r, b, r - corner, b)
+    path.lineTo(l + corner, b)
+    path.quadTo(l, b, l, b - corner)
+    path.close()
+  }
+
+  // The two inner edges of the folded-over corner, at the page's top-right.
+  private fun buildFold(
+    path: Path,
+    r: Float,
+    t: Float,
+    fold: Float,
+  ) {
+    path.rewind()
+    path.moveTo(r - fold, t)
+    path.lineTo(r - fold, t + fold)
+    path.lineTo(r, t + fold)
+  }
+}

package/android/src/main/java/com/renderrichtext/views/WrapGlyph.kt

@@ -0,0 +1,40 @@
+package com.renderrichtext.views
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+
+/**
+ * Material "wrap_text" glyph as strokes on a 24-unit grid, drawn with the same
+ * paint as [CopyGlyph] so the two header buttons match in weight.
+ */
+internal class WrapGlyph {
+  private val lines = Path()
+  private val arrow = Path()
+  private val loop = RectF()
+
+  fun draw(
+    canvas: Canvas,
+    width: Float,
+    stroke: Paint,
+  ) {
+    val u = width / 24f
+    lines.rewind()
+    lines.moveTo(4 * u, 6 * u)
+    lines.lineTo(20 * u, 6 * u)
+    lines.moveTo(4 * u, 18 * u)
+    lines.lineTo(10 * u, 18 * u)
+    lines.moveTo(4 * u, 12 * u)
+    lines.lineTo(17 * u, 12 * u)
+    loop.set(15 * u, 12 * u, 19 * u, 16 * u)
+    lines.arcTo(loop, -90f, 180f)
+    lines.lineTo(13 * u, 16 * u)
+    arrow.rewind()
+    arrow.moveTo(15 * u, 14 * u)
+    arrow.lineTo(13 * u, 16 * u)
+    arrow.lineTo(15 * u, 18 * u)
+    canvas.drawPath(lines, stroke)
+    canvas.drawPath(arrow, stroke)
+  }
+}

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

@@ -0,0 +1,52 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+set(LIB_LITERAL RichTextSpec)
+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}/build/generated/source/codegen/jni)
+set(LIB_ANDROID_GENERATED_COMPONENTS_DIR ${LIB_ANDROID_GENERATED_JNI_DIR}/react/renderer/components/${LIB_LITERAL})
+set(CPP_ROOT ${LIB_ANDROID_DIR}/../cpp)
+
+file(GLOB PARSER_SOURCES "${CPP_ROOT}/parser/*.cpp")
+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}
+  ${LIB_ANDROID_DIR}/src/main/cpp/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}/parser
+  ${CPP_ROOT}/vendor
+)
+
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+find_library(LOG_LIB log)
+
+target_link_libraries(
+  ${LIB_TARGET_NAME}
+  ${LOG_LIB}
+  fbjni::fbjni
+  ReactAndroid::jsi
+  ReactAndroid::reactnative
+)
+
+target_compile_reactnative_options(${LIB_TARGET_NAME} PRIVATE)

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "TiptapTextMeasurementManager.h"
+#include "TiptapTextShadowNode.h"
+
+#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+class EnrichedTiptapTextComponentDescriptor final : public ConcreteComponentDescriptor<TiptapTextShadowNode> {
+public:
+  EnrichedTiptapTextComponentDescriptor(const ComponentDescriptorParameters &parameters)
+      : ConcreteComponentDescriptor(parameters),
+        measurementsManager_(std::make_shared<TiptapTextMeasurementManager>(contextContainer_)) {}
+
+  void adopt(ShadowNode &shadowNode) const override {
+    ConcreteComponentDescriptor::adopt(shadowNode);
+    auto &tiptapTextShadowNode = static_cast<TiptapTextShadowNode &>(shadowNode);
+    tiptapTextShadowNode.setMeasurementsManager(measurementsManager_);
+  }
+
+private:
+  const std::shared_ptr<TiptapTextMeasurementManager> measurementsManager_;
+};
+
+void RichTextSpec_registerComponentDescriptorsFromCodegen(
+    std::shared_ptr<const ComponentDescriptorProviderRegistry> registry);
+
+} // namespace facebook::react

package/android/src/main/jni/react/renderer/components/RichTextSpec/TiptapTextComponentDescriptor.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "TiptapTextMeasurementManager.h"
+#include "TiptapTextShadowNode.h"
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+class TiptapTextComponentDescriptor final : public ConcreteComponentDescriptor<TiptapTextShadowNode> {
+public:
+  TiptapTextComponentDescriptor(const ComponentDescriptorParameters &parameters)
+      : ConcreteComponentDescriptor(parameters),
+        measurementsManager_(std::make_shared<TiptapTextMeasurementManager>(contextContainer_)) {}
+
+  void adopt(ShadowNode &shadowNode) const override {
+    ConcreteComponentDescriptor::adopt(shadowNode);
+    auto &tiptapTextShadowNode = static_cast<TiptapTextShadowNode &>(shadowNode);
+
+    // TiptapTextShadowNode uses TiptapTextMeasurementManager
+    // to provide measurements to Yoga.
+    tiptapTextShadowNode.setMeasurementsManager(measurementsManager_);
+  }
+
+private:
+  const std::shared_ptr<TiptapTextMeasurementManager> measurementsManager_;
+};
+
+} // namespace facebook::react

package/android/src/main/jni/react/renderer/components/RichTextSpec/TiptapTextMeasurementManager.cpp

@@ -0,0 +1,45 @@
+#include "TiptapTextMeasurementManager.h"
+#include "conversions.h"
+
+#include <fbjni/fbjni.h>
+#include <react/jni/ReadableNativeMap.h>
+#include <react/renderer/core/conversions.h>
+
+using namespace facebook::jni;
+
+namespace facebook::react {
+
+Size TiptapTextMeasurementManager::measure(SurfaceId surfaceId, int viewTag, const EnrichedTiptapTextProps &props,
+                                             LayoutConstraints layoutConstraints) const {
+  const jni::global_ref<jobject> &fabricUIManager = contextContainer_->at<jni::global_ref<jobject>>("FabricUIManager");
+
+  static const auto measure =
+      facebook::jni::findClassStatic("com/facebook/react/fabric/FabricUIManager")
+          ->getMethod<jlong(jint, jstring, ReadableMap::javaobject, ReadableMap::javaobject, ReadableMap::javaobject,
+                            jfloat, jfloat, jfloat, jfloat)>("measure");
+
+  auto minimumSize = layoutConstraints.minimumSize;
+  auto maximumSize = layoutConstraints.maximumSize;
+
+  local_ref<JString> componentName = make_jstring("EnrichedTiptapText");
+
+  // Prepare extraData map with viewTag
+  folly::dynamic extraData = folly::dynamic::object();
+  extraData["viewTag"] = viewTag;
+  local_ref<ReadableNativeMap::javaobject> extraDataRNM = ReadableNativeMap::newObjectCxxArgs(extraData);
+  local_ref<ReadableMap::javaobject> extraDataRM =
+      make_local(reinterpret_cast<ReadableMap::javaobject>(extraDataRNM.get()));
+
+  // Prepare layout metrics affecting props
+  auto serializedProps = toDynamic(props);
+  local_ref<ReadableNativeMap::javaobject> propsRNM = ReadableNativeMap::newObjectCxxArgs(serializedProps);
+  local_ref<ReadableMap::javaobject> propsRM = make_local(reinterpret_cast<ReadableMap::javaobject>(propsRNM.get()));
+
+  auto measurement = yogaMeassureToSize(measure(fabricUIManager, surfaceId, componentName.get(), extraDataRM.get(),
+                                                propsRM.get(), nullptr, minimumSize.width, maximumSize.width,
+                                                minimumSize.height, maximumSize.height));
+
+  return measurement;
+}
+
+} // namespace facebook::react