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

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,34 @@
+#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 animatedImageWithAnimatedGIFData: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)animatedImageWithAnimatedGIFData:
+    (NSData *_Nonnull)theData;
+
+@end

package/ios/extensions/ImageExtension.mm

@@ -0,0 +1,165 @@
+#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) {
+    // Try GIF frame delay first
+    CFDictionaryRef formatDict = (CFDictionaryRef)CFDictionaryGetValue(
+        properties, kCGImagePropertyGIFDictionary);
+    CFStringRef unclampedKey = kCGImagePropertyGIFUnclampedDelayTime;
+    CFStringRef delayKey = kCGImagePropertyGIFDelayTime;
+
+    // Fall back to WebP frame delay
+    if (!formatDict) {
+      formatDict = (CFDictionaryRef)CFDictionaryGetValue(
+          properties, kCGImagePropertyWebPDictionary);
+      unclampedKey = kCGImagePropertyWebPUnclampedDelayTime;
+      delayKey = kCGImagePropertyWebPDelayTime;
+    }
+
+    if (formatDict) {
+      NSNumber *number = fromCF CFDictionaryGetValue(formatDict, unclampedKey);
+      if (number == NULL || [number doubleValue] == 0) {
+        number = fromCF CFDictionaryGetValue(formatDict, delayKey);
+      }
+      if ([number doubleValue] > 0) {
+        // ImageIO exposes frame delays in seconds; convert to centiseconds.
+        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

package/ios/extensions/LayoutManagerExtension.h

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