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

package/ios/EnrichedTextView.mm

@@ -0,0 +1,806 @@
+#import "EnrichedTextView.h"
+#import "AttachmentLayoutUtils.h"
+#import "EnrichedTextStyleHeaders.h"
+#import "EnrichedTextTextView.h"
+#import "EnrichedTextTouchHandler.h"
+#import "LayoutManagerExtension.h"
+#import "LinkData.h"
+#import "MentionParams.h"
+#import "MentionStyleProps.h"
+#import "RCTFabricComponentsPlugins.h"
+#import "StringExtension.h"
+#import "StyleUtils.h"
+#import "TextDecorationLineEnum.h"
+#import "TextHtmlParser.h"
+#import <React/RCTConversions.h>
+#import <ReactNativeEnrichedHtml/EnrichedTextComponentDescriptor.h>
+#import <ReactNativeEnrichedHtml/EventEmitters.h>
+#import <ReactNativeEnrichedHtml/Props.h>
+#import <folly/dynamic.h>
+#import <react/utils/ManagedObjectWrapper.h>
+
+using namespace facebook::react;
+
+@interface EnrichedTextView () <NSObject>
+@end
+
+@implementation EnrichedTextView {
+  EnrichedTextViewShadowNode::ConcreteState::Shared _state;
+  NSMutableDictionary<NSValue *, UIImageView *> *_attachmentViews;
+  EnrichedTextTouchHandler *_touchHandler;
+  TextHtmlParser *_textParser;
+  NSString *_content;
+}
+
+@synthesize blockEmitting = _blockEmitting;
+
+// MARK: - Component utils
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<EnrichedTextComponentDescriptor>();
+}
+
+Class<RCTComponentViewProtocol> EnrichedTextViewCls(void) {
+  return EnrichedTextView.class;
+}
+
++ (BOOL)shouldBeRecycled {
+  return NO;
+}
+
+// MARK: - Init
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const EnrichedTextViewProps>();
+    _props = defaultProps;
+    _attachmentViews = [[NSMutableDictionary alloc] init];
+    defaultTypingAttributes = [[NSMutableDictionary alloc] init];
+    _textParser = [[TextHtmlParser alloc] initWithView:self];
+    [self setupTextView];
+    [self setupStyles];
+    self.contentView = textView;
+  }
+  return self;
+}
+
+- (void)setupTextView {
+  EnrichedTextTextView *tv = [[EnrichedTextTextView alloc] init];
+  _touchHandler = [[EnrichedTextTouchHandler alloc] initWithView:self];
+  tv.touchHandler = _touchHandler;
+  tv.host = self;
+  textView = tv;
+
+  textView.backgroundColor = UIColor.clearColor;
+  textView.textContainerInset = UIEdgeInsetsMake(0, 0, 0, 0);
+  textView.textContainer.lineFragmentPadding = 0;
+  textView.editable = NO;
+  textView.scrollEnabled = NO;
+  textView.adjustsFontForContentSizeCategory = YES;
+  textView.layoutManager.input = self;
+}
+
+- (void)setupStyles {
+  stylesDict = [StyleUtils stylesDictForHost:self isInput:NO];
+  conflictingStyles = [[StyleUtils conflictMap] mutableCopy];
+  blockingStyles = [[StyleUtils blockingMap] mutableCopy];
+}
+
+// MARK: - EnrichedViewHost protocol
+
+- (UITextView *)textView {
+  return textView;
+}
+
+- (EnrichedConfig *)config {
+  return config;
+}
+
+- (NSDictionary<NSNumber *, id> *)stylesDict {
+  return stylesDict;
+}
+
+- (NSMutableDictionary<NSNumber *, NSArray<NSNumber *> *> *)conflictingStyles {
+  return conflictingStyles;
+}
+
+- (NSMutableDictionary<NSNumber *, NSArray<NSNumber *> *> *)blockingStyles {
+  return blockingStyles;
+}
+
+- (NSMutableDictionary<NSAttributedStringKey, id> *)defaultTypingAttributes {
+  return defaultTypingAttributes;
+}
+
+// MARK: - Props
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps =
+      *std::static_pointer_cast<EnrichedTextViewProps const>(_props);
+  const auto &newViewProps =
+      *std::static_pointer_cast<EnrichedTextViewProps const>(props);
+  BOOL isFirstMount = NO;
+  BOOL stylePropChanged = NO;
+  BOOL textChanged = NO;
+
+  if (config == nullptr) {
+    isFirstMount = YES;
+    config = [[EnrichedConfig alloc] init];
+  }
+
+  EnrichedConfig *newConfig = [config copy];
+
+  // color
+  if (newViewProps.color != oldViewProps.color) {
+    if (isColorMeaningful(newViewProps.color)) {
+      UIColor *uiColor = RCTUIColorFromSharedColor(newViewProps.color);
+      [newConfig setPrimaryColor:uiColor];
+    } else {
+      [newConfig setPrimaryColor:nullptr];
+    }
+    stylePropChanged = YES;
+  }
+
+  // fontSize
+  if (newViewProps.fontSize != oldViewProps.fontSize) {
+    if (newViewProps.fontSize) {
+      NSNumber *fontSize = @(newViewProps.fontSize);
+      [newConfig setPrimaryFontSize:fontSize];
+    } else {
+      [newConfig setPrimaryFontSize:nullptr];
+    }
+    stylePropChanged = YES;
+  }
+
+  // fontWeight
+  if (newViewProps.fontWeight != oldViewProps.fontWeight) {
+    if (!newViewProps.fontWeight.empty()) {
+      [newConfig
+          setPrimaryFontWeight:[NSString
+                                   fromCppString:newViewProps.fontWeight]];
+    } else {
+      [newConfig setPrimaryFontWeight:nullptr];
+    }
+    stylePropChanged = YES;
+  }
+
+  // fontFamily
+  if (newViewProps.fontFamily != oldViewProps.fontFamily) {
+    if (!newViewProps.fontFamily.empty()) {
+      [newConfig
+          setPrimaryFontFamily:[NSString
+                                   fromCppString:newViewProps.fontFamily]];
+    } else {
+      [newConfig setPrimaryFontFamily:nullptr];
+    }
+    stylePropChanged = YES;
+  }
+
+  // fontStyle
+  if (newViewProps.fontStyle != oldViewProps.fontStyle) {
+    // TODO: Implement fontStyle setter on EnrichedConfig
+    //    stylePropChanged = YES;
+  }
+
+  // htmlStyle headings
+  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;
+  }
+
+  // blockquote
+  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;
+  }
+  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;
+  }
+
+  // inline code
+  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;
+    }
+  }
+
+  // codeblock
+  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;
+  }
+
+  // ordered list
+  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;
+  }
+  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;
+  }
+  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;
+  }
+
+  // unordered list
+  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;
+  }
+
+  // link
+  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.a.pressColor !=
+      oldViewProps.htmlStyle.a.pressColor) {
+    if (isColorMeaningful(newViewProps.htmlStyle.a.pressColor)) {
+      [newConfig setLinkPressColor:RCTUIColorFromSharedColor(
+                                       newViewProps.htmlStyle.a.pressColor)];
+      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 {
+      [newConfig setLinkDecorationLine:DecorationNone];
+    }
+    stylePropChanged = YES;
+  }
+
+  // checkbox list
+  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;
+    }
+  }
+
+  // mention
+  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()) {
+        newSingleProps = YES;
+        break;
+      } else if (obj.second.isObject()) {
+        newSingleProps = NO;
+        break;
+      }
+    }
+
+    if (newSingleProps) {
+      [newConfig setMentionStyleProps:
+                     [MentionStyleProps
+                         getSinglePropsFromFollyDynamic:newMentionStyle]];
+    } else {
+      [newConfig setMentionStyleProps:
+                     [MentionStyleProps
+                         getComplexPropsFromFollyDynamic:newMentionStyle]];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  // text prop
+  if (newViewProps.text != oldViewProps.text || isFirstMount) {
+    textChanged = YES;
+    _content = [NSString fromCppString:newViewProps.text];
+  }
+
+  // ellipsizeMode
+  if (newViewProps.ellipsizeMode != oldViewProps.ellipsizeMode ||
+      isFirstMount) {
+    NSString *mode = [NSString fromCppString:newViewProps.ellipsizeMode];
+    if ([mode isEqualToString:@"head"]) {
+      textView.textContainer.lineBreakMode = NSLineBreakByTruncatingHead;
+    } else if ([mode isEqualToString:@"middle"]) {
+      textView.textContainer.lineBreakMode = NSLineBreakByTruncatingMiddle;
+    } else if ([mode isEqualToString:@"clip"]) {
+      textView.textContainer.lineBreakMode = NSLineBreakByClipping;
+    } else {
+      textView.textContainer.lineBreakMode = NSLineBreakByTruncatingTail;
+    }
+  }
+
+  // numberOfLines
+  if (newViewProps.numberOfLines != oldViewProps.numberOfLines ||
+      isFirstMount) {
+    textView.textContainer.maximumNumberOfLines = newViewProps.numberOfLines;
+  }
+
+  // selectable
+  if (newViewProps.selectable != oldViewProps.selectable || isFirstMount) {
+    textView.selectable = newViewProps.selectable;
+  }
+
+  // selectionColor
+  if (newViewProps.selectionColor != oldViewProps.selectionColor) {
+    if (isColorMeaningful(newViewProps.selectionColor)) {
+      textView.tintColor =
+          RCTUIColorFromSharedColor(newViewProps.selectionColor);
+    }
+  }
+
+  // useHtmlNormalizer
+  if (newViewProps.useHtmlNormalizer != oldViewProps.useHtmlNormalizer) {
+    useHtmlNormalizer = newViewProps.useHtmlNormalizer;
+  }
+
+  // allowFontScaling
+  if (newViewProps.allowFontScaling != oldViewProps.allowFontScaling) {
+    [newConfig setAllowFontScaling:newViewProps.allowFontScaling];
+    stylePropChanged = YES;
+  }
+
+  if (stylePropChanged) {
+    config = newConfig;
+  }
+
+  [self syncDefaultTypingAttributesFromConfig];
+
+  if (textChanged || stylePropChanged) {
+    [self renderContent];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+  [self tryUpdatingHeight];
+}
+
+- (void)syncDefaultTypingAttributesFromConfig {
+  defaultTypingAttributes[NSForegroundColorAttributeName] =
+      [config primaryColor];
+  defaultTypingAttributes[NSFontAttributeName] = [config primaryFont];
+  defaultTypingAttributes[NSUnderlineColorAttributeName] =
+      [config primaryColor];
+  defaultTypingAttributes[NSStrikethroughColorAttributeName] =
+      [config primaryColor];
+  NSMutableParagraphStyle *pStyle = [[NSMutableParagraphStyle alloc] init];
+  pStyle.minimumLineHeight = [config scaledPrimaryLineHeight];
+  defaultTypingAttributes[NSParagraphStyleAttributeName] = pStyle;
+  textView.typingAttributes = defaultTypingAttributes;
+}
+
+// MARK: - Rendering
+
+- (void)renderContent {
+  if (_content.length == 0) {
+    [textView.textStorage
+        setAttributedString:[[NSAttributedString alloc] initWithString:@""]];
+    return;
+  }
+  [_textParser replaceWholeFromHtml:_content];
+  [self layoutAttachments];
+}
+
+// MARK: - Measuring and state
+
+- (CGSize)measureSize:(CGFloat)maxWidth {
+  if (textView.textStorage.length == 0) {
+    return CGSizeMake(maxWidth, 0);
+  }
+
+  NSMutableAttributedString *currentStr = [[NSMutableAttributedString alloc]
+      initWithAttributedString:textView.textStorage];
+
+  // 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:defaultTypingAttributes]];
+  }
+
+  // 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]];
+    }
+  }
+
+  // Use TextKit measurement so height respects:
+  // - maximumNumberOfLines / lineBreakMode
+  // - varying line heights (e.g. headings)
+  NSTextStorage *measurementStorage =
+      [[NSTextStorage alloc] initWithAttributedString:currentStr];
+  NSLayoutManager *measurementLayoutManager = [[NSLayoutManager alloc] init];
+  NSTextContainer *measurementContainer =
+      [[NSTextContainer alloc] initWithSize:CGSizeMake(maxWidth, CGFLOAT_MAX)];
+  measurementContainer.lineFragmentPadding = 0;
+  measurementContainer.maximumNumberOfLines =
+      textView.textContainer.maximumNumberOfLines;
+  measurementContainer.lineBreakMode = textView.textContainer.lineBreakMode;
+  [measurementLayoutManager addTextContainer:measurementContainer];
+  [measurementStorage addLayoutManager:measurementLayoutManager];
+  [measurementLayoutManager ensureLayoutForTextContainer:measurementContainer];
+
+  CGRect usedRect =
+      [measurementLayoutManager usedRectForTextContainer:measurementContainer];
+  CGFloat measuredHeight = ceil(usedRect.size.height);
+
+  return CGSizeMake(maxWidth, measuredHeight);
+}
+
+- (void)updateState:(State::Shared const &)state
+           oldState:(State::Shared const &)oldState {
+  _state =
+      std::static_pointer_cast<const EnrichedTextViewShadowNode::ConcreteState>(
+          state);
+
+  if (oldState == nullptr) {
+    [self tryUpdatingHeight];
+  }
+}
+
+- (void)tryUpdatingHeight {
+  if (_state == nullptr) {
+    return;
+  }
+  auto selfRef = wrapManagedObjectWeakly(self);
+  _state->updateState(EnrichedTextViewState(selfRef));
+}
+
+/**
+ * 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, so we re-parse the HTML to rebuild every run with
+ * fonts at the new content size category.
+ */
+- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection {
+  [super traitCollectionDidChange:previousTraitCollection];
+
+  if (!config.allowFontScaling) {
+    return;
+  }
+
+  if (previousTraitCollection.preferredContentSizeCategory ==
+      self.traitCollection.preferredContentSizeCategory) {
+    return;
+  }
+
+  [config invalidateFonts];
+  [self syncDefaultTypingAttributesFromConfig];
+  [self renderContent];
+  [self tryUpdatingHeight];
+}
+
+- (std::shared_ptr<EnrichedTextViewEventEmitter>)getEventEmitter {
+  if (_eventEmitter != nullptr) {
+    auto emitter =
+        static_cast<const EnrichedTextViewEventEmitter &>(*_eventEmitter);
+    return std::make_shared<EnrichedTextViewEventEmitter>(emitter);
+  }
+  return nullptr;
+}
+
+- (void)emitOnLinkPressEvent:(NSString *)url {
+  if (!url)
+    return;
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    emitter->onLinkPress({.url = [url toCppString]});
+  }
+}
+
+- (void)emitOnMentionPressEvent:(MentionParams *)mention {
+  auto emitter = [self getEventEmitter];
+  if (emitter != nullptr) {
+    folly::dynamic attrsObj = folly::dynamic::object;
+    if (mention.attributes != nil) {
+      NSData *data =
+          [mention.attributes dataUsingEncoding:NSUTF8StringEncoding];
+      NSError *error = nil;
+      NSDictionary *dict = [NSJSONSerialization JSONObjectWithData:data
+                                                           options:0
+                                                             error:&error];
+      if (error != nil) {
+        NSLog(@"[EnrichedTextView] Failed to parse mention attributes JSON: %@",
+              error);
+        return;
+      }
+
+      for (NSString *key in dict) {
+        id val = dict[key];
+        if ([val isKindOfClass:[NSString class]]) {
+          attrsObj[[key toCppString]] = [val toCppString];
+        }
+      }
+    }
+
+    emitter->onMentionPress({
+        .text = mention.text ? [mention.text toCppString] : std::string{},
+        .indicator =
+            mention.indicator ? [mention.indicator toCppString] : std::string{},
+        .attributes = attrsObj,
+    });
+  }
+}
+
+// MARK: - Media attachments delegate
+
+- (void)mediaAttachmentDidUpdate:(MediaAttachment *)attachment {
+  [AttachmentLayoutUtils handleAttachmentUpdate:attachment
+                                       textView:textView
+                                  onLayoutBlock:^{
+                                    [self layoutAttachments];
+                                    [self tryUpdatingHeight];
+                                  }];
+}
+
+- (void)layoutAttachments {
+  _attachmentViews =
+      [AttachmentLayoutUtils layoutAttachmentsInTextView:textView
+                                                  config:config
+                                           existingViews:_attachmentViews];
+}
+
+@end