Upload folder using huggingface_hub

6.26.0/gallery/Example.svelte

@@ -0,0 +1,149 @@
+<script lang="ts">
+	import type { GalleryImage, GalleryVideo } from "./types";
+
+	let {
+		value,
+		type,
+		selected = false
+	}: {
+		value: (GalleryImage | GalleryVideo)[] | null;
+		type: "gallery" | "table";
+		selected?: boolean;
+	} = $props();
+</script>
+
+<div
+	class="container"
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	{#if value && value.length > 0}
+		<div class="images-wrapper">
+			{#each value.slice(0, 3) as item}
+				{#if "image" in item && item.image}
+					<div class="image-container">
+						<img src={item.image.url} alt={item.caption || ""} />
+						{#if item.caption}
+							<span class="caption">{item.caption}</span>
+						{/if}
+					</div>
+				{:else if "video" in item && item.video}
+					<div class="image-container">
+						<video
+							src={item.video.url}
+							controls={false}
+							muted
+							preload="metadata"
+						/>
+						{#if item.caption}
+							<span class="caption">{item.caption}</span>
+						{/if}
+					</div>
+				{/if}
+			{/each}
+			{#if value.length > 3}
+				<div class="more-indicator">…</div>
+			{/if}
+		</div>
+	{/if}
+</div>
+
+<style>
+	.container {
+		border-radius: var(--radius-lg);
+		overflow: hidden;
+	}
+
+	.container.selected {
+		border: 2px solid var(--border-color-accent);
+	}
+
+	.images-wrapper {
+		display: flex;
+		gap: var(--spacing-sm);
+	}
+
+	.container.table .images-wrapper {
+		flex-direction: row;
+		align-items: center;
+		padding: var(--spacing-sm);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-lg);
+		background: var(--background-fill-secondary);
+	}
+
+	.container.gallery .images-wrapper {
+		flex-direction: row;
+		gap: 0;
+	}
+
+	.image-container {
+		position: relative;
+		flex-shrink: 0;
+	}
+
+	.container.table .image-container {
+		width: var(--size-12);
+		height: var(--size-12);
+	}
+
+	.container.gallery .image-container {
+		width: var(--size-20);
+		height: var(--size-20);
+		margin-left: calc(-1 * var(--size-8));
+	}
+
+	.container.gallery .image-container:first-child {
+		margin-left: 0;
+	}
+
+	.more-indicator {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		font-size: var(--text-lg);
+		font-weight: bold;
+		color: var(--border-color-primary);
+	}
+
+	.container.table .more-indicator {
+		width: var(--size-12);
+		height: var(--size-12);
+	}
+
+	.container.gallery .more-indicator {
+		width: var(--size-20);
+		height: var(--size-20);
+		margin-left: calc(-1 * var(--size-8));
+		margin-right: calc(-1 * var(--size-6));
+	}
+
+	.image-container img,
+	.image-container video {
+		width: 100%;
+		height: 100%;
+		object-fit: cover;
+		border-radius: var(--radius-md);
+	}
+
+	.caption {
+		position: absolute;
+		bottom: 0;
+		left: 0;
+		right: 0;
+		background: rgba(0, 0, 0, 0.7);
+		color: white;
+		padding: var(--spacing-xs);
+		font-size: var(--text-xs);
+		text-align: center;
+		border-radius: 0 0 var(--radius-md) var(--radius-md);
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.container.table .caption {
+		display: none;
+	}
+</style>

6.26.0/gallery/Index.svelte

@@ -0,0 +1,329 @@
+<script module lang="ts">
+	export { default as BaseGallery } from "./shared/Gallery.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import { tick } from "svelte";
+	import type { FileData } from "@gradio/client";
+	import { Block, UploadText, SelectSource } from "@gradio/atoms";
+	import Gallery from "./shared/Gallery.svelte";
+	import { StatusTracker } from "@gradio/statustracker";
+	import { Gradio } from "@gradio/utils";
+	import { BaseFileUpload } from "@gradio/file";
+	import { Webcam } from "@gradio/image";
+	import type { GalleryProps, GalleryEvents, GalleryData } from "./types";
+	import { handle_save } from "./shared/utils";
+
+	let upload_promise = $state<Promise<(FileData | null)[]>>();
+
+	class GalleryGradio extends Gradio<GalleryEvents, GalleryProps> {
+		async get_data() {
+			if (upload_promise) {
+				await upload_promise;
+				await tick();
+			}
+			const data = await super.get_data();
+
+			return data;
+		}
+	}
+
+	const props = $props();
+	const gradio = new GalleryGradio(props, {
+		selected_index: null,
+		file_types: ["image", "video"]
+	});
+
+	let fullscreen = $state(false);
+
+	function handle_delete(data: { file: FileData; index: number }): void {
+		if (!gradio.props.value) return;
+		const { index } = data;
+		gradio.dispatch("delete", data);
+		gradio.props.value = gradio.props.value.filter((_, i) => i !== index);
+		gradio.dispatch("change", gradio.props.value);
+	}
+
+	async function process_upload_files(
+		files: FileData[]
+	): Promise<GalleryData[]> {
+		const processed_files = await Promise.all(
+			files.map(async (x) => {
+				if (x.path?.toLowerCase().endsWith(".svg") && x.url) {
+					const response = await fetch(x.url);
+					const svgContent = await response.text();
+					return {
+						...x,
+						url: `data:image/svg+xml,${encodeURIComponent(svgContent)}`
+					};
+				}
+				return x;
+			})
+		);
+
+		return processed_files.map((x) =>
+			x.mime_type?.includes("video")
+				? { video: x, caption: null }
+				: { image: x, caption: null }
+		);
+	}
+
+	let upload_input: BaseFileUpload;
+
+	let active_source = $state<
+		"upload" | "webcam" | "webcam-video" | "clipboard" | null
+	>(gradio.props.sources ? gradio.props.sources[0] : "upload");
+
+	let no_value = $derived(
+		gradio.props.value === null ? true : gradio.props.value.length === 0
+	);
+
+	let sources = $derived.by(() => {
+		if (
+			gradio.props.file_types?.includes("video") &&
+			gradio.props.sources.includes("webcam")
+		) {
+			return gradio.props.sources.concat(["webcam-video"]);
+		} else {
+			return gradio.props.sources;
+		}
+	});
+
+	async function paste_clipboard(): Promise<void> {
+		navigator.clipboard.read().then(async (items) => {
+			let file: File | null = null;
+			for (let i = 0; i < items.length; i++) {
+				const type = items[i].types.find((t) =>
+					(gradio.props.file_types || ["image"]).some((ft) =>
+						t.startsWith(ft + "/")
+					)
+				);
+				if (type) {
+					const blob = await items[i].getType(type);
+					file = new File([blob], `clipboard.${type.replace("image/", "")}`);
+					break;
+				}
+			}
+			if (file) {
+				const f = await handle_save(
+					file,
+					(f) => gradio.shared.client.upload(f, gradio.shared.root),
+					"clipboard_upload"
+				);
+				const processed_files = await process_upload_files(f);
+				gradio.props.value?.push(...processed_files);
+				gradio.dispatch("change", gradio.props.value);
+				active_source = null;
+			} else {
+				gradio.dispatch("warning", "No image or video found in clipboard");
+			}
+		});
+	}
+
+	async function handle_select_source(
+		source: "upload" | "webcam" | "clipboard"
+	): Promise<void> {
+		switch (source) {
+			case "clipboard":
+				await paste_clipboard();
+				break;
+			default:
+				break;
+		}
+	}
+
+	async function onsource_change(
+		source: "upload" | "webcam" | "webcam-video" | "clipboard"
+	): Promise<void> {
+		await tick();
+		if (source === "clipboard") {
+			await paste_clipboard();
+		} else {
+			active_source = source;
+			no_value = true;
+		}
+	}
+</script>
+
+<Block
+	visible={gradio.shared.visible}
+	variant="solid"
+	padding={false}
+	elem_id={gradio.shared.elem_id}
+	elem_classes={gradio.shared.elem_classes}
+	container={gradio.shared.container}
+	scale={gradio.shared.scale}
+	min_width={gradio.shared.min_width}
+	allow_overflow={false}
+	height={gradio.props.height || undefined}
+	bind:fullscreen
+>
+	<StatusTracker
+		autoscroll={gradio.shared.autoscroll}
+		i18n={gradio.i18n}
+		{...gradio.shared.loading_status}
+		on_clear_status={() =>
+			gradio.dispatch("clear_status", gradio.shared.loading_status)}
+	/>
+	{#if gradio.shared.interactive && no_value}
+		<div
+			class={!gradio.props.value ||
+			(active_source && active_source.includes("webcam"))
+				? "hidden-upload-input"
+				: "upload-wrapper"}
+		>
+			<BaseFileUpload
+				bind:upload_promise
+				bind:this={upload_input}
+				value={null}
+				root={gradio.shared.root}
+				label={gradio.shared.label}
+				max_file_size={gradio.shared.max_file_size}
+				file_count={"multiple"}
+				file_types={gradio.props.file_types}
+				i18n={gradio.i18n}
+				upload={(...args) => gradio.shared.client.upload(...args)}
+				stream_handler={(...args) => gradio.shared.client.stream(...args)}
+				onupload={async (e) => {
+					const files = Array.isArray(e) ? e : [e];
+					gradio.props.value = await process_upload_files(files);
+					active_source = null;
+					gradio.dispatch("upload", gradio.props.value);
+					gradio.dispatch("change", gradio.props.value);
+				}}
+				onerror={(detail) => {
+					gradio.shared.loading_status = gradio.shared.loading_status || {};
+					gradio.shared.loading_status.status = "error";
+					gradio.dispatch("error", detail);
+				}}
+			>
+				<UploadText i18n={gradio.i18n} type="gallery" />
+			</BaseFileUpload>
+		</div>
+		{#if active_source === "webcam"}
+			<Webcam
+				root={gradio.shared.root}
+				value={null}
+				oncapture={async (detail) => {
+					if (!(detail instanceof Blob)) return;
+					const f = await handle_save(
+						detail,
+						(f) => gradio.shared.client.upload(f, gradio.shared.root),
+						"webcam_upload"
+					);
+					const processed_files = await process_upload_files(f);
+					gradio.props.value?.push(...processed_files);
+					active_source = null;
+					gradio.dispatch("change", gradio.props.value);
+				}}
+				mirror_webcam={true}
+				streaming={false}
+				mode="image"
+				include_audio={false}
+				i18n={gradio.i18n}
+				upload={(...args) => gradio.shared.client.upload(...args)}
+			/>
+		{:else if active_source === "webcam-video"}
+			<Webcam
+				root={gradio.shared.root}
+				value={null}
+				oncapture={async (detail) => {
+					if (!detail) return;
+					const f = { ...(detail as FileData) };
+					f.mime_type = "video/webm";
+					const processed_files = await process_upload_files([f]);
+					gradio.props.value?.push(...processed_files);
+					active_source = null;
+					gradio.dispatch("change", gradio.props.value);
+				}}
+				mirror_webcam={true}
+				streaming={false}
+				mode="video"
+				include_audio={false}
+				i18n={gradio.i18n}
+				upload={(...args) => gradio.shared.client.upload(...args)}
+			/>
+		{/if}
+		{#if sources.length > 1 || sources.includes("clipboard")}
+			<SelectSource
+				{sources}
+				bind:active_source
+				handle_clear={() => gradio.dispatch("clear")}
+				handle_select={(source) => handle_select_source(source as any)}
+			/>
+		{/if}
+	{:else}
+		<Gallery
+			onchange={() => gradio.dispatch("change")}
+			onclear={() => gradio.dispatch("change")}
+			onselect={(e) => gradio.dispatch("select", e)}
+			onshare={(e) => gradio.dispatch("share", e.detail)}
+			onerror={(e) => gradio.dispatch("error", e.detail)}
+			onpreview_open={() => {
+				gradio.dispatch("preview_open");
+			}}
+			onpreview_close={() => gradio.dispatch("preview_close")}
+			onfullscreen={({ detail }) => {
+				fullscreen = detail;
+			}}
+			ondelete={handle_delete}
+			onupload={async (e) => {
+				const files = Array.isArray(e) ? e : [e];
+				const new_value = await process_upload_files(files);
+				gradio.props.value = gradio.props.value
+					? [...gradio.props.value, ...new_value]
+					: new_value;
+				gradio.dispatch("upload", new_value);
+				gradio.dispatch("change", gradio.props.value);
+			}}
+			{sources}
+			onsource_change={(source) => onsource_change(source as any)}
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			columns={gradio.props.columns}
+			rows={gradio.props.rows}
+			height={gradio.props.height}
+			preview={gradio.props.preview}
+			object_fit={gradio.props.object_fit}
+			interactive={gradio.shared.interactive}
+			allow_preview={gradio.props.allow_preview}
+			bind:selected_index={gradio.props.selected_index}
+			bind:value={gradio.props.value}
+			show_share_button={gradio.props.buttons.some(
+				(btn) => typeof btn === "string" && btn === "share"
+			)}
+			show_download_button={gradio.props.buttons.some(
+				(btn) => typeof btn === "string" && btn === "download"
+			)}
+			show_download_all_button={gradio.props.buttons.some(
+				(btn) => typeof btn === "string" && btn === "download_all"
+			)}
+			fit_columns={gradio.props.fit_columns}
+			i18n={gradio.i18n}
+			_fetch={(...args) => gradio.shared.client.fetch(...args)}
+			show_fullscreen_button={gradio.props.buttons.some(
+				(btn) => typeof btn === "string" && btn === "fullscreen"
+			)}
+			buttons={gradio.props.buttons}
+			oncustom_button_click={(id) => {
+				gradio.dispatch("custom_button_click", { id });
+			}}
+			{fullscreen}
+			root={gradio.shared.root}
+			file_types={gradio.props.file_types}
+			max_file_size={gradio.shared.max_file_size}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+			stream_handler={(...args) => gradio.shared.client.stream(...args)}
+		/>
+	{/if}
+</Block>
+
+<style>
+	.hidden-upload-input {
+		display: none;
+	}
+	.upload-wrapper {
+		height: 100%;
+	}
+</style>

6.26.0/gallery/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "@gradio/gallery",
+	"version": "0.19.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/file": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/image": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@gradio/video": "workspace:^",
+		"dequal": "^2.0.3"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main": "./Index.svelte",
+	"main_changeset": true,
+	"exports": {
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		},
+		"./package.json": "./package.json",
+		"./base": {
+			"gradio": "./shared/Gallery.svelte",
+			"svelte": "./dist/shared/Gallery.svelte",
+			"types": "./dist/shared/Gallery.svelte.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/gallery"
+	}
+}

6.26.0/gallery/shared/Gallery.svelte

@@ -0,0 +1,1131 @@
+<script lang="ts">
+	import {
+		BlockLabel,
+		Empty,
+		ShareButton,
+		IconButton,
+		IconButtonWrapper,
+		FullscreenButton
+	} from "@gradio/atoms";
+	import { type CustomButton as CustomButtonType } from "@gradio/utils";
+	import { ModifyUpload, Upload as UploadComponent } from "@gradio/upload";
+	import { Image } from "@gradio/image/shared";
+	import { Video } from "@gradio/video/shared";
+	import { dequal } from "dequal";
+	import { onMount } from "svelte";
+	import { tick } from "svelte";
+	import type { GalleryImage, GalleryVideo } from "../types";
+
+	import {
+		Download,
+		DownloadAll,
+		Image as ImageIcon,
+		Clear,
+		Play,
+		Upload as UploadIcon,
+		Webcam,
+		Video as VideoIcon,
+		ImagePaste
+	} from "@gradio/icons";
+	import { FileData } from "@gradio/client";
+	import type { Client } from "@gradio/client";
+	import { format_gallery_for_sharing } from "./utils";
+	import type { I18nFormatter } from "@gradio/utils";
+
+	type GalleryData = GalleryImage | GalleryVideo;
+
+	let {
+		show_label = true,
+		label,
+		value = $bindable(),
+		columns = [2],
+		rows = undefined,
+		height = "auto",
+		preview,
+		allow_preview = true,
+		object_fit = "cover",
+		show_share_button = false,
+		show_download_button = false,
+		show_download_all_button = false,
+		i18n,
+		selected_index = $bindable(),
+		interactive,
+		_fetch,
+		show_fullscreen_button = true,
+		fullscreen = false,
+		root = "",
+		file_types = ["image", "video"],
+		sources,
+		max_file_size = null,
+		upload,
+		stream_handler,
+		fit_columns = true,
+		buttons = null,
+		oncustom_button_click = null,
+		onpreview_open = () => {},
+		onchange = () => {},
+		onclear = () => {},
+		onselect = (data) => {},
+		onshare = (data) => {},
+		onerror = (error) => {},
+		onpreview_close = () => {},
+		onfullscreen = (data) => {},
+		ondelete = () => {},
+		onupload = () => {},
+		onsource_change = () => {}
+	}: {
+		show_label: boolean;
+		label: string;
+		value: GalleryData[] | null;
+		columns: number | number[] | undefined;
+		rows: number | number[] | undefined;
+		height: number | string;
+		preview: boolean;
+		allow_preview: boolean;
+		object_fit: "contain" | "cover" | "fill" | "none" | "scale-down";
+		show_share_button: boolean;
+		show_download_button: boolean;
+		show_download_all_button: boolean;
+		i18n: I18nFormatter;
+		selected_index: number | null;
+		interactive: boolean;
+		_fetch: typeof fetch;
+		show_fullscreen_button: boolean;
+		fullscreen: boolean;
+		root: string;
+		file_types: string[] | null;
+		sources: ("upload" | "webcam" | "clipboard" | "webcam-video")[];
+		max_file_size: number | null;
+		upload: Client["upload"] | undefined;
+		stream_handler: Client["stream"] | undefined;
+		fit_columns: boolean;
+		buttons: (string | CustomButtonType)[] | null;
+		oncustom_button_click: ((id: number) => void) | null;
+		onpreview_open: () => void;
+		onchange: () => void;
+		onclear: () => void;
+		onselect: (data: any) => void;
+		onshare: (data: any) => void;
+		onerror: (error: any) => void;
+		onpreview_close: () => void;
+		onfullscreen: (data: any) => void;
+		ondelete: (data: any) => void;
+		onupload: (data: FileData | FileData[]) => void;
+		onsource_change: (source: string) => void;
+	} = $props();
+
+	let upload_promise: Promise<any> | null = null;
+	let mode = $state<"normal" | "minimal">("normal");
+	let display_icon_button_wrapper_top_corner = false;
+	let is_full_screen = false;
+	let image_container: HTMLElement;
+
+	let was_reset: boolean = $state(false);
+
+	let resolved_value = $derived.by(() =>
+		value == null
+			? null
+			: (value.map((data) => {
+					if ("video" in data) {
+						return {
+							video: data.video as FileData,
+							caption: data.caption
+						};
+					} else if ("image" in data) {
+						return { image: data.image as FileData, caption: data.caption };
+					}
+					return {};
+				}) as GalleryData[])
+	);
+
+	function resolve_effective_columns(
+		resolved_value: GalleryData[] | null,
+		columns: number | number[] | undefined,
+		fit_columns: boolean
+	) {
+		if (resolved_value && columns && fit_columns) {
+			const item_count = resolved_value.length;
+			if (Array.isArray(columns)) {
+				return columns.map((col) => Math.min(col, item_count));
+			} else {
+				return Math.min(columns, item_count);
+			}
+		} else {
+			return columns;
+		}
+	}
+
+	let effective_columns: number | number[] | undefined = $derived.by(() =>
+		resolve_effective_columns(resolved_value, columns, fit_columns)
+	);
+
+	let prev_value: GalleryData[] | null = $state(value);
+	if (selected_index == null && preview && value?.length) {
+		selected_index = 0;
+	}
+
+	$effect(() => {
+		if (!dequal(prev_value, value)) {
+			// When value is falsy (clear button or first load),
+			// preview determines the selected image
+			if (was_reset) {
+				selected_index = preview && value?.length ? 0 : null;
+				was_reset = false;
+				// Otherwise we keep the selected_index the same if the
+				// gallery has at least as many elements as it did before
+			} else {
+				if (selected_index !== null && value !== null) {
+					selected_index = Math.max(
+						0,
+						Math.min(selected_index, value.length - 1)
+					);
+				} else {
+					selected_index = null;
+				}
+			}
+			onchange();
+			prev_value = value;
+		}
+	});
+
+	let previous = $derived.by(
+		() =>
+			((selected_index ?? 0) + (resolved_value?.length ?? 0) - 1) %
+			(resolved_value?.length ?? 0)
+	);
+	let next = $derived.by(
+		() => ((selected_index ?? 0) + 1) % (resolved_value?.length ?? 0)
+	);
+
+	function dispatch_select(index: number): void {
+		if (resolved_value !== null) {
+			onselect({
+				index,
+				value: resolved_value?.[index]
+			});
+		}
+	}
+
+	function handle_preview_click(event: MouseEvent): void {
+		const element = event.target as HTMLElement;
+		const x = event.offsetX;
+		const width = element.offsetWidth;
+		const centerX = width / 2;
+
+		if (x < centerX) {
+			selected_index = previous;
+		} else {
+			selected_index = next;
+		}
+		dispatch_select(selected_index);
+	}
+
+	function on_keydown(e: KeyboardEvent): void {
+		switch (e.code) {
+			case "Escape":
+				e.preventDefault();
+				selected_index = null;
+				onpreview_close();
+				break;
+			case "ArrowLeft":
+				e.preventDefault();
+				selected_index = previous;
+				dispatch_select(selected_index);
+				break;
+			case "ArrowRight":
+				e.preventDefault();
+				selected_index = next;
+				dispatch_select(selected_index);
+				break;
+			default:
+				break;
+		}
+	}
+
+	$effect(() => {
+		if (allow_preview && container_element) {
+			scroll_to_img(selected_index);
+		}
+	});
+
+	let el: HTMLButtonElement[] = [];
+	let container_element: HTMLDivElement | undefined = $state();
+
+	async function scroll_to_img(index: number | null): Promise<void> {
+		if (typeof index !== "number") return;
+		await tick();
+
+		if (el[index] === undefined) return;
+		if (!container_element) return;
+
+		el[index]?.focus();
+
+		const { left: container_left, width: container_width } =
+			container_element.getBoundingClientRect();
+		const { left, width } = el[index].getBoundingClientRect();
+
+		const relative_left = left - container_left;
+
+		const pos =
+			relative_left +
+			width / 2 -
+			container_width / 2 +
+			container_element.scrollLeft;
+
+		if (container_element && typeof container_element.scrollTo === "function") {
+			container_element.scrollTo({
+				left: pos < 0 ? 0 : pos,
+				behavior: "smooth"
+			});
+		}
+	}
+
+	let window_height = 0;
+
+	// Unlike `gr.Image()`, images specified via remote URLs are not cached in the server
+	// and their remote URLs are directly passed to the client as `value[].image.url`.
+	// The `download` attribute of the <a> tag doesn't work for remote URLs (https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#download),
+	// so we need to download the image via JS as below.
+	async function download(file_url: string, name: string): Promise<void> {
+		let response;
+		try {
+			response = await _fetch(file_url);
+		} catch (error) {
+			if (error instanceof TypeError) {
+				// If CORS is not allowed (https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#checking_that_the_fetch_was_successful),
+				// open the link in a new tab instead, mimicing the behavior of the `download` attribute for remote URLs,
+				// which is not ideal, but a reasonable fallback.
+				window.open(file_url, "_blank", "noreferrer");
+				return;
+			}
+
+			throw error;
+		}
+		const blob = await response.blob();
+		const url = URL.createObjectURL(blob);
+		const link = document.createElement("a");
+		link.href = url;
+		link.download = name;
+		link.click();
+		URL.revokeObjectURL(url);
+	}
+
+	const crc_table = new Uint32Array(
+		Array.from({ length: 256 }, (_, i) => {
+			let c = i;
+			for (let k = 0; k < 8; k++) {
+				c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+			}
+			return c >>> 0;
+		})
+	);
+
+	function crc32(data: Uint8Array): number {
+		let c = 0xffffffff;
+		for (const byte of data) {
+			c = crc_table[(c ^ byte) & 0xff] ^ (c >>> 8);
+		}
+		return (c ^ 0xffffffff) >>> 0;
+	}
+
+	function write_uint16(view: DataView, offset: number, value: number): void {
+		view.setUint16(offset, value, true);
+	}
+
+	function write_uint32(view: DataView, offset: number, value: number): void {
+		view.setUint32(offset, value, true);
+	}
+
+	function zip_header(size: number): Uint8Array {
+		return new Uint8Array(size);
+	}
+
+	function get_unique_name(
+		file: FileData,
+		fallback: string,
+		used_names: Map<string, number>
+	): string {
+		const raw_name = file.orig_name || file.path || fallback;
+		const name = raw_name.split(/[/\\]/).pop() || fallback;
+		const count = used_names.get(name) ?? 0;
+		used_names.set(name, count + 1);
+		if (count === 0) return name;
+
+		const dot_index = name.lastIndexOf(".");
+		const base = dot_index > 0 ? name.slice(0, dot_index) : name;
+		const ext = dot_index > 0 ? name.slice(dot_index) : "";
+		return `${base}-${count + 1}${ext}`;
+	}
+
+	function create_zip(files: { name: string; data: Uint8Array }[]): Uint8Array {
+		const encoder = new TextEncoder();
+		const parts: Uint8Array[] = [];
+		const central_parts: Uint8Array[] = [];
+		const utf8_flag = 0x0800;
+		let offset = 0;
+
+		for (const file of files) {
+			const name = encoder.encode(file.name);
+			const checksum = crc32(file.data);
+			const local_header = zip_header(30 + name.length);
+			const local_view = new DataView(local_header.buffer);
+			write_uint32(local_view, 0, 0x04034b50);
+			write_uint16(local_view, 4, 20);
+			write_uint16(local_view, 6, utf8_flag);
+			write_uint16(local_view, 8, 0);
+			write_uint16(local_view, 10, 0);
+			write_uint16(local_view, 12, 33);
+			write_uint32(local_view, 14, checksum);
+			write_uint32(local_view, 18, file.data.length);
+			write_uint32(local_view, 22, file.data.length);
+			write_uint16(local_view, 26, name.length);
+			write_uint16(local_view, 28, 0);
+			local_header.set(name, 30);
+			parts.push(local_header, file.data);
+
+			const central_header = zip_header(46 + name.length);
+			const central_view = new DataView(central_header.buffer);
+			write_uint32(central_view, 0, 0x02014b50);
+			write_uint16(central_view, 4, 20);
+			write_uint16(central_view, 6, 20);
+			write_uint16(central_view, 8, utf8_flag);
+			write_uint16(central_view, 10, 0);
+			write_uint16(central_view, 12, 0);
+			write_uint16(central_view, 14, 33);
+			write_uint32(central_view, 16, checksum);
+			write_uint32(central_view, 20, file.data.length);
+			write_uint32(central_view, 24, file.data.length);
+			write_uint16(central_view, 28, name.length);
+			write_uint16(central_view, 30, 0);
+			write_uint16(central_view, 32, 0);
+			write_uint16(central_view, 34, 0);
+			write_uint16(central_view, 36, 0);
+			write_uint32(central_view, 38, 0);
+			write_uint32(central_view, 42, offset);
+			central_header.set(name, 46);
+			central_parts.push(central_header);
+
+			offset += local_header.length + file.data.length;
+		}
+
+		const central_offset = offset;
+		const central_size = central_parts.reduce(
+			(sum, part) => sum + part.length,
+			0
+		);
+		const end = zip_header(22);
+		const end_view = new DataView(end.buffer);
+		write_uint32(end_view, 0, 0x06054b50);
+		write_uint16(end_view, 4, 0);
+		write_uint16(end_view, 6, 0);
+		write_uint16(end_view, 8, files.length);
+		write_uint16(end_view, 10, files.length);
+		write_uint32(end_view, 12, central_size);
+		write_uint32(end_view, 16, central_offset);
+		write_uint16(end_view, 20, 0);
+
+		const zip = new Uint8Array(central_offset + central_size + end.length);
+		let cursor = 0;
+		for (const part of [...parts, ...central_parts, end]) {
+			zip.set(part, cursor);
+			cursor += part.length;
+		}
+		return zip;
+	}
+
+	async function get_zip_file(
+		url: string,
+		name: string
+	): Promise<{ name: string; data: Uint8Array } | null> {
+		let response;
+		try {
+			response = await _fetch(url);
+		} catch (error) {
+			if (error instanceof TypeError) {
+				window.open(url, "_blank", "noreferrer");
+			}
+			return null;
+		}
+		if (!response.ok) return null;
+		return {
+			name,
+			data: new Uint8Array(await response.arrayBuffer())
+		};
+	}
+
+	async function download_all(media: GalleryData[]): Promise<void> {
+		const used_names = new Map<string, number>();
+		const files = await Promise.all(
+			media.flatMap((item, index) => {
+				const file = "image" in item ? item.image : item.video;
+				const fallback =
+					"image" in item ? `image-${index + 1}` : `video-${index + 1}`;
+				if (!file.url) return [];
+				const name = get_unique_name(file, fallback, used_names);
+				return [get_zip_file(file.url, name)];
+			})
+		);
+		const valid_files = files.filter(
+			(file): file is { name: string; data: Uint8Array } => file !== null
+		);
+
+		if (valid_files.length === 0) return;
+
+		const zip = create_zip(valid_files);
+		const url = URL.createObjectURL(
+			new Blob([zip.buffer as ArrayBuffer], { type: "application/zip" })
+		);
+		const link = document.createElement("a");
+		link.href = url;
+		link.download = "gallery.zip";
+		link.click();
+		URL.revokeObjectURL(url);
+	}
+
+	function handle_download_all(): void {
+		if (resolved_value) {
+			download_all(resolved_value);
+		}
+	}
+
+	let selected_media = $derived.by(() =>
+		selected_index != null && resolved_value != null
+			? resolved_value[selected_index]
+			: null
+	);
+
+	let thumbnails_overflow = false;
+
+	function check_thumbnails_overflow(): void {
+		if (container_element) {
+			thumbnails_overflow =
+				container_element.scrollWidth > container_element.clientWidth;
+		}
+	}
+
+	onMount(() => {
+		check_thumbnails_overflow();
+		document.addEventListener("fullscreenchange", () => {
+			is_full_screen = !!document.fullscreenElement;
+		});
+		window.addEventListener("resize", check_thumbnails_overflow);
+		return () =>
+			window.removeEventListener("resize", check_thumbnails_overflow);
+	});
+
+	$effect(() => {
+		resolved_value;
+		check_thumbnails_overflow();
+		if (container_element) {
+			check_thumbnails_overflow();
+		}
+	});
+
+	function handle_item_delete(index: number): void {
+		if (!value || !resolved_value) return;
+
+		const deleted_item = resolved_value[index];
+		let deleted_file_data;
+
+		if ("image" in deleted_item) {
+			deleted_file_data = {
+				file: deleted_item.image,
+				index: index
+			};
+		} else if ("video" in deleted_item) {
+			deleted_file_data = {
+				file: deleted_item.video,
+				index: index
+			};
+		}
+
+		if (deleted_file_data) {
+			ondelete(deleted_file_data);
+		}
+	}
+
+	let uploading = false;
+</script>
+
+<svelte:window bind:innerHeight={window_height} />
+
+{#if show_label}
+	<BlockLabel {show_label} Icon={ImageIcon} label={label || "Gallery"} />
+{/if}
+{#if value == null || resolved_value == null || resolved_value.length === 0}
+	<Empty unpadded_box={true} size="large"><ImageIcon /></Empty>
+{:else}
+	<div class="gallery-container" bind:this={image_container}>
+		{#if selected_media && allow_preview}
+			<span
+				onkeydown={on_keydown}
+				class="preview"
+				class:minimal={mode === "minimal"}
+			>
+				<IconButtonWrapper
+					display_top_corner={display_icon_button_wrapper_top_corner}
+					{buttons}
+					on_custom_button_click={oncustom_button_click}
+				>
+					{#if show_download_button}
+						<IconButton
+							Icon={Download}
+							label={i18n("common.download")}
+							onclick={() => {
+								const image =
+									"image" in selected_media
+										? selected_media?.image
+										: selected_media?.video;
+								if (image == null) {
+									return;
+								}
+								const { url, orig_name } = image;
+								if (url) {
+									download(url, orig_name ?? "image");
+								}
+							}}
+						/>
+					{/if}
+
+					{#if show_fullscreen_button}
+						<FullscreenButton
+							{fullscreen}
+							onclick={(is_fullscreen) =>
+								onfullscreen({ detail: is_fullscreen })}
+						/>
+					{/if}
+
+					{#if show_share_button}
+						<div class="icon-button">
+							<ShareButton
+								{i18n}
+								onshare={(detail) => {
+									onshare({ detail } as CustomEvent);
+								}}
+								onerror={(detail) => {
+									onerror({ detail } as CustomEvent);
+								}}
+								value={resolved_value}
+								formatter={format_gallery_for_sharing}
+							/>
+						</div>
+					{/if}
+					{#if !is_full_screen}
+						<IconButton
+							Icon={Clear}
+							label="Close"
+							onclick={() => {
+								selected_index = null;
+								onpreview_close();
+							}}
+						/>
+					{/if}
+				</IconButtonWrapper>
+				<button
+					class="media-button"
+					onclick={"image" in selected_media
+						? (event) => handle_preview_click(event)
+						: null}
+					style="height: calc(100% - {selected_media.caption
+						? '80px'
+						: '60px'})"
+					aria-label="detailed view of selected image"
+				>
+					{#if "image" in selected_media}
+						<Image
+							restProps={{
+								alt: selected_media.caption || "",
+								title: selected_media.caption || null,
+								class: selected_media.caption && "with-caption",
+								loading: "lazy"
+							}}
+							src={selected_media.image.url}
+							data_testid="detailed-image"
+						/>
+					{:else}
+						<Video
+							src={selected_media.video.url}
+							data-testid={"detailed-video"}
+							alt={selected_media.caption || ""}
+							loading="lazy"
+							loop={false}
+							is_stream={false}
+							muted={false}
+							controls={true}
+						/>
+					{/if}
+				</button>
+				{#if selected_media?.caption}
+					<caption class="caption">
+						{selected_media.caption}
+					</caption>
+				{/if}
+				<div
+					bind:this={container_element}
+					class="thumbnails scroll-hide"
+					data-testid="container_el"
+					style="justify-content: {thumbnails_overflow
+						? 'flex-start'
+						: 'center'};"
+				>
+					{#each resolved_value as media, i}
+						<button
+							bind:this={el[i]}
+							onclick={() => {
+								selected_index = i;
+								dispatch_select(i);
+							}}
+							class="thumbnail-item thumbnail-small"
+							class:selected={selected_index === i && mode !== "minimal"}
+							aria-label={"Thumbnail " +
+								(i + 1) +
+								" of " +
+								resolved_value.length}
+						>
+							{#if "image" in media}
+								<Image
+									src={media.image.url}
+									restProps={{
+										title: media.caption || null,
+										alt: "",
+										class: "with-caption",
+										loading: "lazy"
+									}}
+									data_testid={`thumbnail ${i + 1}`}
+								/>
+							{:else}
+								<Play />
+								<Video
+									src={media.video.url}
+									title={media.caption || null}
+									is_stream={false}
+									data-testid={"thumbnail " + (i + 1)}
+									alt=""
+									loading="lazy"
+									loop={false}
+								/>
+							{/if}
+						</button>
+					{/each}
+				</div>
+			</span>
+		{/if}
+
+		<div
+			class="grid-wrap"
+			class:minimal={mode === "minimal"}
+			class:fixed-height={mode !== "minimal" && (!height || height == "auto")}
+			class:hidden={is_full_screen}
+			style:height={height !== "auto"
+				? typeof height === "number"
+					? height + "px"
+					: height
+				: null}
+		>
+			{#if interactive && selected_index === null}
+				<ModifyUpload
+					{i18n}
+					onclear={() => {
+						value = [];
+						onsource_change("upload");
+						onclear();
+					}}
+				>
+					{#if show_download_all_button}
+						<IconButton
+							Icon={DownloadAll}
+							label={i18n("common.download_all")}
+							onclick={handle_download_all}
+						/>
+					{/if}
+					{#if upload && stream_handler}
+						<IconButton
+							Icon={UploadIcon}
+							label={i18n("upload_text.click_to_upload")}
+						>
+							<UploadComponent
+								bind:upload_promise
+								icon_upload={true}
+								onload={(e) => onupload(e)}
+								filetype={file_types}
+								file_count="multiple"
+								{max_file_size}
+								{root}
+								bind:uploading
+								onerror={(e) => onerror(e)}
+								{stream_handler}
+								{upload}
+							/>
+						</IconButton>
+					{/if}
+					{#if sources.includes("webcam")}
+						<IconButton
+							Icon={Webcam}
+							label={i18n("common.webcam")}
+							onclick={() => {
+								onsource_change("webcam");
+							}}
+						/>
+					{/if}
+					{#if sources.includes("webcam-video")}
+						<IconButton
+							Icon={VideoIcon}
+							label={i18n("common.video")}
+							onclick={() => {
+								onsource_change("webcam-video");
+							}}
+						/>
+					{/if}
+					{#if sources.includes("clipboard")}
+						<IconButton
+							label={i18n("upload_text.paste_clipboard")}
+							onclick={() => {
+								onsource_change("clipboard");
+							}}
+							Icon={ImagePaste}
+						/>
+					{/if}
+				</ModifyUpload>
+			{:else if show_download_all_button && !(selected_media && allow_preview)}
+				<IconButtonWrapper>
+					<IconButton
+						Icon={DownloadAll}
+						label={i18n("common.download_all")}
+						onclick={handle_download_all}
+					/>
+				</IconButtonWrapper>
+			{/if}
+			<div
+				class="grid-container"
+				style="--grid-cols:{effective_columns}; --grid-rows:{rows}; --object-fit: {object_fit};"
+				class:pt-6={show_label}
+			>
+				{#each resolved_value as entry, i}
+					<div class="gallery-item">
+						<button
+							class="thumbnail-item thumbnail-lg"
+							class:selected={selected_index === i}
+							onclick={() => {
+								if (selected_index === null && allow_preview) {
+									onpreview_open();
+								}
+								selected_index = i;
+								dispatch_select(i);
+							}}
+							aria-label={"Thumbnail " +
+								(i + 1) +
+								" of " +
+								resolved_value.length}
+						>
+							{#if "image" in entry}
+								<Image
+									alt={entry.caption || ""}
+									src={typeof entry.image === "string"
+										? entry.image
+										: entry.image.url}
+									loading="lazy"
+								/>
+							{:else}
+								<Play />
+								<Video
+									src={entry.video.url}
+									title={entry.caption || null}
+									is_stream={false}
+									data-testid={"thumbnail " + (i + 1)}
+									alt=""
+									loading="lazy"
+									loop={false}
+								/>
+							{/if}
+							{#if entry.caption}
+								<div class="caption-label">
+									{entry.caption}
+								</div>
+							{/if}
+						</button>
+						{#if interactive}
+							<button
+								class="delete-button"
+								onclick={(event) => {
+									event.stopPropagation();
+									handle_item_delete(i);
+								}}
+								aria-label="Delete image"
+							>
+								<Clear />
+							</button>
+						{/if}
+					</div>
+				{/each}
+			</div>
+		</div>
+	</div>
+{/if}
+
+<style lang="postcss">
+	.gallery-container {
+		height: 100%;
+		position: relative;
+	}
+	.gallery-container :global(img),
+	button {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: contain;
+		display: block;
+		border-radius: var(--radius-lg);
+	}
+
+	.preview {
+		display: flex;
+		position: absolute;
+		flex-direction: column;
+		z-index: var(--layer-2);
+		border-radius: calc(var(--block-radius) - var(--block-border-width));
+		-webkit-backdrop-filter: blur(8px);
+		backdrop-filter: blur(8px);
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+
+	.preview.minimal {
+		width: fit-content;
+		height: fit-content;
+	}
+
+	.preview::before {
+		content: "";
+		position: absolute;
+		z-index: var(--layer-below);
+		background: var(--background-fill-primary);
+		opacity: 0.9;
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+
+	.fixed-height {
+		min-height: var(--size-80);
+		max-height: 55vh;
+	}
+
+	@media (--screen-xl) {
+		.fixed-height {
+			min-height: 450px;
+		}
+	}
+
+	.media-button {
+		height: calc(100% - 60px);
+		width: 100%;
+		display: flex;
+	}
+	.media-button :global(img),
+	.media-button :global(video) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: contain;
+	}
+	.thumbnails :global(img) {
+		object-fit: cover;
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+	.thumbnails :global(svg) {
+		position: absolute;
+		top: var(--size-2);
+		left: var(--size-2);
+		width: 50%;
+		height: 50%;
+		opacity: 50%;
+	}
+	.preview :global(img.with-caption) {
+		height: var(--size-full);
+	}
+
+	.preview.minimal :global(img.with-caption) {
+		height: auto;
+	}
+
+	.selectable {
+		cursor: crosshair;
+	}
+
+	.caption {
+		padding: var(--size-2) var(--size-3);
+		overflow: hidden;
+		color: var(--block-label-text-color);
+		font-weight: var(--weight-semibold);
+		text-align: center;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+		align-self: center;
+	}
+
+	.thumbnails {
+		display: flex;
+		position: absolute;
+		bottom: 0;
+		justify-content: flex-start;
+		align-items: center;
+		gap: var(--spacing-lg);
+		width: var(--size-full);
+		height: var(--size-14);
+		overflow-x: scroll;
+	}
+
+	.thumbnail-item {
+		--ring-color: transparent;
+		position: relative;
+		box-shadow:
+			inset 0 0 0 1px var(--ring-color),
+			var(--shadow-drop);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--button-small-radius);
+		background: var(--background-fill-secondary);
+		aspect-ratio: var(--ratio-square);
+		width: var(--size-full);
+		height: var(--size-full);
+		overflow: clip;
+	}
+
+	.thumbnail-item:hover {
+		--ring-color: var(--color-accent);
+		border-color: var(--color-accent);
+		filter: brightness(1.1);
+	}
+
+	.thumbnail-item.selected {
+		--ring-color: var(--color-accent);
+		border-color: var(--color-accent);
+	}
+
+	.thumbnail-item :global(svg) {
+		position: absolute;
+		top: 50%;
+		left: 50%;
+		width: 50%;
+		height: 50%;
+		opacity: 50%;
+		transform: translate(-50%, -50%);
+	}
+
+	.thumbnail-item :global(video) {
+		width: var(--size-full);
+		height: var(--size-full);
+		overflow: hidden;
+		object-fit: cover;
+	}
+
+	.thumbnail-small {
+		flex: none;
+		transform: scale(0.9);
+		transition: 0.075s;
+		width: var(--size-9);
+		height: var(--size-9);
+	}
+	.thumbnail-small.selected {
+		--ring-color: var(--color-accent);
+		transform: scale(1);
+		border-color: var(--color-accent);
+	}
+
+	.thumbnail-small > img {
+		width: var(--size-full);
+		height: var(--size-full);
+		overflow: hidden;
+		object-fit: var(--object-fit);
+	}
+
+	.grid-wrap {
+		position: relative;
+		padding: var(--size-2);
+		overflow-y: scroll;
+	}
+
+	.grid-container {
+		display: grid;
+		position: relative;
+		grid-template-rows: repeat(var(--grid-rows), minmax(100px, 1fr));
+		grid-template-columns: repeat(var(--grid-cols), minmax(100px, 1fr));
+		grid-auto-rows: minmax(100px, 1fr);
+		gap: var(--spacing-lg);
+	}
+
+	.thumbnail-lg > :global(img) {
+		width: var(--size-full);
+		height: var(--size-full);
+		overflow: hidden;
+		object-fit: var(--object-fit);
+	}
+
+	.thumbnail-lg:hover .caption-label {
+		opacity: 0.5;
+	}
+
+	.caption-label {
+		position: absolute;
+		right: var(--block-label-margin);
+		bottom: var(--block-label-margin);
+		z-index: var(--layer-1);
+		border-top: 1px solid var(--border-color-primary);
+		border-left: 1px solid var(--border-color-primary);
+		border-radius: var(--block-label-radius);
+		background: var(--background-fill-secondary);
+		padding: var(--block-label-padding);
+		max-width: 80%;
+		overflow: hidden;
+		font-size: var(--block-label-text-size);
+		text-align: left;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.grid-wrap.minimal {
+		padding: 0;
+	}
+
+	.gallery-item {
+		position: relative;
+		width: 100%;
+		height: 100%;
+	}
+
+	.delete-button {
+		position: absolute;
+		bottom: 0;
+		left: 0;
+		z-index: var(--layer-1);
+		border-top: 1px solid var(--border-color-primary);
+		border-right: 1px solid var(--border-color-primary);
+		border-radius: 0 var(--radius-sm) 0 var(--radius-sm);
+		background: var(--background-fill-secondary);
+		padding: var(--block-label-padding);
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		opacity: 0;
+		transition: opacity 0.2s ease;
+		font-size: var(--block-label-text-size);
+		color: var(--block-label-text-color);
+		font-weight: var(--weight-semibold);
+		width: auto;
+		height: auto;
+		min-width: fit-content;
+		min-height: fit-content;
+	}
+
+	.gallery-item:hover .delete-button {
+		opacity: 1;
+	}
+
+	.delete-button:hover {
+		opacity: 0.8;
+	}
+
+	.delete-button :global(svg) {
+		width: var(--text-xs);
+		height: var(--text-md);
+		color: var(--block-label-text-color);
+	}
+</style>

6.26.0/gallery/shared/utils.ts

@@ -0,0 +1,40 @@
+import { uploadToHuggingFace } from "@gradio/utils";
+import { FileData } from "@gradio/client";
+
+export async function format_gallery_for_sharing(
+	value: [FileData, string | null][] | null
+): Promise<string> {
+	if (!value) return "";
+	let urls = await Promise.all(
+		value.map(async ([image, _]) => {
+			if (image === null || !image.url) return "";
+			return await uploadToHuggingFace(image.url, "url");
+		})
+	);
+
+	return `<div style="display: flex; flex-wrap: wrap; gap: 16px">${urls
+		.map((url) => `<img src="${url}" style="height: 400px" />`)
+		.join("")}</div>`;
+}
+
+export async function handle_save(
+	img_blob: Blob,
+	upload: (files: FileData[]) => Promise<(FileData | null)[] | null>,
+	filename = "uploaded_file"
+): Promise<FileData[]> {
+	const ext = img_blob.type.split("/")[1] || "png";
+	const f_ = new File([img_blob], `${filename}.${ext}`);
+	const files = [
+		new FileData({
+			path: f_.name,
+			orig_name: f_.name,
+			blob: f_,
+			size: f_.size,
+			mime_type: f_.type,
+			is_stream: false
+		})
+	];
+	return ((await upload(files)) ?? []).filter(
+		(file): file is FileData => file !== null
+	);
+}

6.26.0/gallery/types.ts

@@ -0,0 +1,51 @@
+import type { FileData } from "@gradio/client";
+import type { CustomButton, SelectData } from "@gradio/utils";
+
+export interface GalleryImage {
+	image: FileData;
+	caption: string | null;
+}
+
+export interface GalleryVideo {
+	video: FileData;
+	caption: string | null;
+}
+
+export type GalleryData = GalleryImage | GalleryVideo;
+
+export interface GalleryProps {
+	value: GalleryData[] | null;
+	file_types: string[] | null;
+	columns: number | number[] | undefined;
+	rows: number | number[] | undefined;
+	height: number | string;
+	preview: boolean;
+	allow_preview: boolean;
+	selected_index: number | null;
+	object_fit: "contain" | "cover" | "fill" | "none" | "scale-down";
+	buttons: (
+		| "share"
+		| "download"
+		| "download_all"
+		| "fullscreen"
+		| CustomButton
+	)[];
+	type: "numpy" | "pil" | "filepath";
+	fit_columns: boolean;
+	sources: ("upload" | "webcam-video" | "webcam" | "clipboard")[];
+}
+
+export interface GalleryEvents {
+	change: GalleryData[] | null;
+	upload: GalleryData[] | null;
+	select: SelectData;
+	delete: { file: FileData; index: number };
+	preview_open: never;
+	preview_close: never;
+	clear: never;
+	clear_status: any;
+	share: any;
+	error: any;
+	custom_button_click: { id: number };
+	warning: string;
+}