Upload folder using huggingface_hub

6.23.1/image/Example.svelte

@@ -0,0 +1,55 @@
+<script lang="ts">
+	import Image from "./shared/Image.svelte";
+	import type { FileData } from "@gradio/client";
+
+	let {
+		value,
+		type,
+		selected = false
+	}: {
+		value: null | FileData;
+		type: "gallery" | "table";
+		selected?: boolean;
+	} = $props();
+</script>
+
+<div
+	class="container"
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+	class:border={value}
+>
+	{#if value}
+		<Image src={value.url} alt="" />
+	{/if}
+</div>
+
+<style>
+	.container :global(img) {
+		width: 100%;
+		height: 100%;
+	}
+
+	.container.selected {
+		border-color: var(--border-color-accent);
+	}
+	.border.table {
+		border: 2px solid var(--border-color-primary);
+	}
+
+	.container.table {
+		margin: 0 auto;
+		border-radius: var(--radius-lg);
+		overflow: hidden;
+		width: var(--size-20);
+		height: var(--size-20);
+		object-fit: cover;
+	}
+
+	.container.gallery {
+		width: var(--size-20);
+		max-width: var(--size-20);
+		object-fit: cover;
+	}
+</style>

6.23.1/image/Index.svelte

@@ -0,0 +1,206 @@
+<script module lang="ts">
+	export { default as Webcam } from "./shared/Webcam.svelte";
+	export { default as BaseImageUploader } from "./shared/ImageUploader.svelte";
+	export { default as BaseStaticImage } from "./shared/ImagePreview.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+	export { default as BaseImage } from "./shared/Image.svelte";
+</script>
+
+<script lang="ts">
+	import { tick } from "svelte";
+	import { Gradio } from "@gradio/utils";
+	import StaticImage from "./shared/ImagePreview.svelte";
+	import ImageUploader from "./shared/ImageUploader.svelte";
+	import { Block, Empty, UploadText } from "@gradio/atoms";
+	import { Image } from "@gradio/icons";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { ImageProps, ImageEvents } from "./shared/types";
+
+	let stream_data = { value: null };
+	let upload_promise = $state<Promise<any> | null>(null);
+	class ImageGradio extends Gradio<ImageEvents, ImageProps> {
+		async get_data() {
+			if (upload_promise) {
+				await upload_promise;
+				await tick();
+			}
+
+			const data = await super.get_data();
+			if (props.props.streaming) {
+				data.value = stream_data.value;
+			}
+
+			return data;
+		}
+	}
+
+	const props = $props();
+	const gradio = new ImageGradio(props, { value: null });
+
+	let value = $state(gradio.props.value ?? null);
+	let fullscreen = $state(false);
+	let dragging = $state(false);
+	let active_source = $derived.by(() =>
+		gradio.props.sources ? gradio.props.sources[0] : null
+	);
+
+	$effect(() => {
+		value = gradio.props.value ?? null;
+	});
+
+	$effect(() => {
+		gradio.props.value = value;
+	});
+
+	let old_value = value;
+	let mounted = false;
+
+	$effect(() => {
+		if (!mounted) {
+			old_value = value;
+			mounted = true;
+			return;
+		}
+		if (old_value !== value) {
+			old_value = value;
+			gradio.dispatch("change");
+		}
+	});
+
+	let status = $derived(gradio?.shared?.loading_status.stream_state);
+</script>
+
+{#if !gradio.shared.interactive}
+	<Block
+		visible={gradio.shared.visible}
+		variant={"solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		height={gradio.props.height || undefined}
+		width={gradio.props.width}
+		allow_overflow={false}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+		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)}
+		/>
+		<StaticImage
+			onselect={(detail) => gradio.dispatch("select", detail)}
+			onshare={(detail) => gradio.dispatch("share", detail)}
+			onerror={(detail) => gradio.dispatch("error", detail)}
+			onfullscreen={(detail) => {
+				fullscreen = detail;
+			}}
+			{fullscreen}
+			{value}
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			selectable={gradio.props._selectable}
+			i18n={gradio.i18n}
+			buttons={gradio.props.buttons}
+			on_custom_button_click={(id) => {
+				gradio.dispatch("custom_button_click", { id });
+			}}
+		/>
+	</Block>
+{:else}
+	<Block
+		visible={gradio.shared.visible}
+		variant={gradio.props.value === null ? "dashed" : "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		height={gradio.props.height || undefined}
+		width={gradio.props.width}
+		allow_overflow={false}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+		bind:fullscreen
+	>
+		{#if gradio.shared.loading_status.type === "output" || gradio.shared.loading_status.validation_error}
+			<StatusTracker
+				autoscroll={gradio.shared.autoscroll}
+				i18n={gradio.i18n}
+				{...gradio.shared.loading_status}
+				on_clear_status={() =>
+					gradio.dispatch("clear_status", gradio.shared.loading_status)}
+			/>
+		{/if}
+		<ImageUploader
+			bind:upload_promise
+			bind:active_source
+			bind:value
+			bind:dragging
+			selectable={gradio.props._selectable}
+			root={gradio.shared.root}
+			sources={gradio.props.sources}
+			{fullscreen}
+			show_fullscreen_button={gradio.props.buttons === null
+				? true
+				: gradio.props.buttons.some(
+						(btn) => typeof btn === "string" && btn === "fullscreen"
+					)}
+			onclear={() => {
+				fullscreen = false;
+				gradio.dispatch("clear");
+				gradio.dispatch("input");
+			}}
+			onstream={(detail) => {
+				stream_data = detail;
+				gradio.dispatch("stream", detail);
+			}}
+			ondrag={(detail) => (dragging = detail)}
+			onupload={() => {
+				gradio.dispatch("upload");
+				gradio.dispatch("input");
+			}}
+			onselect={(detail) => gradio.dispatch("select", detail)}
+			onerror={(detail) => {
+				gradio.shared.loading_status.status = "error";
+				gradio.dispatch("error", detail);
+			}}
+			onclose_stream={() => {
+				gradio.dispatch("close_stream");
+			}}
+			onfullscreen={(detail) => {
+				fullscreen = detail;
+			}}
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			pending={gradio.shared.loading_status?.status === "pending" ||
+				gradio.shared.loading_status?.status === "streaming"}
+			streaming={gradio.props.streaming}
+			webcam_options={gradio.props.webcam_options}
+			stream_every={gradio.props.stream_every}
+			time_limit={gradio.shared.loading_status?.time_limit}
+			max_file_size={gradio.shared.max_file_size}
+			i18n={gradio.i18n}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+			stream_handler={gradio.shared.client?.stream}
+			stream_state={status}
+		>
+			{#if active_source === "upload" || !active_source}
+				<UploadText
+					i18n={gradio.i18n}
+					type="image"
+					placeholder={gradio.props.placeholder}
+				/>
+			{:else if active_source === "clipboard"}
+				<UploadText i18n={gradio.i18n} type="clipboard" mode="short" />
+			{:else}
+				<Empty unpadded_box={true} size="large"><Image /></Empty>
+			{/if}
+		</ImageUploader>
+	</Block>
+{/if}

6.23.1/image/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@gradio/image",
+	"version": "0.28.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"cropperjs": "^2.0.1",
+		"lazy-brush": "^2.0.2",
+		"resize-observer-polyfill": "^1.5.1"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"main": "./Index.svelte",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		},
+		"./base": {
+			"gradio": "./shared/ImagePreview.svelte",
+			"svelte": "./dist/shared/ImagePreview.svelte",
+			"types": "./dist/shared/ImagePreview.svelte.d.ts"
+		},
+		"./shared": {
+			"gradio": "./shared/index.ts",
+			"svelte": "./dist/shared/index.js",
+			"types": "./dist/shared/index.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/image"
+	}
+}

6.23.1/image/shared/Image.svelte

@@ -0,0 +1,48 @@
+<script lang="ts">
+	import type { HTMLImgAttributes } from "svelte/elements";
+
+	let {
+		src = "",
+		restProps = {},
+		data_testid,
+		class_names = [],
+		onload,
+		...imgProps
+	}: {
+		src?: string;
+		restProps?: Record<string, any>;
+		data_testid?: string;
+		class_names?: string[];
+		onload?: HTMLImgAttributes["onload"];
+		[key: string]: any;
+	} = $props();
+
+	const without_class = ({
+		class: _class,
+		...props
+	}: Record<string, any>): Record<string, any> => props;
+
+	let rest_img_props = $derived(without_class(restProps));
+	let direct_img_props = $derived(without_class(imgProps));
+	let classes = $derived(
+		[class_names.join(" "), restProps.class, imgProps.class]
+			.filter(Boolean)
+			.join(" ")
+	);
+</script>
+
+<!-- svelte-ignore a11y-missing-attribute -->
+<img
+	{src}
+	class={classes}
+	data-testid={data_testid}
+	{...rest_img_props}
+	{...direct_img_props}
+	{onload}
+/>
+
+<style>
+	img {
+		object-fit: cover;
+	}
+</style>

6.23.1/image/shared/ImagePreview.svelte

@@ -0,0 +1,172 @@
+<script lang="ts">
+	import type { SelectData } from "@gradio/utils";
+	import { uploadToHuggingFace } from "@gradio/utils";
+	import {
+		BlockLabel,
+		Empty,
+		IconButton,
+		ShareButton,
+		IconButtonWrapper,
+		FullscreenButton,
+		DownloadLink
+	} from "@gradio/atoms";
+	import type { CustomButton as CustomButtonType } from "@gradio/utils";
+	import { Download, Image as ImageIcon } from "@gradio/icons";
+	import { get_coordinates_of_clicked_image } from "./utils";
+	import Image from "./Image.svelte";
+
+	import type { I18nFormatter } from "@gradio/utils";
+	import type { FileData } from "@gradio/client";
+
+	let {
+		value,
+		label = undefined,
+		show_label,
+		buttons = [],
+		on_custom_button_click = null,
+		selectable = false,
+		i18n,
+		display_icon_button_wrapper_top_corner = false,
+		fullscreen = $bindable(false),
+		show_button_background = true,
+		onselect,
+		onfullscreen,
+		onshare,
+		onerror,
+		onload
+	}: {
+		value: null | FileData;
+		label?: string;
+		show_label: boolean;
+		buttons?: (string | CustomButtonType)[];
+		on_custom_button_click?: ((id: number) => void) | null;
+		selectable?: boolean;
+		i18n: I18nFormatter;
+		display_icon_button_wrapper_top_corner?: boolean;
+		fullscreen?: boolean;
+		show_button_background?: boolean;
+		onselect?: (value: SelectData) => void;
+		onfullscreen?: (fullscreen: boolean) => void;
+		onshare?: (detail: unknown) => void;
+		onerror?: (error: string) => void;
+		onload?: () => void;
+	} = $props();
+
+	const handle_click = (evt: MouseEvent): void => {
+		let coordinates = get_coordinates_of_clicked_image(evt);
+		if (coordinates) {
+			onselect?.({ index: coordinates, value: null });
+		}
+	};
+
+	let image_container: HTMLElement;
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={ImageIcon}
+	label={!show_label ? "" : label || i18n("image.image")}
+/>
+{#if value == null || !value?.url}
+	<Empty unpadded_box={true} size="large"><ImageIcon /></Empty>
+{:else}
+	<div class="image-container" bind:this={image_container}>
+		<IconButtonWrapper
+			display_top_corner={display_icon_button_wrapper_top_corner}
+			show_background={show_button_background}
+			{buttons}
+			{on_custom_button_click}
+		>
+			{#if buttons.some((btn) => typeof btn === "string" && btn === "fullscreen")}
+				<FullscreenButton
+					{fullscreen}
+					onclick={(is_fullscreen) => {
+						fullscreen = is_fullscreen;
+						onfullscreen?.(is_fullscreen);
+					}}
+				/>
+			{/if}
+			{#if buttons.some((btn) => typeof btn === "string" && btn === "download")}
+				<DownloadLink href={value.url} download={value.orig_name || "image"}>
+					<IconButton Icon={Download} label={i18n("common.download")} />
+				</DownloadLink>
+			{/if}
+			{#if buttons.some((btn) => typeof btn === "string" && btn === "share")}
+				<ShareButton
+					{i18n}
+					onshare={(detail) => onshare?.(detail)}
+					onerror={(detail) => onerror?.(detail)}
+					formatter={async (value) => {
+						if (!value) return "";
+						let url = await uploadToHuggingFace(value, "url");
+						return `<img src="${url}" />`;
+					}}
+					{value}
+				/>
+			{/if}
+		</IconButtonWrapper>
+		<button onclick={handle_click}>
+			<div class:selectable class="image-frame">
+				<Image
+					src={value.url}
+					restProps={{ loading: "lazy", alt: "" }}
+					{onload}
+				/>
+			</div>
+		</button>
+	</div>
+{/if}
+
+<style>
+	.image-container {
+		height: 100%;
+		position: relative;
+		min-width: var(--size-20);
+	}
+
+	.image-container button {
+		width: var(--size-full);
+		height: var(--size-full);
+		border-radius: var(--radius-lg);
+
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.image-frame :global(img) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: scale-down;
+	}
+
+	.selectable {
+		cursor: crosshair;
+	}
+
+	:global(.fullscreen-controls svg) {
+		position: relative;
+		top: 0px;
+	}
+
+	:global(.image-container:fullscreen) {
+		background-color: black;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+	}
+
+	:global(.image-container:fullscreen img) {
+		max-width: 90vw;
+		max-height: 90vh;
+		object-fit: scale-down;
+	}
+
+	.image-frame {
+		width: auto;
+		height: 100%;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+</style>

6.23.1/image/shared/ImageUploader.svelte

@@ -0,0 +1,345 @@
+<script lang="ts">
+	import { tick, type Snippet } from "svelte";
+	import { BlockLabel, IconButtonWrapper, IconButton } from "@gradio/atoms";
+	import { Clear, Image as ImageIcon } from "@gradio/icons";
+	import { FullscreenButton } from "@gradio/atoms";
+	import {
+		type SelectData,
+		type I18nFormatter,
+		type ValueData
+	} from "@gradio/utils";
+	import { get_coordinates_of_clicked_image } from "./utils";
+	import Webcam from "./Webcam.svelte";
+
+	import { Upload, UploadProgress } from "@gradio/upload";
+	import { FileData, type Client } from "@gradio/client";
+	import { SelectSource } from "@gradio/atoms";
+	import Image from "./Image.svelte";
+	import type { Base64File, WebcamOptions } from "./types";
+
+	type source_type = "upload" | "webcam" | "clipboard" | "microphone" | null;
+
+	let {
+		value = $bindable<null | FileData | Base64File>(null),
+		label = undefined,
+		show_label,
+		sources = ["upload", "clipboard", "webcam"],
+		streaming = false,
+		pending = $bindable(false),
+		webcam_options,
+		selectable = false,
+		root,
+		i18n,
+		max_file_size = null,
+		upload,
+		stream_handler,
+		stream_every,
+		time_limit,
+		show_fullscreen_button = true,
+		stream_state = "closed",
+		upload_promise = $bindable<Promise<any> | null>(null),
+		onerror,
+		uploading = $bindable(false),
+		active_source = $bindable<source_type>(null),
+		fullscreen = $bindable(false),
+		dragging = $bindable(false),
+		onchange,
+		onstream,
+		onclear,
+		ondrag,
+		onupload,
+		onselect,
+		onfullscreen,
+		onclose_stream,
+		children
+	}: {
+		value?: null | FileData | Base64File;
+		label?: string;
+		show_label: boolean;
+		sources?: source_type[];
+		streaming?: boolean;
+		pending?: boolean;
+		webcam_options: WebcamOptions;
+		selectable?: boolean;
+		root: string;
+		i18n: I18nFormatter;
+		max_file_size?: number | null;
+		upload: Client["upload"];
+		stream_handler: Client["stream"];
+		stream_every: number;
+		time_limit: number;
+		show_fullscreen_button?: boolean;
+		stream_state?: "open" | "waiting" | "closed";
+		upload_promise?: Promise<any> | null;
+		onerror?: (error: string) => void;
+		uploading?: boolean;
+		active_source?: source_type;
+		fullscreen?: boolean;
+		dragging?: boolean;
+		onchange?: (value?: null | FileData | Base64File) => void;
+		onstream?: (value: ValueData) => void;
+		onclear?: () => void;
+		ondrag?: (dragging: boolean) => void;
+		onupload?: () => void;
+		onselect?: (value: SelectData) => void;
+		onfullscreen?: (fullscreen: boolean) => void;
+		onclose_stream?: () => void;
+		children?: Snippet;
+	} = $props();
+
+	let upload_input: Upload;
+
+	let files = $state<FileData[]>([]);
+	let upload_id = $state("");
+
+	async function handle_upload(detail: FileData): Promise<void> {
+		if (!streaming) {
+			if (detail.path?.toLowerCase().endsWith(".svg") && detail.url) {
+				const response = await fetch(detail.url);
+				const svgContent = await response.text();
+				value = {
+					...detail,
+					url: `data:image/svg+xml,${encodeURIComponent(svgContent)}`
+				};
+			} else {
+				value = detail;
+			}
+
+			await tick();
+			onupload?.();
+		}
+	}
+
+	function handle_clear(): void {
+		value = null;
+		onclear?.();
+		onchange?.(null);
+	}
+
+	function handle_remove_image_click(event: MouseEvent): void {
+		handle_clear();
+		event.stopPropagation();
+	}
+
+	async function handle_save(
+		img_blob: Blob | any,
+		event: "change" | "stream" | "upload"
+	): Promise<void> {
+		if (event === "stream") {
+			onstream?.({
+				value: { url: img_blob } as Base64File,
+				is_value_data: true
+			});
+			return;
+		}
+		upload_id = Math.random().toString(36).substring(2, 15);
+		const f_ = new File([img_blob], `image.${streaming ? "jpeg" : "png"}`);
+		files = [
+			new FileData({
+				path: f_.name,
+				orig_name: f_.name,
+				blob: f_,
+				size: f_.size,
+				mime_type: f_.type,
+				is_stream: false
+			})
+		];
+		pending = true;
+		const f = await upload_input.load_files([f_], upload_id);
+		if (event === "change" || event === "upload") {
+			value = f?.[0] || null;
+			await tick();
+			onchange?.();
+		}
+		pending = false;
+	}
+
+	let active_streaming = $derived(streaming && active_source === "webcam");
+	$effect(() => {
+		if (uploading && !active_streaming) value = null;
+	});
+	$effect(() => {
+		ondrag?.(dragging);
+	});
+
+	function handle_click(evt: MouseEvent): void {
+		let coordinates = get_coordinates_of_clicked_image(evt);
+		if (coordinates) {
+			onselect?.({ index: coordinates, value: null });
+		}
+	}
+
+	$effect(() => {
+		if (!active_source && sources) {
+			active_source = sources[0];
+		}
+	});
+
+	async function handle_select_source(
+		source: (typeof sources)[number]
+	): Promise<void> {
+		switch (source) {
+			case "clipboard":
+				upload_input.paste_clipboard();
+				break;
+			default:
+				break;
+		}
+	}
+
+	let image_container: HTMLElement;
+
+	function on_drag_over(evt: DragEvent): void {
+		evt.preventDefault();
+		evt.stopPropagation();
+		if (evt.dataTransfer) {
+			evt.dataTransfer.dropEffect = "copy";
+		}
+
+		dragging = true;
+	}
+
+	async function on_drop(evt: DragEvent): Promise<void> {
+		evt.preventDefault();
+		evt.stopPropagation();
+		dragging = false;
+
+		if (value) {
+			handle_clear();
+			await tick();
+		}
+
+		active_source = "upload";
+		await tick();
+		upload_input.load_files_from_drop(evt);
+	}
+</script>
+
+<BlockLabel {show_label} Icon={ImageIcon} label={label || "Image"} />
+
+<div data-testid="image" class="image-container" bind:this={image_container}>
+	<IconButtonWrapper>
+		{#if value?.url && !active_streaming}
+			{#if show_fullscreen_button}
+				<FullscreenButton
+					{fullscreen}
+					onclick={(is_fullscreen) => {
+						fullscreen = is_fullscreen;
+						onfullscreen?.(is_fullscreen);
+					}}
+				/>
+			{/if}
+			<IconButton
+				Icon={Clear}
+				label="Remove Image"
+				onclick={handle_remove_image_click}
+			/>
+		{/if}
+	</IconButtonWrapper>
+	<!-- svelte-ignore a11y-no-static-element-interactions -->
+	<div
+		class="upload-container"
+		class:reduced-height={sources.length > 1}
+		style:width={value ? "auto" : "100%"}
+		ondragover={on_drag_over}
+		ondrop={on_drop}
+	>
+		<Upload
+			bind:upload_promise
+			hidden={value !== null || active_source === "webcam"}
+			bind:this={upload_input}
+			bind:uploading
+			bind:dragging
+			filetype={active_source === "clipboard" ? "clipboard" : "image/*"}
+			onload={handle_upload}
+			{onerror}
+			{root}
+			{max_file_size}
+			disable_click={!sources.includes("upload") || value !== null}
+			{upload}
+			{stream_handler}
+			aria_label={i18n("image.drop_to_upload")}
+		>
+			{#if value === null}
+				{#if children}{@render children()}{/if}
+			{/if}
+		</Upload>
+		{#if active_source === "webcam" && !streaming && pending}
+			<UploadProgress {root} {upload_id} {stream_handler} {files} />
+		{:else if active_source === "webcam" && (streaming || (!streaming && !value))}
+			<Webcam
+				{root}
+				{value}
+				oncapture={(detail) => handle_save(detail, "change")}
+				onstream={(detail) => handle_save(detail, "stream")}
+				{onerror}
+				{onclose_stream}
+				{stream_state}
+				mirror_webcam={webcam_options.mirror}
+				{stream_every}
+				{streaming}
+				mode="image"
+				include_audio={false}
+				{i18n}
+				{upload}
+				{time_limit}
+				webcam_constraints={webcam_options.constraints}
+			/>
+		{:else if value !== null && !streaming}
+			<!-- svelte-ignore a11y-click-events-have-key-events-->
+			<!-- svelte-ignore a11y-no-static-element-interactions-->
+			<div class:selectable class="image-frame" onclick={handle_click}>
+				<Image src={value.url} restProps={{ alt: value.alt_text }} />
+			</div>
+		{/if}
+	</div>
+	{#if sources.length > 1 || sources.includes("clipboard")}
+		<SelectSource
+			{sources}
+			bind:active_source
+			{handle_clear}
+			handle_select={(source) => handle_select_source(source as source_type)}
+		/>
+	{/if}
+</div>
+
+<style>
+	.image-frame :global(img) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: scale-down;
+	}
+
+	.upload-container {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+
+		height: 100%;
+		flex-shrink: 1;
+		max-height: 100%;
+	}
+
+	.reduced-height {
+		height: calc(100% - var(--size-10));
+	}
+
+	.image-container {
+		display: flex;
+		height: 100%;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		max-height: 100%;
+	}
+
+	.selectable {
+		cursor: crosshair;
+	}
+
+	.image-frame {
+		object-fit: cover;
+		width: 100%;
+		height: 100%;
+	}
+</style>

6.23.1/image/shared/Webcam.svelte

@@ -0,0 +1,502 @@
+<script lang="ts">
+	import { onDestroy, onMount } from "svelte";
+	import {
+		Camera,
+		Circle,
+		Square,
+		DropdownArrow,
+		Spinner
+	} from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { StreamingBar } from "@gradio/statustracker";
+	import { type FileData, type Client, prepare_files } from "@gradio/client";
+	import WebcamPermissions from "./WebcamPermissions.svelte";
+	import { fade } from "svelte/transition";
+	import {
+		get_devices,
+		get_video_stream,
+		set_available_devices
+	} from "./stream_utils";
+	import type { Base64File } from "./types";
+
+	let video_source: HTMLVideoElement;
+	let available_video_devices = $state<MediaDeviceInfo[]>([]);
+	let selected_device = $state<MediaDeviceInfo | null>(null);
+
+	let canvas: HTMLCanvasElement;
+	let {
+		stream_state = "closed",
+		streaming = false,
+		pending = false,
+		root = "",
+		stream_every = 1,
+		mode = "image",
+		mirror_webcam,
+		include_audio,
+		webcam_constraints = null,
+		i18n,
+		upload,
+		value = null,
+		time_limit = null,
+		onstream,
+		oncapture,
+		onerror,
+		onstart_recording,
+		onstop_recording,
+		onclose_stream
+	}: {
+		stream_state?: "open" | "waiting" | "closed";
+		streaming?: boolean;
+		pending?: boolean;
+		root?: string;
+		stream_every?: number;
+		mode?: "image" | "video";
+		mirror_webcam: boolean;
+		include_audio: boolean;
+		webcam_constraints?: { [key: string]: any } | null;
+		i18n: I18nFormatter;
+		upload: Client["upload"];
+		value?: FileData | null | Base64File;
+		time_limit?: number | null;
+		onstream?: (value: Blob | string) => void;
+		oncapture?: (value: FileData | Blob | null) => void;
+		onerror?: (error: string) => void;
+		onstart_recording?: () => void;
+		onstop_recording?: () => void;
+		onclose_stream?: () => void;
+	} = $props();
+
+	onMount(() => {
+		canvas = document.createElement("canvas");
+		if (streaming && mode === "image") {
+			window.setInterval(() => {
+				if (video_source && !pending) {
+					take_picture();
+				}
+			}, stream_every * 1000);
+		}
+	});
+
+	const handle_device_change = async (event: InputEvent): Promise<void> => {
+		const target = event.target as HTMLInputElement;
+		const device_id = target.value;
+
+		await get_video_stream(
+			include_audio,
+			video_source,
+			webcam_constraints,
+			device_id
+		).then(async (local_stream) => {
+			stream = local_stream;
+			selected_device =
+				available_video_devices.find(
+					(device) => device.deviceId === device_id
+				) || null;
+			options_open = false;
+		});
+	};
+
+	async function access_webcam(): Promise<void> {
+		try {
+			get_video_stream(include_audio, video_source, webcam_constraints)
+				.then(async (local_stream) => {
+					webcam_accessed = true;
+					available_video_devices = await get_devices();
+					stream = local_stream;
+				})
+				.then(() => set_available_devices(available_video_devices))
+				.then((devices) => {
+					available_video_devices = devices;
+
+					const used_devices = stream
+						.getTracks()
+						.map((track) => track.getSettings()?.deviceId)[0];
+
+					selected_device = used_devices
+						? devices.find((device) => device.deviceId === used_devices) ||
+							available_video_devices[0]
+						: available_video_devices[0];
+				});
+
+			if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+				onerror?.(i18n("image.no_webcam_support"));
+			}
+		} catch (err) {
+			if (err instanceof DOMException && err.name == "NotAllowedError") {
+				onerror?.(i18n("image.allow_webcam_access"));
+			} else {
+				throw err;
+			}
+		}
+	}
+
+	function take_picture(): void {
+		if (
+			(!streaming || (streaming && recording)) &&
+			video_source.videoWidth &&
+			video_source.videoHeight
+		) {
+			var context = canvas.getContext("2d")!;
+			canvas.width = video_source.videoWidth;
+			canvas.height = video_source.videoHeight;
+			context.drawImage(
+				video_source,
+				0,
+				0,
+				video_source.videoWidth,
+				video_source.videoHeight
+			);
+
+			if (mirror_webcam) {
+				context.scale(-1, 1);
+				context.drawImage(video_source, -video_source.videoWidth, 0);
+			}
+
+			if (streaming && (!recording || stream_state === "waiting")) {
+				return;
+			}
+			if (streaming) {
+				const image_data = canvas.toDataURL("image/jpeg");
+				onstream?.(image_data);
+				return;
+			}
+
+			canvas.toBlob(
+				(blob) => {
+					if (streaming) {
+						onstream?.(blob as Blob);
+					} else {
+						oncapture?.(blob);
+					}
+				},
+				`image/${streaming ? "jpeg" : "png"}`,
+				0.8
+			);
+		}
+	}
+
+	let recording = $state(false);
+	let recorded_blobs: BlobPart[] = [];
+	let stream: MediaStream;
+	let mimeType: string;
+	let media_recorder: MediaRecorder;
+
+	function take_recording(): void {
+		if (recording) {
+			media_recorder.stop();
+			let video_blob = new Blob(recorded_blobs, { type: mimeType });
+			let ReaderObj = new FileReader();
+			ReaderObj.onload = async function (e): Promise<void> {
+				if (e.target) {
+					let _video_blob = new File(
+						[video_blob],
+						"sample." + mimeType.substring(6)
+					);
+					const val = await prepare_files([_video_blob]);
+					let val_ = (
+						(await upload(val, root))?.filter(Boolean) as FileData[]
+					)[0];
+					oncapture?.(val_);
+					onstop_recording?.();
+				}
+			};
+			ReaderObj.readAsDataURL(video_blob);
+		} else if (typeof MediaRecorder !== "undefined") {
+			onstart_recording?.();
+			recorded_blobs = [];
+			let validMimeTypes = ["video/webm", "video/mp4"];
+			for (let validMimeType of validMimeTypes) {
+				if (MediaRecorder.isTypeSupported(validMimeType)) {
+					mimeType = validMimeType;
+					break;
+				}
+			}
+			if (mimeType === null) {
+				console.error("No supported MediaRecorder mimeType");
+				return;
+			}
+			media_recorder = new MediaRecorder(stream, {
+				mimeType: mimeType
+			});
+			media_recorder.addEventListener("dataavailable", function (e) {
+				recorded_blobs.push(e.data);
+			});
+			media_recorder.start(200);
+		}
+		recording = !recording;
+	}
+
+	let webcam_accessed = $state(false);
+
+	function record_video_or_photo({
+		destroy
+	}: { destroy?: boolean } = {}): void {
+		if (mode === "image" && streaming) {
+			recording = !recording;
+		}
+
+		if (!destroy) {
+			if (mode === "image") {
+				take_picture();
+			} else {
+				take_recording();
+			}
+		}
+
+		if (!recording && stream) {
+			onclose_stream?.();
+		}
+	}
+
+	let options_open = $state(false);
+
+	export function click_outside(node: Node, cb: any): any {
+		const handle_click = (event: MouseEvent): void => {
+			if (
+				node &&
+				!node.contains(event.target as Node) &&
+				!event.defaultPrevented
+			) {
+				cb(event);
+			}
+		};
+
+		document.addEventListener("click", handle_click, true);
+
+		return {
+			destroy() {
+				document.removeEventListener("click", handle_click, true);
+			}
+		};
+	}
+
+	function handle_click_outside(event: MouseEvent): void {
+		event.preventDefault();
+		event.stopPropagation();
+		options_open = false;
+	}
+
+	onDestroy(() => {
+		if (typeof window === "undefined") return;
+		record_video_or_photo({ destroy: true });
+		stream?.getTracks().forEach((track) => track.stop());
+	});
+</script>
+
+<div class="wrap">
+	<StreamingBar {time_limit} />
+	<!-- svelte-ignore a11y-media-has-caption -->
+	<!-- need to suppress for video streaming https://github.com/sveltejs/svelte/issues/5967 -->
+	<video
+		bind:this={video_source}
+		class:flip={mirror_webcam}
+		class:hide={!webcam_accessed || (webcam_accessed && !!value)}
+	/>
+	<!-- svelte-ignore a11y-missing-attribute -->
+	<img
+		src={value?.url}
+		class:hide={!webcam_accessed || (webcam_accessed && !value)}
+	/>
+	{#if !webcam_accessed}
+		<div
+			in:fade={{ delay: 100, duration: 200 }}
+			title="grant webcam access"
+			style="height: 100%"
+		>
+			<WebcamPermissions onclick={async () => access_webcam()} />
+		</div>
+	{:else}
+		<div class="button-wrap">
+			<button
+				onclick={() => record_video_or_photo()}
+				aria-label={mode === "image" ? "capture photo" : "start recording"}
+			>
+				{#if mode === "video" || streaming}
+					{#if streaming && stream_state === "waiting"}
+						<div class="icon-with-text" style="width:var(--size-24);">
+							<div class="icon color-primary" title="spinner">
+								<Spinner />
+							</div>
+							{i18n("audio.waiting")}
+						</div>
+					{:else if (streaming && stream_state === "open") || (!streaming && recording)}
+						<div class="icon-with-text">
+							<div class="icon color-primary" title="stop recording">
+								<Square />
+							</div>
+							{i18n("audio.stop")}
+						</div>
+					{:else}
+						<div class="icon-with-text">
+							<div class="icon color-primary" title="start recording">
+								<Circle />
+							</div>
+							{i18n("audio.record")}
+						</div>
+					{/if}
+				{:else}
+					<div class="icon" title="capture photo">
+						<Camera />
+					</div>
+				{/if}
+			</button>
+			{#if !recording}
+				<button
+					class="icon"
+					onclick={() => (options_open = true)}
+					aria-label="select input source"
+				>
+					<DropdownArrow />
+				</button>
+			{/if}
+		</div>
+		{#if options_open && selected_device}
+			<select
+				class="select-wrap"
+				aria-label="select source"
+				use:click_outside={handle_click_outside}
+				onchange={handle_device_change}
+			>
+				{#if available_video_devices.length === 0}
+					<option value="">{i18n("common.no_devices")}</option>
+				{:else}
+					{#each available_video_devices as device}
+						<option
+							value={device.deviceId}
+							selected={selected_device.deviceId === device.deviceId}
+						>
+							{device.label}
+						</option>
+					{/each}
+				{/if}
+			</select>
+		{/if}
+	{/if}
+</div>
+
+<style>
+	.wrap {
+		position: relative;
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+
+	.hide {
+		display: none;
+	}
+
+	video {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: contain;
+	}
+
+	.button-wrap {
+		position: absolute;
+		background-color: var(--block-background-fill);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-xl);
+		padding: var(--size-1-5);
+		display: flex;
+		bottom: var(--size-2);
+		left: 50%;
+		transform: translate(-50%, 0);
+		box-shadow: var(--shadow-drop-lg);
+		border-radius: var(--radius-xl);
+		line-height: var(--size-3);
+		color: var(--button-secondary-text-color);
+	}
+
+	.icon-with-text {
+		width: var(--size-20);
+		align-items: center;
+		margin: 0 var(--spacing-xl);
+		display: flex;
+		justify-content: space-evenly;
+	}
+
+	@media (--screen-md) {
+		button {
+			bottom: var(--size-4);
+		}
+	}
+
+	@media (--screen-xl) {
+		button {
+			bottom: var(--size-8);
+		}
+	}
+
+	.icon {
+		width: 18px;
+		height: 18px;
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+	}
+
+	.color-primary {
+		fill: var(--primary-600);
+		stroke: var(--primary-600);
+		color: var(--primary-600);
+	}
+
+	.flip {
+		transform: scaleX(-1);
+	}
+
+	.select-wrap {
+		-webkit-appearance: none;
+		-moz-appearance: none;
+		appearance: none;
+		color: var(--button-secondary-text-color);
+		background-color: transparent;
+		width: 95%;
+		font-size: var(--text-md);
+		position: absolute;
+		bottom: var(--size-2);
+		background-color: var(--block-background-fill);
+		box-shadow: var(--shadow-drop-lg);
+		border-radius: var(--radius-xl);
+		z-index: var(--layer-top);
+		border: 1px solid var(--border-color-primary);
+		text-align: left;
+		line-height: var(--size-4);
+		white-space: nowrap;
+		text-overflow: ellipsis;
+		left: 50%;
+		transform: translate(-50%, 0);
+		max-width: var(--size-52);
+	}
+
+	.select-wrap > option {
+		padding: 0.25rem 0.5rem;
+		border-bottom: 1px solid var(--border-color-accent);
+		padding-right: var(--size-8);
+		text-overflow: ellipsis;
+		overflow: hidden;
+	}
+
+	.select-wrap > option:hover {
+		background-color: var(--color-accent);
+	}
+
+	.select-wrap > option:last-child {
+		border: none;
+	}
+
+	.inset-icon {
+		position: absolute;
+		top: 5px;
+		right: -6.5px;
+		width: var(--size-10);
+		height: var(--size-5);
+		opacity: 0.8;
+	}
+
+	@media (--screen-md) {
+		.wrap {
+			font-size: var(--text-lg);
+		}
+	}
+</style>

6.23.1/image/shared/WebcamPermissions.svelte

@@ -0,0 +1,43 @@
+<script lang="ts">
+	import { Webcam } from "@gradio/icons";
+
+	let { onclick }: { onclick?: () => void } = $props();
+</script>
+
+<button style:height="100%" {onclick}>
+	<div class="wrap">
+		<span class="icon-wrap">
+			<Webcam />
+		</span>
+		{"Click to Access Webcam"}
+	</div>
+</button>
+
+<style>
+	button {
+		cursor: pointer;
+		width: var(--size-full);
+	}
+
+	.wrap {
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		min-height: var(--size-60);
+		color: var(--block-label-text-color);
+		height: 100%;
+		padding-top: var(--size-3);
+	}
+
+	.icon-wrap {
+		width: 30px;
+		margin-bottom: var(--spacing-lg);
+	}
+
+	@media (--screen-md) {
+		.wrap {
+			font-size: var(--text-lg);
+		}
+	}
+</style>

6.23.1/image/shared/index.ts

@@ -0,0 +1,2 @@
+export { default as Image } from "./Image.svelte";
+export { default as StaticImage } from "./ImagePreview.svelte";

6.23.1/image/shared/stream_utils.ts

@@ -0,0 +1,50 @@
+export function get_devices(): Promise<MediaDeviceInfo[]> {
+	return navigator.mediaDevices.enumerateDevices();
+}
+
+export function handle_error(error: string): void {
+	throw new Error(error);
+}
+
+export async function set_local_stream(
+	local_stream: MediaStream | null,
+	video_source: HTMLVideoElement
+): Promise<void> {
+	video_source.srcObject = local_stream;
+	video_source.muted = true;
+	await video_source.play();
+}
+
+export async function get_video_stream(
+	include_audio: boolean,
+	video_source: HTMLVideoElement,
+	webcam_constraints?: { [key: string]: any } | null,
+	device_id?: string
+): Promise<MediaStream> {
+	const constraints: MediaStreamConstraints = {
+		video: device_id
+			? { deviceId: { exact: device_id }, ...webcam_constraints?.video }
+			: webcam_constraints?.video || {
+					width: { ideal: 1920 },
+					height: { ideal: 1440 }
+				},
+		audio: include_audio && (webcam_constraints?.audio ?? true) // Defaults to true if not specified
+	};
+
+	return navigator.mediaDevices
+		.getUserMedia(constraints)
+		.then((local_stream: MediaStream) => {
+			set_local_stream(local_stream, video_source);
+			return local_stream;
+		});
+}
+
+export function set_available_devices(
+	devices: MediaDeviceInfo[]
+): MediaDeviceInfo[] {
+	const cameras = devices.filter(
+		(device: MediaDeviceInfo) => device.kind === "videoinput"
+	);
+
+	return cameras;
+}

6.23.1/image/shared/types.ts

@@ -0,0 +1,44 @@
+import type { ILoadingStatus as LoadingStatus } from "@gradio/statustracker";
+import type { FileData } from "@gradio/client";
+import type { CustomButton } from "@gradio/utils";
+
+export interface Base64File {
+	url: string;
+	alt_text: string;
+}
+
+export interface WebcamOptions {
+	mirror: boolean;
+	constraints: MediaStreamConstraints;
+}
+
+export interface ImageProps {
+	_selectable: boolean;
+	sources: ("clipboard" | "webcam" | "upload")[];
+	height: number;
+	width: number;
+	webcam_options: WebcamOptions;
+	value: FileData | null;
+	buttons: (string | CustomButton)[];
+	pending: boolean;
+	streaming: boolean;
+	stream_every: number;
+	input_ready: boolean;
+	placeholder: string;
+	watermark: FileData | null;
+}
+
+export interface ImageEvents {
+	clear: void;
+	change: any;
+	stream: any;
+	select: any;
+	upload: any;
+	input: any;
+	clear_status: LoadingStatus;
+	share: any;
+	error: any;
+	close_stream: void;
+	edit: void;
+	custom_button_click: { id: number };
+}

6.23.1/image/shared/utils.ts

@@ -0,0 +1,27 @@
+export const get_coordinates_of_clicked_image = (
+	evt: MouseEvent
+): [number, number] | null => {
+	let image;
+	if (evt.currentTarget instanceof Element) {
+		image = evt.currentTarget.querySelector("img") as HTMLImageElement;
+	} else {
+		return [NaN, NaN];
+	}
+
+	const imageRect = image.getBoundingClientRect();
+	// The image is rendered with `object-fit: scale-down`: centered, never
+	// scaled above its natural size, so empty space can appear on both axes.
+	const scale = Math.min(
+		imageRect.width / image.naturalWidth,
+		imageRect.height / image.naturalHeight,
+		1
+	);
+	const x_offset = (imageRect.width - image.naturalWidth * scale) / 2;
+	const y_offset = (imageRect.height - image.naturalHeight * scale) / 2;
+	const x = Math.round((evt.clientX - imageRect.left - x_offset) / scale);
+	const y = Math.round((evt.clientY - imageRect.top - y_offset) / scale);
+	if (x < 0 || x >= image.naturalWidth || y < 0 || y >= image.naturalHeight) {
+		return null;
+	}
+	return [x, y];
+};