@depup/react-native-fast-image 8.6.3-depup.0 → 8.13.1-depup.0

package/dist/index.js

@@ -1,137 +1,157 @@
-import _extends from '@babel/runtime/helpers/extends';
-import React, { forwardRef, memo } from 'react';
-import { NativeModules, StyleSheet, requireNativeComponent, Image, View, Platform } from 'react-native';
-
+import React, { forwardRef, memo } from "react";
+import { Image, NativeModules, Platform, StyleSheet, View, requireNativeComponent } from "react-native";
+//#region src/index.tsx
 const resizeMode = {
-  contain: 'contain',
-  cover: 'cover',
-  stretch: 'stretch',
-  center: 'center'
+	contain: "contain",
+	cover: "cover",
+	stretch: "stretch",
+	center: "center"
 };
 const priority = {
-  low: 'low',
-  normal: 'normal',
-  high: 'high'
+	low: "low",
+	normal: "normal",
+	high: "high"
 };
 const cacheControl = {
-  // Ignore headers, use uri as cache key, fetch only if not in cache.
-  immutable: 'immutable',
-  // Respect http headers, no aggressive caching.
-  web: 'web',
-  // Only load from cache.
-  cacheOnly: 'cacheOnly'
+	immutable: "immutable",
+	web: "web",
+	cacheOnly: "cacheOnly"
 };
-
-const resolveDefaultSource = defaultSource => {
-  if (!defaultSource) {
-    return null;
-  }
-
-  if (Platform.OS === 'android') {
-    // Android receives a URI string, and resolves into a Drawable using RN's methods.
-    const resolved = Image.resolveAssetSource(defaultSource);
-
-    if (resolved) {
-      return resolved.uri;
-    }
-
-    return null;
-  } // iOS or other number mapped assets
-  // In iOS the number is passed, and bridged automatically into a UIImage
-
-
-  return defaultSource;
+const resolveDefaultSource = (defaultSource) => {
+	if (!defaultSource) return null;
+	if (Platform.OS === "android") {
+		const resolved = Image.resolveAssetSource(defaultSource);
+		if (resolved) return resolved.uri;
+		return null;
+	}
+	return defaultSource;
 };
-
-function FastImageBase({
-  source,
-  defaultSource,
-  tintColor,
-  onLoadStart,
-  onProgress,
-  onLoad,
-  onError,
-  onLoadEnd,
-  style,
-  fallback,
-  children,
-  // eslint-disable-next-line no-shadow
-  resizeMode = 'cover',
-  forwardedRef,
-  ...props
-}) {
-  if (fallback) {
-    const cleanedSource = { ...source
-    };
-    delete cleanedSource.cache;
-    const resolvedSource = Image.resolveAssetSource(cleanedSource);
-    return /*#__PURE__*/React.createElement(View, {
-      style: [styles.imageContainer, style],
-      ref: forwardedRef
-    }, /*#__PURE__*/React.createElement(Image, _extends({}, props, {
-      style: [StyleSheet.absoluteFill, {
-        tintColor
-      }],
-      source: resolvedSource,
-      defaultSource: defaultSource,
-      onLoadStart: onLoadStart,
-      onProgress: onProgress,
-      onLoad: onLoad,
-      onError: onError,
-      onLoadEnd: onLoadEnd,
-      resizeMode: resizeMode
-    })), children);
-  }
-
-  const resolvedSource = Image.resolveAssetSource(source);
-  const resolvedDefaultSource = resolveDefaultSource(defaultSource);
-  return /*#__PURE__*/React.createElement(View, {
-    style: [styles.imageContainer, style],
-    ref: forwardedRef
-  }, /*#__PURE__*/React.createElement(FastImageView, _extends({}, props, {
-    tintColor: tintColor,
-    style: StyleSheet.absoluteFill,
-    source: resolvedSource,
-    defaultSource: resolvedDefaultSource,
-    onFastImageLoadStart: onLoadStart,
-    onFastImageProgress: onProgress,
-    onFastImageLoad: onLoad,
-    onFastImageError: onError,
-    onFastImageLoadEnd: onLoadEnd,
-    resizeMode: resizeMode
-  })), children);
+function tintColorFromStyle(style) {
+	if (Array.isArray(style)) {
+		for (let i = style.length - 1; i >= 0; i--) {
+			const found = tintColorFromStyle(style[i]);
+			if (found !== void 0) return found;
+		}
+		return;
+	}
+	if (typeof style === "number") {
+		const flattened = StyleSheet.flatten(style);
+		return flattened ? flattened.tintColor : void 0;
+	}
+	return style && typeof style === "object" ? style.tintColor : void 0;
 }
-
-const FastImageMemo = /*#__PURE__*/memo(FastImageBase);
-const FastImageComponent = /*#__PURE__*/forwardRef((props, ref) => /*#__PURE__*/React.createElement(FastImageMemo, _extends({
-  forwardedRef: ref
-}, props)));
-FastImageComponent.displayName = 'FastImage';
+function loopCount(loop) {
+	if (loop === void 0) return -1;
+	if (loop === true) return 0;
+	if (loop === false) return 1;
+	return Number.isFinite(loop) ? Math.max(1, Math.floor(loop)) : 0;
+}
+function withoutCache(source) {
+	const { cache: _cache, ...rest } = source || {};
+	return rest;
+}
+function FastImageBase({ source, defaultSource, tintColor, onLoadStart, onProgress, onLoad, onError, onLoadEnd, style, fallback, children, resizeMode = "cover", loop, forwardedRef, onLayout, pointerEvents, ...viewProps }) {
+	const { onClick, ...props } = viewProps;
+	const wrapperProps = {
+		onLayout,
+		onClick,
+		pointerEvents
+	};
+	const imageProps = {
+		...props,
+		pointerEvents: pointerEvents === "box-none" ? "none" : void 0
+	};
+	const resolvedTintColor = tintColor != null ? tintColor : tintColorFromStyle(style);
+	if (fallback) {
+		const cleanedSource = typeof source === "number" ? source : withoutCache(source);
+		const resolvedSource = Image.resolveAssetSource(cleanedSource);
+		return /* @__PURE__ */ React.createElement(View, {
+			style: [styles.imageContainer, style],
+			...wrapperProps,
+			ref: forwardedRef
+		}, /* @__PURE__ */ React.createElement(Image, {
+			...imageProps,
+			style: [styles.fallbackImage, { tintColor: resolvedTintColor }],
+			source: resolvedSource,
+			defaultSource,
+			onLoadStart,
+			onProgress,
+			onLoad,
+			onError,
+			onLoadEnd,
+			resizeMode
+		}), children);
+	}
+	const resolvedSource = Image.resolveAssetSource(source);
+	const resolvedDefaultSource = resolveDefaultSource(defaultSource);
+	return /* @__PURE__ */ React.createElement(View, {
+		style: [styles.imageContainer, style],
+		...wrapperProps,
+		ref: forwardedRef
+	}, /* @__PURE__ */ React.createElement(FastImageView, {
+		...imageProps,
+		tintColor: resolvedTintColor,
+		loopCount: loopCount(loop),
+		style: StyleSheet.absoluteFill,
+		source: resolvedSource,
+		defaultSource: resolvedDefaultSource,
+		onFastImageLoadStart: onLoadStart,
+		onFastImageProgress: onProgress,
+		onFastImageLoad: onLoad,
+		onFastImageError: onError,
+		onFastImageLoadEnd: onLoadEnd,
+		resizeMode
+	}), children);
+}
+const FastImageMemo = memo(FastImageBase);
+const FastImageComponent = forwardRef((props, ref) => /* @__PURE__ */ React.createElement(FastImageMemo, {
+	forwardedRef: ref,
+	...props
+}));
+FastImageComponent.displayName = "FastImage";
+const noResult = {
+	ok: false,
+	error: "No result"
+};
 const FastImage = FastImageComponent;
 FastImage.resizeMode = resizeMode;
 FastImage.cacheControl = cacheControl;
 FastImage.priority = priority;
-
-FastImage.preload = sources => NativeModules.FastImageView.preload(sources);
-
+FastImage.preload = (sources) => Promise.resolve(NativeModules.FastImageView.preload(sources.map((s) => s || {}))).then((results) => sources.map((source, i) => {
+	var _results$i;
+	const uri = source ? source.uri : void 0;
+	const result = (_results$i = results === null || results === void 0 ? void 0 : results[i]) !== null && _results$i !== void 0 ? _results$i : noResult;
+	if (!result.ok) return {
+		...result,
+		uri
+	};
+	return typeof uri === "string" ? {
+		...result,
+		uri
+	} : {
+		ok: false,
+		error: "Invalid source: no uri",
+		uri
+	};
+}));
 FastImage.clearMemoryCache = () => NativeModules.FastImageView.clearMemoryCache();
-
 FastImage.clearDiskCache = () => NativeModules.FastImageView.clearDiskCache();
-
 const styles = StyleSheet.create({
-  imageContainer: {
-    overflow: 'hidden'
-  }
-}); // Types of requireNativeComponent are not correct.
-
-const FastImageView = requireNativeComponent('FastImageView', FastImage, {
-  nativeOnly: {
-    onFastImageLoadStart: true,
-    onFastImageProgress: true,
-    onFastImageLoad: true,
-    onFastImageError: true,
-    onFastImageLoadEnd: true
-  }
+	fallbackImage: {
+		position: "absolute",
+		top: 0,
+		left: 0,
+		width: "100%",
+		height: "100%"
+	},
+	imageContainer: { overflow: "hidden" }
 });
-
-export default FastImage;
+const FastImageView = requireNativeComponent("FastImageView", FastImage, { nativeOnly: {
+	onFastImageLoadStart: true,
+	onFastImageProgress: true,
+	onFastImageLoad: true,
+	onFastImageError: true,
+	onFastImageLoadEnd: true
+} });
+//#endregion
+export { FastImage as default };

package/dist/index.js.flow

@@ -7,9 +7,18 @@ export type OnLoadEvent = SyntheticEvent<
     $ReadOnly<{
         width: number,
         height: number,
+        // The view's React tag. Missing on Android with the legacy architecture.
+        // TODO: make it required once the New Architecture is the minimum.
+        target?: number,
     }>,
 >
 
+export type OnErrorEvent = SyntheticEvent<
+    $ReadOnly<{|
+        error: string,
+    |}>,
+>
+
 export type OnProgressEvent = SyntheticEvent<
     $ReadOnly<{|
         loaded: number,
@@ -40,7 +49,24 @@ export type ResizeModes = $Values<ResizeMode>
 export type Priorities = $Values<Priority>
 export type CacheControls = $Values<CacheControl>
 
-export type PreloadFn = (sources: Array<FastImageSource>) => void
+export type PreloadSuccess = {|
+    uri: string,
+    ok: true,
+    width: number,
+    height: number,
+|}
+
+export type PreloadFailure = {|
+    uri?: string,
+    ok: false,
+    error: string,
+|}
+
+export type PreloadResult = PreloadSuccess | PreloadFailure
+
+export type PreloadFn = (
+    sources: Array<FastImageSource>,
+) => Promise<Array<PreloadResult>>
 export type FastImageSource = {
     uri?: string,
     headers?: Object,
@@ -50,7 +76,7 @@ export type FastImageSource = {
 
 export type FastImageProps = $ReadOnly<{|
     ...ViewProps,
-    onError?: ?() => void,
+    onError?: ?(event: OnErrorEvent) => void,
     onLoad?: ?(event: OnLoadEvent) => void,
     onLoadEnd?: ?() => void,
     onLoadStart?: ?() => void,
@@ -62,6 +88,11 @@ export type FastImageProps = $ReadOnly<{|
     tintColor?: number | string,
     resizeMode?: ?ResizeModes,
     fallback?: ?boolean,
+    recyclingKey?: ?string,
+    loop?: ?(boolean | number),
+    imageRendering?: ?('auto' | 'smooth' | 'pixelated'),
+    paused?: ?boolean,
+    downsample?: ?boolean,
     testID?: ?string,
 |}>
 

package/ios/FastImage/FFFDownsampledImage.h

@@ -0,0 +1,28 @@
+#import <SDWebImage/SDAnimatedImage.h>
+#import <SDWebImage/SDWebImageDefine.h>
+
+// An image decoded at about the size it's shown at (the `downsample`
+// prop), instead of at full size. The view asks for it with SDWebImage's
+// thumbnail context: the box to fill (the view's size in pixels), and
+// preserveAspectRatio NO when the image has to cover the box (resizeMode
+// cover or stretch) rather than fit in it (contain or center). SDWebImage's
+// own thumbnail decoding can only fit, so this class works out the size from
+// 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.
++ (void) addToContext: (SDWebImageMutableContext*)context forURL: (NSURL*)url box: (CGSize)box cover: (BOOL)cover;
+
+// 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.
++ (CGSize) sourceSizeOfImage: (UIImage*)image;
+
+// Whether this version of SDWebImage can decode through this class: it
+// decodes static images through the animated image class since 5.19.
++ (BOOL) isSupported;
+
+@end

package/ios/FastImage/FFFDownsampledImage.m

@@ -0,0 +1,169 @@
+#import "FFFDownsampledImage.h"
+#import <ImageIO/ImageIO.h>
+#import <SDWebImage/SDImageCoder.h>
+#import <SDWebImage/SDImageCacheDefine.h>
+#import <SDWebImage/SDWebImageCacheKeyFilter.h>
+#import <SDWebImage/UIImage+Metadata.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.
+static CGSize FFFPixelSize(NSData* data) {
+    CGImageSourceRef source = CGImageSourceCreateWithData((__bridge CFDataRef) data, NULL);
+    if (!source) {
+        return CGSizeZero;
+    }
+    NSDictionary* properties = (__bridge_transfer NSDictionary*) CGImageSourceCopyPropertiesAtIndex(source, 0, NULL);
+    CFRelease(source);
+    CGFloat width = [properties[(__bridge NSString*) kCGImagePropertyPixelWidth] doubleValue];
+    CGFloat height = [properties[(__bridge NSString*) kCGImagePropertyPixelHeight] doubleValue];
+    NSUInteger orientation = [properties[(__bridge NSString*) kCGImagePropertyOrientation] unsignedIntegerValue];
+    if (orientation >= kCGImagePropertyOrientationLeftMirrored) {
+        return CGSizeMake(height, width);
+    }
+    return CGSizeMake(width, height);
+}
+
+// Where the decode puts the full image's size, passed in the load's decode
+// options. SDWebImage attaches those options to the image it ends up with
+// (sd_decodeOptions), also when its force decoding replaces the decoded image
+// with another one, which drops anything kept on the image itself.
+@interface FFFSourceSize : NSObject
+@property (atomic, assign) CGSize size;
+@end
+
+@implementation FFFSourceSize
+
+// Any two are equal: it's where the result goes, not part of the request, so
+// the same request from several views is still decoded once (SDWebImage's
+// downloader groups them by their decode options).
+- (BOOL) isEqual: (id)object {
+    return [object isKindOfClass: [FFFSourceSize class]];
+}
+
+- (NSUInteger) hash {
+    return 0;
+}
+
+@end
+
+@implementation FFFDownsampledImage
+
++ (BOOL) isSupported {
+    static BOOL supported = NO;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        // No animated image coder takes JPEG, so before SDWebImage 5.19
+        // SDAnimatedImage returned nil for one, and SDWebImage decoded it with
+        // its thumbnail options as they are (stretched to the box).
+        CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+        CGContextRef context = CGBitmapContextCreate(NULL, 1, 1, 8, 4, colorSpace, kCGImageAlphaNoneSkipLast);
+        CGColorSpaceRelease(colorSpace);
+        CGImageRef pixel = context ? CGBitmapContextCreateImage(context) : NULL;
+        if (context) {
+            CGContextRelease(context);
+        }
+        if (!pixel) {
+            return;
+        }
+        NSMutableData* jpeg = [NSMutableData data];
+        CGImageDestinationRef destination = CGImageDestinationCreateWithData((__bridge CFMutableDataRef) jpeg, CFSTR("public.jpeg"), 1, NULL);
+        if (destination) {
+            CGImageDestinationAddImage(destination, pixel, NULL);
+            CGImageDestinationFinalize(destination);
+            CFRelease(destination);
+        }
+        CGImageRelease(pixel);
+        supported = jpeg.length > 0 && [[SDAnimatedImage alloc] initWithData: jpeg scale: 1 options: nil] != nil;
+    });
+    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.
+    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;
+}
+
++ (void) addToContext: (SDWebImageMutableContext*)context forURL: (NSURL*)url box: (CGSize)box cover: (BOOL)cover {
+    context[SDWebImageContextAnimatedImageClass] = [FFFDownsampledImage class];
+    // Cached under the url itself (see loadURLForURL:), so the disk cache
+    // keeps one download for every size and for loads that aren't downsampled.
+    NSString* key = url.absoluteString;
+    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.
+    context[SDWebImageContextImageThumbnailPixelSize] = [NSValue valueWithCGSize: box];
+    context[SDWebImageContextImagePreserveAspectRatio] = @(!cover);
+    context[SDWebImageContextImageDecodeOptions] = @{FFFDecodeSourceSize: [FFFSourceSize new]};
+    // Only in memory: the disk cache has the downloaded file.
+    context[SDWebImageContextStoreCacheType] = @(SDImageCacheTypeMemory);
+    context[SDWebImageContextQueryCacheType] = @(SDImageCacheTypeMemory);
+}
+
++ (CGSize) sourceSizeOfImage: (UIImage*)image {
+    id sourceSize = image.sd_decodeOptions[FFFDecodeSourceSize];
+    return [sourceSize isKindOfClass: [FFFSourceSize class]] ? ((FFFSourceSize*) sourceSize).size : CGSizeZero;
+}
+
+- (instancetype) initWithData: (NSData*)data scale: (CGFloat)scale options: (SDImageCoderOptions*)options {
+    NSValue* boxValue = options[SDImageCoderDecodeThumbnailPixelSize];
+    CGSize box = boxValue ? boxValue.CGSizeValue : CGSizeZero;
+    NSNumber* preserveAspectRatio = options[SDImageCoderDecodePreserveAspectRatio];
+    BOOL cover = preserveAspectRatio != nil && !preserveAspectRatio.boolValue;
+    CGSize pixelSize = FFFPixelSize(data);
+
+    // Decode at full size unless the image is at least twice as large as it
+    // needs to be (or its size can't be read). Decoding smaller is done in
+    // software, while newer iPhones decode JPEG and HEIC at full size in
+    // hardware: on an iPhone 15 Pro Max a 12 MP JPEG took about 20 ms at full
+    // size, and 120-130 ms with a peak of 100-125 MB decoded to 60-90% of its
+    // size (1-6 MB and 27-40 ms for a thumbnail).
+    NSMutableDictionary* decodeOptions = options ? [options mutableCopy] : [NSMutableDictionary dictionary];
+    [decodeOptions removeObjectForKey: SDImageCoderDecodeThumbnailPixelSize];
+    decodeOptions[SDImageCoderDecodePreserveAspectRatio] = @YES;
+    if (box.width > 0 && box.height > 0 && pixelSize.width > 0 && pixelSize.height > 0) {
+        CGFloat widthRatio = box.width / pixelSize.width;
+        CGFloat heightRatio = box.height / pixelSize.height;
+        CGFloat ratio = cover ? MAX(widthRatio, heightRatio) : MIN(widthRatio, heightRatio);
+        if (ratio <= 0.5) {
+            // ImageIO takes the longest side (kCGImageSourceThumbnailMaxPixelSize).
+            // SDWebImage works it out from the box with the image's stored
+            // width and height, before EXIF orientation, so a square box is
+            // the one that gives this side for any orientation.
+            CGFloat longest = ceil(MAX(pixelSize.width, pixelSize.height) * ratio);
+            decodeOptions[SDImageCoderDecodeThumbnailPixelSize] = [NSValue valueWithCGSize: CGSizeMake(longest, longest)];
+        }
+    }
+
+    self = [super initWithData: data scale: scale options: decodeOptions];
+    if (self) {
+        CGFloat imageScale = MAX(scale, 1);
+        FFFSourceSize* sourceSize = options[FFFDecodeSourceSize];
+        if ([sourceSize isKindOfClass: [FFFSourceSize class]]) {
+            sourceSize.size = pixelSize.width > 0 && pixelSize.height > 0
+                ? CGSizeMake(pixelSize.width / imageScale, pixelSize.height / imageScale)
+                : self.size;
+        }
+    }
+    return self;
+}
+
+@end

package/ios/FastImage/FFFastImageSource.h

@@ -1,5 +1,6 @@
 #import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
+#import <SDWebImage/SDWebImageDownloaderRequestModifier.h>
 
 typedef NS_ENUM(NSInteger, FFFPriority) {
     FFFPriorityLow,
@@ -20,6 +21,8 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 @property (nonatomic) NSURL* url;
 // priority for image request
 @property (nonatomic) FFFPriority priority;
+// whether the source set a priority (preload is low priority otherwise)
+@property (nonatomic) BOOL hasPriority;
 // headers for the image request
 @property (nonatomic) NSDictionary *headers;
 // cache control mode
@@ -30,4 +33,7 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
                     headers:(NSDictionary *)headers
                cacheControl:(FFFCacheControl)cacheControl;
 
+// Adds this source's headers to its image requests.
+- (SDWebImageDownloaderRequestModifier *)requestModifier;
+
 @end

package/ios/FastImage/FFFastImageSource.m

@@ -17,4 +17,17 @@
     return self;
 }
 
+- (SDWebImageDownloaderRequestModifier *)requestModifier
+{
+    NSDictionary* headers = _headers;
+    return [SDWebImageDownloaderRequestModifier requestModifierWithBlock: ^NSURLRequest* _Nullable (NSURLRequest* _Nonnull request) {
+        NSMutableURLRequest* mutableRequest = [request mutableCopy];
+        for (NSString* header in headers) {
+            NSString* value = headers[header];
+            [mutableRequest setValue: value forHTTPHeaderField: header];
+        }
+        return [mutableRequest copy];
+    }];
+}
+
 @end

package/ios/FastImage/FFFastImageView.h

@@ -19,6 +19,23 @@
 @property (nonatomic, strong) FFFastImageSource *source;
 @property (nonatomic, strong) UIImage *defaultSource;
 @property (nonatomic, strong) UIColor *imageColor;
+// When it changes, the next image doesn't replace the current one: the view
+// clears first (for views reused for other content, like list rows).
+@property (nonatomic, copy) NSString *recyclingKey;
+// How many times animated images play: -1 for the file's own loop count (the
+// `loop` prop not set), 0 for forever, or a number of times.
+@property (nonatomic, assign) NSInteger loopCount;
+// How the image is filtered when drawn at another size: auto, smooth or
+// pixelated.
+@property (nonatomic, copy) NSString *imageRendering;
+// Pauses animated images on the frame they're showing.
+@property (nonatomic, assign) BOOL paused;
+// Decodes images at about the view's size instead of at full size.
+@property (nonatomic, assign) BOOL downsample;
 
 @end
 
+// An error's description, with the HTTP status code when there is one.
+FOUNDATION_EXTERN NSString *FFFErrorMessage(NSError *error);
+
+