Upload folder using huggingface_hub

5.49.1/imageslider/Example.svelte

@@ -0,0 +1,69 @@
+<script lang="ts">
+	export let value: [string, string];
+	export let samples_dir: string;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</script>
+
+<!-- TODO: fix -->
+<!-- svelte-ignore a11y-missing-attribute -->
+<div
+	class="wrap"
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	<img src={samples_dir + value[0]} />
+
+	<img src={samples_dir + value[1]} />
+	<span></span>
+</div>
+
+<style>
+	.wrap {
+		position: relative;
+		height: var(--size-64);
+		width: var(--size-40);
+		overflow: hidden;
+		border-radius: var(--radius-lg);
+	}
+	img {
+		height: var(--size-64);
+		width: var(--size-40);
+		position: absolute;
+		/* border-radius: var(--radius-lg); */
+		/* max-width: none; */
+		object-fit: cover;
+	}
+
+	.wrap.selected {
+		border-color: var(--color-accent);
+	}
+	.wrap img:first-child {
+		clip-path: inset(0 50% 0 0%);
+	}
+
+	.wrap img:nth-of-type(2) {
+		clip-path: inset(0 0 0 50%);
+	}
+	span {
+		position: absolute;
+		top: 0;
+		left: calc(50% - 0.75px);
+		height: var(--size-64);
+		width: 1.5px;
+		background: var(--border-color-primary);
+	}
+
+	.table {
+		margin: 0 auto;
+		border: 2px solid var(--border-color-primary);
+		border-radius: var(--radius-lg);
+	}
+
+	.gallery {
+		border: 2px solid var(--border-color-primary);
+		/* max-height: var(--size-20); */
+		object-fit: cover;
+	}
+</style>

5.49.1/imageslider/Index.svelte

@@ -0,0 +1,212 @@
+<svelte:options accessors={true} />
+
+<script lang="ts">
+	import type { Gradio, SelectData, ValueData } from "@gradio/utils";
+	import StaticImage from "./shared/SliderPreview.svelte";
+	import ImageUploader from "./shared/SliderUpload.svelte";
+	import { afterUpdate } from "svelte";
+
+	import { Block, Empty, UploadText } from "@gradio/atoms";
+	import { Image } from "@gradio/icons";
+	import { StatusTracker } from "@gradio/statustracker";
+	import { type FileData } from "@gradio/client";
+	import type { LoadingStatus } from "@gradio/statustracker";
+
+	type sources = "upload" | "webcam" | "clipboard" | null;
+
+	export let value_is_output = false;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible: boolean | "hidden" = true;
+	export let value: [FileData | null, FileData | null] = [null, null];
+	let old_value: [FileData | null, FileData | null] = [null, null];
+	export let label: string;
+	export let show_label: boolean;
+	export let show_download_button: boolean;
+	export let root: string;
+	export let height: number | undefined;
+	export let width: number | undefined;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let loading_status: LoadingStatus;
+	export let interactive: boolean;
+	export let placeholder: string | undefined = undefined;
+	export let show_fullscreen_button: boolean;
+	let fullscreen = false;
+	export let input_ready: boolean;
+	export let slider_position: number;
+	export let upload_count = 1;
+	export let slider_color = "var(--border-color-primary)";
+	export let max_height: number;
+	let uploading = false;
+
+	$: normalised_slider_position =
+		Math.max(0, Math.min(100, slider_position)) / 100;
+
+	$: input_ready = !uploading;
+
+	export let gradio: Gradio<{
+		input: never;
+		change: never;
+		error: string;
+		edit: never;
+		stream: ValueData;
+		drag: never;
+		upload: never;
+		clear: never;
+		select: SelectData;
+		share: ShareData;
+		clear_status: LoadingStatus;
+		close_stream: string;
+	}>;
+
+	$: {
+		if (JSON.stringify(value) !== JSON.stringify(old_value)) {
+			old_value = value;
+			gradio.dispatch("change");
+			if (!value_is_output) {
+				gradio.dispatch("input");
+			}
+		}
+	}
+
+	afterUpdate(() => {
+		value_is_output = false;
+	});
+
+	let dragging: boolean;
+	let active_source: sources = null;
+	let upload_component: ImageUploader;
+
+	const handle_drag_event = (event: Event): void => {
+		const drag_event = event as DragEvent;
+		drag_event.preventDefault();
+		drag_event.stopPropagation();
+		if (drag_event.type === "dragenter" || drag_event.type === "dragover") {
+			dragging = true;
+		} else if (drag_event.type === "dragleave") {
+			dragging = false;
+		}
+	};
+
+	const handle_drop = (event: Event): void => {
+		if (interactive) {
+			const drop_event = event as DragEvent;
+			drop_event.preventDefault();
+			drop_event.stopPropagation();
+			dragging = false;
+
+			if (upload_component) {
+				upload_component.loadFilesFromDrop(drop_event);
+			}
+		}
+	};
+</script>
+
+{#if !interactive || (value?.[1] && value?.[0])}
+	<Block
+		{visible}
+		variant={"solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		{elem_id}
+		{elem_classes}
+		height={height || undefined}
+		{width}
+		allow_overflow={false}
+		{container}
+		{scale}
+		{min_width}
+		bind:fullscreen
+	>
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+		/>
+		<StaticImage
+			on:select={({ detail }) => gradio.dispatch("select", detail)}
+			on:share={({ detail }) => gradio.dispatch("share", detail)}
+			on:error={({ detail }) => gradio.dispatch("error", detail)}
+			on:clear={() => gradio.dispatch("clear")}
+			on:fullscreen={({ detail }) => {
+				fullscreen = detail;
+			}}
+			{fullscreen}
+			{interactive}
+			bind:value
+			{label}
+			{show_label}
+			{show_download_button}
+			i18n={gradio.i18n}
+			{show_fullscreen_button}
+			position={normalised_slider_position}
+			{slider_color}
+			{max_height}
+		/>
+	</Block>
+{:else}
+	<Block
+		{visible}
+		variant={value === null ? "dashed" : "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		{elem_id}
+		{elem_classes}
+		height={height || undefined}
+		{width}
+		allow_overflow={false}
+		{container}
+		{scale}
+		{min_width}
+		on:dragenter={handle_drag_event}
+		on:dragleave={handle_drag_event}
+		on:dragover={handle_drag_event}
+		on:drop={handle_drop}
+	>
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+			on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+		/>
+
+		<ImageUploader
+			bind:this={upload_component}
+			bind:value
+			bind:dragging
+			{root}
+			on:edit={() => gradio.dispatch("edit")}
+			on:clear={() => {
+				gradio.dispatch("clear");
+			}}
+			on:drag={({ detail }) => (dragging = detail)}
+			on:upload={() => gradio.dispatch("upload")}
+			on:error={({ detail }) => {
+				loading_status = loading_status || {};
+				loading_status.status = "error";
+				gradio.dispatch("error", detail);
+			}}
+			on:close_stream={() => {
+				gradio.dispatch("close_stream", "stream");
+			}}
+			{label}
+			{show_label}
+			{upload_count}
+			max_file_size={gradio.max_file_size}
+			i18n={gradio.i18n}
+			upload={(...args) => gradio.client.upload(...args)}
+			stream_handler={gradio.client?.stream}
+			{max_height}
+		>
+			{#if active_source === "upload" || !active_source}
+				<UploadText i18n={gradio.i18n} type="image" {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}

5.49.1/imageslider/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "@gradio/imageslider",
+	"version": "0.3.0",
+	"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:^",
+		"@types/d3-drag": "^3.0.7",
+		"@types/d3-selection": "^3.0.11",
+		"d3-drag": "^3.0.0",
+		"d3-selection": "^3.0.0"
+	},
+	"exports": {
+		".": {
+			"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"
+		},
+		"./package.json": "./package.json"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/imageslider"
+	}
+}

5.49.1/imageslider/shared/ClearImage.svelte

@@ -0,0 +1,30 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import { IconButton } from "@gradio/atoms";
+	import { Clear } from "@gradio/icons";
+
+	const dispatch = createEventDispatcher();
+</script>
+
+<div>
+	<IconButton
+		Icon={Clear}
+		label="Remove Image"
+		on:click={(event) => {
+			dispatch("remove_image");
+			event.stopPropagation();
+		}}
+	/>
+</div>
+
+<style>
+	div {
+		display: flex;
+		position: absolute;
+		top: var(--size-2);
+		right: var(--size-2);
+		justify-content: flex-end;
+		gap: var(--spacing-sm);
+		z-index: var(--layer-5);
+	}
+</style>

5.49.1/imageslider/shared/Image.svelte

@@ -0,0 +1,234 @@
+<script lang="ts">
+	import Slider from "./Slider.svelte";
+	import { createEventDispatcher, tick } from "svelte";
+	import { BlockLabel, Empty, IconButton, DownloadLink } from "@gradio/atoms";
+	import { Download } from "@gradio/icons";
+	import { Image } from "@gradio/icons";
+	import { type SelectData, type I18nFormatter } from "@gradio/utils";
+	import ClearImage from "./ClearImage.svelte";
+	import ImageEl from "./ImageEl.svelte";
+
+	import { Upload } from "@gradio/upload";
+
+	import { type FileData, type Client } from "@gradio/client";
+
+	export let value: [FileData | null, FileData | null];
+
+	export let label: string | undefined = undefined;
+	export let show_label: boolean;
+	export let root: string;
+	export let position: number;
+	export let upload_count = 2;
+
+	export let show_download_button = true;
+	export let slider_color: string;
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let max_file_size: number | null = null;
+	export let i18n: I18nFormatter;
+	export let max_height: number;
+
+	let value_: [FileData | null, FileData | null] = value || [null, null];
+
+	let img: HTMLImageElement;
+	let el_width: number;
+	let el_height: number;
+
+	async function handle_upload(
+		{ detail }: CustomEvent<FileData[]>,
+		n: number
+	): Promise<void> {
+		const new_value = [value[0], value[1]] as [
+			FileData | null,
+			FileData | null
+		];
+		if (detail.length > 1) {
+			new_value[n] = detail[0];
+		} else {
+			new_value[n] = detail[n];
+		}
+		value = new_value;
+		await tick();
+
+		dispatch("upload", new_value);
+	}
+
+	let old_value = "";
+
+	$: if (JSON.stringify(value) !== old_value) {
+		old_value = JSON.stringify(value);
+		value_ = value;
+	}
+
+	const dispatch = createEventDispatcher<{
+		change: string | null;
+		stream: string | null;
+		edit: undefined;
+		clear: undefined;
+		drag: boolean;
+		upload: [FileData | null, FileData | null];
+		select: SelectData;
+	}>();
+
+	export let dragging = false;
+
+	$: dispatch("drag", dragging);
+</script>
+
+<BlockLabel {show_label} Icon={Image} label={label || i18n("image.image")} />
+
+<div
+	data-testid="image"
+	class="image-container"
+	bind:clientWidth={el_width}
+	bind:clientHeight={el_height}
+>
+	{#if value?.[0]?.url || value?.[1]?.url}
+		<ClearImage
+			on:remove_image={() => {
+				position = 0.5;
+				value = [null, null];
+				dispatch("clear");
+			}}
+		/>
+	{/if}
+	{#if value?.[1]?.url}
+		<div class="icon-buttons">
+			{#if show_download_button}
+				<DownloadLink
+					href={value[1].url}
+					download={value[1].orig_name || "image"}
+				>
+					<IconButton Icon={Download} />
+				</DownloadLink>
+			{/if}
+		</div>
+	{/if}
+	<Slider
+		bind:position
+		disabled={upload_count == 2 || !value?.[0]}
+		{slider_color}
+	>
+		<div
+			class="upload-wrap"
+			style:display={upload_count === 2 ? "flex" : "block"}
+			class:side-by-side={upload_count === 2}
+		>
+			{#if !value_?.[0]}
+				<div class="wrap" class:half-wrap={upload_count === 1}>
+					<Upload
+						bind:dragging
+						filetype="image/*"
+						on:load={(e) => handle_upload(e, 0)}
+						disable_click={!!value?.[0]}
+						{root}
+						file_count="multiple"
+						{upload}
+						{stream_handler}
+						{max_file_size}
+					>
+						<slot />
+					</Upload>
+				</div>
+			{:else}
+				<ImageEl
+					variant="upload"
+					src={value_[0]?.url}
+					alt=""
+					bind:img_el={img}
+					{max_height}
+				/>
+			{/if}
+
+			{#if !value_?.[1] && upload_count === 2}
+				<Upload
+					bind:dragging
+					filetype="image/*"
+					on:load={(e) => handle_upload(e, 1)}
+					disable_click={!!value?.[1]}
+					{root}
+					file_count="multiple"
+					{upload}
+					{stream_handler}
+					{max_file_size}
+				>
+					<slot />
+				</Upload>
+			{:else if !value_?.[1] && upload_count === 1}
+				<div
+					class="empty-wrap fixed"
+					style:width="{el_width * (1 - position)}px"
+					style:transform="translateX({el_width * position}px)"
+					class:white-icon={!value?.[0]?.url}
+				>
+					<Empty unpadded_box={true} size="large"><Image /></Empty>
+				</div>
+			{:else if value_?.[1]}
+				<ImageEl
+					variant="upload"
+					src={value_[1].url}
+					alt=""
+					fixed={upload_count === 1}
+					transform="translate(0px, 0px) scale(1)"
+					{max_height}
+				/>
+			{/if}
+		</div>
+	</Slider>
+</div>
+
+<style>
+	.upload-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		height: 100%;
+		width: 100%;
+	}
+
+	.wrap {
+		width: 100%;
+	}
+
+	.half-wrap {
+		width: 50%;
+	}
+	.image-container,
+	.empty-wrap {
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+
+	.fixed {
+		--anim-block-background-fill: 255, 255, 255;
+		position: absolute;
+		top: 0;
+		left: 0;
+		background-color: rgba(var(--anim-block-background-fill), 0.8);
+		z-index: 0;
+	}
+
+	@media (prefers-color-scheme: dark) {
+		.fixed {
+			--anim-block-background-fill: 31, 41, 55;
+		}
+	}
+
+	.side-by-side :global(img) {
+		/* width: 100%; */
+		width: 50%;
+		object-fit: contain;
+	}
+
+	.empty-wrap {
+		pointer-events: none;
+	}
+
+	.icon-buttons {
+		display: flex;
+		position: absolute;
+		right: 8px;
+		z-index: var(--layer-top);
+		top: 8px;
+	}
+</style>

5.49.1/imageslider/shared/ImageEl.svelte

@@ -0,0 +1,141 @@
+<script lang="ts">
+	import type { HTMLImgAttributes } from "svelte/elements";
+	import { createEventDispatcher, onMount, tick } from "svelte";
+	interface Props extends HTMLImgAttributes {
+		"data-testid"?: string;
+		fixed?: boolean;
+		transform?: string;
+		img_el?: HTMLImageElement;
+		hidden?: boolean;
+		variant?: "preview" | "upload";
+		max_height?: number;
+		fullscreen?: boolean;
+	}
+	type $$Props = Props;
+
+	export let src: HTMLImgAttributes["src"] = undefined;
+	export let fullscreen = false;
+
+	export let fixed = false;
+	export let transform = "translate(0px, 0px) scale(1)";
+	export let img_el: HTMLImageElement | null = null;
+	export let hidden = false;
+	export let variant = "upload";
+	export let max_height = 500;
+
+	const dispatch = createEventDispatcher<{
+		load: {
+			top: number;
+			left: number;
+			width: number;
+			height: number;
+		};
+	}>();
+
+	function get_image_size(img: HTMLImageElement | null): {
+		top: number;
+		left: number;
+		width: number;
+		height: number;
+	} {
+		if (!img) return { top: 0, left: 0, width: 0, height: 0 };
+		const container = img.parentElement?.getBoundingClientRect();
+
+		if (!container) return { top: 0, left: 0, width: 0, height: 0 };
+
+		const naturalAspect = img.naturalWidth / img.naturalHeight;
+		const containerAspect = container.width / container.height;
+		let displayedWidth, displayedHeight;
+
+		if (naturalAspect > containerAspect) {
+			displayedWidth = container.width;
+			displayedHeight = container.width / naturalAspect;
+		} else {
+			displayedHeight = container.height;
+			displayedWidth = container.height * naturalAspect;
+		}
+
+		const offsetX = (container.width - displayedWidth) / 2;
+		const offsetY = (container.height - displayedHeight) / 2;
+
+		return {
+			top: offsetY,
+			left: offsetX,
+			width: displayedWidth,
+			height: displayedHeight
+		};
+	}
+
+	onMount(() => {
+		const resizer = new ResizeObserver(async (entries) => {
+			for (const entry of entries) {
+				await tick();
+				dispatch("load", get_image_size(img_el));
+			}
+		});
+
+		resizer.observe(img_el!);
+
+		return () => {
+			resizer.disconnect();
+		};
+	});
+</script>
+
+<!-- svelte-ignore a11y-missing-attribute -->
+<img
+	{src}
+	{...$$restProps}
+	class:fixed
+	style:transform
+	bind:this={img_el}
+	class:hidden
+	class:preview={variant === "preview"}
+	class:slider={variant === "upload"}
+	style:max-height={max_height && !fullscreen ? `${max_height}px` : null}
+	class:fullscreen
+	class:small={!fullscreen}
+	on:load={() => dispatch("load", get_image_size(img_el))}
+/>
+
+<style>
+	.preview {
+		object-fit: contain;
+		width: 100%;
+		transform-origin: top left;
+		margin: auto;
+	}
+
+	.small {
+		max-height: 500px;
+	}
+
+	.upload {
+		object-fit: contain;
+		max-height: 500px;
+	}
+
+	.fixed {
+		position: absolute;
+		top: 0;
+		left: 0;
+		right: 0;
+		bottom: 0;
+	}
+
+	.fullscreen {
+		width: 100%;
+		height: 100%;
+	}
+
+	:global(.image-container:fullscreen) img {
+		width: 100%;
+		height: 100%;
+		max-height: none;
+		max-width: none;
+	}
+
+	.hidden {
+		opacity: 0;
+	}
+</style>

5.49.1/imageslider/shared/Slider.svelte

@@ -0,0 +1,200 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import { drag } from "d3-drag";
+	import { select } from "d3-selection";
+
+	function clamp(value: number, min: number, max: number): number {
+		return Math.min(Math.max(value, min), max);
+	}
+
+	export let position = 0.5;
+	export let disabled = false;
+
+	export let slider_color = "var(--border-color-primary)";
+	export let image_size: {
+		top: number;
+		left: number;
+		width: number;
+		height: number;
+	} = { top: 0, left: 0, width: 0, height: 0 };
+	export let el: HTMLDivElement | undefined = undefined;
+	export let parent_el: HTMLDivElement | undefined = undefined;
+	let inner: Element;
+	let px = 0;
+	let active = false;
+	let container_width = 0;
+
+	function set_position(width: number): void {
+		container_width = parent_el?.getBoundingClientRect().width || 0;
+		if (width === 0) {
+			image_size.width = el?.getBoundingClientRect().width || 0;
+		}
+
+		px = clamp(
+			image_size.width * position + image_size.left,
+			0,
+			container_width
+		);
+	}
+
+	function round(n: number, points: number): number {
+		const mod = Math.pow(10, points);
+		return Math.round((n + Number.EPSILON) * mod) / mod;
+	}
+
+	function update_position(x: number): void {
+		px = clamp(x, 0, container_width);
+		position = round((x - image_size.left) / image_size.width, 5);
+	}
+
+	function drag_start(event: any): void {
+		if (disabled) return;
+		active = true;
+		update_position(event.x);
+	}
+
+	function drag_move(event: any): void {
+		if (disabled) return;
+		update_position(event.x);
+	}
+
+	function drag_end(): void {
+		if (disabled) return;
+		active = false;
+	}
+
+	function update_position_from_pc(pc: number): void {
+		px = clamp(image_size.width * pc + image_size.left, 0, container_width);
+	}
+
+	$: set_position(image_size.width);
+	$: update_position_from_pc(position);
+
+	onMount(() => {
+		set_position(image_size.width);
+		const drag_handler = drag()
+			.on("start", drag_start)
+			.on("drag", drag_move)
+			.on("end", drag_end);
+		select(inner).call(drag_handler);
+	});
+</script>
+
+<svelte:window on:resize={() => set_position(image_size.width)} />
+
+<div class="wrap" role="none" bind:this={parent_el}>
+	<div class="content" bind:this={el}>
+		<slot />
+	</div>
+	<div
+		class="outer"
+		class:disabled
+		bind:this={inner}
+		role="none"
+		style="transform: translateX({px}px)"
+		class:grab={active}
+	>
+		<span class="icon-wrap" class:active class:disabled
+			><span class="icon left">◢</span><span
+				class="icon center"
+				style:--color={slider_color}
+			></span><span class="icon right">◢</span></span
+		>
+		<div class="inner" style:--color={slider_color}></div>
+	</div>
+</div>
+
+<style>
+	.wrap {
+		position: relative;
+		width: 100%;
+		height: 100%;
+		z-index: var(--layer-1);
+		overflow: hidden;
+	}
+
+	.icon-wrap {
+		display: block;
+		position: absolute;
+		top: 50%;
+		transform: translate(-20.5px, -50%);
+		left: 10px;
+		width: 40px;
+		transition: 0.2s;
+		color: var(--body-text-color);
+		height: 30px;
+		border-radius: 5px;
+		background-color: var(--color-accent);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		z-index: var(--layer-3);
+		box-shadow: 0px 0px 5px 2px rgba(0, 0, 0, 0.3);
+		font-size: 12px;
+	}
+
+	.icon.left {
+		transform: rotate(135deg);
+		text-shadow: -1px -1px 1px rgba(0, 0, 0, 0.1);
+	}
+
+	.icon.right {
+		transform: rotate(-45deg);
+		text-shadow: -1px -1px 1px rgba(0, 0, 0, 0.1);
+	}
+
+	.icon.center {
+		display: block;
+		width: 1px;
+		height: 100%;
+		background-color: var(--color);
+		opacity: 0.1;
+	}
+
+	.icon-wrap.active {
+		opacity: 0;
+	}
+
+	.icon-wrap.disabled {
+		opacity: 0;
+	}
+
+	.outer {
+		width: 20px;
+		height: 100%;
+		position: absolute;
+		cursor: grab;
+		position: absolute;
+		top: 0;
+		left: -10px;
+		pointer-events: auto;
+		z-index: var(--layer-2);
+	}
+	.grab {
+		cursor: grabbing;
+	}
+
+	.inner {
+		width: 1px;
+		height: 100%;
+		background: var(--color);
+		position: absolute;
+		left: calc((100% - 2px) / 2);
+	}
+
+	.disabled {
+		cursor: auto;
+	}
+
+	.disabled .inner {
+		box-shadow: none;
+	}
+
+	.content {
+		width: 100%;
+		height: 100%;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+	}
+</style>

5.49.1/imageslider/shared/SliderPreview.svelte

@@ -0,0 +1,229 @@
+<script lang="ts">
+	import Slider from "./Slider.svelte";
+	import ImageEl from "./ImageEl.svelte";
+	import {
+		BlockLabel,
+		Empty,
+		IconButton,
+		IconButtonWrapper,
+		FullscreenButton,
+		DownloadLink
+	} from "@gradio/atoms";
+	import { Image, Download, Undo, Clear } from "@gradio/icons";
+	import { type FileData } from "@gradio/client";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { ZoomableImage } from "./zoom";
+	import { onMount } from "svelte";
+	import { tweened, type Tweened } from "svelte/motion";
+	import { createEventDispatcher } from "svelte";
+
+	export let value: [null | FileData, null | FileData] = [null, null];
+	export let label: string | undefined = undefined;
+	export let show_download_button = true;
+	export let show_label: boolean;
+	export let i18n: I18nFormatter;
+	export let position: number;
+	export let layer_images = true;
+	export let show_single = false;
+	export let slider_color: string;
+	export let show_fullscreen_button = true;
+	export let fullscreen = false;
+	export let el_width = 0;
+	export let max_height: number;
+	export let interactive = true;
+	const dispatch = createEventDispatcher<{ clear: void }>();
+
+	let img: HTMLImageElement;
+	let slider_wrap: HTMLDivElement;
+	let image_container: HTMLDivElement;
+
+	let transform: Tweened<{ x: number; y: number; z: number }> = tweened(
+		{ x: 0, y: 0, z: 1 },
+		{
+			duration: 75
+		}
+	);
+	let parent_el: HTMLDivElement;
+
+	$: coords_at_viewport = get_coords_at_viewport(
+		position,
+		viewport_width,
+		image_size.width,
+		image_size.left,
+		$transform.x,
+		$transform.z
+	);
+	$: style = layer_images
+		? `clip-path: inset(0 0 0 ${coords_at_viewport * 100}%)`
+		: "";
+
+	function get_coords_at_viewport(
+		viewport_percent_x: number, // 0-1
+		viewportWidth: number,
+		image_width: number,
+		img_offset_x: number,
+		tx: number, // image translation x (in pixels)
+		scale: number // image scale (uniform)
+	): number {
+		const px_relative_to_image = viewport_percent_x * image_width;
+		const pixel_position = px_relative_to_image + img_offset_x;
+
+		const normalised_position = (pixel_position - tx) / scale;
+		const percent_position = normalised_position / viewportWidth;
+
+		return percent_position;
+	}
+
+	let img_width = 0;
+	let viewport_width = 0;
+
+	let zoomable_image: ZoomableImage | null = null;
+	let observer: ResizeObserver | null = null;
+
+	function init_image(
+		img: HTMLImageElement,
+		slider_wrap: HTMLDivElement
+	): void {
+		if (!img || !slider_wrap) return;
+		zoomable_image?.destroy();
+		observer?.disconnect();
+		img_width = img?.getBoundingClientRect().width || 0;
+		viewport_width = slider_wrap?.getBoundingClientRect().width || 0;
+		zoomable_image = new ZoomableImage(slider_wrap, img);
+		zoomable_image.subscribe(({ x, y, scale }) => {
+			transform.set({ x, y, z: scale });
+		});
+
+		observer = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				if (entry.target === slider_wrap) {
+					viewport_width = entry.contentRect.width;
+				}
+
+				if (entry.target === img) {
+					img_width = entry.contentRect.width;
+				}
+			}
+		});
+		observer.observe(slider_wrap);
+		observer.observe(img);
+	}
+
+	$: init_image(img, slider_wrap);
+
+	onMount(() => {
+		return () => {
+			zoomable_image?.destroy();
+			observer?.disconnect();
+		};
+	});
+
+	let slider_wrap_parent: HTMLDivElement;
+
+	let image_size: { top: number; left: number; width: number; height: number } =
+		{ top: 0, left: 0, width: 0, height: 0 };
+
+	function handle_image_load(event: CustomEvent): void {
+		image_size = event.detail;
+	}
+</script>
+
+<BlockLabel {show_label} Icon={Image} label={label || i18n("image.image")} />
+{#if (value === null || value[0] === null || value[1] === null) && !show_single}
+	<Empty unpadded_box={true} size="large"><Image /></Empty>
+{:else}
+	<div class="image-container" bind:this={image_container}>
+		<IconButtonWrapper>
+			<IconButton
+				Icon={Undo}
+				label={i18n("common.undo")}
+				disabled={$transform.z === 1}
+				on:click={() => zoomable_image?.reset_zoom()}
+			/>
+			{#if show_fullscreen_button}
+				<FullscreenButton {fullscreen} on:fullscreen />
+			{/if}
+
+			{#if show_download_button}
+				<DownloadLink
+					href={value[1]?.url}
+					download={value[1]?.orig_name || "image"}
+				>
+					<IconButton Icon={Download} label={i18n("common.download")} />
+				</DownloadLink>
+			{/if}
+			{#if interactive}
+				<IconButton
+					Icon={Clear}
+					label="Remove Image"
+					on:click={(event) => {
+						value = [null, null];
+						dispatch("clear");
+						event.stopPropagation();
+					}}
+				/>
+			{/if}
+		</IconButtonWrapper>
+		<div
+			class="slider-wrap"
+			bind:this={slider_wrap_parent}
+			bind:clientWidth={el_width}
+			class:limit_height={!fullscreen}
+		>
+			<Slider
+				bind:position
+				{slider_color}
+				bind:el={slider_wrap}
+				bind:parent_el
+				{image_size}
+			>
+				<ImageEl
+					src={value?.[0]?.url}
+					alt=""
+					loading="lazy"
+					bind:img_el={img}
+					variant="preview"
+					transform="translate({$transform.x}px, {$transform.y}px) scale({$transform.z})"
+					{fullscreen}
+					{max_height}
+					on:load={handle_image_load}
+				/>
+				<ImageEl
+					variant="preview"
+					fixed={layer_images}
+					hidden={!value?.[1]?.url}
+					src={value?.[1]?.url}
+					alt=""
+					loading="lazy"
+					style="{style}; background: var(--block-background-fill);"
+					transform="translate({$transform.x}px, {$transform.y}px) scale({$transform.z})"
+					{fullscreen}
+					{max_height}
+					on:load={handle_image_load}
+				/>
+			</Slider>
+		</div>
+	</div>
+{/if}
+
+<style>
+	.slider-wrap {
+		user-select: none;
+		height: 100%;
+		width: 100%;
+		position: relative;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.limit_height :global(img) {
+		max-height: 500px;
+	}
+
+	.image-container {
+		height: 100%;
+		position: relative;
+		min-width: var(--size-20);
+	}
+</style>

5.49.1/imageslider/shared/SliderUpload.svelte

@@ -0,0 +1,46 @@
+<svelte:options accessors={true} />
+
+<script lang="ts">
+	import type { I18nFormatter } from "@gradio/utils";
+	import Image from "./Image.svelte";
+	import { type Client } from "@gradio/client";
+
+	import type { FileData } from "@gradio/client";
+
+	export let value: [FileData | null, FileData | null] = [null, null];
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let label: string;
+	export let show_label: boolean;
+	export let i18n: I18nFormatter;
+	export let root: string;
+	export let upload_count = 1;
+	export let dragging: boolean;
+	export let max_height: number;
+	export let max_file_size: number | null = null;
+</script>
+
+<Image
+	slider_color="var(--border-color-primary)"
+	position={0.5}
+	bind:value
+	bind:dragging
+	{root}
+	on:edit
+	on:clear
+	on:stream
+	on:drag={({ detail }) => (dragging = detail)}
+	on:upload
+	on:select
+	on:share
+	{label}
+	{show_label}
+	{upload_count}
+	{stream_handler}
+	{upload}
+	{max_file_size}
+	{max_height}
+	{i18n}
+>
+	<slot />
+</Image>

5.49.1/imageslider/shared/zoom.ts

@@ -0,0 +1,487 @@
+export class ZoomableImage {
+	container: HTMLDivElement;
+	image: HTMLImageElement;
+	scale: number;
+	offsetX: number;
+	offsetY: number;
+	isDragging: boolean;
+	lastX: number;
+	lastY: number;
+	initial_left_padding: number;
+	initial_top_padding: number;
+	initial_width: number;
+	initial_height: number;
+	subscribers: (({
+		x,
+		y,
+		scale
+	}: {
+		x: number;
+		y: number;
+		scale: number;
+	}) => void)[];
+	handleImageLoad: () => void;
+	real_image_size: {
+		top: number;
+		left: number;
+		width: number;
+		height: number;
+	} = { top: 0, left: 0, width: 0, height: 0 };
+
+	last_touch_distance: number;
+
+	constructor(container: HTMLDivElement, image: HTMLImageElement) {
+		this.container = container;
+		this.image = image;
+
+		this.scale = 1;
+		this.offsetX = 0;
+		this.offsetY = 0;
+		this.isDragging = false;
+		this.lastX = 0;
+		this.lastY = 0;
+		this.initial_left_padding = 0;
+		this.initial_top_padding = 0;
+		this.initial_width = 0;
+		this.initial_height = 0;
+		this.subscribers = [];
+		this.last_touch_distance = 0;
+
+		this.handleWheel = this.handleWheel.bind(this);
+		this.handleMouseDown = this.handleMouseDown.bind(this);
+		this.handleMouseMove = this.handleMouseMove.bind(this);
+		this.handleMouseUp = this.handleMouseUp.bind(this);
+		this.handleImageLoad = this.init.bind(this);
+		this.handleTouchStart = this.handleTouchStart.bind(this);
+		this.handleTouchMove = this.handleTouchMove.bind(this);
+		this.handleTouchEnd = this.handleTouchEnd.bind(this);
+
+		this.image.addEventListener("load", this.handleImageLoad);
+
+		this.container.addEventListener("wheel", this.handleWheel);
+		this.container.addEventListener("mousedown", this.handleMouseDown);
+		document.addEventListener("mousemove", this.handleMouseMove);
+		document.addEventListener("mouseup", this.handleMouseUp);
+
+		this.container.addEventListener("touchstart", this.handleTouchStart);
+		document.addEventListener("touchmove", this.handleTouchMove);
+		document.addEventListener("touchend", this.handleTouchEnd);
+
+		const observer = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				if (entry.target === this.container) {
+					this.handleResize();
+					this.get_image_size(this.image);
+				}
+			}
+		});
+		observer.observe(this.container);
+	}
+
+	handleResize(): void {
+		this.init();
+	}
+
+	init(): void {
+		const containerRect = this.container.getBoundingClientRect();
+
+		const imageRect = this.image.getBoundingClientRect();
+		this.initial_left_padding = imageRect.left - containerRect.left;
+		this.initial_top_padding = imageRect.top - containerRect.top;
+		this.initial_width = imageRect.width;
+		this.initial_height = imageRect.height;
+
+		this.reset_zoom();
+
+		this.updateTransform();
+	}
+
+	reset_zoom(): void {
+		this.scale = 1;
+		this.offsetX = 0;
+		this.offsetY = 0;
+		this.updateTransform();
+	}
+
+	handleMouseDown(e: MouseEvent): void {
+		const imageRect = this.image.getBoundingClientRect();
+
+		if (
+			e.clientX >= imageRect.left &&
+			e.clientX <= imageRect.right &&
+			e.clientY >= imageRect.top &&
+			e.clientY <= imageRect.bottom
+		) {
+			e.preventDefault();
+			if (this.scale === 1) return;
+			this.isDragging = true;
+			this.lastX = e.clientX;
+			this.lastY = e.clientY;
+			this.image.style.cursor = "grabbing";
+		}
+	}
+
+	handleMouseMove(e: MouseEvent): void {
+		if (!this.isDragging) return;
+
+		const deltaX = e.clientX - this.lastX;
+		const deltaY = e.clientY - this.lastY;
+
+		this.offsetX += deltaX;
+		this.offsetY += deltaY;
+
+		this.lastX = e.clientX;
+		this.lastY = e.clientY;
+
+		this.updateTransform();
+
+		this.updateTransform();
+	}
+
+	handleMouseUp(): void {
+		if (this.isDragging) {
+			this.constrain_to_bounds(true);
+			this.updateTransform();
+			this.isDragging = false;
+			this.image.style.cursor = this.scale > 1 ? "grab" : "zoom-in";
+		}
+	}
+
+	async handleWheel(e: WheelEvent): Promise<void> {
+		e.preventDefault();
+
+		const containerRect = this.container.getBoundingClientRect();
+		const imageRect = this.image.getBoundingClientRect();
+
+		if (
+			e.clientX < imageRect.left ||
+			e.clientX > imageRect.right ||
+			e.clientY < imageRect.top ||
+			e.clientY > imageRect.bottom
+		) {
+			return;
+		}
+
+		const zoomFactor = 1.05;
+		const oldScale = this.scale;
+		const newScale =
+			-Math.sign(e.deltaY) > 0
+				? Math.min(15, oldScale * zoomFactor) // in
+				: Math.max(1, oldScale / zoomFactor); // out
+
+		if (newScale === oldScale) return;
+
+		const cursorX = e.clientX - containerRect.left - this.initial_left_padding;
+		const cursorY = e.clientY - containerRect.top - this.initial_top_padding;
+
+		this.scale = newScale;
+		this.offsetX = this.compute_new_offset({
+			cursor_position: cursorX,
+			current_offset: this.offsetX,
+			new_scale: newScale,
+			old_scale: oldScale
+		});
+		this.offsetY = this.compute_new_offset({
+			cursor_position: cursorY,
+			current_offset: this.offsetY,
+			new_scale: newScale,
+			old_scale: oldScale
+		});
+
+		this.updateTransform(); // apply before constraints
+
+		this.constrain_to_bounds();
+		this.updateTransform(); // apply again after constraints
+
+		this.image.style.cursor = this.scale > 1 ? "grab" : "zoom-in";
+	}
+
+	// compute_offset_for_positions({ position: number, scale: number }) {
+	// 	return position - (scale / this.scale) * (position - this.offset);
+	// }
+
+	compute_new_position({
+		position,
+		scale,
+		anchor_position
+	}: {
+		position: number;
+		scale: number;
+		anchor_position: number;
+	}): number {
+		return position - (position - anchor_position) * (scale / this.scale);
+	}
+
+	compute_new_offset({
+		cursor_position,
+		current_offset,
+		new_scale,
+		old_scale
+	}: {
+		cursor_position: number;
+		current_offset: number;
+		new_scale: number;
+		old_scale: number;
+	}): number {
+		return (
+			cursor_position -
+			(new_scale / old_scale) * (cursor_position - current_offset)
+		);
+	}
+
+	constrain_to_bounds(pan = false): void {
+		if (this.scale === 1) {
+			this.offsetX = 0;
+			this.offsetY = 0;
+			return;
+		}
+		const onscreen = {
+			top: this.real_image_size.top * this.scale + this.offsetY,
+			left: this.real_image_size.left * this.scale + this.offsetX,
+			width: this.real_image_size.width * this.scale,
+			height: this.real_image_size.height * this.scale,
+
+			bottom:
+				this.real_image_size.top * this.scale +
+				this.offsetY +
+				this.real_image_size.height * this.scale,
+			right:
+				this.real_image_size.left * this.scale +
+				this.offsetX +
+				this.real_image_size.width * this.scale
+		};
+
+		const real_image_size_right =
+			this.real_image_size.left + this.real_image_size.width;
+		const real_image_size_bottom =
+			this.real_image_size.top + this.real_image_size.height;
+
+		if (pan) {
+			if (onscreen.top > this.real_image_size.top) {
+				this.offsetY = this.calculate_position(
+					this.real_image_size.top,
+					0,
+					"y"
+				);
+			} else if (onscreen.bottom < real_image_size_bottom) {
+				this.offsetY = this.calculate_position(real_image_size_bottom, 1, "y");
+			}
+
+			if (onscreen.left > this.real_image_size.left) {
+				this.offsetX = this.calculate_position(
+					this.real_image_size.left,
+					0,
+					"x"
+				);
+			} else if (onscreen.right < real_image_size_right) {
+				this.offsetX = this.calculate_position(real_image_size_right, 1, "x");
+			}
+		}
+	}
+
+	updateTransform(): void {
+		this.notify({ x: this.offsetX, y: this.offsetY, scale: this.scale });
+	}
+
+	destroy(): void {
+		this.container.removeEventListener("wheel", this.handleWheel);
+		this.container.removeEventListener("mousedown", this.handleMouseDown);
+		document.removeEventListener("mousemove", this.handleMouseMove);
+		document.removeEventListener("mouseup", this.handleMouseUp);
+		this.container.removeEventListener("touchstart", this.handleTouchStart);
+		document.removeEventListener("touchmove", this.handleTouchMove);
+		document.removeEventListener("touchend", this.handleTouchEnd);
+		this.image.removeEventListener("load", this.handleImageLoad);
+	}
+
+	subscribe(
+		cb: ({ x, y, scale }: { x: number; y: number; scale: number }) => void
+	): void {
+		this.subscribers.push(cb);
+	}
+
+	unsubscribe(
+		cb: ({ x, y, scale }: { x: number; y: number; scale: number }) => void
+	): void {
+		this.subscribers = this.subscribers.filter(
+			(subscriber) => subscriber !== cb
+		);
+	}
+
+	notify({ x, y, scale }: { x: number; y: number; scale: number }): void {
+		this.subscribers.forEach((subscriber) => subscriber({ x, y, scale }));
+	}
+
+	handleTouchStart(e: TouchEvent): void {
+		e.preventDefault();
+		const imageRect = this.image.getBoundingClientRect();
+		const touch = e.touches[0];
+
+		if (
+			touch.clientX >= imageRect.left &&
+			touch.clientX <= imageRect.right &&
+			touch.clientY >= imageRect.top &&
+			touch.clientY <= imageRect.bottom
+		) {
+			if (e.touches.length === 1 && this.scale > 1) {
+				// one finger == prepare pan
+				this.isDragging = true;
+				this.lastX = touch.clientX;
+				this.lastY = touch.clientY;
+			} else if (e.touches.length === 2) {
+				// two fingers == prepare pinch zoom
+				const touch1 = e.touches[0];
+				const touch2 = e.touches[1];
+				this.last_touch_distance = Math.hypot(
+					touch2.clientX - touch1.clientX,
+					touch2.clientY - touch1.clientY
+				);
+			}
+		}
+	}
+
+	get_image_size(img: HTMLImageElement | null): void {
+		if (!img) return;
+		const container = img.parentElement?.getBoundingClientRect();
+
+		if (!container) return;
+
+		const naturalAspect = img.naturalWidth / img.naturalHeight;
+		const containerAspect = container.width / container.height;
+		let displayedWidth, displayedHeight;
+
+		if (naturalAspect > containerAspect) {
+			displayedWidth = container.width;
+			displayedHeight = container.width / naturalAspect;
+		} else {
+			displayedHeight = container.height;
+			displayedWidth = container.height * naturalAspect;
+		}
+
+		const offsetX = (container.width - displayedWidth) / 2;
+		const offsetY = (container.height - displayedHeight) / 2;
+
+		this.real_image_size = {
+			top: offsetY,
+			left: offsetX,
+			width: displayedWidth,
+			height: displayedHeight
+		};
+	}
+
+	handleTouchMove(e: TouchEvent): void {
+		if (e.touches.length === 1 && this.isDragging) {
+			// one finger == pan
+			e.preventDefault();
+			const touch = e.touches[0];
+
+			const deltaX = touch.clientX - this.lastX;
+			const deltaY = touch.clientY - this.lastY;
+
+			this.offsetX += deltaX;
+			this.offsetY += deltaY;
+
+			this.lastX = touch.clientX;
+			this.lastY = touch.clientY;
+
+			this.updateTransform();
+		} else if (e.touches.length === 2) {
+			// two fingers == pinch zoom
+			e.preventDefault();
+
+			const touch1 = e.touches[0];
+			const touch2 = e.touches[1];
+
+			const current_distance = Math.hypot(
+				touch2.clientX - touch1.clientX,
+				touch2.clientY - touch1.clientY
+			);
+
+			if (this.last_touch_distance === 0) {
+				this.last_touch_distance = current_distance;
+				return;
+			}
+
+			const zoomFactor = current_distance / this.last_touch_distance;
+
+			const oldScale = this.scale;
+			const newScale = Math.min(15, Math.max(1, oldScale * zoomFactor));
+
+			if (newScale === oldScale) {
+				this.last_touch_distance = current_distance;
+				return;
+			}
+
+			// midpoint of touches relative to image
+			const containerRect = this.container.getBoundingClientRect();
+			const midX =
+				(touch1.clientX + touch2.clientX) / 2 -
+				containerRect.left -
+				this.initial_left_padding;
+			const midY =
+				(touch1.clientY + touch2.clientY) / 2 -
+				containerRect.top -
+				this.initial_top_padding;
+
+			this.scale = newScale;
+			this.offsetX = this.compute_new_offset({
+				cursor_position: midX,
+				current_offset: this.offsetX,
+				new_scale: newScale,
+				old_scale: oldScale
+			});
+			this.offsetY = this.compute_new_offset({
+				cursor_position: midY,
+				current_offset: this.offsetY,
+				new_scale: newScale,
+				old_scale: oldScale
+			});
+
+			this.updateTransform();
+			this.constrain_to_bounds();
+			this.updateTransform();
+
+			this.last_touch_distance = current_distance;
+
+			this.image.style.cursor = this.scale > 1 ? "grab" : "zoom-in";
+		}
+	}
+
+	handleTouchEnd(e: TouchEvent): void {
+		if (this.isDragging) {
+			this.constrain_to_bounds(true);
+			this.updateTransform();
+			this.isDragging = false;
+		}
+
+		if (e.touches.length === 0) {
+			this.last_touch_distance = 0;
+		}
+	}
+
+	calculate_position(
+		screen_coord: number,
+		image_anchor: number,
+		axis: "x" | "y"
+	): number {
+		const containerRect = this.container.getBoundingClientRect();
+
+		// Calculate X offset if requested
+		if (axis === "x") {
+			const relative_screen_x = screen_coord;
+			const anchor_x =
+				this.real_image_size.left + image_anchor * this.real_image_size.width;
+			return relative_screen_x - anchor_x * this.scale;
+		}
+
+		// Calculate Y offset if requested
+		if (axis === "y") {
+			const relative_screen_y = screen_coord;
+			const anchor_y =
+				this.real_image_size.top + image_anchor * this.real_image_size.height;
+			return relative_screen_y - anchor_y * this.scale;
+		}
+
+		return 0;
+	}
+}