react-native-enriched-html 0.0.0 → 1.1.0-nightly-20260617-3dfd09072

package/ios/interfaces/ImageAttachment.mm

@@ -0,0 +1,107 @@
+#import "ImageAttachment.h"
+#import "ImageExtension.h"
+
+// NSTextStorage frequently recreates NSTextAttachment objects during attribute
+// invalidation (e.g. on every keystroke). Without this cache each recreation
+// would trigger a fresh async network/disk load, causing images to flicker or
+// disappear temporarily. Caching by URI ensures that once an image is loaded it
+// is reused instantly for all subsequent attachment instances with the same
+// URI
+static NSCache<NSString *, UIImage *> *ImageAttachmentCache(void) {
+  static NSCache<NSString *, UIImage *> *cache = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    cache = [[NSCache alloc] init];
+    cache.totalCostLimit = 100 * 1024 * 1024; // 100 MB
+  });
+  return cache;
+}
+
+@implementation ImageAttachment
+
+- (instancetype)initWithImageData:(ImageData *)data {
+  self = [super initWithURI:data.uri width:data.width height:data.height];
+  if (!self)
+    return nil;
+
+  _imageData = data;
+  UIImage *cachedImage = nil;
+  if (self.uri.length > 0) {
+    cachedImage = [ImageAttachmentCache() objectForKey:self.uri];
+  }
+
+  // Assign an empty image to reserve layout space within the text system.
+  // The actual image is not drawn here; it is rendered and overlaid by a
+  // separate ImageView.
+  self.image = [UIImage new];
+
+  if (cachedImage != nil) {
+    self.storedAnimatedImage = cachedImage;
+  } else {
+    [self loadAsync];
+  }
+  return self;
+}
+
+- (CGRect)attachmentBoundsForTextContainer:(NSTextContainer *)textContainer
+                      proposedLineFragment:(CGRect)lineFrag
+                             glyphPosition:(CGPoint)position
+                            characterIndex:(NSUInteger)charIndex {
+  CGRect baseBounds = self.bounds;
+
+  if (!textContainer.layoutManager.textStorage ||
+      charIndex >= textContainer.layoutManager.textStorage.length) {
+    return baseBounds;
+  }
+
+  UIFont *font =
+      [textContainer.layoutManager.textStorage attribute:NSFontAttributeName
+                                                 atIndex:charIndex
+                                          effectiveRange:NULL];
+  if (!font) {
+    return baseBounds;
+  }
+
+  // Extend the layout bounds below the baseline by the font's descender.
+  // Without this, a line containing only the attachment has no descender space
+  // below the baseline, but adding a text character introduces it — causing
+  // the line height to jump.  By reserving descender space upfront the line
+  // height stays consistent regardless of whether text is present.
+  CGFloat descender = font.descender;
+  return CGRectMake(baseBounds.origin.x, descender, baseBounds.size.width,
+                    baseBounds.size.height - descender);
+}
+
+- (void)loadAsync {
+  NSURL *url = [NSURL URLWithString:self.uri];
+  if (!url) {
+    self.storedAnimatedImage = [UIImage systemImageNamed:@"photo"];
+    return;
+  }
+
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSData *bytes = [NSData dataWithContentsOfURL:url];
+
+    // We pass all image data (including static formats like PNG or JPEG)
+    // through the animated image parser. It safely acts as a universal parser,
+    // returning a single-frame UIImage for static formats and an animated
+    // UIImage for GIFs and WebPs.
+    UIImage *img = bytes ? [UIImage animatedImageWithData:bytes]
+                         : [UIImage systemImageNamed:@"photo"];
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (bytes != nil && img != nil && self.uri.length > 0) {
+        CGFloat scale = img.scale;
+        // Calculate true byte cost based on pixels
+        // Width (in pixels) * Height (in pixels) * 4 bytes (for RGBA channels)
+        NSUInteger cost = (NSUInteger)(img.size.width * scale *
+                                       img.size.height * scale * 4.0);
+        [ImageAttachmentCache() setObject:img forKey:self.uri cost:cost];
+      }
+      self.storedAnimatedImage = img;
+      [self notifyUpdate];
+    });
+  });
+}
+
+@end

package/ios/interfaces/ImageData.h

@@ -0,0 +1,10 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface ImageData : NSObject
+
+@property NSString *uri;
+@property CGFloat width;
+@property CGFloat height;
+
+@end

package/ios/interfaces/ImageData.mm

@@ -0,0 +1,4 @@
+#import "ImageData.h"
+
+@implementation ImageData
+@end

package/ios/interfaces/LinkData.h

@@ -0,0 +1,11 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface LinkData : NSObject <NSCopying>
+
+@property(nonatomic, copy) NSString *text;
+@property(nonatomic, copy) NSString *url;
+@property(nonatomic, assign) BOOL isManual;
+- (BOOL)isEqualToLinkData:(LinkData *)linkData;
+
+@end

package/ios/interfaces/LinkData.mm

@@ -0,0 +1,43 @@
+#import "LinkData.h"
+
+@implementation LinkData
+
+- (id)copyWithZone:(NSZone *)zone {
+  LinkData *copy = [[[self class] allocWithZone:zone] init];
+  if (copy) {
+    copy.text = [self.text copyWithZone:zone];
+    copy.url = [self.url copyWithZone:zone];
+    copy.isManual = self.isManual;
+  }
+  return copy;
+}
+
+- (BOOL)isEqualToLinkData:(LinkData *)linkData {
+  if (!linkData) {
+    return NO;
+  }
+
+  BOOL equalText = (!self.text && !linkData.text) ||
+                   [self.text isEqualToString:linkData.text];
+  BOOL equalUrl =
+      (!self.url && !linkData.url) || [self.url isEqualToString:linkData.url];
+  BOOL equalIsManual = (self.isManual == linkData.isManual);
+
+  return equalText && equalUrl && equalIsManual;
+}
+
+- (BOOL)isEqual:(id)other {
+  if (other == self) {
+    return YES;
+  }
+  if (![other isKindOfClass:[LinkData class]]) {
+    return NO;
+  }
+  return [self isEqualToLinkData:(LinkData *)other];
+}
+
+- (NSUInteger)hash {
+  return [self.text hash] ^ [self.url hash] ^ (self.isManual ? 1u : 0u);
+}
+
+@end

package/ios/interfaces/LinkRegexConfig.h

@@ -0,0 +1,19 @@
+#pragma once
+#import <ReactNativeEnrichedHtml/Props.h>
+#import <UIKit/UIKit.h>
+
+using namespace facebook::react;
+
+@interface LinkRegexConfig : NSObject
+
+@property NSString *pattern;
+@property BOOL caseInsensitive;
+@property BOOL dotAll;
+@property BOOL isDisabled;
+@property BOOL isDefault;
+
+- (instancetype)initWithLinkRegexProp:
+    (EnrichedTextInputViewLinkRegexStruct)prop;
+- (BOOL)isEqualToConfig:(LinkRegexConfig *)otherObj;
+
+@end

package/ios/interfaces/LinkRegexConfig.mm

@@ -0,0 +1,37 @@
+#import "LinkRegexConfig.h"
+#import "StringExtension.h"
+
+@implementation LinkRegexConfig
+
+- (instancetype)initWithLinkRegexProp:
+    (EnrichedTextInputViewLinkRegexStruct)prop {
+  if (!self)
+    return nil;
+
+  _pattern = [NSString fromCppString:prop.pattern];
+  _caseInsensitive = prop.caseInsensitive;
+  _dotAll = prop.dotAll;
+  _isDefault = prop.isDefault;
+  _isDisabled = prop.isDisabled;
+
+  return self;
+}
+
+- (id)copyWithZone:(NSZone *)zone {
+  LinkRegexConfig *copy = [[[self class] allocWithZone:zone] init];
+  copy->_pattern = [_pattern copy];
+  copy->_caseInsensitive = _caseInsensitive;
+  copy->_dotAll = _dotAll;
+  copy->_isDefault = _isDefault;
+  copy->_isDisabled = _isDisabled;
+  return copy;
+}
+
+- (BOOL)isEqualToConfig:(LinkRegexConfig *)otherObj {
+  return [_pattern isEqualToString:otherObj.pattern] &&
+         _caseInsensitive == otherObj.caseInsensitive &&
+         _dotAll == otherObj.dotAll && _isDefault == otherObj.isDefault &&
+         _isDisabled == otherObj.isDisabled;
+}
+
+@end

package/ios/interfaces/MediaAttachment.h

@@ -0,0 +1,23 @@
+#import <UIKit/UIKit.h>
+
+@class MediaAttachment;
+
+@protocol MediaAttachmentDelegate <NSObject>
+- (void)mediaAttachmentDidUpdate:(MediaAttachment *)attachment;
+@end
+
+@interface MediaAttachment : NSTextAttachment
+
+@property(nonatomic, weak) id<MediaAttachmentDelegate> delegate;
+@property(nonatomic, strong) NSString *uri;
+@property(nonatomic, assign) CGFloat width;
+@property(nonatomic, assign) CGFloat height;
+
+- (instancetype)initWithURI:(NSString *)uri
+                      width:(CGFloat)width
+                     height:(CGFloat)height;
+
+- (void)loadAsync;
+- (void)notifyUpdate;
+
+@end

package/ios/interfaces/MediaAttachment.mm

@@ -0,0 +1,31 @@
+#import "MediaAttachment.h"
+
+@implementation MediaAttachment
+
+- (instancetype)initWithURI:(NSString *)uri
+                      width:(CGFloat)width
+                     height:(CGFloat)height {
+  self = [super init];
+  if (!self)
+    return nil;
+
+  _uri = uri;
+  _width = width;
+  _height = height;
+
+  self.bounds = CGRectMake(0, 0, width, height);
+
+  return self;
+}
+
+- (void)loadAsync {
+  // no-op for base
+}
+
+- (void)notifyUpdate {
+  if ([self.delegate respondsToSelector:@selector(mediaAttachmentDidUpdate:)]) {
+    [self.delegate mediaAttachmentDidUpdate:self];
+  }
+}
+
+@end

package/ios/interfaces/MentionParams.h

@@ -0,0 +1,8 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface MentionParams : NSObject
+@property NSString *text;
+@property NSString *indicator;
+@property NSString *attributes;
+@end

package/ios/interfaces/MentionParams.mm

@@ -0,0 +1,4 @@
+#import "MentionParams.h"
+
+@implementation MentionParams
+@end

package/ios/interfaces/MentionStyleProps.h

@@ -0,0 +1,17 @@
+#pragma once
+#import "TextDecorationLineEnum.h"
+#import "string"
+#import <UIKit/UIKit.h>
+#import <folly/dynamic.h>
+
+@interface MentionStyleProps : NSObject
+@property UIColor *color;
+@property UIColor *backgroundColor;
+@property TextDecorationLineEnum decorationLine;
++ (NSDictionary *)getSinglePropsFromFollyDynamic:(folly::dynamic)folly;
++ (NSDictionary *)getComplexPropsFromFollyDynamic:(folly::dynamic)folly;
+
+// MARK: - Text only props
+@property UIColor *pressColor;
+@property UIColor *pressBackgroundColor;
+@end

package/ios/interfaces/MentionStyleProps.mm

@@ -0,0 +1,80 @@
+#import "MentionStyleProps.h"
+#import "StringExtension.h"
+#import <React/RCTConversions.h>
+
+@implementation MentionStyleProps
+
++ (MentionStyleProps *)getSingleMentionStylePropsFromFollyDynamic:
+    (folly::dynamic)folly {
+  MentionStyleProps *nativeProps = [[MentionStyleProps alloc] init];
+
+  if (folly["color"].isNumber()) {
+    facebook::react::SharedColor color = facebook::react::SharedColor(
+        facebook::react::Color(int32_t(folly["color"].asInt())));
+    nativeProps.color = RCTUIColorFromSharedColor(color);
+  } else {
+    nativeProps.color = [UIColor blueColor];
+  }
+
+  if (folly["backgroundColor"].isNumber()) {
+    facebook::react::SharedColor bgColor = facebook::react::SharedColor(
+        facebook::react::Color(int32_t(folly["backgroundColor"].asInt())));
+    nativeProps.backgroundColor = RCTUIColorFromSharedColor(bgColor);
+  } else {
+    nativeProps.backgroundColor = [UIColor yellowColor];
+  }
+
+  if (folly["textDecorationLine"].isString()) {
+    std::string textDecorationLine = folly["textDecorationLine"].asString();
+    nativeProps.decorationLine = [[NSString fromCppString:textDecorationLine]
+                                     isEqualToString:DecorationUnderline]
+                                     ? DecorationUnderline
+                                     : DecorationNone;
+  } else {
+    nativeProps.decorationLine = DecorationUnderline;
+  }
+
+  // text only
+  if (folly["pressColor"].isNumber()) {
+    facebook::react::SharedColor pressColor = facebook::react::SharedColor(
+        facebook::react::Color(int32_t(folly["pressColor"].asInt())));
+    nativeProps.pressColor = RCTUIColorFromSharedColor(pressColor);
+  } else {
+    nativeProps.pressColor = [UIColor blueColor];
+  }
+
+  if (folly["pressBackgroundColor"].isNumber()) {
+    facebook::react::SharedColor bgColor = facebook::react::SharedColor(
+        facebook::react::Color(int32_t(folly["pressBackgroundColor"].asInt())));
+    nativeProps.pressBackgroundColor = RCTUIColorFromSharedColor(bgColor);
+  } else {
+    nativeProps.pressBackgroundColor = [UIColor yellowColor];
+  }
+
+  return nativeProps;
+}
+
++ (NSDictionary *)getSinglePropsFromFollyDynamic:(folly::dynamic)folly {
+  MentionStyleProps *nativeProps =
+      [MentionStyleProps getSingleMentionStylePropsFromFollyDynamic:folly];
+  // the single props need to be somehow distinguishable in config
+  NSDictionary *dict = @{@"all" : nativeProps};
+  return dict;
+}
+
++ (NSDictionary *)getComplexPropsFromFollyDynamic:(folly::dynamic)folly {
+  NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
+
+  for (const auto &obj : folly.items()) {
+    if (obj.first.isString() && obj.second.isObject()) {
+      std::string key = obj.first.asString();
+      MentionStyleProps *props = [MentionStyleProps
+          getSingleMentionStylePropsFromFollyDynamic:obj.second];
+      dict[[NSString fromCppString:key]] = props;
+    }
+  }
+
+  return dict;
+}
+
+@end

package/ios/interfaces/StyleBase.h

@@ -0,0 +1,38 @@
+#pragma once
+#import "AttributeEntry.h"
+#import "EnrichedViewHost.h"
+#import "StylePair.h"
+#import "StyleTypeEnum.h"
+#import <UIKit/UIKit.h>
+
+@interface StyleBase : NSObject
+@property(nonatomic, weak) id<EnrichedViewHost> host;
++ (StyleType)getType;
+- (NSString *)getKey;
+- (NSString *)getValue;
+- (NSString *)getMarkerPrefix;
+- (BOOL)isParagraph;
+- (BOOL)needsZWS;
+- (BOOL)appliesStylingToTyping;
+- (instancetype)initWithHost:(id<EnrichedViewHost>)host;
+- (NSRange)actualUsedRange:(NSRange)range;
+- (void)toggle:(NSRange)range;
+- (void)add:(NSRange)range
+        withTyping:(BOOL)withTyping
+    withDirtyRange:(BOOL)withDirtyRange;
+- (void)add:(NSRange)range
+         withValue:(NSString *)value
+        withTyping:(BOOL)withTyping
+    withDirtyRange:(BOOL)withDirtyRange;
+- (void)remove:(NSRange)range withDirtyRange:(BOOL)withDirtyRange;
+- (void)addTypingWithValue:(NSString *)value;
+- (void)removeTyping;
+- (BOOL)styleCondition:(id)value range:(NSRange)range;
+- (BOOL)detect:(NSRange)range;
+- (BOOL)any:(NSRange)range;
+- (NSArray<StylePair *> *)all:(NSRange)range;
+- (void)applyStyling:(NSRange)range;
+- (void)applyStylingToTypingAttrs:(NSMutableDictionary *)attributes;
+- (void)reapplyFromStylePair:(StylePair *)pair;
+- (AttributeEntry *)getEntryIfPresent:(NSRange)range;
+@end