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

package/ios/interfaces/MentionStyleProps.mm

@@ -0,0 +1,63 @@
+#import "MentionStyleProps.h"
+#import "StringExtension.h"
+#import <React/RCTConversions.h>
+
+@implementation MentionStyleProps
+
++ (MentionStyleProps *)getSingleMentionStylePropsFromFollyDynamic:
+    (folly::dynamic)folly {
+  MentionStyleProps *nativeProps = [[MentionStyleProps alloc] init];
+
+  if (folly["color"].isNumber()) {
+    facebook::react::SharedColor color = facebook::react::SharedColor(
+        facebook::react::Color(int32_t(folly["color"].asInt())));
+    nativeProps.color = RCTUIColorFromSharedColor(color);
+  } else {
+    nativeProps.color = [UIColor blueColor];
+  }
+
+  if (folly["backgroundColor"].isNumber()) {
+    facebook::react::SharedColor bgColor = facebook::react::SharedColor(
+        facebook::react::Color(int32_t(folly["backgroundColor"].asInt())));
+    nativeProps.backgroundColor = RCTUIColorFromSharedColor(bgColor);
+  } else {
+    nativeProps.backgroundColor = [UIColor yellowColor];
+  }
+
+  if (folly["textDecorationLine"].isString()) {
+    std::string textDecorationLine = folly["textDecorationLine"].asString();
+    nativeProps.decorationLine = [[NSString fromCppString:textDecorationLine]
+                                     isEqualToString:DecorationUnderline]
+                                     ? DecorationUnderline
+                                     : DecorationNone;
+  } else {
+    nativeProps.decorationLine = DecorationUnderline;
+  }
+
+  return nativeProps;
+}
+
++ (NSDictionary *)getSinglePropsFromFollyDynamic:(folly::dynamic)folly {
+  MentionStyleProps *nativeProps =
+      [MentionStyleProps getSingleMentionStylePropsFromFollyDynamic:folly];
+  // the single props need to be somehow distinguishable in config
+  NSDictionary *dict = @{@"all" : nativeProps};
+  return dict;
+}
+
++ (NSDictionary *)getComplexPropsFromFollyDynamic:(folly::dynamic)folly {
+  NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
+
+  for (const auto &obj : folly.items()) {
+    if (obj.first.isString() && obj.second.isObject()) {
+      std::string key = obj.first.asString();
+      MentionStyleProps *props = [MentionStyleProps
+          getSingleMentionStylePropsFromFollyDynamic:obj.second];
+      dict[[NSString fromCppString:key]] = props;
+    }
+  }
+
+  return dict;
+}
+
+@end

package/ios/interfaces/StyleBase.h

@@ -0,0 +1,36 @@
+#pragma once
+#import "AttributeEntry.h"
+#import "StylePair.h"
+#import "StyleTypeEnum.h"
+#import <UIKit/UIKit.h>
+
+@class EnrichedTextInputView;
+
+@interface StyleBase : NSObject
+@property(nonatomic, weak) EnrichedTextInputView *input;
++ (StyleType)getType;
+- (NSString *)getKey;
+- (NSString *)getValue;
+- (BOOL)isParagraph;
+- (BOOL)needsZWS;
+- (instancetype)initWithInput:(EnrichedTextInputView *)input;
+- (NSRange)actualUsedRange:(NSRange)range;
+- (void)toggle:(NSRange)range;
+- (void)add:(NSRange)range
+        withTyping:(BOOL)withTyping
+    withDirtyRange:(BOOL)withDirtyRange;
+- (void)add:(NSRange)range
+         withValue:(NSString *)value
+        withTyping:(BOOL)withTyping
+    withDirtyRange:(BOOL)withDirtyRange;
+- (void)remove:(NSRange)range withDirtyRange:(BOOL)withDirtyRange;
+- (void)addTypingWithValue:(NSString *)value;
+- (void)removeTyping;
+- (BOOL)styleCondition:(id)value range:(NSRange)range;
+- (BOOL)detect:(NSRange)range;
+- (BOOL)any:(NSRange)range;
+- (NSArray<StylePair *> *)all:(NSRange)range;
+- (void)applyStyling:(NSRange)range;
+- (void)reapplyFromStylePair:(StylePair *)pair;
+- (AttributeEntry *)getEntryIfPresent:(NSRange)range;
+@end

package/ios/interfaces/StyleBase.mm

@@ -0,0 +1,256 @@
+#import "StyleBase.h"
+#import "AttributeEntry.h"
+#import "EnrichedTextInputView.h"
+#import "OccurenceUtils.h"
+#import "RangeUtils.h"
+#import "ZeroWidthSpaceUtils.h"
+
+@implementation StyleBase
+
+// This method gets overridden
++ (StyleType)getType {
+  return None;
+}
+
+// This method gets overridden for inline styles
+- (NSString *)getKey {
+  if ([self isParagraph]) {
+    return NSParagraphStyleAttributeName;
+  }
+  return @"NoneAttribute";
+}
+
+// Basic inline styles will use this default value, paragraph styles will
+// override it and parametrised ones completely don't use it
+- (NSString *)getValue {
+  return @"AnyValue";
+}
+
+// This method gets overridden
+- (BOOL)isParagraph {
+  return false;
+}
+
+- (BOOL)needsZWS {
+  return NO;
+}
+
+- (instancetype)initWithInput:(EnrichedTextInputView *)input {
+  self = [super init];
+  _input = input;
+  return self;
+}
+
+// aligns range to whole paragraph for the paragraph stlyes
+- (NSRange)actualUsedRange:(NSRange)range {
+  if (![self isParagraph])
+    return range;
+  return [_input->textView.textStorage.string paragraphRangeForRange:range];
+}
+
+- (void)toggle:(NSRange)range {
+  NSRange actualRange = [self actualUsedRange:range];
+
+  BOOL isPresent = [self detect:actualRange];
+  if (actualRange.length >= 1) {
+    isPresent ? [self remove:actualRange withDirtyRange:YES]
+              : [self add:actualRange withTyping:YES withDirtyRange:YES];
+  } else {
+    isPresent ? [self removeTyping] : [self addTypingWithValue:[self getValue]];
+  }
+}
+
+- (void)add:(NSRange)range
+        withTyping:(BOOL)withTyping
+    withDirtyRange:(BOOL)withDirtyRange {
+  [self add:range
+           withValue:[self getValue]
+          withTyping:withTyping
+      withDirtyRange:withDirtyRange];
+}
+
+- (void)add:(NSRange)range
+         withValue:(NSString *)value
+        withTyping:(BOOL)withTyping
+    withDirtyRange:(BOOL)withDirtyRange {
+  NSRange actualRange = [self actualUsedRange:range];
+
+  if (![self isParagraph]) {
+    [_input->textView.textStorage addAttribute:[self getKey]
+                                         value:value
+                                         range:actualRange];
+  } else {
+    [_input->textView.textStorage
+        enumerateAttribute:NSParagraphStyleAttributeName
+                   inRange:actualRange
+                   options:0
+                usingBlock:^(id _Nullable existingValue, NSRange subRange,
+                             BOOL *_Nonnull stop) {
+                  NSMutableParagraphStyle *pStyle =
+                      [(NSParagraphStyle *)existingValue mutableCopy];
+                  if (pStyle == nullptr)
+                    return;
+                  pStyle.textLists =
+                      @[ [[NSTextList alloc] initWithMarkerFormat:value
+                                                          options:0] ];
+                  [_input->textView.textStorage
+                      addAttribute:NSParagraphStyleAttributeName
+                             value:pStyle
+                             range:subRange];
+                }];
+  }
+
+  if (withTyping) {
+    [self addTypingWithValue:value];
+  }
+
+  // Notify attributes manager of styling to be re-done if needed.
+  if (withDirtyRange) {
+    [self.input->attributesManager addDirtyRange:actualRange];
+  }
+}
+
+- (void)remove:(NSRange)range withDirtyRange:(BOOL)withDirtyRange {
+  NSRange actualRange = [self actualUsedRange:range];
+
+  if (![self isParagraph]) {
+    [_input->textView.textStorage removeAttribute:[self getKey]
+                                            range:actualRange];
+  } else {
+    [_input->textView.textStorage
+        enumerateAttribute:NSParagraphStyleAttributeName
+                   inRange:actualRange
+                   options:0
+                usingBlock:^(id _Nullable existingValue, NSRange subRange,
+                             BOOL *_Nonnull stop) {
+                  NSMutableParagraphStyle *pStyle =
+                      [(NSParagraphStyle *)existingValue mutableCopy];
+                  if (pStyle == nullptr)
+                    return;
+                  pStyle.textLists = @[];
+                  [_input->textView.textStorage
+                      addAttribute:NSParagraphStyleAttributeName
+                             value:pStyle
+                             range:subRange];
+                }];
+  }
+  [self removeTyping];
+
+  // Notify attributes manager of styling to be re-done if needed.
+  if (withDirtyRange) {
+    [self.input->attributesManager addDirtyRange:actualRange];
+  }
+}
+
+- (void)addTypingWithValue:(NSString *)value {
+  NSMutableDictionary *newTypingAttrs =
+      [_input->textView.typingAttributes mutableCopy];
+
+  if (![self isParagraph]) {
+    newTypingAttrs[[self getKey]] = value;
+  } else {
+    NSMutableParagraphStyle *pStyle =
+        [newTypingAttrs[NSParagraphStyleAttributeName] mutableCopy];
+    pStyle.textLists = @[ [[NSTextList alloc] initWithMarkerFormat:value
+                                                           options:0] ];
+    newTypingAttrs[NSParagraphStyleAttributeName] = pStyle;
+  }
+
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+- (void)removeTyping {
+  NSMutableDictionary *newTypingAttrs =
+      [_input->textView.typingAttributes mutableCopy];
+
+  if (![self isParagraph]) {
+    [newTypingAttrs removeObjectForKey:[self getKey]];
+    // attributes manager also needs to be notified of custom attributes that
+    // shouldn't be extended
+    [_input->attributesManager didRemoveTypingAttribute:[self getKey]];
+  } else {
+    NSMutableParagraphStyle *pStyle =
+        [newTypingAttrs[NSParagraphStyleAttributeName] mutableCopy];
+    pStyle.textLists = @[];
+    newTypingAttrs[NSParagraphStyleAttributeName] = pStyle;
+  }
+
+  _input->textView.typingAttributes = newTypingAttrs;
+}
+
+// custom styles (e.g. ImageStyle, MentionStyle) will likely need to override
+// this method
+- (BOOL)styleCondition:(id)value range:(NSRange)range {
+  if (![self isParagraph]) {
+    NSString *valueString = (NSString *)value;
+    return valueString != nullptr &&
+           [valueString isEqualToString:[self getValue]];
+  } else {
+    NSParagraphStyle *pStyle = (NSParagraphStyle *)value;
+    return pStyle != nullptr && [pStyle.textLists.firstObject.markerFormat
+                                    isEqualToString:[self getValue]];
+  }
+}
+
+- (BOOL)detect:(NSRange)range {
+  if (range.length >= 1) {
+    return [OccurenceUtils detect:[self getKey]
+                        withInput:_input
+                          inRange:range
+                    withCondition:^BOOL(id _Nullable value, NSRange range) {
+                      return [self styleCondition:value range:range];
+                    }];
+  } else {
+    return [OccurenceUtils detect:[self getKey]
+                        withInput:_input
+                          atIndex:range.location
+                    checkPrevious:[self isParagraph]
+                    withCondition:^BOOL(id _Nullable value, NSRange range) {
+                      return [self styleCondition:value range:range];
+                    }];
+  }
+}
+
+- (BOOL)any:(NSRange)range {
+  return [OccurenceUtils any:[self getKey]
+                   withInput:_input
+                     inRange:range
+               withCondition:^BOOL(id _Nullable value, NSRange range) {
+                 return [self styleCondition:value range:range];
+               }];
+}
+
+- (NSArray<StylePair *> *)all:(NSRange)range {
+  return [OccurenceUtils all:[self getKey]
+                   withInput:_input
+                     inRange:range
+               withCondition:^BOOL(id _Nullable value, NSRange range) {
+                 return [self styleCondition:value range:range];
+               }];
+}
+
+// This method gets overridden
+- (void)applyStyling:(NSRange)range {
+}
+
+// Called during dirty range re-application to restore a style from a saved
+// StylePair
+- (void)reapplyFromStylePair:(StylePair *)pair {
+  NSRange range = [pair.rangeValue rangeValue];
+  [self add:range withTyping:NO withDirtyRange:NO];
+}
+
+// Gets a custom attribtue entry for the typingAttributes.
+// Only used with inline styles.
+- (AttributeEntry *)getEntryIfPresent:(NSRange)range {
+  if (![self detect:range]) {
+    return nullptr;
+  }
+
+  AttributeEntry *entry = [[AttributeEntry alloc] init];
+  entry.key = [self getKey];
+  entry.value = [self getValue];
+  return entry;
+}
+
+@end

package/ios/interfaces/StyleHeaders.h

@@ -0,0 +1,102 @@
+#pragma once
+#import "ImageData.h"
+#import "LinkData.h"
+#import "MentionParams.h"
+#import "StyleBase.h"
+
+@interface BoldStyle : StyleBase
+@end
+
+@interface ItalicStyle : StyleBase
+@end
+
+@interface UnderlineStyle : StyleBase
+@end
+
+@interface StrikethroughStyle : StyleBase
+@end
+
+@interface InlineCodeStyle : StyleBase
+@end
+
+@interface LinkStyle : StyleBase
+- (void)addLink:(LinkData *)linkData
+            range:(NSRange)range
+    withSelection:(BOOL)withSelection;
+- (LinkData *)getLinkDataAt:(NSUInteger)location;
+- (NSRange)getFullLinkRangeAt:(NSUInteger)location;
+- (void)handleAutomaticLinks:(NSString *)word inRange:(NSRange)wordRange;
+- (void)handleManualLinks:(NSString *)word inRange:(NSRange)wordRange;
+@end
+
+@interface MentionStyle : StyleBase
+- (void)addMention:(NSString *)indicator
+              text:(NSString *)text
+        attributes:(NSString *)attributes;
+- (void)addMentionAtRange:(NSRange)range params:(MentionParams *)params;
+- (void)startMentionWithIndicator:(NSString *)indicator;
+- (void)handleExistingMentions;
+- (void)manageMentionEditing;
+- (MentionParams *)getMentionParamsAt:(NSUInteger)location;
+- (NSRange)getFullMentionRangeAt:(NSUInteger)location;
+- (NSValue *)getActiveMentionRange;
+@end
+
+@interface HeadingStyleBase : StyleBase
+- (CGFloat)getHeadingFontSize;
+- (BOOL)isHeadingBold;
+- (BOOL)handleNewlinesInRange:(NSRange)range replacementText:(NSString *)text;
+@end
+
+@interface H1Style : HeadingStyleBase
+@end
+
+@interface H2Style : HeadingStyleBase
+@end
+
+@interface H3Style : HeadingStyleBase
+@end
+
+@interface H4Style : HeadingStyleBase
+@end
+
+@interface H5Style : HeadingStyleBase
+@end
+
+@interface H6Style : HeadingStyleBase
+@end
+
+@interface UnorderedListStyle : StyleBase
+- (BOOL)tryHandlingListShorcutInRange:(NSRange)range
+                      replacementText:(NSString *)text;
+@end
+
+@interface OrderedListStyle : StyleBase
+- (BOOL)tryHandlingListShorcutInRange:(NSRange)range
+                      replacementText:(NSString *)text;
+@end
+
+@interface CheckboxListStyle : StyleBase
+- (void)toggleWithChecked:(BOOL)checked range:(NSRange)range;
+- (void)addWithChecked:(BOOL)checked
+                 range:(NSRange)range
+            withTyping:(BOOL)withTyping
+        withDirtyRange:(BOOL)withDirtyRange;
+- (void)toggleCheckedAt:(NSUInteger)location;
+- (BOOL)getCheckboxStateAt:(NSUInteger)location;
+- (BOOL)handleNewlinesInRange:(NSRange)range replacementText:(NSString *)text;
+@end
+
+@interface BlockQuoteStyle : StyleBase
+@end
+
+@interface CodeBlockStyle : StyleBase
+@end
+
+@interface ImageStyle : StyleBase
+- (void)addImage:(NSString *)uri width:(CGFloat)width height:(CGFloat)height;
+- (void)addImageAtRange:(NSRange)range
+              imageData:(ImageData *)imageData
+          withSelection:(BOOL)withSelection;
+- (ImageData *)getImageDataAt:(NSUInteger)location;
+@end

package/ios/interfaces/StylePair.h

@@ -0,0 +1,9 @@
+#pragma once
+#import <UIkit/UIKit.h>
+
+@interface StylePair : NSObject
+
+@property NSValue *rangeValue;
+@property id styleValue;
+
+@end

package/ios/interfaces/StylePair.mm

@@ -0,0 +1,4 @@
+#import "StylePair.h"
+
+@implementation StylePair
+@end

package/ios/interfaces/StyleTypeEnum.h

@@ -0,0 +1,26 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+// the order is aligned with the order of tags in parser
+typedef NS_ENUM(NSInteger, StyleType) {
+  BlockQuote,
+  CodeBlock,
+  UnorderedList,
+  OrderedList,
+  CheckboxList,
+  H1,
+  H2,
+  H3,
+  H4,
+  H5,
+  H6,
+  Link,
+  Mention,
+  Image,
+  InlineCode,
+  Bold,
+  Italic,
+  Underline,
+  Strikethrough,
+  None,
+};

package/ios/interfaces/TextDecorationLineEnum.h

@@ -0,0 +1,6 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+typedef NSString *TextDecorationLineEnum NS_TYPED_ENUM;
+extern TextDecorationLineEnum const DecorationUnderline;
+extern TextDecorationLineEnum const DecorationNone;

package/ios/interfaces/TextDecorationLineEnum.mm

@@ -0,0 +1,4 @@
+#import "TextDecorationLineEnum.h"
+
+TextDecorationLineEnum const DecorationUnderline = @"underline";
+TextDecorationLineEnum const DecorationNone = @"none";

package/ios/internals/EnrichedTextInputViewComponentDescriptor.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <ReactNativeEnriched/EnrichedTextInputViewShadowNode.h>
+#include <ReactNativeEnriched/Props.h>
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+class EnrichedTextInputViewComponentDescriptor final
+    : public ConcreteComponentDescriptor<EnrichedTextInputViewShadowNode> {
+public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+  void adopt(ShadowNode &shadowNode) const override {
+    react_native_assert(
+        dynamic_cast<EnrichedTextInputViewShadowNode *>(&shadowNode));
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react

package/ios/internals/EnrichedTextInputViewShadowNode.h

@@ -0,0 +1,44 @@
+#pragma once
+#include <ReactNativeEnriched/EnrichedTextInputViewState.h>
+#include <ReactNativeEnriched/EventEmitters.h>
+#include <ReactNativeEnriched/Props.h>
+#include <jsi/jsi.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char EnrichedTextInputViewComponentName[];
+
+/*
+ * `ShadowNode` for <EnrichedTextInputView> component.
+ */
+class EnrichedTextInputViewShadowNode
+    : public ConcreteViewShadowNode<
+          EnrichedTextInputViewComponentName, EnrichedTextInputViewProps,
+          EnrichedTextInputViewEventEmitter, EnrichedTextInputViewState> {
+public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+  EnrichedTextInputViewShadowNode(const ShadowNodeFragment &fragment,
+                                  const ShadowNodeFamily::Shared &family,
+                                  ShadowNodeTraits traits);
+  EnrichedTextInputViewShadowNode(const ShadowNode &sourceShadowNode,
+                                  const ShadowNodeFragment &fragment);
+  void dirtyLayoutIfNeeded();
+  Size
+  measureContent(const LayoutContext &layoutContext,
+                 const LayoutConstraints &layoutConstraints) const override;
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+private:
+  int localForceHeightRecalculationCounter_;
+  id setupMockTextInputView_() const;
+};
+
+} // namespace facebook::react

package/ios/internals/EnrichedTextInputViewShadowNode.mm

@@ -0,0 +1,103 @@
+#import "EnrichedTextInputViewShadowNode.h"
+#import "CoreText/CoreText.h"
+#import <EnrichedTextInputView.h>
+#import <React/RCTShadowView+Layout.h>
+#import <react/utils/ManagedObjectWrapper.h>
+#import <yoga/Yoga.h>
+
+namespace facebook::react {
+
+extern const char EnrichedTextInputViewComponentName[] =
+    "EnrichedTextInputView";
+
+EnrichedTextInputViewShadowNode::EnrichedTextInputViewShadowNode(
+    const ShadowNodeFragment &fragment, const ShadowNodeFamily::Shared &family,
+    ShadowNodeTraits traits)
+    : ConcreteViewShadowNode(fragment, family, traits) {
+  localForceHeightRecalculationCounter_ = 0;
+}
+
+// mock input is used for the first measure calls that need to be done when the
+// real input isn't defined yet
+id EnrichedTextInputViewShadowNode::setupMockTextInputView_() const {
+  // it's rendered far away from the viewport
+  const int veryFarAway = 20000;
+  const int mockSize = 1000;
+  EnrichedTextInputView *mockTextInputView_ = [[EnrichedTextInputView alloc]
+      initWithFrame:(CGRectMake(veryFarAway, veryFarAway, mockSize, mockSize))];
+  const auto props = this->getProps();
+  mockTextInputView_->blockEmitting = YES;
+  [mockTextInputView_ updateProps:props oldProps:nullptr];
+  return mockTextInputView_;
+}
+
+EnrichedTextInputViewShadowNode::EnrichedTextInputViewShadowNode(
+    const ShadowNode &sourceShadowNode, const ShadowNodeFragment &fragment)
+    : ConcreteViewShadowNode(sourceShadowNode, fragment) {
+  dirtyLayoutIfNeeded();
+}
+
+void EnrichedTextInputViewShadowNode::dirtyLayoutIfNeeded() {
+  const auto state = this->getStateData();
+  const int receivedCounter = state.getForceHeightRecalculationCounter();
+
+  if (receivedCounter > localForceHeightRecalculationCounter_) {
+    localForceHeightRecalculationCounter_ = receivedCounter;
+    YGNodeMarkDirty(&yogaNode_);
+  }
+}
+
+Size EnrichedTextInputViewShadowNode::measureContent(
+    const LayoutContext &layoutContext,
+    const LayoutConstraints &layoutConstraints) const {
+  const auto state = this->getStateData();
+  const auto componentRef = state.getComponentViewRef();
+  RCTInternalGenericWeakWrapper *weakWrapper =
+      (RCTInternalGenericWeakWrapper *)unwrapManagedObject(componentRef);
+
+  if (weakWrapper != nullptr) {
+    id componentObject = weakWrapper.object;
+    EnrichedTextInputView *typedComponentObject =
+        (EnrichedTextInputView *)componentObject;
+
+    if (typedComponentObject != nullptr) {
+      __block CGSize estimatedSize;
+
+      // synchronously dispatch to main thread if needed
+      if ([NSThread isMainThread]) {
+        estimatedSize = [typedComponentObject
+            measureSize:layoutConstraints.maximumSize.width];
+      } else {
+        dispatch_sync(dispatch_get_main_queue(), ^{
+          estimatedSize = [typedComponentObject
+              measureSize:layoutConstraints.maximumSize.width];
+        });
+      }
+
+      return {estimatedSize.width,
+              MIN(estimatedSize.height, layoutConstraints.maximumSize.height)};
+    }
+  } else {
+    __block CGSize estimatedSize;
+
+    // synchronously dispatch to main thread if needed
+    if ([NSThread isMainThread]) {
+      EnrichedTextInputView *mockTextInputView = setupMockTextInputView_();
+      estimatedSize =
+          [mockTextInputView measureSize:layoutConstraints.maximumSize.width];
+    } else {
+      dispatch_sync(dispatch_get_main_queue(), ^{
+        EnrichedTextInputView *mockTextInputView = setupMockTextInputView_();
+        estimatedSize =
+            [mockTextInputView measureSize:layoutConstraints.maximumSize.width];
+      });
+    }
+
+    return {estimatedSize.width,
+            MIN(estimatedSize.height, layoutConstraints.maximumSize.height)};
+  }
+
+  return Size();
+}
+
+} // namespace facebook::react

package/ios/internals/EnrichedTextInputViewState.cpp

@@ -0,0 +1,10 @@
+#include "EnrichedTextInputViewState.h"
+
+namespace facebook::react {
+int EnrichedTextInputViewState::getForceHeightRecalculationCounter() const {
+  return forceHeightRecalculationCounter_;
+}
+std::shared_ptr<void> EnrichedTextInputViewState::getComponentViewRef() const {
+  return componentViewRef_;
+}
+} // namespace facebook::react