@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.9

package/ios/utils/TiptapExtractor.m

@@ -0,0 +1,367 @@
+#import "TiptapExtractor.h"
+#import "BaselineShiftTextAttributes.h"
+#import "BlockquoteBorder.h"
+#import "CodeBackground.h"
+#import "ENRMFeatureFlags.h"
+#import "ENRMImageAttachment.h"
+#import "ENRMLinkPillText.h"
+#import "ENRMTextLinkAttributes.h"
+#import "ENRMUIKit.h"
+#import "HighlightRenderer.h"
+#include <TargetConditionals.h>
+#if ENRICHED_TIPTAP_MATH
+#import "ENRMMathInlineAttachment.h"
+#endif
+#import "LastElementUtils.h"
+#import "ListItemRenderer.h"
+#import "RuntimeKeys.h"
+#import "ThematicBreakAttachment.h"
+
+#pragma mark - Extraction Context
+
+typedef struct {
+  NSInteger blockquoteDepth; // -1 = not in blockquote
+  NSInteger listDepth;       // -1 = not in list
+  BOOL needsBlankLine;
+} ExtractionState;
+
+#pragma mark - Helper Functions
+
+static void ensureBlankLine(NSMutableString *result)
+{
+  if (result.length == 0)
+    return;
+  if ([result hasSuffix:@"\n\n"])
+    return;
+
+  [result appendString:[result hasSuffix:@"\n"] ? @"\n" : @"\n\n"];
+}
+
+static BOOL isAtLineStart(NSMutableString *result)
+{
+  return result.length == 0 || [result hasSuffix:@"\n"];
+}
+
+/// Depth 0 = "> ", Depth 1 = "> > ", etc.
+static NSString *buildBlockquotePrefix(NSInteger depth)
+{
+  NSMutableString *prefix = [NSMutableString string];
+  for (NSInteger i = 0; i <= depth; i++) {
+    [prefix appendString:@"> "];
+  }
+  return prefix;
+}
+
+static NSString *buildListPrefix(NSInteger depth, BOOL isOrdered, NSInteger itemNumber)
+{
+  NSString *indent = [@"" stringByPaddingToLength:(depth * 2) withString:@" " startingAtIndex:0];
+  NSString *marker = isOrdered ? [NSString stringWithFormat:@"%ld.", (long)itemNumber] : @"-";
+  return [NSString stringWithFormat:@"%@%@ ", indent, marker];
+}
+
+static NSString *buildHeadingPrefix(NSInteger level)
+{
+  return [NSString stringWithFormat:@"%@ ", [@"" stringByPaddingToLength:level withString:@"#" startingAtIndex:0]];
+}
+
+static void extractFontTraits(NSDictionary *attrs, BOOL *isBold, BOOL *isItalic, BOOL *isMonospace)
+{
+  UIFont *font = attrs[NSFontAttributeName];
+  *isBold = NO;
+  *isItalic = NO;
+  *isMonospace = NO;
+
+  if (font) {
+    UIFontDescriptorSymbolicTraits traits = font.fontDescriptor.symbolicTraits;
+    *isBold = (traits & UIFontDescriptorTraitBold) != 0;
+    *isItalic = (traits & UIFontDescriptorTraitItalic) != 0;
+#if !TARGET_OS_OSX
+    *isMonospace = (traits & UIFontDescriptorTraitMonoSpace) != 0;
+#else
+    *isMonospace = (traits & NSFontDescriptorTraitMonoSpace) != 0;
+#endif
+  }
+}
+
+static NSString *applyInlineFormatting(NSString *text, BOOL isBold, BOOL isItalic, BOOL isMonospace,
+                                       BOOL isStrikethrough, BOOL isUnderline, BOOL isSuperscript, BOOL isSubscript,
+                                       BOOL isHighlight, NSString *linkURL)
+{
+  NSMutableString *result = [NSMutableString stringWithString:text];
+
+  // Innermost first
+  if (isMonospace && !linkURL) {
+    result = [NSMutableString stringWithFormat:@"`%@`", result];
+  }
+  if (isStrikethrough) {
+    result = [NSMutableString stringWithFormat:@"~~%@~~", result];
+  }
+  if (isSubscript) {
+    result = [NSMutableString stringWithFormat:@"~%@~", result];
+  }
+  if (isSuperscript) {
+    result = [NSMutableString stringWithFormat:@"^%@^", result];
+  }
+  if (isUnderline && !linkURL) {
+    result = [NSMutableString stringWithFormat:@"<u>%@</u>", result];
+  }
+  if (isItalic) {
+    result = [NSMutableString stringWithFormat:@"*%@*", result];
+  }
+  if (isBold) {
+    result = [NSMutableString stringWithFormat:@"**%@**", result];
+  }
+  if (linkURL) {
+    result = [NSMutableString stringWithFormat:@"[%@](%@)", result, linkURL];
+  }
+  if (isHighlight) {
+    result = [NSMutableString stringWithFormat:@"==%@==", result];
+  }
+
+  return result;
+}
+
+#pragma mark - Main Extraction Function
+
+NSString *_Nullable extractTiptapFromAttributedString(NSAttributedString *attributedText, NSRange range)
+{
+  if (!attributedText || range.length == 0 || range.location >= attributedText.length) {
+    return nil;
+  }
+
+  range.length = MIN(range.length, attributedText.length - range.location);
+  attributedText = ENRMAttributedStringByExpandingLinkPills(attributedText, &range);
+
+  NSMutableString *result = [NSMutableString string];
+
+  // Headings may span multiple attribute runs
+  __block NSString *currentHeadingType = nil;
+  __block NSMutableString *headingContent = nil;
+  __block ExtractionState state = {.blockquoteDepth = -1, .listDepth = -1, .needsBlankLine = NO};
+
+  void (^flushHeading)(void) = ^{
+    if (!currentHeadingType || headingContent.length == 0)
+      return;
+
+    ensureBlankLine(result);
+    NSInteger level = [[currentHeadingType substringFromIndex:8] integerValue];
+    [result appendFormat:@"%@%@\n", buildHeadingPrefix(level), headingContent];
+
+    currentHeadingType = nil;
+    headingContent = nil;
+    state.needsBlankLine = YES;
+  };
+
+  [attributedText
+      enumerateAttributesInRange:range
+                         options:0
+                      usingBlock:^(NSDictionary<NSAttributedStringKey, id> *attrs, NSRange attrRange, BOOL *stop) {
+                        NSString *text = [[attributedText attributedSubstringFromRange:attrRange] string];
+                        if (text.length == 0)
+                          return;
+
+                        // Images and Thematic Breaks
+                        NSTextAttachment *attachment = attrs[NSAttachmentAttributeName];
+                        if ([attachment isKindOfClass:[ENRMImageAttachment class]]) {
+                          ENRMImageAttachment *img = (ENRMImageAttachment *)attachment;
+                          if (!img.imageURL)
+                            return;
+
+                          if (img.isInline) {
+                            [result appendFormat:@"![image](%@)", img.imageURL];
+                          } else {
+                            ensureBlankLine(result);
+                            [result appendFormat:@"![image](%@)\n", img.imageURL];
+                            state.needsBlankLine = YES;
+                            state.blockquoteDepth = -1;
+                            state.listDepth = -1;
+                          }
+                          return;
+                        }
+
+                        if ([attachment isKindOfClass:[ThematicBreakAttachment class]]) {
+                          ensureBlankLine(result);
+                          [result appendString:@"---\n"];
+                          state.needsBlankLine = YES;
+                          state.blockquoteDepth = -1;
+                          state.listDepth = -1;
+                          return;
+                        }
+
+#if ENRICHED_TIPTAP_MATH
+                        if ([attachment isKindOfClass:[ENRMMathInlineAttachment class]]) {
+                          ENRMMathInlineAttachment *math = (ENRMMathInlineAttachment *)attachment;
+                          if (math.latex.length > 0) {
+                            [result appendFormat:@"$%@$", math.latex];
+                          }
+                          return;
+                        }
+#endif
+
+                        if ([text isEqualToString:@"\uFFFC"])
+                          return;
+
+                        // Newlines
+                        if ([text isEqualToString:@"\n"] || [text isEqualToString:@"\n\n"]) {
+                          NSNumber *bqDepth = attrs[BlockquoteDepthAttributeName];
+                          NSNumber *listDepth = attrs[ListDepthAttribute];
+                          BOOL inBlockquote = (bqDepth != nil);
+                          BOOL inList = (listDepth != nil);
+
+                          if (!inBlockquote && state.blockquoteDepth >= 0) {
+                            ensureBlankLine(result);
+                            state.blockquoteDepth = -1;
+                            return;
+                          }
+
+                          if (!inList && state.listDepth >= 0) {
+                            ensureBlankLine(result);
+                            state.listDepth = -1;
+                            return;
+                          }
+
+                          if (inBlockquote || inList) {
+                            if (![result hasSuffix:@"\n"]) {
+                              [result appendString:@"\n"];
+                            }
+                            return;
+                          }
+
+                          ensureBlankLine(result);
+                          return;
+                        }
+
+                        // Headings
+                        NSString *tiptapType = attrs[TiptapTypeAttributeName];
+
+                        if (tiptapType && [tiptapType hasPrefix:@"heading-"]) {
+                          if (![tiptapType isEqualToString:currentHeadingType]) {
+                            flushHeading();
+                            currentHeadingType = tiptapType;
+                            headingContent = [NSMutableString string];
+                          }
+                          [headingContent
+                              appendString:[text stringByTrimmingCharactersInSet:[NSCharacterSet newlineCharacterSet]]];
+                          return;
+                        } else if (currentHeadingType) {
+                          flushHeading();
+                        }
+
+                        // Code blocks
+                        NSNumber *isCodeBlock = attrs[CodeBlockAttributeName];
+                        if ([isCodeBlock boolValue]) {
+                          if (state.needsBlankLine) {
+                            ensureBlankLine(result);
+                            state.needsBlankLine = NO;
+                          }
+
+                          BOOL needsFence = (result.length == 0) || [result hasSuffix:@"\n\n"];
+                          if (needsFence) {
+                            [result appendString:@"```\n"];
+                          }
+
+                          [result appendString:text];
+
+                          if ([text hasSuffix:@"\n"]) {
+                            [result appendString:@"```\n"];
+                            state.needsBlankLine = YES;
+                          }
+                          return;
+                        }
+
+                        // Blockquotes
+                        NSNumber *bqDepthNum = attrs[BlockquoteDepthAttributeName];
+                        NSInteger currentBqDepth = bqDepthNum ? [bqDepthNum integerValue] : -1;
+                        NSString *blockquotePrefix = nil;
+
+                        if (currentBqDepth >= 0) {
+                          blockquotePrefix = buildBlockquotePrefix(currentBqDepth);
+                          state.blockquoteDepth = currentBqDepth;
+                        } else if (state.blockquoteDepth >= 0) {
+                          ensureBlankLine(result);
+                          state.blockquoteDepth = -1;
+                        }
+
+                        // Lists
+                        NSNumber *listDepthNum = attrs[ListDepthAttribute];
+                        NSNumber *listTypeNum = attrs[ListTypeAttribute];
+                        NSNumber *listItemNum = attrs[ListItemNumberAttribute];
+                        BOOL isTaskItem = [attrs[TaskItemAttribute] boolValue];
+                        BOOL isTaskChecked = [attrs[TaskCheckedAttribute] boolValue];
+                        NSInteger currentListDepth = listDepthNum ? [listDepthNum integerValue] : -1;
+
+                        if (currentListDepth >= 0) {
+                          state.listDepth = currentListDepth;
+                        } else if (state.listDepth >= 0) {
+                          ensureBlankLine(result);
+                          state.listDepth = -1;
+                        }
+
+                        // Inline formatting
+                        BOOL isBold, isItalic, isMonospace;
+                        BOOL recognizedLink = [attrs[ENRMRecognizedLinkAttributeName] boolValue];
+                        extractFontTraits(attrs, &isBold, &isItalic, &isMonospace);
+                        if (recognizedLink)
+                          isMonospace = [attrs[CodeAttributeName] boolValue];
+
+                        NSNumber *strikethroughStyle = attrs[NSStrikethroughStyleAttributeName];
+                        BOOL isStrikethrough = (strikethroughStyle != nil && [strikethroughStyle integerValue] != 0);
+                        NSNumber *underlineStyle = recognizedLink
+                                                       ? attrs[ENRMRecognizedLinkOriginalUnderlineAttributeName]
+                                                       : attrs[NSUnderlineStyleAttributeName];
+                        BOOL isUnderline = (underlineStyle != nil && [underlineStyle integerValue] != 0);
+                        // Line-height alignment also shifts baselines. Only semantic script spans
+                        // should produce superscript/subscript Tiptap on the clipboard.
+                        NSString *script = attrs[ENRMScriptAttributeName];
+                        BOOL isSuperscript = [script isEqualToString:ENRMScriptValueSuperscript];
+                        BOOL isSubscript = [script isEqualToString:ENRMScriptValueSubscript];
+
+                        BOOL isHighlight = [attrs[HighlightAttributeName] boolValue];
+                        NSString *linkURL = recognizedLink ? nil : attrs[NSLinkAttributeName];
+                        NSString *segment =
+                            applyInlineFormatting(text, isBold, isItalic, isMonospace, isStrikethrough, isUnderline,
+                                                  isSuperscript, isSubscript, isHighlight, linkURL);
+
+                        // Add block prefixes at line start
+                        if (isAtLineStart(result)) {
+                          NSMutableString *prefixedSegment = [NSMutableString string];
+
+                          if (listDepthNum && ![text hasPrefix:@"\n"]) {
+                            if (isTaskItem) {
+                              NSString *indent = [@"" stringByPaddingToLength:(currentListDepth * 2)
+                                                                   withString:@" "
+                                                              startingAtIndex:0];
+                              NSString *checkbox = isTaskChecked ? @"[x]" : @"[ ]";
+                              [prefixedSegment appendFormat:@"%@- %@ ", indent, checkbox];
+                            } else {
+                              BOOL isOrdered = ([listTypeNum integerValue] == 1);
+                              NSInteger itemNumber = listItemNum ? [listItemNum integerValue] : 1;
+                              [prefixedSegment appendString:buildListPrefix(currentListDepth, isOrdered, itemNumber)];
+                            }
+                          }
+
+                          if (blockquotePrefix) {
+                            [prefixedSegment insertString:blockquotePrefix atIndex:0];
+                          }
+
+                          [prefixedSegment appendString:segment];
+                          segment = prefixedSegment;
+                        }
+
+                        if (state.needsBlankLine && result.length > 0) {
+                          ensureBlankLine(result);
+                          state.needsBlankLine = NO;
+                        }
+
+                        [result appendString:segment];
+                      }];
+
+  // Flush remaining heading
+  if (currentHeadingType && headingContent.length > 0) {
+    ensureBlankLine(result);
+    NSInteger level = [[currentHeadingType substringFromIndex:8] integerValue];
+    [result appendFormat:@"%@%@\n", buildHeadingPrefix(level), headingContent];
+  }
+
+  return result.length > 0 ? result : nil;
+}

package/ios/views/ENRMTiptapTextView.h

@@ -0,0 +1,25 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+#import "ENRMLinkContextMenus.h"
+
+#if !TARGET_OS_OSX
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * The read-only text view tiptap renders into. A link pill is one placeholder character
+ * in text storage; what the system reads for the selection (Look Up, Translate, Share,
+ * drag, the Copy key command) is answered here with the link text the pill stands for.
+ *
+ * It also presents the menu of a pill that has one, taken from a delegate that is an
+ * `ENRMLinkContextMenuSource`: UIKit lifts a pressed text item on a tinted box of its own,
+ * which hides the pill's look.
+ */
+@interface ENRMTiptapTextView : UITextView <ENRMLinkMenuPresenting>
+/// Copies a selection the way the menu Copy does. Set by the hosting view, which knows the
+/// source Tiptap and style; without it the Copy key command writes plain text and RTF only.
+@property (nonatomic, copy, nullable) void (^copySelectionHandler)(NSRange selectedRange);
+@end
+
+NS_ASSUME_NONNULL_END
+#endif

package/ios/views/ENRMTiptapTextView.m

@@ -0,0 +1,247 @@
+#import "ENRMTiptapTextView.h"
+#import "ENRMLinkPillAttachment.h"
+#import "ENRMLinkPillText.h"
+#import "ENRMTextHitTest.h"
+#import "LinkTapUtils.h"
+#import "PasteboardUtils.h"
+
+#if !TARGET_OS_OSX
+@interface ENRMTiptapTextView () <UIContextMenuInteractionDelegate>
+@end
+
+@implementation ENRMTiptapTextView {
+  ENRMLinkMenuLift *_pillLift;
+  // The pill whose menu is being presented. It draws nothing for as long as its lifted image
+  // stands in for it: it would show through that image.
+  ENRMLinkPillAttachment *_liftedPill;
+  NSUInteger _pillMenuIndex;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame textContainer:(NSTextContainer *)textContainer
+{
+  if (self = [super initWithFrame:frame textContainer:textContainer]) {
+    _pillLift = [[ENRMLinkMenuLift alloc] init];
+    __weak ENRMTiptapTextView *weakSelf = self;
+    _pillLift.onEnd = ^{ [weakSelf restoreLiftedPill]; };
+    [self addInteraction:[[UIContextMenuInteraction alloc] initWithDelegate:self]];
+  }
+  return self;
+}
+
+/// A tap places the caret, and UITextView then scrolls that caret into view. This view is
+/// already sized to its text and sits in the screen's scroll view, so that scroll shifts
+/// the page and the tapped line jumps toward the top. Scrolling stays off, and these
+/// requests are dropped. Copy and selection are unchanged.
+- (void)setContentOffset:(CGPoint)contentOffset
+{
+  if (!self.scrollEnabled && !CGPointEqualToPoint(contentOffset, CGPointZero)) {
+    if (!CGPointEqualToPoint(self.contentOffset, CGPointZero)) {
+      [super setContentOffset:CGPointZero];
+    }
+    return;
+  }
+  [super setContentOffset:contentOffset];
+}
+
+- (void)setContentOffset:(CGPoint)contentOffset animated:(BOOL)animated
+{
+  if (!self.scrollEnabled) {
+    [self setContentOffset:CGPointZero];
+    return;
+  }
+  [super setContentOffset:contentOffset animated:animated];
+}
+
+- (void)scrollRangeToVisible:(NSRange)range
+{
+  if (self.scrollEnabled)
+    [super scrollRangeToVisible:range];
+}
+
+- (void)scrollRectToVisible:(CGRect)rect animated:(BOOL)animated
+{
+  if (self.scrollEnabled)
+    [super scrollRectToVisible:rect animated:animated];
+}
+
+/// New text moves or replaces the pill under its lifted image.
+- (void)setAttributedText:(NSAttributedString *)attributedText
+{
+  [_pillLift end];
+  [super setAttributedText:attributedText];
+}
+
+/// The selection with pills expanded, or nil when `range` is not the selection or holds no pill.
+/// Only the selection is rewritten: UIKit also reads arbitrary ranges to find word boundaries,
+/// and those must keep matching storage offsets.
+- (nullable NSAttributedString *)expandedSelectionForRange:(UITextRange *)range
+{
+  UITextRange *selection = self.selectedTextRange;
+  if (!range || !selection || selection.isEmpty || ![range isEqual:selection])
+    return nil;
+  NSRange selected = self.selectedRange;
+  NSTextStorage *storage = self.textStorage;
+  if (selected.location == NSNotFound || NSMaxRange(selected) > storage.length)
+    return nil;
+  NSAttributedString *text = [storage attributedSubstringFromRange:selected];
+  NSAttributedString *expanded = ENRMAttributedStringByExpandingLinkPills(text, NULL);
+  return expanded == text ? nil : expanded;
+}
+
+- (NSString *)textInRange:(UITextRange *)range
+{
+  return [self expandedSelectionForRange:range].string ?: [super textInRange:range];
+}
+
+- (NSAttributedString *)attributedTextInRange:(UITextRange *)range
+{
+  return [self expandedSelectionForRange:range] ?: [super attributedTextInRange:range];
+}
+
+/// The menu's Copy is already replaced by the library's own action; this covers the key command.
+- (void)copy:(id)sender
+{
+  NSRange selected = self.selectedRange;
+  if (self.copySelectionHandler && selected.location != NSNotFound && selected.length > 0) {
+    self.copySelectionHandler(selected);
+    return;
+  }
+  NSAttributedString *expanded = [self expandedSelectionForRange:self.selectedTextRange];
+  if (!expanded) {
+    [super copy:sender];
+    return;
+  }
+  copyAttributedStringToPasteboard(expanded, nil, nil);
+}
+
+#pragma mark - Pill menus
+
+- (nullable ENRMLinkContextMenus *)linkContextMenus
+{
+  id delegate = self.delegate;
+  return [delegate conformsToProtocol:@protocol(ENRMLinkContextMenuSource)]
+             ? [(id<ENRMLinkContextMenuSource>)delegate linkContextMenusForTextView:self]
+             : nil;
+}
+
+/// Where the pill at `index` is drawn, in the text view's coordinates.
+- (CGRect)pillFrameAtIndex:(NSUInteger)index
+{
+  NSLayoutManager *layoutManager = self.layoutManager;
+  NSUInteger glyph = [layoutManager glyphIndexForCharacterAtIndex:index];
+  CGSize size = [layoutManager attachmentSizeForGlyphAtIndex:glyph];
+  if (size.width <= 0 || size.height <= 0)
+    return CGRectNull;
+  CGRect line = [layoutManager lineFragmentRectForGlyphAtIndex:glyph effectiveRange:NULL];
+  // TextKit places an attachment glyph at the bottom edge of its bounds.
+  CGPoint location = [layoutManager locationForGlyphAtIndex:glyph];
+  UIEdgeInsets inset = self.textContainerInset;
+  return CGRectMake(inset.left + line.origin.x + location.x, inset.top + line.origin.y + location.y - size.height,
+                    size.width, size.height);
+}
+
+/// Whether the character at `index` is a pill whose link has a menu.
+- (BOOL)presentsLinkMenuAtIndex:(NSUInteger)index
+{
+  ENRMLinkContextMenus *menus = [self linkContextMenus];
+  NSTextStorage *storage = self.textStorage;
+  if (menus.entries.count == 0 || index >= storage.length)
+    return NO;
+  id attachment = [storage attribute:NSAttachmentAttributeName atIndex:index effectiveRange:NULL];
+  return [attachment isKindOfClass:ENRMLinkPillAttachment.class] &&
+         [menus hasMenuForURL:linkURLAtRange(self, NSMakeRange(index, 1))];
+}
+
+/// The character index of the pill under `point` when its link has a menu, else NSNotFound.
+- (NSUInteger)menuPillIndexAtPoint:(CGPoint)point
+{
+  if ([self linkContextMenus].entries.count == 0)
+    return NSNotFound;
+  NSUInteger index = ENRMCharacterIndexAtPoint(self, point);
+  if (index == NSNotFound || ![self presentsLinkMenuAtIndex:index] ||
+      !CGRectContainsPoint([self pillFrameAtIndex:index], point))
+    return NSNotFound;
+  return index;
+}
+
+- (void)setPill:(ENRMLinkPillAttachment *)pill lifted:(BOOL)lifted
+{
+  pill.lifted = lifted;
+  NSTextStorage *storage = self.textStorage;
+  [storage enumerateAttribute:NSAttachmentAttributeName
+                      inRange:NSMakeRange(0, storage.length)
+                      options:0
+                   usingBlock:^(id value, NSRange range, BOOL *stop) {
+                     if (value != pill)
+                       return;
+                     [self.layoutManager invalidateDisplayForCharacterRange:range];
+                     *stop = YES;
+                   }];
+}
+
+- (void)restoreLiftedPill
+{
+  if (_liftedPill)
+    [self setPill:_liftedPill lifted:NO];
+  _liftedPill = nil;
+}
+
+- (UIContextMenuConfiguration *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+                        configurationForMenuAtLocation:(CGPoint)location
+{
+  [_pillLift end];
+  _pillMenuIndex = [self menuPillIndexAtPoint:location];
+  if (_pillMenuIndex == NSNotFound)
+    return nil;
+  UIMenu *menu = [[self linkContextMenus] menuForURL:linkURLAtRange(self, NSMakeRange(_pillMenuIndex, 1))
+                                               title:linkTitleAtIndex(self.textStorage, _pillMenuIndex)];
+  if (!menu)
+    return nil;
+  return [UIContextMenuConfiguration
+      configurationWithIdentifier:nil
+                  previewProvider:nil
+                   actionProvider:^UIMenu *(NSArray<UIMenuElement *> *suggestedActions) { return menu; }];
+}
+
+/// The pill is lifted as an image of itself, see `ENRMLinkMenuLift`.
+- (UITargetedPreview *)pillMenuPreview
+{
+  if (![_pillLift isOverView:self]) {
+    NSTextStorage *storage = self.textStorage;
+    if (self.window == nil || _pillMenuIndex >= storage.length)
+      return nil;
+    id attachment = [storage attribute:NSAttachmentAttributeName atIndex:_pillMenuIndex effectiveRange:NULL];
+    CGRect frame = [self pillFrameAtIndex:_pillMenuIndex];
+    if (![attachment isKindOfClass:ENRMLinkPillAttachment.class] || CGRectIsNull(frame))
+      return nil;
+    UIImage *image = [(ENRMLinkPillAttachment *)attachment imageForBounds:(CGRect){CGPointZero, frame.size}
+                                                            textContainer:self.textContainer
+                                                           characterIndex:_pillMenuIndex];
+    [_pillLift layImage:image atFrame:frame overView:self];
+    _liftedPill = attachment;
+    [self setPill:_liftedPill lifted:YES];
+  }
+  return [_pillLift previewWithCornerRadius:_liftedPill.cornerRadius backgroundColor:UIColor.clearColor];
+}
+
+- (UITargetedPreview *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+    previewForHighlightingMenuWithConfiguration:(UIContextMenuConfiguration *)configuration
+{
+  return [self pillMenuPreview];
+}
+
+- (UITargetedPreview *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+    previewForDismissingMenuWithConfiguration:(UIContextMenuConfiguration *)configuration
+{
+  return [self pillMenuPreview];
+}
+
+- (void)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+       willEndForConfiguration:(UIContextMenuConfiguration *)configuration
+                      animator:(id<UIContextMenuInteractionAnimating>)animator
+{
+  [_pillLift endWithAnimator:animator];
+}
+
+@end
+#endif