react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.10

package/ios/EnrichedMarkdown.mm

@@ -2,6 +2,7 @@
 #import "ContextMenuUtils.h"
 #import "ENRMAccessibilityLabels.h"
 #import "ENRMAsyncRenderCoordinator.h"
+#import "ENRMAtomicSize.h"
 #import "ENRMImageAttachment.h"
 #import "ENRMMarkdownParser.h"
 #import "ENRMTailFadeInAnimator.h"
@@ -10,12 +11,16 @@
 #import "ENRMTextViewSetup.h"
 #import "ENRMUIKit.h"
 #import "EditMenuUtils.h"
+#import "ImageRequestHeaderUtils.h"
 
 #import "ENRMFeatureFlags.h"
 
 #if ENRICHED_MARKDOWN_MATH
 #import "ENRMMathContainerView.h"
 #endif
+#import "ENRMCodeBlockContainerView.h"
+#import "ENRMLinkLayout.h"
+#import "ENRMSelectionChange.h"
 #import "ENRMSpoilerCapable.h"
 #import "ENRMSpoilerOverlayView.h"
 #import "ENRMSpoilerTapUtils.h"
@@ -66,10 +71,14 @@ typedef NS_OPTIONS(NSUInteger, ENRMDirtyFlags) {
 
 static char kENRMSegmentFadeAnimatorKey;
 
-@interface EnrichedMarkdown () <RCTEnrichedMarkdownViewProtocol, UITextViewDelegate>
+@interface EnrichedMarkdown () <RCTEnrichedMarkdownViewProtocol, UITextViewDelegate, ENRMImageLayoutObserver>
++ (ENRMMd4cFlags *)flagsFromProps:(const EnrichedMarkdownMd4cFlagsStruct &)props;
 - (void)emitLinkPress:(NSString *)url;
 - (void)emitLinkLongPress:(NSString *)url;
+- (void)emitLinkLayoutIfNeeded;
 - (void)emitTaskListItemPress:(NSInteger)index checked:(BOOL)checked text:(NSString *)text;
+- (void)emitCopyPress:(NSString *)code language:(NSString *)language;
+- (void)emitCopyRequest:(NSString *)source markdown:(NSString *)markdown text:(NSString *)text whole:(BOOL)whole;
 - (void)emitContextMenuItemPress:(NSString *)itemText
                     selectedText:(NSString *)selectedText
                   selectionStart:(NSUInteger)selectionStart
@@ -98,8 +107,14 @@ static char kENRMSegmentFadeAnimatorKey;
   BOOL _allowTrailingMargin;
   BOOL _selectable;
   BOOL _enableLinkPreview;
+  BOOL _linkLongPressSelects;
+  BOOL _enableTaskListItemToggle;
+  BOOL _contextMenuHidden;
   BOOL _streamingAnimation;
   ENRMTableStreamingMode _tableStreamingMode;
+  ENRMCodeBlockStreamingMode _codeBlockStreamingMode;
+  // Trailing code block whose closing fence hasn't streamed in yet, if any.
+  ENRMCodeBlockSegment *_pendingCodeBlockSegment;
 
   size_t _renderedStyleFingerprint;
   size_t _pendingStyleFingerprint;
@@ -112,10 +127,27 @@ static char kENRMSegmentFadeAnimatorKey;
 
   ENRMSpoilerOverlay _spoilerOverlay;
 
+  BOOL _emitLinkLayout;
+  NSArray<NSDictionary *> *_lastLinkLayout;
+
+  ENRMSelectionChangeReporter *_selectionReporter;
+#if !TARGET_OS_OSX
+  ENRMSelectionGestureTracker *_selectionGestures;
+#endif
+  // At most one segment holds a selection; a new one clears the previous.
+  __weak ENRMPlatformTextView *_selectionOwner;
+  // A block long-pressed while contextMenuHidden is on, reported as the selection.
+  __weak RCTUIView *_activeBlockView;
+  NSString *_activeBlockSource;
+  NSString *_activeBlockMarkdown;
+  NSString *_activeBlockText;
+
   NSLineBreakStrategy _lineBreakStrategy;
 
   ENRMWritingDirectionMode _writingDirectionMode;
   NSWritingDirection _resolvedLayoutDirection;
+
+  ENRMAtomicSize _lastCommittedSize;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider
@@ -123,43 +155,16 @@ static char kENRMSegmentFadeAnimatorKey;
   return concreteComponentDescriptorProvider<EnrichedMarkdownComponentDescriptor>();
 }
 
-/// Clears every piece of state that `updateProps` derives from props, back to the
-/// values the default-constructed `EnrichedMarkdownProps` 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;
-
-  _md4cFlags = [ENRMMd4cFlags propsDefaultFlags];
-  _maxFontSizeMultiplier = 0;
-  _allowTrailingMargin = NO;
-  _fontScaleObserver.allowFontScaling = YES;
-  _streamingAnimation = NO;
-  _tableStreamingMode = ENRMTableStreamingModeProgressive;
-  _spoilerOverlay = ENRMSpoilerOverlayParticles;
-  _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;
-
-  _dirtyFlags = ENRMDirtyNone;
-  _heightUpdateCounter = 0;
-  _state = nullptr;
++ (ENRMMd4cFlags *)flagsFromProps:(const EnrichedMarkdownMd4cFlagsStruct &)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;
 }
 
 - (instancetype)initWithFrame:(CGRect)frame
@@ -170,22 +175,31 @@ static char kENRMSegmentFadeAnimatorKey;
 
     self.backgroundColor = [RCTUIColor clearColor];
     _parser = [[ENRMMarkdownParser alloc] init];
+    _md4cFlags = [EnrichedMarkdown flagsFromProps:defaultProps->md4cFlags];
     _segmentViews = [NSMutableArray array];
     _segmentSignatures = [NSMutableArray array];
+    _dirtyFlags = ENRMDirtyNone;
     [self configureSegmentViewRegistry];
 
     _renderCoordinator =
         [[ENRMAsyncRenderCoordinator alloc] initWithQueueLabel:"com.swmansion.enriched.markdown.container.render"];
 
+    _maxFontSizeMultiplier = 0;
+    _allowTrailingMargin = NO;
     _selectable = YES;
     _enableLinkPreview = YES;
-    _selectionMenuConfig = (ENRMSelectionMenuConfig){.copyAsMarkdown = YES, .copyImageURL = YES};
+    _enableTaskListItemToggle = YES;
+    _streamingAnimation = NO;
+    _tableStreamingMode = ENRMTableStreamingModeProgressive;
+    _codeBlockStreamingMode = ENRMCodeBlockStreamingModeProgressive;
+    _contextMenuHidden = NO;
+    _selectionMenuConfig = ENRMDefaultSelectionMenuConfig();
+    _lineBreakStrategy = NSLineBreakStrategyNone;
+    _writingDirectionMode = ENRMWritingDirectionModeFirstStrong;
     _resolvedLayoutDirection =
         [[RCTI18nUtil sharedInstance] isRTL] ? NSWritingDirectionRightToLeft : NSWritingDirectionLeftToRight;
 
     _fontScaleObserver = [[FontScaleObserver alloc] init];
-    [self resetPropDerivedState];
-
     __weak EnrichedMarkdown *weakSelf = self;
     _fontScaleObserver.onChange = ^{
       EnrichedMarkdown *strongSelf = weakSelf;
@@ -199,10 +213,132 @@ static char kENRMSegmentFadeAnimatorKey;
         [strongSelf renderMarkdownContent:strongSelf->_cachedMarkdown];
       }
     };
+
+    _selectionReporter = [[ENRMSelectionChangeReporter alloc]
+        initWithSnapshot:^NSDictionary * {
+          EnrichedMarkdown *strongSelf = weakSelf;
+          return strongSelf ? [strongSelf selectionPayload] : ENRMInactiveSelectionPayload();
+        }
+        emit:^(NSDictionary *payload) {
+          EnrichedMarkdown *strongSelf = weakSelf;
+          if (!strongSelf)
+            return;
+          auto emitter = std::static_pointer_cast<EnrichedMarkdownEventEmitter const>(strongSelf->_eventEmitter);
+          if (emitter)
+            emitter->onSelectionChange(
+                ENRMSelectionChangeEventFromPayload<EnrichedMarkdownEventEmitter::OnSelectionChange>(payload));
+        }];
+#if !TARGET_OS_OSX
+    // A handle drag starting or ending is reported right away, even when the
+    // selection itself is unchanged.
+    _selectionGestures = [[ENRMSelectionGestureTracker alloc] initWithChange:^{
+      EnrichedMarkdown *strongSelf = weakSelf;
+      if (!strongSelf)
+        return;
+      UITextView *owner = strongSelf->_selectionOwner;
+      if (owner)
+        [strongSelf->_selectionGestures trackTextView:owner];
+      [strongSelf->_selectionReporter forgetLastReported];
+      [strongSelf->_selectionReporter flushNow];
+    }];
+#endif
   }
   return self;
 }
 
+#pragma mark - Selection
+
+/// The current selection (or active block) as an `onSelectionChange` payload.
+/// Markdown and `whole` follow the same rules as the intercepted Copy.
+- (NSDictionary *)selectionPayload
+{
+  RCTUIView *blockView = _activeBlockView;
+  if (blockView != nil) {
+    if (blockView.superview != self)
+      return ENRMInactiveSelectionPayload();
+    return ENRMBlockSelectionPayload(_activeBlockSource, _activeBlockMarkdown, _activeBlockText, blockView.frame);
+  }
+
+#if !TARGET_OS_OSX
+  UITextView *owner = _selectionOwner;
+  if (owner == nil || ![owner isDescendantOfView:self])
+    return ENRMInactiveSelectionPayload();
+  NSDictionary *selection = ENRMTextSelectionInTextView(owner, self);
+  if (!selection)
+    return ENRMInactiveSelectionPayload();
+
+  NSString *text = selection[ENRMSelectionTextKey];
+  // Segments only see their own text, so a selection is the whole component
+  // only when it spans the sole segment; the markdown is then the original.
+  BOOL whole = [selection[ENRMSelectionFullKey] boolValue] && _segmentViews.count == 1 && _cachedMarkdown.length > 0;
+  NSString *markdown =
+      whole ? _cachedMarkdown : extractMarkdownFromAttributedString(owner.attributedText, owner.selectedRange);
+  NSMutableDictionary *payload = [selection mutableCopy];
+  [payload removeObjectForKey:ENRMSelectionFullKey];
+  payload[ENRMSelectionActiveKey] = @YES;
+  payload[ENRMSelectionSourceKey] = @"selection";
+  payload[ENRMSelectionMarkdownKey] = markdown.length > 0 ? markdown : text;
+  payload[ENRMSelectionWholeKey] = @(whole);
+  payload[ENRMSelectionAdjustingKey] = @(_selectionGestures.adjusting);
+  return payload;
+#else
+  return ENRMInactiveSelectionPayload();
+#endif
+}
+
+- (void)clearActiveBlock
+{
+  _activeBlockView = nil;
+  _activeBlockSource = nil;
+  _activeBlockMarkdown = nil;
+  _activeBlockText = nil;
+}
+
+- (void)clearSegmentSelection:(ENRMPlatformTextView *)textView
+{
+#if !TARGET_OS_OSX
+  textView.selectedRange = NSMakeRange(0, 0);
+  [textView resignFirstResponder];
+#endif
+}
+
+- (void)clearSelection
+{
+  ENRMPlatformTextView *owner = _selectionOwner;
+  _selectionOwner = nil;
+  [self clearActiveBlock];
+  if (owner)
+    [self clearSegmentSelection:owner];
+  [_selectionReporter flushNow];
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTEnrichedMarkdownHandleCommand(self, commandName, args);
+}
+
+- (ENRMBlockCopyRequestBlock)blockMenuSuppressedForSource:(NSString *)source view:(RCTUIView *)view
+{
+  __weak EnrichedMarkdown *weakSelf = self;
+  __weak RCTUIView *weakView = view;
+  return ^(NSString *markdown, NSString *text) {
+    EnrichedMarkdown *strongSelf = weakSelf;
+    RCTUIView *strongView = weakView;
+    if (!strongSelf || !strongView || !strongSelf->_selectionReporter.enabled)
+      return;
+    ENRMPlatformTextView *owner = strongSelf->_selectionOwner;
+    strongSelf->_selectionOwner = nil;
+    if (owner)
+      [strongSelf clearSegmentSelection:owner];
+    strongSelf->_activeBlockView = strongView;
+    strongSelf->_activeBlockSource = source;
+    strongSelf->_activeBlockMarkdown = markdown;
+    strongSelf->_activeBlockText = text;
+    [strongSelf->_selectionReporter forgetLastReported];
+    [strongSelf->_selectionReporter flushNow];
+  };
+}
+
 - (void)configureSegmentViewRegistry
 {
   __weak EnrichedMarkdown *weakSelf = self;
@@ -273,6 +409,29 @@ static char kENRMSegmentFadeAnimatorKey;
                           }]];
 #endif
 
+  [handlers addObject:[ENRMSegmentViewHandler handlerWithKind:ENRMSegmentKindCodeBlock
+                          matchesView:^BOOL(RCTUIView *view, ENRMRenderedSegment *segment) {
+                            return [view isKindOfClass:[ENRMCodeBlockContainerView class]];
+                          }
+                          createView:^RCTUIView *(ENRMRenderedSegment *segment) {
+                            EnrichedMarkdown *strongSelf = weakSelf;
+                            if (!strongSelf) {
+                              return [[RCTUIView alloc] init];
+                            }
+
+                            ENRMCodeBlockContainerView *view =
+                                [strongSelf createCodeBlockViewForSegment:segment.codeBlockSegment];
+                            [strongSelf animateBlockViewIfNeeded:view];
+                            return view;
+                          }
+                          updateView:^(RCTUIView *view, ENRMRenderedSegment *segment) {
+                            EnrichedMarkdown *strongSelf = weakSelf;
+                            ENRMCodeBlockContainerView *codeBlockView = (ENRMCodeBlockContainerView *)view;
+                            codeBlockView.pending =
+                                strongSelf && segment.codeBlockSegment == strongSelf->_pendingCodeBlockSegment;
+                            [codeBlockView applyCodeBlockNode:segment.codeBlockSegment.codeBlockNode];
+                          }]];
+
   _segmentViewRegistry = [[ENRMSegmentViewRegistry alloc] initWithHandlers:handlers];
 }
 
@@ -281,6 +440,29 @@ static char kENRMSegmentFadeAnimatorKey;
   if (_segmentViews.count == 0)
     return CGSizeZero;
 
+  if (applyFrames) {
+    CGFloat overhang = MAX(_config.tableHorizontalOverflow, 0);
+    BOOL needsOverhang = NO;
+    if (overhang > 0) {
+      for (RCTUIView *seg in _segmentViews) {
+        if ([seg isKindOfClass:[TableContainerView class]]) {
+          needsOverhang = YES;
+          break;
+        }
+      }
+    }
+#if TARGET_OS_OSX
+    BOOL isClipping = self.layer.masksToBounds;
+    if (isClipping && needsOverhang)
+      self.layer.masksToBounds = NO;
+    else if (!isClipping && !needsOverhang)
+      self.layer.masksToBounds = YES;
+#else
+    if (self.clipsToBounds != !needsOverhang)
+      self.clipsToBounds = !needsOverhang;
+#endif
+  }
+
   __block CGFloat yOffset = 0.0;
   __block CGFloat maxContentWidth = 0.0;
   const NSUInteger lastIndex = _segmentViews.count - 1;
@@ -290,6 +472,7 @@ static char kENRMSegmentFadeAnimatorKey;
     const BOOL shouldAddBottomMargin = (!isLast || _allowTrailingMargin);
 
     CGFloat segmentHeight = 0;
+    const BOOL isTable = [segment isKindOfClass:[TableContainerView class]];
 
     if ([segment isKindOfClass:[EnrichedMarkdownInternalText class]]) {
       EnrichedMarkdownInternalText *textView = (EnrichedMarkdownInternalText *)segment;
@@ -298,7 +481,7 @@ static char kENRMSegmentFadeAnimatorKey;
       segmentHeight = textSize.height;
       maxContentWidth = MAX(maxContentWidth, textSize.width);
 
-    } else if ([segment isKindOfClass:[TableContainerView class]]) {
+    } else if (isTable) {
       yOffset += _config.tableMarginTop;
       segmentHeight = [(TableContainerView *)segment measureHeight:width];
       maxContentWidth = width;
@@ -310,9 +493,23 @@ static char kENRMSegmentFadeAnimatorKey;
       maxContentWidth = width;
     }
 #endif
+    else if ([segment isKindOfClass:[ENRMCodeBlockContainerView class]]) {
+      yOffset += _config.codeBlockMarginTop;
+      segmentHeight = [(ENRMCodeBlockContainerView *)segment measureHeight:width];
+      maxContentWidth = width;
+    }
 
     if (applyFrames) {
-      CGRect segmentFrame = CGRectMake(0, yOffset, width, segmentHeight);
+      CGFloat segmentX = 0;
+      CGFloat segmentWidth = width;
+      if (isTable) {
+        CGFloat overhang = MAX(_config.tableHorizontalOverflow, 0);
+        if (overhang > 0) {
+          segmentX = -overhang;
+          segmentWidth = width + overhang * 2;
+        }
+      }
+      CGRect segmentFrame = CGRectMake(segmentX, yOffset, segmentWidth, segmentHeight);
       segment.frame = segmentFrame;
 #if TARGET_OS_OSX
       if ([segment isKindOfClass:[EnrichedMarkdownInternalText class]]) {
@@ -335,6 +532,9 @@ static char kENRMSegmentFadeAnimatorKey;
       yOffset += _config.mathMarginBottom;
     }
 #endif
+    else if ([segment isKindOfClass:[ENRMCodeBlockContainerView class]] && shouldAddBottomMargin) {
+      yOffset += _config.codeBlockMarginBottom;
+    }
   }];
 
   return CGSizeMake(maxContentWidth, yOffset);
@@ -353,6 +553,11 @@ static char kENRMSegmentFadeAnimatorKey;
   return CGSizeMake(measuredWidth, measuredHeight);
 }
 
+- (CGSize)lastCommittedLayoutSize
+{
+  return _lastCommittedSize.load();
+}
+
 - (BOOL)hasRenderedMarkdown:(NSString *)markdown
 {
   return _renderedMarkdown != nil && [_renderedMarkdown isEqualToString:markdown];
@@ -396,6 +601,8 @@ static char kENRMSegmentFadeAnimatorKey;
 {
   [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;
@@ -440,9 +647,30 @@ static char kENRMSegmentFadeAnimatorKey;
   }
 }
 
-// Table and math views cache the copy labels at creation time, so re-push them
-// on prop updates (e.g. a language change without a remount) to avoid stale
-// labels. Only the copy/copy-as-markdown labels apply to these block menus.
+- (ENRMBlockMenuOptions)blockMenuOptions
+{
+  return (ENRMBlockMenuOptions){
+      .copyHidden = !_selectionMenuConfig.copyEnabled,
+      .copyWritesMarkdown = _selectionMenuConfig.copyFormatMarkdown,
+      .copyAsMarkdownHidden = !_selectionMenuConfig.copyAsMarkdown,
+      .copyButtonHidden = !_selectionMenuConfig.codeBlockCopyButton,
+      .interceptCopy = _selectionMenuConfig.interceptCopy,
+  };
+}
+
+- (ENRMBlockCopyRequestBlock)blockCopyRequestForSource:(NSString *)source
+{
+  __weak EnrichedMarkdown *weakSelf = self;
+  return ^(NSString *markdown, NSString *text) {
+    EnrichedMarkdown *strongSelf = weakSelf;
+    if (strongSelf)
+      [strongSelf emitCopyRequest:source markdown:markdown text:text whole:YES];
+  };
+}
+
+// Table, math and code block views cache the copy labels and menu options at
+// creation time, so re-push them on prop updates (e.g. a language change
+// without a remount) to avoid stale values.
 - (void)pushSelectionMenuLabelsToSegments
 {
   for (RCTUIView *segment in _segmentViews) {
@@ -450,14 +678,25 @@ static char kENRMSegmentFadeAnimatorKey;
       TableContainerView *tableView = (TableContainerView *)segment;
       tableView.copyLabel = _selectionMenuLabels.copyLabel;
       tableView.copyAsMarkdownLabel = _selectionMenuLabels.copyAsMarkdownLabel;
+      tableView.contextMenuHidden = _contextMenuHidden;
+      tableView.menuOptions = [self blockMenuOptions];
     }
 #if ENRICHED_MARKDOWN_MATH
     else if ([segment isKindOfClass:[ENRMMathContainerView class]]) {
       ENRMMathContainerView *mathView = (ENRMMathContainerView *)segment;
       mathView.copyLabel = _selectionMenuLabels.copyLabel;
       mathView.copyAsMarkdownLabel = _selectionMenuLabels.copyAsMarkdownLabel;
+      mathView.contextMenuHidden = _contextMenuHidden;
+      mathView.menuOptions = [self blockMenuOptions];
     }
 #endif
+    else if ([segment isKindOfClass:[ENRMCodeBlockContainerView class]]) {
+      ENRMCodeBlockContainerView *codeBlockView = (ENRMCodeBlockContainerView *)segment;
+      codeBlockView.copyLabel = _selectionMenuLabels.copyLabel;
+      codeBlockView.copyAsMarkdownLabel = _selectionMenuLabels.copyAsMarkdownLabel;
+      codeBlockView.contextMenuHidden = _contextMenuHidden;
+      codeBlockView.menuOptions = [self blockMenuOptions];
+    }
   }
 }
 
@@ -466,6 +705,25 @@ static char kENRMSegmentFadeAnimatorKey;
   ENRMRequestHeightUpdate<EnrichedMarkdownState>(_state, _heightUpdateCounter, self);
 }
 
+// A block image in one of the text segments 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, re-stack segments, and re-measure.
+- (void)imageAttachmentDidResolveLayout
+{
+  if (_renderedMarkdown.length > 0) {
+    MeasurementCache::shared().removeMatchingMarkdown(std::string(_renderedMarkdown.UTF8String));
+  }
+
+  if (self.bounds.size.width > 0) {
+    [self setNeedsLayout];
+    CGSize measured = [self measureSize:self.bounds.size.width];
+    if (needsHeightUpdate(measured, self.bounds)) {
+      [self requestHeightUpdate];
+    }
+  }
+}
+
 - (void)renderMarkdownContent:(NSString *)markdownString
 {
   if (_renderCoordinator.blockAsyncRender)
@@ -482,17 +740,21 @@ static char kENRMSegmentFadeAnimatorKey;
   BOOL allowTrailingMargin = _allowTrailingMargin;
   BOOL streamingAnimation = _streamingAnimation;
   ENRMTableStreamingMode tableStreamingMode = _tableStreamingMode;
+  ENRMCodeBlockStreamingMode codeBlockStreamingMode = _codeBlockStreamingMode;
   NSLineBreakStrategy lineBreakStrategy = _lineBreakStrategy;
   ENRMWritingDirectionMode writingDirectionMode = _writingDirectionMode;
   NSWritingDirection resolvedLayoutDirection = _resolvedLayoutDirection;
 
   __block NSArray<ENRMRenderedSegment *> *renderedSegments = nil;
   __block NSString *renderableMarkdown = nil;
+  __block BOOL endsInsideOpenCodeFence = NO;
 
   [_renderCoordinator
       scheduleRender:^BOOL {
-        renderableMarkdown = streamingAnimation ? ENRMRenderableMarkdownForStreaming(markdownString, tableStreamingMode)
-                                                : markdownString;
+        renderableMarkdown = streamingAnimation
+                                 ? ENRMRenderableMarkdownForStreaming(markdownString, tableStreamingMode,
+                                                                      codeBlockStreamingMode, &endsInsideOpenCodeFence)
+                                 : markdownString;
 
         if (renderableMarkdown.length == 0) {
           renderedSegments = @[];
@@ -515,7 +777,9 @@ static char kENRMSegmentFadeAnimatorKey;
       }
       apply:^{
         self->_renderedStyleFingerprint = self->_pendingStyleFingerprint;
-        [self applyRenderedSegments:renderedSegments renderedMarkdown:renderableMarkdown];
+        [self applyRenderedSegments:renderedSegments
+                   renderedMarkdown:renderableMarkdown
+            endsInsideOpenCodeFence:endsInsideOpenCodeFence];
       }];
 }
 
@@ -552,8 +816,11 @@ static char kENRMSegmentFadeAnimatorKey;
 
   _renderCoordinator.blockAsyncRender = YES;
   _cachedMarkdown = [markdownString copy];
+  BOOL endsInsideOpenCodeFence = NO;
   NSString *renderableMarkdown =
-      _streamingAnimation ? ENRMRenderableMarkdownForStreaming(markdownString, _tableStreamingMode) : markdownString;
+      _streamingAnimation ? ENRMRenderableMarkdownForStreaming(markdownString, _tableStreamingMode,
+                                                               _codeBlockStreamingMode, &endsInsideOpenCodeFence)
+                          : markdownString;
   _renderedMarkdown = [renderableMarkdown copy];
   _renderedStyleFingerprint = _pendingStyleFingerprint;
 
@@ -566,6 +833,8 @@ static char kENRMSegmentFadeAnimatorKey;
     return;
   }
 
+  [self updatePendingCodeBlockSegment:endsInsideOpenCodeFence segments:renderedSegments];
+
   for (ENRMRenderedSegment *segment in renderedSegments) {
     RCTUIView *view = [_segmentViewRegistry createViewForSegment:segment];
     [_segmentViews addObject:view];
@@ -574,9 +843,24 @@ static char kENRMSegmentFadeAnimatorKey;
   }
 }
 
-- (void)applyRenderedSegments:(NSArray *)renderedSegments renderedMarkdown:(NSString *)renderedMarkdown
+- (void)updatePendingCodeBlockSegment:(BOOL)endsInsideOpenCodeFence segments:(NSArray<ENRMRenderedSegment *> *)segments
+{
+  _pendingCodeBlockSegment = nil;
+  if (!_streamingAnimation || !endsInsideOpenCodeFence) {
+    return;
+  }
+  ENRMRenderedSegment *last = segments.lastObject;
+  if (last.kind == ENRMSegmentKindCodeBlock) {
+    _pendingCodeBlockSegment = last.codeBlockSegment;
+  }
+}
+
+- (void)applyRenderedSegments:(NSArray *)renderedSegments
+             renderedMarkdown:(NSString *)renderedMarkdown
+      endsInsideOpenCodeFence:(BOOL)endsInsideOpenCodeFence
 {
   _renderedMarkdown = [renderedMarkdown copy];
+  [self updatePendingCodeBlockSegment:endsInsideOpenCodeFence segments:renderedSegments];
   BOOL segmentTopologyChanged = _streamingAnimation && [self renderedSegmentsChangeTopology:renderedSegments];
 
   ENRMSegmentReconciliationResult *result = [ENRMSegmentReconciler reconcileCurrentViews:_segmentViews
@@ -600,6 +884,15 @@ static char kENRMSegmentFadeAnimatorKey;
   _segmentViews = result.views;
   _segmentSignatures = result.signatures;
 
+  // A just-closed block has unchanged content, so the reconciler reuses it
+  // without an update; sync pending here to trigger its deferred highlight.
+  [_segmentViews enumerateObjectsUsingBlock:^(RCTUIView *segment, NSUInteger i, BOOL *stop) {
+    if ([segment isKindOfClass:[ENRMCodeBlockContainerView class]]) {
+      ((ENRMCodeBlockContainerView *)segment).pending =
+          self->_pendingCodeBlockSegment != nil && i == self->_segmentViews.count - 1;
+    }
+  }];
+
   if (self.bounds.size.width > 0) {
     [self setNeedsLayout];
 
@@ -640,6 +933,7 @@ static char kENRMSegmentFadeAnimatorKey;
 
 #if !TARGET_OS_OSX
   view.textView.delegate = self;
+  [_selectionGestures trackTextView:view.textView];
 #else
   __weak EnrichedMarkdown *weakSelf = self;
   [view setContextMenuProvider:^NSMenu *_Nullable(NSMenu *baseMenu, NSTextView *textView) {
@@ -647,6 +941,9 @@ static char kENRMSegmentFadeAnimatorKey;
     if (!strongSelf) {
       return baseMenu;
     }
+    if (strongSelf->_contextMenuHidden) {
+      return nil;
+    }
     NSString *segmentMarkdown = extractMarkdownFromAttributedString(textView.textStorage, textView.selectedRange);
     NSArray<NSMenuItem *> *customItems = ENRMBuildContextMenuItems(
         strongSelf->_contextMenuItemTexts, strongSelf->_contextMenuItemIcons, textView,
@@ -676,6 +973,10 @@ static char kENRMSegmentFadeAnimatorKey;
   tableView.accessibilityLabels = _accessibilityLabels;
   tableView.copyLabel = _selectionMenuLabels.copyLabel;
   tableView.copyAsMarkdownLabel = _selectionMenuLabels.copyAsMarkdownLabel;
+  tableView.contextMenuHidden = _contextMenuHidden;
+  tableView.menuOptions = [self blockMenuOptions];
+  tableView.onCopyRequest = [self blockCopyRequestForSource:@"table"];
+  tableView.onMenuSuppressed = [self blockMenuSuppressedForSource:@"table" view:tableView];
 
   __weak EnrichedMarkdown *weakSelf = self;
 
@@ -715,11 +1016,37 @@ static char kENRMSegmentFadeAnimatorKey;
   mathView.accessibilityLabels = _accessibilityLabels;
   mathView.copyLabel = _selectionMenuLabels.copyLabel;
   mathView.copyAsMarkdownLabel = _selectionMenuLabels.copyAsMarkdownLabel;
+  mathView.contextMenuHidden = _contextMenuHidden;
+  mathView.menuOptions = [self blockMenuOptions];
+  mathView.onCopyRequest = [self blockCopyRequestForSource:@"math"];
+  mathView.onMenuSuppressed = [self blockMenuSuppressedForSource:@"math" view:mathView];
   [mathView applyLatex:mathSegment.latex];
   return mathView;
 }
 #endif
 
+- (ENRMCodeBlockContainerView *)createCodeBlockViewForSegment:(ENRMCodeBlockSegment *)codeBlockSegment
+{
+  ENRMCodeBlockContainerView *codeBlockView = [[ENRMCodeBlockContainerView alloc] initWithConfig:_config];
+  codeBlockView.copyLabel = _selectionMenuLabels.copyLabel;
+  codeBlockView.copyAsMarkdownLabel = _selectionMenuLabels.copyAsMarkdownLabel;
+  codeBlockView.contextMenuHidden = _contextMenuHidden;
+  codeBlockView.menuOptions = [self blockMenuOptions];
+  codeBlockView.onCopyRequest = [self blockCopyRequestForSource:@"code"];
+  codeBlockView.onMenuSuppressed = [self blockMenuSuppressedForSource:@"code" view:codeBlockView];
+
+  __weak EnrichedMarkdown *weakSelf = self;
+  codeBlockView.onCopyPress = ^(NSString *code, NSString *language) {
+    EnrichedMarkdown *strongSelf = weakSelf;
+    if (strongSelf)
+      [strongSelf emitCopyPress:code language:language];
+  };
+
+  codeBlockView.pending = codeBlockSegment == _pendingCodeBlockSegment;
+  [codeBlockView applyCodeBlockNode:codeBlockSegment.codeBlockNode];
+  return codeBlockView;
+}
+
 - (void)animateBlockViewIfNeeded:(RCTUIView *)view
 {
   if (!_streamingAnimation)
@@ -759,6 +1086,9 @@ static char kENRMSegmentFadeAnimatorKey;
 {
   [super layoutSubviews];
   [self computeSegmentLayoutForWidth:self.bounds.size.width applyFrames:YES];
+  [self emitLinkLayoutIfNeeded];
+  // Segments may have moved or been replaced; re-read the selection (deduplicated).
+  [_selectionReporter schedule];
 }
 
 - (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
@@ -784,8 +1114,24 @@ static char kENRMSegmentFadeAnimatorKey;
     }
   }
 
+  if (ENRMImageRequestHeadersChanged(oldViewProps.imageRequestHeaders, newViewProps.imageRequestHeaders)) {
+    [_config setImageRequestHeaders:ENRMImageRequestHeadersFromProps(newViewProps.imageRequestHeaders)];
+    _dirtyFlags |= ENRMDirtyRender;
+    if (!markdownChanged) {
+      _dirtyFlags |= ENRMDirtyRecreateSegments;
+    }
+  }
+
   _selectable = newViewProps.selectable;
 
+  if (newViewProps.emitLinkLayout != _emitLinkLayout) {
+    _emitLinkLayout = newViewProps.emitLinkLayout;
+    _lastLinkLayout = nil;
+    [self setNeedsLayout];
+  }
+
+  _selectionReporter.enabled = newViewProps.emitSelectionChange;
+
   for (RCTUIView *segment in _segmentViews) {
     if ([segment isKindOfClass:[EnrichedMarkdownInternalText class]]) {
       EnrichedMarkdownInternalText *textSegment = (EnrichedMarkdownInternalText *)segment;
@@ -816,28 +1162,20 @@ static char kENRMSegmentFadeAnimatorKey;
     _dirtyFlags |= ENRMDirtyRecreateSegments | ENRMDirtyForceHeight | ENRMDirtyRender;
   }
 
-  if (newViewProps.md4cFlags.underline != oldViewProps.md4cFlags.underline) {
-    _md4cFlags.underline = newViewProps.md4cFlags.underline;
-    _dirtyFlags |= ENRMDirtyForceHeight | ENRMDirtyRender;
-  }
-  if (newViewProps.md4cFlags.superscript != oldViewProps.md4cFlags.superscript) {
-    _md4cFlags.superscript = newViewProps.md4cFlags.superscript;
-    _dirtyFlags |= ENRMDirtyForceHeight | ENRMDirtyRender;
-  }
-  if (newViewProps.md4cFlags.subscript != oldViewProps.md4cFlags.subscript) {
-    _md4cFlags.subscript = newViewProps.md4cFlags.subscript;
-    _dirtyFlags |= ENRMDirtyForceHeight | ENRMDirtyRender;
-  }
-  if (newViewProps.md4cFlags.latexMath != oldViewProps.md4cFlags.latexMath) {
-    _md4cFlags.latexMath = newViewProps.md4cFlags.latexMath;
-    _dirtyFlags |= ENRMDirtyForceHeight | 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 = [EnrichedMarkdown flagsFromProps:newViewProps.md4cFlags];
     _dirtyFlags |= ENRMDirtyForceHeight | ENRMDirtyRender;
   }
 
   _enableLinkPreview = newViewProps.enableLinkPreview;
+  _linkLongPressSelects = newViewProps.linkLongPressSelects;
+  _enableTaskListItemToggle = newViewProps.enableTaskListItemToggle;
+  _contextMenuHidden = newViewProps.contextMenuHidden;
 
   if (newViewProps.streamingAnimation != oldViewProps.streamingAnimation) {
     _streamingAnimation = newViewProps.streamingAnimation;
@@ -862,15 +1200,21 @@ static char kENRMSegmentFadeAnimatorKey;
     _dirtyFlags |= ENRMDirtyForceHeight | ENRMDirtyRender;
   }
 
+  if (newViewProps.streamingConfig.codeBlockMode != oldViewProps.streamingConfig.codeBlockMode) {
+    NSString *codeBlockModeStr =
+        [[NSString alloc] initWithUTF8String:newViewProps.streamingConfig.codeBlockMode.c_str()];
+    _codeBlockStreamingMode = [codeBlockModeStr isEqualToString:@"hidden"] ? ENRMCodeBlockStreamingModeHidden
+                                                                           : ENRMCodeBlockStreamingModeProgressive;
+    _dirtyFlags |= ENRMDirtyForceHeight | ENRMDirtyRender;
+  }
+
   if (ENRMContextMenuItemsChanged(oldViewProps.contextMenuItems, newViewProps.contextMenuItems)) {
     _contextMenuItemTexts = ENRMContextMenuTextsFromItems(newViewProps.contextMenuItems);
     _contextMenuItemIcons = ENRMContextMenuIconsFromItems(newViewProps.contextMenuItems);
   }
 
   _selectionMenuLabels = ENRMParseSelectionMenuLabels(newViewProps.selectionMenuConfig);
-  _selectionMenuConfig =
-      ENRMBuildSelectionMenuConfig(_selectionMenuLabels, newViewProps.selectionMenuConfig.copyAsMarkdown,
-                                   newViewProps.selectionMenuConfig.copyImageUrl);
+  _selectionMenuConfig = ENRMBuildSelectionMenuConfig(_selectionMenuLabels, newViewProps.selectionMenuConfig);
   [self pushSelectionMenuLabelsToSegments];
 
   if (ENRMAccessibilityLabelsChanged(oldViewProps.accessibilityLabels, newViewProps.accessibilityLabels)) {
@@ -964,7 +1308,8 @@ static char kENRMSegmentFadeAnimatorKey;
 
 - (void)prepareForRecycle
 {
-  _props = std::make_shared<const EnrichedMarkdownProps>();
+  const auto resetProps = std::make_shared<const EnrichedMarkdownProps>();
+  _props = resetProps;
   [_renderCoordinator invalidate];
 
   for (RCTUIView *segment in _segmentViews) {
@@ -982,8 +1327,39 @@ static char kENRMSegmentFadeAnimatorKey;
 
   _cachedMarkdown = nil;
   _renderedMarkdown = nil;
+  _config = nil;
+  _emitLinkLayout = NO;
+  _lastLinkLayout = nil;
+  _selectionReporter.enabled = NO;
+#if !TARGET_OS_OSX
+  [_selectionGestures reset];
+#endif
+  _selectionOwner = nil;
+  [self clearActiveBlock];
+  _md4cFlags = [EnrichedMarkdown flagsFromProps:resetProps->md4cFlags];
+  _maxFontSizeMultiplier = 0;
+  _allowTrailingMargin = NO;
+  _streamingAnimation = NO;
+  _tableStreamingMode = ENRMTableStreamingModeProgressive;
+  _codeBlockStreamingMode = ENRMCodeBlockStreamingModeProgressive;
+  _pendingCodeBlockSegment = nil;
+  _lineBreakStrategy = NSLineBreakStrategyNone;
+  _writingDirectionMode = ENRMWritingDirectionModeFirstStrong;
+  _renderedStyleFingerprint = 0;
+  _pendingStyleFingerprint = 0;
+  _contextMenuItemTexts = nil;
+  _contextMenuItemIcons = nil;
+  _fontScaleObserver.allowFontScaling = resetProps->allowFontScaling;
+  _accessibilityLabels = nil;
+  _spoilerOverlay =
+      ENRMSpoilerOverlayFromString([[NSString alloc] initWithUTF8String:resetProps->spoilerOverlay.c_str()]);
+  _dirtyFlags = ENRMDirtyNone;
 
-  [self resetPropDerivedState];
+  // 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];
 }
@@ -1070,6 +1446,40 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownCls(void)
     emitter->onLinkPress({.url = std::string(url.UTF8String)});
 }
 
+/// Reports link rects of every text segment (offset by the segment origin) to
+/// JS for `renderLinkDecoration`. Tables are skipped: their cells scroll
+/// horizontally, so rects would go stale. Runs after each segment layout pass;
+/// deduplicated so an unchanged layout sends nothing.
+- (void)emitLinkLayoutIfNeeded
+{
+  if (!_emitLinkLayout || self.bounds.size.width <= 0)
+    return;
+
+  auto emitter = std::static_pointer_cast<EnrichedMarkdownEventEmitter const>(_eventEmitter);
+  if (!emitter)
+    return;
+
+  NSMutableArray<NSDictionary *> *fragments = [NSMutableArray array];
+  NSInteger linkCount = 0;
+  for (RCTUIView *segment in _segmentViews) {
+    if ([segment isKindOfClass:[TableContainerView class]]) {
+      linkCount += ((TableContainerView *)segment).linkCount;
+      continue;
+    }
+    if (![segment isKindOfClass:[EnrichedMarkdownInternalText class]])
+      continue;
+    NSInteger segmentLinks = 0;
+    [fragments addObjectsFromArray:ENRMCollectLinkLayoutFragments(((EnrichedMarkdownInternalText *)segment).textView,
+                                                                  segment.frame.origin, linkCount, &segmentLinks)];
+    linkCount += segmentLinks;
+  }
+
+  if (_lastLinkLayout != nil && [fragments isEqualToArray:_lastLinkLayout])
+    return;
+  _lastLinkLayout = [fragments copy];
+  emitter->onLinkLayout(ENRMLinkLayoutEventFromFragments<EnrichedMarkdownEventEmitter::OnLinkLayout>(fragments));
+}
+
 - (void)emitLinkLongPress:(NSString *)url
 {
   auto emitter = std::static_pointer_cast<EnrichedMarkdownEventEmitter const>(_eventEmitter);
@@ -1084,6 +1494,26 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownCls(void)
     emitter->onTaskListItemPress({.index = (int)index, .checked = checked, .text = std::string(text.UTF8String ?: "")});
 }
 
+- (void)emitCopyPress:(NSString *)code language:(NSString *)language
+{
+  auto emitter = std::static_pointer_cast<EnrichedMarkdownEventEmitter const>(_eventEmitter);
+  if (emitter)
+    emitter->onCopyPress(
+        {.code = std::string(code.UTF8String ?: ""), .language = std::string(language.UTF8String ?: "")});
+}
+
+- (void)emitCopyRequest:(NSString *)source markdown:(NSString *)markdown text:(NSString *)text whole:(BOOL)whole
+{
+  auto emitter = std::static_pointer_cast<EnrichedMarkdownEventEmitter const>(_eventEmitter);
+  if (emitter)
+    emitter->onCopyRequest({
+        .source = std::string(source.UTF8String),
+        .markdown = std::string(markdown.UTF8String ?: ""),
+        .text = std::string(text.UTF8String ?: ""),
+        .whole = (bool)whole,
+    });
+}
+
 - (void)emitContextMenuItemPress:(NSString *)itemText
                     selectedText:(NSString *)selectedText
                   selectionStart:(NSUInteger)selectionStart
@@ -1103,7 +1533,8 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownCls(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];
@@ -1126,12 +1557,37 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownCls(void)
   ENRMHandleTapOnTextView(textView, recognizer, ^(NSString *url) { [self emitLinkPress:url]; });
 }
 
+#if !TARGET_OS_OSX
+- (void)textViewDidChangeSelection:(UITextView *)textView
+{
+  [_selectionGestures trackTextView:textView];
+  ENRMDismissSelectionEditMenuIfMoved(textView);
+  if (textView.selectedRange.length > 0) {
+    // Take ownership first so the previous owner's own "cleared" callback is ignored.
+    ENRMPlatformTextView *previous = _selectionOwner;
+    _selectionOwner = textView;
+    [self clearActiveBlock];
+    if (previous && previous != textView)
+      previous.selectedRange = NSMakeRange(0, 0);
+    [_selectionReporter schedule];
+  } else if (textView == _selectionOwner) {
+    [_selectionReporter selectionChanged:NO];
+  }
+}
+#endif
+
 // TODO: Remove API_AVAILABLE(ios(16.0)) guard when the minimum iOS deployment target in RN is bumped to 16.
 #if !TARGET_OS_OSX
 - (UIMenu *)textView:(UITextView *)textView
     editMenuForTextInRange:(NSRange)range
           suggestedActions:(NSArray<UIMenuElement *> *)suggestedActions API_AVAILABLE(ios(16.0))
 {
+  // An empty menu presents nothing; nil would make UIKit show its default menu
+  // (the selection and handles stay either way).
+  if (_contextMenuHidden) {
+    return [UIMenu menuWithChildren:@[]];
+  }
+
   __weak EnrichedMarkdown *weakSelf = self;
   ENRMContextMenuPressHandler handler =
       ^(NSString *itemText, NSString *selectedText, NSUInteger selectionStart, NSUInteger selectionEnd) {
@@ -1146,8 +1602,47 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownCls(void)
       ENRMBuildContextMenuActions(_contextMenuItemTexts, _contextMenuItemIcons, textView, range, handler);
 
   NSString *segmentMarkdown = extractMarkdownFromAttributedString(textView.attributedText, range);
+
+  // Segments only see their own text, so a selection is the whole component
+  // only when it spans the sole segment; the markdown is then the original.
+  ENRMCopyRequestHandler onCopyRequest = ^(NSString *markdown, NSString *text, BOOL fullSelection) {
+    EnrichedMarkdown *strongSelf = weakSelf;
+    if (!strongSelf)
+      return;
+    BOOL whole = fullSelection && strongSelf->_segmentViews.count == 1 && strongSelf->_cachedMarkdown.length > 0;
+    [strongSelf emitCopyRequest:@"selection"
+                       markdown:whole ? strongSelf->_cachedMarkdown : markdown
+                           text:text
+                          whole:whole];
+  };
+
   return buildEditMenuForSelection(textView.attributedText, range, segmentMarkdown, _config, suggestedActions,
-                                   customActions, _selectionMenuConfig);
+                                   customActions, _selectionMenuConfig, onCopyRequest);
+}
+
+// Attachments other than images (inline math) are text, not items: without
+// this a long press on one in an unfocused text view starts UIKit's text item
+// interaction, which presents nothing and leaves the view unable to select.
+- (BOOL)textView:(UITextView *)textView
+    shouldInteractWithTextAttachment:(NSTextAttachment *)textAttachment
+                             inRange:(NSRange)characterRange
+                         interaction:(UITextItemInteraction)interaction
+{
+  if ([textAttachment isKindOfClass:[ENRMImageAttachment class]]) {
+    return YES;
+  }
+  // A long press selects the attachment like a word, as it does once the view is focused.
+  if (interaction == UITextItemInteractionPresentActions) {
+    __weak UITextView *weakTextView = textView;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      UITextView *strongTextView = weakTextView;
+      if (!strongTextView || NSMaxRange(characterRange) > strongTextView.attributedText.length) {
+        return;
+      }
+      ENRMSelectRangeAndPresentEditMenu(strongTextView, characterRange);
+    });
+  }
+  return NO;
 }
 
 - (BOOL)textView:(UITextView *)textView
@@ -1161,6 +1656,18 @@ Class<RCTComponentViewProtocol> EnrichedMarkdownCls(void)
 
   NSString *urlString = linkURLAtRange(textView, characterRange);
 
+  if (urlString && _linkLongPressSelects) {
+    __weak UITextView *weakTextView = textView;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      UITextView *strongTextView = weakTextView;
+      if (!strongTextView || NSMaxRange(characterRange) > strongTextView.attributedText.length) {
+        return;
+      }
+      ENRMSelectRangeAndPresentEditMenu(strongTextView, characterRange);
+    });
+    return NO;
+  }
+
   if (!urlString || _enableLinkPreview) {
     return YES;
   }