Upload folder using huggingface_hub

6.19.0/multimodaltextbox/Example.svelte

@@ -0,0 +1,104 @@
+<script lang="ts">
+	import { Image } from "@gradio/image/shared";
+	import { Video } from "@gradio/video/shared";
+	import type { FileData } from "@gradio/client";
+
+	let {
+		value = { text: "", files: [] },
+		type,
+		selected = false
+	}: {
+		value?: { text: string; files: FileData[] };
+		type: "gallery" | "table";
+		selected?: boolean;
+	} = $props();
+
+	let size = $state<number>(0);
+	let el: HTMLDivElement;
+
+	function set_styles(element: HTMLElement, el_width: number): void {
+		element.style.setProperty(
+			"--local-text-width",
+			`${el_width && el_width < 150 ? el_width : 200}px`
+		);
+		element.style.whiteSpace = "unset";
+	}
+
+	$effect(() => {
+		if (el && size) {
+			set_styles(el, size);
+		}
+	});
+</script>
+
+<div
+	class="container"
+	bind:clientWidth={size}
+	bind:this={el}
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+	class:border={value}
+>
+	<p>{value.text ? value.text : ""}</p>
+	{#each value.files as file}
+		{#if file.mime_type && file.mime_type.includes("image")}
+			<Image src={file.url} alt="" />
+		{:else if file.mime_type && file.mime_type.includes("video")}
+			<Video src={file.url} alt="" loop={true} is_stream={false} />
+		{:else if file.mime_type && file.mime_type.includes("audio")}
+			<audio src={file.url} controls />
+		{:else}
+			{file.orig_name}
+		{/if}
+	{/each}
+</div>
+
+<style>
+	.gallery {
+		padding: var(--size-1) var(--size-2);
+		display: flex;
+		align-items: center;
+		gap: 20px;
+		overflow-x: auto;
+	}
+
+	div {
+		overflow: hidden;
+		min-width: var(--local-text-width);
+		white-space: nowrap;
+	}
+
+	.container :global(img),
+	.container :global(video) {
+		object-fit: contain;
+		width: 100px;
+		height: 100px;
+	}
+
+	.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-x: auto;
+		width: max-content;
+		height: max-content;
+		object-fit: cover;
+		padding: var(--size-2);
+	}
+
+	.container.gallery {
+		object-fit: cover;
+	}
+
+	div > :global(p) {
+		font-size: var(--text-lg);
+		white-space: normal;
+	}
+</style>

6.19.0/multimodaltextbox/Index.svelte

@@ -0,0 +1,185 @@
+<svelte:options accessors={true} />
+
+<script context="module" lang="ts">
+	export { default as BaseMultimodalTextbox } from "./shared/MultimodalTextbox.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import { Gradio, type SelectData } from "@gradio/utils";
+	import MultimodalTextbox from "./shared/MultimodalTextbox.svelte";
+	import { Block } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+	import { onMount, tick } from "svelte";
+	import type { WaveformOptions } from "../audio/shared/types";
+	import type {
+		MultimodalTextboxProps,
+		MultimodalTextboxEvents
+	} from "./types";
+
+	let upload_promise = $state<Promise<any> | null>(null);
+
+	class MultimodalTextboxGradio extends Gradio<
+		MultimodalTextboxEvents,
+		MultimodalTextboxProps
+	> {
+		async get_data() {
+			if (upload_promise) {
+				await upload_promise;
+				await tick();
+			}
+			const data = await super.get_data();
+
+			return data;
+		}
+	}
+
+	let props = $props();
+	const gradio = new MultimodalTextboxGradio(props);
+
+	gradio.props.value = gradio.props.value ?? { text: "", files: [] };
+
+	let dragging = $state<boolean>(false);
+	let active_source = $state<"microphone" | null>(null);
+
+	let color_accent = "darkorange";
+
+	const waveform_settings = {
+		height: 50,
+		barWidth: 2,
+		barGap: 3,
+		cursorWidth: 2,
+		cursorColor: "#ddd5e9",
+		autoplay: false,
+		barRadius: 10,
+		dragToSeek: true,
+		normalize: true,
+		minPxPerSec: 20,
+		waveColor: "",
+		progressColor: "",
+		mediaControls: false as boolean | undefined,
+		sampleRate: 44100
+	};
+
+	onMount(() => {
+		color_accent = getComputedStyle(document?.documentElement).getPropertyValue(
+			"--color-accent"
+		);
+		set_trim_region_colour();
+		waveform_settings.waveColor =
+			gradio.props?.waveform_options?.waveform_color || "#9ca3af";
+		waveform_settings.progressColor =
+			gradio.props?.waveform_options?.waveform_progress_color || color_accent;
+		waveform_settings.mediaControls =
+			gradio.props?.waveform_options?.show_controls;
+		waveform_settings.sampleRate =
+			gradio.props?.waveform_options?.sample_rate || 44100;
+	});
+
+	const trim_region_settings = {
+		color: gradio.props?.waveform_options?.trim_region_color,
+		drag: true,
+		resize: true
+	};
+
+	function set_trim_region_colour(): void {
+		document.documentElement.style.setProperty(
+			"--trim-region-color",
+			trim_region_settings.color || color_accent
+		);
+	}
+
+	// Create const references to the callbacks so that afterUpdate in child is not called on every prop change
+	// in the DOM. See https://github.com/gradio-app/gradio/issues/11933
+	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+	const upload_fn = (...args: Parameters<typeof gradio.shared.client.upload>) =>
+		gradio.shared.client.upload(...args);
+	const i18n = (s: string | null | undefined): string => gradio.i18n(s);
+	const stream_handler_fn = (
+		...args: Parameters<typeof gradio.shared.client.stream>
+	): EventSource => gradio.shared.client.stream(...args);
+
+	let sources_string = $derived(
+		gradio.props.sources.join(",") as
+			| "upload"
+			| "upload,microphone"
+			| "microphone"
+			| "microphone,upload"
+	);
+
+	let file_types_string = $derived.by(
+		() => (gradio.props.file_types || []).join(",") || null
+	);
+</script>
+
+<Block
+	visible={gradio.shared.visible}
+	elem_id={gradio.shared.elem_id}
+	elem_classes={[...(gradio.shared.elem_classes || []), "multimodal-textbox"]}
+	scale={gradio.shared.scale}
+	min_width={gradio.shared.min_width}
+	allow_overflow={false}
+	padding={false}
+	border_mode={dragging ? "focus" : "base"}
+	rtl={gradio.props.rtl}
+>
+	{#if gradio.shared.loading_status}
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+	{/if}
+
+	<MultimodalTextbox
+		bind:upload_promise
+		bind:value={gradio.props.value}
+		value_is_output
+		bind:dragging
+		bind:active_source
+		{file_types_string}
+		root={gradio.shared.root}
+		label={gradio.shared.label || "MultimodalTextbox"}
+		info={gradio.props.info}
+		show_label={gradio.shared.show_label}
+		lines={gradio.props.lines}
+		rtl={gradio.props.rtl}
+		text_align={gradio.props.text_align}
+		waveform_settings={waveform_settings as WaveformOptions}
+		{i18n}
+		max_lines={!gradio.props.max_lines
+			? gradio.props.lines + 1
+			: gradio.props.max_lines}
+		placeholder={gradio.props.placeholder}
+		submit_btn={gradio.props.submit_btn}
+		stop_btn={gradio.props.stop_btn}
+		autofocus={gradio.props.autofocus}
+		autoscroll={gradio.shared.autoscroll}
+		file_count={gradio.props.file_count}
+		{sources_string}
+		max_file_size={gradio.shared.max_file_size}
+		onchange={(e) => {
+			gradio.props.value = e;
+			gradio.dispatch("change", gradio.props.value);
+		}}
+		oninput={() => gradio.dispatch("input")}
+		onsubmit={() => gradio.dispatch("submit")}
+		onstop={() => gradio.dispatch("stop")}
+		onblur={() => gradio.dispatch("blur")}
+		onselect={(e) => gradio.dispatch("select", e)}
+		onfocus={() => gradio.dispatch("focus")}
+		onerror={(detail) => {
+			gradio.dispatch("error", detail);
+		}}
+		onstop_recording={() => gradio.dispatch("stop_recording")}
+		onupload={(e) => gradio.dispatch("upload", e)}
+		onclear={() => gradio.dispatch("clear")}
+		disabled={!gradio.shared.interactive}
+		upload={upload_fn}
+		stream_handler={stream_handler_fn}
+		max_plain_text_length={gradio.props.max_plain_text_length}
+		html_attributes={gradio.props.html_attributes}
+	/>
+</Block>

6.19.0/multimodaltextbox/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "@gradio/multimodaltextbox",
+	"version": "0.12.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"main_changeset": true,
+	"main": "Index.svelte",
+	"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"
+	},
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/image": "workspace:^",
+		"@gradio/video": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/audio": "workspace:^"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/multimodaltextbox"
+	}
+}

6.19.0/multimodaltextbox/shared/MultimodalTextbox.svelte

@@ -0,0 +1,1071 @@
+<script lang="ts">
+	import { tick } from "svelte";
+	import { text_area_resize, resize } from "../shared/utils";
+	import { BlockTitle, ScrollFade } from "@gradio/atoms";
+	import { Upload } from "@gradio/upload";
+	import { Image } from "@gradio/image/shared";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import type { FileData, Client } from "@gradio/client";
+	import type { WaveformOptions } from "@gradio/audio";
+	import {
+		Clear,
+		File,
+		Music,
+		Paperclip,
+		Video,
+		ArrowUp,
+		Square,
+		Microphone,
+		Check
+	} from "@gradio/icons";
+	import { should_show_scroll_fade, type SelectData } from "@gradio/utils";
+	import {
+		MinimalAudioPlayer,
+		MinimalAudioRecorder
+	} from "@gradio/audio/shared";
+	import type { InputHTMLAttributes } from "./types";
+
+	let {
+		value = $bindable(),
+		value_is_output = false,
+		lines = 1,
+		i18n: _i18n,
+		placeholder = "",
+		disabled = false,
+		label,
+		info = undefined,
+		show_label = true,
+		max_lines,
+		submit_btn = null,
+		stop_btn = null,
+		rtl = false,
+		autofocus = false,
+		text_align = undefined,
+		autoscroll = true,
+		root,
+		file_types_string = null,
+		max_file_size = null,
+		upload,
+		stream_handler,
+		file_count = "multiple",
+		max_plain_text_length = 1000,
+		waveform_settings,
+		waveform_options: _waveform_options = { show_recording_waveform: true },
+		sources_string = "upload",
+		active_source = $bindable<"microphone" | null>(),
+		html_attributes = null,
+		upload_promise = $bindable<Promise<any> | null>(),
+		dragging = $bindable<boolean>(),
+		onchange,
+		onsubmit,
+		onstop,
+		onblur,
+		onselect,
+		oninput,
+		onfocus,
+		ondrag,
+		onupload,
+		onclear,
+		onload: _onload,
+		onerror,
+		onstop_recording
+	}: {
+		value?: { text: string; files: FileData[] };
+		value_is_output?: boolean;
+		lines?: number;
+		i18n: I18nFormatter;
+		placeholder?: string;
+		disabled?: boolean;
+		label: string;
+		info?: string | undefined;
+		show_label?: boolean;
+		max_lines: number;
+		submit_btn?: string | boolean | null;
+		stop_btn?: string | boolean | null;
+		rtl?: boolean;
+		autofocus?: boolean;
+		text_align?: "left" | "right" | undefined;
+		autoscroll?: boolean;
+		root: string;
+		file_types_string?: string | null;
+		max_file_size?: number | null;
+		upload: Client["upload"];
+		stream_handler: Client["stream"];
+		file_count?: "single" | "multiple" | "directory";
+		max_plain_text_length?: number;
+		waveform_settings: Record<string, any>;
+		waveform_options?: WaveformOptions;
+		sources_string?:
+			| "upload"
+			| "upload,microphone"
+			| "microphone"
+			| "microphone,upload";
+		active_source?: "microphone" | null;
+		html_attributes?: InputHTMLAttributes | null;
+		upload_promise?: Promise<any> | null;
+		dragging?: boolean;
+		onchange?: (value: { text: string; files: FileData[] }) => void;
+		onsubmit?: () => void;
+		onstop?: () => void;
+		onblur?: () => void;
+		onselect?: (data: SelectData) => void;
+		oninput?: () => void;
+		onfocus?: () => void;
+		ondrag?: (dragging: boolean) => void;
+		onupload?: (files: FileData[] | FileData) => void;
+		onclear?: () => void;
+		onload?: (files: FileData[] | FileData) => void;
+		onerror?: (error: string) => void;
+		onstop_recording?: () => void;
+	} = $props();
+
+	let upload_component: Upload;
+	let el: HTMLTextAreaElement | HTMLInputElement;
+	let can_scroll = $state(false);
+	let previous_scroll_top = $state(0);
+	let user_has_scrolled_up = $state(false);
+	let show_fade = $state(false);
+	let uploading = $state(false);
+	let oldValue = $state(value?.text ?? "");
+	let recording = $state(false);
+	let mic_audio = $state<FileData | null>(null);
+	let full_container: HTMLDivElement;
+
+	let sources = $derived(
+		sources_string
+			.split(",")
+			.map((s) => s.trim())
+			.filter((s) => s === "upload" || s === "microphone") as (
+			| "upload"
+			| "microphone"
+		)[]
+	);
+
+	let file_types = $derived(
+		file_types_string ? file_types_string.split(",").map((s) => s.trim()) : null
+	);
+
+	let show_upload = $derived(
+		sources &&
+			sources.includes("upload") &&
+			!(file_count === "single" && value?.files?.length > 0)
+	);
+
+	function update_fade(): void {
+		show_fade = should_show_scroll_fade(el);
+	}
+
+	$effect(() => {
+		if (el && value?.text !== undefined) {
+			tick().then(update_fade);
+		}
+	});
+
+	$effect(() => {
+		ondrag?.(dragging);
+	});
+
+	$effect(() => {
+		if (value && oldValue !== value.text) {
+			onchange?.(value);
+			oldValue = value.text;
+		}
+	});
+
+	$effect(() => {
+		value?.text;
+		if (el && lines !== max_lines) {
+			resize(el, lines, max_lines);
+		}
+	});
+
+	$effect.pre(() => {
+		if (el && el.offsetHeight + el.scrollTop > el.scrollHeight - 100) {
+			can_scroll = true;
+		}
+	});
+
+	const scroll = (): void => {
+		if (can_scroll && autoscroll && !user_has_scrolled_up) {
+			el.scrollTo(0, el.scrollHeight);
+		}
+	};
+
+	async function handle_change(): Promise<void> {
+		onchange?.(value);
+		if (!value_is_output) {
+			oninput?.();
+		}
+	}
+
+	$effect(() => {
+		value;
+		if (autofocus && el) {
+			el.focus();
+		}
+	});
+
+	$effect(() => {
+		if (can_scroll && autoscroll) {
+			scroll();
+		}
+	});
+
+	function handle_select(event: Event): void {
+		const target: HTMLTextAreaElement | HTMLInputElement = event.target as
+			| HTMLTextAreaElement
+			| HTMLInputElement;
+		const text = target.value;
+		const index: [number, number] = [
+			target.selectionStart as number,
+			target.selectionEnd as number
+		];
+		onselect?.({ value: text.substring(...index), index: index });
+	}
+
+	async function handle_keypress(e: KeyboardEvent): Promise<void> {
+		if (e.key === "Enter" && e.shiftKey && lines > 1) {
+			e.preventDefault();
+			await tick();
+			onsubmit?.();
+		} else if (
+			e.key === "Enter" &&
+			!e.shiftKey &&
+			lines === 1 &&
+			max_lines >= 1
+		) {
+			e.preventDefault();
+			add_mic_audio_to_files();
+			active_source = null;
+			await tick();
+			onsubmit?.();
+		}
+	}
+
+	function handle_scroll(event: Event): void {
+		const target = event.target as HTMLElement;
+		const current_scroll_top = target.scrollTop;
+		if (current_scroll_top < previous_scroll_top) {
+			user_has_scrolled_up = true;
+		}
+		previous_scroll_top = current_scroll_top;
+
+		const max_scroll_top = target.scrollHeight - target.clientHeight;
+		const user_has_scrolled_to_bottom = current_scroll_top >= max_scroll_top;
+		if (user_has_scrolled_to_bottom) {
+			user_has_scrolled_up = false;
+		}
+		update_fade();
+	}
+
+	async function handle_upload(detail: FileData | FileData[]): Promise<void> {
+		handle_change();
+		if (Array.isArray(detail)) {
+			for (let file of detail) {
+				value.files.push(file);
+			}
+			value = value;
+		} else {
+			value.files.push(detail);
+			value = value;
+		}
+		await tick();
+		onchange?.(value);
+		onupload?.(detail);
+	}
+
+	function remove_thumbnail(event: MouseEvent, index: number): void {
+		handle_change();
+		event.stopPropagation();
+		value.files.splice(index, 1);
+		value = value;
+	}
+
+	function handle_upload_click(): void {
+		upload_component.open_upload();
+	}
+
+	function handle_stop(): void {
+		onstop?.();
+	}
+
+	function add_mic_audio_to_files(): void {
+		if (mic_audio) {
+			value.files.push(mic_audio);
+			value = value;
+			mic_audio = null;
+			onchange?.(value);
+		}
+	}
+
+	function handle_submit(): void {
+		add_mic_audio_to_files();
+		active_source = null;
+		onsubmit?.();
+	}
+
+	async function handle_paste(event: ClipboardEvent): Promise<void> {
+		if (!event.clipboardData) return;
+		const items = event.clipboardData.items;
+		const text = event.clipboardData.getData("text");
+
+		if (text && text.length > max_plain_text_length) {
+			event.preventDefault();
+			const file = new window.File([text], "pasted_text.txt", {
+				type: "text/plain",
+				lastModified: Date.now()
+			});
+			if (upload_component) {
+				upload_component.load_files([file]);
+			}
+			return;
+		}
+
+		for (let index in items) {
+			const item = items[index];
+			if (item.kind === "file" && item.type.includes("image")) {
+				const blob = item.getAsFile();
+				if (blob) upload_component.load_files([blob]);
+			}
+		}
+	}
+
+	function handle_dragenter(event: DragEvent): void {
+		event.preventDefault();
+		dragging = true;
+	}
+
+	function handle_dragleave(event: DragEvent): void {
+		event.preventDefault();
+		const rect = full_container.getBoundingClientRect();
+		const { clientX, clientY } = event;
+		if (
+			clientX <= rect.left ||
+			clientX >= rect.right ||
+			clientY <= rect.top ||
+			clientY >= rect.bottom
+		) {
+			dragging = false;
+		}
+	}
+
+	function handle_drop(event: DragEvent): void {
+		event.preventDefault();
+		dragging = false;
+		if (event.dataTransfer && event.dataTransfer.files) {
+			const files = Array.from(event.dataTransfer.files);
+
+			if (file_types) {
+				const valid_files = files.filter((file) => {
+					return file_types.some((type) => {
+						if (type.startsWith(".")) {
+							return file.name.toLowerCase().endsWith(type.toLowerCase());
+						}
+						return file.type.match(new RegExp(type.replace("*", ".*")));
+					});
+				});
+
+				const invalid_files = files.length - valid_files.length;
+				if (invalid_files > 0) {
+					onerror?.(
+						`${invalid_files} file(s) were rejected. Accepted formats: ${file_types.join(", ")}`
+					);
+				}
+
+				if (valid_files.length > 0) {
+					upload_component.load_files(valid_files);
+				}
+			} else {
+				upload_component.load_files(files);
+			}
+		}
+	}
+</script>
+
+<div
+	class="full-container"
+	class:dragging
+	bind:this={full_container}
+	ondragenter={handle_dragenter}
+	ondragleave={handle_dragleave}
+	ondragover={(e) => e.preventDefault()}
+	ondrop={handle_drop}
+	role="group"
+	aria-label="Multimedia input field"
+>
+	<BlockTitle {show_label} {info} {rtl}>{label}</BlockTitle>
+	<div class="input-container">
+		{#if sources && sources.includes("microphone") && active_source === "microphone"}
+			<div class="recording-overlay" class:has-audio={mic_audio !== null}>
+				{#if !mic_audio}
+					<div class="recording-content">
+						<MinimalAudioRecorder
+							label={label || "Audio"}
+							{waveform_settings}
+							{recording}
+							{upload}
+							{root}
+							{max_file_size}
+							bind:upload_promise
+							onchange={(audio_value) => {
+								mic_audio = audio_value;
+							}}
+							onstoprecording={() => {
+								recording = false;
+								onstop_recording?.();
+							}}
+							onclear={() => {
+								active_source = null;
+								recording = false;
+								mic_audio = null;
+								onclear?.();
+							}}
+						/>
+					</div>
+				{:else}
+					<div class="recording-content">
+						<MinimalAudioPlayer
+							value={mic_audio}
+							label={label || "Audio"}
+							loop={false}
+						/>
+						<div class="action-buttons">
+							<button
+								class="confirm-button"
+								onclick={() => {
+									add_mic_audio_to_files();
+									active_source = null;
+									recording = false;
+								}}
+								aria-label="Attach audio"
+							>
+								<Check />
+							</button>
+							<button
+								class="cancel-button"
+								onclick={() => {
+									active_source = null;
+									recording = false;
+									mic_audio = null;
+								}}
+								aria-label="Clear audio"
+							>
+								<Clear />
+							</button>
+						</div>
+					</div>
+				{/if}
+			</div>
+		{/if}
+		{#if show_upload}
+			<Upload
+				bind:upload_promise
+				bind:this={upload_component}
+				onload={handle_upload}
+				{file_count}
+				filetype={file_types}
+				{root}
+				{max_file_size}
+				bind:dragging
+				bind:uploading
+				show_progress={false}
+				disable_click={true}
+				{onerror}
+				hidden={true}
+				{upload}
+				{stream_handler}
+			/>
+		{/if}
+
+		<div
+			class="input-wrapper"
+			class:has-files={(value?.files?.length ?? 0) > 0 || uploading}
+		>
+			{#if (value?.files?.length ?? 0) > 0 || uploading}
+				<div
+					class="thumbnails"
+					aria-label="Uploaded files"
+					data-testid="container_el"
+				>
+					{#if show_upload}
+						<button
+							data-testid="upload-button"
+							class="upload-button thumbnail-add"
+							{disabled}
+							onclick={handle_upload_click}
+							aria-label="Upload a file"
+						>
+							<Paperclip />
+						</button>
+					{/if}
+					{#each value?.files ?? [] as file, index}
+						<span
+							class="thumbnail-wrapper"
+							role="listitem"
+							aria-label="File thumbnail"
+						>
+							<div class="thumbnail-item thumbnail-small">
+								{#if file.mime_type && file.mime_type.includes("image")}
+									<Image
+										src={file.url}
+										restProps={{
+											title: null,
+											alt: "",
+											loading: "lazy",
+											class: "thumbnail-image"
+										}}
+									/>
+								{:else if file.mime_type && file.mime_type.includes("audio")}
+									<Music />
+								{:else if file.mime_type && file.mime_type.includes("video")}
+									<Video />
+								{:else}
+									<File />
+								{/if}
+								<button
+									class="delete-button"
+									onclick={(event) => remove_thumbnail(event, index)}
+									aria-label="Remove file"
+								>
+									<Clear />
+								</button>
+							</div>
+						</span>
+					{/each}
+					{#if uploading}
+						<div class="loader" role="status" aria-label="Uploading"></div>
+					{/if}
+				</div>
+			{/if}
+
+			<div class="input-row">
+				{#if show_upload && (value?.files?.length ?? 0) === 0 && !uploading}
+					<button
+						data-testid="upload-button"
+						class="upload-button icon-button"
+						{disabled}
+						onclick={handle_upload_click}
+						aria-label="Upload a file"
+					>
+						<Paperclip />
+					</button>
+				{/if}
+				<div class="textarea-wrapper">
+					<textarea
+						data-testid="textbox"
+						use:text_area_resize={{
+							text: value.text,
+							lines: lines,
+							max_lines: max_lines
+						}}
+						class:no-label={!show_label}
+						dir={rtl ? "rtl" : "ltr"}
+						bind:value={value.text}
+						bind:this={el}
+						{placeholder}
+						rows={lines}
+						{disabled}
+						onkeypress={handle_keypress}
+						onblur={() => onblur?.()}
+						onselect={handle_select}
+						onfocus={() => onfocus?.()}
+						onscroll={handle_scroll}
+						onpaste={handle_paste}
+						style={text_align ? "text-align: " + text_align : ""}
+						autocapitalize={html_attributes?.autocapitalize}
+						autocorrect={html_attributes?.autocorrect}
+						spellcheck={html_attributes?.spellcheck}
+						autocomplete={html_attributes?.autocomplete}
+						tabindex={html_attributes?.tabindex}
+						enterkeyhint={html_attributes?.enterkeyhint}
+						lang={html_attributes?.lang}
+					/>
+					<ScrollFade visible={show_fade} position="absolute" />
+				</div>
+
+				{#if sources && sources.includes("microphone")}
+					<button
+						data-testid="microphone-button"
+						class="microphone-button"
+						class:recording
+						{disabled}
+						onclick={async () => {
+							if (active_source !== "microphone") {
+								active_source = "microphone";
+								await tick();
+								recording = true;
+							} else {
+								active_source = null;
+								recording = false;
+							}
+						}}
+						aria-label="Record audio"
+					>
+						<Microphone />
+					</button>
+				{/if}
+
+				{#if submit_btn}
+					<button
+						class="submit-button"
+						data-testid="submit-button"
+						class:padded-button={submit_btn !== true}
+						{disabled}
+						onclick={handle_submit}
+						aria-label="Submit"
+					>
+						{#if submit_btn === true}
+							<ArrowUp />
+						{:else}
+							{submit_btn}
+						{/if}
+					</button>
+				{/if}
+				{#if stop_btn}
+					<button
+						class="stop-button"
+						class:padded-button={stop_btn !== true}
+						onclick={handle_stop}
+						aria-label="Stop"
+					>
+						{#if stop_btn === true}
+							<Square fill={"none"} stroke_width={2.5} />
+						{:else}
+							{stop_btn}
+						{/if}
+					</button>
+				{/if}
+			</div>
+		</div>
+	</div>
+</div>
+
+<style>
+	.full-container {
+		width: 100%;
+		position: relative;
+		padding: var(--block-padding);
+		border: 1px solid transparent;
+	}
+
+	.full-container.dragging {
+		border-color: var(--color-accent);
+		border-radius: calc(var(--radius-sm) - var(--size-px));
+	}
+
+	.full-container.dragging::after {
+		content: "";
+		position: absolute;
+		inset: 0;
+		pointer-events: none;
+	}
+
+	.input-container {
+		display: flex;
+		position: relative;
+		flex-direction: column;
+		gap: 0;
+	}
+
+	.input-wrapper {
+		display: flex;
+		position: relative;
+		flex-direction: column;
+		gap: 0;
+		background: var(--block-background-fill);
+		border-radius: var(--radius-xl);
+		padding: var(--spacing-sm) var(--spacing-sm) var(--spacing-sm) 0;
+		align-items: flex-start;
+		min-height: auto;
+	}
+
+	.input-wrapper.has-files {
+		padding-top: var(--spacing-xs);
+	}
+
+	.input-row {
+		display: flex;
+		align-items: flex-start;
+		gap: var(--spacing-sm);
+		width: 100%;
+	}
+
+	.thumbnails {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-sm);
+		padding: var(--spacing-xs) 0;
+		margin-bottom: var(--spacing-xs);
+		overflow-x: auto;
+		overflow-y: hidden;
+		scrollbar-width: none;
+		-ms-overflow-style: none;
+		flex-wrap: nowrap;
+		-webkit-overflow-scrolling: touch;
+		scroll-behavior: smooth;
+		overflow-y: scroll;
+		width: 100%;
+	}
+
+	.thumbnails::-webkit-scrollbar,
+	.thumbnails::-webkit-scrollbar-track,
+	.thumbnails::-webkit-scrollbar-thumb {
+		display: none;
+	}
+
+	.thumbnails :global(img) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: cover;
+		border-radius: var(--radius-md);
+	}
+
+	.thumbnail-wrapper {
+		position: relative;
+		flex-shrink: 0;
+	}
+
+	.thumbnail-item {
+		position: relative;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		border-radius: var(--radius-md);
+		background: var(--background-fill-secondary);
+		width: var(--size-full);
+		height: var(--size-full);
+		cursor: default;
+		padding: 0;
+	}
+
+	.thumbnail-small {
+		width: var(--size-10);
+		height: var(--size-10);
+	}
+
+	.thumbnail-item :global(svg) {
+		width: var(--size-5);
+		height: var(--size-5);
+	}
+
+	.delete-button {
+		position: absolute;
+		inset: 0;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		color: var(--button-primary-text-color);
+		background: rgba(0, 0, 0, 0.6);
+		backdrop-filter: var(--blur-xs);
+		border-radius: var(--radius-md);
+		padding: 0;
+		z-index: var(--layer-1);
+		opacity: 0;
+		transition: opacity 0.1s var(--easing-standard);
+	}
+
+	.delete-button:hover {
+		background: rgba(0, 0, 0, 0.8);
+	}
+
+	.delete-button :global(svg) {
+		width: var(--size-5);
+		height: var(--size-5);
+	}
+
+	.thumbnail-item:hover .delete-button {
+		opacity: 1;
+	}
+
+	textarea {
+		flex-grow: 1;
+		outline: none !important;
+		background: transparent;
+		padding: var(--spacing-sm) 0;
+		color: var(--body-text-color);
+		font-weight: var(--input-text-weight);
+		font-size: var(--input-text-size);
+		border: none;
+		margin: 0;
+		resize: none;
+		position: relative;
+		z-index: var(--layer-1);
+		text-align: left;
+	}
+
+	textarea:disabled {
+		-webkit-opacity: 1;
+		opacity: 1;
+	}
+
+	textarea::placeholder {
+		color: var(--input-placeholder-color);
+	}
+
+	textarea[dir="rtl"] {
+		text-align: right;
+	}
+
+	textarea[dir="rtl"] ~ .submit-button :global(svg) {
+		transform: scaleX(-1);
+	}
+
+	.microphone-button,
+	.icon-button {
+		color: var(--body-text-color);
+		cursor: pointer;
+		padding: var(--spacing-sm);
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		flex-shrink: 0;
+		border-radius: var(--radius-md);
+	}
+
+	.thumbnail-add {
+		background: var(--button-secondary-background-fill);
+		cursor: pointer;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		flex-shrink: 0;
+		width: var(--size-10);
+		height: var(--size-10);
+		border-radius: var(--radius-md);
+		z-index: var(--layer-1);
+	}
+
+	.thumbnail-add:hover:not(:disabled) {
+		background: var(--button-secondary-background-fill-hover);
+	}
+
+	.thumbnail-add:disabled {
+		opacity: 0.5;
+		cursor: not-allowed;
+	}
+
+	.thumbnail-add :global(svg) {
+		width: var(--size-5);
+		height: var(--size-5);
+	}
+
+	.microphone-button,
+	.icon-button {
+		width: var(--size-9);
+		height: var(--size-9);
+	}
+
+	.microphone-button:hover:not(:disabled),
+	.icon-button:hover:not(:disabled) {
+		background: var(--button-secondary-background-fill);
+	}
+
+	.microphone-button:disabled,
+	.icon-button:disabled {
+		opacity: 0.5;
+		cursor: not-allowed;
+	}
+
+	.microphone-button :global(svg),
+	.icon-button :global(svg) {
+		width: var(--size-5);
+		height: var(--size-5);
+	}
+
+	.submit-button,
+	.stop-button {
+		background: var(--button-secondary-background-fill);
+		cursor: pointer;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		flex-shrink: 0;
+		width: var(--size-9);
+		height: var(--size-9);
+		border-radius: var(--radius-md);
+		z-index: var(--layer-1);
+	}
+
+	.submit-button:hover:not(:disabled),
+	.stop-button:hover:not(:disabled) {
+		background: var(--button-secondary-background-fill-hover);
+	}
+
+	.submit-button:active:not(:disabled),
+	.stop-button:active:not(:disabled) {
+		box-shadow: var(--button-shadow-active);
+	}
+
+	.submit-button:disabled,
+	.stop-button:disabled {
+		cursor: not-allowed;
+	}
+
+	.submit-button :global(svg),
+	.stop-button :global(svg) {
+		width: var(--size-5);
+		height: var(--size-5);
+	}
+
+	.padded-button {
+		padding: 0 var(--spacing-lg);
+		width: auto;
+		border-radius: var(--radius-xl);
+	}
+
+	.loader {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		position: relative;
+		border: var(--size-1) solid var(--border-color-primary);
+		border-top-color: var(--color-accent);
+		border-radius: var(--radius-100);
+		width: var(--size-5);
+		height: var(--size-5);
+		animation: spin 1s linear infinite;
+		flex-shrink: 0;
+	}
+
+	@keyframes spin {
+		to {
+			transform: rotate(360deg);
+		}
+	}
+
+	.recording-overlay {
+		position: absolute;
+		top: 0;
+		left: 0;
+		right: 0;
+		bottom: 0;
+		background: var(--block-background-fill);
+		border-radius: var(--radius-xl);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		z-index: var(--layer-5);
+		padding: var(--spacing-lg);
+		backdrop-filter: blur(8px);
+		animation: fadeIn 0.2s var(--easing-standard);
+	}
+
+	@keyframes fadeIn {
+		from {
+			opacity: 0;
+		}
+		to {
+			opacity: 1;
+		}
+	}
+
+	.recording-content {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-lg);
+		width: 100%;
+		max-width: 700px;
+	}
+
+	.recording-content :global(.minimal-audio-recorder),
+	.recording-content :global(.minimal-audio-player) {
+		flex: 1;
+	}
+
+	.action-buttons {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-sm);
+		flex-shrink: 0;
+	}
+
+	.stop-button,
+	.confirm-button,
+	.cancel-button {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: var(--size-9);
+		height: var(--size-9);
+		padding: 0;
+		border-radius: var(--radius-md);
+		cursor: pointer;
+		flex-shrink: 0;
+	}
+
+	.stop-button {
+		background: var(--button-secondary-background-fill);
+		border-color: var(--border-color-primary);
+		color: var(--error-500);
+	}
+
+	.stop-button:hover {
+		background: var(--button-secondary-background-fill-hover);
+		color: var(--error-600);
+	}
+
+	.stop-button:active {
+		transform: scale(0.95);
+	}
+
+	.confirm-button {
+		background: var(--button-primary-background-fill);
+		border-color: var(--button-primary-border-color);
+		color: white;
+	}
+
+	.confirm-button:hover {
+		background: var(--button-primary-background-fill-hover);
+		color: var(--button-primary-text-color-hover);
+	}
+
+	.confirm-button:active {
+		transform: scale(0.95);
+	}
+
+	.cancel-button {
+		background: var(--button-secondary-background-fill);
+		color: var(--body-text-color);
+	}
+
+	.cancel-button:hover {
+		background: var(--button-secondary-background-fill-hover);
+	}
+
+	.stop-button :global(svg),
+	.confirm-button :global(svg),
+	.cancel-button :global(svg) {
+		width: var(--size-5);
+		height: var(--size-5);
+	}
+
+	@media (max-width: 768px) {
+		.input-wrapper {
+			padding: var(--spacing-xs);
+		}
+
+		.thumbnails {
+			padding: var(--spacing-xs) 0;
+			margin-bottom: var(--spacing-md);
+		}
+
+		.thumbnail-small,
+		.thumbnail-add {
+			width: var(--size-9);
+			height: var(--size-9);
+		}
+
+		.thumbnail-item:active .delete-button {
+			opacity: 1;
+		}
+	}
+
+	.textarea-wrapper {
+		position: relative;
+		flex-grow: 1;
+	}
+
+	.textarea-wrapper textarea {
+		width: 100%;
+	}
+</style>

6.19.0/multimodaltextbox/shared/types.ts

@@ -0,0 +1 @@
+export type { InputHTMLAttributes } from "../../textbox/types";

6.19.0/multimodaltextbox/shared/utils.ts

@@ -0,0 +1,74 @@
+import { tick } from "svelte";
+
+interface Value {
+	lines: number;
+	max_lines: number;
+	text: string;
+}
+
+export async function resize(
+	target: HTMLTextAreaElement | HTMLInputElement,
+	lines: number,
+	max_lines: number
+): Promise<void> {
+	await tick();
+	if (lines === max_lines) return;
+
+	const computed_styles = window.getComputedStyle(target);
+	const padding_top = parseFloat(computed_styles.paddingTop);
+	const padding_bottom = parseFloat(computed_styles.paddingBottom);
+	const line_height = parseFloat(computed_styles.lineHeight);
+
+	let max =
+		max_lines === undefined
+			? false
+			: padding_top + padding_bottom + line_height * max_lines;
+	let min = padding_top + padding_bottom + lines * line_height;
+
+	target.style.height = "1px";
+
+	let scroll_height;
+	if (max && target.scrollHeight > max) {
+		scroll_height = max;
+	} else if (target.scrollHeight < min) {
+		scroll_height = min;
+	} else {
+		scroll_height = target.scrollHeight;
+	}
+
+	target.style.height = `${scroll_height}px`;
+	update_scrollbar_visibility(target);
+}
+
+function update_scrollbar_visibility(
+	textarea: HTMLTextAreaElement | HTMLInputElement
+): void {
+	const content_height = textarea.scrollHeight;
+	const visible_height = textarea.clientHeight;
+	const line_height = parseFloat(window.getComputedStyle(textarea).lineHeight);
+	if (content_height > visible_height + line_height) {
+		textarea.style.overflowY = "scroll";
+	} else {
+		textarea.style.overflowY = "hidden";
+	}
+}
+
+export function text_area_resize(
+	_el: HTMLTextAreaElement,
+	_value: Value
+): any | undefined {
+	if (_value.lines === _value.max_lines) return;
+	update_scrollbar_visibility(_el);
+
+	function handle_input(event: Event): void {
+		resize(event.target as HTMLTextAreaElement, _value.lines, _value.max_lines);
+	}
+	_el.addEventListener("input", handle_input);
+
+	if (!_value.text.trim()) return;
+	resize(_el, _value.lines, _value.max_lines);
+
+	return {
+		destroy: () => _el.removeEventListener("input", handle_input)
+	};
+}

6.19.0/multimodaltextbox/types.ts

@@ -0,0 +1,40 @@
+import type { FileData } from "@gradio/client";
+import type { SelectData } from "@gradio/utils";
+import type { LoadingStatus } from "@gradio/statustracker";
+import type { InputHTMLAttributes } from "./shared/types";
+import type { WaveformOptions } from "js/audio/shared/types";
+
+export interface MultimodalTextboxEvents {
+	change: { text: string; files: FileData[] };
+	submit: never;
+	stop: never;
+	blur: never;
+	select: SelectData;
+	input: never;
+	focus: never;
+	error: string;
+	clear_status: LoadingStatus;
+	stop_recording: never;
+	upload: FileData[] | FileData;
+	clear: undefined;
+}
+
+export interface MultimodalTextboxProps {
+	value: { text: string; files: FileData[] };
+	file_types: string[] | null;
+	lines: number;
+	placeholder: string;
+	info: string | undefined;
+	max_lines: number;
+	submit_btn: string | boolean | null;
+	stop_btn: string | boolean | null;
+	value_is_output: boolean;
+	rtl: boolean;
+	text_align: "left" | "right" | undefined;
+	autofocus: boolean;
+	file_count: "single" | "multiple" | "directory";
+	max_plain_text_length: number;
+	sources: ("microphone" | "upload")[];
+	waveform_options: WaveformOptions;
+	html_attributes: InputHTMLAttributes | null;
+}