react-native-fast-image 8.7.0 → 8.8.1

package/README.md

@@ -112,6 +112,8 @@ If you use Proguard you will need to add these lines to `android/app/proguard-ru
 
 Source for the remote image to load.
 
+When `source` changes, the image that's showing stays until the new one has loaded, as with `<img>` in browsers and React Native's `Image` on iOS. In views that get reused for other content, such as rows in FlashList or recyclerlistview, set `recyclingKey` so a reused row doesn't show the previous row's image.
+
 ---
 
 ### `source.uri?: string`
@@ -147,10 +149,21 @@ Indicates the load order priority of an image. Images with `FastImage.priority.h
 ### `defaultSource?: number`
 
 - An asset loaded with `require(...)`.
+- Shown while the first image loads, and if an image fails to load. When `source` changes, the previous image shows while the new one loads instead (see `source` and `recyclingKey`).
 - Note that like the built-in `Image` implementation, on Android `defaultSource` does not work in debug mode. This is due to the fact that assets are sent from the dev server, but RN's functions only know how to load it from `res`.
 
 ---
 
+### `recyclingKey?: string`
+
+For views that get reused for other content, such as rows in FlashList or recyclerlistview. Set it to something that identifies the content, e.g. the item's id. When it changes, the image is cleared right away (to `defaultSource`, or blank) instead of staying until the new one has loaded. Unlike changing `key`, this keeps the view, which is what list recycling is for.
+
+```jsx
+<FastImage recyclingKey={item.id} source={{ uri: item.imageUrl }} />
+```
+
+---
+
 ### `resizeMode?: enum`
 
 - `FastImage.resizeMode.contain` - 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 less than the corresponding dimension of the view (minus padding).
@@ -230,11 +243,17 @@ FastImage.preload([
 ])
 ```
 
-It resolves when all the images have loaded or failed, with a result for each source, in order: `{ uri, ok, width, height, error }`. `width` and `height` are the image's size (as in `onLoad`), which is also a way to find an image's size without showing it. A few sources load at a time (3, or `SDWebImagePrefetcher`'s `maxConcurrentPrefetchCount` on iOS), so a long list doesn't hold up the images the app is showing, and at low priority unless the source sets `priority`. It never rejects:
+It resolves when all the images have loaded or failed, with a result for each source, in order: `{ uri, ok: true, width, height }` if it loaded, or `{ uri, ok: false, error }` if it didn't (checking `ok` narrows the type in TypeScript). `width` and `height` are the image's size (as in `onLoad`), which is also a way to find an image's size without showing it. A few sources load at a time (3, or `SDWebImagePrefetcher`'s `maxConcurrentPrefetchCount` on iOS), so a long list doesn't hold up the images the app is showing, and at low priority unless the source sets `priority`. It never rejects:
 
 ```js
 const results = await FastImage.preload(sources)
-const failed = results.filter((result) => !result.ok)
+for (const result of results) {
+    if (result.ok) {
+        console.log(result.uri, result.width, result.height)
+    } else {
+        console.warn(result.uri, result.error)
+    }
+}
 ```
 
 ### `FastImage.clearMemoryCache: () => Promise<void>`

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

@@ -19,19 +19,28 @@ public class FastImageRequestListener implements RequestListener<Drawable> {
     static final String REACT_ON_LOAD_END_EVENT = "onFastImageLoadEnd";
     private final String key;
     private final FastImageSource source;
+    // Whether the request shows the previous image as a thumbnail meanwhile.
+    private final boolean thumbnail;
+    // False when loading the image that's showing again at a new size: the
+    // view shows it at its old size if that fails.
+    private final boolean events;
 
-    FastImageRequestListener(String key, FastImageSource source) {
+    FastImageRequestListener(String key, FastImageSource source, boolean thumbnail, boolean events) {
         this.key = key;
         this.source = source;
+        this.thumbnail = thumbnail;
+        this.events = events;
     }
 
     @Override
     public boolean onLoadFailed(@androidx.annotation.Nullable GlideException e, Object model, Target<Drawable> target, boolean isFirstResource) {
+        if (!events) return false;
         FastImageOkHttpProgressGlideModule.forget(key);
         if (!(target instanceof ImageViewTarget)) {
             return false;
         }
         FastImageViewWithUrl view = (FastImageViewWithUrl) ((ImageViewTarget) target).getView();
+        view.onImageFailed(thumbnail);
         FastImageEvents.send(view, REACT_ON_ERROR_EVENT);
         FastImageEvents.send(view, REACT_ON_LOAD_END_EVENT);
         return false;
@@ -43,11 +52,13 @@ public class FastImageRequestListener implements RequestListener<Drawable> {
             return false;
         }
         final FastImageViewWithUrl view = (FastImageViewWithUrl) ((ImageViewTarget) target).getView();
+        view.onImageLoaded();
         if (resource instanceof GifDrawable) {
             // Play the GIF as many times as the file says, as iOS does. Glide
             // loops every GIF forever by default (#651).
             ((GifDrawable) resource).setLoopCount(GifDrawable.LOOP_INTRINSIC);
         }
+        if (!events) return false;
         boolean local = !(model instanceof GlideUrl);
         int[] size = FastImageSourceSize.get(resource, model, local,
                 dataSource == DataSource.RESOURCE_DISK_CACHE);

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

@@ -84,6 +84,11 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
         }
     }
 
+    @ReactProp(name = "recyclingKey")
+    public void setRecyclingKey(FastImageViewWithUrl view, @Nullable String recyclingKey) {
+        view.setRecyclingKey(recyclingKey);
+    }
+
     @ReactProp(name = "resizeMode")
     public void setResizeMode(FastImageViewWithUrl view, String resizeMode) {
         final FastImageViewWithUrl.ScaleType scaleType = FastImageViewConverter.getScaleType(resizeMode);

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

@@ -15,6 +15,8 @@ import com.bumptech.glide.RequestBuilder;
 import com.bumptech.glide.RequestManager;
 import com.bumptech.glide.load.model.GlideUrl;
 import com.bumptech.glide.request.Request;
+import com.bumptech.glide.request.target.DrawableImageViewTarget;
+import com.bumptech.glide.request.target.SizeReadyCallback;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
@@ -67,6 +69,143 @@ class FastImageViewWithUrl extends AppCompatImageView {
         mNeedsReload = true;
     }
 
+    // The request for the image the view shows once it has loaded, and the one
+    // loading. A new source starts with the shown one as a thumbnail, from the
+    // cache only, so the image stays until the new one has loaded instead of
+    // flashing blank (#747). This is Glide's safe way to do that: the previous
+    // bitmap can't be kept in the view itself, since Glide reuses it once its
+    // request is cleared.
+    @Nullable
+    private RequestBuilder<Drawable> mShownRequest;
+    @Nullable
+    private RequestBuilder<Drawable> mLoadingRequest;
+    // Counts loads, to tell whether a posted update is for the current one.
+    private int mLoadCount = 0;
+    // The size Glide loaded the shown image at, and is loading the loading
+    // one at (0 until it has one).
+    private int mShownWidth = 0;
+    private int mShownHeight = 0;
+    private int mLoadingWidth = 0;
+    private int mLoadingHeight = 0;
+    private boolean mResizeReloadPosted = false;
+
+    @Nullable
+    private String mRecyclingKey;
+
+    // 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).
+    void setRecyclingKey(@Nullable String recyclingKey) {
+        if (recyclingKey == null ? mRecyclingKey == null : recyclingKey.equals(mRecyclingKey)) return;
+        boolean changed = mRecyclingKey != null;
+        mRecyclingKey = recyclingKey;
+        if (changed) {
+            // No thumbnail of the current image, so Glide clears the view to
+            // defaultSource (or nothing) while the next one loads. Reload even
+            // if the source is the same.
+            mShownRequest = null;
+            mNeedsReload = true;
+        }
+    }
+
+    // The loading image loaded (FastImageRequestListener).
+    void onImageLoaded() {
+        mShownRequest = mLoadingRequest;
+        mShownWidth = mLoadingWidth;
+        mShownHeight = mLoadingHeight;
+        reloadIfResized();
+    }
+
+    // Glide crops or scales the image to the view's size when it loads, so if
+    // the view's size changes after that, load it again at the new size.
+    // Otherwise a view that gets taller shows a zoomed-in slice of it (#983).
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        reloadIfResized();
+    }
+
+    private void reloadIfResized() {
+        if (mResizeReloadPosted || !isResized()) return;
+        mResizeReloadPosted = true;
+        // After layout (once per frame), and not from within Glide's callback.
+        post(new Runnable() {
+            @Override
+            public void run() {
+                mResizeReloadPosted = false;
+                if (isResized()) reloadForSize();
+            }
+        });
+    }
+
+    // Whether the image loaded, at a size the view doesn't have now.
+    private boolean isResized() {
+        int width = getWidth() - getPaddingLeft() - getPaddingRight();
+        int height = getHeight() - getPaddingTop() - getPaddingBottom();
+        return requestManager != null && !mNeedsReload
+                && mShownRequest != null && mShownRequest == mLoadingRequest
+                && mShownWidth > 0 && mShownHeight > 0 && width > 0 && height > 0
+                && (width != mShownWidth || height != mShownHeight);
+    }
+
+    // The same image at the view's new size. Meanwhile, and if that fails, the
+    // view shows the image at its old size, from the cache. It's the image
+    // that's already showing, so this sends no events.
+    @SuppressLint("CheckResult")
+    private void reloadForSize() {
+        RequestBuilder<Drawable> shown = mShownRequest;
+        RequestBuilder<Drawable> current = fromCache(shown);
+        mLoadCount++;
+        clearView(requestManager);
+        into(shown, shown.clone()
+                .thumbnail(current)
+                .error(current.clone())
+                .listener(new FastImageRequestListener(null, null, true, false)));
+    }
+
+    // The shown image, from the cache only (never loaded again), at the size
+    // it was loaded at: the key it's in Glide's memory cache under.
+    @SuppressLint("CheckResult")
+    private RequestBuilder<Drawable> fromCache(RequestBuilder<Drawable> shown) {
+        RequestBuilder<Drawable> request = shown.clone().onlyRetrieveFromCache(true);
+        if (mShownWidth > 0 && mShownHeight > 0) request = request.override(mShownWidth, mShownHeight);
+        return request;
+    }
+
+    // Starts loading the request (built by builder), recording the size Glide
+    // loads it at. The size callback is added first, so it has the size by
+    // the time the image loads, even from the memory cache.
+    private void into(RequestBuilder<Drawable> request, RequestBuilder<Drawable> builder) {
+        final int load = mLoadCount;
+        mLoadingRequest = request;
+        mLoadingWidth = 0;
+        mLoadingHeight = 0;
+        DrawableImageViewTarget target = new DrawableImageViewTarget(this);
+        target.getSize(new SizeReadyCallback() {
+            @Override
+            public void onSizeReady(int width, int height) {
+                if (load != mLoadCount) return;
+                mLoadingWidth = width;
+                mLoadingHeight = height;
+            }
+        });
+        builder.into(target);
+    }
+
+    // The loading image failed (FastImageRequestListener). Glide shows
+    // defaultSource then, but not over a thumbnail: show it here, as iOS does.
+    void onImageFailed(boolean hadThumbnail) {
+        mShownRequest = null;
+        if (!hadThumbnail) return;
+        final int load = mLoadCount;
+        // Not from within Glide's callback.
+        post(new Runnable() {
+            @Override
+            public void run() {
+                if (load == mLoadCount) setImageDrawable(mDefaultSource);
+            }
+        });
+    }
+
     @SuppressLint("CheckResult")
     public void onAfterUpdate(
             @Nonnull FastImageViewManager manager,
@@ -77,6 +216,10 @@ class FastImageViewWithUrl extends AppCompatImageView {
         // Only reload for changes that affect the request (source,
         // defaultSource, resizeMode), not for every prop update.
         mNeedsReload = false;
+        mLoadCount++;
+        RequestBuilder<Drawable> shownRequest = mShownRequest;
+        mShownRequest = null;
+        mLoadingRequest = null;
 
         // Nothing to show.
         if (mSource == null && mDefaultSource == null) {
@@ -162,11 +305,17 @@ class FastImageViewWithUrl extends AppCompatImageView {
                             // What into() would apply for the scale type, with
                             // the size capture.
                             .apply(FastImageSourceSize.scaleTypeOptions(getScaleType(), capture));
+            RequestBuilder<Drawable> request = builder.clone();
+
+            boolean thumbnail = shownRequest != null && model != null;
+            if (thumbnail) {
+                builder = builder.thumbnail(fromCache(shownRequest));
+            }
 
             if (key != null)
-                builder.listener(new FastImageRequestListener(key, imageSource));
+                builder.listener(new FastImageRequestListener(key, imageSource, thumbnail, true));
 
-            builder.into(this);
+            into(request, builder);
         }
     }
 

package/dist/index.cjs.js

@@ -125,18 +125,29 @@ const FastImageComponent = (0, react.forwardRef)((props, ref) => /* @__PURE__ */
 	...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) => Promise.resolve(react_native.NativeModules.FastImageView.preload(sources.map((s) => s || {}))).then((results) => sources.map((source, i) => {
 	var _results$i;
-	return {
-		uri: source ? source.uri : void 0,
-		...(_results$i = results === null || results === void 0 ? void 0 : results[i]) !== null && _results$i !== void 0 ? _results$i : {
-			ok: false,
-			error: "No result"
-		}
+	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 = () => react_native.NativeModules.FastImageView.clearMemoryCache();

package/dist/index.cjs.js.flow

@@ -43,14 +43,21 @@ export type ResizeModes = $Values<ResizeMode>
 export type Priorities = $Values<Priority>
 export type CacheControls = $Values<CacheControl>
 
-export type PreloadResult = {|
+export type PreloadSuccess = {|
+    uri: string,
+    ok: true,
+    width: number,
+    height: number,
+|}
+
+export type PreloadFailure = {|
     uri?: string,
-    ok: boolean,
-    width?: number,
-    height?: number,
-    error?: string,
+    ok: false,
+    error: string,
 |}
 
+export type PreloadResult = PreloadSuccess | PreloadFailure
+
 export type PreloadFn = (
     sources: Array<FastImageSource>,
 ) => Promise<Array<PreloadResult>>
@@ -75,6 +82,7 @@ export type FastImageProps = $ReadOnly<{|
     tintColor?: number | string,
     resizeMode?: ?ResizeModes,
     fallback?: ?boolean,
+    recyclingKey?: ?string,
     testID?: ?string,
 |}>
 

package/dist/index.d.ts

@@ -60,6 +60,15 @@ export interface FastImageProps extends AccessibilityProps, ViewProps {
     defaultSource?: ImageRequireSource;
     resizeMode?: ResizeMode;
     fallback?: boolean;
+    /**
+     * When `source` changes, the image showing stays until the new one has
+     * loaded. For views that get reused for other content, such as rows in
+     * FlashList or recyclerlistview, set this to something that identifies the
+     * content (e.g. the item's id): when it changes, the image is cleared
+     * right away instead, so a reused row doesn't show the previous row's
+     * image. Unlike changing `key`, the view is kept.
+     */
+    recyclingKey?: string | null;
     onLoadStart?(): void;
     onProgress?(event: OnProgressEvent): void;
     onLoad?(event: OnLoadEvent): void;
@@ -93,13 +102,18 @@ export interface FastImageProps extends AccessibilityProps, ViewProps {
      */
     children?: React.ReactNode;
 }
-export interface PreloadResult {
+export interface PreloadSuccess {
+    uri: string;
+    ok: true;
+    width: number;
+    height: number;
+}
+export interface PreloadFailure {
     uri?: string;
-    ok: boolean;
-    width?: number;
-    height?: number;
-    error?: string;
+    ok: false;
+    error: string;
 }
+export type PreloadResult = PreloadSuccess | PreloadFailure;
 export interface FastImageStaticProperties {
     resizeMode: typeof resizeMode;
     priority: typeof priority;

package/dist/index.js

@@ -102,18 +102,29 @@ const FastImageComponent = forwardRef((props, ref) => /* @__PURE__ */ React.crea
 	...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) => Promise.resolve(NativeModules.FastImageView.preload(sources.map((s) => s || {}))).then((results) => sources.map((source, i) => {
 	var _results$i;
-	return {
-		uri: source ? source.uri : void 0,
-		...(_results$i = results === null || results === void 0 ? void 0 : results[i]) !== null && _results$i !== void 0 ? _results$i : {
-			ok: false,
-			error: "No result"
-		}
+	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();

package/dist/index.js.flow

@@ -43,14 +43,21 @@ export type ResizeModes = $Values<ResizeMode>
 export type Priorities = $Values<Priority>
 export type CacheControls = $Values<CacheControl>
 
-export type PreloadResult = {|
+export type PreloadSuccess = {|
+    uri: string,
+    ok: true,
+    width: number,
+    height: number,
+|}
+
+export type PreloadFailure = {|
     uri?: string,
-    ok: boolean,
-    width?: number,
-    height?: number,
-    error?: string,
+    ok: false,
+    error: string,
 |}
 
+export type PreloadResult = PreloadSuccess | PreloadFailure
+
 export type PreloadFn = (
     sources: Array<FastImageSource>,
 ) => Promise<Array<PreloadResult>>
@@ -75,6 +82,7 @@ export type FastImageProps = $ReadOnly<{|
     tintColor?: number | string,
     resizeMode?: ?ResizeModes,
     fallback?: ?boolean,
+    recyclingKey?: ?string,
     testID?: ?string,
 |}>
 

package/ios/FastImage/FFFastImageView.h

@@ -19,6 +19,9 @@
 @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;
 
 @end
 

package/ios/FastImage/FFFastImageView.m

@@ -20,6 +20,9 @@
 @property(nonatomic, assign) BOOL retriedAfterBackground;
 // Waits for the app to be active again, to restart a load.
 @property(nonatomic, strong) id activeObserver;
+// Whether the view shows an image that loaded (not defaultSource or nothing).
+// A new source then keeps it until the new image has loaded (see reloadImage).
+@property(nonatomic, assign) BOOL showsLoadedImage;
 
 @end
 
@@ -186,6 +189,21 @@ static CFTimeInterval FFFEnteredBackgroundAt = 0;
     }
 }
 
+- (void) setRecyclingKey: (NSString*)recyclingKey {
+    if (_recyclingKey == recyclingKey || [_recyclingKey isEqualToString: recyclingKey]) {
+        return;
+    }
+    BOOL changed = _recyclingKey != nil;
+    _recyclingKey = [recyclingKey copy];
+    if (changed) {
+        // The view shows other content now: don't keep the current image
+        // while the next one loads (reloadImage clears it), even if the
+        // source is the same.
+        self.showsLoadedImage = NO;
+        _needsReload = YES;
+    }
+}
+
 - (void) setDefaultSource: (UIImage*)defaultSource {
     if (_defaultSource != defaultSource) {
         _defaultSource = defaultSource;
@@ -217,6 +235,7 @@ static CFTimeInterval FFFEnteredBackgroundAt = 0;
             if (!image) {
                 // Not decodable: fail like a remote image, showing defaultSource.
                 [self setImage: _defaultSource];
+                self.showsLoadedImage = NO;
                 self.hasErrored = YES;
                 if (self.onFastImageError) {
                     self.onFastImageError(@{});
@@ -234,6 +253,7 @@ static CFTimeInterval FFFEnteredBackgroundAt = 0;
                 });
             }
             self.hasCompleted = YES;
+            self.showsLoadedImage = YES;
             [self sendOnLoad: image];
 
             if (self.onFastImageLoadEnd) {
@@ -270,6 +290,14 @@ static CFTimeInterval FFFEnteredBackgroundAt = 0;
                 break;
         }
 
+        // Keep showing the loaded image until the new one has loaded, instead
+        // of clearing it to defaultSource (or nothing) while it loads, which
+        // flashed (#747). defaultSource shows if the new image fails. As React
+        // Native's Image does; a `key` that changes starts from blank instead.
+        if (self.showsLoadedImage) {
+            options |= SDWebImageDelayPlaceholder;
+        }
+
         if (self.onFastImageLoadStart) {
             self.onFastImageLoadStart(@{});
             self.hasSentOnLoadStart = YES;
@@ -284,6 +312,7 @@ static CFTimeInterval FFFEnteredBackgroundAt = 0;
         [self downloadImage: _source options: options context: context];
     } else if (_defaultSource) {
         [self setImage: _defaultSource];
+        self.showsLoadedImage = NO;
     }
 }
 
@@ -338,6 +367,8 @@ static CFTimeInterval FFFEnteredBackgroundAt = 0;
                     return;
                 }
                 if (error) {
+                    // SDWebImage shows the placeholder (defaultSource or nothing).
+                    weakSelf.showsLoadedImage = NO;
                     weakSelf.hasErrored = YES;
                     if (weakSelf.onFastImageError) {
                         weakSelf.onFastImageError(@{});
@@ -347,6 +378,7 @@ static CFTimeInterval FFFEnteredBackgroundAt = 0;
                     }
                 } else {
                     weakSelf.hasCompleted = YES;
+                    weakSelf.showsLoadedImage = YES;
                     [weakSelf sendOnLoad: image];
                     if (weakSelf.onFastImageLoadEnd) {
                         weakSelf.onFastImageLoadEnd(@{});

package/ios/FastImage/FFFastImageViewManager.m

@@ -17,6 +17,7 @@ RCT_EXPORT_MODULE(FastImageView)
 RCT_EXPORT_VIEW_PROPERTY(source, FFFastImageSource)
 RCT_EXPORT_VIEW_PROPERTY(defaultSource, UIImage)
 RCT_EXPORT_VIEW_PROPERTY(resizeMode, RCTResizeMode)
+RCT_EXPORT_VIEW_PROPERTY(recyclingKey, NSString)
 RCT_EXPORT_VIEW_PROPERTY(onFastImageLoadStart, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onFastImageProgress, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onFastImageError, RCTDirectEventBlock)

package/package.json

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