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

package/ios/enrichedInputTextView/EnrichedInputTextView.h

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

package/ios/enrichedInputTextView/EnrichedInputTextView.mm

@@ -0,0 +1,334 @@
+#import "EnrichedInputTextView.h"
+#import "AlignmentUtils.h"
+#import "EnrichedTextInputView.h"
+#import "HtmlParser.h"
+#import "StringExtension.h"
+#import "TextInsertionUtils.h"
+#import "TextListsUtils.h"
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
+
+@implementation EnrichedInputTextView
+
+- (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];
+  }
+}
+
+// UITextView places the cursor at the leading edge when a paragraph contains
+// zero (or invisible) glyphs because the layout engine has nothing to align.
+// We fix this by reading the active alignment and repositioning the caret rect
+- (CGRect)caretRectForPosition:(UITextPosition *)position {
+  CGRect rect = [super caretRectForPosition:position];
+  NSUInteger idx = [self offsetFromPosition:self.beginningOfDocument
+                                 toPosition:position];
+  NSString *text = self.textStorage.string;
+  NSRange paraRange = NSMakeRange(0, 0);
+  if (idx <= text.length) {
+    paraRange = [text paragraphRangeForRange:NSMakeRange(idx, 0)];
+  }
+
+  // Non-empty paragraph gets its caret drawn the usual way.
+  if (paraRange.length != 0) {
+    return rect;
+  }
+
+  NSParagraphStyle *pStyle =
+      self.typingAttributes[NSParagraphStyleAttributeName];
+
+  if (pStyle == nil) {
+    return rect;
+  }
+
+  NSString *marker =
+      [TextListsUtils firstTextListWithPrefix:@"EnrichedAlignment"
+                                      inArray:pStyle.textLists]
+          .markerFormat;
+  NSTextAlignment alignment = [AlignmentUtils markerToAlignment:marker];
+  CGFloat containerWidth = self.textContainer.size.width;
+
+  if (alignment == NSTextAlignmentCenter) {
+    rect.origin.x = (containerWidth - rect.size.width) / 2.0;
+  } else if (alignment == NSTextAlignmentRight) {
+    rect.origin.x = containerWidth - rect.size.width;
+  }
+
+  return rect;
+}
+
+- (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 =
+      [HtmlParser parseToHtmlFromRange:typedInput->textView.selectedRange
+                                  host:typedInput];
+
+  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]) {
+        id value = item[type];
+        if ([value isKindOfClass:[NSData class]]) {
+          // raw bytes available — no re-encoding needed
+          imageData = (NSData *)value;
+        } else if ([value isKindOfClass:[UIImage class]]) {
+          imageData = [self getDataForImageItem:(UIImage *)value 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:(UIImage *)image type:(NSString *)type {
+  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
+                                                host:input
+                                       withSelection:YES]
+                   : [TextInsertionUtils insertText:plainText
+                                                 at:range.location
+                               additionalAttributes:nullptr
+                                               host: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
+                             host: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/enrichedTextTextView/EnrichedTextTextView.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+@class EnrichedTextTouchHandler;
+@class EnrichedTextView;
+
+// Forwards single-finger touches to `EnrichedTextTouchHandler` before `super`
+// so link/mention pressed styling is not delayed by `UITextView` gesture
+// arbitration.
+@interface EnrichedTextTextView : UITextView
+
+@property(nonatomic, weak) EnrichedTextTouchHandler *touchHandler;
+@property(nonatomic, weak) EnrichedTextView *host;
+
+@end

package/ios/enrichedTextTextView/EnrichedTextTextView.mm

@@ -0,0 +1,71 @@
+#import "EnrichedTextTextView.h"
+#import "EnrichedTextTouchHandler.h"
+#import "EnrichedTextView.h"
+#import "HtmlParser.h"
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
+
+@implementation EnrichedTextTextView
+
+- (void)copy:(id)sender {
+  EnrichedTextView *host = self.host;
+  if (host == nullptr) {
+    return;
+  }
+
+  // remove zero width spaces before copying the text
+  NSString *plainText = [host.textView.textStorage.string
+      substringWithRange:host.textView.selectedRange];
+  NSString *fixedPlainText =
+      [plainText stringByReplacingOccurrencesOfString:@"\u200B" withString:@""];
+
+  NSString *parsedHtml =
+      [HtmlParser parseToHtmlFromRange:host.textView.selectedRange host:host];
+
+  NSMutableAttributedString *attrStr = [[host.textView.textStorage
+      attributedSubstringFromRange:host.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)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+  if (touches.count == 1) {
+    UITouch *touch = touches.anyObject;
+    CGPoint point = [touch locationInView:self];
+    [self.touchHandler handleTouchBeganAtPoint:point];
+  }
+  [super touchesBegan:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+  if (touches.count == 1) {
+    UITouch *touch = touches.anyObject;
+    CGPoint point = [touch locationInView:self];
+    [self.touchHandler handleTouchEndedAtPoint:point];
+  }
+  [super touchesEnded:touches withEvent:event];
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches
+               withEvent:(UIEvent *)event {
+  [self.touchHandler handleTouchCancelled];
+  [super touchesCancelled:touches withEvent:event];
+}
+
+@end

package/ios/extensions/ColorExtension.h

@@ -0,0 +1,8 @@
+#import <UIKit/UIKit.h>
+#pragma once
+
+@interface UIColor (ColorExtension)
+- (BOOL)isEqualToColor:(UIColor *)otherColor;
+- (UIColor *)colorWithResolvedAlpha;
+- (UIColor *)colorWithResolvedAlpha:(CGFloat)newAlpha;
+@end

package/ios/extensions/ColorExtension.mm

@@ -0,0 +1,48 @@
+#import "ColorExtension.h"
+
+@implementation UIColor (ColorExtension)
+- (BOOL)isEqualToColor:(UIColor *)otherColor {
+  CGColorSpaceRef colorSpaceRGB = CGColorSpaceCreateDeviceRGB();
+
+  UIColor * (^convertColorToRGBSpace)(UIColor *) = ^(UIColor *color) {
+    if (CGColorSpaceGetModel(CGColorGetColorSpace(color.CGColor)) ==
+        kCGColorSpaceModelMonochrome) {
+      const CGFloat *oldComponents = CGColorGetComponents(color.CGColor);
+      CGFloat components[4] = {oldComponents[0], oldComponents[0],
+                               oldComponents[0], oldComponents[1]};
+      CGColorRef colorRef = CGColorCreate(colorSpaceRGB, components);
+
+      UIColor *color = [UIColor colorWithCGColor:colorRef];
+      CGColorRelease(colorRef);
+      return color;
+    } else {
+      return color;
+    }
+  };
+
+  UIColor *selfColor = convertColorToRGBSpace(self);
+  otherColor = convertColorToRGBSpace(otherColor);
+  CGColorSpaceRelease(colorSpaceRGB);
+
+  return [selfColor isEqual:otherColor];
+}
+
+// Default fallback alpha of 0.4 — opaque colors get this applied so the text
+// cursor remains visible through the highlight. If the caller already set a
+// custom alpha (anything below 1.0), we respect that value instead.
+- (UIColor *)colorWithResolvedAlpha {
+  return [self colorWithResolvedAlpha:0.4];
+}
+
+- (UIColor *)colorWithResolvedAlpha:(CGFloat)newAlpha {
+  CGFloat alpha = 0.0;
+  [self getRed:nil green:nil blue:nil alpha:&alpha];
+  // alpha == 1.0 means the color was never given a custom transparency, so
+  // apply newAlpha. Any other value means the caller explicitly chose it —
+  // leave it untouched.
+  if (alpha >= 1.0) {
+    return [self colorWithAlphaComponent:newAlpha];
+  }
+  return self;
+}
+@end

package/ios/extensions/FontExtension.h

@@ -0,0 +1,11 @@
+#import <UIKit/UIKit.h>
+#pragma once
+
+@interface UIFont (FontExtension)
+- (BOOL)isBold;
+- (UIFont *)setBold;
+- (BOOL)isItalic;
+- (UIFont *)setItalic;
+- (UIFont *)withFontTraits:(UIFont *)from;
+- (UIFont *)setSize:(CGFloat)size;
+@end

package/ios/extensions/FontExtension.mm

@@ -0,0 +1,72 @@
+#import "FontExtension.h"
+#import <React/RCTLog.h>
+
+@implementation UIFont (FontExtension)
+
+- (BOOL)isBold {
+  return (self.fontDescriptor.symbolicTraits & UIFontDescriptorTraitBold) ==
+         UIFontDescriptorTraitBold;
+}
+
+- (UIFont *)setBold {
+  if ([self isBold]) {
+    return self;
+  }
+  UIFontDescriptorSymbolicTraits newTraits =
+      (self.fontDescriptor.symbolicTraits | UIFontDescriptorTraitBold);
+  UIFontDescriptor *fontDescriptor =
+      [self.fontDescriptor fontDescriptorWithSymbolicTraits:newTraits];
+  if (fontDescriptor != nullptr) {
+    return [UIFont fontWithDescriptor:fontDescriptor size:0];
+  } else {
+    RCTLogWarn(@"[EnrichedTextInput]: Couldn't apply bold trait to the font.");
+    return self;
+  }
+}
+
+- (BOOL)isItalic {
+  return (self.fontDescriptor.symbolicTraits & UIFontDescriptorTraitItalic) ==
+         UIFontDescriptorTraitItalic;
+}
+
+- (UIFont *)setItalic {
+  if ([self isItalic]) {
+    return self;
+  }
+  UIFontDescriptorSymbolicTraits newTraits =
+      (self.fontDescriptor.symbolicTraits | UIFontDescriptorTraitItalic);
+  UIFontDescriptor *fontDescriptor =
+      [self.fontDescriptor fontDescriptorWithSymbolicTraits:newTraits];
+  if (fontDescriptor != nullptr) {
+    return [UIFont fontWithDescriptor:fontDescriptor size:0];
+  } else {
+    RCTLogWarn(
+        @"[EnrichedTextInput]: Couldn't apply italic trait to the font.");
+    return self;
+  }
+}
+
+- (UIFont *)withFontTraits:(UIFont *)from {
+  UIFont *newFont = self;
+  if ([from isBold]) {
+    newFont = [newFont setBold];
+  }
+  if ([from isItalic]) {
+    newFont = [newFont setItalic];
+  }
+  return newFont;
+}
+
+- (UIFont *)setSize:(CGFloat)size {
+  UIFontDescriptor *newFontDescriptor =
+      [self.fontDescriptor fontDescriptorWithSize:size];
+  if (newFontDescriptor != nullptr) {
+    return [UIFont fontWithDescriptor:newFontDescriptor size:0];
+  } else {
+    RCTLogWarn(
+        @"[EnrichedTextInput]: Couldn't apply heading style to the font.");
+    return self;
+  }
+}
+
+@end

package/ios/extensions/ImageExtension.h

@@ -0,0 +1,33 @@
+#import <UIKit/UIKit.h>
+
+/**
+        UIImage (ImageExtension)
+
+    This category adds class methods to `UIImage` to create an animated
+   `UIImage` from animated image data (GIF or WebP).
+*/
+@interface UIImage (ImageExtension)
+
+/*
+        UIImage *animation = [UIImage animatedImageWithData:theData];
+
+    I interpret `theData` as an animated image (GIF or WebP).  I create an
+   animated `UIImage` using the source images and frame delays from the data.
+
+    The image stores a separate duration for each frame, in units of
+   centiseconds (hundredths of a second).  However, a `UIImage` only has a
+   single, total `duration` property, which is a floating-point number.
+
+    To handle this mismatch, I add each source image to `animation` a varying
+   number of times to match the ratios between the frame durations.
+
+    For example, suppose the image contains three frames.  Frame 0 has duration
+   3.  Frame 1 has duration 9.  Frame 2 has duration 15.  I divide each
+   duration by the greatest common denominator of all the durations, which is 3,
+   and add each frame the resulting number of times.  Thus `animation` will
+   contain frame 0 3/3 = 1 time, then frame 1 9/3 = 3 times, then frame 2
+   15/3 = 5 times.  I set `animation.duration` to (3+9+15)/100 = 0.27 seconds.
+*/
++ (UIImage *_Nullable)animatedImageWithData:(NSData *_Nonnull)theData;
+
+@end