react-native-typerich 0.1.0

package/android/src/main/java/com/typerich/TypeRichTextInputViewPackage.kt

@@ -0,0 +1,19 @@
+package com.typerich
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import java.util.ArrayList
+
+class TypeRichTextInputViewPackage : ReactPackage {
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    val viewManagers: MutableList<ViewManager<*, *>> = ArrayList()
+    viewManagers.add(TypeRichTextInputViewManager())
+    return viewManagers
+  }
+
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/typerich/events/OnChangeSelectionEvent.kt

@@ -0,0 +1,29 @@
+package com.typerich.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnChangeSelectionEvent(surfaceId: Int, viewId: Int, private val text: String, private val start: Int, private val end: Int, private val experimentalSynchronousEvents: Boolean) :
+  Event<OnChangeSelectionEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String {
+    return EVENT_NAME
+  }
+
+  override fun getEventData(): WritableMap {
+    val eventData: WritableMap = Arguments.createMap()
+    eventData.putString("text", text)
+    eventData.putInt("start", start)
+    eventData.putInt("end", end)
+    return eventData
+  }
+
+  override fun experimental_isSynchronous(): Boolean {
+    return experimentalSynchronousEvents
+  }
+
+  companion object {
+    const val EVENT_NAME: String = "onChangeSelection"
+  }
+}

package/android/src/main/java/com/typerich/events/OnChangeTextEvent.kt

@@ -0,0 +1,35 @@
+package com.typerich.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnChangeTextEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val text: String,
+  private val experimentalSynchronousEvents: Boolean
+) : Event<OnChangeTextEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String {
+    return EVENT_NAME
+  }
+
+  override fun getEventData(): WritableMap {
+    val eventData = Arguments.createMap()
+
+    // Remove zero-width spaces React Native inserts sometimes
+    val normalizedText = text.replace(Regex("\\u200B"), "")
+
+    eventData.putString("value", normalizedText)
+    return eventData
+  }
+
+  override fun experimental_isSynchronous(): Boolean {
+    return experimentalSynchronousEvents
+  }
+
+  companion object {
+    const val EVENT_NAME = "onChangeText"
+  }
+}

package/android/src/main/java/com/typerich/events/OnInputBlurEvent.kt

@@ -0,0 +1,27 @@
+package com.typerich.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnInputBlurEvent(surfaceId: Int, viewId: Int, private val experimentalSynchronousEvents: Boolean) :
+  Event<OnInputBlurEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String {
+    return EVENT_NAME
+  }
+
+  override fun getEventData(): WritableMap {
+    val eventData: WritableMap = Arguments.createMap()
+
+    return eventData
+  }
+
+  override fun experimental_isSynchronous(): Boolean {
+    return experimentalSynchronousEvents
+  }
+
+  companion object {
+    const val EVENT_NAME: String = "onInputBlur"
+  }
+}

package/android/src/main/java/com/typerich/events/OnInputFocusEvent.kt

@@ -0,0 +1,27 @@
+package com.typerich.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnInputFocusEvent(surfaceId: Int, viewId: Int, private val experimentalSynchronousEvents: Boolean) :
+  Event<OnInputFocusEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String {
+    return EVENT_NAME
+  }
+
+  override fun getEventData(): WritableMap {
+    val eventData: WritableMap = Arguments.createMap()
+
+    return eventData
+  }
+
+  override fun experimental_isSynchronous(): Boolean {
+    return experimentalSynchronousEvents
+  }
+
+  companion object {
+    const val EVENT_NAME: String = "onInputFocus"
+  }
+}

package/android/src/main/java/com/typerich/events/OnPasteImageEvent.kt

@@ -0,0 +1,45 @@
+package com.typerich.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class OnPasteImageEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val uri: String,
+  private val type: String,
+  private val fileName: String,
+  private val fileSize: Double,  // RN Int32 maps to Kotlin Int
+  private val errorMessage: String? = null,
+  private val experimentalSynchronousEvents: Boolean
+) : Event<OnPasteImageEvent>(surfaceId, viewId) {
+
+  override fun getEventName() = EVENT_NAME
+  override fun canCoalesce() = false
+
+  override fun getEventData(): WritableMap {
+    val map = Arguments.createMap()
+
+    map.putString("uri", uri)
+    map.putString("type", type)
+    map.putString("fileName", fileName)
+    map.putDouble("fileSize", fileSize)
+
+    if (errorMessage != null) {
+      val errorMap = Arguments.createMap()
+      errorMap.putString("message", errorMessage)
+      map.putMap("error", errorMap)
+    }
+
+    return map
+  }
+
+  override fun experimental_isSynchronous(): Boolean {
+    return experimentalSynchronousEvents
+  }
+
+  companion object {
+    const val EVENT_NAME = "onPasteImage"
+  }
+}

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

@@ -0,0 +1,73 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+# The JS spec name → codegen outputs react_codegen_<name>
+set(LIB_SPEC_LITERAL TypeRichTextInputViewSpec)
+
+# Your actual custom C++ folder name
+set(LIB_CUSTOM_LITERAL TypeRichTextInputView)
+
+set(LIB_TARGET_NAME react_codegen_${LIB_SPEC_LITERAL})
+
+# Directories
+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_SPEC_LITERAL})
+
+set(LIB_CUSTOM_DIR ${CMAKE_CURRENT_SOURCE_DIR}/react/renderer/components/${LIB_CUSTOM_LITERAL})
+
+# Custom handwritten C++ code
+file(GLOB LIB_CUSTOM_SRCS CONFIGURE_DEPENDS
+    ${LIB_CUSTOM_DIR}/*.cpp
+)
+
+# Codegen generated files
+file(GLOB LIB_CODEGEN_SRCS CONFIGURE_DEPENDS
+    ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}/*.cpp
+)
+
+add_library(
+        ${LIB_TARGET_NAME}
+        SHARED
+        ${CMAKE_CURRENT_SOURCE_DIR}/TypeRichTextInputViewSpec.cpp
+        ${LIB_CUSTOM_SRCS}
+        ${LIB_CODEGEN_SRCS}
+)
+
+target_include_directories(
+        ${LIB_TARGET_NAME}
+        PUBLIC
+        .
+        ${LIB_CUSTOM_DIR}
+        ${LIB_ANDROID_GENERATED_JNI_DIR}
+        ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}
+)
+
+find_package(fbjni REQUIRED CONFIG)
+find_package(ReactAndroid REQUIRED CONFIG)
+
+target_link_libraries(
+        ${LIB_TARGET_NAME}
+        fbjni::fbjni
+        ReactAndroid::jsi
+        ReactAndroid::reactnative
+        log
+)
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 80)
+  target_compile_reactnative_options(${LIB_TARGET_NAME} PRIVATE)
+else()
+  target_compile_options(
+          ${LIB_TARGET_NAME}
+          PRIVATE
+          -fexceptions
+          -frtti
+          -Wall
+  )
+endif()
+
+target_include_directories(
+        ${CMAKE_PROJECT_NAME}
+        PUBLIC
+        ${CMAKE_CURRENT_SOURCE_DIR}
+)

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

@@ -0,0 +1,22 @@
+
+/**
+ * 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 "TypeRichTextInputViewSpec.h"
+
+namespace facebook::react {
+
+std::shared_ptr<TurboModule> TypeRichTextInputViewSpec_ModuleProvider(
+    const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+
+  return nullptr;
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,26 @@
+
+/**
+ * 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: GenerateModuleJniH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+#include <react/renderer/components/TypeRichTextInputView/TypeRichTextInputViewComponentDescriptor.h>
+
+namespace facebook::react {
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> TypeRichTextInputViewSpec_ModuleProvider(
+    const std::string &moduleName, const JavaTurboModule::InitParams &params);
+
+} // namespace facebook::react

package/android/src/main/new_arch/react/renderer/components/TypeRichTextInputView/TypeRichTextInputViewComponentDescriptor.h

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

package/android/src/main/new_arch/react/renderer/components/TypeRichTextInputView/TypeRichTextInputViewMeasurementManager.cpp

@@ -0,0 +1,83 @@
+#include "TypeRichTextInputViewMeasurementManager.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 {
+
+float TypeRichTextInputViewMeasurementManager::measureSingleLineHeight(
+    const TypeRichTextInputViewProps &props) const {
+
+  // TODO: Proper measurement. Temporary fallback.
+  if (props.fontSize > 0) {
+    return props.fontSize * 1.2f;
+  }
+
+  return 20.0f;
+}
+
+Size TypeRichTextInputViewMeasurementManager::measure(
+    SurfaceId surfaceId, int viewTag, const TypeRichTextInputViewProps &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;
+
+  // CRITICAL FIX: Clamp maximum height BEFORE measuring if numberOfLines is set
+  if (props.numberOfLines > 0 && props.multiline) {
+    float lineHeight = measureSingleLineHeight(props);
+    // Don't guess padding here — clamp based on content height only.
+    float maxAllowedContentHeight = (lineHeight * props.numberOfLines);
+
+    // If props contains padding you can add it:
+    // float paddingTop = props.paddingTop; // if available
+    // float paddingBottom = props.paddingBottom;
+    // float maxAllowedHeight = paddingTop + paddingBottom +
+    // maxAllowedContentHeight;
+
+    float maxAllowedHeight = maxAllowedContentHeight; // no guessed padding
+
+    // Clamp the max height constraint (this clamps the content area)
+    maximumSize.height = std::min(maximumSize.height, maxAllowedHeight);
+  }
+
+  local_ref<JString> componentName = make_jstring("TypeRichTextInputView");
+
+  // 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/TypeRichTextInputView/TypeRichTextInputViewMeasurementManager.h

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

package/android/src/main/new_arch/react/renderer/components/TypeRichTextInputView/TypeRichTextInputViewShadowNode.cpp

@@ -0,0 +1,132 @@
+#include "TypeRichTextInputViewShadowNode.h"
+
+#include "conversions.h"
+#include <android/log.h>
+#include <folly/json.h>
+#include <react/renderer/core/LayoutContext.h>
+
+namespace facebook::react {
+extern const char TypeRichTextInputViewComponentName[] =
+    "TypeRichTextInputView";
+void TypeRichTextInputViewShadowNode::setMeasurementsManager(
+    const std::shared_ptr<TypeRichTextInputViewMeasurementManager>
+        &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 TypeRichTextInputViewShadowNode::dirtyLayoutIfNeeded() {
+  const auto state = this->getStateData();
+  const auto counter = state.getForceHeightRecalculationCounter();
+
+  if (forceHeightRecalculationCounter_ != counter) {
+    forceHeightRecalculationCounter_ = counter;
+
+    dirtyLayout();
+  }
+}
+
+Size TypeRichTextInputViewShadowNode::measureContent(
+    const LayoutContext &layoutContext,
+    const LayoutConstraints &layoutConstraints) const {
+
+  const auto &props = getConcreteProps();
+
+  try {
+    folly::dynamic dyn = toDynamic(props);
+    std::string json = folly::toJson(dyn);
+    __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp",
+                        "toDynamic(props) = %s", json.c_str());
+  } catch (const std::exception &e) {
+    __android_log_print(ANDROID_LOG_ERROR, "TypeRichCpp",
+                        "toDynamic() threw: %s", e.what());
+  }
+  auto size = measurementsManager_->measure(getSurfaceId(), getTag(), props,
+                                            layoutConstraints);
+
+  float lineHeight = measurementsManager_->measureSingleLineHeight(props);
+
+  // single line mode
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "numberOfLines = %d",
+                      props.numberOfLines);
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "multiline = %s",
+                      props.multiline ? "true" : "false");
+
+  if (!props.multiline) {
+    size.height = lineHeight;
+    return size;
+  }
+
+  //  multiline without limit
+  if (props.numberOfLines <= 0) {
+    return size; // natural Android height
+  }
+
+  // multiline with limit and autogrow
+  // Extract padding (React Native provides it inside props.style)
+  // Read padding from Fabric LayoutMetrics (RN 0.75+)
+  const auto &layoutMetrics = getLayoutMetrics();
+  float paddingTop = layoutMetrics.contentInsets.top;
+  float paddingBottom = layoutMetrics.contentInsets.bottom;
+
+  float naturalHeight = size.height;
+
+  // Remove padding to calculate pure text height
+  float contentHeight = naturalHeight - paddingTop - paddingBottom;
+  contentHeight = std::max(0.f, contentHeight);
+
+  // Compute natural line count
+  float rawLines = contentHeight / lineHeight;
+  int naturalLines = std::max(1, (int)std::floor(rawLines));
+
+  // Clamp based on numberOfLines
+  int finalLines = std::min(naturalLines, props.numberOfLines);
+
+  // Reapply padding
+  size.height = paddingTop + paddingBottom + lineHeight * finalLines;
+
+  // Handle single line case, bugfix when there is only single line remaining
+  // after you delete other lines
+  // temp fix might change implementation later
+  if (finalLines == 1) {
+    size.height = naturalHeight;
+    return size;
+  }
+
+  // bugfix height of one line after the numberof lines is reached
+  // temp fix might change implementation later
+  if (finalLines == props.numberOfLines) {
+    size.height = lineHeight * finalLines;
+    __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp",
+                        "size reached finalLines = numberOfLines");
+    __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", " size.height  = %f",
+                        size.height);
+    return size;
+  }
+
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "naturalHeight = %f",
+                      naturalHeight);
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "contentHeight = %f",
+                      contentHeight);
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "rawLines = %f",
+                      rawLines);
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "naturalLines = %d",
+                      naturalLines);
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "finalLines = %d",
+                      finalLines);
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "size.height = %f",
+                      size.height);
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "lineheight = %f",
+                      lineHeight);
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "paddingTop = %f",
+                      paddingTop);
+  __android_log_print(ANDROID_LOG_INFO, "TypeRichCpp", "paddingBottom = %f",
+                      paddingBottom);
+
+  return size;
+}
+
+} // namespace facebook::react

package/android/src/main/new_arch/react/renderer/components/TypeRichTextInputView/TypeRichTextInputViewShadowNode.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "TypeRichTextInputViewMeasurementManager.h"
+#include "TypeRichTextInputViewState.h"
+
+#include <react/renderer/components/TypeRichTextInputViewSpec/EventEmitters.h>
+#include <react/renderer/components/TypeRichTextInputViewSpec/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char TypeRichTextInputViewComponentName[];
+/*
+ * `ShadowNode` for <TypeRichTextInputView> component.
+ */
+class TypeRichTextInputViewShadowNode final
+    : public ConcreteViewShadowNode<
+          TypeRichTextInputViewComponentName, TypeRichTextInputViewProps,
+          TypeRichTextInputViewEventEmitter, TypeRichTextInputViewState> {
+public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  // This constructor is called when we "update" shadow node, e.g. after
+  // updating shadow node's state
+  TypeRichTextInputViewShadowNode(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 `TypeRichTextInputViewMeasurementManager` with the
+  // node.
+  void setMeasurementsManager(
+      const std::shared_ptr<TypeRichTextInputViewMeasurementManager>
+          &measurementsManager);
+
+  void dirtyLayoutIfNeeded();
+
+  Size
+  measureContent(const LayoutContext &layoutContext,
+                 const LayoutConstraints &layoutConstraints) const override;
+
+private:
+  int forceHeightRecalculationCounter_;
+  std::shared_ptr<TypeRichTextInputViewMeasurementManager> measurementsManager_;
+};
+} // namespace facebook::react

package/android/src/main/new_arch/react/renderer/components/TypeRichTextInputView/TypeRichTextInputViewState.cpp

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

package/android/src/main/new_arch/react/renderer/components/TypeRichTextInputView/TypeRichTextInputViewState.h

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