react-native-fast-image 9.3.7 → 10.1.0

package/README.md

@@ -18,7 +18,7 @@ React Native's `Image` component handles image caching like browsers for the mos
 
 ## Features
 
-- **Performance**, with images [decoded at the size they're shown](#downsample): in [benchmarks](docs/benchmarks.md), FastImage shows images about as fast as other React Native image components and uses among the least memory for large photos.
+- **Performance**: in [benchmarks](docs/benchmarks.md), FastImage shows images about as fast as other React Native image components on iOS and among the fastest on Android, [significantly faster in some scenarios](docs/benchmarks.md#opening-a-photo-while-others-load), and uses among the least memory for large photos.
 - **Aggressive caching**: an image downloads once, then shows from disk or memory until its url changes, without flickering ([freshness](#sourcecache), [cache keys](#sourcecachekey), [size limits](#configurecachelimits)).
 - **Preloading**, with a [result per image](#preloadsources) and the [cached file's path](#getcachepathsource).
 - **Headers**, e.g. for authentication ([`headers`](#sourceheaders)).
@@ -57,8 +57,6 @@ See [Formats](docs/formats.md) for the versions of iOS and Android each format n
 
 ## Installation
 
-Works with React Native 0.65 and later (iOS 13 and later, Android `minSdkVersion` 21 and later), with the New Architecture (through React Native's interop layer) and the legacy architecture, with Expo, and on tvOS with [React Native tvOS](https://github.com/react-native-tvos/react-native-tvos). It's tested on React Native 0.87 with the New Architecture, 0.73 with the legacy architecture, Expo SDK 57, and React Native tvOS 0.87. A native New Architecture component is planned for a future major version.
-
 ```bash
 npm install react-native-fast-image
 cd ios && pod install
@@ -72,11 +70,13 @@ npx expo install react-native-fast-image
 
 It has native code, so it needs a [development build](https://docs.expo.dev/develop/development-builds/introduction/) (e.g. `npx expo run:ios`), not Expo Go.
 
+Needs React Native 0.83 or later with the New Architecture (Expo SDK 55 or later), iOS/tvOS 15.1 or later, and Android 7.0 (API 24) or later; on tvOS, it works with [React Native tvOS](https://github.com/react-native-tvos/react-native-tvos). Apps on the legacy architecture or older React Native can use FastImage 9 (`npm install react-native-fast-image@9`). Upgrading from FastImage 9: see [Upgrading from 9.x](docs/upgrading.md).
+
 To set the cache's size when the app starts, see [Native config](#native-config).
 
 If your Android app has its own Glide `AppGlideModule`, read [using FastImage with an AppGlideModule](docs/android-build-settings.md#if-your-app-has-its-own-appglidemodule) first, or FastImage may not work.
 
-On iOS, FastImage works with SDWebImage 5.11.1 and later, but apps that run on iOS 26 or later need 5.21.4 or later: earlier versions can crash there while loading images ([SDWebImage#3849](https://github.com/SDWebImage/SDWebImage/issues/3849)). A new install gets the latest version. If your `Podfile.lock` has an older one, update it with `cd ios && pod update SDWebImage`.
+If `pod install` can't find a compatible SDWebImage (FastImage needs 5.21.4 or later), update it with `cd ios && pod update SDWebImage`.
 
 ## Usage
 
@@ -100,7 +100,7 @@ const YourImage = () => (
 
 ### `FastImage`
 
-It also takes React Native's View props, such as accessibility props, `testID`, `nativeID`, `onLayout` and `pointerEvents`.
+It's a single native view, which also takes React Native's View props, such as accessibility props, `testID`, `nativeID`, `onLayout`, `pointerEvents` and `hitSlop`. A ref to it is that view (e.g. for `measure`). It doesn't take children: use [`FastImageBackground`](#fastimagebackground) for content over an image.
 
 <!-- api:props start (generated from src/ by website/scripts/generate.mts) -->
 
@@ -201,6 +201,16 @@ Whether the decoded image is kept in the memory cache. With `false` it's only ke
 
 ---
 
+##### `source.diskCache`
+
+**Type:** `boolean` · **Default:** `true`
+
+Whether the image is kept on disk. With `false` it isn't kept in the disk cache or an HTTP cache, or read from them. Use it for images the app shouldn't keep once they've been shown (e.g. disappearing messages, or where a security policy doesn't allow caching sensitive images), images that change every time they load, or large images shown once, which would push other images out of the disk cache. The image is downloaded again whenever it isn't in memory, e.g. for a view of another size (or on Android, a change of `blurRadius` or `objectFit`), so with `memoryCache: false` too it's downloaded each time it's shown. With `cache: 'web'` it isn't kept in memory either, so it's downloaded every time it loads. With `cache: 'cacheOnly'` it's only looked for in memory. On Android, a large download is held in a temporary file while it loads, as every download is, deleted as soon as it's opened.
+
+`FastImage.preload`, `getCachePath` and `writeToCache` resolve not `ok` for it: there's no file, and a view decodes the image for its own size, so it may download a preloaded one again. A source for the same url (or `cacheKey`) without `diskCache: false` still stores the image.
+
+---
+
 ##### `source.width`
 
 **Type:** `number`
@@ -241,39 +251,32 @@ On Android, `defaultSource` doesn't show in debug builds: there the dev server s
 
 How the image fits the view, as CSS's `object-fit` does.
 
-- `'cover'`: scales it uniformly (keeping its aspect ratio) so it covers the view (minus padding), cropping what doesn't fit.
-- `'contain'`: scales it uniformly (keeping its aspect ratio) so all of it fits in the view (minus padding).
+- `'cover'`: scales it uniformly (keeping its aspect ratio) so it covers the view (inside its borders), cropping what doesn't fit.
+- `'contain'`: scales it uniformly (keeping its aspect ratio) so all of it fits in the view (inside its borders).
 - `'fill'`: scales its width and height separately to fill the view, which can change its aspect ratio.
 - `'none'`: shows it at its own size, centered, cropped if it's larger than the view.
 - `'scale-down'`: shows it at its own size, centered, or scaled down uniformly to fit if it's larger than the view (the smaller of `'none'` and `'contain'`).
 
 An image's own size is its size in pixels, as points (dp on Android), as CSS counts an image's pixels: a 300 × 200 image is 300 × 200 points. A bundled image (`require()`) is its size in points.
 
-It can also be set in `style`; the prop wins. Either one overrides `resizeMode`.
+It can also be set in `style`; the prop wins.
 
 ---
 
-#### `resizeMode`
-
-**Type:** `ResizeMode` · **Default:** `'cover'`
+#### `objectPosition`
 
-**Deprecated:** Use `objectFit` instead.
+**Type:** `ObjectPosition` · **Default:** `'50% 50%'`
 
-How the image fills the view.
+Where the image is in the view, as CSS's `object-position` places it: where its edges are when it doesn't fill the view exactly (`contain`, `cover`, `none` and `scale-down`; with `fill` it always fills it).
 
-- `'contain'`: as `objectFit="contain"`.
-- `'cover'`: as `objectFit="cover"`.
-- `'stretch'`: as `objectFit="fill"`.
-- `'center'`: as `objectFit="scale-down"`, except that on Android an image smaller than the view is shown at its size in pixels on the screen, so smaller than on iOS and the web.
-- `'repeat'`: repeats it 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.
-
----
+- A string in CSS's syntax: one or two keywords (`'top'`, `'left bottom'`), lengths in points (`'10px 20px'`, with `px`) or percentages (`'25% 75%'`), or offsets from an edge (`'right 10px bottom 20%'`). A percentage puts that point of the image at that point of the view: `'0% 0%'` is the top-left corner, `'100% 100%'` the bottom-right.
+- An object with one of `top` and `bottom` and one of `left` and `right`, each in points (a number) or a percentage (`'25%'`), e.g. `{ right: 10, bottom: '20%' }`. A missing axis is centered.
 
-#### `fallback`
+Points are dp on Android. An invalid value is ignored (the image is centered), with a warning in development. `defaultSource` is placed the same way.
 
-**Type:** `boolean`
-
-If true, the image is shown with React Native's `Image` instead, styled and laid out the same way. FastImage's own features, such as its caching options, `priority` and `transition`, don't apply.
+```jsx
+<FastImage source={{ uri }} objectFit="cover" objectPosition="top" />
+```
 
 ---
 
@@ -326,9 +329,11 @@ Pauses an animated image (GIF, animated WebP, APNG, or animated AVIF) on the fra
 
 #### `transition`
 
-**Type:** `number | boolean | Transition | null` · **Default:** `false`
+**Type:** `number | boolean | Transition | null`
+
+Fades the image in when it loads. `true` fades for the default's duration (see `FastImage.setDefaults`), or the platform's usual length if the default doesn't fade; a number is the duration in milliseconds, `false` (or 0) is no fade, or pass a `Transition`.
 
-Fades the image in when it loads. `true` uses the platform's usual fade, a number is the duration in milliseconds, or pass a `Transition`.
+By default, images fade in on Android (300 ms), and not on iOS. `FastImage.setDefaults` changes that for every image; an image's own `transition` wins, and the settings it leaves out come from the default. `null` is the default.
 
 Downloads, local files (`file://`, `content://`) and bundled images (`require()`) fade in. In lists that reuse views (e.g. FlashList), set `recyclingKey`, so a reused view starts empty and its image fades in, instead of showing the previous item's image until it loads.
 
@@ -349,7 +354,7 @@ Decodes a large image at about the size it's shown at, instead of at full size,
 - `true`: an image at least twice the size its view needs is decoded at about the view's size (on Android, any image larger than its view). 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. **It uses more memory:** a 12-megapixel photo takes about 48 MB decoded, however small it's shown. On Android, an image over 16 megapixels (4096 × 4096) is decoded at the largest size under that, which Android can still draw.
 
-It doesn't change `onLoad`'s width and height (the image's own size) or the cached file. On iOS it 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 at about the view's size. Android 16 and later decode animated WebP at full size either way, and scale it as they draw it.
+It doesn't change `onLoad`'s width and height (the image's own size) or the cached file. Photo library images are always decoded at about the view's size. Android 16 and later decode animated WebP at full size either way, and scale it as they draw it.
 
 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.
 
@@ -369,7 +374,7 @@ It's for still images, or a radius that changes now and then (e.g. blurring a ph
 - The image is blurred at about the size it's shown at, off the main thread. The cached file stays the original image, so `getCachePath` and other views of it aren't affected.
 - Changing it blurs the image that's showing again, without sending the load events again.
 
-To animate a blur, or to blur an animated image, use React Native's `filter` style instead, which the GPU draws: `style={{ filter: [{ blur: 6 }] }}`. It needs the New Architecture. React Native's docs list `blur` for Android 12+ only; on iOS it's behind an experimental React Native feature flag (`enableSwiftUIBasedFilters`, SwiftUI-based filters).
+To animate a blur, or to blur an animated image, use React Native's `filter` style instead, which the GPU draws: `style={{ filter: [{ blur: 6 }] }}`. React Native's docs list `blur` for Android 12+ only; on iOS it's behind an experimental React Native feature flag (`enableSwiftUIBasedFilters`, SwiftUI-based filters).
 
 ---
 
@@ -439,7 +444,7 @@ Called when the image finishes loading, whether it was successful or an error, w
 
 **Type:** `StyleProp<ImageStyle>`
 
-The image's style: View's style props (`borderRadius` clips the image), and `tintColor`, as with React Native's `Image` (the `tintColor` prop wins).
+The image's style: View's style props (`borderRadius` clips the image, and borders inset it, but padding doesn't), and `tintColor`, as with React Native's `Image` (the `tintColor` prop wins).
 
 ---
 
@@ -449,24 +454,12 @@ The image's style: View's style props (`borderRadius` clips the image), and `tin
 
 If supplied, changes the color of all the non-transparent pixels to the given color.
 
----
-
-#### `children`
-
-**Type:** `ReactNode`
-
-**Deprecated:** In the next major version, `FastImage` won't render children: use `FastImageBackground`.
-
-Render children within the image.
-
 <!-- api:props end -->
 
 ### `FastImageBackground`
 
 An image with content on top of it: a view that the image fills, with the children on top.
 
-Use it rather than giving `FastImage` children: in the next major version, `FastImage` won't render children, since the image will be a single native view ([#1220](https://github.com/DylanVann/react-native-fast-image/pull/1220)), which can't hold them. `FastImageBackground` works the same in both.
-
 ```jsx
 import { FastImageBackground } from 'react-native-fast-image'
 
@@ -628,11 +621,11 @@ const result = await FastImage.writeToCache(
 
 How much the image cache keeps. Set the limits your app starts with in its native config, so they're in effect from the first image, and change them while the app runs with `configureCache`, e.g. from a storage setting. Runtime changes are saved, and used on the next launches too.
 
-| Limit                                                                                                             | iOS                                                                                        | Android                                                                                              |
-| ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
-| `maxDiskSize`: the most bytes of images kept on disk. When it's over, the least recently used images are removed. | Changes apply at once (the cache is trimmed to half the limit). Default: no limit.         | Changes apply from the next launch (Glide's disk cache size is set when it starts). Default: 250 MB. |
-| `maxDiskAge`: seconds an image is kept on disk after it was last used.                                            | Default: 1 week (counted from when it was stored before SDWebImage 5.21, unless it's set). | No age limit.                                                                                        |
-| `maxMemorySize`: the most bytes of decoded images kept in memory.                                                 | Default: no limit (they're removed when the system is low on memory).                      | About two screenfuls of images.[^glide-memory]                                                       |
+| Limit                                                                                                             | iOS                                                                                | Android                                                                                              |
+| ----------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| `maxDiskSize`: the most bytes of images kept on disk. When it's over, the least recently used images are removed. | Changes apply at once (the cache is trimmed to half the limit). Default: no limit. | Changes apply from the next launch (Glide's disk cache size is set when it starts). Default: 250 MB. |
+| `maxDiskAge`: seconds an image is kept on disk after it was last used.                                            | Default: 1 week.                                                                   | No age limit.                                                                                        |
+| `maxMemorySize`: the most bytes of decoded images kept in memory.                                                 | Default: no limit (they're removed when the system is low on memory).              | About two screenfuls of images.[^glide-memory]                                                       |
 
 `0` means no limit.
 
@@ -649,6 +642,25 @@ On Android, if your app has its own `AppGlideModule` (see [using FastImage with
 
 Images with `cache: 'web'` are kept in their own HTTP cache instead, up to 50 MB on each platform, which these limits don't change.
 
+### `setDefaults(defaults)`
+
+**Parameters:** `defaults: FastImageDefaults` · **Returns:** `void`
+
+Changes the defaults of every image, including `FastImageBackground`'s. Pass the settings to change; `null` goes back to the built-in default.
+
+- `transition`: the [`transition`](#transition) of images that don't set one (its doc describes the built-in default). An image's own `transition` wins, and the settings it leaves out come from the default.
+
+```js
+// In index.js, before images render.
+FastImage.setDefaults({ transition: false }) // no fades
+FastImage.setDefaults({ transition: true }) // fades on iOS too
+FastImage.setDefaults({ transition: Platform.select({ ios: 200 }) }) // 200 ms on iOS; Android keeps its default
+FastImage.setDefaults({ transition: { duration: 200, betweenImages: true } })
+FastImage.setDefaults({ transition: null }) // the built-in default
+```
+
+It isn't saved: call it when the app starts. An image already showing uses a change once one of its props changes, for its next load. It's ignored on the web, where images don't fade.
+
 ## Types
 
 <!-- api:types start (generated from src/ by website/scripts/generate.mts) -->
@@ -698,6 +710,14 @@ How fresh an image must be: see [`source.cache`](#sourcecache).
 
 ---
 
+### `FastImageDefaults`
+
+`FastImage.setDefaults`'s settings.
+
+- `transition?` (`number | boolean | Transition | null`): The `transition` of images that don't set one (an image's own settings win, and those it leaves out come from this). `null` goes back to the built-in default (see `transition`).
+
+---
+
 ### `LoadResult`
 
 **Type:** `{ ok: true; width: number; height: number } | { ok: false; error: string }`
@@ -714,6 +734,14 @@ How the image fits the view: see [`objectFit`](#objectfit).
 
 ---
 
+### `ObjectPosition`
+
+**Type:** `string | ({ top?: PositionLength; bottom?: never } | { bottom: PositionLength; top?: never }) & ({ left?: PositionLength; right?: never } | { right: PositionLength; left?: never })`
+
+Where the image is in the view: see [`objectPosition`](#objectposition).
+
+---
+
 ### `OnErrorEvent`
 
 `onError`'s event: `nativeEvent.error` says what went wrong, e.g. an HTTP status code or an image that can't be decoded.
@@ -724,7 +752,7 @@ How the image fits the view: see [`objectFit`](#objectfit).
 
 ### `OnLoadEvent`
 
-`onLoad`'s event: `nativeEvent` has the image's `width` and `height`, in pixels, and `target`, the view's React tag (missing on Android with the legacy architecture).
+`onLoad`'s event: `nativeEvent` has the image's own `width` and `height` (see `onLoad`), and `target`, the view's React tag (on iOS and Android; not on the web).
 
 - `nativeEvent` (`{ width: number; height: number; target?: number }`)
 
@@ -738,6 +766,14 @@ How the image fits the view: see [`objectFit`](#objectfit).
 
 ---
 
+### `PositionLength`
+
+**Type:** `` number | `${number}%` ``
+
+A length in points (dp on Android), or a percentage: see [`objectPosition`](#objectposition).
+
+---
+
 ### `PreloadFailure`
 
 A preloaded source that failed to load.
@@ -775,19 +811,11 @@ An image's load priority: see [`source.priority`](#sourcepriority).
 
 ---
 
-### `ResizeMode`
-
-**Type:** `'contain' | 'cover' | 'stretch' | 'center' | 'repeat'`
-
-How the image fits the view: see [`resizeMode`](#resizemode).
-
----
-
 ### `Transition`
 
 How the image fades in: see [`transition`](#transition).
 
-- `duration?` (`number`): How long the fade takes, in milliseconds; 0 means no fade. Defaults to the platform's usual length: 300 ms on Android, 250 ms on iOS.
+- `duration?` (`number`): How long the fade takes, in milliseconds; 0 means no fade. Defaults to the default transition's (see `FastImage.setDefaults`) if it fades, otherwise the platform's usual length: 300 ms on Android, 250 ms on iOS.
 - `betweenImages?` (`boolean`, default `false`): Also fades between images: a new `source` replacing an image that's showing cross-dissolves from it. Otherwise only an image that appears over nothing (or over `defaultSource`) fades in, and a new source replaces the image showing at once, once it has loaded.
 - `skipOnCacheHit?` (`'none' | 'memory' | 'all' | null`, default `'memory'`): Skips the fade for an image from a cache, so images already loaded show at once, e.g. in a list scrolled back up or a reused row.
 
@@ -795,7 +823,7 @@ How the image fades in: see [`transition`](#transition).
     - `'all'`: skips it for images from the memory or disk cache too, so images that download fade in, and local files and bundled images usually only the first time (the disk cache usually keeps them too).
     - `'none'`: always fades.
 
-    Downloads, local files and bundled images (`require()`) fade in. On Android, a `cache: 'web'` image from its HTTP cache, without a request, counts as one from the memory cache (these images aren't kept there).
+    On Android, a `cache: 'web'` image from its HTTP cache, without a request, counts as one from the memory cache (these images aren't kept there).
 
 <!-- api:types end -->
 
@@ -854,12 +882,20 @@ FastImage works on the web with [react-native-web](https://necolas.github.io/rea
 
 Support is minimal:
 
-- Props that work: `source` (a `uri`, a `require()`d image, or several sizes), `defaultSource`, `objectFit`, `resizeMode`, `tintColor`, `blurRadius`, `style`, children, `onLoadStart`, `onLoad`, `onError`, `onLoadEnd`, and View props such as `testID`, accessibility props, `onLayout` and `pointerEvents`.
-- Ignored: `source.headers` (a browser can't send them for an image), `source.priority`, `source.cache`, `source.cacheKey`, `source.memoryCache`, `recyclingKey`, `loop`, `imageRendering`, `paused`, `transition`, `downsample`, `fallback` and `onProgress`.
-- The image is an `<img>` element that fills the view inside its borders, with `objectFit` as its CSS `object-fit` (and `resizeMode`'s `stretch` as `fill`, `center` as `scale-down`). With `resizeMode="repeat"`, it's a repeated CSS background, with a transparent `<img>` over it. `tintColor` is an SVG filter and `blurRadius` a CSS `blur()`, and `defaultSource` is another `<img>`, under the image until it has loaded. A new `source` gets a new `<img>`, so the previous image doesn't stay while it loads (with several sizes, the browser shows it until the new one has loaded).
-- Several sizes are shown with a lazily loaded `<img>` whose `srcset` lists them, with `sizes="auto, 100vw"`: the browser loads the one for the width the image is shown at, in device pixels (usually the smallest that's at least as wide). Browsers that don't support `sizes="auto"` use the viewport's width. `resizeMode="repeat"` shows them as `cover`.
+- Props that work: `source` (a `uri`, a `require()`d image, or several sizes), `defaultSource`, `objectFit`, `objectPosition`, `tintColor`, `blurRadius`, `style`, `onLoadStart`, `onLoad`, `onError`, `onLoadEnd`, and View props such as `testID`, accessibility props, `onLayout` and `pointerEvents`.
+- Ignored: `source.headers` (a browser can't send them for an image), `source.priority`, `source.cache`, `source.cacheKey`, `source.memoryCache`, `source.diskCache`, `recyclingKey`, `loop`, `imageRendering`, `paused`, `transition`, `downsample` and `onProgress`.
+- The image is an `<img>` element that fills the view inside its borders, with `objectFit` and `objectPosition` as its CSS `object-fit` and `object-position`. `tintColor` is an SVG filter and `blurRadius` a CSS `blur()`, and `defaultSource` is another `<img>`, under the image until it has loaded. A new `source` gets a new `<img>`, so the previous image doesn't stay while it loads (with several sizes, the browser shows it until the new one has loaded).
+- Several sizes are shown with a lazily loaded `<img>` whose `srcset` lists them, with `sizes="auto, 100vw"`: the browser loads the one for the width the image is shown at, in device pixels (usually the smallest that's at least as wide). Browsers that don't support `sizes="auto"` use the viewport's width.
 - `FastImage.preload` loads the images into the browser's cache and resolves with a result per source. `clearMemoryCache`, `clearDiskCache` and `configureCache` resolve without doing anything (the browser manages its cache), and `getCachePath` and `writeToCache` resolve with `{ ok: false, error: 'Not supported on the web' }`.
 
+## Jest
+
+With React Native's Jest preset, FastImage renders without any setup, as its native view (`FastImageView`, in snapshots). Its functions need the native module, which Jest doesn't have, so they throw: mock the ones a test calls, e.g.
+
+```js
+jest.spyOn(FastImage, 'preload').mockResolvedValue([])
+```
+
 ## Troubleshooting
 
 If you have any problems using this library try the steps in [troubleshooting](docs/troubleshooting.md) and see if they fix it.

package/RNFastImage.podspec

@@ -9,20 +9,25 @@ Pod::Spec.new do |s|
   s.authors       = { "Dylan Vann" => "dylan@dylanvann.com" }
   s.homepage      = "https://github.com/DylanVann/react-native-fast-image#readme"
   s.license       = "MIT"
-  s.platforms     = { :ios => "13.0", :tvos => "13.0" }
+  # React Native 0.83's minimums.
+  s.platforms     = { :ios => "15.1", :tvos => "15.1" }
   s.framework     = 'UIKit'
   s.requires_arc  = true
   s.source        = { :git => "https://github.com/DylanVann/react-native-fast-image.git", :tag => "v#{s.version}" }
-  s.source_files  = "ios/**/*.{h,m}"
+  s.source_files  = "ios/**/*.{h,m,mm}"
 
-  s.dependency 'React-Core'
-  # Any 5.x from 5.11.1, so apps can use newer versions (and share them with
-  # other libraries) without having to update. 5.18.7+ has the privacy
-  # manifest Apple requires.
-  s.dependency 'SDWebImage', '>= 5.11.1', '< 6.0'
+  # React Native's dependencies for a New Architecture component and
+  # TurboModule (React-Core, Codegen's output for src/specs, ...).
+  install_modules_dependencies(s)
+
+  # Any 5.x from 5.21.4, so apps can use newer versions (and share them with
+  # other libraries, such as expo-image, which uses ~> 5.21.0 from Expo SDK 53)
+  # without having to update. downsample needs 5.19.7, tinted animated images
+  # and maxDiskAge counting from an image's last use 5.20, and 5.21.4 fixes a
+  # crash on iOS 26 (SDWebImage #3849).
+  s.dependency 'SDWebImage', '>= 5.21.4', '< 6.0'
   s.dependency 'SDWebImageWebPCoder', '>= 0.8.4', '< 1.0'
-  # SVG images. Every 1.x needs iOS 13 (Apple's SVG renderer). From 1.7, as
-  # expo-image's, so apps with it share one copy.
+  # SVG images. From 1.7, as expo-image's, so apps with it share one copy.
   s.dependency 'SDWebImageSVGCoder', '>= 1.7.0', '< 2.0'
   # Photo library images (ph://).
   s.dependency 'SDWebImagePhotosPlugin', '>= 1.2.0', '< 2.0'

package/android/build.gradle

@@ -2,22 +2,10 @@ def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
-buildscript {
-    // The Android Gradle plugin is only required when opening the android folder stand-alone.
-    // This avoids unnecessary downloads and potential conflicts when the library is included as a
-    // module dependency in an application project.
-    if (project == rootProject) {
-        repositories {
-            google()
-            mavenCentral()
-        }
-        dependencies {
-            classpath 'com.android.tools.build:gradle:3.5.3'
-        }
-    }
-}
-
 apply plugin: 'com.android.library'
+// Codegen for the component and module specs (src/specs), from the app's
+// React Native Gradle plugin.
+apply plugin: 'com.facebook.react'
 
 // Whether the app has expo-image (in a node_modules folder above the app's
 // android folder, as Node finds it), which ships its own AppGlideModule.
@@ -32,10 +20,12 @@ def appHasExpoImage = {
 def excludeAppGlideModule = safeExtGet('excludeAppGlideModule', appHasExpoImage())
 
 // When changing the default, revisit the Glide rules in consumer-rules.pro.
-// 4.15+ animates animated WebP (Android 9+) and AVIF (Android 12+), which
+// 5.0.7: Glide 5.0.9 needs apps to compile against API 37 (React Native
+// 0.83's compileSdk is 36). An app can set another, 4.15 or later: 4.15+
+// animates animated WebP (Android 9+) and AVIF (Android 12+), which
 // FastImageAnimated builds on. A version that isn't numbered (e.g. "4.+") is
 // taken to be recent.
-def glideVersion = safeExtGet('glideVersion', '4.16.0')
+def glideVersion = safeExtGet('glideVersion', '5.0.7')
 def glideVersionParts = glideVersion.toString() =~ /^(\d+)\.(\d+)/
 if (glideVersionParts.find() &&
         (glideVersionParts.group(1).toInteger() < 4 ||
@@ -43,30 +33,18 @@ if (glideVersionParts.find() &&
     throw new GradleException("react-native-fast-image needs Glide 4.15 or later, but glideVersion is ${glideVersion}.")
 }
 
-// Newer versions of the Android Gradle plugin (7.3+) take the namespace from
-// build.gradle and warn about the package attribute in AndroidManifest.xml;
-// older versions need that attribute.
-def supportsNamespace = project.android.hasProperty("namespace")
-
 android {
-    if (supportsNamespace) {
-        namespace "com.dylanvann.fastimage"
-    }
-    compileSdkVersion safeExtGet('compileSdkVersion', 28)
-    buildToolsVersion safeExtGet('buildToolsVersion', '28.0.3')
+    namespace = "com.fastimage"
+    // React Native 0.83's.
+    compileSdkVersion safeExtGet('compileSdkVersion', 36)
     defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', 21)
-        targetSdkVersion safeExtGet('targetSdkVersion', 28)
-        versionCode 1
-        versionName "1.0"
+        minSdkVersion safeExtGet('minSdkVersion', 24)
+        targetSdkVersion safeExtGet('targetSdkVersion', 36)
         // Applied to the app's release build, so apps don't need to add them.
         consumerProguardFiles 'consumer-rules.pro'
     }
     sourceSets {
         main {
-            if (supportsNamespace) {
-                manifest.srcFile "src/main/AndroidManifestNew.xml"
-            }
             java {
                 if (excludeAppGlideModule) {
                     exclude "**/FastImageGlideModule.java"
@@ -74,28 +52,24 @@ android {
             }
         }
     }
-    lintOptions {
-        abortOnError false
+    lint {
+        abortOnError = false
     }
 }
 
+react {
+    jsRootDir = file("../src/specs")
+    libraryName = "RNFastImageSpec"
+    codegenJavaPackageName = "com.fastimage"
+}
+
 repositories {
-    mavenLocal()
-    maven {
-        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
-        url "$rootDir/../node_modules/react-native/android"
-    }
-    maven {
-        // Android JSC is installed from npm
-        url "$rootDir/../node_modules/jsc-android/dist"
-    }
     google()
     mavenCentral()
 }
 
 dependencies {
-    //noinspection GradleDynamicVersion
-    implementation 'com.facebook.react:react-native:+'  // From node_modules
+    implementation 'com.facebook.react:react-android'
     implementation "com.github.bumptech.glide:glide:${glideVersion}"
     // FastImageGlideModule and FastImageOkHttpProgressGlideModule use @GlideModule.
     implementation "com.github.bumptech.glide:annotations:${glideVersion}"

package/android/consumer-rules.pro

@@ -4,16 +4,16 @@
 
 # FastImage's classes: its view manager, native module, Glide modules and
 # events.
--keep public class com.dylanvann.fastimage.* {*;}
--keep public class com.dylanvann.fastimage.** {*;}
+-keep public class com.fastimage.* {*;}
+-keep public class com.fastimage.** {*;}
 
 # The Glide rules below cover what Glide's own rules (its library's
 # proguard-rules.txt) didn't at the version FastImage uses by default
-# (glideVersion in build.gradle) and older ones apps may pick. When updating
-# Glide, revisit which are still needed: whether Glide's rules now keep
-# modules' constructors (4.16.0's still keep only the AppGlideModule's), and
-# whether its integrations still register old-style modules in their
-# manifests (the OkHttp integration's OkHttpGlideModule still did in 5.0.9).
+# (glideVersion in build.gradle, 5.0.7) and older ones apps may pick. When
+# updating Glide, revisit which are still needed: whether Glide's rules now
+# keep modules' constructors, and whether its integrations still register
+# old-style modules in their manifests (the OkHttp integration's
+# OkHttpGlideModule still did in 5.0.9).
 
 # Glide's modules and their constructors: FastImage's, the one Glide
 # generates from them, and old-style modules Glide finds in the app's manifest

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1 @@
-<manifest package="com.dylanvann.fastimage">
-</manifest>
+<manifest />

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageAnimatable.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 // An animated image that applies FastImage's loop and paused itself (an APNG,
 // FastImageApng). The view's target starts it when it's shown.

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageAnimated.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.content.Context;
 import android.content.res.Resources;
@@ -46,7 +46,7 @@ import java.util.concurrent.Executors;
 // the image's data (which the drawable keeps anyway, to decode its frames
 // from), off the main thread.
 //
-// Not animated (dontAnimate: blurRadius, resizeMode repeat), they're decoded
+// Not animated (dontAnimate: blurRadius), they're decoded
 // as their first frame, a bitmap, as GIFs are, and as Glide did before 4.15.
 // Glide's own decoder for them doesn't check that option.
 final class FastImageAnimated {

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageApng.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
@@ -28,7 +28,7 @@ import java.nio.charset.StandardCharsets;
 //
 // The decoders come before Glide's own, and only take PNGs with an animation
 // control chunk (acTL), when the request animates (not with dontAnimate:
-// blurRadius, resizeMode repeat, which get the first frame from Glide's
+// blurRadius, which gets the first frame from Glide's
 // decoder).
 final class FastImageApng {
     // As much of the start of the file as is read to find acTL, which comes

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageBlur.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
@@ -26,15 +26,14 @@ import java.security.MessageDigest;
 // blurred and unblurred views of one image don't share a cached image; the
 // cached file stays the original.
 final class FastImageBlur extends BitmapTransformation {
-    private static final String ID = "com.dylanvann.fastimage.FastImageBlur";
+    private static final String ID = "com.fastimage.FastImageBlur";
     private static final byte[] ID_BYTES = ID.getBytes(Charset.forName("UTF-8"));
 
     // In pixels on screen.
     private final float radius;
     private final ImageView.ScaleType scaleType;
     // Pixels on screen per pixel of the image at its own size (scale-down and
-    // none show it at that size: see FastImageViewWithUrl.updateImageMatrix;
-    // 1 for resizeMode center).
+    // none show it at that size: see FastImageViewWithUrl.updateImageMatrix).
     private final float density;
 
     FastImageBlur(float radius, ImageView.ScaleType scaleType, float density) {
@@ -76,7 +75,6 @@ final class FastImageBlur extends BitmapTransformation {
         if (width <= 0 || height <= 0 || outWidth <= 0 || outHeight <= 0) return 1;
         float x = outWidth / (float) width;
         float y = outHeight / (float) height;
-        if (scaleType == null) return 1;
         switch (scaleType) {
             case CENTER_CROP:
                 return Math.max(x, y);
@@ -212,7 +210,7 @@ final class FastImageBlur extends BitmapTransformation {
 
     @Override
     public int hashCode() {
-        return (ID.hashCode() * 31 + Float.floatToIntBits(radius) * 31 + (scaleType == null ? 0 : scaleType.ordinal())) * 31
+        return (ID.hashCode() * 31 + Float.floatToIntBits(radius) * 31 + scaleType.ordinal()) * 31
                 + Float.floatToIntBits(density);
     }
 

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageCacheControl.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 public enum FastImageCacheControl {
     IMMUTABLE,

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageCacheLimits.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.content.Context;
 import android.content.SharedPreferences;
@@ -76,6 +76,9 @@ final class FastImageCacheLimits {
             ApplicationInfo info = context.getPackageManager()
                     .getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
             Bundle metaData = info.metaData;
+            // Bundle.get (deprecated from API 33 for parcels of unknown types):
+            // the manifest's value is an Integer, a Float or a String.
+            @SuppressWarnings("deprecation")
             Object value = metaData == null ? null : metaData.get(MANIFEST_MAX_DISK_SIZE);
             if (value instanceof Number) return ((Number) value).longValue();
             if (value instanceof String) return Long.parseLong(((String) value).trim());

package/android/src/main/java/com/{dylanvann/fastimage → fastimage}/FastImageCacheWrite.java

@@ -1,4 +1,4 @@
-package com.dylanvann.fastimage;
+package com.fastimage;
 
 import android.content.Context;
 import android.net.Uri;