@react-native-oh/react-native-harmony 0.72.86 → 0.77.18-1

package/Libraries/Image/RCTImageURLLoader.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTResizeMode.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^RCTImageLoaderProgressBlock)(int64_t progress, int64_t total);
+typedef void (^RCTImageLoaderPartialLoadBlock)(UIImage *image);
+typedef void (^RCTImageLoaderCompletionBlock)(NSError *_Nullable error, UIImage *_Nullable image);
+// Metadata is passed as a id in an additional parameter because there are forks of RN without this parameter,
+// and the complexity of RCTImageLoader would make using protocols here difficult to typecheck.
+typedef void (^RCTImageLoaderCompletionBlockWithMetadata)(
+    NSError *_Nullable error,
+    UIImage *_Nullable image,
+    id _Nullable metadata);
+typedef dispatch_block_t RCTImageLoaderCancellationBlock;
+
+/**
+ * Provides the interface needed to register an image loader. Image data
+ * loaders are also bridge modules, so should be registered using
+ * RCT_EXPORT_MODULE().
+ */
+@protocol RCTImageURLLoader <RCTBridgeModule>
+
+/**
+ * Indicates whether this data loader is capable of processing the specified
+ * request URL. Typically the handler would examine the scheme/protocol of the
+ * URL to determine this.
+ */
+- (BOOL)canLoadImageURL:(NSURL *)requestURL;
+
+/**
+ * Send a network request to load the request URL. The method should call the
+ * progressHandler (if applicable) and the completionHandler when the request
+ * has finished. The method should also return a cancellation block, if
+ * applicable.
+ */
+- (nullable RCTImageLoaderCancellationBlock)loadImageForURL:(NSURL *)imageURL
+                                                       size:(CGSize)size
+                                                      scale:(CGFloat)scale
+                                                 resizeMode:(RCTResizeMode)resizeMode
+                                            progressHandler:(RCTImageLoaderProgressBlock)progressHandler
+                                         partialLoadHandler:(RCTImageLoaderPartialLoadBlock)partialLoadHandler
+                                          completionHandler:(RCTImageLoaderCompletionBlock)completionHandler;
+
+@optional
+
+/**
+ * If more than one RCTImageURLLoader responds YES to `-canLoadImageURL:`
+ * then `loaderPriority` is used to determine which one to use. The loader
+ * with the highest priority will be selected. Default priority is zero. If
+ * two or more valid loaders have the same priority, the selection order is
+ * undefined.
+ */
+- (float)loaderPriority;
+
+/**
+ * If the loader must be called on the serial url cache queue, and whether the completion
+ * block should be dispatched off the main thread. If this is NO, the loader will be
+ * called from the main queue. Defaults to YES.
+ *
+ * Use with care: disabling scheduling will reduce RCTImageLoader's ability to throttle
+ * network requests.
+ */
+- (BOOL)requiresScheduling;
+
+/**
+ * If images loaded by the loader should be cached in the decoded image cache.
+ * Defaults to YES.
+ */
+- (BOOL)shouldCacheLoadedImages;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/Libraries/Image/RCTImageURLLoaderWithAttribution.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTImageLoaderLoggable.h>
+#import <React/RCTImageLoaderProtocol.h>
+#import <React/RCTImageURLLoader.h>
+
+// TODO (T61325135): Remove C++ checks
+#ifdef __cplusplus
+namespace facebook::react {
+
+struct ImageURLLoaderAttribution {
+  int32_t nativeViewTag = 0;
+  int32_t surfaceId = 0;
+  std::string queryRootName;
+  NSString *analyticTag;
+};
+
+} // namespace facebook::react
+#endif
+
+@interface RCTImageURLLoaderRequest : NSObject
+
+@property (nonatomic, strong, readonly) NSString *requestId;
+@property (nonatomic, strong, readonly) NSURL *imageURL;
+@property (nonatomic, copy, readonly) RCTImageLoaderCancellationBlock cancellationBlock;
+
+- (instancetype)initWithRequestId:(NSString *)requestId
+                         imageURL:(NSURL *)imageURL
+                cancellationBlock:(RCTImageLoaderCancellationBlock)cancellationBlock;
+- (void)cancel;
+
+@end
+
+/**
+ * Same as the RCTImageURLLoader interface, but allows passing in optional `attribution` information.
+ * This is useful for per-app logging and other instrumentation.
+ */
+@protocol RCTImageURLLoaderWithAttribution <RCTImageURLLoader, RCTImageLoaderLoggable>
+
+// TODO (T61325135): Remove C++ checks
+#ifdef __cplusplus
+/**
+ * Same as the RCTImageURLLoader variant above, but allows optional `attribution` information.
+ * Caller may also specify a preferred requestId for tracking purpose.
+ */
+- (RCTImageURLLoaderRequest *)loadImageForURL:(NSURL *)imageURL
+                                         size:(CGSize)size
+                                        scale:(CGFloat)scale
+                                   resizeMode:(RCTResizeMode)resizeMode
+                                    requestId:(NSString *)requestId
+                                     priority:(RCTImageLoaderPriority)priority
+                                  attribution:(const facebook::react::ImageURLLoaderAttribution &)attribution
+                              progressHandler:(RCTImageLoaderProgressBlock)progressHandler
+                           partialLoadHandler:(RCTImageLoaderPartialLoadBlock)partialLoadHandler
+                            completionHandler:(RCTImageLoaderCompletionBlockWithMetadata)completionHandler;
+#endif
+
+/**
+ * Image instrumentation - start tracking the on-screen visibility of the native image view.
+ */
+- (void)trackURLImageVisibilityForRequest:(RCTImageURLLoaderRequest *)loaderRequest imageView:(UIView *)imageView;
+
+/**
+ * Image instrumentation - notify that the request was destroyed.
+ */
+- (void)trackURLImageRequestDidDestroy:(RCTImageURLLoaderRequest *)loaderRequest;
+
+/**
+ * Image instrumentation - notify that the native image view was destroyed.
+ */
+- (void)trackURLImageDidDestroy:(RCTImageURLLoaderRequest *)loaderRequest;
+
+@end

package/Libraries/Image/RCTImageURLLoaderWithAttribution.mm

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTImageURLLoaderWithAttribution.h"
+
+@implementation RCTImageURLLoaderRequest
+
+- (instancetype)initWithRequestId:(NSString *)requestId
+                         imageURL:(NSURL *)imageURL
+                cancellationBlock:(RCTImageLoaderCancellationBlock)cancellationBlock
+{
+  if (self = [super init]) {
+    _requestId = requestId;
+    _imageURL = imageURL;
+    _cancellationBlock = cancellationBlock;
+  }
+
+  return self;
+}
+
+- (void)cancel
+{
+  if (_cancellationBlock) {
+    _cancellationBlock();
+  }
+}
+
+@end

package/Libraries/Image/RCTImageUtils.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTDefines.h>
+#import <React/RCTResizeMode.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * This function takes an source size (typically from an image), a target size
+ * and scale that it will be drawn at (typically in a CGContext) and then
+ * calculates the rectangle to draw the image into so that it will be sized and
+ * positioned correctly according to the specified resizeMode.
+ */
+RCT_EXTERN CGRect RCTTargetRect(CGSize sourceSize, CGSize destSize, CGFloat destScale, RCTResizeMode resizeMode);
+
+/**
+ * This function takes a source size (typically from an image), a target rect
+ * that it will be drawn into (typically relative to a CGContext), and works out
+ * the transform needed to draw the image at the correct scale and position.
+ */
+RCT_EXTERN CGAffineTransform RCTTransformFromTargetRect(CGSize sourceSize, CGRect targetRect);
+
+/**
+ * This function takes an input content size & scale (typically from an image),
+ * a target size & scale at which it will be displayed (typically in a
+ * UIImageView) and then calculates the optimal size at which to redraw the
+ * image so that it will be displayed correctly with the specified resizeMode.
+ */
+RCT_EXTERN CGSize RCTTargetSize(
+    CGSize sourceSize,
+    CGFloat sourceScale,
+    CGSize destSize,
+    CGFloat destScale,
+    RCTResizeMode resizeMode,
+    BOOL allowUpscaling);
+
+/**
+ * This function takes an input content size & scale (typically from an image),
+ * a target size & scale that it will be displayed at, and determines if the
+ * source will need to be upscaled to fit (which may result in pixelization).
+ */
+RCT_EXTERN BOOL RCTUpscalingRequired(
+    CGSize sourceSize,
+    CGFloat sourceScale,
+    CGSize destSize,
+    CGFloat destScale,
+    RCTResizeMode resizeMode);
+
+/**
+ * This function takes the source data for an image and decodes it at the
+ * specified size. If the original image is smaller than the destination size,
+ * the resultant image's scale will be decreased to compensate, so the
+ * width/height of the returned image is guaranteed to be >= destSize.
+ * Pass a destSize of CGSizeZero to decode the image at its original size.
+ */
+RCT_EXTERN UIImage *__nullable
+RCTDecodeImageWithData(NSData *data, CGSize destSize, CGFloat destScale, RCTResizeMode resizeMode);
+
+/**
+ * This function takes the source data for an image and decodes just the
+ * metadata, without decompressing the image itself.
+ */
+RCT_EXTERN NSDictionary<NSString *, id> *__nullable RCTGetImageMetadata(NSData *data);
+
+/**
+ * Convert an image back into data. Images with an alpha channel will be
+ * converted to lossless PNG data. Images without alpha will be converted to
+ * JPEG. The `quality` argument controls the compression ratio of the JPEG
+ * conversion, with 1.0 being maximum quality. It has no effect for images
+ * using PNG compression.
+ */
+RCT_EXTERN NSData *__nullable RCTGetImageData(UIImage *image, float quality);
+
+/**
+ * This function transforms an image. `destSize` is the size of the final image,
+ * and `destScale` is its scale. The `transform` argument controls how the
+ * source image will be mapped to the destination image.
+ */
+RCT_EXTERN UIImage *__nullable
+RCTTransformImage(UIImage *image, CGSize destSize, CGFloat destScale, CGAffineTransform transform);
+
+/*
+ * Return YES if image has an alpha component
+ */
+RCT_EXTERN BOOL RCTImageHasAlpha(CGImageRef image);
+
+NS_ASSUME_NONNULL_END

package/Libraries/Image/RCTImageUtils.mm

@@ -0,0 +1,389 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTImageUtils.h>
+
+#import <tgmath.h>
+
+#import <ImageIO/ImageIO.h>
+#import <MobileCoreServices/UTCoreTypes.h>
+
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+static CGFloat RCTCeilValue(CGFloat value, CGFloat scale)
+{
+  return ceil(value * scale) / scale;
+}
+
+static CGFloat RCTFloorValue(CGFloat value, CGFloat scale)
+{
+  return floor(value * scale) / scale;
+}
+
+static CGSize RCTCeilSize(CGSize size, CGFloat scale)
+{
+  return (CGSize){RCTCeilValue(size.width, scale), RCTCeilValue(size.height, scale)};
+}
+
+static CGImagePropertyOrientation CGImagePropertyOrientationFromUIImageOrientation(UIImageOrientation imageOrientation)
+{
+  // see https://stackoverflow.com/a/6699649/496389
+  switch (imageOrientation) {
+    case UIImageOrientationUp:
+      return kCGImagePropertyOrientationUp;
+    case UIImageOrientationDown:
+      return kCGImagePropertyOrientationDown;
+    case UIImageOrientationLeft:
+      return kCGImagePropertyOrientationLeft;
+    case UIImageOrientationRight:
+      return kCGImagePropertyOrientationRight;
+    case UIImageOrientationUpMirrored:
+      return kCGImagePropertyOrientationUpMirrored;
+    case UIImageOrientationDownMirrored:
+      return kCGImagePropertyOrientationDownMirrored;
+    case UIImageOrientationLeftMirrored:
+      return kCGImagePropertyOrientationLeftMirrored;
+    case UIImageOrientationRightMirrored:
+      return kCGImagePropertyOrientationRightMirrored;
+    default:
+      return kCGImagePropertyOrientationUp;
+  }
+}
+
+CGRect RCTTargetRect(CGSize sourceSize, CGSize destSize, CGFloat destScale, RCTResizeMode resizeMode)
+{
+  if (CGSizeEqualToSize(destSize, CGSizeZero)) {
+    // Assume we require the largest size available
+    return (CGRect){CGPointZero, sourceSize};
+  }
+
+  CGFloat aspect = sourceSize.width / sourceSize.height;
+  // If only one dimension in destSize is non-zero (for example, an Image
+  // with `flex: 1` whose height is indeterminate), calculate the unknown
+  // dimension based on the aspect ratio of sourceSize
+  if (destSize.width == 0) {
+    destSize.width = destSize.height * aspect;
+  }
+  if (destSize.height == 0) {
+    destSize.height = destSize.width / aspect;
+  }
+
+  // Calculate target aspect ratio if needed
+  CGFloat targetAspect = 0.0;
+  if (resizeMode != RCTResizeModeCenter && resizeMode != RCTResizeModeStretch) {
+    targetAspect = destSize.width / destSize.height;
+    if (aspect == targetAspect) {
+      resizeMode = RCTResizeModeStretch;
+    }
+  }
+
+  switch (resizeMode) {
+    case RCTResizeModeStretch:
+    case RCTResizeModeRepeat:
+    case RCTResizeModeNone:
+
+      return (CGRect){CGPointZero, RCTCeilSize(destSize, destScale)};
+
+    case RCTResizeModeContain:
+
+      if (targetAspect <= aspect) { // target is taller than content
+
+        sourceSize.width = destSize.width;
+        sourceSize.height = sourceSize.width / aspect;
+
+      } else { // target is wider than content
+
+        sourceSize.height = destSize.height;
+        sourceSize.width = sourceSize.height * aspect;
+      }
+      return (CGRect){
+          {
+              RCTFloorValue((destSize.width - sourceSize.width) / 2, destScale),
+              RCTFloorValue((destSize.height - sourceSize.height) / 2, destScale),
+          },
+          RCTCeilSize(sourceSize, destScale)};
+
+    case RCTResizeModeCover:
+
+      if (targetAspect <= aspect) { // target is taller than content
+
+        sourceSize.height = destSize.height;
+        sourceSize.width = sourceSize.height * aspect;
+        destSize.width = destSize.height * targetAspect;
+        return (CGRect){
+            {RCTFloorValue((destSize.width - sourceSize.width) / 2, destScale), 0}, RCTCeilSize(sourceSize, destScale)};
+
+      } else { // target is wider than content
+
+        sourceSize.width = destSize.width;
+        sourceSize.height = sourceSize.width / aspect;
+        destSize.height = destSize.width / targetAspect;
+        return (CGRect){
+            {0, RCTFloorValue((destSize.height - sourceSize.height) / 2, destScale)},
+            RCTCeilSize(sourceSize, destScale)};
+      }
+
+    case RCTResizeModeCenter:
+
+      // Make sure the image is not clipped by the target.
+      if (sourceSize.height > destSize.height) {
+        sourceSize.width = destSize.width;
+        sourceSize.height = sourceSize.width / aspect;
+      }
+      if (sourceSize.width > destSize.width) {
+        sourceSize.height = destSize.height;
+        sourceSize.width = sourceSize.height * aspect;
+      }
+
+      return (CGRect){
+          {
+              RCTFloorValue((destSize.width - sourceSize.width) / 2, destScale),
+              RCTFloorValue((destSize.height - sourceSize.height) / 2, destScale),
+          },
+          RCTCeilSize(sourceSize, destScale)};
+  }
+}
+
+CGAffineTransform RCTTransformFromTargetRect(CGSize sourceSize, CGRect targetRect)
+{
+  CGAffineTransform transform = CGAffineTransformIdentity;
+  transform = CGAffineTransformTranslate(transform, targetRect.origin.x, targetRect.origin.y);
+  transform = CGAffineTransformScale(
+      transform, targetRect.size.width / sourceSize.width, targetRect.size.height / sourceSize.height);
+  return transform;
+}
+
+CGSize RCTTargetSize(
+    CGSize sourceSize,
+    CGFloat sourceScale,
+    CGSize destSize,
+    CGFloat destScale,
+    RCTResizeMode resizeMode,
+    BOOL allowUpscaling)
+{
+  switch (resizeMode) {
+    case RCTResizeModeCenter:
+
+      return RCTTargetRect(sourceSize, destSize, destScale, resizeMode).size;
+
+    case RCTResizeModeStretch:
+
+      if (!allowUpscaling) {
+        CGFloat scale = sourceScale / destScale;
+        destSize.width = MIN(sourceSize.width * scale, destSize.width);
+        destSize.height = MIN(sourceSize.height * scale, destSize.height);
+      }
+      return RCTCeilSize(destSize, destScale);
+
+    default: {
+      // Get target size
+      CGSize size = RCTTargetRect(sourceSize, destSize, destScale, resizeMode).size;
+      if (!allowUpscaling) {
+        // return sourceSize if target size is larger
+        if (sourceSize.width * sourceScale < size.width * destScale) {
+          return sourceSize;
+        }
+      }
+      return size;
+    }
+  }
+}
+
+BOOL RCTUpscalingRequired(
+    CGSize sourceSize,
+    CGFloat sourceScale,
+    CGSize destSize,
+    CGFloat destScale,
+    RCTResizeMode resizeMode)
+{
+  if (CGSizeEqualToSize(destSize, CGSizeZero)) {
+    // Assume we require the largest size available
+    return YES;
+  }
+
+  // Precompensate for scale
+  CGFloat scale = sourceScale / destScale;
+  sourceSize.width *= scale;
+  sourceSize.height *= scale;
+
+  // Calculate aspect ratios if needed (don't bother if resizeMode == stretch)
+  CGFloat aspect = 0.0, targetAspect = 0.0;
+  if (resizeMode != RCTResizeModeStretch) {
+    aspect = sourceSize.width / sourceSize.height;
+    targetAspect = destSize.width / destSize.height;
+    if (aspect == targetAspect) {
+      resizeMode = RCTResizeModeStretch;
+    }
+  }
+
+  switch (resizeMode) {
+    case RCTResizeModeStretch:
+
+      return destSize.width > sourceSize.width || destSize.height > sourceSize.height;
+
+    case RCTResizeModeContain:
+
+      if (targetAspect <= aspect) { // target is taller than content
+
+        return destSize.width > sourceSize.width;
+
+      } else { // target is wider than content
+
+        return destSize.height > sourceSize.height;
+      }
+
+    case RCTResizeModeCover:
+
+      if (targetAspect <= aspect) { // target is taller than content
+
+        return destSize.height > sourceSize.height;
+
+      } else { // target is wider than content
+
+        return destSize.width > sourceSize.width;
+      }
+
+    case RCTResizeModeRepeat:
+    case RCTResizeModeCenter:
+    case RCTResizeModeNone:
+
+      return NO;
+  }
+}
+
+UIImage *__nullable RCTDecodeImageWithData(NSData *data, CGSize destSize, CGFloat destScale, RCTResizeMode resizeMode)
+{
+  CGImageSourceRef sourceRef = CGImageSourceCreateWithData((__bridge CFDataRef)data, NULL);
+  if (!sourceRef) {
+    return nil;
+  }
+
+  // Get original image size
+  CFDictionaryRef imageProperties = CGImageSourceCopyPropertiesAtIndex(sourceRef, 0, NULL);
+  if (!imageProperties) {
+    CFRelease(sourceRef);
+    return nil;
+  }
+  NSNumber *width = (NSNumber *)CFDictionaryGetValue(imageProperties, kCGImagePropertyPixelWidth);
+  NSNumber *height = (NSNumber *)CFDictionaryGetValue(imageProperties, kCGImagePropertyPixelHeight);
+  CGSize sourceSize = {width.doubleValue, height.doubleValue};
+  CFRelease(imageProperties);
+
+  if (CGSizeEqualToSize(destSize, CGSizeZero)) {
+    destSize = sourceSize;
+    if (!destScale) {
+      destScale = 1;
+    }
+  } else if (!destScale) {
+    destScale = RCTScreenScale();
+  }
+
+  if (resizeMode == RCTResizeModeStretch) {
+    // Decoder cannot change aspect ratio, so RCTResizeModeStretch is equivalent
+    // to RCTResizeModeCover for our purposes
+    resizeMode = RCTResizeModeCover;
+  }
+
+  // Calculate target size
+  CGSize targetSize = RCTTargetSize(sourceSize, 1, destSize, destScale, resizeMode, NO);
+  CGSize targetPixelSize = RCTSizeInPixels(targetSize, destScale);
+  CGFloat maxPixelSize =
+      fmax(fmin(sourceSize.width, targetPixelSize.width), fmin(sourceSize.height, targetPixelSize.height));
+
+  NSDictionary<NSString *, NSNumber *> *options = @{
+    (id)kCGImageSourceShouldAllowFloat : @YES,
+    (id)kCGImageSourceCreateThumbnailWithTransform : @YES,
+    (id)kCGImageSourceCreateThumbnailFromImageAlways : @YES,
+    (id)kCGImageSourceThumbnailMaxPixelSize : @(maxPixelSize),
+  };
+
+  // Get thumbnail
+  CGImageRef imageRef = CGImageSourceCreateThumbnailAtIndex(sourceRef, 0, (__bridge CFDictionaryRef)options);
+  CFRelease(sourceRef);
+  if (!imageRef) {
+    return nil;
+  }
+
+  // Return image
+  UIImage *image = [UIImage imageWithCGImage:imageRef scale:destScale orientation:UIImageOrientationUp];
+  CGImageRelease(imageRef);
+  return image;
+}
+
+NSDictionary<NSString *, id> *__nullable RCTGetImageMetadata(NSData *data)
+{
+  CGImageSourceRef sourceRef = CGImageSourceCreateWithData((__bridge CFDataRef)data, NULL);
+  if (!sourceRef) {
+    return nil;
+  }
+  CFDictionaryRef imageProperties = CGImageSourceCopyPropertiesAtIndex(sourceRef, 0, NULL);
+  CFRelease(sourceRef);
+  return (__bridge_transfer id)imageProperties;
+}
+
+NSData *__nullable RCTGetImageData(UIImage *image, float quality)
+{
+  CGImageRef cgImage = image.CGImage;
+  if (!cgImage) {
+    return NULL;
+  }
+  NSMutableDictionary *properties = [[NSMutableDictionary alloc] initWithDictionary:@{
+    (id)kCGImagePropertyOrientation : @(CGImagePropertyOrientationFromUIImageOrientation(image.imageOrientation))
+  }];
+  CGImageDestinationRef destination;
+  CFMutableDataRef imageData = CFDataCreateMutable(NULL, 0);
+  if (RCTImageHasAlpha(cgImage)) {
+    // get png data
+    destination = CGImageDestinationCreateWithData(imageData, kUTTypePNG, 1, NULL);
+  } else {
+    // get jpeg data
+    destination = CGImageDestinationCreateWithData(imageData, kUTTypeJPEG, 1, NULL);
+    [properties setValue:@(quality) forKey:(id)kCGImageDestinationLossyCompressionQuality];
+  }
+  if (!destination) {
+    CFRelease(imageData);
+    return NULL;
+  }
+  CGImageDestinationAddImage(destination, cgImage, (__bridge CFDictionaryRef)properties);
+  if (!CGImageDestinationFinalize(destination)) {
+    CFRelease(imageData);
+    imageData = NULL;
+  }
+  CFRelease(destination);
+  return (__bridge_transfer NSData *)imageData;
+}
+
+UIImage *__nullable RCTTransformImage(UIImage *image, CGSize destSize, CGFloat destScale, CGAffineTransform transform)
+{
+  if (destSize.width <= 0 | destSize.height <= 0 || destScale <= 0) {
+    return nil;
+  }
+
+  BOOL opaque = !RCTImageHasAlpha(image.CGImage);
+  UIGraphicsImageRendererFormat *const rendererFormat = [UIGraphicsImageRendererFormat defaultFormat];
+  rendererFormat.opaque = opaque;
+  rendererFormat.scale = destScale;
+  UIGraphicsImageRenderer *const renderer = [[UIGraphicsImageRenderer alloc] initWithSize:destSize
+                                                                                   format:rendererFormat];
+  return [renderer imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull context) {
+    CGContextConcatCTM(context.CGContext, transform);
+    [image drawAtPoint:CGPointZero];
+  }];
+}
+
+BOOL RCTImageHasAlpha(CGImageRef image)
+{
+  switch (CGImageGetAlphaInfo(image)) {
+    case kCGImageAlphaNone:
+    case kCGImageAlphaNoneSkipLast:
+    case kCGImageAlphaNoneSkipFirst:
+      return NO;
+    default:
+      return YES;
+  }
+}

package/Libraries/Image/RCTImageView.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTResizeMode.h>
+#import <React/RCTView.h>
+#import <UIKit/UIKit.h>
+
+@class RCTBridge;
+@class RCTImageSource;
+
+@interface RCTImageView : RCTView
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge NS_DESIGNATED_INITIALIZER;
+
+@property (nonatomic, assign) UIEdgeInsets capInsets;
+@property (nonatomic, strong) UIImage *defaultImage;
+@property (nonatomic, assign) UIImageRenderingMode renderingMode;
+@property (nonatomic, copy) NSArray<RCTImageSource *> *imageSources;
+@property (nonatomic, assign) CGFloat blurRadius;
+@property (nonatomic, assign) RCTResizeMode resizeMode;
+@property (nonatomic, copy) NSString *internal_analyticTag;
+
+@end