react-native-fast-image 8.27.3 → 8.28.0

package/README.md

@@ -276,7 +276,7 @@ Changing it restarts the animation.
 How the image is filtered when it's drawn smaller or larger than its size (like CSS's `image-rendering`):
 
 - `'auto'` **(Default)** - The platform's usual filtering.
-- `'smooth'` - iOS only. Keeps a large image drawn much smaller than its size (e.g. a big photo as a thumbnail, or fine lines and text) from looking jagged or noisy. **It uses more memory:** the image is also kept at smaller sizes for drawing, about a third more than the decoded image. On Android it's the same as `'auto'` (images are already decoded at about the view's size there).
+- `'smooth'` - iOS only. Keeps a large image drawn much smaller than its size (e.g. a big photo as a thumbnail, or fine lines and text) from looking jagged or noisy. Such an image is already decoded at about the view's size by default (see `downsample`), so this is for images shown at less than half their size with `downsample={false}`, or a little smaller than their size. **It uses more memory:** the image is also kept at smaller sizes for drawing, about a third more than the decoded image. On Android it's the same as `'auto'` (images are always decoded at about the view's size there).
 - `'pixelated'` - Sharp pixels, without smoothing, e.g. for pixel art drawn larger than its size. On Android, animated images are still smoothed.
 
 ---
@@ -312,9 +312,12 @@ Downloads, local files (`file://`, `content://`) and bundled images (`require()`
 
 iOS only. Decodes a large image at about the size it's shown at, instead of at full size, so it takes much less memory.
 
-Use it when you show images much larger than their views and can't get them at the right size, e.g. user uploads or other people's URLs in a list. If you control the images, serve them at the size they're shown instead (resized on your server or by an image CDN), which also saves bandwidth.
+- `true` **(Default)** - An image at least twice the size its view needs is decoded at about the view's size. If the view grows, the image is decoded again for its new size (from the disk cache).
+- `false` - Images are decoded at full size, e.g. for an image that's zoomed in on with a transform (a pinch-to-zoom viewer), which would otherwise show the smaller copy enlarged.
 
-Decoding a smaller copy can take a little longer, so use it where the memory matters. Needs SDWebImage 5.19.7 or later. Photo library images are always decoded this way. On Android images are already decoded at about the view's size.
+It doesn't change `onLoad`'s width and height (the image's own size) or the cached file. Needs SDWebImage 5.19.7 or later: before 5.19 images are decoded at full size, and 5.19.0 to 5.19.6 show photos stored sideways with an EXIF orientation (most phone photos) sideways. Photo library images are always decoded this way, and on Android images are always decoded at about the view's size.
+
+If you control the images, serve them at the size they're shown (resized on your server or by an image CDN), which also saves bandwidth.
 
 ---
 

package/dist/index.d.ts

@@ -161,9 +161,9 @@ export interface FastImageProps extends AccessibilityProps, ViewProps {
     transition?: boolean | number | Transition | null;
     /**
      * iOS only. Decodes a large image at about the size it's shown at, so it
-     * takes much less memory. For images much larger than their views that
-     * you can't get at the right size (if you can, resize them on your server
-     * or with an image CDN instead). See the README.
+     * takes much less memory. `true` (default). `false` decodes images at
+     * full size, e.g. for an image that's zoomed in on with a transform. See
+     * the README.
      */
     downsample?: boolean;
     /**

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

@@ -88,6 +88,9 @@ static UIImage* FFFBlurredImage(UIImage* image, CGFloat scale, CGFloat radius, B
     // rather than dimming like the system's controls.
     self.tintAdjustmentMode = UIViewTintAdjustmentModeNormal;
     _loopCount = -1;
+    // Images are decoded at about the size they're shown at unless
+    // downsample is false, as on Android.
+    _downsample = YES;
     return self;
 }
 
@@ -991,8 +994,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 +1004,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 +1059,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.28.0",
     "description": "FastImage, performant React Native image component.",
     "keywords": [
         "cache",