@octane-xplat/image 0.0.0-stage → 0.11.0

package/package.json

@@ -1,6 +1,86 @@
 {
   "name": "@octane-xplat/image",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.11.0",
+  "description": "Cached image loading for Octane xplat — Glide/SDWebImage engine (ui-image) on native, <img> on web",
+  "keywords": [
+    "android",
+    "cache",
+    "cross-platform",
+    "glide",
+    "image",
+    "ios",
+    "nativescript",
+    "octane",
+    "sdwebimage",
+    "web",
+    "xplat"
+  ],
+  "homepage": "https://github.com/octane-xplat/octane-xplat/tree/main/packages/image",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/octane-xplat/octane-xplat",
+    "directory": "packages/image"
+  },
+  "files": [
+    "dist",
+    "types",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "macos": {
+        "types": "./types/index.macos.d.ts",
+        "default": "./src/index.macos.ts"
+      },
+      "web": {
+        "types": "./types/generated/index.web.d.ts",
+        "default": "./dist/web/index.js"
+      },
+      "native": {
+        "types": "./types/generated/index.d.ts",
+        "default": "./dist/native/index.js"
+      },
+      "types": "./types/generated/index.d.ts",
+      "default": "./dist/native/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nativescript-community/ui-image": "5.0.17"
+  },
+  "devDependencies": {
+    "@nativescript-community/octane": "0.2.4",
+    "@nativescript/core": "9.1.2",
+    "@octane-xplat/ui": "0.11.0",
+    "@octanejs/vite-plugin": "0.1.61",
+    "@tsrx/typescript-plugin": "0.4.11",
+    "octane": "0.6.3",
+    "tsrx-typegen": "0.2.2",
+    "typescript": "5.9.3",
+    "vite": "8.3.0"
+  },
+  "peerDependencies": {
+    "@nativescript-community/octane": ">=0.2.1 <1",
+    "@nativescript/core": ">=9.1.0 <10",
+    "@octane-xplat/ui": ">=0.10.0 <1",
+    "octane": ">=0.6.3 <1"
+  },
+  "peerDependenciesMeta": {
+    "@nativescript-community/octane": {
+      "optional": true
+    },
+    "@nativescript/core": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "vite build && vite build --mode native && pnpm typegen && node ../../scripts/check-native-dist.mjs",
+    "test:packed": "node tests/packed-consumer.mjs",
+    "typegen": "tsrx-typegen --target octane",
+    "pack:check": "tsrx-typegen --pack-check"
+  }
 }

package/src/Image.macos.tsrx

@@ -0,0 +1,24 @@
+/** @jsxImportSource @octane-xplat/macos-renderer */
+import type { ImageProps } from './props'
+
+/** Image — the AppKit host's <image>. The engine leaf has no macOS backend
+ *  (Glide/SDWebImage are iOS/Android), so this mirrors the core AppKit path:
+ *  local src grammar, first array entry for multi-source, contentFit →
+ *  style.objectFit ('cover' degrades to scale-down — AppKit has no cover
+ *  scaling mode); contentPosition is unimplemented here. Engine props are
+ *  ignored — no cache engine exists on this target. */
+export function Image(props: ImageProps) @{
+	const src = (Array.isArray(props.src) ? props.src[0]?.uri : props.src) ?? ''
+	const style = {
+		objectFit: props.contentFit ?? 'cover',
+		...props.style,
+	}
+
+	<image
+		id={props.id}
+		src={src}
+		className={props.className}
+		{style}
+		accessibilityLabel={props.alt ?? ''}
+	/>
+}

package/src/Image.tsrx

@@ -0,0 +1,269 @@
+/** @jsxImportSource @nativescript-community/octane */
+import { registerElement } from '@nativescript-community/octane';
+import { ImageSource, isAndroid, isIOS, Screen } from '@nativescript/core';
+import { Img, initialize } from '@nativescript-community/ui-image';
+import { useMemo, useRef } from 'octane';
+import type { ImageProps } from './props';
+import { hashToPngBase64 } from './hash-image';
+import {
+	contentFitToStretch,
+	needsContentRect,
+	resolveContentFit,
+	resolveContentPosition,
+} from './image-content';
+
+import { createImageBinding } from './image-binding';
+
+// @nativescript-community/ui-image v5 — Glide + okhttp3 on Android (sized LRU
+// memory cache + BitmapPool + disk cache), SDWebImage on iOS. `noCache` maps to
+// skipMemoryCache + DiskCacheStrategy.NONE / SDWebImage FromLoaderOnly.
+registerElement('cachedimage', Img);
+
+let syncDecodeWarned = false;
+
+let engineStarted = false;
+function ensureEngine(): void {
+	if (!engineStarted) {
+		// Android auto-inits inside createNativeView anyway; calling early covers
+		// iOS loader registration and keeps an initializeImageCache() config the
+		// winner when it ran before first render (the plugin guards on its own
+		// `initialized` flag).
+		initialize();
+		engineStarted = true;
+	}
+}
+
+const LAYOUT_KEYS = [
+	'row',
+	'col',
+	'rowSpan',
+	'colSpan',
+	'dock',
+	'left',
+	'top',
+	'flexGrow',
+	'flexShrink',
+	'alignSelf',
+	'order',
+] as const;
+
+function layoutChildAttrs(props: ImageProps) {
+	const result: Record<string, any> = {};
+	for (const key of LAYOUT_KEYS) {
+		if (props[key] !== undefined) {
+			result[key] = props[key];
+		}
+	}
+
+	return result;
+}
+
+function applyEscapeProps(view: any, props: ImageProps): void {
+	const bag = isIOS ? props.ios : isAndroid ? props.android : undefined;
+	if (bag) {
+		Object.assign(view, bag);
+	}
+}
+
+/** A `src` string → engine source. data: URIs decode to an ImageSource — the
+ *  engine has no data: scheme. */
+function resolveSrc(src: string): string | ImageSource {
+	const comma = src.indexOf(',');
+	if (src.startsWith('data:') && comma > 0 && src.slice(0, comma).endsWith(';base64')) {
+		return ImageSource.fromBase64Sync(src.slice(comma + 1));
+	}
+
+	return src;
+}
+
+/** `placeholder` → what the engine's placeholderImageUri accepts: `res://`,
+ *  `~/`, and file paths pass through as strings; `blurhash:`/`thumbhash:` and
+ *  `data:` decode to an ImageSource (the plugin's getDrawable/getUIImage
+ *  accept the instance even though the prop is typed `string`). Remote URLs
+ *  are ignored on native, matching core Image — a placeholder that must fetch
+ *  first is pointless. */
+function placeholderValue(placeholder: string): string | ImageSource | null {
+	const png = hashToPngBase64(placeholder);
+	if (png) {
+		return ImageSource.fromBase64Sync(png);
+	}
+
+	if (/^https?:\/\//.test(placeholder)) {
+		return null;
+	}
+
+	return resolveSrc(placeholder);
+}
+
+/** Image — ui-image `Img` (Glide/SDWebImage). Mirrors the core contract:
+ *  `src` takes the Img grammar (remote URL, res://name, ~/bundle path, file
+ *  path, data: URI) plus a resolution-qualified `ImageSourceLike[]` (closest
+ *  pixel count wins once the view has a real layout — the srcset model).
+ *  `contentFit` maps to stretch for the centered contain/cover/fill cases;
+ *  'none'/'scale-down'/positioned content take the computed path — the host
+ *  box is measured, the content rect computed, and a fill-stretched `Img`
+ *  laid out inside a clipped absolutelayout (same structure core uses).
+ *  `src` never goes through JSX: the binding holds it until first layout,
+ *  writes decodeWidth/decodeHeight in device px, then assigns — an eager src
+ *  decodes at full source resolution. SVG is unsupported — keep core `Image`
+ *  for those. `alt` maps to accessibilityLabel. `decoding` accepts the shared
+ *  vocabulary but 'sync' degrades to async with a warning — the engines have
+ *  no synchronous decode mode (see props.ts). */
+export function Image(props: ImageProps) @{
+	ensureEngine();
+
+	// `decoding='sync'` has no honest path: Glide `.into()` and SDWebImage
+	// `sd_setImageWithURL` always decode off-thread, and the plugin's
+	// `loadMode` prop is registered but never read. Degrade to the async
+	// default with a note rather than setting dead surface.
+	if (props.decoding === 'sync' && !syncDecodeWarned) {
+		syncDecodeWarned = true;
+		console.warn(
+			"[octane-xplat] Image: decoding='sync' is not supported by the Glide/SDWebImage engine — decode stays async.",
+		);
+	}
+
+	const latest = useRef(props);
+	latest.current = props;
+
+	const fit = resolveContentFit(props.contentFit);
+	const position = resolveContentPosition(props.contentPosition);
+	const computed = needsContentRect(fit, position);
+	const imageRef = useRef<any>(null);
+	const hostRef = useRef<any>(null);
+
+	const binding = useMemo(
+		() =>
+			createImageBinding({
+				getFit: () => resolveContentFit(latest.current.contentFit),
+				getPosition: () => resolveContentPosition(latest.current.contentPosition),
+				getSrc: () => {
+					const src = latest.current.src;
+					return Array.isArray(src)
+						? { source: null, sources: src }
+						: { source: resolveSrc(src), sources: null };
+				},
+				getDecodeBounds: () => ({
+					width: latest.current.decodeWidth,
+					height: latest.current.decodeHeight,
+				}),
+				screenScale: () => Screen.mainScreen?.scale ?? 1,
+			}),
+		[],
+	);
+
+	const boundRef = useRef({ key: props.recyclingKey, src: props.src });
+	const bound = boundRef.current;
+	boundRef.current = { key: props.recyclingKey, src: props.src };
+	// expo-image `recyclingKey`: platform-list cells rebind the same view, and
+	// the engine keeps drawing the previous bitmap until the new fetch
+	// resolves. Clear it before the ref re-binds the next src — only when
+	// identity AND source both changed (same src = same bitmap).
+	if (
+		bound.key != null &&
+		props.recyclingKey != null &&
+		bound.key !== props.recyclingKey &&
+		bound.src !== props.src &&
+		imageRef.current
+	) {
+		const nativeView = imageRef.current.nativeViewProtected;
+		if (nativeView) {
+			if (isIOS) {
+				nativeView.image = null;
+			} else {
+				nativeView.setImageDrawable?.(null);
+			}
+		}
+	}
+
+	const attach = (view: any) => {
+		if (!view) {
+			return;
+		}
+
+		imageRef.current = view;
+		applyEscapeProps(view, props);
+		const ph = latest.current.placeholder;
+		if (ph) {
+			const resolved = placeholderValue(ph);
+			if (resolved != null) {
+				// string | ImageSource — the prop is typed `string` but the
+				// plugin's placeholder resolution accepts an ImageSource on
+				// both platforms.
+				view.placeholderImageUri = resolved;
+			}
+		}
+
+		if (!view.__xplatImageWired) {
+			view.__xplatImageWired = true;
+			view.on(Img.finalImageSetEvent, (e: any) => {
+				const info = e.imageInfo;
+				const w = info?.getWidth?.() ?? info?.width ?? 0;
+				const h = info?.getHeight?.() ?? info?.height ?? 0;
+				binding.setIntrinsic(w, h);
+				latest.current.onLoad?.({ width: w, height: h, source: e.source });
+			});
+
+			view.on(Img.failureEvent, (e: any) => {
+				latest.current.onError?.({ error: e.error });
+			});
+		}
+	};
+
+	@if (computed) {
+		<absolutelayout
+			ref={(v: any) => {
+				hostRef.current = v;
+				if (v && isIOS && v.ios) {
+					// cover/positioned rects must clip at the component box (iOS
+					// defaults overflow:visible).
+					v.ios.clipsToBounds = true;
+				}
+
+				if (v) {
+					binding.update(imageRef.current, v);
+				}
+			}}
+			id={props.id}
+			className={props.className}
+			style={props.style}
+			{...layoutChildAttrs(props)}
+		>
+			<cachedimage
+				ref={(v: any) => {
+					attach(v);
+					if (v) {
+						binding.update(v, hostRef.current);
+					}
+				}}
+				stretch="fill"
+				failureImageUri={props.failureImage}
+				headers={props.headers}
+				noCache={props.cachePolicy === 'none'}
+				progressiveRenderingEnabled={props.progressive}
+				fadeDuration={props.fadeDuration}
+				accessibilityLabel={props.alt}
+			/>
+		</absolutelayout>
+	} @else {
+		<cachedimage
+			ref={(v: any) => {
+				attach(v);
+				if (v) {
+					binding.update(v, null);
+				}
+			}}
+			id={props.id}
+			className={props.className}
+			style={props.style}
+			{...layoutChildAttrs(props)}
+			stretch={contentFitToStretch(fit)}
+			failureImageUri={props.failureImage}
+			headers={props.headers}
+			noCache={props.cachePolicy === 'none'}
+			progressiveRenderingEnabled={props.progressive}
+			fadeDuration={props.fadeDuration}
+			accessibilityLabel={props.alt}
+		/>
+	}
+}

package/src/Image.web.tsrx

@@ -0,0 +1,176 @@
+import { useLayoutEffect, useRef } from 'octane';
+import type { ImageProps, ImageSourceLike } from './props';
+import {
+	imageSrcSet,
+	objectPositionCSSValue,
+	resolveContentFit,
+	resolveContentPosition,
+} from './image-content';
+
+import { hashToPngBase64 } from './hash-image';
+
+/** Parent-layout metadata → CSS. Mirrors the ui web mapping: grid indices are
+ *  zero-based, dock has no CSS equivalent and is ignored. */
+function layoutChildStyle(props: ImageProps) {
+	const style: Record<string, any> = {};
+	if (props.row !== undefined) {
+		style.gridRow = `${props.row + 1} / span ${props.rowSpan ?? 1}`;
+	} else if (props.rowSpan !== undefined) {
+		style.gridRow = `span ${props.rowSpan}`;
+	}
+
+	if (props.col !== undefined) {
+		style.gridColumn = `${props.col + 1} / span ${props.colSpan ?? 1}`;
+	} else if (props.colSpan !== undefined) {
+		style.gridColumn = `span ${props.colSpan}`;
+	}
+
+	if (props.left !== undefined) {
+		style.left = props.left;
+	}
+
+	if (props.top !== undefined) {
+		style.top = props.top;
+	}
+
+	if (props.flexGrow !== undefined) {
+		style.flexGrow = props.flexGrow;
+	}
+
+	if (props.flexShrink !== undefined) {
+		style.flexShrink = props.flexShrink;
+	}
+
+	if (props.alignSelf !== undefined) {
+		style.alignSelf = props.alignSelf;
+	}
+
+	if (props.order !== undefined) {
+		style.order = props.order;
+	}
+
+	return style;
+}
+
+/** Dash-named escape-bag keys are attributes; other keys use the DOM property
+ *  where available. Mirrors ui's web escape-props. */
+function applyEscapeProps(element: any, props: ImageProps): void {
+	if (!element || !props.web) {
+		return;
+	}
+
+	for (const [key, value] of Object.entries(props.web)) {
+		if (key.includes('-')) {
+			if (value == null || value === false) {
+				element.removeAttribute(key);
+			} else {
+				element.setAttribute(key, String(value));
+			}
+		} else if (key in element) {
+			element[key] = value;
+		} else if (value != null && value !== false) {
+			element.setAttribute(key, String(value));
+		}
+	}
+}
+
+/** `blurhash:`/`thumbhash:` decode to a data: PNG (./hash-image — the ui
+ *  copy); every other value passes through as an ordinary <img> URL (a
+ *  low-res source URL is a fine placeholder on web). */
+function placeholderUrl(placeholder: string): string {
+	const png = hashToPngBase64(placeholder);
+	return png ? `data:image/png;base64,${png}` : placeholder;
+}
+
+/** Image — a plain <img>, mirroring the core contract: a source array becomes
+ *  a real `srcset` (browser owns selection); `contentFit`/`contentPosition`
+ *  map 1:1 to object-fit/object-position with 'cover'/'50% 50%' defaults;
+ *  `placeholder` rides the same element — the img keeps its last decoded
+ *  image while a hidden prefetch warms the final src, so placeholder → final
+ *  swaps in one view without a blank frame. Engine-only props (cachePolicy,
+ *  failureImage, headers, decodeWidth/decodeHeight, progressive,
+ *  fadeDuration) have no <img> equivalent and are ignored. onLoad fires
+ *  without `source` — the browser does not report which cache satisfied the
+ *  request. */
+export function Image(props: ImageProps) @{
+	const imgRef = useRef<HTMLImageElement | null>(null);
+	const sources = Array.isArray(props.src) ? (props.src as ImageSourceLike[]) : null;
+	const selected = sources
+		? imageSrcSet(sources)
+		: { src: props.src as string, srcSet: undefined };
+
+	useLayoutEffect(() => {
+		const img = imgRef.current;
+		// complete = the current src already resolved (cache/sync data URI) —
+		// showing the placeholder would flash backwards.
+		if (!img || !props.placeholder || img.complete) return;
+		const placeholder = placeholderUrl(props.placeholder);
+		const { src: final, srcSet: finalSrcSet } = selected;
+		// (document.createElement — `Image` here is this component, not the
+		// global HTMLImageElement constructor)
+		const warm = document.createElement('img');
+		warm.src = final;
+		if (finalSrcSet) {
+			warm.srcset = finalSrcSet;
+		}
+
+		const swap = () => {
+			img.src = final;
+			if (finalSrcSet) {
+				// srcset overrides src while present — restore it after the
+				// src write so both point at the final selection.
+				img.srcset = finalSrcSet;
+			}
+		};
+
+		img.addEventListener('load', swap, { once: true });
+		img.addEventListener('error', swap, { once: true });
+		if (finalSrcSet) {
+			// While srcset is set it wins over src — clear it or the
+			// placeholder assignment below is inert.
+			img.srcset = '';
+		}
+
+		img.src = placeholder;
+		return () => {
+			img.removeEventListener('load', swap);
+			img.removeEventListener('error', swap);
+		};
+	}, [props.src, props.placeholder]);
+
+	const style = {
+		objectFit: 'cover',
+		objectPosition: '50% 50%',
+		...layoutChildStyle(props),
+		...(typeof props.style === 'object' ? props.style : {}),
+		...(props.contentFit !== undefined
+			? { objectFit: resolveContentFit(props.contentFit) }
+			: null),
+		...(props.contentPosition !== undefined
+			? { objectPosition: objectPositionCSSValue(resolveContentPosition(props.contentPosition)) }
+			: null),
+	};
+
+	<img
+		ref={(e: any) => {
+			imgRef.current = e;
+			applyEscapeProps(e, props);
+		}}
+		id={props.id}
+		className={props.className}
+		src={selected.src}
+		srcSet={selected.srcSet}
+		decoding={props.decoding ?? 'async'}
+		alt={props.alt}
+		style={style}
+		onLoad={(e: any) =>
+			props.onLoad?.({
+				width: e.currentTarget.naturalWidth ?? 0,
+				height: e.currentTarget.naturalHeight ?? 0,
+			})
+		}
+		onError={() =>
+			props.onError?.({ error: new Error(`Failed to load image: ${props.src}`) })
+		}
+	/>
+}

package/src/cache.macos.ts

@@ -0,0 +1,31 @@
+import type { ImageCacheConfig, ImageCacheQueryOptions, ImageCacheState, PrefetchOptions } from './props';
+
+/** No-op — the AppKit host has no image engine. */
+export function initializeImageCache(_config?: ImageCacheConfig): void {}
+
+/** No-op — the AppKit host has no image pipeline to warm, so nothing is
+ *  prefetched; resolves `false` to report that honestly. */
+export function prefetch(_srcs: string | string[], _options?: PrefetchOptions): Promise<boolean> {
+	return Promise.resolve(false);
+}
+
+export function evictImage(_src: string): Promise<boolean> {
+	return Promise.resolve(false);
+}
+
+export function clearImageCaches(): Promise<void> {
+	return Promise.resolve();
+}
+
+export function isImageCached(
+	srcs: string | readonly string[],
+	_options?: ImageCacheQueryOptions,
+): Promise<Record<string, ImageCacheState>> {
+	const list = typeof srcs === 'string' ? [srcs] : srcs;
+	const states: Record<string, ImageCacheState> = {};
+	for (const src of list) {
+		states[src] = 'none';
+	}
+
+	return Promise.resolve(states);
+}

package/src/cache.ts

@@ -0,0 +1,93 @@
+import { ImagePipeline, getImagePipeline, initialize } from '@nativescript-community/ui-image';
+import { prefetchBatch } from './prefetch-batch';
+import type { ImageCacheConfig, ImageCacheQueryOptions, ImageCacheState, PrefetchOptions } from './props';
+
+/** Apply engine-level cache configuration. Call from the app entry before the
+ *  first <Image> renders — the plugin initializes Glide lazily, so sizing must
+ *  arrive before the first view creates the engine. A later call is a no-op
+ *  (the plugin guards on its own `initialized` flag). Native only. */
+export function initializeImageCache(config?: ImageCacheConfig): void {
+	initialize({
+		memoryCacheSize: config?.memoryCacheSize,
+		memoryCacheScreens: config?.memoryCacheScreens,
+		usePersistentCacheKeyStore: config?.persistentCacheKeys,
+		globalSignatureKey: config?.globalSignatureKey,
+	});
+
+	if (config?.iosComplexCacheEviction !== undefined) {
+		ImagePipeline.iosComplexCacheEviction = config.iosComplexCacheEviction;
+	}
+}
+
+/** Warm the disk cache without decoding — bytes are fetched and stored, decode
+ *  cost stays at display time. One URL or an array; resolves `true` when all
+ *  warmed, `false` if any URL fails or the pipeline is not up yet (e.g. called
+ *  before app launch). Same contract as `@octane-xplat/gif`'s `prefetch`.
+ *
+ *  `options.headers` is forwarded on Android and iOS (via the framework
+ *  patch). `options.concurrency` caps parallel fetches. */
+export function prefetch(srcs: string | string[], options?: PrefetchOptions): Promise<boolean> {
+	try {
+		initialize();
+		const pipeline = getImagePipeline();
+		const { concurrency, ...engineOptions } = options ?? {};
+		return prefetchBatch(srcs, concurrency, (url) =>
+			pipeline.prefetchToDiskCache(url, engineOptions).then(
+				() => true,
+				() => false,
+			),
+		);
+	} catch {
+		return Promise.resolve(false);
+	}
+}
+
+/** Remove `src` from memory and disk caches. */
+export function evictImage(src: string): Promise<boolean> {
+	initialize();
+	return getImagePipeline().evictFromCache(src);
+}
+
+/** Drop every cached image (memory + disk). */
+export function clearImageCaches(): Promise<void> {
+	initialize();
+	return getImagePipeline().clearCaches();
+}
+
+// The published index.d.ts omits the options params on the two presence
+// probes — the iOS implementation folds them into the cache key through
+// getContextFromOptions (the same context the Img display path builds), and
+// Android ignores the extra arg since its probe keys on the URL alone.
+// Declared locally so the probe can pass the display load's decode context.
+interface CacheProbe {
+	isInBitmapMemoryCache(uri: string, options?: ImageCacheQueryOptions): boolean;
+	isInDiskCache(uri: string, options?: ImageCacheQueryOptions): Promise<boolean>;
+}
+
+/** Report which cache level currently holds each `src` — 'memory', 'disk',
+ *  or 'none' (not cached / unknown). Accepts a single URL or a list; the
+ *  result is always a `Record` keyed by URL (the RN `queryCache` shape).
+ *  `options` repeats the display load's decode bounds: on iOS the cache key
+ *  includes the transform context, so an image displayed with
+ *  decodeWidth/decodeHeight only reports its level when the probe passes
+ *  the same values. Android caveat: the plugin's probe cannot see Glide's
+ *  active resources, so a bitmap still on screen may report 'none' —
+ *  treat 'none' as "not provably cached", not "absent". */
+export async function isImageCached(
+	srcs: string | readonly string[],
+	options?: ImageCacheQueryOptions,
+): Promise<Record<string, ImageCacheState>> {
+	initialize();
+	const pipeline = getImagePipeline() as unknown as CacheProbe;
+	const list = typeof srcs === 'string' ? [srcs] : srcs;
+	const states: Record<string, ImageCacheState> = {};
+	await Promise.all(
+		list.map(async (src) => {
+			states[src] = pipeline.isInBitmapMemoryCache(src, options)
+				? 'memory'
+				: ((await pipeline.isInDiskCache(src, options)) ? 'disk' : 'none');
+		}),
+	);
+
+	return states;
+}