Upload folder using huggingface_hub

5.49.1/dialogue/Dialogue.svelte

@@ -0,0 +1,1006 @@
+<script lang="ts">
+	import { createEventDispatcher, tick, onMount } from "svelte";
+	import { BlockTitle, IconButton, IconButtonWrapper } from "@gradio/atoms";
+	import { Copy, Check, Send, Plus, Trash } from "@gradio/icons";
+	import { fade } from "svelte/transition";
+	import { BaseDropdown, BaseDropdownOptions } from "@gradio/dropdown";
+	import type { SelectData, CopyData } from "@gradio/utils";
+	import type { DialogueLine } from "./utils";
+	import Switch from "./Switch.svelte";
+
+	export let speakers: string[] = [];
+	export let tags: string[] = [];
+	export let value: DialogueLine[] | string = [];
+	export let value_is_output = false;
+	export let placeholder: string | undefined = undefined;
+	export let label: string;
+	export let info: string | undefined = undefined;
+	export let disabled = false;
+	export let show_label = true;
+	export let container = true;
+	export let max_lines: number | undefined = undefined;
+	export let show_copy_button = false;
+	export let show_submit_button = true;
+	export let color_map: Record<string, string> | null = null;
+	export let ui_mode: "dialogue" | "text" | "both" = "both";
+	let checked = ui_mode === "text";
+
+	export let server: {
+		format: (body: DialogueLine[]) => Promise<string>;
+		unformat: (body: object) => Promise<DialogueLine[]>;
+	};
+
+	let dialogue_lines: DialogueLine[] = [];
+
+	if (value && value.length && typeof value !== "string") {
+		dialogue_lines = [...value];
+	} else if (value && typeof value !== "string") {
+		dialogue_lines = [
+			{ speaker: `${speakers.length ? speakers[0] : ""}`, text: "" }
+		];
+	}
+
+	let dialogue_container_element: HTMLDivElement;
+
+	let showTagMenu = false;
+	let currentLineIndex = -1;
+	let selectedOptionIndex = 0;
+	let filtered_tags: string[] = [];
+	let input_elements: (HTMLInputElement | HTMLTextAreaElement)[] = [];
+	let textarea_element: HTMLTextAreaElement;
+	let old_value = JSON.stringify(value);
+	let offset_from_top = 0;
+	let copied = false;
+	let timer: any;
+	let textbox_value = "";
+	let hoveredSpeaker: string | null = null;
+	let is_unformatting = false;
+	let is_formatting = false;
+	let is_internal_update = false;
+
+	const defaultColorNames = [
+		"red",
+		"green",
+		"blue",
+		"yellow",
+		"purple",
+		"teal",
+		"orange",
+		"cyan",
+		"lime",
+		"pink"
+	];
+
+	const colorNameToHex: Record<string, string> = {
+		red: "rgba(254, 202, 202, 0.7)",
+		green: "rgba(209, 250, 229, 0.7)",
+		blue: "rgba(219, 234, 254, 0.7)",
+		yellow: "rgba(254, 243, 199, 0.7)",
+		purple: "rgba(233, 213, 255, 0.7)",
+		teal: "rgba(204, 251, 241, 0.7)",
+		orange: "rgba(254, 215, 170, 0.7)",
+		cyan: "rgba(207, 250, 254, 0.7)",
+		lime: "rgba(217, 249, 157, 0.7)",
+		pink: "rgba(252, 231, 243, 0.7)"
+	};
+
+	let speakerColors: Record<string, string> = {};
+	$: {
+		if (color_map) {
+			speakerColors = { ...color_map };
+		} else {
+			speakerColors = {};
+			speakers.forEach((speaker, index) => {
+				const colorName = defaultColorNames[index % defaultColorNames.length];
+				speakerColors[speaker] = colorNameToHex[colorName];
+			});
+		}
+	}
+
+	if (speakers.length === 0) {
+		checked = true;
+		value = "";
+	}
+
+	$: {
+		if (dialogue_lines.length > input_elements.length) {
+			input_elements = [
+				...input_elements,
+				...Array(dialogue_lines.length - input_elements.length).fill(null)
+			];
+		} else if (dialogue_lines.length < input_elements.length) {
+			input_elements = input_elements.slice(0, dialogue_lines.length);
+		}
+
+		tick().then(() => {
+			input_elements.forEach((element) => {
+				if (element && element instanceof HTMLTextAreaElement) {
+					element.style.height = "auto";
+					element.style.height = element.scrollHeight + "px";
+				}
+			});
+		});
+	}
+
+	function add_line(index: number): void {
+		const newSpeaker = speakers.length > 0 ? speakers[0] : "";
+		dialogue_lines = [
+			...dialogue_lines.slice(0, index + 1),
+			{ speaker: newSpeaker, text: "" },
+			...dialogue_lines.slice(index + 1)
+		];
+
+		tick().then(() => {
+			if (input_elements[index + 1]) {
+				input_elements[index + 1].focus();
+			}
+		});
+	}
+
+	function delete_line(index: number): void {
+		dialogue_lines = [
+			...dialogue_lines.slice(0, index),
+			...dialogue_lines.slice(index + 1)
+		];
+	}
+
+	function update_line(
+		index: number,
+		key: keyof DialogueLine,
+		value: string
+	): void {
+		dialogue_lines[index][key] = value;
+		dialogue_lines = [...dialogue_lines];
+	}
+
+	function handle_input(event: Event, index: number): void {
+		const input = (event.target as HTMLInputElement) || HTMLTextAreaElement;
+		if (input && !input_elements[index]) {
+			input_elements[index] = input;
+		}
+
+		const cursor_position = input.selectionStart || 0;
+		const text = input.value;
+		let show_menu = false;
+		let position_reference_index = -1;
+
+		if (text[cursor_position - 1] === ":") {
+			currentLineIndex = index;
+			position_reference_index = cursor_position;
+			const search_text = get_tag_search_text(text, cursor_position);
+			filtered_tags = tags.filter(
+				(tag) =>
+					search_text === "" ||
+					tag.toLowerCase().includes(search_text.toLowerCase())
+			);
+			show_menu = filtered_tags.length > 0;
+			selectedOptionIndex = 0;
+		} else {
+			const lastColonIndex = text.lastIndexOf(":", cursor_position - 1);
+			if (
+				lastColonIndex >= 0 &&
+				!text.substring(lastColonIndex + 1, cursor_position).includes(" ")
+			) {
+				currentLineIndex = index;
+				position_reference_index = lastColonIndex + 1; // Position menu relative to the start of the potential tag
+				const searchText = text.substring(lastColonIndex + 1, cursor_position);
+				filtered_tags = tags.filter(
+					(tag) =>
+						searchText === "" ||
+						tag.toLowerCase().includes(searchText.toLowerCase())
+				);
+				show_menu = filtered_tags.length > 0;
+				selectedOptionIndex = 0;
+			}
+		}
+
+		if (show_menu && position_reference_index !== -1) {
+			showTagMenu = true;
+			const input_rect = input.getBoundingClientRect();
+			// Position menu below the current input by calculating the distance from the top of the container
+			// and use 1.5 times the input height.
+			if (dialogue_container_element) {
+				const container_rect =
+					dialogue_container_element.getBoundingClientRect();
+				offset_from_top =
+					container_rect.top + input_rect.height * (index + 1.5);
+			}
+		} else {
+			showTagMenu = false;
+		}
+	}
+
+	function get_tag_search_text(text: string, cursorPosition: number): string {
+		const lastColonIndex = text.lastIndexOf(":", cursorPosition - 1);
+		if (lastColonIndex >= 0) {
+			return text.substring(lastColonIndex + 1, cursorPosition);
+		}
+		return "";
+	}
+
+	async function insert_selected_tag(): Promise<void> {
+		const tag = filtered_tags[selectedOptionIndex];
+		if (tag) {
+			let text;
+			let currentInput;
+			if (checked) {
+				currentInput = textarea_element;
+				text = textbox_value;
+			} else {
+				currentInput = input_elements[currentLineIndex];
+				text = dialogue_lines[currentLineIndex].text;
+			}
+			const cursorPosition = currentInput?.selectionStart || 0;
+			const lastColonIndex = text.lastIndexOf(":", cursorPosition - 1);
+			if (lastColonIndex >= 0) {
+				const beforeColon = text.substring(0, lastColonIndex);
+				const afterCursor = text.substring(cursorPosition);
+
+				if (checked) {
+					// plain text mode: don't filter speaker tags
+					const newText = `${beforeColon}${tag} ${afterCursor}`;
+					textbox_value = newText;
+					if (speakers.length === 0) {
+						value = newText;
+					} else {
+						value = await server.unformat({ text: newText });
+					}
+
+					tick().then(() => {
+						if (textarea_element) {
+							const newCursorPosition = beforeColon.length + tag.length + 1;
+							textarea_element.setSelectionRange(
+								newCursorPosition,
+								newCursorPosition
+							);
+							textarea_element.focus();
+						}
+					});
+				} else {
+					// dialogue line mode
+					const filteredBeforeColon = beforeColon
+						.replace(/\[S\d+\]/g, "")
+						.trim();
+					const newText = `${filteredBeforeColon}${tag} ${afterCursor}`;
+					update_line(currentLineIndex, "text", newText);
+
+					tick().then(() => {
+						const updatedInput = input_elements[currentLineIndex];
+						if (updatedInput) {
+							const newCursorPosition =
+								filteredBeforeColon.length + tag.length + 1;
+							updatedInput.setSelectionRange(
+								newCursorPosition,
+								newCursorPosition
+							);
+							updatedInput.focus();
+						}
+					});
+				}
+			}
+
+			showTagMenu = false;
+			selectedOptionIndex = 0;
+		}
+	}
+
+	async function insert_tag(e: CustomEvent): Promise<void> {
+		const tag = tags[e.detail.target.dataset.index];
+		if (tag) {
+			let text;
+			let currentInput;
+			if (checked) {
+				currentInput = textarea_element;
+				text = textbox_value;
+			} else {
+				currentInput = input_elements[currentLineIndex];
+				text = dialogue_lines[currentLineIndex].text;
+			}
+			const cursorPosition = currentInput?.selectionStart || 0;
+			const lastColonIndex = text.lastIndexOf(":", cursorPosition - 1);
+			if (lastColonIndex >= 0) {
+				const beforeColon = text.substring(0, lastColonIndex);
+				const afterCursor = text.substring(cursorPosition);
+
+				if (checked) {
+					// plain text mode: don't filter speaker tags
+					const newText = `${beforeColon}${tag} ${afterCursor}`;
+					textbox_value = newText;
+					if (speakers.length === 0) {
+						value = newText;
+					} else {
+						value = await server.unformat({ text: newText });
+					}
+
+					tick().then(() => {
+						if (textarea_element) {
+							const newCursorPosition = beforeColon.length + tag.length + 1;
+							textarea_element.setSelectionRange(
+								newCursorPosition,
+								newCursorPosition
+							);
+							textarea_element.focus();
+						}
+					});
+				} else {
+					// dialogue line mode
+					const filteredBeforeColon = beforeColon
+						.replace(/\[S\d+\]/g, "")
+						.trim();
+					const newText = `${filteredBeforeColon}${tag} ${afterCursor}`;
+					update_line(currentLineIndex, "text", newText);
+
+					tick().then(() => {
+						const updatedInput = input_elements[currentLineIndex];
+						if (updatedInput) {
+							const newCursorPosition =
+								filteredBeforeColon.length + tag.length + 1;
+							updatedInput.setSelectionRange(
+								newCursorPosition,
+								newCursorPosition
+							);
+							updatedInput.focus();
+						}
+					});
+				}
+			}
+
+			showTagMenu = false;
+			selectedOptionIndex = 0;
+		}
+	}
+
+	function handle_click_outside(event: MouseEvent): void {
+		if (showTagMenu) {
+			const target = event.target as Node;
+			const tagMenu = document.getElementById("tag-menu");
+			if (tagMenu && !tagMenu.contains(target)) {
+				showTagMenu = false;
+			}
+		}
+	}
+
+	const dispatch = createEventDispatcher<{
+		change: DialogueLine[] | string;
+		submit: undefined;
+		blur: undefined;
+		select: SelectData;
+		input: undefined;
+		focus: undefined;
+		copy: CopyData;
+	}>();
+
+	function handle_change(): void {
+		dispatch("change", value);
+		if (!value_is_output) {
+			dispatch("input");
+		}
+	}
+
+	function sync_value(dialogueLines: DialogueLine[]): void {
+		if (speakers.length !== 0) {
+			is_internal_update = true;
+			value = [...dialogueLines];
+		}
+	}
+
+	$: sync_value(dialogue_lines);
+
+	$: if (JSON.stringify(value) !== old_value) {
+		if (value == null) {
+			dialogue_lines = [];
+		}
+		old_value = JSON.stringify(value);
+		if (typeof value === "string") {
+			textbox_value = value;
+		} else if (typeof value === "object" && Array.isArray(value)) {
+			dialogue_lines = [...value];
+			if (!is_internal_update || checked) {
+				value_to_string(dialogue_lines).then((result) => {
+					textbox_value = result;
+				});
+			}
+		}
+		is_internal_update = false;
+		handle_change();
+	}
+
+	async function value_to_string(
+		value: DialogueLine[] | string
+	): Promise<string> {
+		if (typeof value === "string") {
+			return value;
+		}
+		return await server.format(value);
+	}
+
+	async function handle_copy(): Promise<void> {
+		if ("clipboard" in navigator) {
+			const text = await value_to_string(value);
+			await navigator.clipboard.writeText(text);
+			dispatch("copy", { value: text });
+			copy_feedback();
+		}
+	}
+
+	function copy_feedback(): void {
+		copied = true;
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			copied = false;
+		}, 1000);
+	}
+
+	async function handle_submit(): Promise<void> {
+		if (checked) {
+			value = await server.unformat({ text: textbox_value });
+		}
+		dispatch("submit");
+	}
+
+	onMount(async () => {
+		if (typeof value === "string") {
+			textbox_value = value;
+		} else if (value && value.length > 0) {
+			const formatted = await value_to_string(value);
+			textbox_value = formatted;
+		} else {
+			textbox_value = "";
+		}
+	});
+</script>
+
+<svelte:window on:click={handle_click_outside} />
+
+<label class:container>
+	{#if show_label && show_copy_button}
+		<IconButtonWrapper>
+			<IconButton
+				Icon={copied ? Check : Copy}
+				on:click={handle_copy}
+				label={copied ? "Copied" : "Copy"}
+			/>
+		</IconButtonWrapper>
+	{/if}
+
+	<BlockTitle {show_label} {info}>{label}</BlockTitle>
+	{#if speakers.length !== 0 && ui_mode === "both"}
+		<div
+			class="switch-container top-switch"
+			class:switch-disabled={is_formatting || is_unformatting}
+		>
+			<Switch
+				label="Plain Text"
+				bind:checked
+				disabled={is_formatting || is_unformatting}
+				on:click={async (e) => {
+					if (!e.detail.checked) {
+						is_unformatting = true;
+						try {
+							value = await server.unformat({ text: textbox_value });
+							dialogue_lines = [...value];
+						} finally {
+							is_unformatting = false;
+						}
+					} else {
+						is_formatting = true;
+						try {
+							textbox_value = await value_to_string(dialogue_lines);
+						} finally {
+							is_formatting = false;
+						}
+					}
+				}}
+			/>
+		</div>
+	{/if}
+	{#if !checked && ui_mode !== "text"}
+		<div
+			class="dialogue-container"
+			bind:this={dialogue_container_element}
+			class:loading={is_unformatting}
+		>
+			{#if is_unformatting}
+				<div class="loading-overlay" transition:fade={{ duration: 200 }}>
+					<div class="loading-spinner"></div>
+					<div class="loading-text">Converting to dialogue format...</div>
+				</div>
+			{/if}
+			{#each dialogue_lines as line, i}
+				<div
+					class="dialogue-line"
+					style="--speaker-bg-color: {disabled &&
+					(hoveredSpeaker === null || hoveredSpeaker === line.speaker)
+						? speakerColors[line.speaker] || 'transparent'
+						: 'transparent'}"
+				>
+					<div
+						class="speaker-column"
+						role="button"
+						tabindex="0"
+						on:mouseenter={() => disabled && (hoveredSpeaker = line.speaker)}
+						on:mouseleave={() => disabled && (hoveredSpeaker = null)}
+					>
+						{#if disabled}
+							<textarea
+								bind:value={line.speaker}
+								{disabled}
+								rows="1"
+								readonly
+							/>
+						{:else}
+							<BaseDropdown
+								bind:value={line.speaker}
+								on:change={() => update_line(i, "speaker", line.speaker)}
+								choices={speakers.map((s) => [s, s])}
+								show_label={false}
+								container={true}
+								label={""}
+							/>
+						{/if}
+					</div>
+					<div class="text-column">
+						<div class="input-container">
+							<textarea
+								bind:value={line.text}
+								{placeholder}
+								{disabled}
+								on:input={(event) => handle_input(event, i)}
+								on:focus={(event) => handle_input(event, i)}
+								on:keydown={(event) => {
+									if (event.key === "Escape" && showTagMenu) {
+										showTagMenu = false;
+										selectedOptionIndex = 0;
+										event.preventDefault();
+									} else if (showTagMenu && currentLineIndex === i) {
+										if (event.key === "ArrowDown") {
+											selectedOptionIndex = Math.min(
+												selectedOptionIndex + 1,
+												filtered_tags.length - 1
+											);
+											event.preventDefault();
+										} else if (event.key === "ArrowUp") {
+											selectedOptionIndex = Math.max(
+												selectedOptionIndex - 1,
+												0
+											);
+											event.preventDefault();
+										} else if (event.key === "Enter") {
+											if (filtered_tags[selectedOptionIndex]) {
+												insert_selected_tag();
+											}
+											event.preventDefault();
+										}
+									}
+								}}
+								bind:this={input_elements[i]}
+								rows="1"
+							></textarea>
+							{#if showTagMenu && currentLineIndex === i}
+								<div
+									id="tag-menu"
+									class="tag-menu"
+									transition:fade={{ duration: 100 }}
+								>
+									<BaseDropdownOptions
+										choices={tags.map((s, i) => [s, i])}
+										filtered_indices={filtered_tags.map((s) => tags.indexOf(s))}
+										active_index={filtered_tags.map((s) => tags.indexOf(s))[
+											selectedOptionIndex
+										]}
+										show_options={true}
+										on:change={(e) => insert_tag(e)}
+										{offset_from_top}
+										from_top={true}
+									/>
+								</div>
+							{/if}
+						</div>
+					</div>
+					{#if max_lines == undefined || (max_lines && i < max_lines - 1)}
+						<div class:action-column={i == 0} class:hidden={disabled}>
+							<button
+								class="add-button"
+								on:click={() => add_line(i)}
+								aria-label="Add new line"
+								{disabled}
+							>
+								<Plus />
+							</button>
+						</div>
+					{/if}
+					<div class="action-column" class:hidden={disabled || i == 0}>
+						<button
+							class="delete-button"
+							on:click={() => delete_line(i)}
+							aria-label="Remove current line"
+							{disabled}
+						>
+							<Trash />
+						</button>
+					</div>
+				</div>
+			{/each}
+		</div>
+	{:else if checked && ui_mode !== "dialogue"}
+		<div class="textarea-container" class:loading={is_formatting}>
+			{#if is_formatting}
+				<div class="loading-overlay" transition:fade={{ duration: 200 }}>
+					<div class="loading-spinner"></div>
+					<div class="loading-text">Converting to plain text...</div>
+				</div>
+			{/if}
+			<textarea
+				data-testid="textbox"
+				bind:value={textbox_value}
+				{placeholder}
+				rows={5}
+				{disabled}
+				on:input={(event) => {
+					handle_input(event, 0);
+				}}
+				on:focus={(event) => handle_input(event, 0)}
+				on:keydown={(event) => {
+					if (event.key === "Escape" && showTagMenu) {
+						showTagMenu = false;
+						selectedOptionIndex = 0;
+						event.preventDefault();
+					} else if (showTagMenu) {
+						if (event.key === "ArrowDown") {
+							selectedOptionIndex = Math.min(
+								selectedOptionIndex + 1,
+								filtered_tags.length - 1
+							);
+							event.preventDefault();
+						} else if (event.key === "ArrowUp") {
+							selectedOptionIndex = Math.max(selectedOptionIndex - 1, 0);
+							event.preventDefault();
+						} else if (event.key === "Enter") {
+							if (filtered_tags[selectedOptionIndex]) {
+								insert_selected_tag();
+							}
+							event.preventDefault();
+						}
+					}
+				}}
+				bind:this={textarea_element}
+			/>
+			{#if showTagMenu}
+				<div
+					id="tag-menu"
+					class="tag-menu-plain-text"
+					transition:fade={{ duration: 100 }}
+				>
+					<BaseDropdownOptions
+						choices={tags.map((s, i) => [s, i])}
+						filtered_indices={filtered_tags.map((s) => tags.indexOf(s))}
+						active_index={filtered_tags.map((s) => tags.indexOf(s))[
+							selectedOptionIndex
+						]}
+						show_options={true}
+						on:change={(e) => insert_tag(e)}
+					/>
+				</div>
+			{/if}
+		</div>
+	{/if}
+
+	{#if show_submit_button && !disabled}
+		<div class="submit-container">
+			<button class="submit-button" on:click={handle_submit} {disabled}>
+				<Send />
+			</button>
+		</div>
+	{/if}
+</label>
+
+<style>
+	label {
+		display: block;
+		width: 100%;
+	}
+
+	.input-container {
+		display: flex;
+		position: relative;
+		align-items: flex-end;
+	}
+
+	.dialogue-container {
+		border: none;
+		border-radius: var(--input-radius);
+		background: var(--input-background-fill);
+		padding: var(--spacing-md);
+		margin-bottom: var(--spacing-sm);
+		position: relative;
+	}
+
+	.dialogue-line {
+		display: flex;
+		align-items: center;
+		margin-bottom: var(--spacing-sm);
+	}
+
+	.dialogue-line:has(.action-column.hidden) .text-column {
+		margin-right: 0;
+	}
+
+	.speaker-column {
+		flex: 0 0 150px;
+		margin-right: var(--spacing-sm);
+		display: flex;
+		align-items: center;
+	}
+
+	.speaker-column textarea {
+		background: var(--speaker-bg-color);
+		transition: background-color 0.2s ease;
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-sm);
+		padding: var(--input-padding);
+		color: var(--body-text-color);
+		font-weight: var(--input-text-weight);
+		font-size: var(--input-text-size);
+		line-height: var(--line-sm);
+		resize: none;
+		width: 100%;
+		box-sizing: border-box;
+		height: auto;
+		min-height: 30px;
+		max-height: none;
+		margin-top: 0px;
+		margin-bottom: 0px;
+		z-index: 1;
+		display: block;
+		position: relative;
+		white-space: pre-wrap;
+		word-wrap: break-word;
+		overflow-wrap: break-word;
+		overflow: hidden;
+	}
+
+	.text-column {
+		flex: 1;
+		margin-right: var(--spacing-sm);
+	}
+
+	.text-column textarea {
+		width: 100%;
+		padding: var(--spacing-sm);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-sm);
+		color: var(--body-text-color);
+		background: var(--speaker-bg-color);
+		transition: background-color 0.2s ease;
+		height: auto;
+		min-height: 30px;
+		max-height: none;
+		flex-grow: 1;
+		margin-top: 0px;
+		margin-bottom: 0px;
+		resize: none;
+		z-index: 1;
+		display: block;
+		position: relative;
+		padding: var(--input-padding);
+		width: 100%;
+		color: var(--body-text-color);
+		font-weight: var(--input-text-weight);
+		font-size: var(--input-text-size);
+		line-height: var(--line-sm);
+		white-space: pre-wrap;
+		word-wrap: break-word;
+		overflow-wrap: break-word;
+		overflow: hidden;
+		box-sizing: border-box;
+	}
+
+	.text-column textarea {
+		color: var(--body-text-color);
+	}
+
+	.dialogue-line[style*="--speaker-bg-color: rgba"] .text-column textarea,
+	.dialogue-line[style*="--speaker-bg-color: rgba"] .speaker-column textarea {
+		color: black;
+	}
+
+	textarea {
+		flex-grow: 1;
+		outline: none !important;
+		margin-top: 0px;
+		margin-bottom: 0px;
+		resize: none;
+		z-index: 1;
+		display: block;
+		position: relative;
+		outline: none !important;
+		background: var(--input-background-fill);
+		padding: var(--input-padding);
+		width: 100%;
+		color: var(--body-text-color);
+		font-weight: var(--input-text-weight);
+		font-size: var(--input-text-size);
+		line-height: var(--line-sm);
+		box-shadow: var(--input-shadow);
+		border: var(--input-border-width) solid var(--input-border-color);
+		border-radius: var(--input-radius);
+	}
+
+	textarea:disabled {
+		-webkit-opacity: 1;
+		opacity: 1;
+	}
+
+	textarea:focus {
+		box-shadow: var(--input-shadow-focus);
+		border-color: var(--input-border-color-focus);
+		background: var(--input-background-fill-focus);
+	}
+
+	textarea::placeholder {
+		color: var(--input-placeholder-color);
+	}
+
+	.action-column {
+		display: flex;
+		justify-content: center;
+	}
+
+	.add-button {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		width: 25px;
+		height: 25px;
+		border: none;
+		background: transparent;
+		cursor: pointer;
+	}
+
+	.delete-button {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		width: 15px;
+		height: 15px;
+	}
+
+	.add-button:hover {
+		color: var(--color-accent);
+	}
+
+	.switch-container {
+		display: flex;
+		justify-content: flex-start;
+		transition: opacity 0.2s ease-in-out;
+	}
+
+	.switch-container.switch-disabled {
+		opacity: 0.6;
+		pointer-events: none;
+	}
+
+	.switch-container.top-switch {
+		margin-bottom: var(--spacing-sm);
+		justify-content: flex-end;
+	}
+
+	.submit-container {
+		display: flex;
+		justify-content: flex-end;
+		margin-top: var(--spacing-sm);
+	}
+
+	.submit-container button[disabled] {
+		cursor: not-allowed;
+	}
+
+	.submit-button {
+		border: none;
+		text-align: center;
+		text-decoration: none;
+		font-size: 14px;
+		cursor: pointer;
+		border-radius: 15px;
+		min-width: 30px;
+		height: 30px;
+		flex-shrink: 0;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		background: var(--button-secondary-background-fill);
+		color: var(--button-secondary-text-color);
+	}
+
+	.submit-button:hover {
+		background: var(--button-secondary-background-fill-hover);
+	}
+
+	.submit-button:active {
+		box-shadow: var(--button-shadow-active);
+	}
+
+	.submit-button :global(svg) {
+		height: 22px;
+		width: 22px;
+	}
+
+	.tag-menu {
+		position: absolute;
+		width: 100%;
+		top: 100%;
+		left: 0;
+	}
+
+	.tag-menu-plain-text {
+		position: relative;
+		width: 100%;
+	}
+
+	.tag-menu-plain-text :global(.options) {
+		position: static !important;
+		width: 100% !important;
+		max-height: none !important;
+		top: auto !important;
+		bottom: auto !important;
+	}
+
+	.hidden {
+		display: none;
+	}
+
+	.loading-overlay {
+		position: absolute;
+		top: 0;
+		left: 0;
+		right: 0;
+		bottom: 0;
+		background: var(--input-background-fill);
+		opacity: 0.95;
+		backdrop-filter: blur(2px);
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		z-index: 10;
+		border-radius: var(--input-radius);
+	}
+
+	.loading-spinner {
+		width: 24px;
+		height: 24px;
+		border: 2px solid var(--border-color-primary);
+		border-top: 2px solid var(--color-accent);
+		border-radius: 50%;
+		animation: spin 1s linear infinite;
+		margin-bottom: var(--spacing-sm);
+	}
+
+	@keyframes spin {
+		0% {
+			transform: rotate(0deg);
+		}
+		100% {
+			transform: rotate(360deg);
+		}
+	}
+
+	.loading-text {
+		color: var(--body-text-color);
+		font-size: var(--text-sm);
+		font-weight: 500;
+		opacity: 0.8;
+	}
+
+	.dialogue-container.loading,
+	.textarea-container.loading {
+		position: relative;
+		opacity: 0.7;
+		transition: opacity 0.3s ease-in-out;
+	}
+
+	.dialogue-container,
+	.textarea-container {
+		transition: opacity 0.3s ease-in-out;
+	}
+</style>

5.49.1/dialogue/Example.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+	export let value: string;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</script>
+
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	{value}
+</div>
+
+<style>
+	.gallery {
+		padding: var(--size-1) var(--size-2);
+	}
+</style>

5.49.1/dialogue/Index.svelte

@@ -0,0 +1,95 @@
+<svelte:options accessors={true} />
+
+<script context="module" lang="ts">
+	export { default as BaseDialogue } from "./Dialogue.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio, SelectData, CopyData } from "@gradio/utils";
+	import Dialogue from "./Dialogue.svelte";
+	import { Block } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import type { DialogueLine } from "./utils";
+	export let gradio: Gradio<{
+		change: DialogueLine[] | string;
+		submit: never;
+		blur: never;
+		select: SelectData;
+		input: never;
+		focus: never;
+		clear_status: LoadingStatus;
+		copy: CopyData;
+	}>;
+
+	export let server: {
+		format: (body: DialogueLine[]) => Promise<string>;
+		unformat: (body: object) => Promise<DialogueLine[]>;
+	};
+
+	export let label = "Dialogue";
+	export let speakers: string[] = [];
+	export let tags: string[] = [];
+	export let info: string | undefined = undefined;
+	export let placeholder: string | undefined = undefined;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible: boolean | "hidden" = true;
+	export let value: DialogueLine[] | string = [];
+	export let show_label: boolean;
+	export let max_lines: number | undefined = undefined;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let show_copy_button = false;
+	export let loading_status: LoadingStatus | undefined = undefined;
+	export let value_is_output = false;
+	export let interactive: boolean;
+	export let show_submit_button = true;
+	export let ui_mode: "dialogue" | "text" | "both" = "both";
+</script>
+
+<Block
+	{visible}
+	{elem_id}
+	{elem_classes}
+	{scale}
+	{min_width}
+	allow_overflow={true}
+	padding={container}
+>
+	{#if loading_status}
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+			on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+		/>
+	{/if}
+
+	<Dialogue
+		bind:value
+		bind:value_is_output
+		{label}
+		{info}
+		{show_label}
+		{max_lines}
+		{show_copy_button}
+		{container}
+		{speakers}
+		{tags}
+		{placeholder}
+		{show_submit_button}
+		{server}
+		{ui_mode}
+		on:change={() => gradio.dispatch("change", value)}
+		on:input={() => gradio.dispatch("input")}
+		on:submit={() => gradio.dispatch("submit")}
+		on:blur={() => gradio.dispatch("blur")}
+		on:select={(e) => gradio.dispatch("select", e.detail)}
+		on:focus={() => gradio.dispatch("focus")}
+		on:copy={(e) => gradio.dispatch("copy", e.detail)}
+		disabled={!interactive}
+	/>
+</Block>

5.49.1/dialogue/Switch.svelte

@@ -0,0 +1,86 @@
+<script lang="ts">
+	// based on https://svelte.dev/playground/d65a4e9f0ae74d1eb1b08d13e428af32?version=3.35.0
+
+	import { createEventDispatcher } from "svelte";
+	export let label;
+	export let checked = false;
+	export let disabled = false;
+	const dispatch = createEventDispatcher();
+	// @ts-ignore
+	function handleClick(event: Event): void {
+		const target = event.target;
+		// @ts-ignore
+		const state = target.getAttribute("aria-checked");
+		checked = state === "true" ? false : true;
+		dispatch("click", { checked });
+	}
+</script>
+
+<div class="s s--slider" style="font-size:var(--font-size-sm)px">
+	<button
+		role="switch"
+		aria-checked={checked}
+		on:click={handleClick}
+		{disabled}
+	>
+	</button>
+	<span>{label}</span>
+</div>
+
+<style>
+	.s--slider {
+		display: flex;
+		align-items: center;
+	}
+
+	.s--slider button {
+		width: 3em;
+		height: 1.6em;
+		position: relative;
+		margin: 0 0.5em 0 0;
+		background: var(--button-secondary-background-fill);
+		border: none;
+	}
+
+	.s--slider button[disabled] {
+		cursor: not-allowed;
+	}
+
+	.s--slider button::before {
+		content: "";
+		position: absolute;
+		width: 1.3em;
+		height: 1.3em;
+		background: #fff;
+		top: 0.13em;
+		right: 1.5em;
+		transition: transform 0.3s;
+	}
+
+	.s--slider button[aria-checked="true"] {
+		background-color: var(--color-accent);
+	}
+
+	.s--slider button[aria-checked="true"]::before {
+		transform: translateX(1.3em);
+		transition: transform 0.3s;
+	}
+
+	.s--slider button:focus {
+		box-shadow: 0 0px 0px 1px var(--color-accent);
+	}
+
+	/* Slider Design Option */
+	.s--slider button {
+		border-radius: 1.5em;
+	}
+
+	.s--slider button::before {
+		border-radius: 100%;
+	}
+
+	.s--slider button:focus {
+		box-shadow: 0 0px 8px var(--accent-color);
+		border-radius: 1.5em;
+	}
+</style>

5.49.1/dialogue/main.ts

@@ -0,0 +1,2 @@
+import { default as Index } from "./Index.svelte";
+export default Index;

5.49.1/dialogue/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@gradio/dialogue",
+	"version": "0.2.3",
+	"description": "Gradio dialogue component",
+	"type": "module",
+	"author": "Gradio",
+	"license": "ISC",
+	"private": false,
+	"main_changeset": true,
+	"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/dropdown": "workspace:^",
+		"@gradio/textbox": "workspace:^"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/dialogue"
+	}
+}

5.49.1/dialogue/utils.ts

@@ -0,0 +1,4 @@
+export interface DialogueLine {
+	speaker: string;
+	text: string;
+}