react-native-fast-image 8.27.2 → 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/FFFastImageSource.m

@@ -157,18 +157,73 @@ static CGSize FFFPhotoPixelSize(NSURL *url)
 // body is an image: a page sent instead (e.g. a captive portal's, with status
 // 200) would be served from there until it expired, and each load would fail.
 // Removing it after a load failed (forgetResponseAfterError:) could still be
-// in progress when the next load started.
+// in progress when the next load started. A page with an inline <svg> isn't
+// an SVG image.
 @interface FFFWebDownloaderOperation : SDWebImageDownloaderOperation
 @end
 
 @implementation FFFWebDownloaderOperation
 
+// Whether data is an SVG document: its first element (after an XML
+// declaration, comments or a doctype) is <svg>, as on Android
+// (FastImageSvg.looksLikeSvg). SDWebImage takes data that starts with '<' and
+// has an <svg> element anywhere for SVG, such as a page with an icon.
+static BOOL FFFHasPrefixAt(NSString *text, NSUInteger i, NSString *prefix)
+{
+    return text.length - i >= prefix.length && [text compare:prefix options:0 range:NSMakeRange(i, prefix.length)] == NSOrderedSame;
+}
+
+// The index after the end marker from i, or NSNotFound if it isn't there.
+static NSUInteger FFFSkipPast(NSString *text, NSUInteger i, NSString *end)
+{
+    NSRange found = [text rangeOfString:end options:0 range:NSMakeRange(i, text.length - i)];
+    return found.location == NSNotFound ? NSNotFound : NSMaxRange(found);
+}
+
+static BOOL FFFLooksLikeSVG(NSData *data)
+{
+    // The markup is ASCII: Latin-1 reads any bytes (a UTF-8 character cut off
+    // at the end too).
+    NSData *head = [data subdataWithRange:NSMakeRange(0, MIN(data.length, (NSUInteger)1024))];
+    NSString *text = [[[NSString alloc] initWithData:head encoding:NSISOLatin1StringEncoding] lowercaseString];
+    NSCharacterSet *space = NSCharacterSet.whitespaceAndNewlineCharacterSet;
+    // A UTF-8 byte order mark, as Latin-1.
+    NSUInteger i = FFFHasPrefixAt(text, 0, @"\u00EF\u00BB\u00BF") ? 3 : 0;
+    while (i < text.length) {
+        if ([space characterIsMember:[text characterAtIndex:i]]) {
+            i++;
+        } else if (FFFHasPrefixAt(text, i, @"<?")) {
+            i = FFFSkipPast(text, i, @"?>");
+        } else if (FFFHasPrefixAt(text, i, @"<!--")) {
+            i = FFFSkipPast(text, i, @"-->");
+        } else if (FFFHasPrefixAt(text, i, @"<!")) {
+            // A doctype, whose internal subset ([...]) can have '>'s.
+            NSRange rest = NSMakeRange(i, text.length - i);
+            NSUInteger subset = [text rangeOfString:@"[" options:0 range:rest].location;
+            NSUInteger close = [text rangeOfString:@">" options:0 range:rest].location;
+            if (subset != NSNotFound && subset < close) {
+                i = FFFSkipPast(text, subset, @"]");
+            }
+            if (i != NSNotFound) {
+                i = FFFSkipPast(text, i, @">");
+            }
+        } else {
+            return FFFHasPrefixAt(text, i, @"<svg");
+        }
+        if (i == NSNotFound) {
+            return NO;
+        }
+    }
+    return NO;
+}
+
 - (void)URLSession:(NSURLSession *)session
           dataTask:(NSURLSessionDataTask *)dataTask
  willCacheResponse:(NSCachedURLResponse *)proposedResponse
  completionHandler:(void (^)(NSCachedURLResponse *cachedResponse))completionHandler
 {
-    if ([NSData sd_imageFormatForImageData:proposedResponse.data] == SDImageFormatUndefined) {
+    SDImageFormat format = [NSData sd_imageFormatForImageData:proposedResponse.data];
+    if (format == SDImageFormatUndefined || (format == SDImageFormatSVG && !FFFLooksLikeSVG(proposedResponse.data))) {
         completionHandler(nil);
         return;
     }

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.2",
+    "version": "8.27.4",
     "description": "FastImage, performant React Native image component.",
     "keywords": [
         "cache",