react-native-enriched-markdown-scaffold 0.7.4-scaffold.8 → 1.0.2-scaffold.1

package/ios/EnrichedMarkdownText.mm

@@ -3,6 +3,7 @@
 #import "ContextMenuUtils.h"
 #import "ENRMAccessibilityLabels.h"
 #import "ENRMAsyncRenderCoordinator.h"
+#import "ENRMAtomicSize.h"
 #import "ENRMContextMenuTextView+macOS.h"
 #import "ENRMImageAttachment.h"
 #import "ENRMMarkdownParser.h"
@@ -17,6 +18,7 @@
 #import "FontScaleObserver.h"
 #import "FontUtils.h"
 #import "HeightUpdateUtils.h"
+#import "ImageRequestHeaderUtils.h"
 #import "LinkTapUtils.h"
 #import "MarkdownASTNode.h"
 #import "MarkdownAccessibilityElementBuilder.h"
@@ -45,8 +47,8 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
   ENRMDirtyRender = 1 << 0,
 };
 
-@interface EnrichedMarkdownText () <RCTEnrichedMarkdownTextViewProtocol, UITextViewDelegate>
-- (void)resetPropDerivedState;
+@interface EnrichedMarkdownText () <RCTEnrichedMarkdownTextViewProtocol, UITextViewDelegate, ENRMImageLayoutObserver>
++ (ENRMMd4cFlags *)flagsFromProps:(const EnrichedMarkdownTextMd4cFlagsStruct &)props;
 - (void)setupTextView;
 - (void)renderMarkdownContent:(NSString *)markdownString;
 - (void)applyRenderedText:(NSMutableAttributedString *)attributedText;
@@ -80,6 +82,8 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
   CGFloat _lastElementMarginBottom;
   BOOL _allowTrailingMargin;
   BOOL _enableLinkPreview;
+  BOOL _enableTaskListItemToggle;
+  BOOL _contextMenuHidden;
   BOOL _streamingAnimation;
   BOOL _forceHeightUpdateOnNextRender;
 
@@ -111,6 +115,8 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
   NSWritingDirection _resolvedLayoutDirection;
 
   ENRMDirtyFlags _dirtyFlags;
+
+  ENRMAtomicSize _lastCommittedSize;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider
@@ -118,6 +124,18 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
   return concreteComponentDescriptorProvider<EnrichedMarkdownTextComponentDescriptor>();
 }
 
++ (ENRMMd4cFlags *)flagsFromProps:(const EnrichedMarkdownTextMd4cFlagsStruct &)props
+{
+  ENRMMd4cFlags *flags = [ENRMMd4cFlags defaultFlags];
+  flags.underline = props.underline;
+  flags.superscript = props.superscript;
+  flags.subscript = props.subscript;
+  flags.latexMath = props.latexMath;
+  flags.highlight = props.highlight;
+  flags.hardSoftBreaks = props.hardSoftBreaks;
+  return flags;
+}
+
 #pragma mark - Measuring and State
 
 - (CGSize)measureSize:(CGFloat)maxWidth
@@ -130,6 +148,11 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
   return size;
 }
 
+- (CGSize)lastCommittedLayoutSize
+{
+  return _lastCommittedSize.load();
+}
+
 - (BOOL)hasRenderedMarkdown:(NSString *)markdown
 {
   return _renderedMarkdown != nil && [_renderedMarkdown isEqualToString:markdown];
@@ -158,6 +181,8 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
 {
   [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
 
+  _lastCommittedSize.store(CGSizeMake(layoutMetrics.frame.size.width, layoutMetrics.frame.size.height));
+
   NSWritingDirection resolved = _resolvedLayoutDirection;
   if (layoutMetrics.layoutDirection == LayoutDirection::RightToLeft) {
     resolved = NSWritingDirectionRightToLeft;
@@ -178,44 +203,21 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
   ENRMRequestHeightUpdate<EnrichedMarkdownTextState>(_state, _heightUpdateCounter, self);
 }
 
-/// Clears every piece of state that `updateProps` derives from props, back to the
-/// values the default-constructed `EnrichedMarkdownTextProps` describes.
-///
-/// `updateProps` applies most props as a per-field diff against `_props`, so this
-/// state is only correct while it stays in phase with the `_props` baseline it was
-/// diffed from. `prepareForRecycle` resets `_props`, so it must reset this too —
-/// otherwise every field the next consumer leaves at its default silently inherits
-/// the previous consumer's value. Called from `initWithFrame:` as well, so the two
-/// baselines cannot drift apart.
-///
-/// Requires `_fontScaleObserver` to already exist.
-- (void)resetPropDerivedState
-{
-  // Discarded rather than cleared field-by-field: the style diff can only clear a
-  // field when new and old differ, which never holds against a reset baseline.
-  _config = nil;
-  _spoilerManager = nil;
-
-  _md4cFlags = [ENRMMd4cFlags propsDefaultFlags];
-  _maxFontSizeMultiplier = 0;
-  _allowTrailingMargin = NO;
-  _fontScaleObserver.allowFontScaling = YES;
-  _streamingAnimation = NO;
-  _lineBreakStrategy = NSLineBreakStrategyNone;
-  _writingDirectionMode = ENRMWritingDirectionModeFirstStrong;
-  _contextMenuItemTexts = nil;
-  _contextMenuItemIcons = nil;
-  _accessibilityLabels = nil;
-
-  // Written only once a render completes, so stale until the next one lands.
-  _renderedStyleFingerprint = 0;
-  _pendingStyleFingerprint = 0;
-  _lastElementMarginBottom = 0;
+// A block image resolved its box height after loading (maxHeight/aspectRatio
+// sizing). The shadow node measured — and cached — this markdown with the
+// pre-load fallback height, so drop those entries and re-measure.
+- (void)imageAttachmentDidResolveLayout
+{
+  if (_renderedMarkdown.length > 0) {
+    facebook::react::MeasurementCache::shared().removeMatchingMarkdown(std::string(_renderedMarkdown.UTF8String));
+  }
 
-  _dirtyFlags = ENRMDirtyNone;
-  _forceHeightUpdateOnNextRender = NO;
-  _heightUpdateCounter = 0;
-  _state = nullptr;
+  if (self.bounds.size.width > 0) {
+    CGSize measured = [self measureSize:self.bounds.size.width];
+    if (needsHeightUpdate(measured, self.bounds)) {
+      [self requestHeightUpdate];
+    }
+  }
 }
 
 - (instancetype)initWithFrame:(CGRect)frame
@@ -226,18 +228,25 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
 
     self.backgroundColor = [RCTUIColor clearColor];
     _parser = [[ENRMMarkdownParser alloc] init];
+    _md4cFlags = [EnrichedMarkdownText flagsFromProps:defaultProps->md4cFlags];
 
     _renderCoordinator =
         [[ENRMAsyncRenderCoordinator alloc] initWithQueueLabel:"com.swmansion.enriched.markdown.render"];
 
+    _maxFontSizeMultiplier = 0;
+    _allowTrailingMargin = NO;
     _enableLinkPreview = YES;
+    _enableTaskListItemToggle = YES;
+    _forceHeightUpdateOnNextRender = NO;
+    _contextMenuHidden = NO;
     _selectionMenuConfig = (ENRMSelectionMenuConfig){.copyAsMarkdown = YES, .copyImageURL = YES};
+    _lineBreakStrategy = NSLineBreakStrategyNone;
+    _writingDirectionMode = ENRMWritingDirectionModeFirstStrong;
     _resolvedLayoutDirection =
         [[RCTI18nUtil sharedInstance] isRTL] ? NSWritingDirectionRightToLeft : NSWritingDirectionLeftToRight;
+    _dirtyFlags = ENRMDirtyNone;
 
     _fontScaleObserver = [[FontScaleObserver alloc] init];
-    [self resetPropDerivedState];
-
     __weak EnrichedMarkdownText *weakSelf = self;
     _fontScaleObserver.onChange = ^{
       EnrichedMarkdownText *strongSelf = weakSelf;
@@ -280,6 +289,9 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
     if (!strongSelf) {
       return baseMenu;
     }
+    if (strongSelf->_contextMenuHidden) {
+      return nil;
+    }
     NSArray<NSMenuItem *> *customItems = ENRMBuildContextMenuItems(
         strongSelf->_contextMenuItemTexts, strongSelf->_contextMenuItemIcons, textView,
         ^(NSString *itemText, NSString *selectedText, NSUInteger selectionStart, NSUInteger selectionEnd) {
@@ -495,6 +507,11 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
     _dirtyFlags |= ENRMDirtyRender;
   }
 
+  if (ENRMImageRequestHeadersChanged(oldViewProps.imageRequestHeaders, newViewProps.imageRequestHeaders)) {
+    [_config setImageRequestHeaders:ENRMImageRequestHeadersFromProps(newViewProps.imageRequestHeaders)];
+    _dirtyFlags |= ENRMDirtyRender;
+  }
+
   NSLayoutManager *layoutManager = _textView.layoutManager;
   if ([layoutManager isKindOfClass:[TextViewLayoutManager class]]) {
     StyleConfig *currentConfig = [layoutManager valueForKey:@"config"];
@@ -539,33 +556,20 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
     _dirtyFlags |= ENRMDirtyRender;
   }
 
-  if (newViewProps.md4cFlags.underline != oldViewProps.md4cFlags.underline) {
-    _md4cFlags.underline = newViewProps.md4cFlags.underline;
-    _forceHeightUpdateOnNextRender = YES;
-    _dirtyFlags |= ENRMDirtyRender;
-  }
-  if (newViewProps.md4cFlags.superscript != oldViewProps.md4cFlags.superscript) {
-    _md4cFlags.superscript = newViewProps.md4cFlags.superscript;
-    _forceHeightUpdateOnNextRender = YES;
-    _dirtyFlags |= ENRMDirtyRender;
-  }
-  if (newViewProps.md4cFlags.subscript != oldViewProps.md4cFlags.subscript) {
-    _md4cFlags.subscript = newViewProps.md4cFlags.subscript;
-    _forceHeightUpdateOnNextRender = YES;
-    _dirtyFlags |= ENRMDirtyRender;
-  }
-  if (newViewProps.md4cFlags.latexMath != oldViewProps.md4cFlags.latexMath) {
-    _md4cFlags.latexMath = newViewProps.md4cFlags.latexMath;
-    _forceHeightUpdateOnNextRender = YES;
-    _dirtyFlags |= ENRMDirtyRender;
-  }
-  if (newViewProps.md4cFlags.highlight != oldViewProps.md4cFlags.highlight) {
-    _md4cFlags.highlight = newViewProps.md4cFlags.highlight;
+  if (newViewProps.md4cFlags.underline != oldViewProps.md4cFlags.underline ||
+      newViewProps.md4cFlags.superscript != oldViewProps.md4cFlags.superscript ||
+      newViewProps.md4cFlags.subscript != oldViewProps.md4cFlags.subscript ||
+      newViewProps.md4cFlags.latexMath != oldViewProps.md4cFlags.latexMath ||
+      newViewProps.md4cFlags.highlight != oldViewProps.md4cFlags.highlight ||
+      newViewProps.md4cFlags.hardSoftBreaks != oldViewProps.md4cFlags.hardSoftBreaks) {
+    _md4cFlags = [EnrichedMarkdownText flagsFromProps:newViewProps.md4cFlags];
     _forceHeightUpdateOnNextRender = YES;
     _dirtyFlags |= ENRMDirtyRender;
   }
 
   _enableLinkPreview = newViewProps.enableLinkPreview;
+  _enableTaskListItemToggle = newViewProps.enableTaskListItemToggle;
+  _contextMenuHidden = newViewProps.contextMenuHidden;
 
   if (ENRMContextMenuItemsChanged(oldViewProps.contextMenuItems, newViewProps.contextMenuItems)) {
     _contextMenuItemTexts = ENRMContextMenuTextsFromItems(newViewProps.contextMenuItems);
@@ -665,26 +669,46 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
 
 - (void)prepareForRecycle
 {
-  _props = std::make_shared<const EnrichedMarkdownTextProps>();
+  const auto resetProps = std::make_shared<const EnrichedMarkdownTextProps>();
+  _props = resetProps;
   [_renderCoordinator invalidate];
 
   [_fadeAnimator cancel];
   _fadeAnimator = nil;
   _previousTextLength = 0;
+  _streamingAnimation = NO;
+  _forceHeightUpdateOnNextRender = NO;
   _cachedMarkdown = nil;
   _renderedMarkdown = nil;
+  _config = nil;
+  _md4cFlags = [EnrichedMarkdownText flagsFromProps:resetProps->md4cFlags];
+  _maxFontSizeMultiplier = 0;
+  _lastElementMarginBottom = 0;
+  _allowTrailingMargin = NO;
+  _lineBreakStrategy = NSLineBreakStrategyNone;
+  _writingDirectionMode = ENRMWritingDirectionModeFirstStrong;
+  _renderedStyleFingerprint = 0;
+  _pendingStyleFingerprint = 0;
+  _contextMenuItemTexts = nil;
+  _contextMenuItemIcons = nil;
+  _fontScaleObserver.allowFontScaling = resetProps->allowFontScaling;
+  _accessibilityLabels = nil;
   _accessibilityElements = nil;
   _accessibilityInfo = nil;
   _accessibilityNeedsRebuild = NO;
   [_spoilerManager removeAllOverlays];
-
-  [self resetPropDerivedState];
-
+  _spoilerManager = nil;
   if (_textView != nil) {
     ENRMSetAttributedText(_textView, [[NSAttributedString alloc] initWithString:@""]);
     _textView.hidden = YES;
   }
 
+  // Ported from the fork's resetPropDerivedState: upstream's prepareForRecycle covers every
+  // other prop-derived ivar but leaves these two, so a recycled view keeps the previous
+  // consumer's height-update counter and a dangling shadow-node state handle.
+  _heightUpdateCounter = 0;
+  _state = nullptr;
+
   [super prepareForRecycle];
 }
 
@@ -745,7 +769,8 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownTextCls(void)
 {
   ENRMPlatformTextView *textView = (ENRMPlatformTextView *)recognizer.view;
 
-  if (handleTaskListTapWithSharedLogic(
+  if (_enableTaskListItemToggle &&
+      handleTaskListTapWithSharedLogic(
           textView, recognizer, &self->_cachedMarkdown, self->_config,
           ^(NSInteger index, BOOL checked, NSString *itemText) {
             [self emitTaskListItemPress:index checked:checked text:itemText];
@@ -790,6 +815,10 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownTextCls(void)
     editMenuForTextInRange:(NSRange)range
           suggestedActions:(NSArray<UIMenuElement *> *)suggestedActions API_AVAILABLE(ios(16.0))
 {
+  if (_contextMenuHidden) {
+    return nil;
+  }
+
   __weak EnrichedMarkdownText *weakSelf = self;
   ENRMContextMenuPressHandler handler =
       ^(NSString *itemText, NSString *selectedText, NSUInteger selectionStart, NSUInteger selectionEnd) {

package/ios/attachments/ENRMImageAttachment.h

@@ -5,6 +5,15 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+/**
+ * Adopted by component views that host markdown text. Notified when a block
+ * image resolves its box height after loading (maxHeight/aspectRatio sizing),
+ * so the view can drop stale cached measurements and request a height update.
+ */
+@protocol ENRMImageLayoutObserver
+- (void)imageAttachmentDidResolveLayout;
+@end
+
 /**
  * Custom NSTextAttachment for rendering markdown images.
  * Images are loaded asynchronously and scaled dynamically based on text container width.

package/ios/attachments/ENRMImageAttachment.m

@@ -5,7 +5,7 @@
 #import "StyleConfig.h"
 #import <objc/runtime.h>
 
-#define CACHE_KEY_PROCESSED(url, w, h, r) [NSString stringWithFormat:@"%@_w%.1f_h%.1f_r%.1f", url, w, h, r]
+#define CACHE_KEY_PROCESSED(url, w, h, r, m) [NSString stringWithFormat:@"%@_w%.1f_h%.1f_r%.1f_m%@", url, w, h, r, m]
 
 static inline NSUInteger ENRMImageByteCost(RCTUIImage *image)
 {
@@ -22,13 +22,19 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 @interface ENRMImageAttachment ()
 
 @property (nonatomic, copy) NSString *imageURL;
+@property (nonatomic, copy, nullable) NSDictionary<NSString *, NSString *> *requestHeaders;
+@property (nonatomic, copy) NSString *cacheKey;
 @property (nonatomic, assign) BOOL isInline;
 @property (nonatomic, assign) CGFloat cachedHeight;
+@property (nonatomic, assign) CGFloat cachedMaxHeight;
+@property (nonatomic, assign) CGFloat cachedAspectRatio;
+@property (nonatomic, copy) NSString *cachedResizeMode;
 @property (nonatomic, assign) CGFloat cachedBorderRadius;
 @property (nonatomic, weak) NSTextContainer *textContainer;
 @property (nonatomic, weak) ENRMPlatformTextView *textView;
 @property (nonatomic, strong) RCTUIImage *originalImage;
 @property (nonatomic, strong) RCTUIImage *loadedImage;
+@property (nonatomic, strong) RCTUIImage *placeholderImage;
 @property (nonatomic, copy) NSString *lastProcessedKey;
 
 @end
@@ -66,7 +72,8 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 
 + (instancetype)attachmentForURL:(NSString *)imageURL config:(StyleConfig *)config isInline:(BOOL)isInline
 {
-  NSString *key = [NSString stringWithFormat:@"%@_%d", imageURL, isInline];
+  NSString *key =
+      [NSString stringWithFormat:@"%@_%d", ENRMImageCacheKey(imageURL, [config imageRequestHeaders]), isInline];
   ENRMImageAttachment *existing = [[self attachmentRegistry] objectForKey:key];
   if (existing && existing.loadedImage) {
     return existing;
@@ -86,9 +93,14 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   self = [super init];
   if (self) {
     _imageURL = imageURL;
+    _requestHeaders = [[config imageRequestHeaders] copy];
+    _cacheKey = ENRMImageCacheKey(imageURL, _requestHeaders);
     _isInline = isInline;
 
     _cachedHeight = isInline ? [config inlineImageSize] : [config imageHeight];
+    _cachedMaxHeight = [config imageMaxHeight];
+    _cachedAspectRatio = [config imageAspectRatio];
+    _cachedResizeMode = [config imageResizeMode];
     _cachedBorderRadius = [config imageBorderRadius];
 
     [self setupPlaceholder];
@@ -97,6 +109,33 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   return self;
 }
 
+- (CGFloat)resolvedBoxHeightForWidth:(CGFloat)width
+{
+  if (self.cachedAspectRatio > 0 && width > 0) {
+    return width / self.cachedAspectRatio;
+  }
+
+  if (self.cachedMaxHeight > 0) {
+    RCTUIImage *source = self.originalImage;
+    if (source && width > 0 && source.size.width > 0 && source.size.height > 0) {
+      CGFloat fitted = width * source.size.height / source.size.width;
+      return MIN(self.cachedMaxHeight, fitted);
+    }
+    // Intrinsic size not known yet — fall back to the full max height; the box
+    // shrinks once the image loads and layout is invalidated.
+    return self.cachedMaxHeight;
+  }
+
+  return self.cachedHeight;
+}
+
+// True when resizeMode is unset ('') - legacy always implies a fixed height box.
+
+- (BOOL)isLegacyBlockSizing
+{
+  return !self.isInline && self.cachedResizeMode.length == 0;
+}
+
 - (CGRect)attachmentBoundsForTextContainer:(NSTextContainer *)textContainer
                       proposedLineFragment:(CGRect)lineFragment
                              glyphPosition:(CGPoint)position
@@ -105,26 +144,27 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   CGFloat height = self.cachedHeight;
   CGFloat width = self.isInline ? height : (lineFragment.size.width > 0 ? lineFragment.size.width : height);
 
-  if (self.isInline) {
-    UIFont *appliedFont = nil;
-    NSLayoutManager *layoutManager = textContainer.layoutManager;
-    NSTextStorage *textStorage = layoutManager.textStorage;
+  if (!self.isInline) {
+    height = [self resolvedBoxHeightForWidth:width];
+    return CGRectMake(0, 0, width, height);
+  }
 
-    if (textStorage && characterIndex < textStorage.length) {
-      appliedFont = [textStorage attribute:NSFontAttributeName atIndex:characterIndex effectiveRange:NULL];
-    }
+  UIFont *appliedFont = nil;
+  NSLayoutManager *layoutManager = textContainer.layoutManager;
+  NSTextStorage *textStorage = layoutManager.textStorage;
 
-    CGFloat verticalOffset;
-    if (appliedFont) {
-      verticalOffset = (appliedFont.capHeight - height) / 2.0;
-    } else {
-      verticalOffset = (lineFragment.size.height - height) / 2.0;
-    }
+  if (textStorage && characterIndex < textStorage.length) {
+    appliedFont = [textStorage attribute:NSFontAttributeName atIndex:characterIndex effectiveRange:NULL];
+  }
 
-    return CGRectMake(0, verticalOffset, width, height);
+  CGFloat verticalOffset;
+  if (appliedFont) {
+    verticalOffset = (appliedFont.capHeight - height) / 2.0;
+  } else {
+    verticalOffset = (lineFragment.size.height - height) / 2.0;
   }
 
-  return CGRectMake(0, 0, width, height);
+  return CGRectMake(0, verticalOffset, width, height);
 }
 
 - (RCTUIImage *)imageForBounds:(CGRect)imageBounds
@@ -138,7 +178,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
     [self processAndApplyImage:self.originalImage withTargetWidth:imageBounds.size.width];
   }
 
-  return self.loadedImage ?: self.image;
+  return self.loadedImage ?: self.placeholderImage;
 }
 
 - (void)handleLoadedImage:(RCTUIImage *)image
@@ -146,7 +186,15 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   if (!image)
     return;
 
+  // The downloader completes synchronously on cache hits, which can happen on the render queue
+  if (!NSThread.isMainThread) {
+    dispatch_async(dispatch_get_main_queue(), ^{ [self handleLoadedImage:image]; });
+    return;
+  }
+
   self.originalImage = image;
+  // UIKit reads the plain image property for save/drag/copy — it must hold the original
+  self.image = image;
   CGFloat targetWidth = self.isInline ? self.cachedHeight : self.bounds.size.width;
 
   // Defer processing if we don't have valid bounds yet (common for non-inline block images)
@@ -162,7 +210,10 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   if (targetWidth <= 0)
     return;
 
-  NSString *processedKey = CACHE_KEY_PROCESSED(self.imageURL, targetWidth, self.cachedHeight, self.cachedBorderRadius);
+  CGFloat boxHeight = self.isInline ? self.cachedHeight : [self resolvedBoxHeightForWidth:targetWidth];
+
+  NSString *processedKey =
+      CACHE_KEY_PROCESSED(self.cacheKey, targetWidth, boxHeight, self.cachedBorderRadius, self.cachedResizeMode);
 
   if ([processedKey isEqualToString:self.lastProcessedKey])
     return;
@@ -172,8 +223,6 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 
   if (cachedProcessed) {
     self.loadedImage = cachedProcessed;
-    if (self.isInline)
-      self.image = cachedProcessed;
     [self refreshDisplay];
     return;
   }
@@ -186,7 +235,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 
     RCTUIImage *processedImage = [strongSelf createScaledImage:image
                                                        toWidth:targetWidth
-                                                        height:strongSelf.cachedHeight
+                                                        height:boxHeight
                                                   borderRadius:strongSelf.cachedBorderRadius];
 
     if (processedImage) {
@@ -198,10 +247,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
     dispatch_async(dispatch_get_main_queue(), ^{
       strongSelf.loadedImage = processedImage;
       if (strongSelf.isInline) {
-        strongSelf.image = processedImage;
         strongSelf.bounds = CGRectMake(0, 0, strongSelf.cachedHeight, strongSelf.cachedHeight);
-      } else {
-        strongSelf.image = image; // Keep original for layout references
       }
       [strongSelf refreshDisplay];
     });
@@ -218,32 +264,64 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   if (sourceWidth <= 0 || sourceHeight <= 0)
     return nil;
 
-  CGFloat drawingWidth, drawingHeight;
+  CGSize source = CGSizeMake(sourceWidth, sourceHeight);
+  CGSize box = CGSizeMake(targetWidth, targetHeight);
+  BOOL legacy = [self isLegacyBlockSizing];
 
-  if (!self.isInline) {
-    CGFloat aspectRatioScale = targetWidth / sourceWidth;
-    drawingWidth = targetWidth;
-    drawingHeight = sourceHeight * aspectRatioScale;
+  CGRect drawingRect;
+  if (self.isInline || legacy) {
+    CGFloat drawingWidth, drawingHeight;
+    if (!self.isInline) {
+      CGFloat aspectRatioScale = targetWidth / sourceWidth;
+      drawingWidth = targetWidth;
+      drawingHeight = sourceHeight * aspectRatioScale;
+    } else {
+      drawingWidth = targetWidth;
+      drawingHeight = targetHeight;
+    }
+    drawingRect = CGRectMake((targetWidth - drawingWidth) / 2.0, (targetHeight - drawingHeight) / 2.0, drawingWidth,
+                             drawingHeight);
   } else {
-    drawingWidth = targetWidth;
-    drawingHeight = targetHeight;
+    drawingRect = [self drawingRectForResizeMode:self.cachedResizeMode source:source box:box];
   }
 
-  CGRect drawingRect =
-      CGRectMake((targetWidth - drawingWidth) / 2.0, (targetHeight - drawingHeight) / 2.0, drawingWidth, drawingHeight);
-
-  RCTUIGraphicsImageRenderer *renderer = ImageRendererForSize(CGSizeMake(targetWidth, targetHeight));
+  RCTUIGraphicsImageRenderer *renderer = ImageRendererForSize(box);
 
   return [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *context) {
     if (radius > 0) {
-      CGRect clippingRect = CGRectIntersection(CGRectMake(0, 0, targetWidth, targetHeight), drawingRect);
-      UIBezierPath *path = UIBezierPathWithRoundedRect(clippingRect, radius);
+      CGRect clipRect = CGRectIntersection(CGRectMake(0, 0, targetWidth, targetHeight), drawingRect);
+      UIBezierPath *path = UIBezierPathWithRoundedRect(clipRect, radius);
       [path addClip];
     }
     [image drawInRect:drawingRect];
   }];
 }
 
+- (CGRect)drawingRectForResizeMode:(NSString *)mode source:(CGSize)source box:(CGSize)box
+{
+  if ([mode isEqualToString:@"stretch"]) {
+    return CGRectMake(0, 0, box.width, box.height);
+  }
+
+  CGFloat widthScale = box.width / source.width;
+  CGFloat heightScale = box.height / source.height;
+
+  CGFloat scale;
+  if ([mode isEqualToString:@"contain"]) {
+    scale = MIN(widthScale, heightScale);
+  } else if ([mode isEqualToString:@"center"]) {
+    scale = MIN(1.0, MIN(widthScale, heightScale));
+  } else if ([mode isEqualToString:@"none"]) {
+    scale = 1.0;
+  } else { // cover (default)
+    scale = MAX(widthScale, heightScale);
+  }
+
+  CGFloat drawingWidth = source.width * scale;
+  CGFloat drawingHeight = source.height * scale;
+  return CGRectMake((box.width - drawingWidth) / 2.0, (box.height - drawingHeight) / 2.0, drawingWidth, drawingHeight);
+}
+
 - (void)startDownloadingImage
 {
   if (self.imageURL.length == 0)
@@ -251,6 +329,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
 
   __weak typeof(self) weakSelf = self;
   [[ENRMImageDownloader shared] downloadURL:self.imageURL
+                                    headers:self.requestHeaders
                                  completion:^(RCTUIImage *image) { [weakSelf handleLoadedImage:image]; }];
 }
 
@@ -265,10 +344,34 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
     [textView.layoutManager invalidateDisplayForCharacterRange:range];
     if (!self.isInline) {
       [textView.layoutManager invalidateLayoutForCharacterRange:range actualCharacterRange:NULL];
+      [self notifyImageLayoutObserver:textView];
     }
   }
 }
 
+// With maxHeight/aspectRatio sizing the box height can settle after the image
+// loads, while the component was measured (and its size cached) with the
+// pre-load fallback. Notify the hosting component so it can re-measure.
+// Dispatched async: refreshDisplay can run mid-layout (imageForBounds) and
+// re-measuring would re-enter the layout manager.
+- (void)notifyImageLayoutObserver:(UITextView *)textView
+{
+  // Only maxHeight/aspectRatio boxes can change height after load; a fixed
+  // height box (legacy or explicit resizeMode) never needs a re-measure.
+  if (self.cachedMaxHeight <= 0 && self.cachedAspectRatio <= 0)
+    return;
+
+  RCTUIView *candidate = textView;
+  while (candidate && ![candidate conformsToProtocol:@protocol(ENRMImageLayoutObserver)]) {
+    candidate = candidate.superview;
+  }
+  if (!candidate)
+    return;
+
+  id<ENRMImageLayoutObserver> observer = (id<ENRMImageLayoutObserver>)candidate;
+  dispatch_async(dispatch_get_main_queue(), ^{ [observer imageAttachmentDidResolveLayout]; });
+}
+
 - (ENRMPlatformTextView *)fetchAssociatedTextView
 {
   if (self.textView)
@@ -284,7 +387,7 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   CGFloat size = self.cachedHeight;
   self.bounds = CGRectMake(0, 0, size, size);
   RCTUIGraphicsImageRenderer *renderer = [[RCTUIGraphicsImageRenderer alloc] initWithSize:CGSizeMake(1, 1)];
-  self.image = [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *ctx){}];
+  self.placeholderImage = [renderer imageWithActions:^(RCTUIGraphicsImageRendererContext *ctx){}];
 }
 
 - (NSRange)findAttachmentRangeInText:(NSAttributedString *)attributedString
@@ -302,4 +405,4 @@ static NSMapTable<NSString *, ENRMImageAttachment *> *_attachmentRegistry;
   return foundRange;
 }
 
-@end
+@end

package/ios/attachments/ENRMMathInlineAttachment.h

@@ -9,6 +9,8 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) CGFloat fontSize;
 @property (nonatomic, strong, nullable) RCTUIColor *mathTextColor;
 
+@property (nonatomic, readonly) CGFloat boxHeight;
+
 /// Typeset the glyphs at bold weight (synthetic — see ENRMRaTeXBridge).
 @property (nonatomic, assign) BOOL bold;