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

package/ios/utils/ENRMImageDownloader.m

@@ -0,0 +1,168 @@
+#import "ENRMImageDownloader.h"
+#import "ENRMImageAttachment.h"
+#import "ENRMLocalImageLoader.h"
+#import <CommonCrypto/CommonDigest.h>
+#include <TargetConditionals.h>
+
+static const NSUInteger kDiskCacheMemoryCapacity = 10 * 1024 * 1024;
+static const NSUInteger kDiskCacheDiskCapacity = 100 * 1024 * 1024;
+
+NSUInteger ENRMImageByteCost(RCTUIImage *image)
+{
+  CGImageRef cgImage = image.CGImage;
+  if (!cgImage)
+    return 0;
+  return CGImageGetBytesPerRow(cgImage) * CGImageGetHeight(cgImage);
+}
+
+static NSDictionary<NSString *, NSString *> *ENRMNormalizedImageHeaders(NSDictionary<NSString *, NSString *> *headers)
+{
+  NSMutableDictionary<NSString *, NSString *> *normalized = [NSMutableDictionary dictionary];
+  for (NSString *name in [headers.allKeys sortedArrayUsingSelector:@selector(compare:)])
+    normalized[name.lowercaseString] = headers[name];
+  return normalized;
+}
+
+NSString *ENRMImageCacheKey(NSString *url, NSDictionary<NSString *, NSString *> *headers)
+{
+  if (headers.count == 0) {
+    return url;
+  }
+  NSDictionary<NSString *, NSString *> *normalized = ENRMNormalizedImageHeaders(headers);
+  NSArray<NSString *> *names = [normalized.allKeys sortedArrayUsingSelector:@selector(compare:)];
+  NSMutableArray<NSString *> *pairs = [NSMutableArray arrayWithCapacity:names.count];
+  for (NSString *name in names) {
+    [pairs addObject:[NSString stringWithFormat:@"%@:%@", name, normalized[name]]];
+  }
+  NSString *joined = [pairs componentsJoinedByString:@"\n"];
+  NSData *data = [joined dataUsingEncoding:NSUTF8StringEncoding];
+  unsigned char digest[CC_SHA256_DIGEST_LENGTH];
+  CC_SHA256(data.bytes, (CC_LONG)data.length, digest);
+  NSMutableString *hash = [NSMutableString stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
+  for (int i = 0; i < CC_SHA256_DIGEST_LENGTH; i++) {
+    [hash appendFormat:@"%02x", digest[i]];
+  }
+  return [NSString stringWithFormat:@"%@|%@", url, hash];
+}
+
+@implementation ENRMImageDownloader {
+  NSURLSession *_session;
+  NSURLSession *_headerSession;
+  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];
+    // No URL cache: it keys by URL alone and would mix header sets.
+    NSURLSessionConfiguration *headerConfig = [config copy];
+    headerConfig.URLCache = nil;
+    _headerSession = [NSURLSession sessionWithConfiguration:headerConfig];
+    _inFlightRequests = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
+- (void)downloadURL:(NSString *)url
+            headers:(NSDictionary<NSString *, NSString *> *)headers
+         completion:(ENRMImageDownloadCompletion)completion
+{
+  if (url.length == 0) {
+    completion(nil);
+    return;
+  }
+
+  headers = ENRMNormalizedImageHeaders(headers);
+  BOOL isLocal = ENRMIsLocalImageURL(url);
+  NSString *cacheKey = isLocal ? url : ENRMImageCacheKey(url, headers);
+
+  RCTUIImage *cached = [[ENRMImageAttachment originalImageCache] objectForKey:cacheKey];
+  if (cached) {
+    completion(cached);
+    return;
+  }
+
+  if (isLocal) {
+    RCTUIImage *local = ENRMLoadLocalImage(url);
+    if (local) {
+      [[ENRMImageAttachment originalImageCache] setObject:local forKey:cacheKey cost:ENRMImageByteCost(local)];
+    }
+    completion(local);
+    return;
+  }
+
+  @synchronized(_inFlightRequests) {
+    NSMutableArray *existing = _inFlightRequests[cacheKey];
+    if (existing) {
+      [existing addObject:completion];
+      return;
+    }
+    _inFlightRequests[cacheKey] = [NSMutableArray arrayWithObject:completion];
+  }
+
+  NSURL *nsURL = [NSURL URLWithString:url];
+  if (!nsURL) {
+    [self dispatchCallbacksForKey:cacheKey image:nil];
+    return;
+  }
+
+  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:nsURL];
+  [headers enumerateKeysAndObjectsUsingBlock:^(NSString *name, NSString *value, BOOL *stop) {
+    [request setValue:value forHTTPHeaderField:name];
+  }];
+
+  NSURLSession *session = headers.count > 0 ? _headerSession : _session;
+  [[session dataTaskWithRequest:request
+              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:cacheKey
+                                                                 cost:ENRMImageByteCost(image)];
+                }
+
+                [self dispatchCallbacksForKey:cacheKey image:image];
+              }] resume];
+}
+
+- (void)dispatchCallbacksForKey:(NSString *)cacheKey image:(RCTUIImage *_Nullable)image
+{
+  NSArray<ENRMImageDownloadCompletion> *callbacks;
+  @synchronized(_inFlightRequests) {
+    callbacks = [_inFlightRequests[cacheKey] copy];
+    [_inFlightRequests removeObjectForKey:cacheKey];
+  }
+
+  if (!callbacks)
+    return;
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    for (ENRMImageDownloadCompletion cb in callbacks) {
+      cb(image);
+    }
+  });
+}
+
+@end

package/ios/utils/ENRMLatexErrorCoordinator.h

@@ -0,0 +1,27 @@
+#pragma once
+#import <Foundation/Foundation.h>
+
+#import "ENRMLatexErrorReporting.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Returns YES when the error was delivered to a live event emitter, NO when it
+/// must be queued and flushed once an emitter is attached.
+typedef BOOL (^ENRMLatexErrorEmit)(NSString *source, NSString *message, BOOL displayMode);
+
+/// Shared LaTeX-error plumbing for both host views. Owns the dedup set and the
+/// pending queue and wires reporters; the only per-view difference - casting
+/// `_eventEmitter` to the concrete type - stays in the `emit` block each view
+/// supplies.
+@interface ENRMLatexErrorCoordinator : NSObject
+
+- (instancetype)initWithEmit:(ENRMLatexErrorEmit)emit NS_DESIGNATED_INITIALIZER;
+- (instancetype)init NS_UNAVAILABLE;
+
+- (void)wireReporters:(NSArray<id<ENRMLatexErrorReporting>> *)reporters;
+- (void)reportSource:(NSString *)source message:(NSString *)message displayMode:(BOOL)displayMode;
+- (void)flushPending;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMLatexErrorCoordinator.mm

@@ -0,0 +1,75 @@
+#import "ENRMLatexErrorCoordinator.h"
+
+@interface ENRMPendingLatexError : NSObject
+@property (nonatomic, copy, readonly) NSString *source;
+@property (nonatomic, copy, readonly) NSString *message;
+@property (nonatomic, readonly) BOOL displayMode;
+@end
+
+@implementation ENRMPendingLatexError
+- (instancetype)initWithSource:(NSString *)source message:(NSString *)message displayMode:(BOOL)displayMode
+{
+  if (self = [super init]) {
+    _source = [source copy];
+    _message = [message copy];
+    _displayMode = displayMode;
+  }
+  return self;
+}
+@end
+
+@implementation ENRMLatexErrorCoordinator {
+  ENRMLatexErrorEmit _emit;
+  NSMutableSet<NSString *> *_reportedErrors;
+  NSMutableArray<ENRMPendingLatexError *> *_pendingErrors;
+}
+
+- (instancetype)initWithEmit:(ENRMLatexErrorEmit)emit
+{
+  if (self = [super init]) {
+    _emit = [emit copy];
+    _reportedErrors = [NSMutableSet set];
+    _pendingErrors = [NSMutableArray array];
+  }
+  return self;
+}
+
+- (void)wireReporters:(NSArray<id<ENRMLatexErrorReporting>> *)reporters
+{
+  if (reporters.count == 0)
+    return;
+  __weak __typeof(self) weakSelf = self;
+  ENRMLatexErrorHandler handler = ^(NSString *source, NSString *message, BOOL displayMode) {
+    [weakSelf reportSource:source message:message displayMode:displayMode];
+  };
+  for (id<ENRMLatexErrorReporting> reporter in reporters) {
+    reporter.onLatexError = handler;
+    [reporter reportLatexErrorIfNeeded];
+  }
+}
+
+- (void)reportSource:(NSString *)source message:(NSString *)message displayMode:(BOOL)displayMode
+{
+  NSString *key = [NSString stringWithFormat:@"%@ %@", displayMode ? @"B" : @"I", source];
+  if ([_reportedErrors containsObject:key])
+    return;
+  [_reportedErrors addObject:key];
+  if (!_emit(source, message, displayMode)) {
+    [_pendingErrors addObject:[[ENRMPendingLatexError alloc] initWithSource:source
+                                                                    message:message
+                                                                displayMode:displayMode]];
+  }
+}
+
+- (void)flushPending
+{
+  if (_pendingErrors.count == 0)
+    return;
+  NSArray<ENRMPendingLatexError *> *pending = [_pendingErrors copy];
+  [_pendingErrors removeAllObjects];
+  for (ENRMPendingLatexError *e in pending) {
+    _emit(e.source, e.message, e.displayMode);
+  }
+}
+
+@end

package/ios/utils/ENRMLatexErrorReporting.h

@@ -0,0 +1,13 @@
+#pragma once
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^ENRMLatexErrorHandler)(NSString *source, NSString *message, BOOL displayMode);
+
+@protocol ENRMLatexErrorReporting <NSObject>
+@property (nonatomic, copy, nullable) ENRMLatexErrorHandler onLatexError;
+- (void)reportLatexErrorIfNeeded;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMLinkContextMenus.h

@@ -0,0 +1,93 @@
+#pragma once
+#import "ENRMUIKit.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// One item of a link's long-press menu.
+@interface ENRMLinkContextMenuItem : NSObject
+@property (nonatomic, copy) NSString *text;
+/// SF Symbol name; empty for no icon.
+@property (nonatomic, copy) NSString *icon;
+@property (nonatomic, assign) BOOL disabled;
+@property (nonatomic, assign) BOOL destructive;
+@end
+
+/// The menu items for links whose URL matches `pattern`.
+@interface ENRMLinkContextMenuEntry : NSObject
+@property (nonatomic, copy) NSString *pattern;
+@property (nonatomic, copy) NSArray<ENRMLinkContextMenuItem *> *items;
+@end
+
+typedef void (^ENRMLinkContextMenuPressHandler)(NSString *url, NSString *pattern, NSString *itemText);
+
+/**
+ * The `linkContextMenuItems` prop: long-press menus for links, by URL pattern.
+ * Entries are tried in order, like link variants, and the first whose pattern
+ * matches a URL supplies its menu. Menus need iOS 17; below that no URL has one.
+ */
+@interface ENRMLinkContextMenus : NSObject
+@property (nonatomic, copy) NSArray<ENRMLinkContextMenuEntry *> *entries;
+@property (nonatomic, copy, nullable) ENRMLinkContextMenuPressHandler onPress;
+- (BOOL)hasMenuForURL:(nullable NSString *)url;
+#if !TARGET_OS_OSX
+/// `title` is what the user sees the link as: its text, or its pill label.
+- (nullable UIMenu *)menuForURL:(nullable NSString *)url title:(nullable NSString *)title;
+#endif
+@end
+
+#if !TARGET_OS_OSX
+/// Adopted by a text view's delegate to supply the long-press menus of its links.
+@protocol ENRMLinkContextMenuSource <NSObject>
+- (nullable ENRMLinkContextMenus *)linkContextMenusForTextView:(UITextView *)textView;
+@end
+
+/// Adopted by a text view that presents the menus of some of its links itself.
+@protocol ENRMLinkMenuPresenting <NSObject>
+/// UIKit must be given no menu for such a link, or it lifts the link as a text item as well.
+- (BOOL)presentsLinkMenuAtIndex:(NSUInteger)index;
+@end
+
+/**
+ * The copy of a link that its long-press menu lifts.
+ *
+ * UIKit draws a menu's preview only from a view that is on screen, and hides that view for as
+ * long as the menu is open. Lifting part of a larger view through a visible path would hide
+ * all of it, and a detached view stays blank until the menu appears. So the link is lifted as
+ * an image of itself, laid over the view it belongs to and taken down when the menu ends.
+ */
+@interface ENRMLinkMenuLift : NSObject
+/// Called when the image is taken down, for the owner to restore what the image stood in for.
+@property (nonatomic, copy, nullable) void (^onEnd)(void);
+/// Whether an image is laid over `view`.
+- (BOOL)isOverView:(UIView *)view;
+/// Takes down the image laid before, if any.
+- (void)layImage:(UIImage *)image atFrame:(CGRect)frame overView:(UIView *)view;
+/// The preview that lifts the laid image, nil when there is none. A nil `backgroundColor`
+/// leaves UIKit's own behind the image.
+- (nullable UITargetedPreview *)previewWithCornerRadius:(CGFloat)cornerRadius
+                                        backgroundColor:(nullable UIColor *)backgroundColor;
+- (void)end;
+/// Ends once the menu has animated away, unless another image was laid in the meantime.
+- (void)endWithAnimator:(nullable id<UIContextMenuInteractionAnimating>)animator;
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * What a long press on a text item shows: the link's configured menu, or what links did before
+ * menus existed (the system menu with a preview, or `onLinkLongPress` when previews are off).
+ * Every text view delegate answers `textView:menuConfigurationForTextItem:defaultMenu:` with this.
+ * A link whose menu the text view presents itself (`ENRMLinkMenuPresenting`) gets none here.
+ */
+UITextItemMenuConfiguration *_Nullable ENRMLinkMenuConfigurationForTextItem(
+    UITextView *textView, UITextItem *textItem, UIMenu *defaultMenu, ENRMLinkContextMenus *_Nullable menus,
+    BOOL linkPreviewEnabled, void (^_Nullable onLinkLongPress)(NSString *url)) API_AVAILABLE(ios(17.0));
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMLinkContextMenus.m

@@ -0,0 +1,178 @@
+#import "ENRMLinkContextMenus.h"
+#import "LinkTapUtils.h"
+
+@implementation ENRMLinkContextMenuItem
+@end
+
+@implementation ENRMLinkContextMenuEntry
+@end
+
+@implementation ENRMLinkContextMenus {
+  NSArray<NSRegularExpression *> *_regexes;
+  // A long press asks about the same URL several times (gesture gating, then the menu).
+  NSMutableDictionary<NSString *, id> *_entriesByURL;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _entries = @[];
+    _regexes = @[];
+    _entriesByURL = [NSMutableDictionary new];
+  }
+  return self;
+}
+
+- (void)setEntries:(NSArray<ENRMLinkContextMenuEntry *> *)entries
+{
+  NSMutableArray<ENRMLinkContextMenuEntry *> *valid = [NSMutableArray arrayWithCapacity:entries.count];
+  NSMutableArray<NSRegularExpression *> *regexes = [NSMutableArray arrayWithCapacity:entries.count];
+  for (ENRMLinkContextMenuEntry *entry in entries) {
+    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:entry.pattern options:0 error:nil];
+    if (!regex || entry.items.count == 0)
+      continue;
+    [valid addObject:entry];
+    [regexes addObject:regex];
+  }
+  _entries = [valid copy];
+  _regexes = [regexes copy];
+  [_entriesByURL removeAllObjects];
+}
+
+- (nullable ENRMLinkContextMenuEntry *)entryForURL:(NSString *)url
+{
+  if (url.length == 0 || _entries.count == 0)
+    return nil;
+  id cached = _entriesByURL[url];
+  if (cached)
+    return cached == NSNull.null ? nil : cached;
+
+  ENRMLinkContextMenuEntry *match = nil;
+  NSRange whole = NSMakeRange(0, url.length);
+  for (NSUInteger index = 0; index < _regexes.count; index++) {
+    if ([_regexes[index] rangeOfFirstMatchInString:url options:0 range:whole].location != NSNotFound) {
+      match = _entries[index];
+      break;
+    }
+  }
+  _entriesByURL[url] = match ?: NSNull.null;
+  return match;
+}
+
+- (BOOL)hasMenuForURL:(NSString *)url
+{
+#if !TARGET_OS_OSX
+  if (@available(iOS 17.0, *))
+    return [self entryForURL:url] != nil;
+#endif
+  return NO;
+}
+
+#if !TARGET_OS_OSX
+- (UIMenu *)menuForURL:(NSString *)url title:(NSString *)title
+{
+  if (![self hasMenuForURL:url])
+    return nil;
+  ENRMLinkContextMenuEntry *entry = [self entryForURL:url];
+  NSString *pattern = entry.pattern;
+  NSMutableArray<UIAction *> *actions = [NSMutableArray arrayWithCapacity:entry.items.count];
+  __weak ENRMLinkContextMenus *weakSelf = self;
+  for (ENRMLinkContextMenuItem *item in entry.items) {
+    NSString *text = item.text;
+    UIAction *action = [UIAction actionWithTitle:text
+                                           image:item.icon.length > 0 ? [UIImage systemImageNamed:item.icon] : nil
+                                      identifier:nil
+                                         handler:^(__kindof UIAction *pressed) {
+                                           ENRMLinkContextMenuPressHandler onPress = weakSelf.onPress;
+                                           if (onPress)
+                                             onPress(url, pattern, text);
+                                         }];
+    if (item.disabled)
+      action.attributes |= UIMenuElementAttributesDisabled;
+    if (item.destructive)
+      action.attributes |= UIMenuElementAttributesDestructive;
+    [actions addObject:action];
+  }
+  return [UIMenu menuWithTitle:title ?: @"" children:actions];
+}
+#endif
+@end
+
+#if !TARGET_OS_OSX
+@implementation ENRMLinkMenuLift {
+  UIImageView *_imageView;
+}
+
+- (BOOL)isOverView:(UIView *)view
+{
+  return _imageView != nil && _imageView.superview == view;
+}
+
+- (void)layImage:(UIImage *)image atFrame:(CGRect)frame overView:(UIView *)view
+{
+  [self end];
+  _imageView = [[UIImageView alloc] initWithImage:image];
+  _imageView.frame = frame;
+  [view addSubview:_imageView];
+}
+
+- (UITargetedPreview *)previewWithCornerRadius:(CGFloat)cornerRadius backgroundColor:(UIColor *)backgroundColor
+{
+  if (_imageView.window == nil)
+    return nil;
+  UIPreviewParameters *parameters = [[UIPreviewParameters alloc] init];
+  if (backgroundColor)
+    parameters.backgroundColor = backgroundColor;
+  parameters.visiblePath = [UIBezierPath bezierPathWithRoundedRect:_imageView.bounds cornerRadius:cornerRadius];
+  return [[UITargetedPreview alloc] initWithView:_imageView parameters:parameters];
+}
+
+- (void)end
+{
+  if (!_imageView)
+    return;
+  [_imageView removeFromSuperview];
+  _imageView = nil;
+  if (self.onEnd)
+    self.onEnd();
+}
+
+- (void)endWithAnimator:(id<UIContextMenuInteractionAnimating>)animator
+{
+  UIImageView *laid = _imageView;
+  if (!laid)
+    return;
+  __weak ENRMLinkMenuLift *weakSelf = self;
+  void (^end)(void) = ^{
+    ENRMLinkMenuLift *strongSelf = weakSelf;
+    if (strongSelf && strongSelf->_imageView == laid)
+      [strongSelf end];
+  };
+  if (animator)
+    [animator addCompletion:end];
+  else
+    end();
+}
+
+@end
+
+UITextItemMenuConfiguration *ENRMLinkMenuConfigurationForTextItem(UITextView *textView, UITextItem *textItem,
+                                                                  UIMenu *defaultMenu, ENRMLinkContextMenus *menus,
+                                                                  BOOL linkPreviewEnabled,
+                                                                  void (^onLinkLongPress)(NSString *url))
+{
+  if ([textView conformsToProtocol:@protocol(ENRMLinkMenuPresenting)] &&
+      [(id<ENRMLinkMenuPresenting>)textView presentsLinkMenuAtIndex:textItem.range.location])
+    return nil;
+  NSString *url = linkURLAtRange(textView, textItem.range);
+  UIMenu *menu = [menus menuForURL:url title:linkTitleAtIndex(textView.textStorage, textItem.range.location)];
+  if (menu)
+    return [UITextItemMenuConfiguration configurationWithMenu:menu];
+  if (url && !linkPreviewEnabled) {
+    if (onLinkLongPress)
+      onLinkLongPress(url);
+    return nil;
+  }
+  return [UITextItemMenuConfiguration configurationWithMenu:defaultMenu];
+}
+#endif

package/ios/utils/ENRMLinkRegexConfig.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ENRMLinkRegexConfig : NSObject
+
+@property (nonatomic, copy, readonly) NSString *pattern;
+@property (nonatomic, assign, readonly) BOOL caseInsensitive;
+@property (nonatomic, assign, readonly) BOOL dotAll;
+@property (nonatomic, assign, readonly) BOOL isDisabled;
+@property (nonatomic, assign, readonly) BOOL isDefault;
+@property (nonatomic, strong, readonly, nullable) NSRegularExpression *parsedRegex;
+@property (nonatomic, strong, readonly, nullable) NSRegularExpression *parsedWholeSpanRegex;
+
+- (instancetype)initWithPattern:(NSString *)pattern
+                caseInsensitive:(BOOL)caseInsensitive
+                         dotAll:(BOOL)dotAll
+                     isDisabled:(BOOL)isDisabled
+                      isDefault:(BOOL)isDefault;
+
+/// Shared instance per pattern and flags; the renderer's props go through here. Thread-safe.
++ (instancetype)cachedConfigWithPattern:(NSString *)pattern caseInsensitive:(BOOL)caseInsensitive dotAll:(BOOL)dotAll;
+
+- (BOOL)isEqualToConfig:(nullable ENRMLinkRegexConfig *)other;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/utils/ENRMLinkRegexConfig.mm

@@ -0,0 +1,104 @@
+#import "ENRMLinkRegexConfig.h"
+
+#import <React/RCTLog.h>
+
+@implementation ENRMLinkRegexConfig {
+  NSRegularExpression *_parsedWholeSpanRegex;
+  BOOL _wholeSpanResolved;
+}
+
+- (instancetype)initWithPattern:(NSString *)pattern
+                caseInsensitive:(BOOL)caseInsensitive
+                         dotAll:(BOOL)dotAll
+                     isDisabled:(BOOL)isDisabled
+                      isDefault:(BOOL)isDefault
+{
+  self = [super init];
+  if (!self) {
+    return nil;
+  }
+
+  _pattern = [pattern copy];
+  _caseInsensitive = caseInsensitive;
+  _dotAll = dotAll;
+  _isDisabled = isDisabled;
+  _isDefault = isDefault;
+  _parsedRegex = nil;
+
+  if (!_isDefault && !_isDisabled && _pattern.length > 0) {
+    NSError *error = nil;
+    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:_pattern
+                                                                           options:[self options]
+                                                                             error:&error];
+    if (error) {
+      RCTLogWarn(@"[EnrichedTiptap]: The link regex '%@' is not a valid NSRegularExpression and is ignored.",
+                 _pattern);
+    } else {
+      _parsedRegex = regex;
+    }
+  }
+
+  return self;
+}
+
++ (instancetype)cachedConfigWithPattern:(NSString *)pattern caseInsensitive:(BOOL)caseInsensitive dotAll:(BOOL)dotAll
+{
+  static NSCache<NSString *, ENRMLinkRegexConfig *> *cache;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    cache = [[NSCache alloc] init];
+    cache.countLimit = 64;
+  });
+  NSString *key = [NSString stringWithFormat:@"%d%d%@", caseInsensitive, dotAll, pattern];
+  ENRMLinkRegexConfig *config = [cache objectForKey:key];
+  if (!config) {
+    config = [[self alloc] initWithPattern:pattern
+                           caseInsensitive:caseInsensitive
+                                    dotAll:dotAll
+                                isDisabled:NO
+                                 isDefault:NO];
+    [cache setObject:config forKey:key];
+  }
+  return config;
+}
+
+- (NSRegularExpressionOptions)options
+{
+  NSRegularExpressionOptions options = 0;
+  if (_caseInsensitive) {
+    options |= NSRegularExpressionCaseInsensitive;
+  }
+  if (_dotAll) {
+    options |= NSRegularExpressionDotMatchesLineSeparators;
+  }
+  return options;
+}
+
+- (NSRegularExpression *)parsedWholeSpanRegex
+{
+  if (_parsedRegex == nil) {
+    return nil;
+  }
+  @synchronized(self) {
+    if (!_wholeSpanResolved) {
+      // Anchor the whole alternation so `a|ab` matches "ab" in full.
+      _parsedWholeSpanRegex =
+          [NSRegularExpression regularExpressionWithPattern:[NSString stringWithFormat:@"\\A(?:%@)\\z", _pattern]
+                                                    options:[self options]
+                                                      error:nil];
+      _wholeSpanResolved = YES;
+    }
+    return _parsedWholeSpanRegex;
+  }
+}
+
+- (BOOL)isEqualToConfig:(ENRMLinkRegexConfig *)other
+{
+  if (other == nil) {
+    return NO;
+  }
+  return [_pattern isEqualToString:other.pattern] && _caseInsensitive == other.caseInsensitive &&
+         _dotAll == other.dotAll && _isDefault == other.isDefault && _isDisabled == other.isDisabled;
+}
+
+@end