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

package/ios/EnrichedTextInputView.mm

@@ -0,0 +1,2170 @@
+#import "EnrichedTextInputView.h"
+#import "AlignmentUtils.h"
+#import "AttachmentLayoutUtils.h"
+#import "CoreText/CoreText.h"
+#import "DotReplacementUtils.h"
+#import "HtmlParser.h"
+#import "ImageAttachment.h"
+#import "KeyboardUtils.h"
+#import "LayoutManagerExtension.h"
+#import "ParagraphAttributesUtils.h"
+#import "RCTFabricComponentsPlugins.h"
+#import "ShortcutsUtils.h"
+#import "StringExtension.h"
+#import "StyleHeaders.h"
+#import "StyleUtils.h"
+#import "TextBlockTapGestureRecognizer.h"
+#import "TextInsertionUtils.h"
+#import "UIView+React.h"
+#import "WordsUtils.h"
+#import "ZeroWidthSpaceUtils.h"
+#import <React/RCTConversions.h>
+#import <ReactNativeEnrichedHtml/EnrichedTextInputViewComponentDescriptor.h>
+#import <ReactNativeEnrichedHtml/EventEmitters.h>
+#import <ReactNativeEnrichedHtml/Props.h>
+#import <ReactNativeEnrichedHtml/RCTComponentViewHelpers.h>
+#import <folly/dynamic.h>
+#import <react/utils/ManagedObjectWrapper.h>
+
+#define GET_STYLE_STATE(TYPE_ENUM)                                             \
+  {                                                                            \
+    .isActive = [self isStyleActive:TYPE_ENUM],                                \
+    .isBlocking = [self isStyle:TYPE_ENUM activeInMap:blockingStyles],         \
+    .isConflicting = [self isStyle:TYPE_ENUM activeInMap:conflictingStyles]    \
+  }
+
+using namespace facebook::react;
+
+@interface EnrichedTextInputView () <
+    RCTEnrichedTextInputViewViewProtocol, UITextViewDelegate,
+    UIGestureRecognizerDelegate, NSTextStorageDelegate, NSObject>
+
+@end
+
+@implementation EnrichedTextInputView {
+  EnrichedTextInputViewShadowNode::ConcreteState::Shared _state;
+  int _componentViewHeightUpdateCounter;
+  NSMutableSet<NSNumber *> *_activeStyles;
+  NSMutableSet<NSNumber *> *_blockedStyles;
+  LinkData *_recentlyActiveLinkData;
+  NSRange _recentlyActiveLinkRange;
+  NSString *_recentInputString;
+  MentionParams *_recentlyActiveMentionParams;
+  NSRange _recentlyActiveMentionRange;
+  NSString *_recentlyEmittedHtml;
+  BOOL _emitHtml;
+  UILabel *_placeholderLabel;
+  UIColor *_placeholderColor;
+  BOOL _emitFocusBlur;
+  BOOL _emitTextChange;
+  NSMutableDictionary<NSValue *, UIImageView *> *_attachmentViews;
+  NSArray<NSDictionary *> *_contextMenuItems;
+  NSString *_submitBehavior;
+  NSDictionary<NSAttributedStringKey, id> *_capturedAttributesBeforeChange;
+  NSString *_recentlyEmittedAlignment;
+}
+
+@synthesize blockEmitting = blockEmitting;
+
+// MARK: - Component utils
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      EnrichedTextInputViewComponentDescriptor>();
+}
+
+Class<RCTComponentViewProtocol> EnrichedTextInputViewCls(void) {
+  return EnrichedTextInputView.class;
+}
+
++ (BOOL)shouldBeRecycled {
+  return NO;
+}
+
+// MARK: - EnrichedViewHost protocol
+
+- (UITextView *)textView {
+  return textView;
+}
+
+- (EnrichedConfig *)config {
+  return config;
+}
+
+- (NSDictionary<NSNumber *, id> *)stylesDict {
+  return stylesDict;
+}
+
+- (InputAttributesManager *)attributesManager {
+  return attributesManager;
+}
+
+- (NSMutableDictionary<NSNumber *, NSArray<NSNumber *> *> *)conflictingStyles {
+  return conflictingStyles;
+}
+
+- (NSMutableDictionary<NSNumber *, NSArray<NSNumber *> *> *)blockingStyles {
+  return blockingStyles;
+}
+
+- (NSMutableDictionary<NSAttributedStringKey, id> *)defaultTypingAttributes {
+  return defaultTypingAttributes;
+}
+
+// MARK: - Init
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const EnrichedTextInputViewProps>();
+    _props = defaultProps;
+    [self setDefaults];
+    [self setupTextView];
+    [self setupPlaceholderLabel];
+    self.contentView = textView;
+  }
+  return self;
+}
+
+- (void)setDefaults {
+  _componentViewHeightUpdateCounter = 0;
+  _activeStyles = [[NSMutableSet alloc] init];
+  _blockedStyles = [[NSMutableSet alloc] init];
+  _recentlyActiveLinkRange = NSMakeRange(0, 0);
+  _recentlyActiveMentionRange = NSMakeRange(0, 0);
+  _recentlyEmittedAlignment = @"left";
+  _recentInputString = @"";
+  _recentlyEmittedHtml = @"<html>\n<p></p>\n</html>";
+  _emitHtml = NO;
+  blockEmitting = NO;
+  _emitFocusBlur = YES;
+  _emitTextChange = NO;
+  dotReplacementRange = nullptr;
+
+  defaultTypingAttributes =
+      [[NSMutableDictionary<NSAttributedStringKey, id> alloc] init];
+
+  stylesDict = [StyleUtils stylesDictForHost:self isInput:YES];
+  conflictingStyles = [[StyleUtils conflictMap] mutableCopy];
+  blockingStyles = [[StyleUtils blockingMap] mutableCopy];
+
+  parser = [[InputHtmlParser alloc] initWithInput:self];
+  _attachmentViews = [[NSMutableDictionary alloc] init];
+  attributesManager = [[InputAttributesManager alloc] initWithInput:self];
+}
+
+- (void)setupTextView {
+  textView = [[EnrichedInputTextView alloc] init];
+  textView.backgroundColor = UIColor.clearColor;
+  textView.textContainerInset = UIEdgeInsetsMake(0, 0, 0, 0);
+  textView.textContainer.lineFragmentPadding = 0;
+  textView.delegate = self;
+  textView.input = self;
+  textView.layoutManager.input = self;
+  textView.textStorage.delegate = self;
+
+  textView.adjustsFontForContentSizeCategory = YES;
+  [textView addGestureRecognizer:[[TextBlockTapGestureRecognizer alloc]
+                                     initWithInput:self
+                                            action:@selector(onTextBlockTap:)]];
+}
+
+- (void)setupPlaceholderLabel {
+  _placeholderLabel = [[UILabel alloc] initWithFrame:CGRectZero];
+  _placeholderLabel.translatesAutoresizingMaskIntoConstraints = NO;
+  [textView addSubview:_placeholderLabel];
+  [NSLayoutConstraint activateConstraints:@[
+    [_placeholderLabel.leadingAnchor
+        constraintEqualToAnchor:textView.leadingAnchor],
+    [_placeholderLabel.widthAnchor
+        constraintEqualToAnchor:textView.widthAnchor],
+    [_placeholderLabel.topAnchor constraintEqualToAnchor:textView.topAnchor],
+    [_placeholderLabel.bottomAnchor
+        constraintEqualToAnchor:textView.bottomAnchor]
+  ]];
+  _placeholderLabel.lineBreakMode = NSLineBreakByTruncatingTail;
+  _placeholderLabel.text = @"";
+  _placeholderLabel.hidden = YES;
+  _placeholderLabel.adjustsFontForContentSizeCategory = YES;
+}
+
+// MARK: - Props
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps =
+      *std::static_pointer_cast<EnrichedTextInputViewProps const>(_props);
+  const auto &newViewProps =
+      *std::static_pointer_cast<EnrichedTextInputViewProps const>(props);
+  BOOL isFirstMount = NO;
+  BOOL stylePropChanged = NO;
+
+  // initial config
+  if (config == nullptr) {
+    isFirstMount = YES;
+    config = [[EnrichedConfig alloc] init];
+  }
+
+  // any style prop changes:
+  // firstly we create the new config for the changes
+
+  EnrichedConfig *newConfig = [config copy];
+
+  if (newViewProps.color != oldViewProps.color) {
+    if (isColorMeaningful(newViewProps.color)) {
+      UIColor *uiColor = RCTUIColorFromSharedColor(newViewProps.color);
+      [newConfig setPrimaryColor:uiColor];
+    } else {
+      [newConfig setPrimaryColor:nullptr];
+    }
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.fontSize != oldViewProps.fontSize) {
+    if (newViewProps.fontSize) {
+      NSNumber *fontSize = @(newViewProps.fontSize);
+      [newConfig setPrimaryFontSize:fontSize];
+    } else {
+      [newConfig setPrimaryFontSize:nullptr];
+    }
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.lineHeight != oldViewProps.lineHeight) {
+    [newConfig setPrimaryLineHeight:newViewProps.lineHeight];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.fontWeight != oldViewProps.fontWeight) {
+    if (!newViewProps.fontWeight.empty()) {
+      [newConfig
+          setPrimaryFontWeight:[NSString
+                                   fromCppString:newViewProps.fontWeight]];
+    } else {
+      [newConfig setPrimaryFontWeight:nullptr];
+    }
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.fontFamily != oldViewProps.fontFamily) {
+    if (!newViewProps.fontFamily.empty()) {
+      [newConfig
+          setPrimaryFontFamily:[NSString
+                                   fromCppString:newViewProps.fontFamily]];
+    } else {
+      [newConfig setPrimaryFontFamily:nullptr];
+    }
+    stylePropChanged = YES;
+  }
+
+  // rich text style
+
+  if (newViewProps.htmlStyle.h1.fontSize !=
+      oldViewProps.htmlStyle.h1.fontSize) {
+    [newConfig setH1FontSize:newViewProps.htmlStyle.h1.fontSize];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h1.bold != oldViewProps.htmlStyle.h1.bold) {
+    [newConfig setH1Bold:newViewProps.htmlStyle.h1.bold];
+
+    // Update style blocks and conflicts for bold
+    if (newViewProps.htmlStyle.h1.bold) {
+      [StyleUtils addStyleBlock:H1 to:Bold forHost:self];
+      [StyleUtils addStyleConflict:Bold to:H1 forHost:self];
+    } else {
+      [StyleUtils removeStyleBlock:H1 from:Bold forHost:self];
+      [StyleUtils removeStyleConflict:Bold from:H1 forHost:self];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h2.fontSize !=
+      oldViewProps.htmlStyle.h2.fontSize) {
+    [newConfig setH2FontSize:newViewProps.htmlStyle.h2.fontSize];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h2.bold != oldViewProps.htmlStyle.h2.bold) {
+    [newConfig setH2Bold:newViewProps.htmlStyle.h2.bold];
+
+    // Update style blocks and conflicts for bold
+    if (newViewProps.htmlStyle.h2.bold) {
+      [StyleUtils addStyleBlock:H2 to:Bold forHost:self];
+      [StyleUtils addStyleConflict:Bold to:H2 forHost:self];
+    } else {
+      [StyleUtils removeStyleBlock:H2 from:Bold forHost:self];
+      [StyleUtils removeStyleConflict:Bold from:H2 forHost:self];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h3.fontSize !=
+      oldViewProps.htmlStyle.h3.fontSize) {
+    [newConfig setH3FontSize:newViewProps.htmlStyle.h3.fontSize];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h3.bold != oldViewProps.htmlStyle.h3.bold) {
+    [newConfig setH3Bold:newViewProps.htmlStyle.h3.bold];
+
+    // Update style blocks and conflicts for bold
+    if (newViewProps.htmlStyle.h3.bold) {
+      [StyleUtils addStyleBlock:H3 to:Bold forHost:self];
+      [StyleUtils addStyleConflict:Bold to:H3 forHost:self];
+    } else {
+      [StyleUtils removeStyleBlock:H3 from:Bold forHost:self];
+      [StyleUtils removeStyleConflict:Bold from:H3 forHost:self];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h4.fontSize !=
+      oldViewProps.htmlStyle.h4.fontSize) {
+    [newConfig setH4FontSize:newViewProps.htmlStyle.h4.fontSize];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h4.bold != oldViewProps.htmlStyle.h4.bold) {
+    [newConfig setH4Bold:newViewProps.htmlStyle.h4.bold];
+
+    // Update style blocks and conflicts for bold
+    if (newViewProps.htmlStyle.h4.bold) {
+      [StyleUtils addStyleBlock:H4 to:Bold forHost:self];
+      [StyleUtils addStyleConflict:Bold to:H4 forHost:self];
+    } else {
+      [StyleUtils removeStyleBlock:H4 from:Bold forHost:self];
+      [StyleUtils removeStyleConflict:Bold from:H4 forHost:self];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h5.fontSize !=
+      oldViewProps.htmlStyle.h5.fontSize) {
+    [newConfig setH5FontSize:newViewProps.htmlStyle.h5.fontSize];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h5.bold != oldViewProps.htmlStyle.h5.bold) {
+    [newConfig setH5Bold:newViewProps.htmlStyle.h5.bold];
+
+    // Update style blocks and conflicts for bold
+    if (newViewProps.htmlStyle.h5.bold) {
+      [StyleUtils addStyleBlock:H5 to:Bold forHost:self];
+      [StyleUtils addStyleConflict:Bold to:H5 forHost:self];
+    } else {
+      [StyleUtils removeStyleBlock:H5 from:Bold forHost:self];
+      [StyleUtils removeStyleConflict:Bold from:H5 forHost:self];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h6.fontSize !=
+      oldViewProps.htmlStyle.h6.fontSize) {
+    [newConfig setH6FontSize:newViewProps.htmlStyle.h6.fontSize];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.h6.bold != oldViewProps.htmlStyle.h6.bold) {
+    [newConfig setH6Bold:newViewProps.htmlStyle.h6.bold];
+
+    // Update style blocks and conflicts for bold
+    if (newViewProps.htmlStyle.h6.bold) {
+      [StyleUtils addStyleBlock:H6 to:Bold forHost:self];
+      [StyleUtils addStyleConflict:Bold to:H6 forHost:self];
+    } else {
+      [StyleUtils removeStyleBlock:H6 from:Bold forHost:self];
+      [StyleUtils removeStyleConflict:Bold from:H6 forHost:self];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.blockquote.borderColor !=
+      oldViewProps.htmlStyle.blockquote.borderColor) {
+    if (isColorMeaningful(newViewProps.htmlStyle.blockquote.borderColor)) {
+      [newConfig setBlockquoteBorderColor:RCTUIColorFromSharedColor(
+                                              newViewProps.htmlStyle.blockquote
+                                                  .borderColor)];
+      stylePropChanged = YES;
+    }
+  }
+
+  if (newViewProps.htmlStyle.blockquote.borderWidth !=
+      oldViewProps.htmlStyle.blockquote.borderWidth) {
+    [newConfig
+        setBlockquoteBorderWidth:newViewProps.htmlStyle.blockquote.borderWidth];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.blockquote.gapWidth !=
+      oldViewProps.htmlStyle.blockquote.gapWidth) {
+    [newConfig
+        setBlockquoteGapWidth:newViewProps.htmlStyle.blockquote.gapWidth];
+    stylePropChanged = YES;
+  }
+
+  // since this prop defaults to undefined on JS side, we need to force set the
+  // value on first mount
+  if (newViewProps.htmlStyle.blockquote.color !=
+          oldViewProps.htmlStyle.blockquote.color ||
+      isFirstMount) {
+    if (isColorMeaningful(newViewProps.htmlStyle.blockquote.color)) {
+      [newConfig
+          setBlockquoteColor:RCTUIColorFromSharedColor(
+                                 newViewProps.htmlStyle.blockquote.color)];
+    } else {
+      [newConfig setBlockquoteColor:[newConfig primaryColor]];
+    }
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.code.color != oldViewProps.htmlStyle.code.color) {
+    if (isColorMeaningful(newViewProps.htmlStyle.code.color)) {
+      [newConfig setInlineCodeFgColor:RCTUIColorFromSharedColor(
+                                          newViewProps.htmlStyle.code.color)];
+      stylePropChanged = YES;
+    }
+  }
+
+  if (newViewProps.htmlStyle.code.backgroundColor !=
+      oldViewProps.htmlStyle.code.backgroundColor) {
+    if (isColorMeaningful(newViewProps.htmlStyle.code.backgroundColor)) {
+      [newConfig setInlineCodeBgColor:RCTUIColorFromSharedColor(
+                                          newViewProps.htmlStyle.code
+                                              .backgroundColor)];
+      stylePropChanged = YES;
+    }
+  }
+
+  if (newViewProps.htmlStyle.ol.gapWidth !=
+      oldViewProps.htmlStyle.ol.gapWidth) {
+    [newConfig setOrderedListGapWidth:newViewProps.htmlStyle.ol.gapWidth];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.ol.marginLeft !=
+      oldViewProps.htmlStyle.ol.marginLeft) {
+    [newConfig setOrderedListMarginLeft:newViewProps.htmlStyle.ol.marginLeft];
+    stylePropChanged = YES;
+  }
+
+  // since this prop defaults to undefined on JS side, we need to force set the
+  // value on first mount
+  if (newViewProps.htmlStyle.ol.markerFontWeight !=
+          oldViewProps.htmlStyle.ol.markerFontWeight ||
+      isFirstMount) {
+    if (!newViewProps.htmlStyle.ol.markerFontWeight.empty()) {
+      [newConfig
+          setOrderedListMarkerFontWeight:
+              [NSString
+                  fromCppString:newViewProps.htmlStyle.ol.markerFontWeight]];
+    } else {
+      [newConfig setOrderedListMarkerFontWeight:[newConfig primaryFontWeight]];
+    }
+    stylePropChanged = YES;
+  }
+
+  // since this prop defaults to undefined on JS side, we need to force set the
+  // value on first mount
+  if (newViewProps.htmlStyle.ol.markerColor !=
+          oldViewProps.htmlStyle.ol.markerColor ||
+      isFirstMount) {
+    if (isColorMeaningful(newViewProps.htmlStyle.ol.markerColor)) {
+      [newConfig
+          setOrderedListMarkerColor:RCTUIColorFromSharedColor(
+                                        newViewProps.htmlStyle.ol.markerColor)];
+    } else {
+      [newConfig setOrderedListMarkerColor:[newConfig primaryColor]];
+    }
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.ul.bulletColor !=
+      oldViewProps.htmlStyle.ul.bulletColor) {
+    if (isColorMeaningful(newViewProps.htmlStyle.ul.bulletColor)) {
+      [newConfig setUnorderedListBulletColor:RCTUIColorFromSharedColor(
+                                                 newViewProps.htmlStyle.ul
+                                                     .bulletColor)];
+      stylePropChanged = YES;
+    }
+  }
+
+  if (newViewProps.htmlStyle.ul.bulletSize !=
+      oldViewProps.htmlStyle.ul.bulletSize) {
+    [newConfig setUnorderedListBulletSize:newViewProps.htmlStyle.ul.bulletSize];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.ul.gapWidth !=
+      oldViewProps.htmlStyle.ul.gapWidth) {
+    [newConfig setUnorderedListGapWidth:newViewProps.htmlStyle.ul.gapWidth];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.ul.marginLeft !=
+      oldViewProps.htmlStyle.ul.marginLeft) {
+    [newConfig setUnorderedListMarginLeft:newViewProps.htmlStyle.ul.marginLeft];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.a.color != oldViewProps.htmlStyle.a.color) {
+    if (isColorMeaningful(newViewProps.htmlStyle.a.color)) {
+      [newConfig setLinkColor:RCTUIColorFromSharedColor(
+                                  newViewProps.htmlStyle.a.color)];
+      stylePropChanged = YES;
+    }
+  }
+
+  if (newViewProps.htmlStyle.codeblock.color !=
+      oldViewProps.htmlStyle.codeblock.color) {
+    if (isColorMeaningful(newViewProps.htmlStyle.codeblock.color)) {
+      [newConfig
+          setCodeBlockFgColor:RCTUIColorFromSharedColor(
+                                  newViewProps.htmlStyle.codeblock.color)];
+      stylePropChanged = YES;
+    }
+  }
+
+  if (newViewProps.htmlStyle.codeblock.backgroundColor !=
+      oldViewProps.htmlStyle.codeblock.backgroundColor) {
+    if (isColorMeaningful(newViewProps.htmlStyle.codeblock.backgroundColor)) {
+      [newConfig setCodeBlockBgColor:RCTUIColorFromSharedColor(
+                                         newViewProps.htmlStyle.codeblock
+                                             .backgroundColor)];
+      stylePropChanged = YES;
+    }
+  }
+
+  if (newViewProps.htmlStyle.codeblock.borderRadius !=
+      oldViewProps.htmlStyle.codeblock.borderRadius) {
+    [newConfig
+        setCodeBlockBorderRadius:newViewProps.htmlStyle.codeblock.borderRadius];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.ulCheckbox.boxSize !=
+      oldViewProps.htmlStyle.ulCheckbox.boxSize) {
+    [newConfig
+        setCheckboxListBoxSize:newViewProps.htmlStyle.ulCheckbox.boxSize];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.ulCheckbox.gapWidth !=
+      oldViewProps.htmlStyle.ulCheckbox.gapWidth) {
+    [newConfig
+        setCheckboxListGapWidth:newViewProps.htmlStyle.ulCheckbox.gapWidth];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.ulCheckbox.marginLeft !=
+      oldViewProps.htmlStyle.ulCheckbox.marginLeft) {
+    [newConfig
+        setCheckboxListMarginLeft:newViewProps.htmlStyle.ulCheckbox.marginLeft];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.htmlStyle.ulCheckbox.boxColor !=
+      oldViewProps.htmlStyle.ulCheckbox.boxColor) {
+    if (isColorMeaningful(newViewProps.htmlStyle.ulCheckbox.boxColor)) {
+      [newConfig setCheckboxListBoxColor:RCTUIColorFromSharedColor(
+                                             newViewProps.htmlStyle.ulCheckbox
+                                                 .boxColor)];
+      stylePropChanged = YES;
+    }
+  }
+
+  if (newViewProps.htmlStyle.a.textDecorationLine !=
+      oldViewProps.htmlStyle.a.textDecorationLine) {
+    NSString *objcString =
+        [NSString fromCppString:newViewProps.htmlStyle.a.textDecorationLine];
+    if ([objcString isEqualToString:DecorationUnderline]) {
+      [newConfig setLinkDecorationLine:DecorationUnderline];
+    } else {
+      // both DecorationNone and a different, wrong value gets a DecorationNone
+      // here
+      [newConfig setLinkDecorationLine:DecorationNone];
+    }
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.scrollEnabled != oldViewProps.scrollEnabled ||
+      textView.scrollEnabled != newViewProps.scrollEnabled) {
+    [textView setScrollEnabled:newViewProps.scrollEnabled];
+  }
+
+  if (newViewProps.allowFontScaling != oldViewProps.allowFontScaling) {
+    [newConfig setAllowFontScaling:newViewProps.allowFontScaling];
+    stylePropChanged = YES;
+  }
+
+  folly::dynamic oldMentionStyle = oldViewProps.htmlStyle.mention;
+  folly::dynamic newMentionStyle = newViewProps.htmlStyle.mention;
+  if (oldMentionStyle != newMentionStyle) {
+    bool newSingleProps = NO;
+
+    for (const auto &obj : newMentionStyle.items()) {
+      if (obj.second.isInt() || obj.second.isString()) {
+        // we are in just a single MentionStyleProps object
+        newSingleProps = YES;
+        break;
+      } else if (obj.second.isObject()) {
+        // we are in map of indicators to MentionStyleProps
+        newSingleProps = NO;
+        break;
+      }
+    }
+
+    if (newSingleProps) {
+      [newConfig setMentionStyleProps:
+                     [MentionStyleProps
+                         getSinglePropsFromFollyDynamic:newMentionStyle]];
+    } else {
+      [newConfig setMentionStyleProps:
+                     [MentionStyleProps
+                         getComplexPropsFromFollyDynamic:newMentionStyle]];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  if (stylePropChanged) {
+    // all the text needs to be rebuilt
+    // we get the current html using old config, then switch to new config and
+    // replace text using the html this way, the newest config attributes are
+    // being used!
+
+    // the html needs to be generated using the old config
+    NSString *currentHtml = [HtmlParser
+        parseToHtmlFromRange:NSMakeRange(0, textView.textStorage.string.length)
+                        host:self];
+    // we want to preserve the selection between props changes
+    NSRange prevSelectedRange = textView.selectedRange;
+
+    // now set the new config
+    config = newConfig;
+
+    // fill the typing attributes with style props
+    defaultTypingAttributes[NSForegroundColorAttributeName] =
+        [config primaryColor];
+    defaultTypingAttributes[NSFontAttributeName] = [config primaryFont];
+    defaultTypingAttributes[NSUnderlineColorAttributeName] =
+        [config primaryColor];
+    defaultTypingAttributes[NSStrikethroughColorAttributeName] =
+        [config primaryColor];
+    NSMutableParagraphStyle *defaultPStyle =
+        [[NSMutableParagraphStyle alloc] init];
+    defaultPStyle.minimumLineHeight = [config scaledPrimaryLineHeight];
+    defaultTypingAttributes[NSParagraphStyleAttributeName] = defaultPStyle;
+
+    // no emitting during styles reload
+    blockEmitting = YES;
+
+    // make sure everything is sound in the html
+    NSString *initiallyProcessedHtml =
+        [parser initiallyProcessHtml:currentHtml];
+    if (initiallyProcessedHtml != nullptr) {
+      [parser replaceWholeFromHtml:initiallyProcessedHtml];
+    }
+
+    blockEmitting = NO;
+
+    textView.typingAttributes = defaultTypingAttributes;
+    textView.selectedRange = prevSelectedRange;
+
+    // make sure the newest lineHeight is applied
+    [self refreshLineHeight];
+    // update the placeholder as well
+    [self refreshPlaceholderLabelStyles];
+  }
+
+  // editable
+  if (newViewProps.editable != textView.editable) {
+    textView.editable = newViewProps.editable;
+  }
+
+  // useHtmlNormalizer
+  if (newViewProps.useHtmlNormalizer != oldViewProps.useHtmlNormalizer) {
+    useHtmlNormalizer = newViewProps.useHtmlNormalizer;
+  }
+
+  // textShortcuts
+  bool textShortcutsChanged =
+      newViewProps.textShortcuts.size() != oldViewProps.textShortcuts.size();
+  if (!textShortcutsChanged) {
+    for (size_t i = 0; i < newViewProps.textShortcuts.size(); i++) {
+      const auto &newItem = newViewProps.textShortcuts[i];
+      const auto &oldItem = oldViewProps.textShortcuts[i];
+      if (newItem.trigger != oldItem.trigger ||
+          newItem.style != oldItem.style) {
+        textShortcutsChanged = true;
+        break;
+      }
+    }
+  }
+
+  if (textShortcutsChanged) {
+    NSMutableArray *shortcuts = [NSMutableArray new];
+    for (const auto &item : newViewProps.textShortcuts) {
+      [shortcuts addObject:@{
+        @"trigger" : [NSString fromCppString:item.trigger],
+        @"style" : [NSString fromCppString:item.style],
+      }];
+    }
+    textShortcuts = shortcuts;
+  }
+
+  // default value - must be set before placeholder to make sure it correctly
+  // shows on first mount
+  if (newViewProps.defaultValue != oldViewProps.defaultValue) {
+    NSString *newDefaultValue =
+        [NSString fromCppString:newViewProps.defaultValue];
+
+    NSString *initiallyProcessedHtml =
+        [parser initiallyProcessHtml:newDefaultValue];
+    if (initiallyProcessedHtml == nullptr) {
+      // just plain text
+      textView.text = newDefaultValue;
+    } else {
+      // we've got some seemingly proper html
+      [parser replaceWholeFromHtml:initiallyProcessedHtml];
+    }
+    textView.selectedRange = NSRange(textView.textStorage.string.length, 0);
+  }
+
+  // placeholderTextColor
+  if (newViewProps.placeholderTextColor != oldViewProps.placeholderTextColor) {
+    // some real color
+    if (isColorMeaningful(newViewProps.placeholderTextColor)) {
+      _placeholderColor =
+          RCTUIColorFromSharedColor(newViewProps.placeholderTextColor);
+    } else {
+      _placeholderColor = nullptr;
+    }
+    [self refreshPlaceholderLabelStyles];
+  }
+
+  // placeholder
+  if (newViewProps.placeholder != oldViewProps.placeholder) {
+    _placeholderLabel.text = [NSString fromCppString:newViewProps.placeholder];
+    [self refreshPlaceholderLabelStyles];
+    // additionally show placeholder on first mount if it should be there
+    if (isFirstMount && textView.text.length == 0) {
+      [self setPlaceholderLabelShown:YES];
+    }
+  }
+
+  // mention indicators
+  auto mismatchPair = std::mismatch(newViewProps.mentionIndicators.begin(),
+                                    newViewProps.mentionIndicators.end(),
+                                    oldViewProps.mentionIndicators.begin(),
+                                    oldViewProps.mentionIndicators.end());
+  if (mismatchPair.first != newViewProps.mentionIndicators.end() ||
+      mismatchPair.second != oldViewProps.mentionIndicators.end()) {
+    NSMutableSet<NSNumber *> *newIndicators = [[NSMutableSet alloc] init];
+    for (const std::string &item : newViewProps.mentionIndicators) {
+      if (item.length() == 1) {
+        [newIndicators addObject:@(item[0])];
+      }
+    }
+    [config setMentionIndicators:newIndicators];
+  }
+
+  // linkRegex
+  LinkRegexConfig *oldRegexConfig =
+      [[LinkRegexConfig alloc] initWithLinkRegexProp:oldViewProps.linkRegex];
+  LinkRegexConfig *newRegexConfig =
+      [[LinkRegexConfig alloc] initWithLinkRegexProp:newViewProps.linkRegex];
+  if (![newRegexConfig isEqualToConfig:oldRegexConfig]) {
+    [config setLinkRegexConfig:newRegexConfig];
+  }
+
+  // selection color sets both selection and cursor on iOS (just as in RN)
+  if (newViewProps.selectionColor != oldViewProps.selectionColor) {
+    if (isColorMeaningful(newViewProps.selectionColor)) {
+      textView.tintColor =
+          RCTUIColorFromSharedColor(newViewProps.selectionColor);
+    } else {
+      textView.tintColor = nullptr;
+    }
+  }
+
+  if (newViewProps.returnKeyType != oldViewProps.returnKeyType) {
+    NSString *str = [NSString fromCppString:newViewProps.returnKeyType];
+
+    textView.returnKeyType =
+        [KeyboardUtils getUIReturnKeyTypeFromReturnKeyType:str];
+  }
+
+  if (newViewProps.submitBehavior != oldViewProps.submitBehavior) {
+    _submitBehavior = [NSString fromCppString:newViewProps.submitBehavior];
+  }
+
+  // autoCapitalize
+  if (newViewProps.autoCapitalize != oldViewProps.autoCapitalize) {
+    NSString *str = [NSString fromCppString:newViewProps.autoCapitalize];
+    if ([str isEqualToString:@"none"]) {
+      textView.autocapitalizationType = UITextAutocapitalizationTypeNone;
+    } else if ([str isEqualToString:@"sentences"]) {
+      textView.autocapitalizationType = UITextAutocapitalizationTypeSentences;
+    } else if ([str isEqualToString:@"words"]) {
+      textView.autocapitalizationType = UITextAutocapitalizationTypeWords;
+    } else if ([str isEqualToString:@"characters"]) {
+      textView.autocapitalizationType =
+          UITextAutocapitalizationTypeAllCharacters;
+    }
+
+    // textView needs to be refocused on autocapitalization type change and we
+    // don't want to emit these events
+    if ([textView isFirstResponder]) {
+      _emitFocusBlur = NO;
+      [textView reactBlur];
+      [textView reactFocus];
+      _emitFocusBlur = YES;
+    }
+  }
+
+  // isOnChangeHtmlSet
+  _emitHtml = newViewProps.isOnChangeHtmlSet;
+
+  // isOnChangeTextSet
+  _emitTextChange = newViewProps.isOnChangeTextSet;
+
+  // contextMenuItems
+  bool contextMenuChanged = newViewProps.contextMenuItems.size() !=
+                            oldViewProps.contextMenuItems.size();
+  if (!contextMenuChanged) {
+    for (size_t i = 0; i < newViewProps.contextMenuItems.size(); i++) {
+      if (newViewProps.contextMenuItems[i].text !=
+          oldViewProps.contextMenuItems[i].text) {
+        contextMenuChanged = true;
+        break;
+      }
+    }
+  }
+  if (contextMenuChanged) {
+    NSMutableArray<NSString *> *items = [NSMutableArray new];
+    for (const auto &item : newViewProps.contextMenuItems) {
+      [items addObject:[NSString fromCppString:item.text]];
+    }
+    _contextMenuItems = [items copy];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+  // run the changes callback
+  [self anyTextMayHaveBeenModified];
+
+  // autofocus - needs to be done at the very end
+  if (isFirstMount && newViewProps.autoFocus) {
+    [textView reactFocus];
+  }
+}
+
+- (void)setPlaceholderLabelShown:(BOOL)shown {
+  if (shown) {
+    [self refreshPlaceholderLabelStyles];
+    _placeholderLabel.hidden = NO;
+  } else {
+    _placeholderLabel.hidden = YES;
+  }
+}
+
+- (void)refreshPlaceholderLabelStyles {
+  NSMutableDictionary *newAttrs = [defaultTypingAttributes mutableCopy];
+  if (_placeholderColor != nullptr) {
+    newAttrs[NSForegroundColorAttributeName] = _placeholderColor;
+  }
+
+  // Get the current active alignment in input
+  NSParagraphStyle *currentTypingPara =
+      textView.typingAttributes[NSParagraphStyleAttributeName];
+  NSTextAlignment activeAlignment =
+      currentTypingPara ? currentTypingPara.alignment : NSTextAlignmentNatural;
+  NSMutableParagraphStyle *placeholderPStyle =
+      [newAttrs[NSParagraphStyleAttributeName] mutableCopy];
+  if (!placeholderPStyle) {
+    placeholderPStyle = [[NSMutableParagraphStyle alloc] init];
+  }
+  placeholderPStyle.alignment = activeAlignment;
+  newAttrs[NSParagraphStyleAttributeName] = placeholderPStyle;
+
+  NSAttributedString *newAttrStr =
+      [[NSAttributedString alloc] initWithString:_placeholderLabel.text
+                                      attributes:newAttrs];
+  _placeholderLabel.attributedText = newAttrStr;
+}
+
+- (void)refreshLineHeight {
+  [textView.textStorage
+      enumerateAttribute:NSParagraphStyleAttributeName
+                 inRange:NSMakeRange(0, textView.textStorage.string.length)
+                 options:0
+              usingBlock:^(id _Nullable value, NSRange range,
+                           BOOL *_Nonnull stop) {
+                NSMutableParagraphStyle *pStyle =
+                    [(NSParagraphStyle *)value mutableCopy];
+                if (pStyle == nil)
+                  return;
+                pStyle.minimumLineHeight = [config scaledPrimaryLineHeight];
+                [textView.textStorage addAttribute:NSParagraphStyleAttributeName
+                                             value:pStyle
+                                             range:range];
+              }];
+}
+
+// MARK: - Measuring and states
+
+- (CGSize)measureSize:(CGFloat)maxWidth {
+  // copy the the whole attributed string
+  NSMutableAttributedString *currentStr = [[NSMutableAttributedString alloc]
+      initWithAttributedString:textView.textStorage];
+
+  // edge case: empty input should still be of a height of a single line, so we
+  // add a mock "I" character
+  if ([currentStr length] == 0) {
+    [currentStr
+        appendAttributedString:[[NSAttributedString alloc]
+                                   initWithString:@"I"
+                                       attributes:textView.typingAttributes]];
+  }
+
+  // edge case: input with only a zero width space should still be of a height
+  // of a single line, so we add a mock "I" character
+  if ([currentStr length] == 1 &&
+      [[currentStr.string substringWithRange:NSMakeRange(0, 1)]
+          isEqualToString:@"\u200B"]) {
+    [currentStr
+        appendAttributedString:[[NSAttributedString alloc]
+                                   initWithString:@"I"
+                                       attributes:textView.typingAttributes]];
+  }
+
+  // edge case: trailing newlines aren't counted towards height calculations, so
+  // we add a mock "I" character
+  if (currentStr.length > 0) {
+    unichar lastChar =
+        [currentStr.string characterAtIndex:currentStr.length - 1];
+    if ([[NSCharacterSet newlineCharacterSet] characterIsMember:lastChar]) {
+      [currentStr
+          appendAttributedString:[[NSAttributedString alloc]
+                                     initWithString:@"I"
+                                         attributes:defaultTypingAttributes]];
+    }
+  }
+
+  CGRect boundingBox =
+      [currentStr boundingRectWithSize:CGSizeMake(maxWidth, CGFLOAT_MAX)
+                               options:NSStringDrawingUsesLineFragmentOrigin |
+                                       NSStringDrawingUsesFontLeading
+                               context:nullptr];
+
+  return CGSizeMake(maxWidth, ceil(boundingBox.size.height));
+}
+
+// make sure the newest state is kept in _state property
+- (void)updateState:(State::Shared const &)state
+           oldState:(State::Shared const &)oldState {
+  _state = std::static_pointer_cast<
+      const EnrichedTextInputViewShadowNode::ConcreteState>(state);
+
+  // first render with all the needed stuff already defined (state and
+  // componentView) so we need to run a single height calculation for any
+  // initial values
+  if (oldState == nullptr) {
+    [self tryUpdatingHeight];
+  }
+}
+
+- (void)tryUpdatingHeight {
+  if (_state == nullptr) {
+    return;
+  }
+  _componentViewHeightUpdateCounter++;
+  auto selfRef = wrapManagedObjectWeakly(self);
+  _state->updateState(
+      EnrichedTextInputViewState(_componentViewHeightUpdateCounter, selfRef));
+}
+
+// MARK: - Active styles
+
+- (void)tryUpdatingActiveStyles {
+  // style updates are emitted only if something differs from the previously
+  // active styles
+  BOOL updateNeeded = NO;
+
+  // active styles are kept in a separate set until we're sure they can be
+  // emitted
+  NSMutableSet *newActiveStyles = [_activeStyles mutableCopy];
+
+  // currently blocked styles are subject to change (e.g. bold being blocked by
+  // headings might change in reaction to prop change) so they also are kept
+  // separately
+  NSMutableSet *newBlockedStyles = [_blockedStyles mutableCopy];
+
+  // data for onLinkDetected event
+  LinkData *detectedLinkData;
+  NSRange detectedLinkRange = NSMakeRange(0, 0);
+  BOOL shouldClearLink = NO;
+
+  // data for onMentionDetected event
+  MentionParams *detectedMentionParams = nullptr;
+  NSRange detectedMentionRange = NSMakeRange(0, 0);
+  BOOL shouldClearMention = NO;
+
+  for (NSNumber *type in stylesDict) {
+    StyleBase *style = stylesDict[type];
+
+    BOOL wasActive = [newActiveStyles containsObject:type];
+    BOOL isActive = [style detect:textView.selectedRange];
+
+    BOOL wasBlocked = [newBlockedStyles containsObject:type];
+    BOOL isBlocked = [self isStyle:(StyleType)[type integerValue]
+                       activeInMap:blockingStyles];
+
+    if (wasActive != isActive) {
+      updateNeeded = YES;
+      if (isActive) {
+        [newActiveStyles addObject:type];
+      } else {
+        [newActiveStyles removeObject:type];
+      }
+    }
+
+    // blocked state change for a style also needs an update
+    if (wasBlocked != isBlocked) {
+      updateNeeded = YES;
+      if (isBlocked) {
+        [newBlockedStyles addObject:type];
+      } else {
+        [newBlockedStyles removeObject:type];
+      }
+    }
+
+    // onLinkDetected event
+    if ([type intValue] == [LinkStyle getType]) {
+      if (isActive) {
+        // get the link data
+        LinkData *candidateLinkData;
+        NSRange candidateLinkRange = NSMakeRange(0, 0);
+        LinkStyle *linkStyleClass =
+            (LinkStyle *)stylesDict[@([LinkStyle getType])];
+        if (linkStyleClass != nullptr) {
+          candidateLinkData =
+              [linkStyleClass getLinkDataAt:textView.selectedRange.location];
+          candidateLinkRange = [linkStyleClass
+              getFullLinkRangeAt:textView.selectedRange.location];
+        }
+
+        if (wasActive == NO) {
+          // we changed selection from non-link to a link
+          detectedLinkData = candidateLinkData;
+          detectedLinkRange = candidateLinkRange;
+        } else if (![_recentlyActiveLinkData
+                       isEqualToLinkData:candidateLinkData] ||
+                   !NSEqualRanges(_recentlyActiveLinkRange,
+                                  candidateLinkRange)) {
+          // we changed selection from one link to the other or modified
+          // current link's text
+          detectedLinkData = candidateLinkData;
+          detectedLinkRange = candidateLinkRange;
+        }
+      } else if (wasActive) {
+        shouldClearLink = YES;
+      }
+    }
+
+    // onMentionDetected event
+    if ([type intValue] == [MentionStyle getType]) {
+      if (isActive) {
+        // get mention data
+        MentionParams *candidateMentionParams;
+        NSRange candidateMentionRange = NSMakeRange(0, 0);
+        MentionStyle *mentionStyleClass =
+            (MentionStyle *)stylesDict[@([MentionStyle getType])];
+        if (mentionStyleClass != nullptr) {
+          candidateMentionParams = [mentionStyleClass
+              getMentionParamsAt:textView.selectedRange.location];
+          candidateMentionRange = [mentionStyleClass
+              getFullMentionRangeAt:textView.selectedRange.location];
+        }
+
+        if (wasActive == NO) {
+          // selection was changed from a non-mention to a mention
+          detectedMentionParams = candidateMentionParams;
+          detectedMentionRange = candidateMentionRange;
+        } else if (![_recentlyActiveMentionParams.text
+                       isEqualToString:candidateMentionParams.text] ||
+                   ![_recentlyActiveMentionParams.attributes
+                       isEqualToString:candidateMentionParams.attributes] ||
+                   !NSEqualRanges(_recentlyActiveMentionRange,
+                                  candidateMentionRange)) {
+          // selection changed from one mention to another
+          detectedMentionParams = candidateMentionParams;
+          detectedMentionRange = candidateMentionRange;
+        }
+      } else if (wasActive) {
+        shouldClearMention = YES;
+      }
+    }
+  }
+
+  // detect alignment change
+  AlignmentStyle *alignmentStyle = stylesDict[@([AlignmentStyle getType])];
+  NSString *currentAlignment = [alignmentStyle getStyleState];
+  if (![currentAlignment isEqualToString:_recentlyEmittedAlignment]) {
+    updateNeeded = YES;
+  }
+
+  if (updateNeeded) {
+    auto emitter = [self getEventEmitter];
+    if (emitter != nullptr) {
+      // update activeStyles and blockedStyles only if emitter is available
+      _activeStyles = newActiveStyles;
+      _blockedStyles = newBlockedStyles;
+      _recentlyEmittedAlignment = currentAlignment;
+
+      emitter->onChangeState(
+          {.bold = GET_STYLE_STATE([BoldStyle getType]),
+           .italic = GET_STYLE_STATE([ItalicStyle getType]),
+           .underline = GET_STYLE_STATE([UnderlineStyle getType]),
+           .strikeThrough = GET_STYLE_STATE([StrikethroughStyle getType]),
+           .inlineCode = GET_STYLE_STATE([InlineCodeStyle getType]),
+           .link = GET_STYLE_STATE([LinkStyle getType]),
+           .mention = GET_STYLE_STATE([MentionStyle getType]),
+           .h1 = GET_STYLE_STATE([H1Style getType]),
+           .h2 = GET_STYLE_STATE([H2Style getType]),
+           .h3 = GET_STYLE_STATE([H3Style getType]),
+           .h4 = GET_STYLE_STATE([H4Style getType]),
+           .h5 = GET_STYLE_STATE([H5Style getType]),
+           .h6 = GET_STYLE_STATE([H6Style getType]),
+           .unorderedList = GET_STYLE_STATE([UnorderedListStyle getType]),
+           .orderedList = GET_STYLE_STATE([OrderedListStyle getType]),
+           .blockQuote = GET_STYLE_STATE([BlockQuoteStyle getType]),
+           .codeBlock = GET_STYLE_STATE([CodeBlockStyle getType]),
+           .image = GET_STYLE_STATE([ImageStyle getType]),
+           .checkboxList = GET_STYLE_STATE([CheckboxListStyle getType]),
+           .alignment = [currentAlignment UTF8String]});
+    }
+  }
+
+  if (detectedLinkData != nullptr) {
+    // emit onLinkeDetected event
+    [self emitOnLinkDetectedEvent:detectedLinkData range:detectedLinkRange];
+  } else if (shouldClearLink) {
+    LinkData *emptyLinkData = [[LinkData alloc] init];
+    emptyLinkData.text = @"";
+    emptyLinkData.url = @"";
+    [self emitOnLinkDetectedEvent:emptyLinkData range:NSMakeRange(0, 0)];
+  }
+
+  if (detectedMentionParams != nullptr) {
+    // emit onMentionDetected event
+    [self emitOnMentionDetectedEvent:detectedMentionParams.text
+                           indicator:detectedMentionParams.indicator
+                          attributes:detectedMentionParams.attributes];
+
+    _recentlyActiveMentionParams = detectedMentionParams;
+    _recentlyActiveMentionRange = detectedMentionRange;
+  } else if (shouldClearMention) {
+    [self emitOnMentionDetectedEvent:@"" indicator:@"" attributes:@"{}"];
+    _recentlyActiveMentionParams = nullptr;
+    _recentlyActiveMentionRange = NSMakeRange(0, 0);
+  }
+  // emit onChangeHtml event if needed
+  [self tryEmittingOnChangeHtmlEvent];
+}
+
+- (bool)isStyleActive:(StyleType)type {
+  return [_activeStyles containsObject:@(type)];
+}
+
+- (bool)isStyle:(StyleType)type activeInMap:(NSDictionary *)styleMap {
+  NSArray *relatedStyles = styleMap[@(type)];
+
+  if (!relatedStyles) {
+    return false;
+  }
+
+  for (NSNumber *style in relatedStyles) {
+    if ([_activeStyles containsObject:style]) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+- (bool)textInputShouldReturn {
+  return [_submitBehavior isEqualToString:@"blurAndSubmit"];
+}
+
+- (bool)textInputShouldSubmitOnReturn {
+  return [_submitBehavior isEqualToString:@"blurAndSubmit"] ||
+         [_submitBehavior isEqualToString:@"submit"];
+}
+
+// MARK: - Native commands and events
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
+  if ([commandName isEqualToString:@"focus"]) {
+    [self focus];
+  } else if ([commandName isEqualToString:@"blur"]) {
+    [self blur];
+  } else if ([commandName isEqualToString:@"setValue"]) {
+    NSString *value = (NSString *)args[0];
+    [self setValue:value];
+  } else if ([commandName isEqualToString:@"toggleBold"]) {
+    [self toggleRegularStyle:[BoldStyle getType]];
+  } else if ([commandName isEqualToString:@"toggleItalic"]) {
+    [self toggleRegularStyle:[ItalicStyle getType]];
+  } else if ([commandName isEqualToString:@"toggleUnderline"]) {
+    [self toggleRegularStyle:[UnderlineStyle getType]];
+  } else if ([commandName isEqualToString:@"toggleStrikeThrough"]) {
+    [self toggleRegularStyle:[StrikethroughStyle getType]];
+  } else if ([commandName isEqualToString:@"toggleInlineCode"]) {
+    [self toggleRegularStyle:[InlineCodeStyle getType]];
+  } else if ([commandName isEqualToString:@"addLink"]) {
+    NSInteger start = [((NSNumber *)args[0]) integerValue];
+    NSInteger end = [((NSNumber *)args[1]) integerValue];
+    NSString *text = (NSString *)args[2];
+    NSString *url = (NSString *)args[3];
+    [self addLinkAt:start end:end text:text url:url];
+  } else if ([commandName isEqualToString:@"removeLink"]) {
+    NSInteger start = [((NSNumber *)args[0]) integerValue];
+    NSInteger end = [((NSNumber *)args[1]) integerValue];
+    [self removeLinkAt:start end:end];
+  } else if ([commandName isEqualToString:@"addMention"]) {
+    NSString *indicator = (NSString *)args[0];
+    NSString *text = (NSString *)args[1];
+    NSString *attributes = (NSString *)args[2];
+    [self addMention:indicator text:text attributes:attributes];
+  } else if ([commandName isEqualToString:@"startMention"]) {
+    NSString *indicator = (NSString *)args[0];
+    [self startMentionWithIndicator:indicator];
+  } else if ([commandName isEqualToString:@"toggleH1"]) {
+    [self toggleRegularStyle:[H1Style getType]];
+  } else if ([commandName isEqualToString:@"toggleH2"]) {
+    [self toggleRegularStyle:[H2Style getType]];
+  } else if ([commandName isEqualToString:@"toggleH3"]) {
+    [self toggleRegularStyle:[H3Style getType]];
+  } else if ([commandName isEqualToString:@"toggleH4"]) {
+    [self toggleRegularStyle:[H4Style getType]];
+  } else if ([commandName isEqualToString:@"toggleH5"]) {
+    [self toggleRegularStyle:[H5Style getType]];
+  } else if ([commandName isEqualToString:@"toggleH6"]) {
+    [self toggleRegularStyle:[H6Style getType]];
+  } else if ([commandName isEqualToString:@"toggleUnorderedList"]) {
+    [self toggleRegularStyle:[UnorderedListStyle getType]];
+  } else if ([commandName isEqualToString:@"toggleOrderedList"]) {
+    [self toggleRegularStyle:[OrderedListStyle getType]];
+  } else if ([commandName isEqualToString:@"toggleCheckboxList"]) {
+    BOOL checked = [args[0] boolValue];
+    [self toggleCheckboxList:checked];
+  } else if ([commandName isEqualToString:@"toggleBlockQuote"]) {
+    [self toggleRegularStyle:[BlockQuoteStyle getType]];
+  } else if ([commandName isEqualToString:@"toggleCodeBlock"]) {
+    [self toggleRegularStyle:[CodeBlockStyle getType]];
+  } else if ([commandName isEqualToString:@"addImage"]) {
+    NSString *uri = (NSString *)args[0];
+    CGFloat imgWidth = [(NSNumber *)args[1] floatValue];
+    CGFloat imgHeight = [(NSNumber *)args[2] floatValue];
+
+    [self addImage:uri width:imgWidth height:imgHeight];
+  } else if ([commandName isEqualToString:@"setSelection"]) {
+    NSInteger start = [((NSNumber *)args[0]) integerValue];
+    NSInteger end = [((NSNumber *)args[1]) integerValue];
+    [self setCustomSelection:start end:end];
+  } else if ([commandName isEqualToString:@"requestHTML"]) {
+    NSInteger requestId = [((NSNumber *)args[0]) integerValue];
+    [self requestHTML:requestId];
+  } else if ([commandName isEqualToString:@"setTextAlignment"]) {
+    NSString *alignmentString = (NSString *)args[0];
+
+    AlignmentStyle *alignmentStyle = stylesDict[@([AlignmentStyle getType])];
+    [alignmentStyle
+          addAlignment:[AlignmentUtils stringToAlignment:alignmentString]
+                 range:textView.selectedRange
+            withTyping:YES
+        withDirtyRange:YES];
+
+    [self anyTextMayHaveBeenModified];
+    if (!_placeholderLabel.isHidden) {
+      [self refreshPlaceholderLabelStyles];
+    }
+  }
+}
+
+- (std::shared_ptr<EnrichedTextInputViewEventEmitter>)getEventEmitter {
+  if (_eventEmitter != nullptr && !blockEmitting) {
+    auto emitter =
+        static_cast<const EnrichedTextInputViewEventEmitter &>(*_eventEmitter);
+    return std::make_shared<EnrichedTextInputViewEventEmitter>(emitter);
+  } else {
+    return nullptr;
+  }
+}
+
+- (void)blur {
+  [textView reactBlur];
+}
+
+- (void)focus {
+  [textView reactFocus];
+}
+
+- (void)setValue:(NSString *)value {
+  NSString *initiallyProcessedHtml = [parser initiallyProcessHtml:value];
+  if (initiallyProcessedHtml == nullptr) {
+    // reset the text first and reset typing attributes
+    textView.text = @"";
+    textView.typingAttributes = defaultTypingAttributes;
+    // set new text
+    textView.text = value;
+  } else {
+    // we've got some seemingly proper html
+    [parser replaceWholeFromHtml:initiallyProcessedHtml];
+  }
+
+  // set selectedRange and check for changes
+  textView.selectedRange = NSRange(textView.textStorage.string.length, 0);
+  [self anyTextMayHaveBeenModified];
+}
+
+- (void)setCustomSelection:(NSInteger)visibleStart end:(NSInteger)visibleEnd {
+  NSString *text = textView.textStorage.string;
+
+  NSUInteger actualStart = [self getActualIndex:visibleStart text:text];
+  NSUInteger actualEnd = [self getActualIndex:visibleEnd text:text];
+
+  textView.selectedRange = NSMakeRange(actualStart, actualEnd - actualStart);
+}
+
+// Helper: Walks through the string skipping ZWSPs to find the Nth visible
+// character
+- (NSUInteger)getActualIndex:(NSInteger)visibleIndex text:(NSString *)text {
+  NSUInteger currentVisibleCount = 0;
+  NSUInteger actualIndex = 0;
+
+  while (actualIndex < text.length) {
+    if (currentVisibleCount == visibleIndex) {
+      return actualIndex;
+    }
+
+    // If the current char is not a hidden space, it counts towards our visible
+    // index.
+    if ([text characterAtIndex:actualIndex] != 0x200B) {
+      currentVisibleCount++;
+    }
+
+    actualIndex++;
+  }
+
+  return actualIndex;
+}
+
+- (void)emitOnSubmitEdittingEvent {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    NSString *stringToBeEmitted = [[textView.textStorage.string
+        stringByReplacingOccurrencesOfString:@"\u200B"
+                                  withString:@""] copy];
+
+    emitter->onSubmitEditing({
+        .text = [stringToBeEmitted toCppString],
+    });
+  }
+}
+
+- (void)emitOnLinkDetectedEvent:(LinkData *)linkData range:(NSRange)range {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    // update recently active link info
+    _recentlyActiveLinkData = linkData;
+    _recentlyActiveLinkRange = range;
+
+    emitter->onLinkDetected({
+        .text = [linkData.text toCppString],
+        .url = [linkData.url toCppString],
+        .start = static_cast<int>(range.location),
+        .end = static_cast<int>(range.location + range.length),
+    });
+  }
+}
+
+- (void)emitOnPasteImagesEvent:(NSArray<NSDictionary *> *)images {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    std::vector<EnrichedTextInputViewEventEmitter::OnPasteImagesImages>
+        imagesVector;
+    imagesVector.reserve(images.count);
+
+    for (NSDictionary *img in images) {
+      NSString *uri = img[@"uri"];
+      NSString *type = img[@"type"];
+      double width = [img[@"width"] doubleValue];
+      double height = [img[@"height"] doubleValue];
+
+      EnrichedTextInputViewEventEmitter::OnPasteImagesImages imageStruct = {
+          .uri = [uri toCppString],
+          .type = [type toCppString],
+          .width = width,
+          .height = height};
+
+      imagesVector.push_back(imageStruct);
+    }
+
+    emitter->onPasteImages({.images = imagesVector});
+  }
+}
+
+- (void)emitOnMentionDetectedEvent:(NSString *)text
+                         indicator:(NSString *)indicator
+                        attributes:(NSString *)attributes {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    emitter->onMentionDetected({.text = [text toCppString],
+                                .indicator = [indicator toCppString],
+                                .payload = [attributes toCppString]});
+  }
+}
+
+- (void)emitOnMentionEvent:(NSString *)indicator text:(NSString *)text {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    if (text != nullptr) {
+      folly::dynamic fdStr = [text toCppString];
+      emitter->onMention({.indicator = [indicator toCppString], .text = fdStr});
+    } else {
+      folly::dynamic nul = nullptr;
+      emitter->onMention({.indicator = [indicator toCppString], .text = nul});
+    }
+  }
+}
+
+- (void)tryEmittingOnChangeHtmlEvent {
+  if (!_emitHtml || textView.markedTextRange != nullptr) {
+    return;
+  }
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    NSString *htmlOutput = [HtmlParser
+        parseToHtmlFromRange:NSMakeRange(0, textView.textStorage.string.length)
+                        host:self];
+    // make sure html really changed
+    if (![htmlOutput isEqualToString:_recentlyEmittedHtml]) {
+      _recentlyEmittedHtml = htmlOutput;
+      emitter->onChangeHtml({.value = [htmlOutput toCppString]});
+    }
+  }
+}
+
+- (void)requestHTML:(NSInteger)requestId {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    @try {
+      NSString *htmlOutput = [HtmlParser
+          parseToHtmlFromRange:NSMakeRange(0,
+                                           textView.textStorage.string.length)
+                          host:self];
+      emitter->onRequestHtmlResult({.requestId = static_cast<int>(requestId),
+                                    .html = [htmlOutput toCppString]});
+    } @catch (NSException *exception) {
+      emitter->onRequestHtmlResult({.requestId = static_cast<int>(requestId),
+                                    .html = folly::dynamic(nullptr)});
+    }
+  }
+}
+
+- (void)emitOnKeyPressEvent:(NSString *)key {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    emitter->onInputKeyPress({.key = [key toCppString]});
+  }
+}
+
+// MARK: - Styles manipulation
+
+- (void)toggleRegularStyle:(StyleType)type {
+  StyleBase *style = stylesDict[@(type)];
+  NSRange range = textView.selectedRange;
+  if ([style isParagraph]) {
+    range = [textView.textStorage.string paragraphRangeForRange:range];
+  }
+  if ([StyleUtils handleStyleBlocksAndConflicts:type
+                                          range:range
+                                        forHost:self]) {
+    [style toggle:range];
+    [self anyTextMayHaveBeenModified];
+  }
+}
+
+- (void)toggleCheckboxList:(BOOL)checked {
+  CheckboxListStyle *style =
+      (CheckboxListStyle *)stylesDict[@([CheckboxListStyle getType])];
+  if (style == nullptr) {
+    return;
+  }
+  NSRange range = [textView.textStorage.string
+      paragraphRangeForRange:textView.selectedRange];
+  if ([StyleUtils handleStyleBlocksAndConflicts:[CheckboxListStyle getType]
+                                          range:range
+                                        forHost:self]) {
+    [style toggleWithChecked:checked range:range];
+    [self anyTextMayHaveBeenModified];
+  }
+}
+
+- (void)addLinkAt:(NSInteger)start
+              end:(NSInteger)end
+             text:(NSString *)text
+              url:(NSString *)url {
+  LinkStyle *linkStyleClass = (LinkStyle *)stylesDict[@([LinkStyle getType])];
+  if (linkStyleClass == nullptr) {
+    return;
+  }
+
+  // translate the output start-end notation to range
+  NSRange linkRange = NSMakeRange(start, end - start);
+  if ([StyleUtils handleStyleBlocksAndConflicts:[LinkStyle getType]
+                                          range:linkRange
+                                        forHost:self]) {
+    LinkData *linkData = [[LinkData alloc] init];
+    linkData.text = text;
+    linkData.url = url;
+    linkData.isManual = YES;
+    [linkStyleClass addLink:linkData range:linkRange withSelection:YES];
+    [self anyTextMayHaveBeenModified];
+  }
+}
+
+- (void)removeLinkAt:(NSInteger)start end:(NSInteger)end {
+  LinkStyle *linkStyleClass = (LinkStyle *)stylesDict[@([LinkStyle getType])];
+  if (linkStyleClass == nullptr) {
+    return;
+  }
+
+  NSInteger textLength = (NSInteger)textView.textStorage.length;
+  if (start < 0) {
+    start = 0;
+  }
+  if (end > textLength) {
+    end = textLength;
+  }
+
+  NSInteger rangeStart = MIN(start, end);
+  NSInteger rangeLength = MAX(start, end) - rangeStart;
+  NSRange linkRange = NSMakeRange(rangeStart, rangeLength);
+
+  [linkStyleClass remove:linkRange withDirtyRange:YES];
+  [self anyTextMayHaveBeenModified];
+}
+
+- (void)addMention:(NSString *)indicator
+              text:(NSString *)text
+        attributes:(NSString *)attributes {
+  MentionStyle *mentionStyleClass =
+      (MentionStyle *)stylesDict[@([MentionStyle getType])];
+  if (mentionStyleClass == nullptr) {
+    return;
+  }
+
+  NSValue *activeMentionRange = [mentionStyleClass getActiveMentionRange];
+  NSRange rangeToUse = activeMentionRange != nullptr
+                           ? [activeMentionRange rangeValue]
+                           : self.textView.selectedRange;
+
+  if ([StyleUtils handleStyleBlocksAndConflicts:[MentionStyle getType]
+                                          range:rangeToUse
+                                        forHost:self]) {
+    [mentionStyleClass addMention:indicator text:text attributes:attributes];
+    [self anyTextMayHaveBeenModified];
+  }
+}
+
+- (void)addImage:(NSString *)uri width:(float)width height:(float)height {
+  ImageStyle *imageStyleClass =
+      (ImageStyle *)stylesDict[@([ImageStyle getType])];
+  if (imageStyleClass == nullptr) {
+    return;
+  }
+
+  if ([StyleUtils handleStyleBlocksAndConflicts:[ImageStyle getType]
+                                          range:textView.selectedRange
+                                        forHost:self]) {
+    [imageStyleClass addImage:uri width:width height:height];
+    [self anyTextMayHaveBeenModified];
+  }
+}
+
+- (void)startMentionWithIndicator:(NSString *)indicator {
+  MentionStyle *mentionStyleClass =
+      (MentionStyle *)stylesDict[@([MentionStyle getType])];
+  if (mentionStyleClass == nullptr) {
+    return;
+  }
+
+  if ([StyleUtils handleStyleBlocksAndConflicts:[MentionStyle getType]
+                                          range:textView.selectedRange
+                                        forHost:self]) {
+    [mentionStyleClass startMentionWithIndicator:indicator];
+    [self anyTextMayHaveBeenModified];
+  }
+}
+
+- (void)manageSelectionBasedChanges {
+  NSString *currentString = [textView.textStorage.string copy];
+
+  MentionStyle *mentionStyleClass =
+      (MentionStyle *)stylesDict[@([MentionStyle getType])];
+  if (mentionStyleClass != nullptr) {
+    // mention editing runs if only a selection was done (no text change)
+    // otherwise we would double-emit with a second call in the
+    // anyTextMayHaveBeenModified method
+    if ([_recentInputString isEqualToString:currentString]) {
+      [mentionStyleClass manageMentionEditing];
+    }
+  }
+
+  // attributes manager handles proper typingAttributes at all times to properly
+  // extend meta-attributes
+  BOOL onlySelectionChanged =
+      textView.selectedRange.length == 0 &&
+      [_recentInputString isEqualToString:currentString];
+  // removedTypingAttributes aren't normally removed during the regular flow
+  // and we do remove them only here - so when we are sure that selection
+  // changed. We want to remember which attributes were removed as long as we
+  // stay at the same position. This prevents a removed attribute from being
+  // re-applied from the preceding character right after we toggled it off.
+  [attributesManager clearRemovedTypingAttributes];
+  [attributesManager
+      manageTypingAttributesWithOnlySelection:onlySelectionChanged];
+
+  // always update active styles
+  [self tryUpdatingActiveStyles];
+}
+
+- (void)handleWordModificationBasedChanges:(NSString *)word
+                                   inRange:(NSRange)range {
+  // manual links refreshing and automatic links detection handling
+  LinkStyle *linkStyle = [stylesDict objectForKey:@([LinkStyle getType])];
+
+  if (linkStyle != nullptr) {
+    // manual links need to be handled first because they can block automatic
+    // links after being refreshed
+    [linkStyle handleManualLinks:word inRange:range];
+    [linkStyle handleAutomaticLinks:word inRange:range];
+  }
+}
+
+- (void)anyTextMayHaveBeenModified {
+  // we don't do no text changes when working with iOS marked text
+  if (textView.markedTextRange != nullptr) {
+    return;
+  }
+
+  // zero width space adding or removal
+  [ZeroWidthSpaceUtils handleZeroWidthSpacesInHost:self];
+
+  // emptying input typing attributes management
+  if (textView.textStorage.string.length == 0 &&
+      _recentInputString.length > 0) {
+    // reset typing attribtues
+    textView.typingAttributes = defaultTypingAttributes;
+  }
+
+  // mentions management: removal and editing
+  MentionStyle *mentionStyleClass =
+      (MentionStyle *)stylesDict[@([MentionStyle getType])];
+  if (mentionStyleClass != nullptr) {
+    [mentionStyleClass handleExistingMentions];
+    [mentionStyleClass manageMentionEditing];
+  }
+
+  // placholder management
+  if (!_placeholderLabel.hidden && textView.textStorage.string.length > 0) {
+    [self setPlaceholderLabelShown:NO];
+  } else if (textView.textStorage.string.length == 0 &&
+             _placeholderLabel.hidden) {
+    [self setPlaceholderLabelShown:YES];
+  }
+
+  // modified words handling
+  NSArray *currentDirtyRanges = [attributesManager getDirtyRanges];
+  if (currentDirtyRanges.count > 0) {
+    NSMutableArray *modifiedWords = [[NSMutableArray alloc] init];
+
+    for (NSValue *dirtyRangeValue in currentDirtyRanges) {
+      NSRange dirtyRange = [dirtyRangeValue rangeValue];
+      NSArray *words =
+          [WordsUtils getAffectedWordsFromText:textView.textStorage.string
+                             modificationRange:dirtyRange];
+      if (words != nullptr) {
+        [modifiedWords addObjectsFromArray:words];
+      }
+    }
+
+    for (NSDictionary *wordDict in modifiedWords) {
+      NSString *wordText = (NSString *)[wordDict objectForKey:@"word"];
+      NSValue *wordRange = (NSValue *)[wordDict objectForKey:@"range"];
+
+      if (wordText == nullptr || wordRange == nullptr) {
+        continue;
+      }
+
+      [self handleWordModificationBasedChanges:wordText
+                                       inRange:[wordRange rangeValue]];
+    }
+  }
+
+  if (![textView.textStorage.string isEqualToString:_recentInputString]) {
+    // emit onChangeText event
+    auto emitter = [self getEventEmitter];
+    if (emitter != nullptr && _emitTextChange) {
+      // set the recent input string only if the emitter is defined
+      _recentInputString = [textView.textStorage.string copy];
+
+      // emit string without zero width spaces
+      NSString *stringToBeEmitted = [[textView.textStorage.string
+          stringByReplacingOccurrencesOfString:@"\u200B"
+                                    withString:@""] copy];
+
+      emitter->onChangeText({.value = [stringToBeEmitted toCppString]});
+    }
+  }
+  // all the visible (not meta) attributes handling in the ranges that could
+  // have changed
+  [attributesManager handleDirtyRangesStyling];
+  // update height on each character change
+  [self tryUpdatingHeight];
+  // update active styles as well
+  [self tryUpdatingActiveStyles];
+  [self layoutAttachments];
+  // update drawing - schedule debounced relayout
+  [self scheduleRelayoutIfNeeded];
+}
+
+// Debounced relayout helper - coalesces multiple requests into one per runloop
+// tick
+- (void)scheduleRelayoutIfNeeded {
+  // Cancel any previously scheduled invocation to debounce
+  [NSObject cancelPreviousPerformRequestsWithTarget:self
+                                           selector:@selector(_performRelayout)
+                                             object:nil];
+  // Schedule on next runloop cycle
+  [self performSelector:@selector(_performRelayout)
+             withObject:nil
+             afterDelay:0];
+}
+
+- (void)_performRelayout {
+  if (!textView) {
+    return;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSRange wholeRange =
+        NSMakeRange(0, self->textView.textStorage.string.length);
+    NSRange actualRange = NSMakeRange(0, 0);
+    [self->textView.layoutManager
+        invalidateLayoutForCharacterRange:wholeRange
+                     actualCharacterRange:&actualRange];
+    [self->textView.layoutManager ensureLayoutForCharacterRange:actualRange];
+    [self->textView.layoutManager
+        invalidateDisplayForCharacterRange:wholeRange];
+
+    // We have to explicitly set contentSize
+    // That way textView knows if content overflows and if should be scrollable
+    // We recall measureSize here because value returned from previous
+    // measureSize may not be up-to date at that point
+    CGSize measuredSize = [self measureSize:self->textView.frame.size.width];
+    self->textView.contentSize = measuredSize;
+  });
+}
+
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+  // used to run all lifecycle callbacks
+  [self anyTextMayHaveBeenModified];
+}
+
+// MARK: - Delegate methods
+
+- (void)textViewDidBeginEditing:(UITextView *)textView {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    // send onFocus event if allowed
+    if (_emitFocusBlur) {
+      emitter->onInputFocus({});
+    }
+  }
+  // manage selection changes since textViewDidChangeSelection sometimes doesn't
+  // run on focus
+  [self manageSelectionBasedChanges];
+}
+
+- (void)textViewDidEndEditing:(UITextView *)textView {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr && _emitFocusBlur) {
+    // send onBlur event
+    emitter->onInputBlur({});
+  }
+}
+
+- (UIMenu *)textView:(UITextView *)tv
+    editMenuForTextInRange:(NSRange)range
+          suggestedActions:(NSArray<UIMenuElement *> *)suggestedActions
+    API_AVAILABLE(ios(16.0)) {
+  if (_contextMenuItems == nil || _contextMenuItems.count == 0) {
+    return [UIMenu menuWithChildren:suggestedActions];
+  }
+
+  NSMutableArray<UIMenuElement *> *customActions = [NSMutableArray new];
+
+  for (NSString *title in _contextMenuItems) {
+    __weak EnrichedTextInputView *weakSelf = self;
+
+    UIAction *action =
+        [UIAction actionWithTitle:title
+                            image:nil
+                       identifier:nil
+                          handler:^(__kindof UIAction *_Nonnull action) {
+                            [weakSelf emitOnContextMenuItemPressEvent:title];
+                          }];
+    [customActions addObject:action];
+  }
+
+  [customActions addObjectsFromArray:suggestedActions];
+  return [UIMenu menuWithChildren:customActions];
+}
+
+- (void)emitOnContextMenuItemPressEvent:(NSString *)itemText {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    NSRange selectedRange = textView.selectedRange;
+    NSString *selectedText = @"";
+    if (selectedRange.length > 0) {
+      selectedText =
+          [textView.textStorage.string substringWithRange:selectedRange];
+    }
+
+    AlignmentStyle *alignmentStyle = stylesDict[@([AlignmentStyle getType])];
+    NSString *currentAlignment = [alignmentStyle getStyleState];
+
+    emitter->onContextMenuItemPress(
+        {.itemText = [itemText toCppString],
+         .selectedText = [selectedText toCppString],
+         .selectionStart = static_cast<int>(selectedRange.location),
+         .selectionEnd =
+             static_cast<int>(selectedRange.location + selectedRange.length),
+         .styleState = {
+             .bold = GET_STYLE_STATE([BoldStyle getType]),
+             .italic = GET_STYLE_STATE([ItalicStyle getType]),
+             .underline = GET_STYLE_STATE([UnderlineStyle getType]),
+             .strikeThrough = GET_STYLE_STATE([StrikethroughStyle getType]),
+             .inlineCode = GET_STYLE_STATE([InlineCodeStyle getType]),
+             .h1 = GET_STYLE_STATE([H1Style getType]),
+             .h2 = GET_STYLE_STATE([H2Style getType]),
+             .h3 = GET_STYLE_STATE([H3Style getType]),
+             .h4 = GET_STYLE_STATE([H4Style getType]),
+             .h5 = GET_STYLE_STATE([H5Style getType]),
+             .h6 = GET_STYLE_STATE([H6Style getType]),
+             .codeBlock = GET_STYLE_STATE([CodeBlockStyle getType]),
+             .blockQuote = GET_STYLE_STATE([BlockQuoteStyle getType]),
+             .orderedList = GET_STYLE_STATE([OrderedListStyle getType]),
+             .unorderedList = GET_STYLE_STATE([UnorderedListStyle getType]),
+             .link = GET_STYLE_STATE([LinkStyle getType]),
+             .image = GET_STYLE_STATE([ImageStyle getType]),
+             .mention = GET_STYLE_STATE([MentionStyle getType]),
+             .checkboxList = GET_STYLE_STATE([CheckboxListStyle getType]),
+             .alignment = [currentAlignment UTF8String]}});
+  }
+}
+
+- (void)handleKeyPressInRange:(NSString *)text range:(NSRange)range {
+  NSString *key = nil;
+
+  if (text.length == 0) {
+    key = @"Backspace";
+  } else if ([text isEqualToString:@"\n"]) {
+    key = @"Enter";
+  } else if ([text isEqualToString:@"\t"]) {
+    key = @"Tab";
+  } else if (text.length == 1) {
+    key = text;
+  }
+
+  if (key != nil) {
+    [self emitOnKeyPressEvent:key];
+  }
+}
+
+- (bool)textView:(UITextView *)textView
+    shouldChangeTextInRange:(NSRange)range
+            replacementText:(NSString *)text {
+  // Capture the attributes at range.location that are being replaced
+  // (autocorrect / predictive) so didProcessEditing: can re-stamp them onto the
+  // replacement.
+  if (range.length > 0) {
+    _capturedAttributesBeforeChange =
+        [textView.textStorage attributesAtIndex:range.location
+                                 effectiveRange:NULL];
+  }
+
+  // Check if the user pressed "Enter"
+  if ([text isEqualToString:@"\n"]) {
+    const bool shouldSubmit = [self textInputShouldSubmitOnReturn];
+    const bool shouldReturn = [self textInputShouldReturn];
+
+    if (shouldSubmit) {
+      [self emitOnSubmitEdittingEvent];
+    }
+
+    if (shouldReturn) {
+      [textView endEditing:NO];
+    }
+
+    if (shouldSubmit || shouldReturn) {
+      return NO;
+    }
+  }
+
+  [self handleKeyPressInRange:text range:range];
+
+  CheckboxListStyle *cbLStyle =
+      (CheckboxListStyle *)stylesDict[@([CheckboxListStyle getType])];
+  H1Style *h1Style = stylesDict[@([H1Style getType])];
+  H2Style *h2Style = stylesDict[@([H2Style getType])];
+  H3Style *h3Style = stylesDict[@([H3Style getType])];
+  H4Style *h4Style = stylesDict[@([H4Style getType])];
+  H5Style *h5Style = stylesDict[@([H5Style getType])];
+  H6Style *h6Style = stylesDict[@([H6Style getType])];
+
+  // some of the changes these checks do could interfere with later checks and
+  // cause a crash so here we rely on short circuiting evaluation of the logical
+  // expression. Either way it's not possible to have two of them come off at
+  // the same time
+  if (
+      // ZWS backspace handling for paragraph styles
+      [ZeroWidthSpaceUtils handleBackspaceInRange:range
+                                  replacementText:text
+                                             host:self] ||
+      [cbLStyle handleNewlinesInRange:range replacementText:text] ||
+      [h1Style handleNewlinesInRange:range replacementText:text] ||
+      [h2Style handleNewlinesInRange:range replacementText:text] ||
+      [h3Style handleNewlinesInRange:range replacementText:text] ||
+      [h4Style handleNewlinesInRange:range replacementText:text] ||
+      [h5Style handleNewlinesInRange:range replacementText:text] ||
+      [h6Style handleNewlinesInRange:range replacementText:text] ||
+      [ParagraphAttributesUtils handleBackspaceInRange:range
+                                       replacementText:text
+                                                 input:self] ||
+      [ParagraphAttributesUtils handleResetTypingAttributesOnBackspace:range
+                                                       replacementText:text
+                                                                 input:self]
+      // Check configurable text shortcuts (block: "# " → h1, inline: `code` →
+      // inline_code)
+      || [ShortcutsUtils tryHandlingParagraphShortcutsInRange:range
+                                              replacementText:text
+                                                        input:self] ||
+      [ShortcutsUtils tryHandlingInlineShortcutsInRange:range
+                                        replacementText:text
+                                                  input:self]
+      //       CRITICAL: This callback HAS TO be always evaluated last.
+      //
+      //       This function is the "Generic Fallback": if no specific style
+      //       claims the backspace action to change its state, only then do we
+      //       proceed to physically delete the newline and merge paragraphs.
+      ||
+      [ParagraphAttributesUtils handleParagraphStylesMergeOnBackspace:range
+                                                      replacementText:text
+                                                                input:self]) {
+    [self anyTextMayHaveBeenModified];
+    return NO;
+  }
+
+  return YES;
+}
+
+- (void)textViewDidChangeSelection:(UITextView *)textView {
+  // emit the event
+  NSString *textAtSelection =
+      [[[NSMutableString alloc] initWithString:textView.textStorage.string]
+          substringWithRange:textView.selectedRange];
+
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    // iOS range works differently because it specifies location and length
+    // here, start is the location, but end is the first index BEHIND the end.
+    // So a 0 length range will have equal start and end
+    emitter->onChangeSelection(
+        {.start = static_cast<int>(textView.selectedRange.location),
+         .end = static_cast<int>(textView.selectedRange.location +
+                                 textView.selectedRange.length),
+         .text = [textAtSelection toCppString]});
+  }
+
+  // manage selection changes
+  [self manageSelectionBasedChanges];
+}
+
+// this function isn't called always when some text changes (for example setting
+// link or starting mention with indicator doesn't fire it) so all the logic is
+// in anyTextMayHaveBeenModified
+- (void)textViewDidChange:(UITextView *)textView {
+  [self anyTextMayHaveBeenModified];
+}
+
+/**
+ * Handles iOS Dynamic Type changes (User changing font size in System
+ * Settings).
+ *
+ * Unlike Android, iOS Views do not automatically rescale existing
+ * NSAttributedStrings when the system font size changes. The text attributes
+ * are static once drawn.
+ *
+ * This method detects the change and performs a "Hard Refresh" of the content.
+ */
+- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection {
+  [super traitCollectionDidChange:previousTraitCollection];
+
+  if (!config.allowFontScaling) {
+    return;
+  }
+
+  if (previousTraitCollection.preferredContentSizeCategory ==
+      self.traitCollection.preferredContentSizeCategory) {
+    return;
+  }
+
+  [config invalidateFonts];
+
+  NSMutableDictionary *newTypingAttrs = [defaultTypingAttributes mutableCopy];
+  newTypingAttrs[NSFontAttributeName] = [config primaryFont];
+
+  defaultTypingAttributes = newTypingAttrs;
+  textView.typingAttributes = defaultTypingAttributes;
+
+  [self refreshPlaceholderLabelStyles];
+
+  NSRange prevSelectedRange = textView.selectedRange;
+
+  NSString *currentHtml = [HtmlParser
+      parseToHtmlFromRange:NSMakeRange(0, textView.textStorage.string.length)
+                      host:self];
+  NSString *initiallyProcessedHtml = [parser initiallyProcessHtml:currentHtml];
+  [parser replaceWholeFromHtml:initiallyProcessedHtml];
+
+  textView.selectedRange = prevSelectedRange;
+  [self anyTextMayHaveBeenModified];
+}
+
+- (void)onTextBlockTap:(TextBlockTapGestureRecognizer *)gr {
+  if (gr.state != UIGestureRecognizerStateEnded)
+    return;
+  if (![self->textView isFirstResponder]) {
+    [self->textView becomeFirstResponder];
+  }
+
+  switch (gr.tapKind) {
+
+  case TextBlockTapKindCheckbox: {
+    CheckboxListStyle *checkboxStyle =
+        (CheckboxListStyle *)stylesDict[@([CheckboxListStyle getType])];
+
+    if (checkboxStyle) {
+      NSUInteger charIndex = (NSUInteger)gr.characterIndex;
+      [checkboxStyle toggleCheckedAt:charIndex withDirtyRange:YES];
+      [self anyTextMayHaveBeenModified];
+
+      NSString *fullText = textView.textStorage.string;
+      NSRange paragraphRange =
+          [fullText paragraphRangeForRange:NSMakeRange(charIndex, 0)];
+      NSUInteger endOfLineIndex = NSMaxRange(paragraphRange);
+
+      // If the paragraph ends with a newline, step back by 1 so the cursor
+      // stays on the current line instead of jumping to the next one.
+      if (endOfLineIndex > 0 && endOfLineIndex <= fullText.length) {
+        unichar lastChar = [fullText characterAtIndex:endOfLineIndex - 1];
+        if ([[NSCharacterSet newlineCharacterSet] characterIsMember:lastChar]) {
+          endOfLineIndex--;
+        }
+      }
+
+      // Move the cursor to the end of the currently tapped checkbox line.
+      // Without this, the cursor may remain at its previous position,
+      // potentially inside a different checkbox line.
+      textView.selectedRange = NSMakeRange(endOfLineIndex, 0);
+    }
+    break;
+  }
+
+  default:
+    break;
+  }
+}
+
+- (void)textStorage:(NSTextStorage *)textStorage
+    didProcessEditing:(NSTextStorageEditActions)editedMask
+                range:(NSRange)editedRange
+       changeInLength:(NSInteger)delta {
+  // iOS replacing quick double space with ". " attributes fix.
+  [DotReplacementUtils handleDotReplacement:self
+                                textStorage:textStorage
+                                 editedMask:editedMask
+                                editedRange:editedRange
+                                      delta:delta];
+
+  // Needed dirty ranges adjustments happen on every character edition.
+  if ((editedMask & NSTextStorageEditedCharacters) != 0) {
+    // Re-stamp custom meta-attributes captured in shouldChangeTextInRange: onto
+    // the new range so autocorrect/predictive replacements keep their styling.
+    if (_capturedAttributesBeforeChange != nil) {
+      // Skip while an IME composition is in progress; restamp on commit.
+      if (textView.markedTextRange == nil) {
+        NSSet *customKeys = [attributesManager customAttributesKeys];
+        for (NSString *key in _capturedAttributesBeforeChange) {
+          if ([customKeys containsObject:key]) {
+            [textStorage addAttribute:key
+                                value:_capturedAttributesBeforeChange[key]
+                                range:editedRange];
+          }
+        }
+      }
+
+      // Clear after consuming
+      _capturedAttributesBeforeChange = nil;
+    }
+    // Always try shifting dirty ranges (happens only with delta != 0).
+    [attributesManager shiftDirtyRangesWithEditedRange:editedRange
+                                        changeInLength:delta];
+
+    // Add dirty ranges. We also add zero-length ranges because they are useful
+    // for word modification-based changes.
+    [attributesManager addDirtyRange:editedRange];
+  }
+}
+
+// MARK: - Media attachments delegate
+
+- (void)mediaAttachmentDidUpdate:(MediaAttachment *)attachment {
+  [AttachmentLayoutUtils handleAttachmentUpdate:attachment
+                                       textView:textView
+                                  onLayoutBlock:^{
+                                    [self layoutAttachments];
+                                  }];
+}
+
+// MARK: - Image/GIF Overlay Management
+
+- (void)layoutAttachments {
+  _attachmentViews =
+      [AttachmentLayoutUtils layoutAttachmentsInTextView:textView
+                                                  config:config
+                                           existingViews:_attachmentViews];
+}
+@end