react-native-fast-image 8.27.3 → 8.27.4

package/ios/FastImage/FFFDownsampledImage.h

@@ -10,12 +10,16 @@
 // the image's header before it decodes, as React Native's Image does.
 @interface FFFDownsampledImage : SDAnimatedImage
 
-// The url to load a source's url with, when it's downsampled.
-+ (NSURL*) loadURLForURL: (NSURL*)url;
-
 // Sets a load's context to decode the image for a box (in pixels) to cover
-// or fit in. `key` is the source's cache key (its url, or its cacheKey).
-+ (void) addToContext: (SDWebImageMutableContext*)context forKey: (NSString*)key box: (CGSize)box cover: (BOOL)cover;
+// or fit in.
++ (void) addToContext: (SDWebImageMutableContext*)context box: (CGSize)box cover: (BOOL)cover;
+
+// Sets a load's context to decode the image at full size, through this class
+// when it's supported. Every FastImage load uses it, so loads of the same url
+// can share a download: SDWebImage's downloader decodes each load of a
+// download with the first load's image class (and each with its own size),
+// and SDWebImage's own thumbnail decoding can't cover a box.
++ (void) addFullSizeToContext: (SDWebImageMutableContext*)context;
 
 // The size of the full image (in points, like UIImage's size) that an image
 // loaded this way was decoded from, for onLoad, or zero for other images.

package/ios/FastImage/FFFDownsampledImage.m

@@ -2,13 +2,12 @@
 #import <ImageIO/ImageIO.h>
 #import <SDWebImage/SDImageCoder.h>
 #import <SDWebImage/SDImageCacheDefine.h>
-#import <SDWebImage/SDWebImageCacheKeyFilter.h>
 #import <SDWebImage/UIImage+Metadata.h>
+#import <SDWebImage/NSData+ImageContentType.h>
+#import <SDWebImage/SDImageCodersManager.h>
 
 // The decode option that carries the full image's size to the view.
 static SDImageCoderOption const FFFDecodeSourceSize = @"FFFDecodeSourceSize";
-// Added to the url's fragment, which isn't sent to the server.
-static NSString* const FFFDownsampledFragment = @"fastimage-downsampled";
 
 // The image's size in pixels as it's shown (EXIF orientations 5 to 8 turn it
 // sideways), from its header, or zero if ImageIO can't read it.
@@ -83,38 +82,20 @@ static CGSize FFFPixelSize(NSData* data) {
     return supported;
 }
 
-+ (NSURL*) loadURLForURL: (NSURL*)url {
-    // SDWebImage's downloader shares a download between loads of the same
-    // url, and decodes each load's image with the first load's image class.
-    // After a load that isn't downsampled (e.g. a preload), this class
-    // wouldn't be used, and the box would be decoded as SDWebImage does (to
-    // fill it, stretched). With its own url, a downsampled load only shares
-    // downloads with other downsampled ones. Not a photo library url, which
-    // isn't downloaded, and whose loader reads everything after ph:// as the
-    // photo's identifier.
-    if ([url.scheme isEqualToString: @"ph"]) {
-        return url;
++ (void) addFullSizeToContext: (SDWebImageMutableContext*)context {
+    if (![self isSupported]) {
+        context[SDWebImageContextAnimatedImageClass] = [SDAnimatedImage class];
+        return;
     }
-    NSURLComponents* components = [NSURLComponents componentsWithURL: url resolvingAgainstBaseURL: NO];
-    if (!components) {
-        return url;
-    }
-    components.fragment = components.fragment.length > 0
-        ? [components.fragment stringByAppendingFormat: @"-%@", FFFDownsampledFragment]
-        : FFFDownsampledFragment;
-    return components.URL ?: url;
+    context[SDWebImageContextAnimatedImageClass] = [FFFDownsampledImage class];
+    context[SDWebImageContextImageDecodeOptions] = @{FFFDecodeSourceSize: [FFFSourceSize new]};
 }
 
-+ (void) addToContext: (SDWebImageMutableContext*)context forKey: (NSString*)key box: (CGSize)box cover: (BOOL)cover {
++ (void) addToContext: (SDWebImageMutableContext*)context box: (CGSize)box cover: (BOOL)cover {
     context[SDWebImageContextAnimatedImageClass] = [FFFDownsampledImage class];
-    // Cached under the source's own key (not the url from loadURLForURL:),
-    // so the disk cache keeps one download for every size and for loads
-    // that aren't downsampled.
-    context[SDWebImageContextCacheKeyFilter] = [SDWebImageCacheKeyFilter cacheKeyFilterWithBlock: ^NSString* (NSURL* _Nonnull loadURL) {
-        return key;
-    }];
-    // The memory cache key is the url with these (SDWebImage's thumbnail
-    // key), so views of other sizes don't get this image.
+    // The memory cache key is the source's key with these (SDWebImage's
+    // thumbnail key), so views of other sizes don't get this image. The disk
+    // cache keeps the downloaded file under the source's key, for every size.
     context[SDWebImageContextImageThumbnailPixelSize] = [NSValue valueWithCGSize: box];
     context[SDWebImageContextImagePreserveAspectRatio] = @(!cover);
     context[SDWebImageContextImageDecodeOptions] = @{FFFDecodeSourceSize: [FFFSourceSize new]};
@@ -129,6 +110,22 @@ static CGSize FFFPixelSize(NSData* data) {
 }
 
 - (instancetype) initWithData: (NSData*)data scale: (CGFloat)scale options: (SDImageCoderOptions*)options {
+    // An SVG isn't decoded smaller: it's a vector image, drawn at any size.
+    // This class can't decode it, and SDWebImage would then give it to the
+    // SVG coder with the box, which draws it into a bitmap that size. Decoded
+    // as without downsample instead (this init can return another image).
+    if ([NSData sd_imageFormatForImageData: data] == SDImageFormatSVG) {
+        NSMutableDictionary* vectorOptions = options ? [options mutableCopy] : [NSMutableDictionary dictionary];
+        [vectorOptions removeObjectForKey: SDImageCoderDecodeThumbnailPixelSize];
+        UIImage* image = [[SDImageCodersManager sharedManager] decodedImageWithData: data options: vectorOptions];
+        FFFSourceSize* sourceSize = options[FFFDecodeSourceSize];
+        if (image && [sourceSize isKindOfClass: [FFFSourceSize class]]) {
+            sourceSize.size = image.size;
+        }
+        self = (id) image;
+        return self;
+    }
+
     NSValue* boxValue = options[SDImageCoderDecodeThumbnailPixelSize];
     CGSize box = boxValue ? boxValue.CGSizeValue : CGSizeZero;
     NSNumber* preserveAspectRatio = options[SDImageCoderDecodePreserveAspectRatio];

package/ios/FastImage/FFFastImageView.m

@@ -991,8 +991,7 @@ NSString *FFFErrorMessage(NSError *error)
     }
     CGSize box = [self decodeBox];
     SDWebImageContext* context = [self contextForSource: source box: box cover: [self decodeCovers]];
-    NSURL* url = CGSizeEqualToSize(box, CGSizeZero) ? source.url : [FFFDownsampledImage loadURLForURL: source.url];
-    NSString* key = [manager cacheKeyForURL: url context: context];
+    NSString* key = [manager cacheKeyForURL: source.url context: context];
     return [(SDImageCache*) manager.imageCache imageFromMemoryCacheForKey: key] != nil;
 }
 
@@ -1002,15 +1001,14 @@ NSString *FFFErrorMessage(NSError *error)
     context[SDWebImageContextImageLoader] = source.imageLoader;
     context[SDWebImageContextCacheKeyFilter] = source.cacheKeyFilter;
     if (CGSizeEqualToSize(box, CGSizeZero)) {
-        context[SDWebImageContextAnimatedImageClass] = [SDAnimatedImage class];
+        [FFFDownsampledImage addFullSizeToContext: context];
         if (!source.memoryCache) {
             // Only on disk, also when it comes from there.
             context[SDWebImageContextStoreCacheType] = @(SDImageCacheTypeDisk);
         }
         return context;
     }
-    NSString* key = source.cacheKeyFilter ? source.cacheKey : source.url.absoluteString;
-    [FFFDownsampledImage addToContext: context forKey: key box: box cover: cover];
+    [FFFDownsampledImage addToContext: context box: box cover: cover];
     if ([source isPhotoLibrary]) {
         // Photos makes the photo at the size asked for, with no file
         // downloaded: SDWebImage would keep this smaller copy on disk as the
@@ -1058,7 +1056,7 @@ NSString *FFFErrorMessage(NSError *error)
         };
     }
     CFTimeInterval startedAt = CACurrentMediaTime();
-    NSURL* url = context[SDWebImageContextImageThumbnailPixelSize] ? [FFFDownsampledImage loadURLForURL: source.url] : source.url;
+    NSURL* url = source.url;
     if (!events) {
         // Only this load's image: SDWebImage would clear the view (to the
         // placeholder) if it fails, and a cancelled load can still complete.

package/ios/FastImage/FFFastImageViewManager.m

@@ -1,5 +1,6 @@
 #import "FFFastImageViewManager.h"
 #import "FFFastImageView.h"
+#import "FFFDownsampledImage.h"
 
 #import <SDWebImage/SDImageCache.h>
 #import <SDWebImage/SDWebImageManager.h>
@@ -128,13 +129,16 @@ RCT_REMAP_VIEW_PROPERTY(tintColor, imageColor, UIColor)
 static NSMutableArray<dispatch_block_t> *FFFPendingPreloads;
 static NSUInteger FFFPreloadsInFlight;
 
-// A preload's context: the source's headers and cache key.
+// A preload's context: the source's headers and cache key, and the image
+// class views use, so a view of the same url can share its download (see
+// FFFDownsampledImage).
 static SDWebImageMutableContext *FFFPreloadContext(FFFastImageSource *source)
 {
     SDWebImageMutableContext *context = [NSMutableDictionary dictionary];
     context[SDWebImageContextDownloadRequestModifier] = source.requestModifier;
     context[SDWebImageContextImageLoader] = source.imageLoader;
     context[SDWebImageContextCacheKeyFilter] = source.cacheKeyFilter;
+    [FFFDownsampledImage addFullSizeToContext:context];
     return context;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-fast-image",
-    "version": "8.27.3",
+    "version": "8.27.4",
     "description": "FastImage, performant React Native image component.",
     "keywords": [
         "cache",