Upload folder using huggingface_hub

6.2.0/dropdown/Example.svelte

@@ -0,0 +1,33 @@
+<script lang="ts">
+	export let value: string | string[] | null;
+	export let type: "gallery" | "table";
+	export let selected = false;
+	export let choices: [string, string | number][];
+
+	let value_array = value ? (Array.isArray(value) ? value : [value]) : [];
+	let names = value_array
+		.map(
+			(val) =>
+				(
+					choices.find((pair) => pair[1] === val) as
+						| [string, string | number]
+						| undefined
+				)?.[0]
+		)
+		.filter((name) => name !== undefined);
+	let names_string = names.join(", ");
+</script>
+
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	{names_string}
+</div>
+
+<style>
+	.gallery {
+		padding: var(--size-1) var(--size-2);
+	}
+</style>

6.2.0/dropdown/Index.svelte

@@ -0,0 +1,57 @@
+<script context="module" lang="ts">
+	export { default as BaseDropdown } from "./shared/Dropdown.svelte";
+	export { default as BaseDropdownOptions } from "./shared/DropdownOptions.svelte";
+	export { default as BaseMultiselect } from "./shared/Multiselect.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import { Gradio } from "@gradio/utils";
+	import Multiselect from "./shared/Multiselect.svelte";
+	import Dropdown from "./shared/Dropdown.svelte";
+	import { Block } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { DropdownProps, DropdownEvents } from "./types.ts";
+
+	let props = $props();
+	const gradio = new Gradio<DropdownEvents, DropdownProps>(props);
+</script>
+
+<Block
+	visible={gradio.shared.visible}
+	elem_id={gradio.shared.elem_id}
+	elem_classes={gradio.shared.elem_classes}
+	padding={gradio.shared.container}
+	allow_overflow={false}
+	scale={gradio.shared.scale}
+	min_width={gradio.shared.min_width}
+>
+	<StatusTracker
+		autoscroll={gradio.shared.autoscroll}
+		i18n={gradio.i18n}
+		{...gradio.shared.loading_status}
+		on_clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+
+	{#if gradio.props.multiselect}
+		<Multiselect {gradio} />
+	{:else}
+		<Dropdown
+			label={gradio.shared.label}
+			info={gradio.props.info}
+			bind:value={gradio.props.value}
+			choices={gradio.props.choices}
+			interactive={gradio.shared.interactive}
+			show_label={gradio.shared.show_label}
+			container={gradio.shared.container}
+			allow_custom_value={gradio.props.allow_custom_value}
+			filterable={gradio.props.filterable}
+			on_change={() => gradio.dispatch("change")}
+			on_input={() => gradio.dispatch("input")}
+			on_select={(data) => gradio.dispatch("select", data)}
+			on_focus={() => gradio.dispatch("focus")}
+			on_blur={() => gradio.dispatch("blur")}
+			on_key_up={(data) => gradio.dispatch("key_up", data)}
+		/>
+	{/if}
+</Block>

6.2.0/dropdown/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@gradio/dropdown",
+	"version": "0.10.7",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"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:^"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^5.43.4"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/dropdown"
+	}
+}

6.2.0/dropdown/shared/Dropdown.svelte

@@ -0,0 +1,285 @@
+<script lang="ts">
+	import DropdownOptions from "./DropdownOptions.svelte";
+	import { BlockTitle } from "@gradio/atoms";
+	import { DropdownArrow } from "@gradio/icons";
+	import { handle_filter, handle_shared_keys } from "./utils";
+	import type { SelectData, KeyUpData } from "@gradio/utils";
+	import { tick } from "svelte";
+
+	const is_browser = typeof window !== "undefined";
+
+	let {
+		label = "Dropdown",
+		info = undefined,
+		value = $bindable<string | number | null>(),
+		choices = [],
+		interactive = true,
+		show_label = true,
+		container = true,
+		allow_custom_value = false,
+		filterable = true,
+		on_change,
+		on_input,
+		on_select,
+		on_focus,
+		on_blur,
+		on_key_up
+	}: {
+		label?: string;
+		info?: string;
+		value?: string | number | null;
+		choices?: [string, string | number][];
+		interactive?: boolean;
+		show_label?: boolean;
+		container?: boolean;
+		allow_custom_value?: boolean;
+		filterable?: boolean;
+		on_change?: (value: string | number | null) => void;
+		on_input?: () => void;
+		on_select?: (data: SelectData) => void;
+		on_focus?: () => void;
+		on_blur?: () => void;
+		on_key_up?: (data: KeyUpData) => void;
+	} = $props();
+
+	let filter_input: HTMLElement;
+
+	let show_options = $derived.by(() => {
+		return is_browser && filter_input === document.activeElement;
+	});
+	let choices_names: string[] = $derived.by(() => {
+		return choices.map((c) => c[0]);
+	});
+	let choices_values: (string | number)[] = $derived.by(() => {
+		return choices.map((c) => c[1]);
+	});
+	let [input_text, selected_index] = $derived.by(() => {
+		if (
+			value === undefined ||
+			value === null ||
+			(Array.isArray(value) && value.length === 0)
+		) {
+			return ["", null];
+		} else if (choices_values.includes(value as string | number)) {
+			return [
+				choices_names[choices_values.indexOf(value as string | number)],
+				choices_values.indexOf(value as string | number)
+			];
+		} else if (allow_custom_value) {
+			return [value as string, null];
+		} else {
+			return ["", null];
+		}
+	});
+	let initialized = $state(false);
+	let disabled = $derived(!interactive);
+
+	// All of these are indices with respect to the choices array
+	let filtered_indices = $state(choices.map((_, i) => i));
+	let active_index: number | null = $state(null);
+
+	function handle_option_selected(e: any): void {
+		selected_index = parseInt(e.detail.target.dataset.index);
+		if (isNaN(selected_index)) {
+			// This is the case when the user clicks on the scrollbar
+			selected_index = null;
+			return;
+		}
+
+		let [_input_text, _value] = choices[selected_index];
+		input_text = _input_text;
+		value = _value;
+		on_select?.({
+			index: selected_index,
+			value: choices_values[selected_index],
+			selected: true
+		});
+		show_options = false;
+		active_index = null;
+		filter_input.blur();
+	}
+
+	function handle_focus(e: FocusEvent): void {
+		filtered_indices = choices.map((_, i) => i);
+		show_options = true;
+		on_focus?.();
+	}
+
+	function handle_blur(): void {
+		if (!allow_custom_value) {
+			input_text =
+				choices_names[choices_values.indexOf(value as string | number)];
+		} else {
+			value = input_text;
+		}
+		show_options = false;
+		active_index = null;
+		filtered_indices = choices.map((_, i) => i);
+		on_blur?.();
+		on_input?.();
+	}
+
+	async function handle_key_down(e: KeyboardEvent): Promise<void> {
+		await tick();
+		filtered_indices = handle_filter(choices, input_text);
+		active_index = filtered_indices.length > 0 ? filtered_indices[0] : null;
+		[show_options, active_index] = handle_shared_keys(
+			e,
+			active_index,
+			filtered_indices
+		);
+		if (e.key === "Enter") {
+			if (active_index !== null) {
+				selected_index = active_index;
+				value = choices_values[active_index];
+				show_options = false;
+				filter_input.blur();
+				active_index = null;
+			} else if (choices_names.includes(input_text)) {
+				selected_index = choices_names.indexOf(input_text);
+				value = choices_values[selected_index];
+				show_options = false;
+				active_index = null;
+				filter_input.blur();
+			} else if (allow_custom_value) {
+				value = input_text;
+				selected_index = null;
+				show_options = false;
+				active_index = null;
+				filter_input.blur();
+			}
+		}
+	}
+
+	let old_value = $state(value);
+	$effect(() => {
+		if (old_value !== value) {
+			old_value = value;
+			on_change?.(value);
+		}
+	});
+</script>
+
+<div class:container>
+	<BlockTitle {show_label} {info}>{label}</BlockTitle>
+
+	<div class="wrap">
+		<div class="wrap-inner" class:show_options>
+			<div class="secondary-wrap">
+				<input
+					role="listbox"
+					aria-controls="dropdown-options"
+					aria-expanded={show_options}
+					aria-label={label}
+					class="border-none"
+					class:subdued={!choices_names.includes(input_text) &&
+						!allow_custom_value}
+					autocomplete="off"
+					{disabled}
+					bind:value={input_text}
+					bind:this={filter_input}
+					on:keydown={handle_key_down}
+					on:keyup={(e) => {
+						on_key_up?.({
+							key: e.key,
+							input_value: input_text
+						});
+					}}
+					on:blur={handle_blur}
+					on:focus={handle_focus}
+					readonly={!filterable}
+				/>
+				{#if !disabled}
+					<div class="icon-wrap">
+						<DropdownArrow />
+					</div>
+				{/if}
+			</div>
+		</div>
+		<DropdownOptions
+			{show_options}
+			{choices}
+			{filtered_indices}
+			{disabled}
+			selected_indices={selected_index === null ? [] : [selected_index]}
+			{active_index}
+			on:change={handle_option_selected}
+			on:load={() => (initialized = true)}
+		/>
+	</div>
+</div>
+
+<style>
+	.icon-wrap {
+		position: absolute;
+		top: 50%;
+		transform: translateY(-50%);
+		right: var(--size-5);
+		color: var(--body-text-color);
+		width: var(--size-5);
+		pointer-events: none;
+	}
+	.container {
+		height: 100%;
+	}
+	.container .wrap {
+		box-shadow: var(--input-shadow);
+		border: var(--input-border-width) solid var(--border-color-primary);
+	}
+
+	.wrap {
+		position: relative;
+		border-radius: var(--input-radius);
+		background: var(--input-background-fill);
+	}
+
+	.wrap:focus-within {
+		box-shadow: var(--input-shadow-focus);
+		border-color: var(--input-border-color-focus);
+		background: var(--input-background-fill-focus);
+	}
+
+	.wrap-inner {
+		display: flex;
+		position: relative;
+		flex-wrap: wrap;
+		align-items: center;
+		gap: var(--checkbox-label-gap);
+		padding: var(--checkbox-label-padding);
+		height: 100%;
+	}
+	.secondary-wrap {
+		display: flex;
+		flex: 1 1 0%;
+		align-items: center;
+		border: none;
+		min-width: min-content;
+		height: 100%;
+	}
+
+	input {
+		margin: var(--spacing-sm);
+		outline: none;
+		border: none;
+		background: inherit;
+		width: var(--size-full);
+		color: var(--body-text-color);
+		font-size: var(--input-text-size);
+		height: 100%;
+	}
+
+	input:disabled {
+		-webkit-text-fill-color: var(--body-text-color);
+		-webkit-opacity: 1;
+		opacity: 1;
+		cursor: not-allowed;
+	}
+
+	.subdued {
+		color: var(--body-text-color-subdued);
+	}
+
+	input[readonly] {
+		cursor: pointer;
+	}
+</style>

6.2.0/dropdown/shared/DropdownOptions.svelte

@@ -0,0 +1,163 @@
+<script lang="ts">
+	import { fly } from "svelte/transition";
+	import { createEventDispatcher } from "svelte";
+	export let choices: [string, string | number][];
+	export let filtered_indices: number[];
+	export let show_options = false;
+	export let disabled = false;
+	export let selected_indices: (string | number)[] = [];
+	export let active_index: number | null = null;
+	export let remember_scroll = false;
+	export let offset_from_top = 0;
+	export let from_top = false;
+
+	let distance_from_top: number;
+	let distance_from_bottom: number;
+	let input_height: number;
+	let input_width: number;
+	let refElement: HTMLDivElement;
+	let listElement: HTMLUListElement;
+	let top: string | null, bottom: string | null, max_height: number;
+	let innerHeight: number;
+	let list_scroll_y = 0;
+
+	function calculate_window_distance(): void {
+		const { top: ref_top, bottom: ref_bottom } =
+			refElement.getBoundingClientRect();
+		if (from_top) {
+			distance_from_top = offset_from_top;
+		} else {
+			distance_from_top = ref_top;
+		}
+		distance_from_bottom = innerHeight - ref_bottom;
+	}
+
+	let scroll_timeout: NodeJS.Timeout | null = null;
+	function scroll_listener(): void {
+		if (!show_options) return;
+		if (scroll_timeout !== null) {
+			clearTimeout(scroll_timeout);
+		}
+
+		scroll_timeout = setTimeout(() => {
+			calculate_window_distance();
+			scroll_timeout = null;
+		}, 10);
+	}
+
+	function restore_last_scroll(): void {
+		listElement?.scrollTo?.(0, list_scroll_y);
+	}
+
+	$: {
+		if (show_options && refElement) {
+			if (remember_scroll) {
+				restore_last_scroll();
+			} else {
+				if (listElement && selected_indices.length > 0) {
+					let elements = listElement.querySelectorAll("li");
+					for (const element of Array.from(elements)) {
+						if (
+							element.getAttribute("data-index") ===
+							selected_indices[0].toString()
+						) {
+							listElement?.scrollTo?.(0, (element as HTMLLIElement).offsetTop);
+							break;
+						}
+					}
+				}
+			}
+			calculate_window_distance();
+			const rect = refElement.parentElement?.getBoundingClientRect();
+			input_height = rect?.height || 0;
+			input_width = rect?.width || 0;
+		}
+		if (distance_from_bottom > distance_from_top || from_top) {
+			top = `${distance_from_top}px`;
+			max_height = distance_from_bottom;
+			bottom = null;
+		} else {
+			bottom = `${distance_from_bottom + input_height}px`;
+			max_height = distance_from_top - input_height;
+			top = null;
+		}
+	}
+
+	const dispatch = createEventDispatcher();
+</script>
+
+<svelte:window on:scroll={scroll_listener} bind:innerHeight />
+
+<div class="reference" bind:this={refElement} />
+{#if show_options && !disabled}
+	<ul
+		class="options"
+		transition:fly={{ duration: 200, y: 5 }}
+		on:mousedown|preventDefault={(e) => dispatch("change", e)}
+		on:scroll={(e) => (list_scroll_y = e.currentTarget.scrollTop)}
+		style:top
+		style:bottom
+		style:max-height={`calc(${max_height}px - var(--window-padding))`}
+		style:width={input_width + "px"}
+		bind:this={listElement}
+		role="listbox"
+	>
+		{#each filtered_indices as index}
+			<li
+				class="item"
+				class:selected={selected_indices.includes(index)}
+				class:active={index === active_index}
+				class:bg-gray-100={index === active_index}
+				class:dark:bg-gray-600={index === active_index}
+				style:width={input_width + "px"}
+				data-index={index}
+				aria-label={choices[index][0]}
+				data-testid="dropdown-option"
+				role="option"
+				aria-selected={selected_indices.includes(index)}
+			>
+				<span class:hide={!selected_indices.includes(index)} class="inner-item">
+					✓
+				</span>
+				{choices[index][0]}
+			</li>
+		{/each}
+	</ul>
+{/if}
+
+<style>
+	.options {
+		--window-padding: var(--size-8);
+		position: fixed;
+		z-index: var(--layer-top);
+		margin-left: 0;
+		box-shadow: var(--shadow-drop-lg);
+		border-radius: var(--container-radius);
+		background: var(--background-fill-primary);
+		min-width: fit-content;
+		max-width: inherit;
+		overflow: auto;
+		color: var(--body-text-color);
+		list-style: none;
+	}
+
+	.item {
+		display: flex;
+		cursor: pointer;
+		padding: var(--size-2);
+		word-break: break-word;
+	}
+
+	.item:hover,
+	.active {
+		background: var(--background-fill-secondary);
+	}
+
+	.inner-item {
+		padding-right: var(--size-1);
+	}
+
+	.hide {
+		visibility: hidden;
+	}
+</style>

6.2.0/dropdown/shared/Multiselect.svelte

@@ -0,0 +1,390 @@
+<script lang="ts">
+	import { _ } from "svelte-i18n";
+	import { BlockTitle } from "@gradio/atoms";
+	import { Remove, DropdownArrow } from "@gradio/icons";
+	import type { Gradio } from "@gradio/utils";
+	import DropdownOptions from "./DropdownOptions.svelte";
+	import { handle_filter, handle_shared_keys } from "./utils";
+	import type { DropdownEvents, DropdownProps, Item } from "../types.ts";
+
+	const props = $props();
+
+	const gradio: Gradio<DropdownEvents, DropdownProps> = props.gradio;
+
+	let filter_input: HTMLElement;
+	let input_text = $state("");
+	let label = $derived(gradio.shared.label || "Multiselect");
+
+	let choices_names: string[] = $derived.by(() => {
+		return gradio.props.choices.map((c) => c[0]);
+	});
+	let choices_values: (string | number)[] = $derived.by(() => {
+		return gradio.props.choices.map((c) => c[1]);
+	});
+
+	let disabled = $derived(!gradio.shared.interactive);
+
+	let show_options = $state(false);
+
+	// All of these are indices with respect to the choices array
+	let [filtered_indices, active_index] = $derived.by(() => {
+		const filtered = handle_filter(gradio.props.choices, input_text);
+		return [
+			filtered,
+			filtered.length > 0 && !gradio.props.allow_custom_value
+				? filtered[0]
+				: null
+		];
+	});
+
+	function set_selected_indices(): Item[] {
+		if (gradio.props.value === undefined) {
+			return [];
+		} else if (Array.isArray(gradio.props.value)) {
+			return gradio.props.value
+				.map((v) => {
+					const index = choices_values.indexOf(v);
+					if (index !== -1) {
+						return index;
+					}
+					if (gradio.props.allow_custom_value) {
+						return v;
+					}
+					// Instead of returning null, skip this iteration
+					return undefined;
+				})
+				.filter((val): val is string | number => val !== undefined);
+		}
+		return [];
+	}
+
+	let selected_indices: (number | string)[] = $derived.by(set_selected_indices);
+
+	function handle_blur(): void {
+		if (!gradio.props.allow_custom_value) {
+			input_text = "";
+		}
+
+		if (gradio.props.allow_custom_value && input_text !== "") {
+			add_selected_choice(input_text);
+			input_text = "";
+		}
+		gradio.dispatch("blur");
+		show_options = false;
+		active_index = null;
+	}
+
+	function remove_selected_choice(option_index: number | string) {
+		selected_indices = selected_indices.filter((v) => v !== option_index);
+		gradio.props.value = selected_indices.map((index) =>
+			typeof index === "number" ? choices_values[index] : index
+		);
+		gradio.dispatch("input");
+		gradio.dispatch("select", {
+			index: typeof option_index === "number" ? option_index : -1,
+			value:
+				typeof option_index === "number"
+					? choices_values[option_index]
+					: option_index,
+			selected: false
+		});
+	}
+
+	function add_selected_choice(option_index: number | string) {
+		if (
+			gradio.props.max_choices == null ||
+			selected_indices.length < gradio.props.max_choices
+		) {
+			selected_indices.push(option_index);
+			gradio.dispatch("select", {
+				index: typeof option_index === "number" ? option_index : -1,
+				value:
+					typeof option_index === "number"
+						? choices_values[option_index]
+						: option_index,
+				selected: true
+			});
+		}
+		if (selected_indices.length === gradio.props.max_choices) {
+			show_options = false;
+			active_index = null;
+			filter_input.blur();
+		}
+		gradio.props.value = selected_indices.map((index) =>
+			typeof index === "number" ? choices_values[index] : index
+		);
+	}
+
+	function handle_option_selected(e: any): void {
+		const option_index = parseInt(e.detail.target.dataset.index);
+		add_or_remove_index(option_index);
+	}
+
+	function add_or_remove_index(option_index: number): void {
+		if (selected_indices.includes(option_index)) {
+			remove_selected_choice(option_index);
+		} else {
+			add_selected_choice(option_index);
+		}
+		input_text = "";
+		active_index = null;
+		gradio.dispatch("input");
+	}
+
+	function remove_all(e: any): void {
+		selected_indices = [];
+		input_text = "";
+		gradio.props.value = [];
+		e.preventDefault();
+	}
+
+	function handle_focus(e: FocusEvent): void {
+		filtered_indices = gradio.props.choices.map((_, i) => i);
+		if (
+			gradio.props.max_choices === null ||
+			selected_indices.length < gradio.props.max_choices
+		) {
+			show_options = true;
+		}
+		gradio.dispatch("focus");
+		show_options = true;
+	}
+
+	function handle_key_down(e: KeyboardEvent): void {
+		[show_options, active_index] = handle_shared_keys(
+			e,
+			active_index,
+			filtered_indices
+		);
+		if (e.key === "Enter") {
+			if (active_index !== null) {
+				add_or_remove_index(active_index);
+			} else {
+				if (gradio.props.allow_custom_value) {
+					add_selected_choice(input_text);
+					input_text = "";
+				}
+			}
+		}
+		if (e.key === "Backspace" && input_text === "") {
+			selected_indices = [...selected_indices.slice(0, -1)];
+		}
+		if (selected_indices.length === gradio.props.max_choices) {
+			show_options = false;
+			active_index = null;
+		}
+	}
+
+	let old_value = $state(gradio.props.value);
+
+	$effect(() => {
+		if (old_value !== gradio.props.value) {
+			old_value = gradio.props.value;
+			gradio.dispatch("change");
+		}
+	});
+</script>
+
+<label class:container={gradio.shared.container}>
+	<BlockTitle show_label={gradio.shared.show_label} info={gradio.props.info}
+		>{label}</BlockTitle
+	>
+
+	<div class="wrap">
+		<div class="wrap-inner" class:show_options>
+			{#each selected_indices as s}
+				<div class="token">
+					<span>
+						{#if typeof s === "number"}
+							{choices_names[s]}
+						{:else}
+							{s}
+						{/if}
+					</span>
+					{#if !disabled}
+						<div
+							class="token-remove"
+							on:click|preventDefault={() => remove_selected_choice(s)}
+							on:keydown={(event) => {
+								if (event.key === "Enter") {
+									remove_selected_choice(s);
+								}
+							}}
+							role="button"
+							tabindex="0"
+							title={gradio.i18n("common.remove") + " " + s}
+						>
+							<Remove />
+						</div>
+					{/if}
+				</div>
+			{/each}
+			<div class="secondary-wrap">
+				<input
+					class="border-none"
+					class:subdued={(!choices_names.includes(input_text) &&
+						!gradio.props.allow_custom_value) ||
+						selected_indices.length === gradio.props.max_choices}
+					{disabled}
+					autocomplete="off"
+					bind:value={input_text}
+					bind:this={filter_input}
+					on:keydown={handle_key_down}
+					on:keyup={(e) => {
+						gradio.dispatch("key_up", {
+							key: e.key,
+							input_value: input_text
+						});
+					}}
+					on:blur={handle_blur}
+					on:focus={handle_focus}
+					readonly={!gradio.props.filterable}
+				/>
+
+				{#if !disabled}
+					{#if selected_indices.length > 0}
+						<div
+							role="button"
+							tabindex="0"
+							class="token-remove remove-all"
+							title={gradio.i18n("common.clear")}
+							on:click={remove_all}
+							on:keydown={(event) => {
+								if (event.key === "Enter") {
+									remove_all(event);
+								}
+							}}
+						>
+							<Remove />
+						</div>
+					{/if}
+					<span class="icon-wrap"> <DropdownArrow /></span>
+				{/if}
+			</div>
+		</div>
+		<DropdownOptions
+			{show_options}
+			choices={gradio.props.choices}
+			{filtered_indices}
+			{disabled}
+			{selected_indices}
+			{active_index}
+			remember_scroll={true}
+			on:change={handle_option_selected}
+		/>
+	</div>
+</label>
+
+<style>
+	.icon-wrap {
+		color: var(--body-text-color);
+		margin-right: var(--size-2);
+		width: var(--size-5);
+	}
+	label:not(.container),
+	label:not(.container) .wrap,
+	label:not(.container) .wrap-inner,
+	label:not(.container) .secondary-wrap,
+	label:not(.container) .token,
+	label:not(.container) input {
+		height: 100%;
+	}
+	.container .wrap {
+		box-shadow: var(--input-shadow);
+		border: var(--input-border-width) solid var(--border-color-primary);
+	}
+
+	.wrap {
+		position: relative;
+		border-radius: var(--input-radius);
+		background: var(--input-background-fill);
+	}
+
+	.wrap:focus-within {
+		box-shadow: var(--input-shadow-focus);
+		border-color: var(--input-border-color-focus);
+	}
+
+	.wrap-inner {
+		display: flex;
+		position: relative;
+		flex-wrap: wrap;
+		align-items: center;
+		gap: var(--checkbox-label-gap);
+		padding: var(--checkbox-label-padding);
+	}
+
+	.token {
+		display: flex;
+		align-items: center;
+		transition: var(--button-transition);
+		cursor: pointer;
+		box-shadow: var(--checkbox-label-shadow);
+		border: var(--checkbox-label-border-width) solid
+			var(--checkbox-label-border-color);
+		border-radius: var(--button-small-radius);
+		background: var(--checkbox-label-background-fill);
+		padding: var(--checkbox-label-padding);
+		color: var(--checkbox-label-text-color);
+		font-weight: var(--checkbox-label-text-weight);
+		font-size: var(--checkbox-label-text-size);
+		line-height: var(--line-md);
+		word-break: break-word;
+	}
+
+	.token > * + * {
+		margin-left: var(--size-2);
+	}
+
+	.token-remove {
+		fill: var(--body-text-color);
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		cursor: pointer;
+		border: var(--checkbox-border-width) solid var(--border-color-primary);
+		border-radius: var(--radius-full);
+		background: var(--background-fill-primary);
+		padding: var(--size-0-5);
+		width: 16px;
+		height: 16px;
+		flex-shrink: 0;
+	}
+
+	.secondary-wrap {
+		display: flex;
+		flex: 1 1 0%;
+		align-items: center;
+		border: none;
+		min-width: min-content;
+	}
+
+	input {
+		margin: var(--spacing-sm);
+		outline: none;
+		border: none;
+		background: inherit;
+		width: var(--size-full);
+		color: var(--body-text-color);
+		font-size: var(--input-text-size);
+	}
+
+	input:disabled {
+		-webkit-text-fill-color: var(--body-text-color);
+		-webkit-opacity: 1;
+		opacity: 1;
+		cursor: not-allowed;
+	}
+
+	.remove-all {
+		margin-left: var(--size-1);
+		width: 20px;
+		height: 20px;
+	}
+	.subdued {
+		color: var(--body-text-color-subdued);
+	}
+	input[readonly] {
+		cursor: pointer;
+	}
+</style>

6.2.0/dropdown/shared/utils.ts

@@ -0,0 +1,56 @@
+function positive_mod(n: number, m: number): number {
+	return ((n % m) + m) % m;
+}
+
+export function handle_filter(
+	choices: [string, string | number][],
+	input_text: string
+): number[] {
+	return choices.reduce((filtered_indices, o, index) => {
+		if (
+			input_text ? o[0].toLowerCase().includes(input_text.toLowerCase()) : true
+		) {
+			filtered_indices.push(index);
+		}
+		return filtered_indices;
+	}, [] as number[]);
+}
+
+export function handle_change(
+	dispatch: any,
+	value: string | number | (string | number)[] | undefined,
+	value_is_output: boolean
+): void {
+	dispatch("change", value);
+	if (!value_is_output) {
+		dispatch("input");
+	}
+}
+
+export function handle_shared_keys(
+	e: KeyboardEvent,
+	active_index: number | null,
+	filtered_indices: number[]
+): [boolean, number | null] {
+	if (e.key === "Escape") {
+		return [false, active_index];
+	}
+	if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+		if (filtered_indices.length > 0) {
+			if (active_index === null) {
+				active_index =
+					e.key === "ArrowDown"
+						? filtered_indices[0]
+						: filtered_indices[filtered_indices.length - 1];
+			} else {
+				const index_in_filtered = filtered_indices.indexOf(active_index);
+				const increment = e.key === "ArrowUp" ? -1 : 1;
+				active_index =
+					filtered_indices[
+						positive_mod(index_in_filtered + increment, filtered_indices.length)
+					];
+			}
+		}
+	}
+	return [true, active_index];
+}

6.2.0/dropdown/types.ts

@@ -0,0 +1,22 @@
+import type { KeyUpData, SelectData } from "@gradio/utils";
+
+export type Item = string | number;
+
+export interface DropdownProps {
+	multiselect: boolean;
+	max_choices: number | null;
+	choices: [string, Item][];
+	allow_custom_value: boolean;
+	value: Item | Item[];
+	info: string;
+	filterable: boolean;
+}
+
+export interface DropdownEvents {
+	change: never;
+	input: never;
+	select: SelectData;
+	focus: never;
+	blur: never;
+	key_up: KeyUpData;
+}