react-native-enriched-html 0.0.0 → 1.1.0-nightly-20260617-3dfd09072

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

@@ -0,0 +1,109 @@
+package com.swmansion.enriched.textinput.watchers
+
+import android.text.SpanWatcher
+import android.text.Spannable
+import android.text.style.MetricAffectingSpan
+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.common.spans.interfaces.EnrichedInlineSpan
+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 or inline MetricAffectingSpan spans, 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 || (what is EnrichedInlineSpan && what is MetricAffectingSpan)) {
+      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,106 @@
+package com.swmansion.enriched.textinput.watchers
+
+import android.text.Editable
+import android.text.Spannable
+import android.text.TextWatcher
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.swmansion.enriched.common.EnrichedConstants
+import com.swmansion.enriched.textinput.EnrichedTextInputView
+import com.swmansion.enriched.textinput.events.OnChangeTextEvent
+import com.swmansion.enriched.textinput.spans.EnrichedInputAlignmentSpan
+import com.swmansion.enriched.textinput.spans.EnrichedSpans
+
+class EnrichedTextWatcher(
+  private val view: EnrichedTextInputView,
+) : TextWatcher {
+  private var endCursorPosition: Int = 0
+  private var startCursorPosition: Int = 0
+  private var previousTextLength: Int = 0
+
+  private var deletedText: String = ""
+  private var anchorAlignmentToRestore: String? = null
+
+  override fun beforeTextChanged(
+    s: CharSequence?,
+    start: Int,
+    count: Int,
+    after: Int,
+  ) {
+    previousTextLength = s?.length ?: 0
+    deletedText = if (count > 0 && s != null) s.substring(start, start + count) else ""
+
+    anchorAlignmentToRestore = null
+
+    // When a ZWS is being deleted, check whether it was anchoring a list or paragraph
+    // style. If so, capture the co-located alignment value so AlignmentStyles can
+    // re-anchor it after the deletion completes.
+    if (deletedText == EnrichedConstants.ZWS_STRING && s is Spannable) {
+      val isBlockAnchor =
+        EnrichedSpans.listSpans.values
+          .any { config -> s.getSpans(start, start + 1, config.clazz).isNotEmpty() } ||
+          EnrichedSpans.paragraphSpans.values
+            .any { config -> s.getSpans(start, start + 1, config.clazz).isNotEmpty() }
+
+      if (isBlockAnchor) {
+        anchorAlignmentToRestore =
+          s
+            .getSpans(start, start + 1, EnrichedInputAlignmentSpan::class.java)
+            .firstOrNull()
+            ?.cssValue
+      }
+    }
+  }
+
+  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)
+    view.layoutManager.invalidateLayout()
+  }
+
+  private fun applyStyles(s: Editable) {
+    view.inlineStyles?.afterTextChanged(s, startCursorPosition, endCursorPosition)
+    view.paragraphStyles?.afterTextChanged(s, endCursorPosition, previousTextLength)
+    view.listStyles?.afterTextChanged(s, endCursorPosition, previousTextLength)
+    view.alignmentStyles?.afterTextChanged(s, endCursorPosition, deletedText, anchorAlignmentToRestore)
+    view.shortcutsHandler?.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,16 @@
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+#include <react/renderer/components/ReactNativeEnrichedSpec/EnrichedTextComponentDescriptor.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/EnrichedTextComponentDescriptor.h

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

package/android/src/main/new_arch/react/renderer/components/ReactNativeEnrichedSpec/EnrichedTextInputMeasurementManager.cpp

@@ -0,0 +1,53 @@
+#include "EnrichedTextInputMeasurementManager.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 EnrichedTextInputMeasurementManager::measure(
+    SurfaceId surfaceId, int viewTag, const EnrichedTextInputViewProps &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("EnrichedTextInputView");
+
+  // 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

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "ComponentDescriptors.h"
+
+#include <react/renderer/components/ReactNativeEnrichedSpec/Props.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/utils/ContextContainer.h>
+
+namespace facebook::react {
+
+class EnrichedTextInputMeasurementManager {
+public:
+  EnrichedTextInputMeasurementManager(
+      const std::shared_ptr<const ContextContainer> &contextContainer)
+      : contextContainer_(contextContainer) {}
+
+  Size measure(SurfaceId surfaceId, int viewTag,
+               const EnrichedTextInputViewProps &props,
+               LayoutConstraints layoutConstraints) const;
+
+private:
+  const std::shared_ptr<const ContextContainer> contextContainer_;
+};
+
+} // namespace facebook::react

package/android/src/main/new_arch/react/renderer/components/ReactNativeEnrichedSpec/EnrichedTextInputShadowNode.cpp

@@ -0,0 +1,35 @@
+#include "EnrichedTextInputShadowNode.h"
+
+#include <react/renderer/core/LayoutContext.h>
+
+namespace facebook::react {
+extern const char EnrichedTextInputComponentName[] = "EnrichedTextInputView";
+void EnrichedTextInputShadowNode::setMeasurementsManager(
+    const std::shared_ptr<EnrichedTextInputMeasurementManager>
+        &measurementsManager) {
+  ensureUnsealed();
+  measurementsManager_ = measurementsManager;
+}
+
+// Mark layout as dirty after state has been updated
+// Once layout is marked as dirty, `measureContent` will be called in order to
+// recalculate layout
+void EnrichedTextInputShadowNode::dirtyLayoutIfNeeded() {
+  const auto state = this->getStateData();
+  const auto counter = state.getForceHeightRecalculationCounter();
+
+  if (forceHeightRecalculationCounter_ != counter) {
+    forceHeightRecalculationCounter_ = counter;
+
+    dirtyLayout();
+  }
+}
+
+Size EnrichedTextInputShadowNode::measureContent(
+    const LayoutContext &layoutContext,
+    const LayoutConstraints &layoutConstraints) const {
+  return measurementsManager_->measure(getSurfaceId(), getTag(),
+                                       getConcreteProps(), layoutConstraints);
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "EnrichedTextInputMeasurementManager.h"
+#include "EnrichedTextInputState.h"
+
+#include <react/renderer/components/ReactNativeEnrichedSpec/EventEmitters.h>
+#include <react/renderer/components/ReactNativeEnrichedSpec/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char EnrichedTextInputComponentName[];
+/*
+ * `ShadowNode` for <EnrichedTextInputView> component.
+ */
+class EnrichedTextInputShadowNode final
+    : public ConcreteViewShadowNode<
+          EnrichedTextInputComponentName, EnrichedTextInputViewProps,
+          EnrichedTextInputViewEventEmitter, EnrichedTextInputState> {
+public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  // This constructor is called when we "update" shadow node, e.g. after
+  // updating shadow node's state
+  EnrichedTextInputShadowNode(ShadowNode const &sourceShadowNode,
+                              ShadowNodeFragment const &fragment)
+      : ConcreteViewShadowNode(sourceShadowNode, fragment) {
+    dirtyLayoutIfNeeded();
+  }
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  // Associates a shared `EnrichedTextInputMeasurementManager` with the node.
+  void setMeasurementsManager(
+      const std::shared_ptr<EnrichedTextInputMeasurementManager>
+          &measurementsManager);
+
+  void dirtyLayoutIfNeeded();
+
+  Size
+  measureContent(const LayoutContext &layoutContext,
+                 const LayoutConstraints &layoutConstraints) const override;
+
+private:
+  int forceHeightRecalculationCounter_;
+  std::shared_ptr<EnrichedTextInputMeasurementManager> measurementsManager_;
+};
+} // namespace facebook::react

package/android/src/main/new_arch/react/renderer/components/ReactNativeEnrichedSpec/EnrichedTextInputState.cpp

@@ -0,0 +1,9 @@
+#include "EnrichedTextInputState.h"
+
+namespace facebook::react {
+
+int EnrichedTextInputState::getForceHeightRecalculationCounter() const {
+  return forceHeightRecalculationCounter_;
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <folly/dynamic.h>
+
+namespace facebook::react {
+
+class EnrichedTextInputState {
+public:
+  EnrichedTextInputState() : forceHeightRecalculationCounter_(0) {}
+
+  // Used by Kotlin to set current text value
+  EnrichedTextInputState(EnrichedTextInputState const &previousState,
+                         folly::dynamic data)
+      : forceHeightRecalculationCounter_(
+            (int)data["forceHeightRecalculationCounter"].getInt()){};
+  folly::dynamic getDynamic() const { return {}; };
+
+  int getForceHeightRecalculationCounter() const;
+
+private:
+  const int forceHeightRecalculationCounter_{};
+};
+
+} // namespace facebook::react

package/android/src/main/new_arch/react/renderer/components/ReactNativeEnrichedSpec/EnrichedTextMeasurementManager.cpp

@@ -0,0 +1,45 @@
+#include "EnrichedTextMeasurementManager.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 EnrichedTextMeasurementManager::measure(
+    SurfaceId surfaceId, int viewTag, const EnrichedTextViewProps &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("EnrichedTextView");
+
+  // 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(), nullptr,
+              propsRM.get(), nullptr, minimumSize.width, maximumSize.width,
+              minimumSize.height, maximumSize.height));
+
+  return measurement;
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "ComponentDescriptors.h"
+
+#include <react/renderer/components/ReactNativeEnrichedSpec/Props.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/utils/ContextContainer.h>
+
+namespace facebook::react {
+
+class EnrichedTextMeasurementManager {
+public:
+  EnrichedTextMeasurementManager(
+      const std::shared_ptr<const ContextContainer> &contextContainer)
+      : contextContainer_(contextContainer) {}
+
+  Size measure(SurfaceId surfaceId, int viewTag,
+               const EnrichedTextViewProps &props,
+               LayoutConstraints layoutConstraints) const;
+
+private:
+  const std::shared_ptr<const ContextContainer> contextContainer_;
+};
+
+} // namespace facebook::react