react-native-enriched-markdown 0.1.1 → 0.2.0

package/ios/EnrichedMarkdownText.mm

@@ -1,17 +1,21 @@
 #import "EnrichedMarkdownText.h"
+#import "AccessibilityInfo.h"
 #import "AttributedRenderer.h"
 #import "CodeBlockBackground.h"
 #import "EditMenuUtils.h"
+#import "EnrichedMarkdownImageAttachment.h"
 #import "FontUtils.h"
-#import "ImageAttachment.h"
 #import "LastElementUtils.h"
 #import "MarkdownASTNode.h"
+#import "MarkdownAccessibilityElementBuilder.h"
 #import "MarkdownExtractor.h"
 #import "MarkdownParser.h"
+#import "ParagraphStyleUtils.h"
 #import "RenderContext.h"
 #import "RuntimeKeys.h"
 #import "StyleConfig.h"
 #import "TextViewLayoutManager.h"
+#import <React/RCTUtils.h>
 #import <objc/runtime.h>
 
 #import <ReactNativeEnrichedMarkdown/EnrichedMarkdownTextComponentDescriptor.h>
@@ -39,6 +43,7 @@ using namespace facebook::react;
   MarkdownParser *_parser;
   NSString *_cachedMarkdown;
   StyleConfig *_config;
+  Md4cFlags *_md4cFlags;
 
   // Background rendering support
   dispatch_queue_t _renderQueue;
@@ -47,6 +52,22 @@ using namespace facebook::react;
 
   EnrichedMarkdownTextShadowNode::ConcreteState::Shared _state;
   int _heightUpdateCounter;
+
+  // Font scale tracking
+  CGFloat _currentFontScale;
+  BOOL _allowFontScaling;
+  CGFloat _maxFontSizeMultiplier;
+
+  // Last element marginBottom tracking
+  CGFloat _lastElementMarginBottom;
+  BOOL _allowTrailingMargin;
+
+  // iOS link preview control
+  BOOL _enableLinkPreview;
+
+  // Accessibility data for VoiceOver
+  AccessibilityInfo *_accessibilityInfo;
+  NSMutableArray<UIAccessibilityElement *> *_accessibilityElements;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider
@@ -61,37 +82,37 @@ using namespace facebook::react;
   NSAttributedString *text = _textView.attributedText;
   CGFloat defaultHeight = [UIFont systemFontOfSize:16.0].lineHeight;
 
-  if (!text || text.length == 0) {
+  if (text.length == 0) {
     return CGSizeMake(maxWidth, defaultHeight);
   }
 
-  // Find last content character (exclude trailing newlines from measurement)
-  NSRange lastContent = [text.string rangeOfCharacterFromSet:[[NSCharacterSet newlineCharacterSet] invertedSet]
-                                                     options:NSBackwardsSearch];
-  if (lastContent.location == NSNotFound) {
-    return CGSizeMake(maxWidth, defaultHeight);
-  }
+  // Use UITextView's layout manager for measurement to avoid
+  // boundingRectWithSize: height discrepancies with NSTextAttachment objects.
+  _textView.textContainer.size = CGSizeMake(maxWidth, CGFLOAT_MAX);
+  [_textView.layoutManager ensureLayoutForTextContainer:_textView.textContainer];
+  CGRect usedRect = [_textView.layoutManager usedRectForTextContainer:_textView.textContainer];
 
-  NSAttributedString *contentToMeasure = [text attributedSubstringFromRange:NSMakeRange(0, NSMaxRange(lastContent))];
+  CGFloat measuredWidth = ceil(usedRect.size.width);
+  CGFloat measuredHeight = usedRect.size.height;
 
-  // Use NSStringDrawingUsesDeviceMetrics for tighter bounds (especially for images)
-  NSStringDrawingOptions options = NSStringDrawingUsesLineFragmentOrigin | NSStringDrawingUsesFontLeading;
-  if (isLastElementImage(text)) {
-    options |= NSStringDrawingUsesDeviceMetrics;
+  // When text ends with \n (e.g. code block's bottom padding spacer),
+  // TextKit creates an "extra line fragment" after it that adds unwanted height.
+  CGRect extraFragment = _textView.layoutManager.extraLineFragmentRect;
+  if (!CGRectIsEmpty(extraFragment)) {
+    measuredHeight -= extraFragment.size.height;
   }
 
-  CGRect boundingRect = [contentToMeasure boundingRectWithSize:CGSizeMake(maxWidth, CGFLOAT_MAX)
-                                                       options:options
-                                                       context:nil];
-
-  CGFloat measuredHeight = boundingRect.size.height;
-
-  // Compensate for iOS not measuring trailing newlines (code block bottom padding)
+  // Code block's bottom padding is a spacer \n with minimumLineHeight = codeBlockPadding.
+  // The layout manager may not size it accurately, so add the padding explicitly.
   if (isLastElementCodeBlock(text)) {
     measuredHeight += [_config codeBlockPadding];
   }
 
-  return CGSizeMake(maxWidth, ceil(measuredHeight));
+  if (_allowTrailingMargin && _lastElementMarginBottom > 0) {
+    measuredHeight += _lastElementMarginBottom;
+  }
+
+  return CGSizeMake(measuredWidth, ceil(measuredHeight));
 }
 
 - (void)updateState:(const facebook::react::State::Shared &)state
@@ -124,17 +145,61 @@ using namespace facebook::react;
 
     self.backgroundColor = [UIColor clearColor];
     _parser = [[MarkdownParser alloc] init];
+    _md4cFlags = [Md4cFlags defaultFlags];
 
     // Serial queue for background rendering
     _renderQueue = dispatch_queue_create("com.swmansion.enriched.markdown.render", DISPATCH_QUEUE_SERIAL);
     _currentRenderId = 0;
 
+    // Initialize font scale from current content size category
+    _allowFontScaling = YES;
+    _maxFontSizeMultiplier = 0;
+    _allowTrailingMargin = NO;
+    _currentFontScale = RCTFontSizeMultiplier();
+    _enableLinkPreview = YES;
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(contentSizeCategoryDidChange:)
+                                                 name:UIContentSizeCategoryDidChangeNotification
+                                               object:nil];
+
     [self setupTextView];
   }
 
   return self;
 }
 
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self name:UIContentSizeCategoryDidChangeNotification object:nil];
+}
+
+- (CGFloat)effectiveFontScale
+{
+  // If font scaling is disabled, always return 1.0 (no scaling)
+  return _allowFontScaling ? _currentFontScale : 1.0;
+}
+
+- (void)contentSizeCategoryDidChange:(NSNotification *)notification
+{
+  if (!_allowFontScaling) {
+    return;
+  }
+
+  CGFloat newFontScale = RCTFontSizeMultiplier();
+  if (_currentFontScale != newFontScale) {
+    _currentFontScale = newFontScale;
+
+    if (_config != nil) {
+      [_config setFontScaleMultiplier:[self effectiveFontScale]];
+    }
+
+    if (_cachedMarkdown != nil && _cachedMarkdown.length > 0) {
+      [self renderMarkdownContent:_cachedMarkdown];
+    }
+  }
+}
+
 - (void)setupTextView
 {
   _textView = [[UITextView alloc] init];
@@ -145,15 +210,19 @@ using namespace facebook::react;
   _textView.editable = NO;
   _textView.delegate = self;
   _textView.scrollEnabled = NO;
+  _textView.showsVerticalScrollIndicator = NO;
+  _textView.showsHorizontalScrollIndicator = NO;
   _textView.textContainerInset = UIEdgeInsetsZero;
   _textView.textContainer.lineFragmentPadding = 0;
   // Disable UITextView's default link styling - we handle it directly in attributed strings
   _textView.linkTextAttributes = @{};
-  // isSelectable controls text selection and link previews
+  // selectable controls text selection and link previews
   // Default to YES to match the prop default
   _textView.selectable = YES;
   // Hide initially to prevent flash before content is rendered
   _textView.hidden = YES;
+  // Disable textView's built-in accessibility - we provide custom elements with proper traits
+  _textView.accessibilityElementsHidden = YES;
 
   // Add tap gesture recognizer
   UITapGestureRecognizer *tapRecognizer = [[UITapGestureRecognizer alloc] initWithTarget:self
@@ -218,14 +287,19 @@ using namespace facebook::react;
   // Capture state needed for background rendering
   StyleConfig *config = [_config copy];
   MarkdownParser *parser = _parser;
+  Md4cFlags *md4cFlags = [_md4cFlags copy];
   NSUInteger inputLength = markdownString.length;
   NSDate *scheduleStart = [NSDate date];
 
+  // Capture font scaling settings
+  BOOL allowFontScaling = _allowFontScaling;
+  CGFloat maxFontSizeMultiplier = _maxFontSizeMultiplier;
+
   // Dispatch heavy work to background queue
   dispatch_async(_renderQueue, ^{
     // 1. Parse Markdown → AST (C++ md4c parser)
     NSDate *parseStart = [NSDate date];
-    MarkdownASTNode *ast = [parser parseMarkdown:markdownString];
+    MarkdownASTNode *ast = [parser parseMarkdown:markdownString flags:md4cFlags];
     if (!ast) {
       return;
     }
@@ -235,9 +309,14 @@ using namespace facebook::react;
     // 2. Render AST → NSAttributedString
     NSDate *renderStart = [NSDate date];
     AttributedRenderer *renderer = [[AttributedRenderer alloc] initWithConfig:config];
+    [renderer setAllowTrailingMargin:self->_allowTrailingMargin];
     RenderContext *context = [RenderContext new];
+    context.allowFontScaling = allowFontScaling;
+    context.maxFontSizeMultiplier = maxFontSizeMultiplier;
     NSMutableAttributedString *attributedText = [renderer renderRoot:ast context:context];
 
+    self->_lastElementMarginBottom = [renderer getLastElementMarginBottom];
+
     // Add link attributes
     for (NSUInteger i = 0; i < context.linkRanges.count; i++) {
       NSValue *rangeValue = context.linkRanges[i];
@@ -245,6 +324,10 @@ using namespace facebook::react;
       NSString *url = context.linkURLs[i];
       [attributedText addAttribute:@"linkURL" value:url range:range];
     }
+
+    // Capture accessibility info
+    AccessibilityInfo *accessibilityInfo = [AccessibilityInfo infoFromContext:context];
+
     NSTimeInterval renderTime = [[NSDate date] timeIntervalSinceDate:renderStart] * 1000;
     NSUInteger styledLength = attributedText.length;
 
@@ -255,6 +338,9 @@ using namespace facebook::react;
         return;
       }
 
+      // Store accessibility info
+      self->_accessibilityInfo = accessibilityInfo;
+
       [self applyRenderedText:attributedText];
 
       NSTimeInterval totalTime = [[NSDate date] timeIntervalSinceDate:scheduleStart] * 1000;
@@ -279,15 +365,20 @@ using namespace facebook::react;
   _blockAsyncRender = YES;
   _cachedMarkdown = [markdownString copy];
 
-  MarkdownASTNode *ast = [_parser parseMarkdown:markdownString];
+  MarkdownASTNode *ast = [_parser parseMarkdown:markdownString flags:_md4cFlags];
   if (!ast) {
     return;
   }
 
   AttributedRenderer *renderer = [[AttributedRenderer alloc] initWithConfig:_config];
+  [renderer setAllowTrailingMargin:_allowTrailingMargin];
   RenderContext *context = [RenderContext new];
+  context.allowFontScaling = _allowFontScaling;
+  context.maxFontSizeMultiplier = _maxFontSizeMultiplier;
   NSMutableAttributedString *attributedText = [renderer renderRoot:ast context:context];
 
+  _lastElementMarginBottom = [renderer getLastElementMarginBottom];
+
   for (NSUInteger i = 0; i < context.linkRanges.count; i++) {
     NSValue *rangeValue = context.linkRanges[i];
     NSRange range = [rangeValue rangeValue];
@@ -295,6 +386,9 @@ using namespace facebook::react;
     [attributedText addAttribute:@"linkURL" value:url range:range];
   }
 
+  // Store accessibility info
+  _accessibilityInfo = [AccessibilityInfo infoFromContext:context];
+
   _textView.attributedText = attributedText;
 }
 
@@ -323,6 +417,9 @@ using namespace facebook::react;
   // Request height recalculation from shadow node FIRST
   [self requestHeightUpdate];
 
+  // Build accessibility elements after layout is complete
+  [self buildAccessibilityElements];
+
   // Show text view on next run loop, after layout has settled
   if (_textView.hidden) {
     dispatch_async(dispatch_get_main_queue(), ^{ self->_textView.hidden = NO; });
@@ -338,6 +435,7 @@ using namespace facebook::react;
 
   if (_config == nil) {
     _config = [[StyleConfig alloc] init];
+    [_config setFontScaleMultiplier:[self effectiveFontScale]];
   }
 
   // Paragraph style
@@ -378,6 +476,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.paragraph.marginTop != oldViewProps.markdownStyle.paragraph.marginTop) {
+    [_config setParagraphMarginTop:newViewProps.markdownStyle.paragraph.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.paragraph.marginBottom != oldViewProps.markdownStyle.paragraph.marginBottom) {
     [_config setParagraphMarginBottom:newViewProps.markdownStyle.paragraph.marginBottom];
     stylePropChanged = YES;
@@ -388,6 +491,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.paragraph.textAlign != oldViewProps.markdownStyle.paragraph.textAlign) {
+    [_config setParagraphTextAlign:textAlignmentFromString(@(newViewProps.markdownStyle.paragraph.textAlign.c_str()))];
+    stylePropChanged = YES;
+  }
+
   // H1 style
   if (newViewProps.markdownStyle.h1.fontSize != oldViewProps.markdownStyle.h1.fontSize) {
     [_config setH1FontSize:newViewProps.markdownStyle.h1.fontSize];
@@ -424,6 +532,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h1.marginTop != oldViewProps.markdownStyle.h1.marginTop) {
+    [_config setH1MarginTop:newViewProps.markdownStyle.h1.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.h1.marginBottom != oldViewProps.markdownStyle.h1.marginBottom) {
     [_config setH1MarginBottom:newViewProps.markdownStyle.h1.marginBottom];
     stylePropChanged = YES;
@@ -434,6 +547,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h1.textAlign != oldViewProps.markdownStyle.h1.textAlign) {
+    [_config setH1TextAlign:textAlignmentFromString(@(newViewProps.markdownStyle.h1.textAlign.c_str()))];
+    stylePropChanged = YES;
+  }
+
   // H2 style
   if (newViewProps.markdownStyle.h2.fontSize != oldViewProps.markdownStyle.h2.fontSize) {
     [_config setH2FontSize:newViewProps.markdownStyle.h2.fontSize];
@@ -470,6 +588,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h2.marginTop != oldViewProps.markdownStyle.h2.marginTop) {
+    [_config setH2MarginTop:newViewProps.markdownStyle.h2.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.h2.marginBottom != oldViewProps.markdownStyle.h2.marginBottom) {
     [_config setH2MarginBottom:newViewProps.markdownStyle.h2.marginBottom];
     stylePropChanged = YES;
@@ -480,6 +603,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h2.textAlign != oldViewProps.markdownStyle.h2.textAlign) {
+    [_config setH2TextAlign:textAlignmentFromString(@(newViewProps.markdownStyle.h2.textAlign.c_str()))];
+    stylePropChanged = YES;
+  }
+
   // H3 style
   if (newViewProps.markdownStyle.h3.fontSize != oldViewProps.markdownStyle.h3.fontSize) {
     [_config setH3FontSize:newViewProps.markdownStyle.h3.fontSize];
@@ -516,6 +644,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h3.marginTop != oldViewProps.markdownStyle.h3.marginTop) {
+    [_config setH3MarginTop:newViewProps.markdownStyle.h3.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.h3.marginBottom != oldViewProps.markdownStyle.h3.marginBottom) {
     [_config setH3MarginBottom:newViewProps.markdownStyle.h3.marginBottom];
     stylePropChanged = YES;
@@ -526,6 +659,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h3.textAlign != oldViewProps.markdownStyle.h3.textAlign) {
+    [_config setH3TextAlign:textAlignmentFromString(@(newViewProps.markdownStyle.h3.textAlign.c_str()))];
+    stylePropChanged = YES;
+  }
+
   // H4 style
   if (newViewProps.markdownStyle.h4.fontSize != oldViewProps.markdownStyle.h4.fontSize) {
     [_config setH4FontSize:newViewProps.markdownStyle.h4.fontSize];
@@ -562,6 +700,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h4.marginTop != oldViewProps.markdownStyle.h4.marginTop) {
+    [_config setH4MarginTop:newViewProps.markdownStyle.h4.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.h4.marginBottom != oldViewProps.markdownStyle.h4.marginBottom) {
     [_config setH4MarginBottom:newViewProps.markdownStyle.h4.marginBottom];
     stylePropChanged = YES;
@@ -572,6 +715,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h4.textAlign != oldViewProps.markdownStyle.h4.textAlign) {
+    [_config setH4TextAlign:textAlignmentFromString(@(newViewProps.markdownStyle.h4.textAlign.c_str()))];
+    stylePropChanged = YES;
+  }
+
   // H5 style
   if (newViewProps.markdownStyle.h5.fontSize != oldViewProps.markdownStyle.h5.fontSize) {
     [_config setH5FontSize:newViewProps.markdownStyle.h5.fontSize];
@@ -608,6 +756,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h5.marginTop != oldViewProps.markdownStyle.h5.marginTop) {
+    [_config setH5MarginTop:newViewProps.markdownStyle.h5.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.h5.marginBottom != oldViewProps.markdownStyle.h5.marginBottom) {
     [_config setH5MarginBottom:newViewProps.markdownStyle.h5.marginBottom];
     stylePropChanged = YES;
@@ -618,6 +771,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h5.textAlign != oldViewProps.markdownStyle.h5.textAlign) {
+    [_config setH5TextAlign:textAlignmentFromString(@(newViewProps.markdownStyle.h5.textAlign.c_str()))];
+    stylePropChanged = YES;
+  }
+
   // H6 style
   if (newViewProps.markdownStyle.h6.fontSize != oldViewProps.markdownStyle.h6.fontSize) {
     [_config setH6FontSize:newViewProps.markdownStyle.h6.fontSize];
@@ -654,6 +812,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h6.marginTop != oldViewProps.markdownStyle.h6.marginTop) {
+    [_config setH6MarginTop:newViewProps.markdownStyle.h6.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.h6.marginBottom != oldViewProps.markdownStyle.h6.marginBottom) {
     [_config setH6MarginBottom:newViewProps.markdownStyle.h6.marginBottom];
     stylePropChanged = YES;
@@ -664,6 +827,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.h6.textAlign != oldViewProps.markdownStyle.h6.textAlign) {
+    [_config setH6TextAlign:textAlignmentFromString(@(newViewProps.markdownStyle.h6.textAlign.c_str()))];
+    stylePropChanged = YES;
+  }
+
   // Blockquote style
   if (newViewProps.markdownStyle.blockquote.fontSize != oldViewProps.markdownStyle.blockquote.fontSize) {
     [_config setBlockquoteFontSize:newViewProps.markdownStyle.blockquote.fontSize];
@@ -690,6 +858,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.blockquote.marginTop != oldViewProps.markdownStyle.blockquote.marginTop) {
+    [_config setBlockquoteMarginTop:newViewProps.markdownStyle.blockquote.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.blockquote.marginBottom != oldViewProps.markdownStyle.blockquote.marginBottom) {
     [_config setBlockquoteMarginBottom:newViewProps.markdownStyle.blockquote.marginBottom];
     stylePropChanged = YES;
@@ -754,6 +927,18 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.strikethrough.color != oldViewProps.markdownStyle.strikethrough.color) {
+    UIColor *strikethroughColor = RCTUIColorFromSharedColor(newViewProps.markdownStyle.strikethrough.color);
+    [_config setStrikethroughColor:strikethroughColor];
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.markdownStyle.underline.color != oldViewProps.markdownStyle.underline.color) {
+    UIColor *underlineColor = RCTUIColorFromSharedColor(newViewProps.markdownStyle.underline.color);
+    [_config setUnderlineColor:underlineColor];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.code.color != oldViewProps.markdownStyle.code.color) {
     if (newViewProps.markdownStyle.code.color) {
       UIColor *codeColor = RCTUIColorFromSharedColor(newViewProps.markdownStyle.code.color);
@@ -794,6 +979,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.image.marginTop != oldViewProps.markdownStyle.image.marginTop) {
+    [_config setImageMarginTop:newViewProps.markdownStyle.image.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.image.marginBottom != oldViewProps.markdownStyle.image.marginBottom) {
     [_config setImageMarginBottom:newViewProps.markdownStyle.image.marginBottom];
     stylePropChanged = YES;
@@ -828,6 +1018,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.list.marginTop != oldViewProps.markdownStyle.list.marginTop) {
+    [_config setListStyleMarginTop:newViewProps.markdownStyle.list.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.list.marginBottom != oldViewProps.markdownStyle.list.marginBottom) {
     [_config setListStyleMarginBottom:newViewProps.markdownStyle.list.marginBottom];
     stylePropChanged = YES;
@@ -898,6 +1093,11 @@ using namespace facebook::react;
     stylePropChanged = YES;
   }
 
+  if (newViewProps.markdownStyle.codeBlock.marginTop != oldViewProps.markdownStyle.codeBlock.marginTop) {
+    [_config setCodeBlockMarginTop:newViewProps.markdownStyle.codeBlock.marginTop];
+    stylePropChanged = YES;
+  }
+
   if (newViewProps.markdownStyle.codeBlock.marginBottom != oldViewProps.markdownStyle.codeBlock.marginBottom) {
     [_config setCodeBlockMarginBottom:newViewProps.markdownStyle.codeBlock.marginBottom];
     stylePropChanged = YES;
@@ -967,16 +1167,51 @@ using namespace facebook::react;
     }
   }
 
-  // Control text selection and link previews via isSelectable property
-  // According to Apple docs, isSelectable controls whether text selection and link previews work
+  // Control text selection and link previews via selectable property
+  // According to Apple docs, selectable controls whether text selection and link previews work
   // https://developer.apple.com/documentation/uikit/uitextview/isselectable
-  if (_textView.selectable != newViewProps.isSelectable) {
-    _textView.selectable = newViewProps.isSelectable;
+  if (_textView.selectable != newViewProps.selectable) {
+    _textView.selectable = newViewProps.selectable;
+  }
+
+  if (newViewProps.allowFontScaling != oldViewProps.allowFontScaling) {
+    _allowFontScaling = newViewProps.allowFontScaling;
+
+    if (_config != nil) {
+      [_config setFontScaleMultiplier:[self effectiveFontScale]];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  if (newViewProps.maxFontSizeMultiplier != oldViewProps.maxFontSizeMultiplier) {
+    _maxFontSizeMultiplier = newViewProps.maxFontSizeMultiplier;
+
+    if (_config != nil) {
+      [_config setMaxFontSizeMultiplier:_maxFontSizeMultiplier];
+    }
+
+    stylePropChanged = YES;
+  }
+
+  // Update allowTrailingMargin
+  if (newViewProps.allowTrailingMargin != oldViewProps.allowTrailingMargin) {
+    _allowTrailingMargin = newViewProps.allowTrailingMargin;
+  }
+
+  // Update md4cFlags
+  BOOL md4cFlagsChanged = NO;
+  if (newViewProps.md4cFlags.underline != oldViewProps.md4cFlags.underline) {
+    _md4cFlags.underline = newViewProps.md4cFlags.underline;
+    md4cFlagsChanged = YES;
   }
 
   BOOL markdownChanged = oldViewProps.markdown != newViewProps.markdown;
+  BOOL allowTrailingMarginChanged = newViewProps.allowTrailingMargin != oldViewProps.allowTrailingMargin;
 
-  if (markdownChanged || stylePropChanged) {
+  _enableLinkPreview = newViewProps.enableLinkPreview;
+
+  if (markdownChanged || stylePropChanged || md4cFlagsChanged || allowTrailingMarginChanged) {
     NSString *markdownString = [[NSString alloc] initWithUTF8String:newViewProps.markdown.c_str()];
     [self renderMarkdownContent:markdownString];
   }
@@ -1061,6 +1296,36 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownTextCls(void)
   }
 }
 
+#pragma mark - UITextViewDelegate (Link Interaction)
+
+- (BOOL)textView:(UITextView *)textView
+    shouldInteractWithURL:(NSURL *)URL
+                  inRange:(NSRange)characterRange
+              interaction:(UITextItemInteraction)interaction
+{
+  // Only intercept long-press interactions
+  if (interaction != UITextItemInteractionPresentActions) {
+    return YES;
+  }
+
+  // Safely extract the custom URL attribute
+  NSString *urlString = [textView.attributedText attribute:@"linkURL"
+                                                   atIndex:characterRange.location
+                                            effectiveRange:NULL];
+
+  // If link preview is enabled or no URL found, allow default system behavior
+  if (!urlString || _enableLinkPreview) {
+    return YES;
+  }
+
+  // System preview disabled — emit onLinkLongPress event to React Native
+  auto eventEmitter = std::static_pointer_cast<EnrichedMarkdownTextEventEmitter const>(_eventEmitter);
+  if (eventEmitter) {
+    eventEmitter->onLinkLongPress({.url = std::string([urlString UTF8String])});
+  }
+  return NO;
+}
+
 #pragma mark - UITextViewDelegate (Edit Menu)
 
 // Customizes the edit menu
@@ -1071,4 +1336,66 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownTextCls(void)
   return buildEditMenuForSelection(_textView.attributedText, range, _cachedMarkdown, _config, suggestedActions);
 }
 
+#pragma mark - Accessibility (VoiceOver Navigation)
+
+- (void)buildAccessibilityElements
+{
+  _accessibilityElements = [MarkdownAccessibilityElementBuilder buildElementsForTextView:_textView
+                                                                                    info:_accessibilityInfo
+                                                                               container:self];
+}
+
+- (BOOL)isAccessibilityElement
+{
+  return NO; // This is a container, not a single element
+}
+
+- (NSInteger)accessibilityElementCount
+{
+  return _accessibilityElements.count;
+}
+
+- (id)accessibilityElementAtIndex:(NSInteger)index
+{
+  if (index < 0 || index >= (NSInteger)_accessibilityElements.count) {
+    return nil;
+  }
+  return _accessibilityElements[index];
+}
+
+- (NSInteger)indexOfAccessibilityElement:(id)element
+{
+  return [_accessibilityElements indexOfObject:element];
+}
+
+- (NSArray *)accessibilityElements
+{
+  return _accessibilityElements;
+}
+
+- (NSArray<UIAccessibilityCustomRotor *> *)accessibilityCustomRotors
+{
+  NSMutableArray<UIAccessibilityCustomRotor *> *rotors = [NSMutableArray array];
+
+  NSArray<UIAccessibilityElement *> *headingElements =
+      [MarkdownAccessibilityElementBuilder filterHeadingElements:_accessibilityElements];
+  if (headingElements.count > 0) {
+    [rotors addObject:[MarkdownAccessibilityElementBuilder createHeadingRotorWithElements:headingElements]];
+  }
+
+  NSArray<UIAccessibilityElement *> *linkElements =
+      [MarkdownAccessibilityElementBuilder filterLinkElements:_accessibilityElements];
+  if (linkElements.count > 0) {
+    [rotors addObject:[MarkdownAccessibilityElementBuilder createLinkRotorWithElements:linkElements]];
+  }
+
+  NSArray<UIAccessibilityElement *> *imageElements =
+      [MarkdownAccessibilityElementBuilder filterImageElements:_accessibilityElements];
+  if (imageElements.count > 0) {
+    [rotors addObject:[MarkdownAccessibilityElementBuilder createImageRotorWithElements:imageElements]];
+  }
+
+  return rotors;
+}
+
 @end

package/ios/attachments/{ImageAttachment.h → EnrichedMarkdownImageAttachment.h}

@@ -11,7 +11,7 @@ NS_ASSUME_NONNULL_BEGIN
  * Images are loaded asynchronously and scaled dynamically based on text container width.
  * Supports inline and block images with custom height and border radius from config.
  */
-@interface ImageAttachment : NSTextAttachment
+@interface EnrichedMarkdownImageAttachment : NSTextAttachment
 
 @property (nonatomic, readonly) NSString *imageURL;
 @property (nonatomic, readonly) BOOL isInline;