@octane-xplat/image 0.0.0-stage → 0.11.0

package/src/image-content.ts

@@ -0,0 +1,310 @@
+import type {
+	ImageContentFit,
+	ImageContentPosition,
+	ImageContentPositionObject,
+	ImageContentPositionValue,
+	ImageSourceLike,
+} from './props'
+
+/** VENDORED from packages/ui/src/image-content.ts — keep in sync.
+ *  Shared `contentFit`/`contentPosition` + multi-source math for `Image` —
+ *  pure functions used by every leaf (docs/notes/expo-image-study.md L7/L8).
+ *  Semantics mirror CSS `object-fit`/`object-position`, which is also
+ *  expo-image's contract: the leaves compute the drawn-content rect
+ *  themselves instead of delegating to platform scaleType/contentMode,
+ *  so all platforms get the same answer.
+ *
+ *  The default fit is 'cover' everywhere (the expo/RN default). Today's
+ *  platform defaults disagree — web <img> is 'fill' and NS stretch is
+ *  'aspectFit' — so an un-propped Image was silently divergent. */
+
+export const DEFAULT_CONTENT_FIT: ImageContentFit = 'cover'
+
+export function resolveContentFit(fit?: ImageContentFit): ImageContentFit {
+	return fit ?? DEFAULT_CONTENT_FIT
+}
+
+/** expo-image's keyword shorthands; the object form positions relative to
+ *  any corner pair ({top,left}, {top,right}, {bottom,left}, {bottom,right}). */
+const POSITION_KEYWORDS: Record<string, ImageContentPositionObject> = {
+	center: { top: '50%', left: '50%' },
+	top: { top: 0, left: '50%' },
+	right: { top: '50%', right: 0 },
+	bottom: { bottom: 0, left: '50%' },
+	left: { top: '50%', left: 0 },
+	'top center': { top: 0, left: '50%' },
+	'top right': { top: 0, right: 0 },
+	'top left': { top: 0, left: 0 },
+	'right center': { top: '50%', right: 0 },
+	'right top': { top: 0, right: 0 },
+	'right bottom': { bottom: 0, right: 0 },
+	'bottom center': { bottom: 0, left: '50%' },
+	'bottom right': { bottom: 0, right: 0 },
+	'bottom left': { bottom: 0, left: 0 },
+	'left center': { top: '50%', left: 0 },
+	'left top': { top: 0, left: 0 },
+	'left bottom': { bottom: 0, left: 0 },
+}
+
+export function resolveContentPosition(
+	position?: ImageContentPosition,
+): ImageContentPositionObject {
+	if (typeof position === 'string') {
+		return POSITION_KEYWORDS[position] ?? POSITION_KEYWORDS.center
+	}
+
+	return position ?? POSITION_KEYWORDS.center
+}
+
+type AxisValue = { percent: number } | { dips: number }
+
+function parseAxisValue(value: ImageContentPositionValue | undefined): AxisValue | null {
+	if (value == null) {
+		return null
+	}
+
+	if (typeof value === 'number') {
+		return { dips: value }
+	}
+
+	const text = String(value).trim()
+	if (text === 'center') {
+		return { percent: 50 }
+	}
+
+	if (text.endsWith('%')) {
+		const parsed = Number.parseFloat(text)
+		return Number.isNaN(parsed) ? null : { percent: parsed }
+	}
+
+	const parsed = Number.parseFloat(text)
+	return Number.isNaN(parsed) ? null : { dips: parsed }
+}
+
+/** Offset of the drawn content's start edge inside the view along one axis.
+ *  expo-image `calcTranslation`: percentages run over the free space
+ *  (view − content), absolute dips measure from the named edge, and the
+ *  reverse edge (right/bottom) counts back from the far side. */
+export function contentAxisOffset(
+	viewSize: number,
+	contentSize: number,
+	start: ImageContentPositionValue | undefined,
+	end: ImageContentPositionValue | undefined,
+): number {
+	const from = parseAxisValue(start)
+	if (from) {
+		return 'percent' in from ? (from.percent / 100) * (viewSize - contentSize) : from.dips
+	}
+
+	const to = parseAxisValue(end)
+	if (to) {
+		return 'percent' in to
+			? (1 - to.percent / 100) * (viewSize - contentSize)
+			: viewSize - contentSize - to.dips
+	}
+
+	return (viewSize - contentSize) / 2
+}
+
+function centeredAxis(
+	start: ImageContentPositionValue | undefined,
+	end: ImageContentPositionValue | undefined,
+): boolean {
+	const from = parseAxisValue(start)
+	if (from) {
+		return 'percent' in from && from.percent === 50
+	}
+
+	const to = parseAxisValue(end)
+	if (to) {
+		return 'percent' in to && to.percent === 50
+	}
+
+	return true
+}
+
+export function isCenteredContentPosition(position: ImageContentPositionObject): boolean {
+	return (
+		centeredAxis(position.left, position.right) && centeredAxis(position.top, position.bottom)
+	)
+}
+
+/** The rect the bitmap occupies inside the view box, in the same units the
+ *  caller measures with (native: dips; web: CSS px via object-fit anyway —
+ *  only the native leaf calls this). Every length unit is dips except the
+ *  intrinsic size, which the leaf must supply in dips too. */
+export function contentRect(
+	fit: ImageContentFit,
+	position: ImageContentPositionObject,
+	viewWidth: number,
+	viewHeight: number,
+	imageWidth: number,
+	imageHeight: number,
+): { x: number; y: number; width: number; height: number } {
+	let width: number
+	let height: number
+	switch (fit) {
+		case 'fill':
+			width = viewWidth
+			height = viewHeight
+			break
+		case 'cover': {
+			const scale = Math.max(viewWidth / imageWidth, viewHeight / imageHeight)
+			width = imageWidth * scale
+			height = imageHeight * scale
+			break
+		}
+		case 'scale-down': {
+			const scale = Math.min(1, Math.min(viewWidth / imageWidth, viewHeight / imageHeight))
+			width = imageWidth * scale
+			height = imageHeight * scale
+			break
+		}
+		case 'none':
+			width = imageWidth
+			height = imageHeight
+			break
+		default: {
+			// 'contain'
+			const scale = Math.min(viewWidth / imageWidth, viewHeight / imageHeight)
+			width = imageWidth * scale
+			height = imageHeight * scale
+		}
+	}
+
+	return {
+		x: contentAxisOffset(viewWidth, width, position.left, position.right),
+		y: contentAxisOffset(viewHeight, height, position.top, position.bottom),
+		width,
+		height,
+	}
+}
+
+/** True when no platform stretch/scaleType can express the request and the
+ *  leaf must measure + lay out the image itself: 'none' (iOS maps NS
+ *  stretch='none' to TopLeft, not CSS centered), 'scale-down' (needs the
+ *  intrinsic-vs-view compare), or any non-center position. 'fill' is
+ *  exempt — its rect is always the whole box, so position can't matter. */
+export function needsContentRect(
+	fit: ImageContentFit,
+	position: ImageContentPositionObject,
+): boolean {
+	if (fit === 'none' || fit === 'scale-down') {
+		return true
+	}
+
+	return fit !== 'fill' && !isCenteredContentPosition(position)
+}
+
+/** NS `stretch` for the fast path — only reached for fits the platform
+ *  vocabulary expresses identically (contain/cover/fill centered). */
+export function contentFitToStretch(fit: ImageContentFit): 'aspectFit' | 'aspectFill' | 'fill' {
+	switch (fit) {
+		case 'contain':
+			return 'aspectFit'
+		case 'fill':
+			return 'fill'
+		default:
+			return 'aspectFill'
+	}
+}
+
+/** L8 — expo `getBestSource`: the source whose declared pixel count
+ *  (`width·height·scale²`, dips × density) is closest to the view's pixel
+ *  count. Needs a real measured size; one source or no size picks nothing
+ *  to decide. Unsized sources score worst and are skipped when any sized
+ *  candidate exists. */
+export function bestImageSource(
+	sources: readonly ImageSourceLike[],
+	viewWidth: number,
+	viewHeight: number,
+	screenScale: number,
+): ImageSourceLike | null {
+	if (sources.length === 0 || viewWidth <= 0 || viewHeight <= 0) {
+		return null
+	}
+
+	if (sources.length === 1) {
+		return sources[0]
+	}
+
+	const target = viewWidth * viewHeight * screenScale * screenScale
+	let best: ImageSourceLike | null = null
+	let bestFit = Infinity
+	for (const source of sources) {
+		const pixelCount = (source.width ?? 0) * (source.height ?? 0) * (source.scale ?? 1) ** 2
+		const fit = Math.abs(1 - pixelCount / target)
+		if (fit < bestFit) {
+			best = source
+			bestFit = fit
+		}
+	}
+
+	return best
+}
+
+function ensureWebUnits(value: ImageContentPositionValue): string {
+	const text = String(value).trim()
+	return text.endsWith('%') ? text : `${text}px`
+}
+
+/** Browser `object-position` for a resolved position — mirrors expo-image
+ *  web's `getObjectPositionFromContentPositionObject`. */
+export function objectPositionCSSValue(position: ImageContentPositionObject): string {
+	const resolved: ImageContentPositionObject = { ...position }
+	if (resolved.top == null && resolved.bottom == null) {
+		resolved.top = '50%'
+	}
+
+	if (resolved.left == null && resolved.right == null) {
+		resolved.left = '50%'
+	}
+
+	return (
+		(['top', 'bottom', 'left', 'right'] as const)
+			.map((edge) => (resolved[edge] != null ? `${edge} ${ensureWebUnits(resolved[edge]!)}` : ''))
+			.filter((part) => part !== '')
+			.join(' ') || '50% 50%'
+	)
+}
+
+/** Browser `srcset` candidates for a source array: `w` descriptors (real
+ *  file px = width·scale) when every source is sized, `x` descriptors when
+ *  every source only carries density. `src` falls back to the largest
+ *  declared pixel count — guaranteed coverage where srcset is ignored. */
+export function imageSrcSet(sources: readonly ImageSourceLike[]): {
+	src: string
+	srcSet?: string
+} {
+	if (sources.length === 0) {
+		return { src: '' }
+	}
+
+	const everyWidth = sources.every(
+		(source) => typeof source.width === 'number' && source.width > 0,
+	)
+
+	const everyScale =
+		!everyWidth &&
+		sources.every((source) => typeof source.scale === 'number' && source.scale > 0)
+
+	const srcSet = everyWidth
+		? sources
+				.map((source) => `${source.uri} ${Math.round(source.width! * (source.scale ?? 1))}w`)
+				.join(', ')
+		: everyScale
+			? sources.map((source) => `${source.uri} ${source.scale}x`).join(', ')
+			: undefined
+
+	let fallback = sources[0]
+	let bestCount = -Infinity
+	for (const source of sources) {
+		const count = (source.width ?? 0) * (source.height ?? 0) * (source.scale ?? 1) ** 2
+		if (count > bestCount) {
+			bestCount = count
+			fallback = source
+		}
+	}
+
+	return { src: fallback.uri, srcSet }
+}

package/src/index.macos.ts

@@ -0,0 +1,26 @@
+export { Image } from './Image.macos.tsrx'
+export {
+	clearImageCaches,
+	evictImage,
+	initializeImageCache,
+	isImageCached,
+	prefetch,
+} from './cache.macos'
+
+export type {
+	ImageCacheConfig,
+	ImageCachePolicy,
+	ImageCacheQueryOptions,
+	ImageCacheState,
+	ImageContentFit,
+	ImageContentPosition,
+	ImageContentPositionObject,
+	ImageContentPositionString,
+	ImageContentPositionValue,
+	ImageDecoding,
+	ImageErrorEvent,
+	ImageLoadEvent,
+	ImageProps,
+	PrefetchOptions,
+	ImageSourceLike,
+} from './props'

package/src/index.ts

@@ -0,0 +1,28 @@
+// Platform barrels — explicit .tsrx leaf imports (moduleSuffixes don't
+// reach .tsrx; same convention as @octane-xplat/ui index.*.ts).
+export { Image } from './Image.tsrx'
+export {
+	clearImageCaches,
+	evictImage,
+	initializeImageCache,
+	isImageCached,
+	prefetch,
+} from './cache'
+
+export type {
+	ImageCacheConfig,
+	ImageCachePolicy,
+	ImageCacheQueryOptions,
+	ImageCacheState,
+	ImageContentFit,
+	ImageContentPosition,
+	ImageContentPositionObject,
+	ImageContentPositionString,
+	ImageContentPositionValue,
+	ImageDecoding,
+	ImageErrorEvent,
+	ImageLoadEvent,
+	ImageProps,
+	PrefetchOptions,
+	ImageSourceLike,
+} from './props'

package/src/index.web.ts

@@ -0,0 +1,28 @@
+// Platform barrels — explicit .tsrx leaf imports (moduleSuffixes don't
+// reach .tsrx; same convention as @octane-xplat/ui index.*.ts).
+export { Image } from './Image.web.tsrx'
+export {
+	clearImageCaches,
+	evictImage,
+	initializeImageCache,
+	isImageCached,
+	prefetch,
+} from './cache.web'
+
+export type {
+	ImageCacheConfig,
+	ImageCachePolicy,
+	ImageCacheQueryOptions,
+	ImageCacheState,
+	ImageContentFit,
+	ImageContentPosition,
+	ImageContentPositionObject,
+	ImageContentPositionString,
+	ImageContentPositionValue,
+	ImageDecoding,
+	ImageErrorEvent,
+	ImageLoadEvent,
+	ImageProps,
+	PrefetchOptions,
+	ImageSourceLike,
+} from './props'

package/src/native-elements.d.ts

@@ -0,0 +1,8 @@
+import { Img } from '@nativescript-community/ui-image'
+import type { Attributes } from '@nativescript-community/octane/intrinsics'
+
+declare module '@nativescript-community/octane/intrinsics' {
+	interface NativeScriptElements {
+		cachedimage: Attributes<typeof Img>
+	}
+}

package/src/prefetch-batch.ts

@@ -0,0 +1,50 @@
+/** VENDORED — identical copy in packages/gif/src/prefetch-batch.ts; keep in
+ *  sync.
+ *
+ *  Shared batch driver for the image-engine leaves' `prefetch` contract:
+ *  normalizes `string | string[]`, caps in-flight requests JS-side, and
+ *  resolves `true` only when every URL warms — `false` on the first failure
+ *  (in-flight requests settle on their own; the result is already decided). */
+
+/** Matches the `maxRequests = 5` ceiling NS core's ImageCache used. */
+export const DEFAULT_PREFETCH_CONCURRENCY = 5
+
+export function prefetchBatch(
+	srcs: string | string[],
+	concurrency: number | undefined,
+	warm: (url: string) => Promise<boolean>,
+): Promise<boolean> {
+	const urls = Array.isArray(srcs) ? srcs : [srcs]
+	if (urls.length === 0) {
+		return Promise.resolve(true)
+	}
+
+	const requested = Math.floor(concurrency ?? DEFAULT_PREFETCH_CONCURRENCY)
+	const limit =
+		Number.isFinite(requested) && requested > 0 ? requested : DEFAULT_PREFETCH_CONCURRENCY
+
+	return new Promise<boolean>((resolve) => {
+		let next = 0
+		let active = Math.min(limit, urls.length)
+		for (let i = 0; i < active; i++) {
+			void (async () => {
+				while (next < urls.length) {
+					const url = urls[next++]
+					try {
+						if (!(await warm(url))) {
+							resolve(false)
+							return
+						}
+					} catch {
+						resolve(false)
+						return
+					}
+				}
+
+				if (--active === 0) {
+					resolve(true)
+				}
+			})()
+		}
+	})
+}

package/src/prefetch.web.test.ts

@@ -0,0 +1,105 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { prefetch } from './cache.web'
+import { prefetchBatch } from './prefetch-batch'
+
+// Web prefetch contract: a throwaway <img> per URL, the promise awaited until
+// load/error fires, false when any URL fails, and a JS-side concurrency cap —
+// the same contract @octane-xplat/gif's prefetch carries.
+
+class MockImage {
+	static instances: MockImage[] = []
+	onload: (() => void) | null = null
+	onerror: (() => void) | null = null
+	set src(_url: string) {
+		MockImage.instances.push(this)
+	}
+	load() {
+		this.onload?.()
+	}
+	fail() {
+		this.onerror?.()
+	}
+}
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0))
+
+async function drainPending(promise: Promise<boolean>) {
+	let result: boolean | undefined
+	void promise.then((value) => {
+		result = value
+	})
+
+	while (result === undefined) {
+		for (const image of MockImage.instances.splice(0)) {
+			image.load()
+		}
+
+		await flush()
+	}
+
+	return result
+}
+
+describe('prefetch (web)', () => {
+	afterEach(() => {
+		MockImage.instances = []
+		vi.unstubAllGlobals()
+	})
+
+	it('resolves true only after every <img> fires load', async () => {
+		vi.stubGlobal('Image', MockImage)
+		const promise = prefetch(['https://x/a.png', 'https://x/b.png'])
+		let settled = false
+		void promise.then(() => {
+			settled = true
+		})
+
+		await flush()
+		expect(settled).toBe(false) // bytes have not landed yet — honest await
+		expect(await drainPending(promise)).toBe(true)
+	})
+
+	it('resolves false when any URL fails', async () => {
+		vi.stubGlobal('Image', MockImage)
+		const promise = prefetch(['https://x/a.png', 'https://x/b.png'])
+		const [failed] = MockImage.instances.splice(0)
+		failed.fail()
+		expect(await promise).toBe(false)
+	})
+
+	it('accepts a single URL and resolves true for an empty batch', async () => {
+		vi.stubGlobal('Image', MockImage)
+		expect(await prefetch([])).toBe(true)
+		const promise = prefetch('https://x/a.png')
+		expect(MockImage.instances).toHaveLength(1)
+		expect(await drainPending(promise)).toBe(true)
+	})
+
+	it('caps in-flight loads at options.concurrency', async () => {
+		vi.stubGlobal('Image', MockImage)
+		const promise = prefetch(
+			Array.from({ length: 7 }, (_, i) => `https://x/${i}.png`),
+			{ concurrency: 2, headers: { Authorization: 'Bearer x' } },
+		)
+
+		expect(MockImage.instances).toHaveLength(2)
+		MockImage.instances.splice(0).forEach((image) => image.load())
+		await flush()
+		await flush()
+		expect(MockImage.instances.length).toBeLessThanOrEqual(2)
+		expect(await drainPending(promise)).toBe(true)
+	})
+
+	it('defaults to five parallel loads', async () => {
+		vi.stubGlobal('Image', MockImage)
+		const promise = prefetch(Array.from({ length: 9 }, (_, i) => `https://x/${i}.png`))
+		expect(MockImage.instances).toHaveLength(5)
+		expect(await drainPending(promise)).toBe(true)
+	})
+})
+
+describe('prefetchBatch', () => {
+	it('reports false if the warm callback throws', async () => {
+		expect(await prefetchBatch(['a', 'b'], 5, () => Promise.reject(new Error('boom')))).toBe(false)
+	})
+})

package/src/props.ts

@@ -0,0 +1,119 @@
+import type { ImageProps as CoreImageProps } from '@octane-xplat/ui';
+
+// The leaf's Image is a drop-in for `@octane-xplat/ui`'s Image — same name,
+// same props. The core contract types come straight from ui so the leaf can
+// never drift from them; swapping engines is an import-path change.
+export type {
+	ImageContentFit,
+	ImageContentPosition,
+	ImageContentPositionObject,
+	ImageContentPositionString,
+	ImageContentPositionValue,
+	ImageDecoding,
+	ImageSourceLike,
+} from '@octane-xplat/ui';
+
+/** How the engine's caches participate in a load. The plugin exposes a single
+ *  all-off switch (`noCache` → Glide `skipMemoryCache` + `DiskCacheStrategy.NONE`
+ *  on Android, `SDWebImageOptions.FromLoaderOnly` on iOS), so the only honest
+ *  non-default value is 'none'. 'memory'/'disk' splits are not representable
+ *  through the plugin's request options today. Ignored on web — browsers own
+ *  their HTTP cache. */
+export type ImageCachePolicy = 'memory-disk' | 'none'
+
+export interface ImageLoadEvent {
+	/** Decoded bitmap size in pixels. */
+	width: number
+	height: number
+	/** Where the engine served the image from. Absent on web — the browser
+	 *  does not report which cache (if any) satisfied an <img>. */
+	source?: 'network' | 'memory' | 'disk' | 'local'
+}
+
+export interface ImageErrorEvent {
+	error: Error
+}
+
+/** Cache sizing/eviction applied through `initializeImageCache`. Native only —
+ *  the web engine (browser HTTP cache) offers no equivalent knobs. */
+export interface ImageCacheConfig {
+	/** In-memory bitmap cache size in bytes (Android Glide). */
+	memoryCacheSize?: number
+	/** Size the memory cache as N fullscreen bitmaps (Android Glide). */
+	memoryCacheScreens?: number
+	/** Persist the cache-key registry across launches so evictions stay
+	 *  consistent (Android SharedPreferences store). */
+	persistentCacheKeys?: boolean
+	/** Bump to invalidate every cached entry — Glide `ObjectKey` signature. */
+	globalSignatureKey?: string
+	/** iOS: track transformed cache keys for eviction. Needed when decodeWidth/
+	 *  decodeHeight (or other transforms) are used alongside evictImage —
+	 *  transformed images key differently than the raw URL. */
+	iosComplexCacheEviction?: boolean
+}
+
+/** Result of `isImageCached`. 'none' also covers "unknown" — on web the
+ *  browser cache is not queryable, so web always reports 'none'. */
+export type ImageCacheState = 'memory' | 'disk' | 'none'
+
+/** Options for `prefetch` — the same contract `@octane-xplat/gif`'s
+ *  `prefetch` carries. */
+export interface PrefetchOptions {
+	/** Request headers forwarded on Android and iOS (the framework patch
+	 *  restores iOS request modifiers). Ignored on web — a plain <img>
+	 *  cannot send custom headers. */
+	headers?: Record<string, string>
+	/** Max URLs fetched in parallel (JS-side cap). Default 5 — the same
+	 *  ceiling NS core's ImageCache used. */
+	concurrency?: number
+}
+
+/** Display-load context for `isImageCached`. On iOS the engine folds the
+ *  transform a load used into the cache key — decode bounds are the common
+ *  one, and the leaf always decodes to a size (explicit props or the view's
+ *  measured size), so a bare probe misses entries a display load wrote.
+ *  Repeat the same decode bounds here to probe the key a display load hits.
+ *  Android keys probes on the URL alone and ignores these — but the plugin
+ *  cannot see Glide's active resources there, so a bitmap still on screen
+ *  may report 'none'. Web reports 'none' regardless. */
+export interface ImageCacheQueryOptions {
+	/** Device-pixel decode bounds — same meaning as the `Image` props. */
+	decodeWidth?: number
+	decodeHeight?: number
+}
+
+/** Image — drop-in alternative to `@octane-xplat/ui`'s Image backed by a real
+ *  image engine (Glide on Android, SDWebImage on iOS via
+ *  `@nativescript-community/ui-image`): sized in-memory bitmap cache, disk
+ *  cache, decode-to-view-size, placeholders and transitions. Web renders a
+ *  plain <img>. Every `@octane-xplat/ui` Image prop is accepted with the same
+ *  meaning — the members below are engine extensions with no core equivalent;
+ *  they are ignored on web. SVG `src` is the one behavioral gap — keep core
+ *  `Image` for those. One asymmetry: `decoding='sync'` is not honorably
+ *  supported — Glide/SDWebImage have no synchronous decode mode (the plugin's
+ *  `loadMode` prop is registered but never read), so 'sync' degrades to
+ *  async on native with a console warning rather than a fake. */
+export interface ImageProps extends CoreImageProps {
+	/** Native only — 'none' bypasses memory and disk caches for this image.
+	 *  Default 'memory-disk' leaves both caches active. */
+	cachePolicy?: ImageCachePolicy
+	/** Native only — image shown when `src` fails (`failureImageUri`). */
+	failureImage?: string
+	/** Native only — extra HTTP headers for the request (authenticated URLs). */
+	headers?: Record<string, string>
+	/** Native only — explicit decode bounds in device pixels. Default is the
+	 *  view's laid-out size (the src is held until first layout so the engine
+	 *  never decodes at full source resolution). */
+	decodeWidth?: number
+	decodeHeight?: number
+	/** Native only — progressive/interlaced rendering while bytes stream. */
+	progressive?: boolean
+	/** Native only — crossfade duration in ms when the image lands (0
+	 *  disables; engine default applies when unset). */
+	fadeDuration?: number
+	/** Fired when the final image is set. `source` reports which cache level
+	 *  served the bitmap — native only; web fires without `source`. */
+	onLoad?: (event: ImageLoadEvent) => void
+	/** Fired when the load fails. */
+	onError?: (event: ImageErrorEvent) => void
+}

package/types/generated/.tsrx-typegen-manifest.json

@@ -0,0 +1,16 @@
+{
+  "version": 1,
+  "files": [
+    "Image.d.ts",
+    "Image.web.d.ts",
+    "cache.d.ts",
+    "cache.web.d.ts",
+    "hash-image.d.ts",
+    "image-binding.d.ts",
+    "image-content.d.ts",
+    "index.d.ts",
+    "index.web.d.ts",
+    "prefetch-batch.d.ts",
+    "props.d.ts"
+  ]
+}