react-native-enriched-markdown-scaffold 0.6.0-scaffold.4

package/ios/utils/ENRMAsyncRenderCoordinator.m

@@ -0,0 +1,37 @@
+#import "ENRMAsyncRenderCoordinator.h"
+
+@implementation ENRMAsyncRenderCoordinator {
+  dispatch_queue_t _queue;
+  NSUInteger _currentRenderId;
+}
+
+- (instancetype)initWithQueueLabel:(const char *)label
+{
+  if (self = [super init]) {
+    _queue = dispatch_queue_create(label, DISPATCH_QUEUE_SERIAL);
+  }
+  return self;
+}
+
+- (void)scheduleRender:(BOOL (^)(void))renderBlock apply:(dispatch_block_t)applyBlock
+{
+  if (_blockAsyncRender)
+    return;
+  NSUInteger renderId = ++_currentRenderId;
+  dispatch_async(_queue, ^{
+    if (!renderBlock())
+      return;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (renderId == self->_currentRenderId) {
+        applyBlock();
+      }
+    });
+  });
+}
+
+- (void)invalidate
+{
+  ++_currentRenderId;
+}
+
+@end

package/ios/utils/ENRMFeatureFlags.h

@@ -0,0 +1,12 @@
+#pragma once
+
+// Auto-detect RaTeX availability as a fallback for the podspec flag.
+#if __has_include(<RaTeXFFI/ratex.h>) || __has_include("ReactNativeEnrichedMarkdown-Swift.h")
+#if !defined(ENRICHED_MARKDOWN_MATH)
+#define ENRICHED_MARKDOWN_MATH 1
+#endif
+#endif
+
+#if !defined(ENRICHED_MARKDOWN_MATH)
+#define ENRICHED_MARKDOWN_MATH 0
+#endif

package/ios/utils/ENRMImageDownloader.h

@@ -0,0 +1,16 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^ENRMImageDownloadCompletion)(RCTUIImage *_Nullable image);
+
+@interface ENRMImageDownloader : NSObject
+
++ (instancetype)shared;
+
+- (void)downloadURL:(NSString *)url completion:(ENRMImageDownloadCompletion)completion;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMImageDownloader.m

@@ -0,0 +1,108 @@
+#import "ENRMImageDownloader.h"
+#import "ENRMImageAttachment.h"
+#include <TargetConditionals.h>
+
+static const NSUInteger kDiskCacheMemoryCapacity = 10 * 1024 * 1024;
+static const NSUInteger kDiskCacheDiskCapacity = 100 * 1024 * 1024;
+
+static inline NSUInteger ENRMImageByteCost(RCTUIImage *image)
+{
+  CGImageRef cgImage = image.CGImage;
+  if (!cgImage)
+    return 0;
+  return CGImageGetBytesPerRow(cgImage) * CGImageGetHeight(cgImage);
+}
+
+@implementation ENRMImageDownloader {
+  NSURLSession *_session;
+  NSMutableDictionary<NSString *, NSMutableArray<ENRMImageDownloadCompletion> *> *_inFlightRequests;
+}
+
++ (instancetype)shared
+{
+  static ENRMImageDownloader *instance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{ instance = [[ENRMImageDownloader alloc] init]; });
+  return instance;
+}
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
+    config.URLCache = [[NSURLCache alloc] initWithMemoryCapacity:kDiskCacheMemoryCapacity
+                                                    diskCapacity:kDiskCacheDiskCapacity
+                                                    directoryURL:nil];
+    config.requestCachePolicy = NSURLRequestReturnCacheDataElseLoad;
+    config.timeoutIntervalForRequest = 15;
+    config.timeoutIntervalForResource = 30;
+    _session = [NSURLSession sessionWithConfiguration:config];
+    _inFlightRequests = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
+- (void)downloadURL:(NSString *)url completion:(ENRMImageDownloadCompletion)completion
+{
+  if (url.length == 0) {
+    completion(nil);
+    return;
+  }
+
+  RCTUIImage *cached = [[ENRMImageAttachment originalImageCache] objectForKey:url];
+  if (cached) {
+    completion(cached);
+    return;
+  }
+
+  @synchronized(_inFlightRequests) {
+    NSMutableArray *existing = _inFlightRequests[url];
+    if (existing) {
+      [existing addObject:completion];
+      return;
+    }
+    _inFlightRequests[url] = [NSMutableArray arrayWithObject:completion];
+  }
+
+  NSURL *nsURL = [NSURL URLWithString:url];
+  if (!nsURL) {
+    [self dispatchCallbacksForURL:url image:nil];
+    return;
+  }
+
+  [[_session dataTaskWithURL:nsURL
+           completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+#if !TARGET_OS_OSX
+             RCTUIImage *image = (data && !error) ? [RCTUIImage imageWithData:data] : nil;
+#else
+        RCTUIImage *image = (data && !error) ? [[RCTUIImage alloc] initWithData:data] : nil;
+#endif
+
+             if (image) {
+               [[ENRMImageAttachment originalImageCache] setObject:image forKey:url cost:ENRMImageByteCost(image)];
+             }
+
+             [self dispatchCallbacksForURL:url image:image];
+           }] resume];
+}
+
+- (void)dispatchCallbacksForURL:(NSString *)url image:(RCTUIImage *_Nullable)image
+{
+  NSArray<ENRMImageDownloadCompletion> *callbacks;
+  @synchronized(_inFlightRequests) {
+    callbacks = [_inFlightRequests[url] copy];
+    [_inFlightRequests removeObjectForKey:url];
+  }
+
+  if (!callbacks)
+    return;
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    for (ENRMImageDownloadCompletion cb in callbacks) {
+      cb(image);
+    }
+  });
+}
+
+@end

package/ios/utils/ENRMMenuAction.h

@@ -0,0 +1,27 @@
+#pragma once
+#include <TargetConditionals.h>
+
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+
+// NSMenuItem uses target/action with no block-based API, so we use a lightweight
+// action object as the target. NSMenuItem.target is a WEAK reference (AppKit does
+// not retain it), so we also store the action object in representedObject (strong)
+// to tie its lifetime to the menu item.
+@interface ENRMMenuAction : NSObject
+- (instancetype)initWithBlock:(void (^)(void))block;
+- (BOOL)validateMenuItem:(NSMenuItem *)menuItem;
+- (void)performAction:(id)sender;
+@end
+
+/// Creates an NSMenuItem whose action fires a block.
+static inline NSMenuItem *ENRMCreateMenuItem(NSString *title, void (^action)(void))
+{
+  ENRMMenuAction *actionObject = [[ENRMMenuAction alloc] initWithBlock:action];
+  NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:title action:@selector(performAction:) keyEquivalent:@""];
+  item.target = actionObject;
+  item.representedObject = actionObject;
+  return item;
+}
+
+#endif // TARGET_OS_OSX

package/ios/utils/ENRMMenuAction.m

@@ -0,0 +1,33 @@
+#include <TargetConditionals.h>
+
+#if TARGET_OS_OSX
+#import "ENRMMenuAction.h"
+
+@implementation ENRMMenuAction {
+  void (^_block)(void);
+}
+
+- (instancetype)initWithBlock:(void (^)(void))block
+{
+  self = [super init];
+  if (self) {
+    _block = [block copy];
+  }
+  return self;
+}
+
+- (BOOL)validateMenuItem:(NSMenuItem *)menuItem
+{
+  return YES;
+}
+
+- (void)performAction:(id)sender
+{
+  if (_block) {
+    _block();
+  }
+}
+
+@end
+
+#endif // TARGET_OS_OSX

package/ios/utils/ENRMParticleOverlayView.h

@@ -0,0 +1,12 @@
+#pragma once
+#import "ENRMSpoilerOverlayView.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMParticleOverlayView : ENRMSpoilerOverlayView
+
+- (instancetype)initWithConfig:(StyleConfig *)config charRange:(NSRange)charRange;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMParticleOverlayView.m

@@ -0,0 +1,159 @@
+#import "ENRMParticleOverlayView.h"
+#import <QuartzCore/QuartzCore.h>
+
+static const CGFloat kDefaultParticleDensity = 8.0;
+static const CGFloat kDefaultParticleSpeed = 20.0;
+static const CGFloat kDotImageSize = 6.0;
+static const CGFloat kRevealVelocityMultiplier = 10.0;
+static const CGFloat kRevealAlphaSpeedMultiplier = 6.0;
+
+static const CGFloat kDot1BirthRateMin = 3.0;
+static const CGFloat kDot1BirthRatePerArea = 0.013;
+static const CGFloat kDot1Lifetime = 1.6;
+static const CGFloat kDot1Velocity = 8.0;
+static const CGFloat kDot1Scale = 0.25;
+static const CGFloat kDot1AlphaSpeed = -0.25;
+
+static const CGFloat kDot2BirthRateMin = 1.5;
+static const CGFloat kDot2BirthRatePerArea = 0.007;
+static const CGFloat kDot2Lifetime = 1.2;
+static const CGFloat kDot2Velocity = 12.0;
+static const CGFloat kDot2Scale = 0.18;
+static const CGFloat kDot2AlphaSpeed = -0.3;
+
+static const CGFloat kMaxParticleLifetime = 1.6; // must match the longest lifetime above
+
+static CGImageRef sharedDotCGImage(void)
+{
+  static CGImageRef cgImage;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    CGColorSpaceRef space = CGColorSpaceCreateDeviceRGB();
+    CGContextRef ctx = CGBitmapContextCreate(NULL, (size_t)kDotImageSize, (size_t)kDotImageSize, 8, 0, space,
+                                             kCGImageAlphaPremultipliedLast);
+    CGColorSpaceRelease(space);
+    CGContextSetRGBFillColor(ctx, 1, 1, 1, 1);
+    CGContextFillEllipseInRect(ctx, CGRectMake(0, 0, kDotImageSize, kDotImageSize));
+    cgImage = CGBitmapContextCreateImage(ctx);
+    CGContextRelease(ctx);
+  });
+  return cgImage;
+}
+
+@implementation ENRMParticleOverlayView {
+  CAEmitterLayer *_emitterLayer;
+  RCTUIColor *_particleColor;
+  CGFloat _particleDensity;
+  CGFloat _particleSpeed;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config charRange:(NSRange)charRange
+{
+  if (self = [super initWithCharRange:charRange]) {
+    _particleColor = [config spoilerColor];
+    _particleDensity = [config spoilerParticleDensity];
+    _particleSpeed = [config spoilerParticleSpeed];
+  }
+  return self;
+}
+
+#pragma mark - Overrides
+
+- (void)didAttachToSuperview
+{
+  self.layer.backgroundColor = [self resolveBackgroundCGColor];
+  if (!_emitterLayer) {
+    [self setupEmitter];
+  }
+}
+
+- (void)didLayoutOverlay
+{
+  if (!_emitterLayer) {
+    // Emitter creation is deferred when bounds were zero at attach time.
+    [self setupEmitter];
+    return;
+  }
+  if (!self.revealing) {
+    _emitterLayer.frame = self.bounds;
+    _emitterLayer.emitterPosition = CGPointMake(self.bounds.size.width / 2.0, self.bounds.size.height / 2.0);
+    _emitterLayer.emitterSize = self.bounds.size;
+  }
+}
+
+- (void)prepareRevealAnimation
+{
+  _emitterLayer.birthRate = 0;
+
+  for (CAEmitterCell *cell in _emitterLayer.emitterCells) {
+    NSString *velocityPath = [NSString stringWithFormat:@"emitterCells.%@.velocity", cell.name];
+    NSString *alphaPath = [NSString stringWithFormat:@"emitterCells.%@.alphaSpeed", cell.name];
+    [_emitterLayer setValue:@(cell.velocity * kRevealVelocityMultiplier) forKeyPath:velocityPath];
+    [_emitterLayer setValue:@(cell.alphaSpeed * kRevealAlphaSpeedMultiplier) forKeyPath:alphaPath];
+  }
+}
+
+#pragma mark - Emitter setup
+
+- (CAEmitterCell *)makeParticleCellWithName:(NSString *)name
+                                  birthRate:(CGFloat)birthRate
+                                   lifetime:(CGFloat)lifetime
+                                   velocity:(CGFloat)velocity
+                                      scale:(CGFloat)scale
+                                 alphaSpeed:(CGFloat)alphaSpeed
+{
+  CAEmitterCell *cell = [CAEmitterCell emitterCell];
+  cell.name = name;
+  cell.contents = (__bridge id)sharedDotCGImage();
+  cell.color = _particleColor.CGColor;
+  cell.birthRate = birthRate;
+  cell.lifetime = lifetime;
+  cell.lifetimeRange = lifetime * 0.3;
+  cell.velocity = velocity;
+  cell.velocityRange = velocity * 0.5;
+  cell.emissionRange = M_PI * 2;
+  cell.scale = scale;
+  cell.scaleRange = scale * 0.3;
+  cell.alphaRange = 0.2;
+  cell.alphaSpeed = alphaSpeed;
+  return cell;
+}
+
+- (void)setupEmitter
+{
+  CGRect bounds = self.bounds;
+  if (bounds.size.width <= 0 || bounds.size.height <= 0)
+    return;
+
+  CGFloat area = bounds.size.width * bounds.size.height;
+  CGFloat densityFactor = _particleDensity / kDefaultParticleDensity;
+  CGFloat speedFactor = _particleSpeed / kDefaultParticleSpeed;
+
+  _emitterLayer = [CAEmitterLayer layer];
+  _emitterLayer.emitterShape = kCAEmitterLayerRectangle;
+  _emitterLayer.renderMode = kCAEmitterLayerOldestLast;
+  _emitterLayer.frame = bounds;
+  _emitterLayer.emitterPosition = CGPointMake(bounds.size.width / 2.0, bounds.size.height / 2.0);
+  _emitterLayer.emitterSize = bounds.size;
+  _emitterLayer.emitterCells = @[
+    [self makeParticleCellWithName:@"dot1"
+                         birthRate:MAX(kDot1BirthRateMin, area * kDot1BirthRatePerArea * densityFactor)
+                          lifetime:kDot1Lifetime
+                          velocity:kDot1Velocity * speedFactor
+                             scale:kDot1Scale
+                        alphaSpeed:kDot1AlphaSpeed],
+    [self makeParticleCellWithName:@"dot2"
+                         birthRate:MAX(kDot2BirthRateMin, area * kDot2BirthRatePerArea * densityFactor)
+                          lifetime:kDot2Lifetime
+                          velocity:kDot2Velocity * speedFactor
+                             scale:kDot2Scale
+                        alphaSpeed:kDot2AlphaSpeed],
+  ];
+
+  // Backdate the emitter so it appears pre-populated with particles.
+  _emitterLayer.beginTime = CACurrentMediaTime() - kMaxParticleLifetime;
+
+  [self.layer addSublayer:_emitterLayer];
+}
+
+@end

package/ios/utils/ENRMSolidOverlayView.h

@@ -0,0 +1,12 @@
+#pragma once
+#import "ENRMSpoilerOverlayView.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMSolidOverlayView : ENRMSpoilerOverlayView
+
+- (instancetype)initWithConfig:(StyleConfig *)config charRange:(NSRange)charRange;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMSolidOverlayView.m

@@ -0,0 +1,25 @@
+#import "ENRMSolidOverlayView.h"
+
+@implementation ENRMSolidOverlayView {
+  RCTUIColor *_solidColor;
+  CGFloat _borderRadius;
+}
+
+- (instancetype)initWithConfig:(StyleConfig *)config charRange:(NSRange)charRange
+{
+  if (self = [super initWithCharRange:charRange]) {
+    _solidColor = [config spoilerColor];
+    _borderRadius = [config spoilerSolidBorderRadius];
+  }
+  return self;
+}
+
+#pragma mark - Overrides
+
+- (void)didAttachToSuperview
+{
+  self.layer.backgroundColor = _solidColor.CGColor;
+  self.layer.cornerRadius = _borderRadius;
+}
+
+@end

package/ios/utils/ENRMSpoilerCapable.h

@@ -0,0 +1,15 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+@class ENRMSpoilerOverlayManager;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol ENRMSpoilerCapable <NSObject>
+
+@property (nonatomic, readonly) ENRMPlatformTextView *textView;
+@property (nonatomic, readonly) ENRMSpoilerOverlayManager *spoilerManager;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMSpoilerOverlayManager.h

@@ -0,0 +1,21 @@
+#pragma once
+#import "ENRMSpoilerOverlayView.h"
+#import "ENRMUIKit.h"
+#import "StyleConfig.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMSpoilerOverlayManager : NSObject
+
+@property (nonatomic) ENRMSpoilerOverlay spoilerOverlay;
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView config:(StyleConfig *)config;
+
+- (void)setNeedsUpdate;
+- (void)updateIfNeeded;
+- (void)removeOverlaysForCharRange:(NSRange)charRange;
+- (void)removeAllOverlays;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMSpoilerOverlayManager.m

@@ -0,0 +1,181 @@
+#import "ENRMSpoilerOverlayManager.h"
+#import "ENRMSpoilerOverlayView.h"
+#import "ENRMSpoilerTapUtils.h"
+
+static NSString *overlayKey(NSRange charRange, CGRect frame)
+{
+  return [NSString stringWithFormat:@"%lu-%lu-%.0f-%.0f-%.0f-%.0f", (unsigned long)charRange.location,
+                                    (unsigned long)charRange.length, frame.origin.x, frame.origin.y, frame.size.width,
+                                    frame.size.height];
+}
+
+@implementation ENRMSpoilerOverlayManager {
+  __weak ENRMPlatformTextView *_textView;
+  StyleConfig *_config;
+  NSMutableDictionary<NSString *, ENRMSpoilerOverlayView *> *_overlaysByKey;
+  BOOL _needsUpdate;
+}
+
+- (void)setSpoilerOverlay:(ENRMSpoilerOverlay)spoilerOverlay
+{
+  if (_spoilerOverlay == spoilerOverlay)
+    return;
+  _spoilerOverlay = spoilerOverlay;
+  [self rebuildOverlays];
+}
+
+- (void)rebuildOverlays
+{
+  for (ENRMSpoilerOverlayView *overlay in _overlaysByKey.allValues) {
+    [overlay removeFromSuperview];
+  }
+  [_overlaysByKey removeAllObjects];
+  _needsUpdate = YES;
+  [self updateIfNeeded];
+}
+
+- (instancetype)initWithTextView:(ENRMPlatformTextView *)textView config:(StyleConfig *)config
+{
+  if (self = [super init]) {
+    _textView = textView;
+    _config = config;
+    _overlaysByKey = [NSMutableDictionary new];
+  }
+  return self;
+}
+
+#pragma mark - Public
+
+- (void)setNeedsUpdate
+{
+  _needsUpdate = YES;
+}
+
+- (void)updateIfNeeded
+{
+  if (!_needsUpdate)
+    return;
+  ENRMPlatformTextView *textView = _textView;
+  // Intentionally keep _needsUpdate=YES when the text view is unavailable
+  // or has zero width — the update will be retried on the next layout pass.
+  if (!textView || textView.bounds.size.width <= 0)
+    return;
+  [self updateOverlays];
+}
+
+- (void)removeOverlaysForCharRange:(NSRange)charRange
+{
+  NSMutableArray<NSString *> *keysToReveal = [NSMutableArray new];
+  [_overlaysByKey enumerateKeysAndObjectsUsingBlock:^(NSString *key, ENRMSpoilerOverlayView *overlay, BOOL *stop) {
+    if (NSIntersectionRange(overlay.charRange, charRange).length > 0) {
+      [keysToReveal addObject:key];
+    }
+  }];
+
+  // Keep revealing overlays in _overlaysByKey so updateOverlays won't create
+  // duplicates during the animation. They are removed on completion.
+  for (NSString *key in keysToReveal) {
+    ENRMSpoilerOverlayView *overlay = _overlaysByKey[key];
+    NSMutableDictionary *dict = _overlaysByKey;
+    [overlay animateRevealWithCompletion:^{ [dict removeObjectForKey:key]; }];
+  }
+}
+
+- (void)removeAllOverlays
+{
+  ENRMPlatformTextView *textView = _textView;
+  if (textView && textView.textStorage.length > 0) {
+    ENRMRestoreSpoilerTextColors(textView.textStorage, NSMakeRange(0, textView.textStorage.length));
+  }
+  for (ENRMSpoilerOverlayView *overlay in _overlaysByKey.allValues) {
+    [overlay removeFromSuperview];
+  }
+  [_overlaysByKey removeAllObjects];
+}
+
+#pragma mark - Private
+
+- (void)updateOverlays
+{
+  _needsUpdate = NO;
+
+  ENRMPlatformTextView *textView = _textView;
+  if (!textView) {
+    [self removeAllOverlays];
+    return;
+  }
+
+  NSTextStorage *textStorage = textView.textStorage;
+  if (!textStorage || textStorage.length == 0) {
+    [self removeAllOverlays];
+    return;
+  }
+
+  NSLayoutManager *layoutManager = textView.layoutManager;
+  NSTextContainer *textContainer = textView.textContainer;
+  [layoutManager ensureLayoutForTextContainer:textContainer];
+
+  UIEdgeInsets inset = textView.textContainerInset;
+
+  NSMutableSet<NSString *> *desiredKeys = [NSMutableSet new];
+
+  [textStorage
+      enumerateAttribute:SpoilerAttributeName
+                 inRange:NSMakeRange(0, textStorage.length)
+                 options:0
+              usingBlock:^(id value, NSRange charRange, BOOL *stop) {
+                if (!value || charRange.length == 0)
+                  return;
+
+                NSRange glyphRange = [layoutManager glyphRangeForCharacterRange:charRange actualCharacterRange:NULL];
+                if (glyphRange.location == NSNotFound || glyphRange.length == 0)
+                  return;
+
+                [layoutManager
+                    enumerateLineFragmentsForGlyphRange:glyphRange
+                                             usingBlock:^(CGRect lineRect, CGRect usedRect, NSTextContainer *container,
+                                                          NSRange lineGlyphRange, BOOL *lineStop) {
+                                               NSRange intersect = NSIntersectionRange(lineGlyphRange, glyphRange);
+                                               if (intersect.length == 0)
+                                                 return;
+
+                                               CGRect textRect =
+                                                   [layoutManager boundingRectForGlyphRange:intersect
+                                                                            inTextContainer:textContainer];
+                                               CGRect frame = CGRectMake(textRect.origin.x + inset.left,
+                                                                         textRect.origin.y + inset.top,
+                                                                         textRect.size.width, textRect.size.height);
+                                               if (frame.size.width <= 0 || frame.size.height <= 0)
+                                                 return;
+
+                                               NSString *key = overlayKey(charRange, frame);
+                                               [desiredKeys addObject:key];
+
+                                               ENRMSpoilerOverlayView *existing = self->_overlaysByKey[key];
+                                               if (existing && !existing.revealing)
+                                                 return;
+
+                                               ENRMSpoilerOverlayView *overlay =
+                                                   [ENRMSpoilerOverlayView overlayWithMode:self->_spoilerOverlay
+                                                                                    config:self->_config
+                                                                                 charRange:charRange];
+                                               overlay.frame = frame;
+                                               [textView addSubview:overlay];
+                                               self->_overlaysByKey[key] = overlay;
+                                             }];
+              }];
+
+  NSMutableArray<NSString *> *staleKeys = [NSMutableArray new];
+  [_overlaysByKey enumerateKeysAndObjectsUsingBlock:^(NSString *key, ENRMSpoilerOverlayView *overlay, BOOL *stop) {
+    if (![desiredKeys containsObject:key] && !overlay.revealing) {
+      [staleKeys addObject:key];
+    }
+  }];
+  for (NSString *key in staleKeys) {
+    ENRMSpoilerOverlayView *overlay = _overlaysByKey[key];
+    [overlay removeFromSuperview];
+    [_overlaysByKey removeObjectForKey:key];
+  }
+}
+
+@end