@fendent/react-native-enriched 0.5.2-fork.1

package/android/src/main/java/com/swmansion/enriched/textinput/utils/EnrichedSpannable.kt

@@ -0,0 +1,106 @@
+package com.swmansion.enriched.textinput.utils
+
+import android.text.Spannable
+import android.text.SpannableString
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.common.spans.interfaces.EnrichedBlockSpan
+import com.swmansion.enriched.common.spans.interfaces.EnrichedParagraphSpan
+
+fun Spannable.getSafeSpanBoundaries(
+  start: Int,
+  end: Int,
+): Pair<Int, Int> {
+  val safeStart = start.coerceAtMost(end).coerceAtLeast(0)
+  val safeEnd = end.coerceAtLeast(start).coerceAtMost(this.length)
+
+  return Pair(safeStart, safeEnd)
+}
+
+fun Spannable.getParagraphBounds(
+  start: Int,
+  end: Int,
+): Pair<Int, Int> {
+  var startPosition = start.coerceAtLeast(0).coerceAtMost(this.length)
+  var endPosition = end.coerceAtLeast(0).coerceAtMost(this.length)
+
+  // Find the start of the paragraph
+  while (startPosition > 0 && this[startPosition - 1] != '\n') {
+    startPosition--
+  }
+
+  // Find the end of the paragraph
+  while (endPosition < this.length && this[endPosition] != '\n') {
+    endPosition++
+  }
+
+  if (startPosition >= endPosition) {
+    // If the start position is equal or greater than the end position, return the same position
+    startPosition = endPosition
+  }
+
+  return Pair(startPosition, endPosition)
+}
+
+fun Spannable.getParagraphBounds(index: Int): Pair<Int, Int> = this.getParagraphBounds(index, index)
+
+fun Spannable.mergeSpannables(
+  start: Int,
+  end: Int,
+  string: String,
+): Spannable = this.mergeSpannables(start, end, SpannableString(string))
+
+fun Spannable.mergeSpannables(
+  start: Int,
+  end: Int,
+  spannable: Spannable,
+): Spannable {
+  var finalStart = start
+  var finalEnd = end
+
+  val builder = SpannableStringBuilder(this)
+  val startBlockSpans = spannable.getSpans(0, 0, EnrichedBlockSpan::class.java)
+  val startParagraphSpans = spannable.getSpans(0, 0, EnrichedParagraphSpan::class.java)
+  val endBlockSpans = spannable.getSpans(this.length, this.length, EnrichedBlockSpan::class.java)
+  val endParagraphSpans = spannable.getSpans(this.length, this.length, EnrichedParagraphSpan::class.java)
+  val (paragraphStart, paragraphEnd) = this.getParagraphBounds(start, end)
+  val isNewLineStart = startBlockSpans.isNotEmpty() || startParagraphSpans.isNotEmpty()
+  val isNewLineEnd = endBlockSpans.isNotEmpty() || endParagraphSpans.isNotEmpty()
+
+  val pastedHasOwnStyles =
+    spannable.getSpans(0, spannable.length, EnrichedBlockSpan::class.java).isNotEmpty() ||
+      spannable.getSpans(0, spannable.length, EnrichedParagraphSpan::class.java).isNotEmpty()
+
+  if (isNewLineStart && start != paragraphStart) {
+    builder.insert(start, "\n")
+    finalStart = start + 1
+    finalEnd = end + 1
+  }
+
+  if (isNewLineEnd && end != paragraphEnd) {
+    builder.insert(finalEnd, "\n")
+  }
+
+  builder.replace(finalStart, finalEnd, spannable)
+
+  // Manually extend existing paragraph/block spans to cover the pasted text.
+  if (!pastedHasOwnStyles) {
+    val pasteEnd = finalStart + spannable.length
+
+    val affectedParagraphSpans = builder.getSpans(finalStart, finalStart, EnrichedParagraphSpan::class.java)
+    val affectedBlockSpans = builder.getSpans(finalStart, finalStart, EnrichedBlockSpan::class.java)
+    val affectedSpans = affectedBlockSpans.toList() + affectedParagraphSpans.toList()
+
+    for (span in affectedSpans) {
+      val spanStart = builder.getSpanStart(span)
+      val spanEnd = builder.getSpanEnd(span)
+      if (spanStart == -1 || spanEnd >= pasteEnd) continue
+
+      val (_, newParagraphEnd) = builder.getParagraphBounds(spanStart, pasteEnd)
+      val flags = builder.getSpanFlags(span)
+      builder.removeSpan(span)
+      builder.setSpan(span, spanStart, newParagraphEnd, flags)
+    }
+  }
+
+  return builder
+}

package/android/src/main/java/com/swmansion/enriched/textinput/utils/EnrichedSpannableStringBuilder.kt

@@ -0,0 +1,24 @@
+package com.swmansion.enriched.textinput.utils
+
+import android.text.SpannableStringBuilder
+import com.swmansion.enriched.common.EnrichedConstants
+
+fun CharSequence.zwsCountBefore(index: Int): Int {
+  var count = 0
+  for (i in 0 until index) {
+    if (this[i] == EnrichedConstants.ZWS) count++
+  }
+  return count
+}
+
+// Removes zero-width spaces from the given range in the SpannableStringBuilder without affecting spans
+fun SpannableStringBuilder.removeZWS(
+  start: Int,
+  end: Int,
+) {
+  for (i in (end - 1) downTo start) {
+    if (this[i] == EnrichedConstants.ZWS) {
+      delete(i, i + 1)
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/textinput/utils/RichContentReceiver.kt

@@ -0,0 +1,127 @@
+package com.swmansion.enriched.textinput.utils
+
+import android.content.ClipData
+import android.content.Context
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import android.webkit.MimeTypeMap
+import androidx.core.view.ContentInfoCompat
+import androidx.core.view.OnReceiveContentListener
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.textinput.EnrichedTextInputView
+import com.swmansion.enriched.textinput.events.OnPasteImagesEvent
+import java.io.File
+import java.io.FileOutputStream
+import kotlin.io.copyTo
+
+class RichContentReceiver(
+  private val view: EnrichedTextInputView,
+  private val context: ReactContext,
+) : OnReceiveContentListener {
+  override fun onReceiveContent(
+    view: View,
+    contentInfo: ContentInfoCompat,
+  ): ContentInfoCompat? {
+    val split = contentInfo.partition { item: ClipData.Item -> item.uri != null }
+    val uriContent = split.first
+    val remaining = split.second
+
+    if (uriContent != null) {
+      processClipDataInBackground(uriContent.clip)
+    }
+
+    if (remaining != null && remaining.clip.itemCount > 0) {
+      val item = remaining.clip.getItemAt(0)
+
+      this.view.handleTextPaste(item)
+    }
+
+    return null
+  }
+
+  private fun processClipDataInBackground(clip: ClipData) {
+    Thread {
+      val results = mutableListOf<OnPasteImagesEvent.Companion.PastedImage>()
+
+      for (i in 0 until clip.itemCount) {
+        val item = clip.getItemAt(i)
+        val uri = item.uri ?: continue
+        val mimeType = getMimeTypeFromUri(uri) ?: continue
+
+        if (mimeType.startsWith("image/")) {
+          val result = saveUriToTempFile(context, uri, mimeType)
+          if (result != null) {
+            results.add(result)
+          }
+        }
+      }
+
+      if (results.isNotEmpty()) {
+        Handler(Looper.getMainLooper()).post {
+          emitOnPasteImageEvent(results)
+        }
+      }
+    }.start()
+  }
+
+  private fun emitOnPasteImageEvent(images: List<OnPasteImagesEvent.Companion.PastedImage>) {
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    dispatcher?.dispatchEvent(OnPasteImagesEvent(surfaceId, view.id, images, false))
+  }
+
+  private fun saveUriToTempFile(
+    context: Context,
+    uri: Uri,
+    mimeType: String,
+  ): OnPasteImagesEvent.Companion.PastedImage? {
+    return try {
+      val resolver = context.contentResolver
+      val ext = MimeTypeMap.getFileExtensionFromUrl(uri.toString())
+      val file = File.createTempFile("temp", ".$ext", context.cacheDir)
+
+      // Copy Stream
+      resolver.openInputStream(uri).use { input ->
+        if (input == null) return null
+        FileOutputStream(file).use { output ->
+          input.copyTo(output)
+        }
+      }
+
+      // Decode Dimensions
+      val options = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+      BitmapFactory.decodeFile(file.absolutePath, options)
+
+      OnPasteImagesEvent.Companion.PastedImage(
+        uri = "file://${file.absolutePath}",
+        type = mimeType,
+        width = options.outWidth.toDouble(),
+        height = options.outHeight.toDouble(),
+      )
+    } catch (e: Exception) {
+      Log.e("RichContentReceiver", "Failed to save URI: $uri", e)
+      null
+    }
+  }
+
+  private fun getMimeTypeFromUri(uri: Uri): String? {
+    var mimeType = context.contentResolver.getType(uri)
+
+    if (mimeType == null) {
+      val extension = MimeTypeMap.getFileExtensionFromUrl(uri.toString())
+
+      mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension)
+    }
+
+    return mimeType
+  }
+
+  companion object {
+    val MIME_TYPES = arrayOf("image/*", "text/*")
+  }
+}

package/android/src/main/java/com/swmansion/enriched/textinput/utils/Utils.kt

@@ -0,0 +1,106 @@
+package com.swmansion.enriched.textinput.utils
+
+import android.annotation.SuppressLint
+import android.text.Selection
+import android.text.Spannable
+import android.text.Spanned
+import android.util.Log
+import android.view.MotionEvent
+import android.widget.TextView
+import com.swmansion.enriched.textinput.spans.EnrichedInputCheckboxListSpan
+import org.json.JSONObject
+
+fun jsonStringToStringMap(json: String): Map<String, String> {
+  val result = mutableMapOf<String, String>()
+  try {
+    val jsonObject = JSONObject(json)
+    for (key in jsonObject.keys()) {
+      val value = jsonObject.opt(key)
+      if (value is String) {
+        result[key] = value
+      }
+    }
+  } catch (e: Exception) {
+    Log.w("ReactNativeEnrichedView", "Failed to parse JSON string to Map: $json", e)
+  }
+
+  return result
+}
+
+// Sets a touch listener on TextView which is responsible for detecting touches on checkbox icons
+// We don't use ClickableSpan because it works fine only when LinkMovementMethod is set on TextView
+// Which breaks text selection and other features
+@SuppressLint("ClickableViewAccessibility")
+fun TextView.setCheckboxClickListener() {
+  var isDownOnCheckbox = false
+
+  setOnTouchListener { v, event ->
+    val tv = v as TextView
+    val layout = tv.layout ?: return@setOnTouchListener false
+    val spannable = tv.text as? Spanned ?: return@setOnTouchListener false
+
+    // Get touch coordinates relative to the text content
+    val x = event.x.toInt() - tv.totalPaddingLeft + tv.scrollX
+    val y = event.y.toInt() - tv.totalPaddingTop + tv.scrollY
+
+    // Identify the line and whether it's the first line of the span
+    val line = layout.getLineForVertical(y)
+    val lineStart = layout.getLineStart(line)
+
+    // Find spans for specific line
+    val spans = spannable.getSpans(lineStart, lineStart, EnrichedInputCheckboxListSpan::class.java)
+    if (spans.isEmpty()) return@setOnTouchListener false
+
+    // There should be only one span per line as we don't support nested lists
+    val span = spans[0]
+    val isFirstLine = spannable.getSpanStart(span) == lineStart
+    val marginWidth = span.getLeadingMargin(true)
+
+    // Check if touch is on checkbox icon area (which is in the leading margin on the first line)
+    val isInHotZone = isFirstLine && x in 0..marginWidth
+
+    when (event.action) {
+      MotionEvent.ACTION_DOWN -> {
+        if (isInHotZone) {
+          isDownOnCheckbox = true
+          return@setOnTouchListener true
+        }
+      }
+
+      MotionEvent.ACTION_UP -> {
+        if (isDownOnCheckbox && isInHotZone) {
+          val spannable = tv.text as? Spannable
+          if (spannable != null) {
+            val start = spannable.getSpanStart(span)
+            val end = spannable.getSpanEnd(span)
+            val flags = spannable.getSpanFlags(span)
+            span.isChecked = !span.isChecked
+
+            // Reapply span so changes are visible without need to redraw entire TextView
+            spannable.removeSpan(span)
+            spannable.setSpan(span, start, end, flags)
+
+            // For focused input, ensure cursor is active for affected paragraph
+            if (tv.isFocused) {
+              val currentCursor = Selection.getSelectionEnd(spannable)
+              if (currentCursor < start || currentCursor > end) {
+                Selection.setSelection(spannable, end)
+              }
+            }
+          }
+
+          isDownOnCheckbox = false
+          return@setOnTouchListener true
+        }
+        isDownOnCheckbox = false
+      }
+
+      MotionEvent.ACTION_CANCEL -> {
+        isDownOnCheckbox = false
+      }
+    }
+
+    // Let TextView handle other touches (e.g., for selection)
+    false
+  }
+}

package/android/src/main/java/com/swmansion/enriched/textinput/watchers/EnrichedSpanWatcher.kt

@@ -0,0 +1,107 @@
+package com.swmansion.enriched.textinput.watchers
+
+import android.text.SpanWatcher
+import android.text.Spannable
+import android.text.style.ParagraphStyle
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.common.parser.EnrichedParser
+import com.swmansion.enriched.common.spans.interfaces.EnrichedHeadingSpan
+import com.swmansion.enriched.textinput.EnrichedTextInputView
+import com.swmansion.enriched.textinput.events.OnChangeHtmlEvent
+import com.swmansion.enriched.textinput.spans.EnrichedInputOrderedListSpan
+import com.swmansion.enriched.textinput.spans.interfaces.EnrichedInputSpan
+import com.swmansion.enriched.textinput.utils.getSafeSpanBoundaries
+
+class EnrichedSpanWatcher(
+  private val view: EnrichedTextInputView,
+) : SpanWatcher {
+  private var previousHtml: String? = null
+
+  override fun onSpanAdded(
+    text: Spannable,
+    what: Any,
+    start: Int,
+    end: Int,
+  ) {
+    updateNextLineLayout(what, text, end)
+    updateUnorderedListSpans(what, text, end)
+    emitEvent(text, what)
+  }
+
+  override fun onSpanRemoved(
+    text: Spannable,
+    what: Any,
+    start: Int,
+    end: Int,
+  ) {
+    updateNextLineLayout(what, text, end)
+    updateUnorderedListSpans(what, text, end)
+    emitEvent(text, what)
+  }
+
+  override fun onSpanChanged(
+    text: Spannable,
+    what: Any,
+    ostart: Int,
+    oend: Int,
+    nstart: Int,
+    nend: Int,
+  ) {
+    // Do nothing for now
+  }
+
+  private fun updateUnorderedListSpans(
+    what: Any,
+    text: Spannable,
+    end: Int,
+  ) {
+    if (what is EnrichedInputOrderedListSpan) {
+      view.listStyles?.updateOrderedListIndexes(text, end)
+    }
+  }
+
+  // After adding/removing heading span, we have to manually set empty paragraph span to the following text
+  // This allows us to update the layout (as it's not updated automatically - looks like an Android issue)
+  private fun updateNextLineLayout(
+    what: Any,
+    text: Spannable,
+    end: Int,
+  ) {
+    class EmptySpan : ParagraphStyle
+
+    if (what is EnrichedHeadingSpan) {
+      val finalStart = (end + 1)
+      val finalEnd = text.length
+      val (safeStart, safeEnd) = text.getSafeSpanBoundaries(finalStart, finalEnd)
+      text.setSpan(EmptySpan(), safeStart, safeEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+    }
+  }
+
+  fun emitEvent(
+    s: Spannable,
+    what: Any?,
+  ) {
+    // Do not parse spannable and emit event if onChangeHtml is not provided
+    if (!view.shouldEmitHtml) return
+
+    // Emit event only if we change one of ours spans
+    if (what != null && what !is EnrichedInputSpan) return
+
+    val html = EnrichedParser.toHtml(s)
+    if (html == previousHtml) return
+
+    previousHtml = html
+    val context = view.context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    dispatcher?.dispatchEvent(
+      OnChangeHtmlEvent(
+        surfaceId,
+        view.id,
+        html,
+        view.experimentalSynchronousEvents,
+      ),
+    )
+  }
+}

package/android/src/main/java/com/swmansion/enriched/textinput/watchers/EnrichedTextWatcher.kt

@@ -0,0 +1,74 @@
+package com.swmansion.enriched.textinput.watchers
+
+import android.text.Editable
+import android.text.TextWatcher
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.textinput.EnrichedTextInputView
+import com.swmansion.enriched.textinput.events.OnChangeTextEvent
+
+class EnrichedTextWatcher(
+  private val view: EnrichedTextInputView,
+) : TextWatcher {
+  private var endCursorPosition: Int = 0
+  private var startCursorPosition: Int = 0
+  private var previousTextLength: Int = 0
+
+  override fun beforeTextChanged(
+    s: CharSequence?,
+    start: Int,
+    count: Int,
+    after: Int,
+  ) {
+    previousTextLength = s?.length ?: 0
+  }
+
+  override fun onTextChanged(
+    s: CharSequence?,
+    start: Int,
+    before: Int,
+    count: Int,
+  ) {
+    startCursorPosition = start
+    endCursorPosition = start + count
+    view.layoutManager.invalidateLayout()
+    view.isRemovingMany = !view.isDuringTransaction && before > count + 1
+  }
+
+  override fun afterTextChanged(s: Editable?) {
+    if (s == null) return
+    emitEvents(s)
+
+    if (view.isDuringTransaction) return
+    applyStyles(s)
+  }
+
+  private fun applyStyles(s: Editable) {
+    view.inlineStyles?.afterTextChanged(s, endCursorPosition)
+    view.paragraphStyles?.afterTextChanged(s, endCursorPosition, previousTextLength)
+    view.listStyles?.afterTextChanged(s, endCursorPosition, previousTextLength)
+    view.parametrizedStyles?.afterTextChanged(s, startCursorPosition, endCursorPosition)
+  }
+
+  private fun emitChangeText(editable: Editable) {
+    if (!view.shouldEmitOnChangeText) {
+      return
+    }
+    val context = view.context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(context)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    dispatcher?.dispatchEvent(
+      OnChangeTextEvent(
+        surfaceId,
+        view.id,
+        editable,
+        view.experimentalSynchronousEvents,
+      ),
+    )
+  }
+
+  private fun emitEvents(s: Editable) {
+    emitChangeText(s)
+    view.spanWatcher?.emitEvent(s, null)
+  }
+}

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

@@ -0,0 +1,62 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+set(LIB_LITERAL ReactNativeEnrichedSpec)
+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(LIB_CPP_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../cpp)
+
+file(GLOB LIB_MODULE_SRCS CONFIGURE_DEPENDS *.cpp react/renderer/components/${LIB_LITERAL}/*.cpp)
+file(GLOB LIB_CODEGEN_SRCS CONFIGURE_DEPENDS ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}/*.cpp)
+file(GLOB LIB_CPP_SRCS CONFIGURE_DEPENDS ${LIB_CPP_DIR}/parser/GumboParser.cpp ${LIB_CPP_DIR}/parser/GumboNormalizer.c)
+
+set_source_files_properties(${LIB_CPP_DIR}/parser/GumboNormalizer.c PROPERTIES LANGUAGE C COMPILE_FLAGS "-std=c99")
+
+if(NOT DEFINED REACT_NATIVE_MINOR_VERSION)
+  set(REACT_NATIVE_MINOR_VERSION ${ReactAndroid_VERSION_MINOR})
+endif()
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}")
+
+add_library(
+        ${LIB_TARGET_NAME}
+        SHARED
+        ${LIB_MODULE_SRCS}
+        ${LIB_CUSTOM_SRCS}
+        ${LIB_CODEGEN_SRCS}
+        ${LIB_CPP_SRCS}
+)
+
+target_include_directories(
+        ${LIB_TARGET_NAME}
+        PUBLIC
+        .
+        ./react/renderer/components/${LIB_LITERAL}
+        ${LIB_ANDROID_GENERATED_JNI_DIR}
+        ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}
+        ${LIB_CPP_DIR}
+        ${LIB_CPP_DIR}/parser
+        ${LIB_CPP_DIR}/GumboParser
+)
+
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+
+target_link_libraries(
+        ${LIB_TARGET_NAME}
+        fbjni::fbjni
+        ReactAndroid::jsi
+        ReactAndroid::reactnative
+)
+
+target_compile_reactnative_options(${LIB_TARGET_NAME} PRIVATE)
+
+target_include_directories(
+        ${CMAKE_PROJECT_NAME}
+        PUBLIC
+        ${CMAKE_CURRENT_SOURCE_DIR}
+)

package/android/src/main/new_arch/GumboNormalizerJni.cpp

@@ -0,0 +1,14 @@
+#include "GumboParser.hpp"
+#include <jni.h>
+#include <string>
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_com_swmansion_enriched_common_GumboNormalizer_normalizeHtml(
+    JNIEnv *env, jclass /*cls*/, jstring htmlJString) {
+  const char *htmlChars = env->GetStringUTFChars(htmlJString, nullptr);
+  std::string result = GumboParser::normalizeHtml(htmlChars);
+  env->ReleaseStringUTFChars(htmlJString, htmlChars);
+  if (result.empty())
+    return nullptr;
+  return env->NewStringUTF(result.c_str());
+}

package/android/src/main/new_arch/ReactNativeEnrichedSpec.cpp

@@ -0,0 +1,11 @@
+#include "ReactNativeEnrichedSpec.h"
+
+namespace facebook::react {
+
+std::shared_ptr<TurboModule> ReactNativeEnrichedSpec_ModuleProvider(
+    const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+
+  return nullptr;
+}
+
+} // namespace facebook::react

package/android/src/main/new_arch/ReactNativeEnrichedSpec.h

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

package/android/src/main/new_arch/react/renderer/components/ReactNativeEnrichedSpec/EnrichedTextInputComponentDescriptor.h

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