react-native-fast-image 8.23.0 → 8.25.0

package/README.md

@@ -105,6 +105,25 @@ When `source` changes, the image that's showing stays until the new one has load
 
 Remote url to load the image from. e.g. `'https://facebook.github.io/react/img/logo_og.png'`.
 
+#### Photo library images (iOS)
+
+A photo library url (`ph://<localIdentifier>`, as camera roll libraries give) loads when the app has SDWebImagePhotosPlugin. Add it to the app's `ios/Podfile` and run `pod install`:
+
+```ruby
+pod 'SDWebImagePhotosPlugin'
+```
+
+With Expo, add it with [expo-build-properties](https://docs.expo.dev/versions/latest/sdk/build-properties/):
+
+```json
+[
+    "expo-build-properties",
+    { "ios": { "extraPods": [{ "name": "SDWebImagePhotosPlugin" }] } }
+]
+```
+
+The app needs access to the photo library, which it has if it got the url from there. A photo library image is decoded at about the view's size, since photos are large and usually shown small; `onLoad` still reports the photo's own size. `FastImage.preload` of a `ph://` source loads the full-size photo (there's no view to size it for), which doesn't make a view's smaller copy load faster, so preloading photo library images usually isn't worth it. Without the plugin, a `ph://` source fails with `onError`, saying so. `assets-library://` urls aren't supported. On Android, photo pickers give `content://` urls, which load as they are.
+
 ---
 
 ### `source.headers?: object`
@@ -180,6 +199,7 @@ For views that get reused for other content, such as rows in FlashList or recycl
 - `FastImage.resizeMode.cover` **(Default)** - Scale the image uniformly (maintain the image's aspect ratio) so that both dimensions (width and height) of the image will be equal to or larger than the corresponding dimension of the view (minus padding).
 - `FastImage.resizeMode.stretch` - Scale width and height independently, This may change the aspect ratio of the src.
 - `FastImage.resizeMode.center` - Do not scale the image, keep centered.
+- `FastImage.resizeMode.repeat` - Repeat the image to cover the view, from its top-left corner, at the image's own size in pixels (a bundled image at its size in points), scaled down to fit if it's larger than the view. An animated image repeats its first frame, and `defaultSource` repeats too.
 
 ---
 
@@ -239,7 +259,7 @@ iOS only. Decodes a large image at about the size it's shown at, instead of at f
 
 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.
 
-Decoding a smaller copy can take a little longer, so use it where the memory matters. Needs SDWebImage 5.19.7 or later. On Android images are already decoded at about the view's size.
+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.
 
 ---
 

package/android/src/main/java/com/dylanvann/fastimage/FastImageViewManager.java

@@ -127,8 +127,11 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
 
     @ReactProp(name = "resizeMode")
     public void setResizeMode(FastImageViewWithUrl view, String resizeMode) {
-        final FastImageViewWithUrl.ScaleType scaleType = FastImageViewConverter.getScaleType(resizeMode);
-        view.setResizeMode(scaleType);
+        // repeat fills the view with the tiled image (see setImageDrawable).
+        boolean repeat = "repeat".equals(resizeMode);
+        final FastImageViewWithUrl.ScaleType scaleType =
+                repeat ? FastImageViewWithUrl.ScaleType.FIT_XY : FastImageViewConverter.getScaleType(resizeMode);
+        view.setResizeMode(scaleType, repeat);
     }
 
     @Override

package/android/src/main/java/com/dylanvann/fastimage/FastImageViewWithUrl.java

@@ -12,6 +12,7 @@ import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.PorterDuff;
 import android.graphics.PorterDuffXfermode;
+import android.graphics.Shader;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 
@@ -354,14 +355,41 @@ class FastImageViewWithUrl extends AppCompatImageView {
                 : mLoopCount);
     }
 
+    // resizeMode repeat: the image (a GIF's first frame) repeated from the
+    // top-left at its own size, scaled down to fit the view if it's larger,
+    // as React Native's Image does. The view fills with it (FIT_XY).
+    private boolean mRepeat = false;
+
     // Glide crops or fits the bitmap for the scale type when it loads, so a
     // new resizeMode needs a reload to take effect (#762).
-    public void setResizeMode(ScaleType scaleType) {
-        if (scaleType == getScaleType()) return;
+    public void setResizeMode(ScaleType scaleType, boolean repeat) {
+        if (scaleType == getScaleType() && repeat == mRepeat) return;
         setScaleType(scaleType);
+        mRepeat = repeat;
         mNeedsReload = true;
     }
 
+    // Repeats what the view shows (the loaded image, and defaultSource).
+    @Override
+    public void setImageDrawable(@Nullable Drawable drawable) {
+        super.setImageDrawable(mRepeat ? tiled(drawable) : drawable);
+    }
+
+    @Nullable
+    private Drawable tiled(@Nullable Drawable drawable) {
+        if (!(drawable instanceof BitmapDrawable)) return drawable;
+        BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
+        if (bitmapDrawable.getTileModeX() == Shader.TileMode.REPEAT) return drawable;
+        Bitmap bitmap = bitmapDrawable.getBitmap();
+        if (bitmap == null) return drawable;
+        // A copy of the drawable (not of the bitmap): Glide's may be shown by
+        // other views too.
+        BitmapDrawable tiled = new BitmapDrawable(getResources(), bitmap);
+        tiled.setTileModeXY(Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);
+        if (mPixelated) tiled.setFilterBitmap(false);
+        return tiled;
+    }
+
     // imageRendering="pixelated": no resampling by Glide, and drawn without
     // filtering (sharp pixels). "smooth" is iOS only; here it's the same as
     // "auto": Glide already decodes a large image at about the view's size, and
@@ -391,9 +419,20 @@ class FastImageViewWithUrl extends AppCompatImageView {
     // pixelated, and the blur. A blurred animated image shows its first frame,
     // as on iOS.
     private RequestOptions renderingOptions(Object model) {
-        FastImageBlur blur = mBlurRadius > 0 ? new FastImageBlur(mBlurRadius, getScaleType()) : null;
+        FastImageBlur blur = mBlurRadius > 0 ? new FastImageBlur(mBlurRadius, mRepeat ? null : getScaleType()) : null;
         RequestOptions options;
-        if (mPixelated) {
+        if (mRepeat) {
+            // Decoded at its own size, or scaled down to fit the view if it's
+            // larger (not cropped or fitted for the scale type), and a GIF as
+            // its first frame (tiled by setImageDrawable).
+            options = new RequestOptions()
+                    .downsample(new FastImageSourceSize.Capture(
+                            mPixelated ? DownsampleStrategy.NONE : DownsampleStrategy.CENTER_INSIDE,
+                            String.valueOf(model)))
+                    .dontTransform()
+                    .dontAnimate();
+            if (blur != null) options = options.optionalTransform(blur);
+        } else if (mPixelated) {
             // Decoded as it is, then scaled by the view without filtering (see
             // OwnGifTarget).
             options = new RequestOptions()

package/dist/constants.d.ts

@@ -3,6 +3,7 @@ export declare const resizeMode: {
     readonly cover: 'cover';
     readonly stretch: 'stretch';
     readonly center: 'center';
+    readonly repeat: 'repeat';
 };
 export declare const priority: {
     readonly low: 'low';

package/dist/index.cjs.js

@@ -32,7 +32,8 @@ const resizeMode = {
 	contain: "contain",
 	cover: "cover",
 	stretch: "stretch",
-	center: "center"
+	center: "center",
+	repeat: "repeat"
 };
 const priority = {
 	low: "low",

package/dist/index.cjs.js.flow

@@ -33,6 +33,7 @@ export type ResizeMode = $ReadOnly<{|
     cover: 'cover',
     stretch: 'stretch',
     center: 'center',
+    repeat: 'repeat',
 |}>
 
 export type Priority = $ReadOnly<{|

package/dist/index.cjs.web.js

@@ -32,7 +32,8 @@ const resizeMode = {
 	contain: "contain",
 	cover: "cover",
 	stretch: "stretch",
-	center: "center"
+	center: "center",
+	repeat: "repeat"
 };
 const priority = {
 	low: "low",

package/dist/index.cjs.web.js.flow

@@ -33,6 +33,7 @@ export type ResizeMode = $ReadOnly<{|
     cover: 'cover',
     stretch: 'stretch',
     center: 'center',
+    repeat: 'repeat',
 |}>
 
 export type Priority = $ReadOnly<{|

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import React from 'react';
 import { LayoutChangeEvent, StyleProp, ViewStyle, ImageRequireSource, AccessibilityProps, ViewProps } from 'react-native';
 import { cacheControl, priority, resizeMode } from './constants';
 type ColorValue = NonNullable<ViewStyle['backgroundColor']>;
-export type ResizeMode = 'contain' | 'cover' | 'stretch' | 'center';
+export type ResizeMode = 'contain' | 'cover' | 'stretch' | 'center' | 'repeat';
 export type Priority = 'low' | 'normal' | 'high';
 export type Cache = 'immutable' | 'web' | 'cacheOnly';
 export type Source = {

package/dist/index.js

@@ -5,7 +5,8 @@ const resizeMode = {
 	contain: "contain",
 	cover: "cover",
 	stretch: "stretch",
-	center: "center"
+	center: "center",
+	repeat: "repeat"
 };
 const priority = {
 	low: "low",

package/dist/index.js.flow

@@ -33,6 +33,7 @@ export type ResizeMode = $ReadOnly<{|
     cover: 'cover',
     stretch: 'stretch',
     center: 'center',
+    repeat: 'repeat',
 |}>
 
 export type Priority = $ReadOnly<{|

package/dist/index.web.js

@@ -5,7 +5,8 @@ const resizeMode = {
 	contain: "contain",
 	cover: "cover",
 	stretch: "stretch",
-	center: "center"
+	center: "center",
+	repeat: "repeat"
 };
 const priority = {
 	low: "low",

package/dist/index.web.js.flow

@@ -33,6 +33,7 @@ export type ResizeMode = $ReadOnly<{|
     cover: 'cover',
     stretch: 'stretch',
     center: 'center',
+    repeat: 'repeat',
 |}>
 
 export type Priority = $ReadOnly<{|

package/ios/FastImage/FFFDownsampledImage.m

@@ -89,7 +89,12 @@ static CGSize FFFPixelSize(NSData* data) {
     // 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.
+    // 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;
+    }
     NSURLComponents* components = [NSURLComponents componentsWithURL: url resolvingAgainstBaseURL: NO];
     if (!components) {
         return url;

package/ios/FastImage/FFFastImageSource.h

@@ -53,9 +53,18 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 - (SDWebImageOptions)cacheOptions;
 
 // The loader for `cache: 'web'` images, whose HTTP cache is their own (see
-// webURLCache), or nil for SDWebImage's shared one.
+// webURLCache), for photo library images (ph://, see FFFPhotosLoader), or nil
+// for SDWebImage's shared one.
 - (id<SDImageLoader>)imageLoader;
 
+// Whether the source is a photo library image (ph://<localIdentifier>),
+// which is decoded at about the view's size.
+- (BOOL)isPhotoLibrary;
+
+// A photo library image's own size in pixels (for onLoad when it comes from
+// a cache, where the size it was decoded from isn't recorded), or zero.
+- (CGSize)photoPixelSize;
+
 // The HTTP cache of `cache: 'web'` images: their own rather than the app's
 // shared NSURLCache, so clearDiskCache can empty it without the app's other
 // responses. 50 MB, as on Android.

package/ios/FastImage/FFFastImageSource.m

@@ -5,9 +5,150 @@
 #import <SDWebImage/SDWebImageError.h>
 #import <SDWebImage/SDWebImageDownloaderOperation.h>
 #import <SDWebImage/NSData+ImageContentType.h>
+#import <objc/message.h>
 
 static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
 
+// The photo's own size in pixels, looked up by its identifier (the url after
+// ph://), or zero. Through the runtime, as the Photos framework is only there
+// when the app links it (with SDWebImagePhotosPlugin). Kept once looked up.
+static CGSize FFFLookUpPhotoPixelSize(NSURL *url)
+{
+    Class assetClass = NSClassFromString(@"PHAsset");
+    SEL fetch = NSSelectorFromString(@"fetchAssetsWithLocalIdentifiers:options:");
+    NSString *prefix = @"ph://";
+    NSString *string = url.absoluteString;
+    if (!assetClass || ![assetClass respondsToSelector:fetch] || ![string hasPrefix:prefix]) {
+        return CGSizeZero;
+    }
+    id (*fetchAssets)(id, SEL, NSArray *, id) = (void *)objc_msgSend;
+    id result = fetchAssets(assetClass, fetch, @[[string substringFromIndex:prefix.length]], nil);
+    id asset = [result respondsToSelector:@selector(firstObject)] ? [result firstObject] : nil;
+    if (!asset) {
+        return CGSizeZero;
+    }
+    return CGSizeMake([[asset valueForKey:@"pixelWidth"] doubleValue], [[asset valueForKey:@"pixelHeight"] doubleValue]);
+}
+
+static NSCache<NSString *, NSValue *> *FFFPhotoSizes(void)
+{
+    static NSCache *sizes;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        sizes = [NSCache new];
+    });
+    return sizes;
+}
+
+static CGSize FFFPhotoPixelSize(NSURL *url)
+{
+    NSString *key = url.absoluteString;
+    NSValue *known = key ? [FFFPhotoSizes() objectForKey:key] : nil;
+    if (known) {
+        return known.CGSizeValue;
+    }
+    CGSize size = FFFLookUpPhotoPixelSize(url);
+    if (key && size.width > 0 && size.height > 0) {
+        [FFFPhotoSizes() setObject:[NSValue valueWithCGSize:size] forKey:key];
+    }
+    return size;
+}
+
+// Loads photo library images (ph://<localIdentifier>) with
+// SDWebImagePhotosPlugin's loader when the app has it (the pod): FastImage
+// finds it at runtime, so it doesn't depend on it or on the Photos framework.
+// Its own instance, so the app's use of the plugin is left as it is. Without
+// the plugin, or for a source it can't load (assets-library://), the load
+// fails with `failure`.
+@interface FFFPhotosLoader : NSObject <SDImageLoader>
+@property (nonatomic, strong) id<SDImageLoader> plugin;
+@property (nonatomic, copy) NSString *failure;
+@end
+
+@implementation FFFPhotosLoader
+
++ (FFFPhotosLoader *)photosLoader
+{
+    static FFFPhotosLoader *loader;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        loader = [FFFPhotosLoader new];
+        Class pluginClass = NSClassFromString(@"SDImagePhotosLoader");
+        id<SDImageLoader> plugin = pluginClass ? [pluginClass new] : nil;
+        if ([plugin conformsToProtocol:@protocol(SDImageLoader)]) {
+            // One image per load, at full quality. By default the plugin
+            // first sends a quick low quality one, which a view would show
+            // (and fade in) before the one it asked for.
+            // PHImageRequestOptionsDeliveryModeHighQualityFormat. Skipped if
+            // a later version of the plugin renames these.
+            NSObject *requestOptions = [(NSObject *)plugin respondsToSelector:NSSelectorFromString(@"imageRequestOptions")]
+                ? [(NSObject *)plugin valueForKey:@"imageRequestOptions"]
+                : nil;
+            if ([requestOptions respondsToSelector:NSSelectorFromString(@"setDeliveryMode:")]) {
+                [requestOptions setValue:@1 forKey:@"deliveryMode"];
+            }
+            loader.plugin = plugin;
+        } else {
+            loader.failure = @"Photo library images (ph://) need SDWebImagePhotosPlugin: add pod 'SDWebImagePhotosPlugin' to the app's Podfile";
+        }
+    });
+    return loader;
+}
+
++ (FFFPhotosLoader *)assetsLibraryLoader
+{
+    static FFFPhotosLoader *loader;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        loader = [FFFPhotosLoader new];
+        loader.failure = @"assets-library:// urls aren't supported: use the photo's ph:// url (with SDWebImagePhotosPlugin)";
+    });
+    return loader;
+}
+
+- (BOOL)canRequestImageForURL:(NSURL *)url
+{
+    return YES;
+}
+
+- (id<SDWebImageOperation>)requestImageWithURL:(NSURL *)url
+                                        options:(SDWebImageOptions)options
+                                        context:(SDWebImageContext *)context
+                                       progress:(SDImageLoaderProgressBlock)progressBlock
+                                      completed:(SDImageLoaderCompletedBlock)completedBlock
+{
+    if (!self.plugin) {
+        if (completedBlock) {
+            NSError *error = [NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidURL userInfo:@{NSLocalizedDescriptionKey: self.failure}];
+            completedBlock(nil, nil, error, YES);
+        }
+        return nil;
+    }
+    return [self.plugin requestImageWithURL:url options:options context:context progress:progressBlock completed:^(UIImage *image, NSData *data, NSError *error, BOOL finished) {
+        if (!image || !completedBlock) {
+            if (completedBlock) {
+                completedBlock(image, data, error, finished);
+            }
+            return;
+        }
+        // Looks up the photo's own size for onLoad here, off the main thread
+        // (the image is decoded at about the view's size).
+        dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+            FFFPhotoPixelSize(url);
+            dispatch_async(dispatch_get_main_queue(), ^{
+                completedBlock(image, data, error, finished);
+            });
+        });
+    }];
+}
+
+- (BOOL)shouldBlockFailedURLWithURL:(NSURL *)url error:(NSError *)error
+{
+    return self.plugin ? [self.plugin shouldBlockFailedURLWithURL:url error:error] : NO;
+}
+
+@end
+
 // Downloads `cache: 'web'` images. The HTTP cache only stores a response whose
 // 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.
@@ -75,8 +216,24 @@ static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
     return 0;
 }
 
+- (BOOL)isPhotoLibrary
+{
+    return [_url.scheme isEqualToString:@"ph"];
+}
+
+- (CGSize)photoPixelSize
+{
+    return [self isPhotoLibrary] ? FFFPhotoPixelSize(_url) : CGSizeZero;
+}
+
 - (id<SDImageLoader>)imageLoader
 {
+    if ([self isPhotoLibrary]) {
+        return [FFFPhotosLoader photosLoader];
+    }
+    if ([_url.scheme isEqualToString:@"assets-library"]) {
+        return [FFFPhotosLoader assetsLibraryLoader];
+    }
     if (_cacheControl != FFFCacheControlWeb) {
         return nil;
     }

package/ios/FastImage/FFFastImageView.m

@@ -24,6 +24,8 @@
 @property(nonatomic, assign) NSUInteger imageCount;
 // The view's size when the image showing was blurred.
 @property(nonatomic, assign) CGSize blurredForSize;
+// The view's size when the image showing was tiled (resizeMode repeat).
+@property(nonatomic, assign) CGSize tiledForSize;
 // The blurred image showing (untinted), so a tint change can re-show it.
 @property(nonatomic, strong) UIImage* blurredImage;
 // The image being blurred fades in once it's blurred (transition).
@@ -211,11 +213,14 @@ static UIImage* FFFBlurredImage(UIImage* image, CGFloat scale, CGFloat radius, B
 
 - (void) setResizeMode: (RCTResizeMode)resizeMode {
     if (_resizeMode != resizeMode) {
+        BOOL repeated = _resizeMode == RCTResizeModeRepeat;
         _resizeMode = resizeMode;
         [self updateContentMode];
-        // The blur is made for the size the image is shown at.
-        if ([self blurs: self.originalImage]) {
-            [self setImage: self.originalImage];
+        // The blur is made for the size the image is shown at, and repeat
+        // shows the image tiled: show it again.
+        UIImage* image = self.originalImage ?: super.image;
+        if ([self blurs: self.originalImage] || ((repeated || resizeMode == RCTResizeModeRepeat) && image)) {
+            [self setImage: image];
         }
     }
 }
@@ -227,7 +232,10 @@ static UIImage* FFFBlurredImage(UIImage* image, CGFloat scale, CGFloat radius, B
 // view's size.
 - (void) updateContentMode {
     UIViewContentMode contentMode = (UIViewContentMode) _resizeMode;
-    if (_resizeMode == RCTResizeModeCenter) {
+    if (_resizeMode == RCTResizeModeRepeat) {
+        // The tiled image (see tiledImage:) fills the view.
+        contentMode = UIViewContentModeScaleToFill;
+    } else if (_resizeMode == RCTResizeModeCenter) {
         CGSize imageSize = super.image.size;
         CGSize viewSize = self.bounds.size;
         if (imageSize.width > viewSize.width || imageSize.height > viewSize.height) {
@@ -243,6 +251,7 @@ static UIImage* FFFBlurredImage(UIImage* image, CGFloat scale, CGFloat radius, B
     [super layoutSubviews];
     [self updateContentMode];
     [self blurAgainIfResized];
+    [self tileAgainIfResized];
     if (self.waitsForSize) {
         if ([self hasSize]) {
             [self reloadImage];
@@ -320,7 +329,8 @@ static UIImage* FFFBlurredImage(UIImage* image, CGFloat scale, CGFloat radius, B
         [self blurImage: image];
         return;
     }
-    self.originalImage = image && self.imageColor ? image : nil;
+    // Kept to tint, or tile (resizeMode repeat), it again.
+    self.originalImage = image && (self.imageColor || _resizeMode == RCTResizeModeRepeat) ? image : nil;
     self.blurredImage = nil;
     self.blursOverNothing = NO;
     // The blur was removed before it was ready: the fade it was waiting for
@@ -342,7 +352,9 @@ static UIImage* FFFBlurredImage(UIImage* image, CGFloat scale, CGFloat radius, B
 // template is), or, before SDWebImage 5.20, the first frame shows.
 - (void) showImage: (UIImage*)image {
     UIColor* tint = image ? self.imageColor : nil;
-    BOOL animated = [image conformsToProtocol: @protocol(SDAnimatedImage)] && [(id<SDAnimatedImage>)image animatedImageFrameCount] > 1;
+    // resizeMode repeat tiles an animated image's first frame (tiledImage:).
+    BOOL repeats = image && _resizeMode == RCTResizeModeRepeat;
+    BOOL animated = !repeats && [image conformsToProtocol: @protocol(SDAnimatedImage)] && [(id<SDAnimatedImage>)image animatedImageFrameCount] > 1;
     self.tintColor = tint;
     if ([self tintsFrames]) {
         [self setValue: tint && animated ? [SDImageTintTransformer transformerWithColor: tint] : nil forKey: @"animationTransformer"];
@@ -356,17 +368,54 @@ static UIImage* FFFBlurredImage(UIImage* image, CGFloat scale, CGFloat radius, B
         if (changed) {
             [self.player seekToFrameAtIndex: 0 loopCount: 0];
         }
-    } else if (tint) {
-        if (animated) {
-            image = [UIImage imageWithCGImage: image.CGImage scale: image.scale orientation: image.imageOrientation];
-        }
-        super.image = [image imageWithRenderingMode: UIImageRenderingModeAlwaysTemplate];
     } else {
+        if (tint) {
+            if (animated) {
+                image = [UIImage imageWithCGImage: image.CGImage scale: image.scale orientation: image.imageOrientation];
+            }
+            image = [image imageWithRenderingMode: UIImageRenderingModeAlwaysTemplate];
+        }
+        if (repeats) {
+            image = [self tiledImage: image];
+            self.tiledForSize = self.bounds.size;
+        }
         super.image = image;
     }
     [self updateContentMode];
 }
 
+// resizeMode repeat: the image repeated from the top-left at its own size in
+// pixels (a scaled image, e.g. a bundled @3x one, at its size in points), an
+// animated image's first frame, scaled down to fit the view if it's larger,
+// as React Native's Image does (and Android here).
+- (UIImage*) tiledImage: (UIImage*)image {
+    CGImageRef cgImage = image.CGImage;
+    if (!cgImage) {
+        return image;
+    }
+    CGFloat scale = image.scale > 1 ? image.scale : (self.window.screen.scale ?: [UIScreen mainScreen].scale);
+    CGSize size = CGSizeMake(image.size.width * image.scale / scale, image.size.height * image.scale / scale);
+    CGSize view = self.bounds.size;
+    if (view.width > 0 && view.height > 0 && (size.width > view.width || size.height > view.height)) {
+        scale *= MAX(size.width / view.width, size.height / view.height);
+    }
+    UIImage* still = [[UIImage imageWithCGImage: cgImage scale: scale orientation: image.imageOrientation]
+                      imageWithRenderingMode: image.renderingMode];
+    return [still resizableImageWithCapInsets: UIEdgeInsetsZero resizingMode: UIImageResizingModeTile];
+}
+
+// The view's size changed since the image was tiled, which scales an image
+// larger than the view down to fit it: tile it again.
+- (void) tileAgainIfResized {
+    if (_resizeMode != RCTResizeModeRepeat || CGSizeEqualToSize(self.bounds.size, self.tiledForSize)) {
+        return;
+    }
+    UIImage* image = [self blurs: self.originalImage] ? self.blurredImage : self.originalImage;
+    if (image) {
+        [self showImage: image];
+    }
+}
+
 - (void) setBlurRadius: (CGFloat)blurRadius {
     if (_blurRadius == blurRadius) {
         return;
@@ -570,7 +619,9 @@ NSString *FFFErrorMessage(NSError *error)
 
 - (void) sendOnLoad: (UIImage*)image {
     // The full image's size, also when it was decoded smaller.
-    CGSize size = [FFFDownsampledImage sourceSizeOfImage: image];
+    // A photo library image's own size (it's decoded at about the view's
+    // size), looked up when it loaded.
+    CGSize size = [_source isPhotoLibrary] ? [_source photoPixelSize] : [FFFDownsampledImage sourceSizeOfImage: image];
     if (CGSizeEqualToSize(size, CGSizeZero)) {
         size = image.size;
     }
@@ -646,11 +697,15 @@ NSString *FFFErrorMessage(NSError *error)
     }
 }
 
-// Whether images are decoded at about the view's size (downsample).
-// Not for `repeat`, which tiles the image at its own size, or SDWebImage
-// before 5.19.
+// Whether images are decoded at about the view's size (downsample, from
+// SDWebImage 5.19, and always for photo library images, which are large and
+// usually shown small: Photos makes them at the size asked for, on any
+// version). Not for `repeat`, which tiles the image at its own size.
 - (BOOL) downsamples {
-    return _downsample && _resizeMode != RCTResizeModeRepeat && [FFFDownsampledImage isSupported];
+    if (_resizeMode == RCTResizeModeRepeat) {
+        return NO;
+    }
+    return [_source isPhotoLibrary] || (_downsample && [FFFDownsampledImage isSupported]);
 }
 
 // Whether the view has been laid out with an area. One that's 0 wide or tall
@@ -823,6 +878,13 @@ NSString *FFFErrorMessage(NSError *error)
     }
     NSString* key = _source.cacheKeyFilter ? _source.cacheKey : _source.url.absoluteString;
     [FFFDownsampledImage addToContext: context forKey: key box: box cover: self.decodedCover];
+    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
+        // photo's original, and a larger view would get it from there.
+        context[SDWebImageContextOriginalStoreCacheType] = @(SDImageCacheTypeNone);
+        context[SDWebImageContextOriginalQueryCacheType] = @(SDImageCacheTypeNone);
+    }
     if (!_source.memoryCache) {
         // The smaller copy is only kept in memory, so it isn't kept (the
         // downloaded file is still on disk).

package/package.json

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