@fendent/react-native-enriched 0.5.2-fork.1

package/ios/inputTextView/InputTextView.h

@@ -0,0 +1,6 @@
+#pragma once
+#import <UIkit/UIKit.h>
+
+@interface InputTextView : UITextView
+@property(nonatomic, weak) id input;
+@end

package/ios/inputTextView/InputTextView.mm

@@ -0,0 +1,285 @@
+#import "InputTextView.h"
+#import "EnrichedTextInputView.h"
+#import "StringExtension.h"
+#import "TextInsertionUtils.h"
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
+
+@implementation InputTextView
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  // UITextView resets contentSize during its own layout pass (triggered when
+  // the frame is set on first mount). Re-schedule a relayout so our explicit
+  // contentSize is applied after UITextView finishes its internal layout.
+  EnrichedTextInputView *input = (EnrichedTextInputView *)_input;
+  if (input != nil) {
+    [input scheduleRelayoutIfNeeded];
+  }
+}
+
+- (void)copy:(id)sender {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)_input;
+  if (typedInput == nullptr) {
+    return;
+  }
+
+  // remove zero width spaces before copying the text
+  NSString *plainText = [typedInput->textView.textStorage.string
+      substringWithRange:typedInput->textView.selectedRange];
+  NSString *fixedPlainText =
+      [plainText stringByReplacingOccurrencesOfString:@"\u200B" withString:@""];
+
+  NSString *parsedHtml = [typedInput->parser
+      parseToHtmlFromRange:typedInput->textView.selectedRange];
+
+  NSMutableAttributedString *attrStr = [[typedInput->textView.textStorage
+      attributedSubstringFromRange:typedInput->textView.selectedRange]
+      mutableCopy];
+  NSRange fullAttrStrRange = NSMakeRange(0, attrStr.length);
+  [attrStr.mutableString replaceOccurrencesOfString:@"\u200B"
+                                         withString:@""
+                                            options:0
+                                              range:fullAttrStrRange];
+
+  NSData *rtfData =
+      [attrStr dataFromRange:NSMakeRange(0, attrStr.length)
+          documentAttributes:@{
+            NSDocumentTypeDocumentAttribute : NSRTFTextDocumentType
+          }
+                       error:nullptr];
+
+  UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+  [pasteboard setItems:@[ @{
+                UTTypeUTF8PlainText.identifier : fixedPlainText,
+                UTTypeHTML.identifier : parsedHtml,
+                UTTypeRTF.identifier : rtfData
+              } ]];
+}
+
+- (void)paste:(id)sender {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)_input;
+  if (typedInput == nullptr) {
+    return;
+  }
+
+  UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+  NSArray<NSString *> *pasteboardTypes = pasteboard.pasteboardTypes;
+  NSRange currentRange = typedInput->textView.selectedRange;
+
+  // Check the pasteboard for supported image formats. If found, save them to
+  // temporary storage then emit the 'onPasteImages' event and stop processing
+  // further (ignoring any HTML/Text).
+  NSMutableArray<NSDictionary *> *foundImages = [NSMutableArray new];
+
+  for (NSDictionary<NSString *, id> *item in pasteboard.items) {
+    NSData *imageData = nil;
+    BOOL added = NO;
+    NSString *ext = nil;
+    NSString *mimeType = nil;
+
+    for (int j = 0; j < item.allKeys.count; j++) {
+      if (added) {
+        break;
+      }
+
+      NSString *type = item.allKeys[j];
+      if ([type isEqual:UTTypeJPEG.identifier] ||
+          [type isEqual:UTTypePNG.identifier] ||
+          [type isEqual:UTTypeHEIC.identifier] ||
+          [type isEqual:UTTypeTIFF.identifier]) {
+        imageData = [self getDataForImageItem:item[type] type:type];
+      } else if ([type isEqual:UTTypeWebP.identifier] ||
+                 [type isEqual:UTTypeGIF.identifier]) {
+        // webp and gifs: read raw bytes directly — no re-encoding needed
+        imageData = [pasteboard dataForPasteboardType:type];
+      }
+      if (!imageData) {
+        continue;
+      }
+
+      NSDictionary *info = [self detectImageFormat:type];
+      if (!info) {
+        continue;
+      }
+      ext = info[@"ext"];
+      mimeType = info[@"mime"];
+
+      UIImage *imageInfo = [UIImage imageWithData:imageData];
+
+      if (imageInfo) {
+        NSString *path = [self saveToTempFile:imageData extension:ext];
+
+        if (path) {
+          added = YES;
+          [foundImages addObject:@{
+            @"uri" : path,
+            @"type" : mimeType,
+            @"width" : @(imageInfo.size.width),
+            @"height" : @(imageInfo.size.height)
+          }];
+        }
+      }
+    }
+  }
+
+  if (foundImages.count > 0) {
+    [typedInput emitOnPasteImagesEvent:foundImages];
+    return;
+  }
+
+  if ([pasteboardTypes containsObject:UTTypeHTML.identifier]) {
+    // we try processing the html contents
+
+    NSString *htmlString;
+    id htmlValue = [pasteboard valueForPasteboardType:UTTypeHTML.identifier];
+
+    if ([htmlValue isKindOfClass:[NSData class]]) {
+      htmlString = [[NSString alloc] initWithData:htmlValue
+                                         encoding:NSUTF8StringEncoding];
+    } else if ([htmlValue isKindOfClass:[NSString class]]) {
+      htmlString = htmlValue;
+    }
+
+    // validate the html
+    NSString *initiallyProcessedHtml =
+        [typedInput->parser initiallyProcessHtml:htmlString];
+
+    if (initiallyProcessedHtml != nullptr) {
+      // valid html, let's apply it
+      currentRange.length > 0
+          ? [typedInput->parser replaceFromHtml:initiallyProcessedHtml
+                                          range:currentRange]
+          : [typedInput->parser insertFromHtml:initiallyProcessedHtml
+                                      location:currentRange.location];
+    } else {
+      // fall back to plain text, otherwise do nothing
+      [self tryHandlingPlainTextItemsIn:pasteboard
+                                  range:currentRange
+                                  input:typedInput];
+    }
+  } else {
+    [self tryHandlingPlainTextItemsIn:pasteboard
+                                range:currentRange
+                                input:typedInput];
+  }
+
+  [typedInput anyTextMayHaveBeenModified];
+}
+
+- (NSDictionary *)detectImageFormat:(NSString *)type {
+  if ([type isEqual:UTTypeJPEG.identifier]) {
+    return @{@"ext" : @"jpg", @"mime" : @"image/jpeg"};
+  } else if ([type isEqual:UTTypePNG.identifier]) {
+    return @{@"ext" : @"png", @"mime" : @"image/png"};
+  } else if ([type isEqual:UTTypeGIF.identifier]) {
+    return @{@"ext" : @"gif", @"mime" : @"image/gif"};
+  } else if ([type isEqual:UTTypeHEIC.identifier]) {
+    return @{@"ext" : @"heic", @"mime" : @"image/heic"};
+  } else if ([type isEqual:UTTypeWebP.identifier]) {
+    return @{@"ext" : @"webp", @"mime" : @"image/webp"};
+  } else if ([type isEqual:UTTypeTIFF.identifier]) {
+    return @{@"ext" : @"tiff", @"mime" : @"image/tiff"};
+  } else {
+    return nil;
+  }
+}
+
+- (NSData *)getDataForImageItem:(NSData *)imageData type:(NSString *)type {
+  UIImage *image = (UIImage *)imageData;
+
+  if ([type isEqual:UTTypePNG.identifier]) {
+    return UIImagePNGRepresentation(image);
+  } else if ([type isEqual:UTTypeHEIC.identifier]) {
+    return UIImageHEICRepresentation(image);
+  } else {
+    return UIImageJPEGRepresentation(image, 1.0);
+  }
+}
+
+- (NSString *)saveToTempFile:(NSData *)data extension:(NSString *)ext {
+  if (!data)
+    return nil;
+  NSString *fileName =
+      [NSString stringWithFormat:@"%@.%@", [NSUUID UUID].UUIDString, ext];
+
+  NSString *filePath =
+      [NSTemporaryDirectory() stringByAppendingPathComponent:fileName];
+
+  if ([data writeToFile:filePath atomically:YES]) {
+    return [NSURL fileURLWithPath:filePath].absoluteString;
+  }
+
+  return nil;
+}
+
+- (void)tryHandlingPlainTextItemsIn:(UIPasteboard *)pasteboard
+                              range:(NSRange)range
+                              input:(EnrichedTextInputView *)input {
+  NSArray *existingTypes = pasteboard.pasteboardTypes;
+  NSArray *handledTypes = @[
+    UTTypeUTF8PlainText.identifier, UTTypePlainText.identifier,
+    UTTypeURL.identifier
+  ];
+  NSString *plainText;
+
+  for (NSString *type in handledTypes) {
+    if (![existingTypes containsObject:type]) {
+      continue;
+    }
+
+    id value = [pasteboard valueForPasteboardType:type];
+
+    if ([value isKindOfClass:[NSData class]]) {
+      plainText = [[NSString alloc] initWithData:value
+                                        encoding:NSUTF8StringEncoding];
+    } else if ([value isKindOfClass:[NSString class]]) {
+      plainText = (NSString *)value;
+    } else if ([value isKindOfClass:[NSURL class]]) {
+      plainText = [(NSURL *)value absoluteString];
+    }
+  }
+
+  if (!plainText) {
+    return;
+  }
+
+  range.length > 0 ? [TextInsertionUtils replaceText:plainText
+                                                  at:range
+                                additionalAttributes:nullptr
+                                               input:input
+                                       withSelection:YES]
+                   : [TextInsertionUtils insertText:plainText
+                                                 at:range.location
+                               additionalAttributes:nullptr
+                                              input:input
+                                      withSelection:YES];
+}
+
+- (void)cut:(id)sender {
+  EnrichedTextInputView *typedInput = (EnrichedTextInputView *)_input;
+  if (typedInput == nullptr) {
+    return;
+  }
+
+  [self copy:sender];
+  [TextInsertionUtils replaceText:@""
+                               at:typedInput->textView.selectedRange
+             additionalAttributes:nullptr
+                            input:typedInput
+                    withSelection:YES];
+
+  [typedInput anyTextMayHaveBeenModified];
+}
+
+- (BOOL)canPerformAction:(SEL)action withSender:(id)sender {
+  if (action == @selector(paste:)) {
+    UIPasteboard *pasteboard = [UIPasteboard generalPasteboard];
+    // Enable Paste if clipboard has Text OR Images
+    if (pasteboard.hasStrings || pasteboard.hasImages) {
+      return YES;
+    }
+  }
+  return [super canPerformAction:action withSender:sender];
+}
+
+@end

package/ios/interfaces/AttributeEntry.h

@@ -0,0 +1,9 @@
+#pragma once
+#import <UIKit/UIKit.h>
+
+@interface AttributeEntry : NSObject
+
+@property NSString *key;
+@property id value;
+
+@end

package/ios/interfaces/AttributeEntry.mm

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

package/ios/interfaces/BaseStyleProtocol.h

@@ -0,0 +1,17 @@
+#pragma once
+#import "StylePair.h"
+#import "StyleTypeEnum.h"
+
+@protocol BaseStyleProtocol <NSObject>
++ (StyleType)getStyleType;
++ (BOOL)isParagraphStyle;
+- (instancetype _Nonnull)initWithInput:(id _Nonnull)input;
+- (void)applyStyle:(NSRange)range;
+- (void)addAttributes:(NSRange)range withTypingAttr:(BOOL)withTypingAttr;
+- (void)removeAttributes:(NSRange)range;
+- (void)addTypingAttributes;
+- (void)removeTypingAttributes;
+- (BOOL)detectStyle:(NSRange)range;
+- (BOOL)anyOccurence:(NSRange)range;
+- (NSArray<StylePair *> *_Nullable)findAllOccurences:(NSRange)range;
+@end

package/ios/interfaces/ImageAttachment.h

@@ -0,0 +1,11 @@
+#import "ImageData.h"
+#import "MediaAttachment.h"
+
+@interface ImageAttachment : MediaAttachment
+
+@property(nonatomic, strong) ImageData *imageData;
+@property(nonatomic, strong) UIImage *storedAnimatedImage;
+
+- (instancetype)initWithImageData:(ImageData *)data;
+
+@end

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 GIF parser. It safely acts as a universal parser, returning
+    // a single-frame UIImage for static formats and an animated UIImage for
+    // GIFs.
+    UIImage *img = bytes ? [UIImage animatedImageWithAnimatedGIFData: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,29 @@
+#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;
+}
+
+@end

package/ios/interfaces/LinkRegexConfig.h

@@ -0,0 +1,19 @@
+#pragma once
+#import <ReactNativeEnriched/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,13 @@
+#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;
+@end