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

package/ios/attachments/ENRMLinkPillAttachment.m

@@ -0,0 +1,324 @@
+#import "ENRMLinkPillAttachment.h"
+#import "ENRMImageAttachment.h"
+#import "ENRMImageDownloader.h"
+#import "ENRMLinkPillIconCache.h"
+#import "ENRMSpoilerTapUtils.h"
+#import "RuntimeKeys.h"
+#import "StyleConfig.h"
+#import <objc/runtime.h>
+
+#if !TARGET_OS_OSX
+
+// The icon occupies a square of the label's font size plus a quarter of it as a gap.
+static const CGFloat kIconSlotRatio = 1.25;
+
+/// Everything that decides what a drawn pill looks like. Streaming re-renders create new
+/// attachments for the same links on every update; keyed like this, they reuse the drawn image.
+@interface ENRMLinkPillAppearance : NSObject
+@property (nonatomic, strong) LinkVariantConfig *variant;
+@property (nonatomic, copy) NSString *label;
+@property (nonatomic, strong) UIFont *font;
+@property (nonatomic, strong, nullable) UIImage *icon;
+@property (nonatomic, strong, nullable) UIColor *iconTint;
+@property (nonatomic, assign) BOOL reservesIconSlot;
+@property (nonatomic, assign) CGSize size;
+@property (nonatomic, assign) UIUserInterfaceStyle interfaceStyle;
+@end
+
+@implementation ENRMLinkPillAppearance
+- (NSUInteger)hash
+{
+  return _label.hash ^ _font.hash ^ (NSUInteger)_variant ^ (NSUInteger)(_size.width * 31 + _size.height);
+}
+
+- (BOOL)isEqual:(id)object
+{
+  if (![object isKindOfClass:ENRMLinkPillAppearance.class])
+    return NO;
+  ENRMLinkPillAppearance *other = object;
+  // The variant and icon are compared by identity: both objects live as long as the style and
+  // the icon cache keep them, and this key retains them, so a match is never a recycled pointer.
+  BOOL sameTint = _iconTint == other->_iconTint || [_iconTint isEqual:other->_iconTint];
+  return _variant == other->_variant && _icon == other->_icon && sameTint &&
+         _reservesIconSlot == other->_reservesIconSlot && _interfaceStyle == other->_interfaceStyle &&
+         CGSizeEqualToSize(_size, other->_size) && [_font isEqual:other->_font] &&
+         [_label isEqualToString:other->_label];
+}
+@end
+
+/// Drawn pills, shared and bounded: the ones on screen are redrawn often, but a long document
+/// holds thousands, each a bitmap of 100 KB or more, so pills must not each keep their own.
+static NSCache<ENRMLinkPillAppearance *, UIImage *> *ENRMRenderedLinkPills(void)
+{
+  static NSCache<ENRMLinkPillAppearance *, UIImage *> *rendered;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    rendered = [NSCache new];
+    rendered.countLimit = 256;
+    rendered.totalCostLimit = 8 * 1024 * 1024;
+  });
+  return rendered;
+}
+
+static UIImage *ENRMClearLinkPillImage(void)
+{
+  static UIImage *clear;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
+    format.opaque = NO;
+    clear = [[[UIGraphicsImageRenderer alloc] initWithSize:CGSizeMake(1, 1) format:format]
+        imageWithActions:^(UIGraphicsImageRendererContext *context){}];
+  });
+  return clear;
+}
+
+/// Streaming renders the same links again on every update; their label widths do not change.
+static CGFloat ENRMLinkPillLabelWidth(NSString *label, UIFont *font)
+{
+  static NSCache<NSString *, NSNumber *> *widths;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    widths = [NSCache new];
+    widths.countLimit = 2048;
+  });
+  NSString *key = [NSString stringWithFormat:@"%@|%.2f|%@", font.fontName, font.pointSize, label];
+  NSNumber *cached = [widths objectForKey:key];
+  if (cached)
+    return cached.doubleValue;
+  CGFloat width = [label sizeWithAttributes:@{NSFontAttributeName : font}].width;
+  [widths setObject:@(width) forKey:key];
+  return width;
+}
+
+@implementation ENRMLinkPillAttachment {
+  LinkVariantConfig *_variant;
+  LinkPillConfig *_pill;
+  UIFont *_font;
+  UIImage *_icon;
+  UIColor *_iconTint;
+  // Space for the icon is held while a remote icon is still loading, so its arrival only needs a redraw.
+  BOOL _reservesIconSlot;
+  __weak NSTextContainer *_textContainer;
+  CGFloat _labelWidth;
+}
+
+- (instancetype)initWithOriginalText:(NSAttributedString *)originalText
+                             variant:(LinkVariantConfig *)variant
+                               label:(NSString *)label
+                             iconUri:(NSString *)iconUri
+                       iconTintColor:(UIColor *)iconTintColor
+                                font:(UIFont *)font
+                      requestHeaders:(NSDictionary<NSString *, NSString *> *)requestHeaders
+{
+  self = [super initWithData:nil ofType:nil];
+  if (self) {
+    _variant = variant;
+    _pill = variant.pill;
+    _iconTint = iconTintColor;
+    _originalText = [originalText copy];
+    _font = font ?: [UIFont systemFontOfSize:16];
+    // The pill is a single line; a label supplied by the app may still carry breaks.
+    NSString *visible = label.length > 0 ? label : originalText.string;
+    _label = [[visible componentsSeparatedByCharactersInSet:NSCharacterSet.newlineCharacterSet]
+        componentsJoinedByString:@" "];
+    [self resolveIcon:iconUri requestHeaders:requestHeaders];
+  }
+  return self;
+}
+
+- (void)resolveIcon:(NSString *)iconUri requestHeaders:(NSDictionary<NSString *, NSString *> *)requestHeaders
+{
+  if (iconUri.length == 0)
+    return;
+  _icon = ENRMLoadLinkPillIcon(iconUri) ?: ENRMCachedLinkPillIcon(iconUri, requestHeaders);
+  _reservesIconSlot = _icon != nil;
+  if (_icon || ENRMLinkPillIconDidFail(iconUri, requestHeaders))
+    return;
+  _reservesIconSlot = YES;
+  __weak typeof(self) weakSelf = self;
+  ENRMLoadLinkPillIconAsync(iconUri, requestHeaders, ^(UIImage *icon) { [weakSelf iconDidSettle:icon]; });
+}
+
+- (void)adoptFont:(UIFont *)font
+{
+  if (!font || [font isEqual:_font])
+    return;
+  _font = font;
+  _labelWidth = 0;
+}
+
+- (NSString *)linkAccessibilityLabel
+{
+  NSString *original = _originalText.string;
+  return [_label isEqualToString:original] ? original : [NSString stringWithFormat:@"%@, %@", _label, original];
+}
+
+- (CGFloat)boxHeight
+{
+  return ceil(_font.ascender - _font.descender + 2 * (_pill.paddingVertical + _pill.borderWidth));
+}
+
+- (CGFloat)widthForLimit:(CGFloat)available
+{
+  CGFloat iconWidth = _reservesIconSlot ? _font.pointSize * kIconSlotRatio : 0;
+  if (_labelWidth <= 0)
+    _labelWidth = ENRMLinkPillLabelWidth(_label, _font);
+  CGFloat natural = ceil(_labelWidth + iconWidth + 2 * (_pill.paddingHorizontal + _pill.borderWidth));
+  CGFloat limit = _pill.maxWidth > 0 ? MIN(available, _pill.maxWidth) : available;
+  return MAX(1, MIN(natural, limit));
+}
+
+- (CGRect)attachmentBoundsForTextContainer:(NSTextContainer *)container
+                      proposedLineFragment:(CGRect)lineFragment
+                             glyphPosition:(CGPoint)position
+                            characterIndex:(NSUInteger)characterIndex
+{
+  CGFloat available = CGFLOAT_MAX;
+  if (container) {
+    _textContainer = container;
+    // Use the full container width, not the remainder of the current line. TextKit then moves
+    // the whole attachment to the next line if it doesn't fit the remainder.
+    NSTextStorage *storage = container.layoutManager.textStorage;
+    NSParagraphStyle *paragraph = characterIndex < storage.length ? [storage attribute:NSParagraphStyleAttributeName
+                                                                               atIndex:characterIndex
+                                                                        effectiveRange:NULL]
+                                                                  : nil;
+    CGFloat indent = MAX(paragraph.firstLineHeadIndent, paragraph.headIndent);
+    CGFloat tailInset = paragraph.tailIndent < 0 ? -paragraph.tailIndent : 0;
+    available = MAX(1, container.size.width - 2 * container.lineFragmentPadding - indent - tailInset);
+  } else if (lineFragment.size.width > 0 && lineFragment.size.width < 1e6) {
+    // String drawing (table cells) lays out without a text container.
+    available = lineFragment.size.width;
+  }
+  CGFloat inset = _pill.paddingVertical + _pill.borderWidth;
+  return CGRectMake(0, _font.descender - inset, [self widthForLimit:available], self.boxHeight);
+}
+
+- (CGFloat)cornerRadius
+{
+  return MIN(_pill.borderRadius, self.boxHeight / 2);
+}
+
+- (UIImage *)imageForBounds:(CGRect)bounds textContainer:(NSTextContainer *)container characterIndex:(NSUInteger)index
+{
+  if (bounds.size.width <= 0 || bounds.size.height <= 0)
+    return nil;
+  if (_lifted)
+    return ENRMClearLinkPillImage();
+  if (container) {
+    _textContainer = container;
+    // The spoiler hides text by clearing its color, which this drawing does not use.
+    NSTextStorage *storage = container.layoutManager.textStorage;
+    if (index < storage.length && [storage attribute:SpoilerAttributeName atIndex:index effectiveRange:NULL])
+      return ENRMClearLinkPillImage();
+  }
+  CGSize size = bounds.size;
+  UIUserInterfaceStyle interfaceStyle = UITraitCollection.currentTraitCollection.userInterfaceStyle;
+  ENRMLinkPillAppearance *appearance = [ENRMLinkPillAppearance new];
+  appearance.variant = _variant;
+  appearance.label = _label;
+  appearance.font = _font;
+  appearance.icon = _icon;
+  appearance.iconTint = _iconTint;
+  appearance.reservesIconSlot = _reservesIconSlot;
+  appearance.size = size;
+  appearance.interfaceStyle = interfaceStyle;
+  UIImage *rendered = [ENRMRenderedLinkPills() objectForKey:appearance];
+  if (rendered)
+    return rendered;
+
+  UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
+  format.opaque = NO;
+  UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:size format:format];
+  UIImage *image = [renderer imageWithActions:^(UIGraphicsImageRendererContext *context) {
+    CGRect rect = (CGRect){CGPointZero, size};
+    UIBezierPath *background = [UIBezierPath bezierPathWithRoundedRect:rect cornerRadius:_pill.borderRadius];
+    [_variant.backgroundColor ?: UIColor.clearColor setFill];
+    [background fill];
+    if (_pill.borderWidth > 0) {
+      UIBezierPath *border =
+          [UIBezierPath bezierPathWithRoundedRect:CGRectInset(rect, _pill.borderWidth / 2, _pill.borderWidth / 2)
+                                     cornerRadius:_pill.borderRadius];
+      border.lineWidth = _pill.borderWidth;
+      [_pill.borderColor setStroke];
+      [border stroke];
+    }
+    [background addClip];
+    CGFloat left = _pill.paddingHorizontal + _pill.borderWidth;
+    CGFloat right = size.width - left;
+    if (_reservesIconSlot && right - left >= _font.pointSize) {
+      CGFloat side = _font.pointSize;
+      if (_icon) {
+        CGFloat scale = side / MAX(_icon.size.width, _icon.size.height);
+        CGSize iconSize = CGSizeMake(_icon.size.width * scale, _icon.size.height * scale);
+        CGRect iconRect = CGRectMake(left + (side - iconSize.width) / 2, (size.height - iconSize.height) / 2,
+                                     iconSize.width, iconSize.height);
+        UIImage *presented =
+            _iconTint ? [_icon imageWithTintColor:_iconTint renderingMode:UIImageRenderingModeAlwaysOriginal] : _icon;
+        [presented drawInRect:iconRect];
+      }
+      left += side * kIconSlotRatio;
+    }
+    NSMutableParagraphStyle *paragraph = [[NSMutableParagraphStyle alloc] init];
+    paragraph.lineBreakMode = NSLineBreakByTruncatingTail;
+    NSDictionary *attributes = @{
+      NSFontAttributeName : _font,
+      NSForegroundColorAttributeName : _variant.color ?: UIColor.labelColor,
+      NSUnderlineStyleAttributeName : @(_variant.underline ? NSUnderlineStyleSingle : NSUnderlineStyleNone),
+      NSParagraphStyleAttributeName : paragraph,
+    };
+    [_label drawInRect:CGRectMake(left, _pill.paddingVertical + _pill.borderWidth, MAX(0, right - left), size.height)
+        withAttributes:attributes];
+  }];
+  [ENRMRenderedLinkPills() setObject:image forKey:appearance cost:ENRMImageByteCost(image)];
+  return image;
+}
+
+#pragma mark - Asynchronous icon
+
+- (void)iconDidSettle:(UIImage *)icon
+{
+  _icon = icon;
+  BOOL slotReleased = icon == nil;
+  if (slotReleased)
+    _reservesIconSlot = NO;
+
+  if (self.onIconLoaded)
+    self.onIconLoaded();
+
+  NSTextContainer *container = _textContainer;
+  UITextView *textView = container ? objc_getAssociatedObject(container, kTextViewKey) : nil;
+  if (!textView)
+    return;
+  NSRange range = [self rangeInText:textView.textStorage];
+  if (range.location == NSNotFound)
+    return;
+  if (!slotReleased) {
+    [textView.layoutManager invalidateDisplayForCharacterRange:range];
+    return;
+  }
+  // The pill got narrower, so lines can reflow: lay out again and let the host re-measure.
+  [textView.layoutManager invalidateLayoutForCharacterRange:range actualCharacterRange:NULL];
+  id<ENRMImageLayoutObserver> observer = [textView enrm_imageLayoutObserver];
+  if (observer)
+    dispatch_async(dispatch_get_main_queue(), ^{ [observer imageAttachmentDidResolveLayout]; });
+}
+
+- (NSRange)rangeInText:(NSAttributedString *)text
+{
+  __block NSRange found = NSMakeRange(NSNotFound, 0);
+  [text enumerateAttribute:NSAttachmentAttributeName
+                   inRange:NSMakeRange(0, text.length)
+                   options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                usingBlock:^(id value, NSRange range, BOOL *stop) {
+                  if (value == self) {
+                    found = range;
+                    *stop = YES;
+                  }
+                }];
+  return found;
+}
+@end
+
+#endif

package/ios/attachments/ENRMLinkPillIconCache.h

@@ -0,0 +1,28 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+#if !TARGET_OS_OSX
+NS_ASSUME_NONNULL_BEGIN
+
+/// Pill icons, kept small in one bounded cache. Local files decode synchronously, so a bundled
+/// icon is there on the first layout; every other source goes through the shared image
+/// downloader, like tiptap images, and arrives asynchronously.
+
+/// A local file icon, or nil when the source is not a readable local file.
+FOUNDATION_EXPORT UIImage *_Nullable ENRMLoadLinkPillIcon(NSString *_Nullable iconUri);
+
+FOUNDATION_EXPORT UIImage *_Nullable ENRMCachedLinkPillIcon(NSString *iconUri,
+                                                            NSDictionary<NSString *, NSString *> *_Nullable headers);
+
+/// YES for a while after an asynchronous load of this source failed; callers then do not
+/// reserve an icon slot. The source is tried again once that period has passed.
+FOUNDATION_EXPORT BOOL ENRMLinkPillIconDidFail(NSString *iconUri,
+                                               NSDictionary<NSString *, NSString *> *_Nullable headers);
+
+/// Loads through the shared image pipeline. `completion` runs on the main thread; nil means the source failed.
+FOUNDATION_EXPORT void ENRMLoadLinkPillIconAsync(NSString *iconUri,
+                                                 NSDictionary<NSString *, NSString *> *_Nullable headers,
+                                                 void (^completion)(UIImage *_Nullable icon));
+
+NS_ASSUME_NONNULL_END
+#endif

package/ios/attachments/ENRMLinkPillIconCache.m

@@ -0,0 +1,181 @@
+#import "ENRMLinkPillIconCache.h"
+#import "ENRMImageDownloader.h"
+#import "ENRMLocalImageLoader.h"
+#if !TARGET_OS_OSX
+#import <ImageIO/ImageIO.h>
+#import <QuartzCore/QuartzCore.h>
+
+// Icons are drawn at the label's font size, so even a large heading at 3x needs few pixels.
+static const CGFloat kMaxIconPixelSize = 128;
+
+static NSCache<NSString *, UIImage *> *ENRMLinkPillIcons(void)
+{
+  static NSCache<NSString *, UIImage *> *icons;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    icons = [NSCache new];
+    icons.countLimit = 64;
+    icons.totalCostLimit = 8 * 1024 * 1024;
+  });
+  return icons;
+}
+
+// A failed source is left alone for a while, so a broken URL is not requested on every
+// render, and then tried again, so a transient failure does not hide the icon for good.
+static const CFTimeInterval kFailedIconRetryInterval = 30;
+
+static NSCache<NSString *, NSNumber *> *ENRMFailedLinkPillIcons(void)
+{
+  static NSCache<NSString *, NSNumber *> *failed;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    failed = [NSCache new];
+    failed.countLimit = 256;
+  });
+  return failed;
+}
+
+// A local icon and the state of its file when it was decoded.
+@interface ENRMLocalLinkPillIcon : NSObject
+@property (nonatomic, strong) UIImage *image;
+@property (nonatomic, copy) NSString *path;
+@property (nonatomic, strong, nullable) NSDate *modified;
+@property (nonatomic, assign) unsigned long long fileSize;
+@property (nonatomic, assign) CFTimeInterval checkedAt;
+@end
+
+@implementation ENRMLocalLinkPillIcon
+@end
+
+// Every render asks for the same icons again, so the file is looked at no more than once
+// per interval; a file replaced under the same path is picked up after that.
+static const CFTimeInterval kLocalIconRevalidateInterval = 1;
+
+static NSCache<NSString *, ENRMLocalLinkPillIcon *> *ENRMLocalLinkPillIcons(void)
+{
+  static NSCache<NSString *, ENRMLocalLinkPillIcon *> *icons;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    icons = [NSCache new];
+    icons.countLimit = 64;
+    icons.totalCostLimit = 8 * 1024 * 1024;
+  });
+  return icons;
+}
+
+static UIImage *ENRMDecodeLinkPillIcon(NSString *path)
+{
+  CGImageSourceRef source = CGImageSourceCreateWithURL((__bridge CFURLRef)[NSURL fileURLWithPath:path], NULL);
+  if (!source)
+    return nil;
+  NSDictionary *options = @{
+    (__bridge NSString *)kCGImageSourceCreateThumbnailFromImageAlways : @YES,
+    (__bridge NSString *)kCGImageSourceCreateThumbnailWithTransform : @YES,
+    (__bridge NSString *)kCGImageSourceShouldCacheImmediately : @YES,
+    (__bridge NSString *)kCGImageSourceThumbnailMaxPixelSize : @(kMaxIconPixelSize),
+  };
+  CGImageRef decoded = CGImageSourceCreateThumbnailAtIndex(source, 0, (__bridge CFDictionaryRef)options);
+  CFRelease(source);
+  if (!decoded)
+    return nil;
+  UIImage *image = [UIImage imageWithCGImage:decoded];
+  CGImageRelease(decoded);
+  return image;
+}
+
+UIImage *ENRMLoadLinkPillIcon(NSString *iconUri)
+{
+  if (iconUri.length == 0)
+    return nil;
+  NSCache<NSString *, ENRMLocalLinkPillIcon *> *icons = ENRMLocalLinkPillIcons();
+  ENRMLocalLinkPillIcon *cached = [icons objectForKey:iconUri];
+  CFTimeInterval now = CACurrentMediaTime();
+  if (cached && now - cached.checkedAt < kLocalIconRevalidateInterval)
+    return cached.image;
+
+  NSString *path = cached.path ?: ENRMResolveLocalImagePath(iconUri);
+  if (!path)
+    return nil;
+  NSDictionary *attributes = [NSFileManager.defaultManager attributesOfItemAtPath:path error:nil];
+  NSDate *modified = attributes[NSFileModificationDate];
+  unsigned long long fileSize = [attributes[NSFileSize] unsignedLongLongValue];
+  if (cached && attributes && cached.fileSize == fileSize && [cached.modified isEqualToDate:modified]) {
+    cached.checkedAt = now;
+    return cached.image;
+  }
+
+  UIImage *image = attributes ? ENRMDecodeLinkPillIcon(path) : nil;
+  if (!image) {
+    [icons removeObjectForKey:iconUri];
+    return nil;
+  }
+  ENRMLocalLinkPillIcon *entry = [ENRMLocalLinkPillIcon new];
+  entry.image = image;
+  entry.path = path;
+  entry.modified = modified;
+  entry.fileSize = fileSize;
+  entry.checkedAt = now;
+  [icons setObject:entry forKey:iconUri cost:ENRMImageByteCost(image)];
+  return image;
+}
+
+UIImage *ENRMCachedLinkPillIcon(NSString *iconUri, NSDictionary<NSString *, NSString *> *headers)
+{
+  return [ENRMLinkPillIcons() objectForKey:ENRMImageCacheKey(iconUri, headers)];
+}
+
+BOOL ENRMLinkPillIconDidFail(NSString *iconUri, NSDictionary<NSString *, NSString *> *headers)
+{
+  NSString *key = ENRMImageCacheKey(iconUri, headers);
+  NSNumber *failedAt = [ENRMFailedLinkPillIcons() objectForKey:key];
+  if (!failedAt)
+    return NO;
+  if (CACurrentMediaTime() - failedAt.doubleValue < kFailedIconRetryInterval)
+    return YES;
+  [ENRMFailedLinkPillIcons() removeObjectForKey:key];
+  return NO;
+}
+
+static UIImage *ENRMLinkPillThumbnail(UIImage *image)
+{
+  CGFloat pixelWidth = image.size.width * image.scale;
+  CGFloat pixelHeight = image.size.height * image.scale;
+  CGFloat longest = MAX(pixelWidth, pixelHeight);
+  if (longest <= kMaxIconPixelSize || longest <= 0)
+    return image;
+  CGFloat ratio = kMaxIconPixelSize / longest;
+  CGSize size = CGSizeMake(MAX(1, floor(pixelWidth * ratio)), MAX(1, floor(pixelHeight * ratio)));
+  UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
+  format.scale = 1;
+  format.opaque = NO;
+  UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:size format:format];
+  return [renderer imageWithActions:^(UIGraphicsImageRendererContext *context) {
+    [image drawInRect:(CGRect){CGPointZero, size}];
+  }];
+}
+
+void ENRMLoadLinkPillIconAsync(NSString *iconUri, NSDictionary<NSString *, NSString *> *headers,
+                               void (^completion)(UIImage *_Nullable icon))
+{
+  NSString *key = ENRMImageCacheKey(iconUri, headers);
+  [[ENRMImageDownloader shared] downloadURL:iconUri
+                                    headers:headers
+                                 completion:^(RCTUIImage *image) {
+                                   // Drawn pills are cached by icon identity: every pill waiting
+                                   // for this icon gets the same image.
+                                   UIImage *icon = [ENRMLinkPillIcons() objectForKey:key];
+                                   if (!icon && image) {
+                                     icon = ENRMLinkPillThumbnail(image);
+                                     [ENRMLinkPillIcons() setObject:icon forKey:key cost:ENRMImageByteCost(icon)];
+                                   }
+                                   if (!icon) {
+                                     [ENRMFailedLinkPillIcons() setObject:@(CACurrentMediaTime()) forKey:key];
+                                   }
+                                   if (NSThread.isMainThread) {
+                                     completion(icon);
+                                   } else {
+                                     dispatch_async(dispatch_get_main_queue(), ^{ completion(icon); });
+                                   }
+                                 }];
+}
+#endif

package/ios/attachments/ENRMLinkPillText.h

@@ -0,0 +1,27 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * In text storage a link pill is one placeholder character. Wherever text leaves the
+ * view it must carry the link text again: the Tiptap, HTML and RTF exporters expand
+ * pills themselves, and code that reads plain text out of storage calls these functions.
+ * On macOS, where pills are not rendered, they return their input unchanged.
+ */
+
+/**
+ * Returns `text` with every pill placeholder replaced by the link content it stands for,
+ * or `text` itself when it holds no pills. `ioRange`, when given, is a range in `text` on
+ * input and the matching range in the result on output.
+ */
+FOUNDATION_EXPORT NSAttributedString *ENRMAttributedStringByExpandingLinkPills(NSAttributedString *text,
+                                                                               NSRange *_Nullable ioRange);
+
+FOUNDATION_EXPORT NSString *ENRMStringByExpandingLinkPills(NSAttributedString *text);
+
+/// Enclosing strong/emphasis restyle the placeholder after the pill was created. Run once
+/// rendering is finished so each label uses the font ordinary link text would have.
+FOUNDATION_EXPORT void ENRMLinkPillsAdoptPlaceholderFonts(NSAttributedString *text);
+
+NS_ASSUME_NONNULL_END

package/ios/attachments/ENRMLinkPillText.m

@@ -0,0 +1,118 @@
+#import "ENRMLinkPillText.h"
+#import "ENRMLinkPillAttachment.h"
+
+#if !TARGET_OS_OSX
+
+/// Inline parents (strong, emphasis) restyle the placeholder's font after the pill was created; carry that over.
+static UIFont *ENRMFontAddingTraits(UIFont *font, UIFontDescriptorSymbolicTraits traits)
+{
+  UIFontDescriptorSymbolicTraits current = font.fontDescriptor.symbolicTraits;
+  if ((current & traits) == traits)
+    return font;
+  UIFontDescriptor *descriptor = [font.fontDescriptor fontDescriptorWithSymbolicTraits:current | traits];
+  return descriptor ? [UIFont fontWithDescriptor:descriptor size:font.pointSize] : font;
+}
+
+static NSAttributedString *ENRMExpandedLinkPill(ENRMLinkPillAttachment *pill, NSDictionary *placeholderAttributes)
+{
+  NSMutableAttributedString *expanded = [pill.originalText mutableCopy];
+  NSRange all = NSMakeRange(0, expanded.length);
+  // The placeholder started with the font of the link's first character, so only traits it has
+  // gained since come from an enclosing parent.
+  UIFont *placeholderFont = placeholderAttributes[NSFontAttributeName];
+  UIFont *firstFont = all.length > 0 ? [expanded attribute:NSFontAttributeName atIndex:0 effectiveRange:NULL] : nil;
+  UIFontDescriptorSymbolicTraits inherited = placeholderFont.fontDescriptor.symbolicTraits &
+                                             ~firstFont.fontDescriptor.symbolicTraits &
+                                             (UIFontDescriptorTraitBold | UIFontDescriptorTraitItalic);
+  [placeholderAttributes enumerateKeysAndObjectsUsingBlock:^(NSAttributedStringKey key, id value, BOOL *stop) {
+    if ([key isEqualToString:NSAttachmentAttributeName])
+      return;
+    BOOL isFont = [key isEqualToString:NSFontAttributeName];
+    [pill.originalText enumerateAttribute:key
+                                  inRange:all
+                                  options:0
+                               usingBlock:^(id existing, NSRange range, BOOL *innerStop) {
+                                 if (!existing) {
+                                   [expanded addAttribute:key value:value range:range];
+                                 } else if (isFont && inherited != 0) {
+                                   [expanded addAttribute:key
+                                                    value:ENRMFontAddingTraits(existing, inherited)
+                                                    range:range];
+                                 }
+                               }];
+  }];
+  return expanded;
+}
+
+#endif
+
+void ENRMLinkPillsAdoptPlaceholderFonts(NSAttributedString *text)
+{
+#if !TARGET_OS_OSX
+  [text enumerateAttribute:NSAttachmentAttributeName
+                   inRange:NSMakeRange(0, text.length)
+                   options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
+                usingBlock:^(id value, NSRange range, BOOL *stop) {
+                  if ([value isKindOfClass:ENRMLinkPillAttachment.class])
+                    [(ENRMLinkPillAttachment *)value adoptFont:[text attribute:NSFontAttributeName
+                                                                          atIndex:range.location
+                                                                   effectiveRange:NULL]];
+                }];
+#endif
+}
+
+NSAttributedString *ENRMAttributedStringByExpandingLinkPills(NSAttributedString *text, NSRange *ioRange)
+{
+#if TARGET_OS_OSX
+  return text;
+#else
+  if (text.length == 0)
+    return text;
+  NSMutableArray<NSValue *> *ranges = nil;
+  NSMutableArray<ENRMLinkPillAttachment *> *pills = nil;
+  NSRange all = NSMakeRange(0, text.length);
+  NSRange cursor = NSMakeRange(0, 0);
+  while (NSMaxRange(cursor) < text.length) {
+    id value = [text attribute:NSAttachmentAttributeName
+                       atIndex:NSMaxRange(cursor)
+         longestEffectiveRange:&cursor
+                       inRange:all];
+    if (![value isKindOfClass:ENRMLinkPillAttachment.class])
+      continue;
+    if (!pills) {
+      ranges = [NSMutableArray new];
+      pills = [NSMutableArray new];
+    }
+    [ranges addObject:[NSValue valueWithRange:cursor]];
+    [pills addObject:value];
+  }
+  if (!pills)
+    return text;
+
+  NSMutableAttributedString *result = [text mutableCopy];
+  NSRange range = ioRange ? *ioRange : NSMakeRange(0, 0);
+  NSInteger locationDelta = 0;
+  NSInteger lengthDelta = 0;
+  // Back to front, so earlier ranges stay valid while the string grows.
+  for (NSInteger i = (NSInteger)pills.count - 1; i >= 0; i--) {
+    NSRange placeholder = ranges[i].rangeValue;
+    NSAttributedString *expanded = ENRMExpandedLinkPill(pills[i], [text attributesAtIndex:placeholder.location
+                                                                           effectiveRange:NULL]);
+    [result replaceCharactersInRange:placeholder withAttributedString:expanded];
+    NSInteger growth = (NSInteger)expanded.length - (NSInteger)placeholder.length;
+    if (NSMaxRange(placeholder) <= range.location) {
+      locationDelta += growth;
+    } else if (placeholder.location < NSMaxRange(range)) {
+      lengthDelta += growth;
+    }
+  }
+  if (ioRange)
+    *ioRange = NSMakeRange(range.location + locationDelta, range.length + lengthDelta);
+  return result;
+#endif
+}
+
+NSString *ENRMStringByExpandingLinkPills(NSAttributedString *text)
+{
+  return ENRMAttributedStringByExpandingLinkPills(text, NULL).string;
+}

package/ios/attachments/ENRMMathInlineAttachment.h

@@ -0,0 +1,7 @@
+#import <UIKit/UIKit.h>
+
+// Math is not rendered. This empty attachment exists so copied measurement
+// code that type-checks attachments still compiles.
+@interface ENRMMathInlineAttachment : NSTextAttachment
+@property (nonatomic, assign) CGFloat boxHeight;
+@end