react-native-fast-image 9.3.7 → 10.0.0

package/dist/index.web.js

@@ -1,4 +1,4 @@
-import React, { forwardRef, memo, useEffect, useLayoutEffect, useRef, useState } from "react";
+import React, { Children, forwardRef, memo, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { Image, PixelRatio, StyleSheet, View } from "react-native";
 import { getAssetByID } from "react-native-web/dist/modules/AssetRegistry";
 //#region src/constants.ts
@@ -35,13 +35,6 @@ function fromStyle(style, key) {
 	}
 	return style && typeof style === "object" ? style[key] : void 0;
 }
-const RESIZE_MODE_FIT = {
-	contain: "contain",
-	cover: "cover",
-	stretch: "fill",
-	center: "center",
-	repeat: "repeat"
-};
 const FITS = {
 	fill: true,
 	contain: true,
@@ -49,11 +42,202 @@ const FITS = {
 	none: true,
 	"scale-down": true
 };
-function resolveObjectFit(objectFit, style, resizeMode) {
-	var _RESIZE_MODE_FIT$resi;
+function resolveObjectFit(objectFit, style) {
 	const fit = objectFit != null ? objectFit : fromStyle(style, "objectFit");
-	if (fit && FITS[fit] === true) return fit;
-	return (_RESIZE_MODE_FIT$resi = RESIZE_MODE_FIT[resizeMode]) !== null && _RESIZE_MODE_FIT$resi !== void 0 ? _RESIZE_MODE_FIT$resi : "cover";
+	return fit && FITS[fit] === true ? fit : "cover";
+}
+//#endregion
+//#region src/warnings.ts
+const warned = /* @__PURE__ */ new Set();
+function warnOnce(key, message, level) {
+	if (!warned.has(key)) {
+		warned.add(key);
+		console[level](message);
+	}
+}
+function warnIfChildren(children) {
+	if (Children.toArray(children).length > 0) warnOnce("children", "react-native-fast-image: FastImage doesn't render children (since 10.0): use FastImageBackground for content over an image.", "error");
+}
+//#endregion
+//#region src/objectPosition.ts
+const START = {
+	fraction: 0,
+	offset: 0
+};
+const CENTER = {
+	fraction: .5,
+	offset: 0
+};
+const END = {
+	fraction: 1,
+	offset: 0
+};
+/** The default, `50% 50%`. */
+const CENTERED = {
+	x: CENTER,
+	y: CENTER
+};
+const NUMBER = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+function length(text) {
+	const lower = text.toLowerCase();
+	if (lower.endsWith("%")) {
+		const number = lower.slice(0, -1);
+		return NUMBER.test(number) ? {
+			fraction: Number(number) / 100,
+			offset: 0
+		} : null;
+	}
+	if (lower.endsWith("px")) {
+		const number = lower.slice(0, -2);
+		return NUMBER.test(number) ? {
+			fraction: 0,
+			offset: Number(number)
+		} : null;
+	}
+	return NUMBER.test(lower) && Number(lower) === 0 ? START : null;
+}
+function token(text) {
+	const lower = text.toLowerCase();
+	if (lower === "left" || lower === "right" || lower === "top" || lower === "bottom" || lower === "center") return { keyword: lower };
+	const axis = length(text);
+	return axis ? { length: axis } : null;
+}
+const X = {
+	left: START,
+	center: CENTER,
+	right: END
+};
+const Y = {
+	top: START,
+	center: CENTER,
+	bottom: END
+};
+const x = (t) => "length" in t ? t.length : X[t.keyword];
+const y = (t) => "length" in t ? t.length : Y[t.keyword];
+function fromEdge(edge, axis) {
+	return edge === "left" || edge === "top" ? axis : {
+		fraction: 1 - axis.fraction,
+		offset: -axis.offset || 0
+	};
+}
+function parse(text) {
+	const tokens = [];
+	for (const part of text.trim().split(/\s+/)) {
+		const t = token(part);
+		if (!t) return null;
+		tokens.push(t);
+	}
+	if (tokens.length === 1) {
+		const [a] = tokens;
+		if ("keyword" in a && (a.keyword === "top" || a.keyword === "bottom")) return {
+			x: CENTER,
+			y: Y[a.keyword]
+		};
+		return {
+			x: x(a),
+			y: CENTER
+		};
+	}
+	if (tokens.length === 2) {
+		const [a, b] = tokens;
+		const ax = x(a);
+		const by = y(b);
+		if (ax && by) return {
+			x: ax,
+			y: by
+		};
+		if ("keyword" in a && "keyword" in b) {
+			const bx = X[b.keyword];
+			const ay = Y[a.keyword];
+			if (bx && ay) return {
+				x: bx,
+				y: ay
+			};
+		}
+		return null;
+	}
+	if (tokens.length === 4) {
+		const [a, b, c, d] = tokens;
+		if (!("keyword" in a && "length" in b && "keyword" in c && "length" in d)) return null;
+		const horizontal = (k) => k === "left" || k === "right";
+		const vertical = (k) => k === "top" || k === "bottom";
+		if (horizontal(a.keyword) && vertical(c.keyword)) return {
+			x: fromEdge(a.keyword, b.length),
+			y: fromEdge(c.keyword, d.length)
+		};
+		if (vertical(a.keyword) && horizontal(c.keyword)) return {
+			x: fromEdge(c.keyword, d.length),
+			y: fromEdge(a.keyword, b.length)
+		};
+	}
+	return null;
+}
+const parsed = /* @__PURE__ */ new Map();
+function objectLength(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? {
+		fraction: 0,
+		offset: value
+	} : null;
+	return typeof value === "string" && value.endsWith("%") ? length(value) : null;
+}
+/**
+* The position for objectPosition, or null if it isn't valid. A string is
+* CSS's syntax; an object has one of `top` and `bottom` and one of `left`
+* and `right`, each in points or a percentage, and a missing axis is
+* centered. Unset is centered.
+*/
+function resolveObjectPosition(position) {
+	if (position == null) return CENTERED;
+	if (typeof position === "string") {
+		let result = parsed.get(position);
+		if (result === void 0) {
+			result = parse(position);
+			if (parsed.size < 100) parsed.set(position, result);
+		}
+		return result;
+	}
+	if (typeof position !== "object") return null;
+	const edges = position;
+	const axis = (start, end) => {
+		const hasStart = edges[start] != null;
+		const hasEnd = edges[end] != null;
+		if (hasStart && hasEnd) return null;
+		if (!hasStart && !hasEnd) return CENTER;
+		const edge = hasStart ? start : end;
+		const value = objectLength(edges[edge]);
+		return value && fromEdge(edge, value);
+	};
+	const resolvedX = axis("left", "right");
+	const resolvedY = axis("top", "bottom");
+	return resolvedX && resolvedY ? {
+		x: resolvedX,
+		y: resolvedY
+	} : null;
+}
+const round = (n) => Math.round(n * 1e6) / 1e6;
+/**
+* The position for objectPosition, or centered if it isn't valid (as CSS
+* ignores it), with a warning in development.
+*/
+function objectPositionOrCentered(position) {
+	const resolved = resolveObjectPosition(position);
+	if (resolved) return resolved;
+	if (typeof __DEV__ !== "undefined" && __DEV__) {
+		const value = JSON.stringify(position);
+		warnOnce(`objectPosition ${value}`, `react-native-fast-image: objectPosition ${value} isn't a position, so the image is centered. Use CSS's syntax with px or % (e.g. 'right 10px bottom 20%'), or { top | bottom, left | right } in points or percentages.`, "warn");
+	}
+	return CENTERED;
+}
+/** The position as CSS (for the web version's object-position). */
+function cssPosition({ x, y }) {
+	const axis = ({ fraction, offset }) => {
+		const percent = round(fraction * 100);
+		const px = round(offset);
+		if (px === 0) return `${percent}%`;
+		if (percent === 0) return `${px}px`;
+		return `calc(${percent}% ${px < 0 ? "-" : "+"} ${Math.abs(px)}px)`;
+	};
+	return `${axis(x)} ${axis(y)}`;
 }
 //#endregion
 //#region src/index.web.tsx
@@ -66,8 +250,9 @@ let ids = 0;
 const useCounterId = () => useState(() => `${++ids}`)[0];
 const useSvgId = (_useId = React.useId) !== null && _useId !== void 0 ? _useId : useCounterId;
 const useClientLayoutEffect = globalThis.document === void 0 ? useEffect : useLayoutEffect;
-function FastImageBase({ source, defaultSource, tintColor, blurRadius, onLoadStart, onLoad, onError, onLoadEnd, style, children, objectFit, resizeMode: mode = "cover", forwardedRef, onLayout, pointerEvents, fallback: _fallback, recyclingKey: _recyclingKey, loop: _loop, imageRendering: _imageRendering, paused: _paused, transition: _transition, downsample: _downsample, onProgress: _onProgress, ...props }) {
-	const { accessibilityLabel, "aria-label": ariaLabel, ...viewProps } = props;
+function FastImageBase({ source, defaultSource, tintColor, blurRadius, onLoadStart, onLoad, onError, onLoadEnd, style, children, objectFit, objectPosition, forwardedRef, onLayout, pointerEvents, recyclingKey: _recyclingKey, loop: _loop, imageRendering: _imageRendering, paused: _paused, transition: _transition, downsample: _downsample, onProgress: _onProgress, ...props }) {
+	if (typeof __DEV__ !== "undefined" && __DEV__) warnIfChildren(children);
+	const { accessibilityLabel, "aria-label": ariaLabel, resizeMode: _resizeMode, ...viewProps } = props;
 	const label = ariaLabel || accessibilityLabel || void 0;
 	const several = Array.isArray(source) && source.length > 1 ? source : void 0;
 	const sized = several ? sizedSources(several) : void 0;
@@ -78,8 +263,8 @@ function FastImageBase({ source, defaultSource, tintColor, blurRadius, onLoadSta
 	const [result, setResult] = useState();
 	const ok = result && result.key === key ? result.ok : void 0;
 	const tintId = `fast-image-tint-${useSvgId().replace(/[^\w-]/g, "")}`;
-	const resolved = resolveObjectFit(objectFit, style, mode);
-	const fit = resolved === "center" ? "scale-down" : several && resolved === "repeat" ? "cover" : resolved;
+	const fit = resolveObjectFit(objectFit, style);
+	const position = cssPosition(objectPositionOrCentered(objectPosition));
 	const filter = [blurRadius ? `blur(${blurRadius}px)` : "", tintColor ? `url(#${tintId})` : ""].filter(Boolean).join(" ") || void 0;
 	const showDefault = !!defaultUri && ok !== true;
 	useClientLayoutEffect(() => {
@@ -96,6 +281,7 @@ function FastImageBase({ source, defaultSource, tintColor, blurRadius, onLoadSta
 		key: `default ${defaultUri}`,
 		src: defaultUri,
 		fit,
+		position,
 		filter,
 		alt: key ? "" : label !== null && label !== void 0 ? label : ""
 	}) : null, key && src ? /* @__PURE__ */ React.createElement(Picture, {
@@ -104,6 +290,7 @@ function FastImageBase({ source, defaultSource, tintColor, blurRadius, onLoadSta
 		srcSet,
 		lazy: !!several,
 		fit,
+		position,
 		filter,
 		hidden: ok === false,
 		alt: label !== null && label !== void 0 ? label : "",
@@ -138,7 +325,7 @@ function FastImageBase({ source, defaultSource, tintColor, blurRadius, onLoadSta
 	}) : null, tintColor ? /* @__PURE__ */ React.createElement(TintFilter, {
 		id: tintId,
 		color: tintColor
-	}) : null, children);
+	}) : null);
 }
 function resolveUri(source) {
 	let uri;
@@ -186,14 +373,10 @@ const fill = {
 	width: "100%",
 	height: "100%"
 };
-function Picture({ src, srcSet, lazy, fit, filter, hidden, alt, onLoad, onError }) {
-	const repeat = fit === "repeat";
+function Picture({ src, srcSet, lazy, fit, position, filter, hidden, alt, onLoad, onError }) {
 	const image = useRef(null);
-	const tiles = useRef(null);
 	const mounted = useRef(true);
 	const handled = useRef(void 0);
-	const [natural, setNatural] = useState();
-	const [box, setBox] = useState();
 	const loaded = (target) => {
 		var _handled$current, _target$decode;
 		const file = target.currentSrc || src;
@@ -203,10 +386,6 @@ function Picture({ src, srcSet, lazy, fit, filter, hidden, alt, onLoad, onError
 			sources,
 			file
 		};
-		setNatural({
-			width: target.naturalWidth,
-			height: target.naturalHeight
-		});
 		const done = () => {
 			if (mounted.current) onLoad === null || onLoad === void 0 || onLoad(target);
 		};
@@ -227,21 +406,7 @@ function Picture({ src, srcSet, lazy, fit, filter, hidden, alt, onLoad, onError
 			if (mounted.current) onError === null || onError === void 0 || onError(target.currentSrc || src);
 		});
 	}, []);
-	useClientLayoutEffect(() => {
-		const Observer = globalThis.ResizeObserver;
-		const node = tiles.current;
-		if (!repeat || !node || !Observer) return;
-		const observer = new Observer((entries) => {
-			const { width, height } = entries[0].contentRect;
-			setBox({
-				width,
-				height
-			});
-		});
-		observer.observe(node);
-		return () => observer.disconnect();
-	}, [repeat]);
-	const img = /* @__PURE__ */ React.createElement("img", {
+	return /* @__PURE__ */ React.createElement("img", {
 		ref: image,
 		src,
 		srcSet,
@@ -251,9 +416,10 @@ function Picture({ src, srcSet, lazy, fit, filter, hidden, alt, onLoad, onError
 		draggable: false,
 		style: {
 			...fill,
-			objectFit: repeat ? "cover" : fit,
-			filter: repeat ? void 0 : filter,
-			opacity: repeat || hidden ? 0 : void 0
+			objectFit: fit,
+			objectPosition: position,
+			filter,
+			opacity: hidden ? 0 : void 0
 		},
 		onLoad: (event) => loaded(event.currentTarget),
 		onError: (event) => {
@@ -261,23 +427,6 @@ function Picture({ src, srcSet, lazy, fit, filter, hidden, alt, onLoad, onError
 			if (mounted.current) onError === null || onError === void 0 || onError((target === null || target === void 0 ? void 0 : target.currentSrc) || src);
 		}
 	});
-	return /* @__PURE__ */ React.createElement(React.Fragment, null, repeat ? /* @__PURE__ */ React.createElement("div", {
-		ref: tiles,
-		style: {
-			...fill,
-			backgroundImage: `url("${src}")`,
-			backgroundRepeat: "repeat",
-			backgroundPosition: "0",
-			backgroundSize: tileSize(natural, box),
-			filter,
-			opacity: hidden ? 0 : void 0
-		}
-	}) : null, img);
-}
-function tileSize(natural, box) {
-	if (!(natural === null || natural === void 0 ? void 0 : natural.width) || !natural.height || !(box === null || box === void 0 ? void 0 : box.width) || !box.height) return;
-	const scale = Math.min(1, box.width / natural.width, box.height / natural.height);
-	return `${Math.ceil(scale * natural.width)}px ${Math.ceil(scale * natural.height)}px`;
 }
 function TintFilter({ id, color }) {
 	return /* @__PURE__ */ React.createElement("svg", { style: tintStyle }, /* @__PURE__ */ React.createElement("defs", null, /* @__PURE__ */ React.createElement("filter", { id }, /* @__PURE__ */ React.createElement("feFlood", {
@@ -312,9 +461,9 @@ function getSize(uri) {
 	});
 }
 const FastImage = FastImageComponent;
-FastImage.resizeMode = resizeMode;
 FastImage.cacheControl = cacheControl;
 FastImage.priority = priority;
+FastImage.resizeMode = resizeMode;
 FastImage.preload = (sources) => Promise.all(sources.map((source) => {
 	const uri = source ? source.uri : void 0;
 	if (typeof uri !== "string" || !uri) return Promise.resolve({
@@ -335,6 +484,7 @@ FastImage.preload = (sources) => Promise.all(sources.map((source) => {
 FastImage.clearMemoryCache = () => Promise.resolve(notSupported);
 FastImage.clearDiskCache = () => Promise.resolve(notSupported);
 FastImage.configureCache = () => Promise.resolve({});
+FastImage.setDefaults = () => {};
 FastImage.writeToCache = () => Promise.resolve(notSupported);
 FastImage.getCachePath = () => Promise.resolve(notSupported);
 const styles = StyleSheet.create({ container: { overflow: "hidden" } });

package/dist/index.web.js.flow

@@ -1,25 +1,23 @@
 // @flow
 
-import type { ViewProps } from 'react-native/Libraries/Components/View/ViewPropTypes'
-import type { SyntheticEvent } from 'react-native/Libraries/Types/CoreEventTypes'
+import type { NativeSyntheticEvent, ViewProps } from 'react-native'
 
-export type OnLoadEvent = SyntheticEvent<
+export type OnLoadEvent = NativeSyntheticEvent<
     $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.
+        // The view's React tag (on iOS and Android; not on the web).
         target?: number,
     }>,
 >
 
-export type OnErrorEvent = SyntheticEvent<
+export type OnErrorEvent = NativeSyntheticEvent<
     $ReadOnly<{|
         error: string,
     |}>,
 >
 
-export type OnProgressEvent = SyntheticEvent<
+export type OnProgressEvent = NativeSyntheticEvent<
     $ReadOnly<{|
         loaded: number,
         total: number,
@@ -28,6 +26,12 @@ export type OnProgressEvent = SyntheticEvent<
     |}>,
 >
 
+export type Priority = $ReadOnly<{|
+    low: 'low',
+    normal: 'normal',
+    high: 'high',
+|}>
+
 export type ResizeMode = $ReadOnly<{|
     contain: 'contain',
     cover: 'cover',
@@ -36,20 +40,22 @@ export type ResizeMode = $ReadOnly<{|
     repeat: 'repeat',
 |}>
 
-export type Priority = $ReadOnly<{|
-    low: 'low',
-    normal: 'normal',
-    high: 'high',
-|}>
-
 export type CacheControl = $ReadOnly<{|
     immutable: 'immutable',
     web: 'web',
     cacheOnly: 'cacheOnly',
 |}>
 
-export type ResizeModes = $Values<ResizeMode>
 export type ObjectFit = 'fill' | 'contain' | 'cover' | 'none' | 'scale-down'
+export type PositionLength = number | string
+export type ObjectPosition =
+    | string
+    | $ReadOnly<{|
+          top?: PositionLength,
+          bottom?: PositionLength,
+          left?: PositionLength,
+          right?: PositionLength,
+      |}>
 export type Priorities = $Values<Priority>
 export type CacheControls = $Values<CacheControl>
 
@@ -82,6 +88,10 @@ export type Transition = $ReadOnly<{|
     skipOnCacheHit?: ?('none' | 'memory' | 'all'),
 |}>
 
+export type FastImageDefaults = $ReadOnly<{|
+    transition?: ?(boolean | number | Transition),
+|}>
+
 export type PreloadSuccess = {|
     uri: string,
     ok: true,
@@ -125,9 +135,7 @@ export type FastImageProps = $ReadOnly<{|
 
     tintColor?: number | string,
     objectFit?: ?ObjectFit,
-    // Deprecated: use objectFit.
-    resizeMode?: ?ResizeModes,
-    fallback?: ?boolean,
+    objectPosition?: ?ObjectPosition,
     recyclingKey?: ?string,
     loop?: ?(boolean | number),
     imageRendering?: ?('auto' | 'smooth' | 'pixelated'),
@@ -136,6 +144,9 @@ export type FastImageProps = $ReadOnly<{|
     downsample?: ?boolean,
     blurRadius?: ?number,
     testID?: ?string,
+    // FastImage is a single native view, which doesn't take children (since
+    // 10.0): use FastImageBackground.
+    children?: "FastImage doesn't take children: use FastImageBackground for content over an image",
 |}>
 
 export type FastImageBackgroundProps = $ReadOnly<{|
@@ -148,14 +159,19 @@ export type FastImageBackgroundProps = $ReadOnly<{|
 declare export var FastImageBackground: React$ComponentType<FastImageBackgroundProps>
 
 declare export default class FastImage extends React$Component<FastImageProps> {
+    // Deprecated: removed in 10.0, and a resizeMode prop is ignored; use
+    // objectFit. Kept so code that reads it doesn't throw.
     static resizeMode: ResizeMode;
+    // Deprecated: use the strings instead, e.g. priority: 'high'.
     static priority: Priority;
+    // Deprecated: use the strings instead, e.g. cache: 'immutable'.
     static cacheControl: CacheControl;
     static preload: PreloadFn;
     static clearMemoryCache: () => Promise<ClearCacheResult>;
     static clearDiskCache: () => Promise<ClearCacheResult>;
     static getCachePath: (source: FastImageSource) => Promise<CachePathResult>;
     static configureCache: (limits?: CacheLimits) => Promise<CacheState>;
+    static setDefaults: (defaults: FastImageDefaults) => void;
     static writeToCache: (
         source: FastImageSource,
         file: string,

package/dist/objectFit.d.ts

@@ -1,3 +1,3 @@
-import type { ImageStyle, ObjectFit, ResizeMode } from './index';
+import type { ImageStyle, ObjectFit } from './index';
 export declare function fromStyle<K extends 'tintColor' | 'objectFit'>(style: unknown, key: K): ImageStyle[K];
-export declare function resolveObjectFit(objectFit: ObjectFit | null | undefined, style: unknown, resizeMode: ResizeMode): ObjectFit | 'repeat' | 'center';
+export declare function resolveObjectFit(objectFit: ObjectFit | null | undefined, style: unknown): ObjectFit;

package/dist/objectPosition.d.ts

@@ -0,0 +1,42 @@
+/** A length in points (dp on Android), or a percentage: see [`objectPosition`](#objectposition). */
+export type PositionLength = number | `${number}%`;
+/**
+ * Where the image is in the view: see [`objectPosition`](#objectposition).
+ */
+export type ObjectPosition = string | (({
+    top?: PositionLength;
+    bottom?: never;
+} | {
+    bottom: PositionLength;
+    top?: never;
+}) & ({
+    left?: PositionLength;
+    right?: never;
+} | {
+    right: PositionLength;
+    left?: never;
+}));
+export type ResolvedAxis = {
+    fraction: number;
+    offset: number;
+};
+export type ResolvedPosition = {
+    x: ResolvedAxis;
+    y: ResolvedAxis;
+};
+/** The default, `50% 50%`. */
+export declare const CENTERED: ResolvedPosition;
+/**
+ * The position for objectPosition, or null if it isn't valid. A string is
+ * CSS's syntax; an object has one of `top` and `bottom` and one of `left`
+ * and `right`, each in points or a percentage, and a missing axis is
+ * centered. Unset is centered.
+ */
+export declare function resolveObjectPosition(position: ObjectPosition | null | undefined): ResolvedPosition | null;
+/**
+ * The position for objectPosition, or centered if it isn't valid (as CSS
+ * ignores it), with a warning in development.
+ */
+export declare function objectPositionOrCentered(position: ObjectPosition | null | undefined): ResolvedPosition;
+/** The position as CSS (for the web version's object-position). */
+export declare function cssPosition({ x, y }: ResolvedPosition): string;

package/dist/specs/FastImageViewNativeComponent.d.ts

@@ -0,0 +1,48 @@
+import type { CodegenTypes, ColorValue, HostComponent, ViewProps } from 'react-native';
+type LoadStartEvent = Readonly<{}>;
+type ProgressEvent = Readonly<{
+    loaded: CodegenTypes.Double;
+    total: CodegenTypes.Double;
+    progress: CodegenTypes.Double;
+}>;
+type LoadEvent = Readonly<{
+    width: CodegenTypes.Double;
+    height: CodegenTypes.Double;
+}>;
+type ErrorEvent = Readonly<{
+    error: string;
+}>;
+type LoadEndEvent = Readonly<{
+    ok: boolean;
+    width?: CodegenTypes.Double;
+    height?: CodegenTypes.Double;
+    error?: string;
+}>;
+export interface NativeProps extends ViewProps {
+    source?: CodegenTypes.UnsafeMixed;
+    sources?: CodegenTypes.UnsafeMixed;
+    defaultSource?: CodegenTypes.UnsafeMixed;
+    objectFit?: CodegenTypes.WithDefault<string, 'cover'>;
+    objectPositionX?: CodegenTypes.WithDefault<CodegenTypes.Float, 0.5>;
+    objectPositionXOffset?: CodegenTypes.Float;
+    objectPositionY?: CodegenTypes.WithDefault<CodegenTypes.Float, 0.5>;
+    objectPositionYOffset?: CodegenTypes.Float;
+    tintColor?: ColorValue;
+    recyclingKey?: string;
+    loopCount?: CodegenTypes.WithDefault<CodegenTypes.Int32, -1>;
+    imageRendering?: string;
+    paused?: boolean;
+    transitionDuration?: CodegenTypes.Double;
+    transitionBetweenImages?: boolean;
+    transitionSkipOnCacheHit?: string;
+    downsample?: CodegenTypes.WithDefault<boolean, true>;
+    blurRadius?: CodegenTypes.Float;
+    handledEvents?: CodegenTypes.Int32;
+    onFastImageLoadStart?: CodegenTypes.DirectEventHandler<LoadStartEvent>;
+    onFastImageProgress?: CodegenTypes.DirectEventHandler<ProgressEvent>;
+    onFastImageLoad?: CodegenTypes.DirectEventHandler<LoadEvent>;
+    onFastImageError?: CodegenTypes.DirectEventHandler<ErrorEvent>;
+    onFastImageLoadEnd?: CodegenTypes.DirectEventHandler<LoadEndEvent>;
+}
+declare const _default: HostComponent<NativeProps>;
+export default _default;

package/dist/specs/NativeFastImageModule.d.ts

@@ -0,0 +1,11 @@
+import type { CodegenTypes, TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    preload(sources: Array<CodegenTypes.UnsafeObject>): Promise<Array<CodegenTypes.UnsafeObject>>;
+    getCachePath(source: CodegenTypes.UnsafeObject): Promise<CodegenTypes.UnsafeObject>;
+    writeToCache(source: CodegenTypes.UnsafeObject, file: string): Promise<CodegenTypes.UnsafeObject>;
+    configureCache(limits: CodegenTypes.UnsafeObject): Promise<CodegenTypes.UnsafeObject>;
+    clearMemoryCache(): Promise<CodegenTypes.UnsafeObject>;
+    clearDiskCache(): Promise<CodegenTypes.UnsafeObject>;
+}
+declare const _default: Spec | null;
+export default _default;

package/dist/warnings.d.ts

@@ -0,0 +1,3 @@
+export declare function warnOnce(key: string, message: string, level: 'warn' | 'error'): void;
+export declare function resetWarnings(): void;
+export declare function warnIfChildren(children: unknown): void;

package/ios/FastImage/FFFDownsampledImage.h

@@ -4,8 +4,8 @@
 // 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
+// preserveAspectRatio NO when the image has to cover the box (objectFit
+// cover or fill) rather than fit in it (contain or scale-down). 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
@@ -14,8 +14,8 @@
 // or fit in.
 + (void) addToContext: (SDWebImageMutableContext*)context box: (CGSize)box cover: (BOOL)cover;
 
-// Sets a load's context to decode the image at full size, through this class
-// when it's supported. Every FastImage load uses it, so loads of the same url
+// Sets a load's context to decode the image at full size, through this class.
+// Every FastImage load uses it, so loads of the same url
 // can share a download: SDWebImage's downloader decodes each load of a
 // download with the first load's image class (and each with its own size),
 // and SDWebImage's own thumbnail decoding can't cover a box.
@@ -33,8 +33,4 @@
 // decodes the file from the disk cache. Call it before a full-size load.
 + (void) forgetSmallerFullSizeImageForURL: (NSURL*)url context: (SDWebImageContext*)context;
 
-// 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