react-native-enriched 0.2.1 → 0.4.0

package/ios/config/InputConfig.h

@@ -1,4 +1,5 @@
 #pragma once
+#import "LinkRegexConfig.h"
 #import "MentionStyleProps.h"
 #import "TextDecorationLineEnum.h"
 #import <UIKit/UIKit.h>
@@ -29,6 +30,18 @@
 - (void)setH3FontSize:(CGFloat)newValue;
 - (BOOL)h3Bold;
 - (void)setH3Bold:(BOOL)newValue;
+- (CGFloat)h4FontSize;
+- (void)setH4FontSize:(CGFloat)newValue;
+- (BOOL)h4Bold;
+- (void)setH4Bold:(BOOL)newValue;
+- (CGFloat)h5FontSize;
+- (void)setH5FontSize:(CGFloat)newValue;
+- (BOOL)h5Bold;
+- (void)setH5Bold:(BOOL)newValue;
+- (CGFloat)h6FontSize;
+- (void)setH6FontSize:(CGFloat)newValue;
+- (BOOL)h6Bold;
+- (void)setH6Bold:(BOOL)newValue;
 - (UIColor *)blockquoteBorderColor;
 - (void)setBlockquoteBorderColor:(UIColor *)newValue;
 - (CGFloat)blockquoteBorderWidth;
@@ -70,4 +83,19 @@
 - (void)setCodeBlockBgColor:(UIColor *)newValue;
 - (CGFloat)codeBlockBorderRadius;
 - (void)setCodeBlockBorderRadius:(CGFloat)newValue;
+- (LinkRegexConfig *)linkRegexConfig;
+- (void)setLinkRegexConfig:(LinkRegexConfig *)newValue;
+- (NSRegularExpression *)parsedLinkRegex;
+- (void)invalidateFonts;
+- (NSNumber *)scaledPrimaryFontSize;
+- (CGFloat)checkboxListBoxSize;
+- (void)setCheckboxListBoxSize:(CGFloat)newValue;
+- (CGFloat)checkboxListGapWidth;
+- (void)setCheckboxListGapWidth:(CGFloat)newValue;
+- (CGFloat)checkboxListMarginLeft;
+- (void)setCheckboxListMarginLeft:(CGFloat)newValue;
+- (UIColor *)checkboxListBoxColor;
+- (void)setCheckboxListBoxColor:(UIColor *)newValue;
+- (UIImage *)checkboxCheckedImage;
+- (UIImage *)checkboxUncheckedImage;
 @end

package/ios/config/InputConfig.mm

@@ -17,6 +17,12 @@
   BOOL _h2Bold;
   CGFloat _h3FontSize;
   BOOL _h3Bold;
+  CGFloat _h4FontSize;
+  BOOL _h4Bold;
+  CGFloat _h5FontSize;
+  BOOL _h5Bold;
+  CGFloat _h6FontSize;
+  BOOL _h6Bold;
   UIColor *_blockquoteBorderColor;
   CGFloat _blockquoteBorderWidth;
   CGFloat _blockquoteGapWidth;
@@ -39,8 +45,14 @@
   UIColor *_codeBlockFgColor;
   CGFloat _codeBlockBorderRadius;
   UIColor *_codeBlockBgColor;
-  CGFloat _imageWidth;
-  CGFloat _imageHeight;
+  LinkRegexConfig *_linkRegexConfig;
+  NSRegularExpression *_parsedLinkRegex;
+  CGFloat _checkboxListBoxSize;
+  CGFloat _checkboxListGapWidth;
+  CGFloat _checkboxListMarginLeft;
+  UIColor *_checkboxListBoxColor;
+  UIImage *_checkboxCheckedImage;
+  UIImage *_checkboxUncheckedImage;
 }
 
 - (instancetype)init {
@@ -66,6 +78,12 @@
   copy->_h2Bold = _h2Bold;
   copy->_h3FontSize = _h3FontSize;
   copy->_h3Bold = _h3Bold;
+  copy->_h4FontSize = _h4FontSize;
+  copy->_h4Bold = _h4Bold;
+  copy->_h5FontSize = _h5FontSize;
+  copy->_h5Bold = _h5Bold;
+  copy->_h6FontSize = _h6FontSize;
+  copy->_h6Bold = _h6Bold;
   copy->_blockquoteBorderColor = [_blockquoteBorderColor copy];
   copy->_blockquoteBorderWidth = _blockquoteBorderWidth;
   copy->_blockquoteGapWidth = _blockquoteGapWidth;
@@ -87,6 +105,14 @@
   copy->_codeBlockFgColor = [_codeBlockFgColor copy];
   copy->_codeBlockBgColor = [_codeBlockBgColor copy];
   copy->_codeBlockBorderRadius = _codeBlockBorderRadius;
+  copy->_linkRegexConfig = [_linkRegexConfig copy];
+  copy->_parsedLinkRegex = [_parsedLinkRegex copy];
+  copy->_checkboxListBoxSize = _checkboxListBoxSize;
+  copy->_checkboxListGapWidth = _checkboxListGapWidth;
+  copy->_checkboxListMarginLeft = _checkboxListMarginLeft;
+  copy->_checkboxListBoxColor = [_checkboxListBoxColor copy];
+  copy->_checkboxCheckedImage = _checkboxCheckedImage;
+  copy->_checkboxUncheckedImage = _checkboxUncheckedImage;
   return copy;
 }
 
@@ -146,7 +172,7 @@
 
     _primaryFont = [RCTFont updateFont:nullptr
                             withFamily:[self primaryFontFamily]
-                                  size:[self primaryFontSize]
+                                  size:[self scaledPrimaryFontSize]
                                 weight:newFontWeight
                                  style:nullptr
                                variant:nullptr
@@ -159,7 +185,7 @@
   if (_monospacedFontNeedsRecreation) {
     _monospacedFontNeedsRecreation = NO;
     _monospacedFont = [UIFont
-        monospacedSystemFontOfSize:[[self primaryFontSize] floatValue]
+        monospacedSystemFontOfSize:[[self scaledPrimaryFontSize] floatValue]
                             weight:[[self primaryFontWeight] floatValue]];
   }
   return _monospacedFont;
@@ -175,7 +201,7 @@
 }
 
 - (CGFloat)h1FontSize {
-  return _h1FontSize;
+  return [[UIFontMetrics defaultMetrics] scaledValueForValue:_h1FontSize];
 }
 
 - (void)setH1FontSize:(CGFloat)newValue {
@@ -191,7 +217,7 @@
 }
 
 - (CGFloat)h2FontSize {
-  return _h2FontSize;
+  return [[UIFontMetrics defaultMetrics] scaledValueForValue:_h2FontSize];
 }
 
 - (void)setH2FontSize:(CGFloat)newValue {
@@ -207,7 +233,7 @@
 }
 
 - (CGFloat)h3FontSize {
-  return _h3FontSize;
+  return [[UIFontMetrics defaultMetrics] scaledValueForValue:_h3FontSize];
 }
 
 - (void)setH3FontSize:(CGFloat)newValue {
@@ -222,6 +248,54 @@
   _h3Bold = newValue;
 }
 
+- (CGFloat)h4FontSize {
+  return [[UIFontMetrics defaultMetrics] scaledValueForValue:_h4FontSize];
+}
+
+- (void)setH4FontSize:(CGFloat)newValue {
+  _h4FontSize = newValue;
+}
+
+- (BOOL)h4Bold {
+  return _h4Bold;
+}
+
+- (void)setH4Bold:(BOOL)newValue {
+  _h4Bold = newValue;
+}
+
+- (CGFloat)h5FontSize {
+  return [[UIFontMetrics defaultMetrics] scaledValueForValue:_h5FontSize];
+}
+
+- (void)setH5FontSize:(CGFloat)newValue {
+  _h5FontSize = newValue;
+}
+
+- (BOOL)h5Bold {
+  return _h5Bold;
+}
+
+- (void)setH5Bold:(BOOL)newValue {
+  _h5Bold = newValue;
+}
+
+- (CGFloat)h6FontSize {
+  return [[UIFontMetrics defaultMetrics] scaledValueForValue:_h6FontSize];
+}
+
+- (void)setH6FontSize:(CGFloat)newValue {
+  _h6FontSize = newValue;
+}
+
+- (BOOL)h6Bold {
+  return _h6Bold;
+}
+
+- (void)setH6Bold:(BOOL)newValue {
+  _h6Bold = newValue;
+}
+
 - (UIColor *)blockquoteBorderColor {
   return _blockquoteBorderColor;
 }
@@ -318,7 +392,7 @@
 
     _orderedListMarkerFont = [RCTFont updateFont:nullptr
                                       withFamily:[self primaryFontFamily]
-                                            size:[self primaryFontSize]
+                                            size:[self scaledPrimaryFontSize]
                                           weight:newFontWeight
                                            style:nullptr
                                          variant:nullptr
@@ -417,4 +491,159 @@
   _codeBlockBorderRadius = newValue;
 }
 
+- (LinkRegexConfig *)linkRegexConfig {
+  return _linkRegexConfig;
+}
+
+- (void)setLinkRegexConfig:(LinkRegexConfig *)newValue {
+  _linkRegexConfig = newValue;
+
+  // try initializing the native regular expression if it applies
+  if (_linkRegexConfig.isDefault || _linkRegexConfig.isDisabled) {
+    return;
+  }
+
+  NSError *regexInitError;
+  NSRegularExpressionOptions options =
+      (_linkRegexConfig.caseInsensitive ? NSRegularExpressionCaseInsensitive
+                                        : 0) |
+      (_linkRegexConfig.dotAll ? NSRegularExpressionDotMatchesLineSeparators
+                               : 0);
+  NSRegularExpression *userRegex =
+      [NSRegularExpression regularExpressionWithPattern:_linkRegexConfig.pattern
+                                                options:options
+                                                  error:&regexInitError];
+
+  if (regexInitError) {
+    RCTLogWarn(@"[EnrichedTextInput]: Couldn't parse the user-defined link "
+               @"regex, falling back to a default regex.");
+    _parsedLinkRegex = nullptr;
+  } else {
+    _parsedLinkRegex = userRegex;
+  }
+}
+
+- (NSRegularExpression *)parsedLinkRegex {
+  return _parsedLinkRegex;
+}
+
+- (void)invalidateFonts {
+  _primaryFontNeedsRecreation = YES;
+  _monospacedFontNeedsRecreation = YES;
+  _olMarkerFontNeedsRecreation = YES;
+}
+
+- (NSNumber *)scaledPrimaryFontSize {
+  CGFloat scaledSize = [[UIFontMetrics defaultMetrics]
+      scaledValueForValue:[[self primaryFontSize] floatValue]];
+  return @(scaledSize);
+}
+
+- (CGFloat)checkboxListBoxSize {
+  return _checkboxListBoxSize;
+}
+
+- (void)setCheckboxListBoxSize:(CGFloat)newValue {
+  if (_checkboxListBoxSize != newValue) {
+    _checkboxListBoxSize = newValue;
+    // Invalidate checkbox images because box size changed
+    _checkboxCheckedImage = nil;
+    _checkboxUncheckedImage = nil;
+  }
+}
+
+- (CGFloat)checkboxListGapWidth {
+  return _checkboxListGapWidth;
+}
+
+- (void)setCheckboxListGapWidth:(CGFloat)newValue {
+  _checkboxListGapWidth = newValue;
+}
+
+- (CGFloat)checkboxListMarginLeft {
+  return _checkboxListMarginLeft;
+}
+
+- (void)setCheckboxListMarginLeft:(CGFloat)newValue {
+  _checkboxListMarginLeft = newValue;
+}
+
+- (UIColor *)checkboxListBoxColor {
+  return _checkboxListBoxColor;
+}
+
+- (void)setCheckboxListBoxColor:(UIColor *)newValue {
+  if (_checkboxListBoxColor != newValue) {
+    _checkboxListBoxColor = newValue;
+    // Invalidate checkbox images because color changed
+    _checkboxCheckedImage = nil;
+    _checkboxUncheckedImage = nil;
+  }
+}
+
+- (UIImage *)checkboxCheckedImage {
+  if (!_checkboxCheckedImage) {
+    _checkboxCheckedImage = [self generateCheckboxImage:YES];
+  }
+  return _checkboxCheckedImage;
+}
+
+- (UIImage *)checkboxUncheckedImage {
+  if (!_checkboxUncheckedImage) {
+    _checkboxUncheckedImage = [self generateCheckboxImage:NO];
+  }
+  return _checkboxUncheckedImage;
+}
+
+- (UIImage *)generateCheckboxImage:(BOOL)isChecked {
+  CGFloat boxSize = self.checkboxListBoxSize;
+  UIColor *boxColor = self.checkboxListBoxColor ?: [UIColor blackColor];
+
+  UIGraphicsBeginImageContextWithOptions(CGSizeMake(boxSize, boxSize), NO, 0.0);
+  CGRect localRect = CGRectMake(0, 0, boxSize, boxSize);
+  CGFloat cornerRadius = boxSize * 0.15f;
+  CGFloat strokeWidth = boxSize * 0.1f;
+  CGRect insetRect =
+      CGRectInset(localRect, strokeWidth / 2.0, strokeWidth / 2.0);
+
+  // Draw Box
+  UIBezierPath *boxPath = [UIBezierPath bezierPathWithRoundedRect:insetRect
+                                                     cornerRadius:cornerRadius];
+  [boxPath setLineWidth:strokeWidth];
+
+  if (isChecked) {
+    [[boxColor colorWithAlphaComponent:1.0] setFill];
+    [boxPath fill];
+    [[boxColor colorWithAlphaComponent:1.0] setStroke];
+    [boxPath stroke];
+
+    // Draw Checkmark
+    UIBezierPath *checkPath = [UIBezierPath bezierPath];
+    CGFloat startX = insetRect.origin.x + insetRect.size.width * 0.25;
+    CGFloat startY = insetRect.origin.y + insetRect.size.height * 0.5;
+    CGFloat midX = insetRect.origin.x + insetRect.size.width * 0.45;
+    CGFloat midY = insetRect.origin.y + insetRect.size.height * 0.65;
+    CGFloat endX = insetRect.origin.x + insetRect.size.width * 0.75;
+    CGFloat endY = insetRect.origin.y + insetRect.size.height * 0.35;
+
+    [checkPath moveToPoint:CGPointMake(startX, startY)];
+    [checkPath addLineToPoint:CGPointMake(midX, midY)];
+    [checkPath addLineToPoint:CGPointMake(endX, endY)];
+
+    [checkPath setLineWidth:strokeWidth * 1.5];
+    [[UIColor whiteColor] setStroke];
+    [checkPath setLineCapStyle:kCGLineCapRound];
+    [checkPath setLineJoinStyle:kCGLineJoinRound];
+    [checkPath stroke];
+  } else {
+    [[boxColor colorWithAlphaComponent:1.0] setStroke];
+    [boxPath stroke];
+  }
+
+  UIImage *result = UIGraphicsGetImageFromCurrentImageContext();
+  UIGraphicsEndImageContext();
+
+  return result;
+}
+
 @end

package/ios/extensions/ImageExtension.h

@@ -0,0 +1,35 @@
+#import <UIKit/UIKit.h>
+
+/**
+        UIImage (animatedGIF)
+
+    This category adds class methods to `UIImage` to create an animated
+   `UIImage` from an animated GIF.
+*/
+@interface UIImage (ImageExtension)
+
+/*
+        UIImage *animation = [UIImage animatedImageWithAnimatedGIFData:theData];
+
+    I interpret `theData` as a GIF.  I create an animated `UIImage` using the
+   source images in the GIF.
+
+    The GIF 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 (from the GIF) to
+   `animation` a varying number of times to match the ratios between the frame
+   durations in the GIF.
+
+    For example, suppose the GIF 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)animatedImageWithAnimatedGIFData:
+    (NSData *_Nonnull)theData;
+
+@end

package/ios/extensions/ImageExtension.mm

@@ -0,0 +1,156 @@
+#import "ImageExtension.h"
+#import <ImageIO/ImageIO.h>
+#include <cmath>
+#include <vector>
+
+#if __has_feature(objc_arc)
+#define toCF (__bridge CFTypeRef)
+#define fromCF (__bridge id)
+#else
+#define toCF (CFTypeRef)
+#define fromCF (id)
+#endif
+
+// implementation from:
+// https://github.com/mayoff/uiimage-from-animated-gif/blob/master/uiimage-from-animated-gif/UIImage%2BanimatedGIF.m
+@implementation UIImage (ImageExtension)
+
+static int delayCentisecondsForImageAtIndex(CGImageSourceRef const source,
+                                            size_t const i) {
+  int delayCentiseconds = 1;
+  CFDictionaryRef const properties =
+      CGImageSourceCopyPropertiesAtIndex(source, i, NULL);
+  if (properties) {
+    CFDictionaryRef const gifProperties = (CFDictionaryRef)CFDictionaryGetValue(
+        properties, kCGImagePropertyGIFDictionary);
+    if (gifProperties) {
+      NSNumber *number = fromCF CFDictionaryGetValue(
+          gifProperties, kCGImagePropertyGIFUnclampedDelayTime);
+      if (number == NULL || [number doubleValue] == 0) {
+        number = fromCF CFDictionaryGetValue(gifProperties,
+                                             kCGImagePropertyGIFDelayTime);
+      }
+      if ([number doubleValue] > 0) {
+        // Even though the GIF stores the delay as an integer number of
+        // centiseconds, ImageIO “helpfully” converts that to seconds for us.
+        delayCentiseconds = (int)lrint([number doubleValue] * 100);
+      }
+    }
+    CFRelease(properties);
+  }
+  return delayCentiseconds;
+}
+
+// Changed to use std::vector references instead of C-arrays
+static void createImagesAndDelays(CGImageSourceRef source, size_t count,
+                                  std::vector<CGImageRef> &imagesOut,
+                                  std::vector<int> &delayCentisecondsOut) {
+  for (size_t i = 0; i < count; ++i) {
+    imagesOut[i] = CGImageSourceCreateImageAtIndex(source, i, NULL);
+    delayCentisecondsOut[i] = delayCentisecondsForImageAtIndex(source, i);
+  }
+}
+
+static int sum(const std::vector<int> &values) {
+  int theSum = 0;
+  for (int value : values) {
+    theSum += value;
+  }
+  return theSum;
+}
+
+static int pairGCD(int a, int b) {
+  if (a < b)
+    return pairGCD(b, a);
+  while (true) {
+    int const r = a % b;
+    if (r == 0)
+      return b;
+    a = b;
+    b = r;
+  }
+}
+
+static int vectorGCD(const std::vector<int> &values) {
+  if (values.empty())
+    return 1;
+
+  int gcd = values[0];
+  for (size_t i = 1; i < values.size(); ++i) {
+    // Note that after I process the first few elements of the vector, `gcd`
+    // will probably be smaller than any remaining element. By passing the
+    // smaller value as the second argument to `pairGCD`, I avoid making it swap
+    // the arguments.
+    gcd = pairGCD(values[i], gcd);
+  }
+  return gcd;
+}
+
+static NSArray *frameArray(const std::vector<CGImageRef> &images,
+                           const std::vector<int> &delayCentiseconds,
+                           int const totalDurationCentiseconds) {
+  int const gcd = vectorGCD(delayCentiseconds);
+  size_t const frameCount = totalDurationCentiseconds / gcd;
+
+  // Replaced VLA with NSMutableArray for safety and OBJ-C++ compatibility
+  NSMutableArray *frames = [NSMutableArray arrayWithCapacity:frameCount];
+
+  for (size_t i = 0; i < images.size(); ++i) {
+    UIImage *const frame = [UIImage imageWithCGImage:images[i]];
+    for (size_t j = delayCentiseconds[i] / gcd; j > 0; --j) {
+      [frames addObject:frame];
+    }
+  }
+  return frames;
+}
+
+static void releaseImages(const std::vector<CGImageRef> &images) {
+  for (CGImageRef image : images) {
+    if (image)
+      CGImageRelease(image);
+  }
+}
+
+static UIImage *
+animatedImageWithAnimatedGIFImageSource(CGImageSourceRef const source) {
+  size_t const count = CGImageSourceGetCount(source);
+  if (count == 0) {
+    return nil;
+  }
+
+  // Replaced VLAs (variable length arrays) with std::vector
+  std::vector<CGImageRef> images(count);
+  std::vector<int> delayCentiseconds(count); // in centiseconds
+
+  createImagesAndDelays(source, count, images, delayCentiseconds);
+
+  int const totalDurationCentiseconds = sum(delayCentiseconds);
+  NSArray *const frames =
+      frameArray(images, delayCentiseconds, totalDurationCentiseconds);
+
+  UIImage *const animation = [UIImage
+      animatedImageWithImages:frames
+                     duration:(NSTimeInterval)totalDurationCentiseconds /
+                              100.0];
+
+  releaseImages(images);
+  return animation;
+}
+
+static UIImage *animatedImageWithAnimatedGIFReleasingImageSource(
+    CGImageSourceRef CF_RELEASES_ARGUMENT source) {
+  if (source) {
+    UIImage *const image = animatedImageWithAnimatedGIFImageSource(source);
+    CFRelease(source);
+    return image;
+  } else {
+    return nil;
+  }
+}
+
++ (UIImage *)animatedImageWithAnimatedGIFData:(NSData *)data {
+  return animatedImageWithAnimatedGIFReleasingImageSource(
+      CGImageSourceCreateWithData((__bridge CFDataRef)data, NULL));
+}
+
+@end