@react-native-oh/react-native-harmony 0.77.18 → 0.77.33

package/Libraries/Image/RCTImageLoaderLoggable.h

@@ -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 <Foundation/Foundation.h>
+
+/**
+ * The image loader (i.e. RCTImageLoader) implement this to declare whether image performance should be logged.
+ */
+@protocol RCTImageLoaderLoggableProtocol <NSObject>
+
+/**
+ * Image instrumentation - declares whether its caller should log images
+ */
+- (BOOL)shouldEnablePerfLoggingForRequestUrl:(NSURL *)url;
+
+@end
+
+/**
+ * Image handlers in the image loader implement this to declare whether image performance should be logged.
+ */
+@protocol RCTImageLoaderLoggable
+
+/**
+ * Image instrumentation - declares whether its caller should log images
+ */
+- (BOOL)shouldEnablePerfLogging;
+
+@end

package/Libraries/Image/RCTImageLoaderProtocol.h

@@ -0,0 +1,135 @@
+/*
+ * 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/RCTImageCache.h>
+#import <React/RCTImageDataDecoder.h>
+#import <React/RCTImageURLLoader.h>
+#import <React/RCTResizeMode.h>
+#import <React/RCTURLRequestHandler.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * If available, RCTImageRedirectProtocol is invoked before loading an asset.
+ * Implementation should return either a new URL or nil when redirection is
+ * not needed.
+ */
+
+@protocol RCTImageRedirectProtocol
+
+- (NSURL *)redirectAssetsURL:(NSURL *)URL;
+
+@end
+
+/**
+ * Image Downloading priority.
+ * Use PriorityImmediate to download images at the highest priority.
+ * Use PriorityPrefetch to prefetch images at a lower priority.
+ * The priority logic is up to each @RCTImageLoaderProtocol implementation
+ */
+typedef NS_ENUM(NSInteger, RCTImageLoaderPriority) { RCTImageLoaderPriorityImmediate, RCTImageLoaderPriorityPrefetch };
+
+@protocol RCTImageLoaderProtocol <RCTURLRequestHandler>
+
+/**
+ * The maximum number of concurrent image loading tasks. Loading and decoding
+ * images can consume a lot of memory, so setting this to a higher value may
+ * cause memory to spike. If you are seeing out-of-memory crashes, try reducing
+ * this value.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentLoadingTasks;
+
+/**
+ * The maximum number of concurrent image decoding tasks. Decoding large
+ * images can be especially CPU and memory intensive, so if your are decoding a
+ * lot of large images in your app, you may wish to adjust this value.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentDecodingTasks;
+
+/**
+ * Decoding large images can use a lot of memory, and potentially cause the app
+ * to crash. This value allows you to throttle the amount of memory used by the
+ * decoder independently of the number of concurrent threads. This means you can
+ * still decode a lot of small images in parallel, without allowing the decoder
+ * to try to decompress multiple huge images at once. Note that this value is
+ * only a hint, and not an indicator of the total memory used by the app.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentDecodingBytes;
+
+/**
+ * Loads the specified image at the highest available resolution.
+ * Can be called from any thread, will call back on an unspecified thread.
+ */
+- (nullable RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                           callback:(RCTImageLoaderCompletionBlock)callback;
+/**
+ * As above, but includes download `priority`.
+ */
+- (nullable RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                           priority:(RCTImageLoaderPriority)priority
+                                                           callback:(RCTImageLoaderCompletionBlock)callback;
+
+/**
+ * As above, but includes target `size`, `scale` and `resizeMode`, which are used to
+ * select the optimal dimensions for the loaded image. The `clipped` option
+ * controls whether the image will be clipped to fit the specified size exactly,
+ * or if the original aspect ratio should be retained.
+ * `partialLoadBlock` is meant for custom image loaders that do not ship with the core RN library.
+ * It is meant to be called repeatedly while loading the image as higher quality versions are decoded,
+ * for instance with progressive JPEGs.
+ */
+- (nullable RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                               size:(CGSize)size
+                                                              scale:(CGFloat)scale
+                                                            clipped:(BOOL)clipped
+                                                         resizeMode:(RCTResizeMode)resizeMode
+                                                      progressBlock:(RCTImageLoaderProgressBlock)progressBlock
+                                                   partialLoadBlock:(RCTImageLoaderPartialLoadBlock)partialLoadBlock
+                                                    completionBlock:(RCTImageLoaderCompletionBlock)completionBlock;
+
+/**
+ * Finds an appropriate image decoder and passes the target `size`, `scale` and
+ * `resizeMode` for optimal image decoding.  The `clipped` option controls
+ * whether the image will be clipped to fit the specified size exactly, or
+ * if the original aspect ratio should be retained. Can be called from any
+ * thread, will call callback on an unspecified thread.
+ */
+- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)imageData
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                           clipped:(BOOL)clipped
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                   completionBlock:(RCTImageLoaderCompletionBlock)completionBlock;
+
+/**
+ * Get image size, in pixels. This method will do the least work possible to get
+ * the information, and won't decode the image if it doesn't have to.
+ */
+- (RCTImageLoaderCancellationBlock)getImageSizeForURLRequest:(NSURLRequest *)imageURLRequest
+                                                       block:(void (^)(NSError *error, CGSize size))completionBlock;
+/**
+ * Determines whether given image URLs are cached locally. The `requests` array is expected
+ * to contain objects convertible to NSURLRequest. The return value maps URLs to strings:
+ * "disk" for images known to be cached in non-volatile storage, "memory" for images known
+ * to be cached in memory. Dictionary items corresponding to images that are not known to be
+ * cached are simply missing.
+ */
+- (NSDictionary *)getImageCacheStatus:(NSArray *)requests;
+
+/**
+ * Allows developers to set their own caching implementation for
+ * decoded images as long as it conforms to the RCTImageCache
+ * protocol. This method should be called in bridgeDidInitializeModule.
+ */
+- (void)setImageCache:(id<RCTImageCache>)cache;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/Libraries/Image/RCTImageLoaderWithAttributionProtocol.h

@@ -0,0 +1,48 @@
+/*
+ * 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/RCTImageLoaderProtocol.h>
+#import <React/RCTImageURLLoaderWithAttribution.h>
+
+@protocol RCTImageLoaderWithAttributionProtocol <RCTImageLoaderProtocol, RCTImageLoaderLoggableProtocol>
+
+// TODO (T61325135): Remove C++ checks
+#ifdef __cplusplus
+/**
+ * Same as the variant in RCTImageURLLoaderProtocol, but allows passing attribution
+ * information that each image URL loader can process.
+ */
+- (RCTImageURLLoaderRequest *)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                 size:(CGSize)size
+                                                scale:(CGFloat)scale
+                                              clipped:(BOOL)clipped
+                                           resizeMode:(RCTResizeMode)resizeMode
+                                             priority:(RCTImageLoaderPriority)priority
+                                          attribution:(const facebook::react::ImageURLLoaderAttribution &)attribution
+                                        progressBlock:(RCTImageLoaderProgressBlock)progressBlock
+                                     partialLoadBlock:(RCTImageLoaderPartialLoadBlock)partialLoadBlock
+                                      completionBlock:(RCTImageLoaderCompletionBlockWithMetadata)completionBlock;
+#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 cancelled.
+ */
+- (void)trackURLImageRequestDidDestroy:(RCTImageURLLoaderRequest *)loaderRequest;
+
+/**
+ * Image instrumentation - notify that the native image view was destroyed.
+ */
+- (void)trackURLImageDidDestroy:(RCTImageURLLoaderRequest *)loaderRequest;
+
+@end

package/Libraries/Image/RCTImagePlugins.h

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ *
+ * @generated by an internal plugin build system
+ */
+
+#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
+
+// FB Internal: FBRCTImagePlugins.h is autogenerated by the build system.
+#import <React/FBRCTImagePlugins.h>
+
+#else
+
+// OSS-compatibility layer
+
+#import <Foundation/Foundation.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// RCTTurboModuleManagerDelegate should call this to resolve module classes.
+Class RCTImageClassProvider(const char *name);
+
+// Lookup functions
+Class RCTGIFImageDecoderCls(void) __attribute__((used));
+Class RCTImageEditingManagerCls(void) __attribute__((used));
+Class RCTImageLoaderCls(void) __attribute__((used));
+Class RCTImageStoreManagerCls(void) __attribute__((used));
+Class RCTLocalAssetImageLoaderCls(void) __attribute__((used));
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma GCC diagnostic pop
+
+#endif // RN_DISABLE_OSS_PLUGIN_HEADER

package/Libraries/Image/RCTImagePlugins.mm

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ *
+ * @generated by an internal plugin build system
+ */
+
+#ifndef RN_DISABLE_OSS_PLUGIN_HEADER
+
+// OSS-compatibility layer
+
+#import "RCTImagePlugins.h"
+
+#import <string>
+#import <unordered_map>
+
+Class RCTImageClassProvider(const char *name) {
+  // Intentionally leak to avoid crashing after static destructors are run.
+  static const auto sCoreModuleClassMap = new const std::unordered_map<std::string, Class (*)(void)>{
+    {"GIFImageDecoder", RCTGIFImageDecoderCls},
+    {"ImageEditingManager", RCTImageEditingManagerCls},
+    {"ImageLoader", RCTImageLoaderCls},
+    {"ImageStoreManager", RCTImageStoreManagerCls},
+    {"LocalAssetImageLoader", RCTLocalAssetImageLoaderCls},
+  };
+
+  auto p = sCoreModuleClassMap->find(name);
+  if (p != sCoreModuleClassMap->end()) {
+    auto classFunc = p->second;
+    return classFunc();
+  }
+  return nil;
+}
+
+#endif // RN_DISABLE_OSS_PLUGIN_HEADER

package/Libraries/Image/RCTImageShadowView.h

@@ -0,0 +1,12 @@
+/*
+ * 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/RCTShadowView.h>
+
+@interface RCTImageShadowView : RCTShadowView
+
+@end

package/Libraries/Image/RCTImageShadowView.mm

@@ -0,0 +1,24 @@
+/*
+ * 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/RCTImageShadowView.h>
+
+#import <React/RCTLog.h>
+
+@implementation RCTImageShadowView
+
+- (BOOL)isYogaLeafNode
+{
+  return YES;
+}
+
+- (BOOL)canHaveSubviews
+{
+  return NO;
+}
+
+@end

package/Libraries/Image/RCTImageStoreManager.h

@@ -0,0 +1,55 @@
+/*
+ * 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/RCTBridgeProxy.h>
+#import <React/RCTURLRequestHandler.h>
+
+RCT_EXTERN void RCTEnableImageStoreManagerStorageQueue(BOOL enabled);
+
+@interface RCTImageStoreManager : NSObject <RCTURLRequestHandler>
+
+/**
+ * Set and get cached image data asynchronously. It is safe to call these from any
+ * thread. The callbacks will be called on an unspecified thread.
+ */
+- (void)removeImageForTag:(NSString *)imageTag withBlock:(void (^)(void))block;
+- (void)storeImageData:(NSData *)imageData withBlock:(void (^)(NSString *imageTag))block;
+- (void)getImageDataForTag:(NSString *)imageTag withBlock:(void (^)(NSData *imageData))block;
+
+/**
+ * Convenience method to store an image directly (image is converted to data
+ * internally, so any metadata such as scale or orientation will be lost).
+ */
+- (void)storeImage:(UIImage *)image withBlock:(void (^)(NSString *imageTag))block;
+
+@end
+
+@interface RCTImageStoreManager (Deprecated)
+
+/**
+ * These methods are deprecated - use the data-based alternatives instead.
+ */
+- (NSString *)storeImage:(UIImage *)image __deprecated;
+- (UIImage *)imageForTag:(NSString *)imageTag __deprecated;
+- (void)getImageForTag:(NSString *)imageTag withBlock:(void (^)(UIImage *image))block __deprecated;
+
+@end
+
+@interface RCTBridge (RCTImageStoreManager)
+
+@property (nonatomic, readonly) RCTImageStoreManager *imageStoreManager;
+
+@end
+
+@interface RCTBridgeProxy (RCTImageStoreManager)
+
+@property (nonatomic, readonly) RCTImageStoreManager *imageStoreManager;
+
+@end

package/Libraries/Image/RCTImageStoreManager.mm

@@ -0,0 +1,296 @@
+/*
+ * 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/RCTImageStoreManager.h>
+
+#import <atomic>
+#import <memory>
+
+#import <FBReactNativeSpec/FBReactNativeSpec.h>
+#import <ImageIO/ImageIO.h>
+#import <MobileCoreServices/UTType.h>
+#import <React/RCTAssert.h>
+#import <React/RCTImageUtils.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+#import "RCTImagePlugins.h"
+
+static NSString *const RCTImageStoreURLScheme = @"rct-image-store";
+static BOOL gImageStoreManagerStorageQueueEnabled = NO;
+
+void RCTEnableImageStoreManagerStorageQueue(BOOL enabled)
+{
+  gImageStoreManagerStorageQueueEnabled = enabled;
+}
+
+@interface RCTImageStoreManager () <NativeImageStoreIOSSpec>
+@end
+
+@implementation RCTImageStoreManager {
+  NSMutableDictionary<NSString *, NSData *> *_store;
+  NSUInteger _id;
+  dispatch_queue_t _storageQueue;
+}
+
+@synthesize methodQueue = _methodQueue;
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    if (gImageStoreManagerStorageQueueEnabled) {
+      _storageQueue = dispatch_queue_create("com.facebook.react.imagestoremanager.storage", DISPATCH_QUEUE_SERIAL);
+    }
+  }
+  return self;
+}
+
+- (dispatch_queue_t)_getAsyncQueue
+{
+  return gImageStoreManagerStorageQueueEnabled ? _storageQueue : _methodQueue;
+}
+
+- (float)handlerPriority
+{
+  return 1;
+}
+
+- (void)removeImageForTag:(NSString *)imageTag withBlock:(void (^)(void))block
+{
+  dispatch_async([self _getAsyncQueue], ^{
+    [self removeImageForTag:imageTag];
+    if (block) {
+      block();
+    }
+  });
+}
+
+- (NSString *)_storeImageData:(NSData *)imageData
+{
+  RCTAssertThread([self _getAsyncQueue], @"Must be called on RCTImageStoreManager thread");
+
+  if (!_store) {
+    _store = [NSMutableDictionary new];
+    _id = 0;
+  }
+
+  NSString *imageTag = [NSString stringWithFormat:@"%@://%tu", RCTImageStoreURLScheme, _id++];
+  _store[imageTag] = imageData;
+  return imageTag;
+}
+
+- (void)storeImageData:(NSData *)imageData withBlock:(void (^)(NSString *imageTag))block
+{
+  RCTAssertParam(block);
+  dispatch_async([self _getAsyncQueue], ^{
+    block([self _storeImageData:imageData]);
+  });
+}
+
+- (void)getImageDataForTag:(NSString *)imageTag withBlock:(void (^)(NSData *imageData))block
+{
+  RCTAssertParam(block);
+  dispatch_async([self _getAsyncQueue], ^{
+    block(self->_store[imageTag]);
+  });
+}
+
+- (void)storeImage:(UIImage *)image withBlock:(void (^)(NSString *imageTag))block
+{
+  RCTAssertParam(block);
+  dispatch_async([self _getAsyncQueue], ^{
+    NSString *imageTag = [self _storeImageData:RCTGetImageData(image, 0.75)];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      block(imageTag);
+    });
+  });
+}
+
+RCT_EXPORT_METHOD(removeImageForTag : (NSString *)imageTag)
+{
+  [_store removeObjectForKey:imageTag];
+}
+
+RCT_EXPORT_METHOD(hasImageForTag : (NSString *)imageTag callback : (RCTResponseSenderBlock)callback)
+{
+  callback(@[ @(_store[imageTag] != nil) ]);
+}
+
+// TODO (#5906496): Name could be more explicit - something like getBase64EncodedDataForTag:?
+RCT_EXPORT_METHOD(getBase64ForTag
+                  : (NSString *)imageTag successCallback
+                  : (RCTResponseSenderBlock)successCallback errorCallback
+                  : (RCTResponseSenderBlock)errorCallback)
+{
+  NSData *imageData = _store[imageTag];
+  if (!imageData) {
+    errorCallback(
+        @[ RCTJSErrorFromNSError(RCTErrorWithMessage([NSString stringWithFormat:@"Invalid imageTag: %@", imageTag])) ]);
+    return;
+  }
+  // Dispatching to a background thread to perform base64 encoding
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    successCallback(@[ [imageData base64EncodedStringWithOptions:0] ]);
+  });
+}
+
+RCT_EXPORT_METHOD(addImageFromBase64
+                  : (NSString *)base64String successCallback
+                  : (RCTResponseSenderBlock)successCallback errorCallback
+                  : (RCTResponseSenderBlock)errorCallback)
+
+{
+  // Dispatching to a background thread to perform base64 decoding
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    NSData *imageData = [[NSData alloc] initWithBase64EncodedString:base64String options:0];
+    if (imageData) {
+      dispatch_async([self _getAsyncQueue], ^{
+        successCallback(@[ [self _storeImageData:imageData] ]);
+      });
+    } else {
+      errorCallback(@[ RCTJSErrorFromNSError(RCTErrorWithMessage(@"Failed to add image from base64String")) ]);
+    }
+  });
+}
+
+#pragma mark - RCTURLRequestHandler
+
+- (BOOL)canHandleRequest:(NSURLRequest *)request
+{
+  return [request.URL.scheme caseInsensitiveCompare:RCTImageStoreURLScheme] == NSOrderedSame;
+}
+
+- (id)sendRequest:(NSURLRequest *)request withDelegate:(id<RCTURLRequestDelegate>)delegate
+{
+  __block auto cancelled = std::make_shared<std::atomic<bool>>(false);
+  void (^cancellationBlock)(void) = ^{
+    cancelled->store(true);
+  };
+
+  // Dispatch async to give caller time to cancel the request
+  dispatch_async([self _getAsyncQueue], ^{
+    if (cancelled->load()) {
+      return;
+    }
+
+    NSString *imageTag = request.URL.absoluteString;
+    NSData *imageData = self->_store[imageTag];
+    if (!imageData) {
+      NSError *error = RCTErrorWithMessage([NSString stringWithFormat:@"Invalid imageTag: %@", imageTag]);
+      [delegate URLRequest:cancellationBlock didCompleteWithError:error];
+      return;
+    }
+
+    CGImageSourceRef sourceRef = CGImageSourceCreateWithData((__bridge CFDataRef)imageData, NULL);
+    if (!sourceRef) {
+      NSError *error =
+          RCTErrorWithMessage([NSString stringWithFormat:@"Unable to decode data for imageTag: %@", imageTag]);
+      [delegate URLRequest:cancellationBlock didCompleteWithError:error];
+      return;
+    }
+    CFStringRef UTI = CGImageSourceGetType(sourceRef);
+    CFRelease(sourceRef);
+
+    NSString *MIMEType = (__bridge_transfer NSString *)UTTypeCopyPreferredTagWithClass(UTI, kUTTagClassMIMEType);
+    NSURLResponse *response = [[NSURLResponse alloc] initWithURL:request.URL
+                                                        MIMEType:MIMEType
+                                           expectedContentLength:imageData.length
+                                                textEncodingName:nil];
+    CFRelease(UTI);
+
+    [delegate URLRequest:cancellationBlock didReceiveResponse:response];
+    [delegate URLRequest:cancellationBlock didReceiveData:imageData];
+    [delegate URLRequest:cancellationBlock didCompleteWithError:nil];
+  });
+
+  return cancellationBlock;
+}
+
+- (void)cancelRequest:(id)requestToken
+{
+  if (requestToken) {
+    ((void (^)(void))requestToken)();
+  }
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeImageStoreIOSSpecJSI>(params);
+}
+
+@end
+
+@implementation RCTImageStoreManager (Deprecated)
+
+- (NSString *)storeImage:(UIImage *)image
+{
+  RCTAssertMainQueue();
+  RCTLogWarn(
+      @"RCTImageStoreManager.storeImage() is deprecated and has poor performance. Use an alternative method instead.");
+  __block NSString *imageTag;
+  dispatch_sync([self _getAsyncQueue], ^{
+    imageTag = [self _storeImageData:RCTGetImageData(image, 0.75)];
+  });
+  return imageTag;
+}
+
+- (UIImage *)imageForTag:(NSString *)imageTag
+{
+  RCTAssertMainQueue();
+  RCTLogWarn(
+      @"RCTImageStoreManager.imageForTag() is deprecated and has poor performance. Use an alternative method instead.");
+  __block NSData *imageData;
+  dispatch_sync([self _getAsyncQueue], ^{
+    imageData = self->_store[imageTag];
+  });
+  return [UIImage imageWithData:imageData];
+}
+
+- (void)getImageForTag:(NSString *)imageTag withBlock:(void (^)(UIImage *image))block
+{
+  RCTAssertParam(block);
+  dispatch_async([self _getAsyncQueue], ^{
+    NSData *imageData = self->_store[imageTag];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      // imageWithData: is not thread-safe, so we can't do this on methodQueue
+      block([UIImage imageWithData:imageData]);
+    });
+  });
+}
+
+@end
+
+@implementation RCTBridge (RCTImageStoreManager)
+
+- (RCTImageStoreManager *)imageStoreManager
+{
+  return [self moduleForClass:[RCTImageStoreManager class]];
+}
+
+@end
+
+@implementation RCTBridgeProxy (RCTImageStoreManager)
+
+- (RCTImageStoreManager *)imageStoreManager
+{
+  return [self moduleForClass:[RCTImageStoreManager class]];
+}
+
+@end
+
+Class RCTImageStoreManagerCls(void)
+{
+  return RCTImageStoreManager.class;
+}