Upload folder using huggingface_hub

5.49.1/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>

5.49.1/dropdown/Index.svelte

@@ -0,0 +1,104 @@
+<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 type { Gradio, KeyUpData, SelectData } 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 { LoadingStatus } from "@gradio/statustracker";
+
+	type Item = string | number;
+
+	export let label = "Dropdown";
+	export let info: string | undefined = undefined;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible: boolean | "hidden" = true;
+	export let multiselect = false;
+	export let value: Item | Item[] | undefined = multiselect ? [] : undefined;
+	export let value_is_output = false;
+	export let max_choices: number | null = null;
+	export let choices: [string, Item][];
+	export let show_label: boolean;
+	export let filterable: boolean;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let loading_status: LoadingStatus;
+	export let allow_custom_value = false;
+	export let gradio: Gradio<{
+		change: never;
+		input: never;
+		select: SelectData;
+		blur: never;
+		focus: never;
+		key_up: KeyUpData;
+		clear_status: LoadingStatus;
+	}>;
+	export let interactive: boolean;
+</script>
+
+<Block
+	{visible}
+	{elem_id}
+	{elem_classes}
+	padding={container}
+	allow_overflow={false}
+	{scale}
+	{min_width}
+>
+	<StatusTracker
+		autoscroll={gradio.autoscroll}
+		i18n={gradio.i18n}
+		{...loading_status}
+		on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+
+	{#if multiselect}
+		<Multiselect
+			bind:value
+			bind:value_is_output
+			{choices}
+			{max_choices}
+			{label}
+			{info}
+			{show_label}
+			{allow_custom_value}
+			{filterable}
+			{container}
+			i18n={gradio.i18n}
+			on:change={() => gradio.dispatch("change")}
+			on:input={() => gradio.dispatch("input")}
+			on:select={(e) => gradio.dispatch("select", e.detail)}
+			on:blur={() => gradio.dispatch("blur")}
+			on:focus={() => gradio.dispatch("focus")}
+			on:key_up={() => gradio.dispatch("key_up")}
+			disabled={!interactive}
+		/>
+	{:else}
+		<Dropdown
+			bind:value
+			bind:value_is_output
+			{choices}
+			{label}
+			{info}
+			{show_label}
+			{filterable}
+			{allow_custom_value}
+			{container}
+			on:change={() => gradio.dispatch("change")}
+			on:input={() => gradio.dispatch("input")}
+			on:select={(e) => gradio.dispatch("select", e.detail)}
+			on:blur={() => gradio.dispatch("blur")}
+			on:focus={() => gradio.dispatch("focus")}
+			on:key_up={(e) => gradio.dispatch("key_up", e.detail)}
+			disabled={!interactive}
+		/>
+	{/if}
+</Block>

5.49.1/dropdown/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@gradio/dropdown",
+	"version": "0.10.5",
+	"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": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/dropdown"
+	}
+}

5.49.1/dropdown/shared/Dropdown.svelte

@@ -0,0 +1,320 @@
+<script lang="ts">
+	import DropdownOptions from "./DropdownOptions.svelte";
+	import { createEventDispatcher, afterUpdate } from "svelte";
+	import { BlockTitle } from "@gradio/atoms";
+	import { DropdownArrow } from "@gradio/icons";
+	import type { SelectData, KeyUpData } from "@gradio/utils";
+	import { handle_filter, handle_change, handle_shared_keys } from "./utils";
+
+	type Item = string | number;
+
+	export let label: string;
+	export let info: string | undefined = undefined;
+	export let value: Item | Item[] | undefined = undefined;
+	let old_value: typeof value = undefined;
+	export let value_is_output = false;
+	export let choices: [string, Item][];
+	let old_choices: typeof choices;
+	export let disabled = false;
+	export let show_label: boolean;
+	export let container = true;
+	export let allow_custom_value = false;
+	export let filterable = true;
+
+	let filter_input: HTMLElement;
+
+	let show_options = false;
+	let choices_names: string[];
+	let choices_values: (string | number)[];
+	let input_text = "";
+	let old_input_text = "";
+	let initialized = false;
+
+	// All of these are indices with respect to the choices array
+	let filtered_indices: number[] = [];
+	let active_index: number | null = null;
+	// selected_index is null if allow_custom_value is true and the input_text is not in choices_names
+	let selected_index: number | null = null;
+	let old_selected_index: number | null;
+
+	const dispatch = createEventDispatcher<{
+		change: string | undefined;
+		input: undefined;
+		select: SelectData;
+		blur: undefined;
+		focus: undefined;
+		key_up: KeyUpData;
+	}>();
+
+	// Setting the initial value of the dropdown
+	if (value) {
+		old_selected_index = choices.map((c) => c[1]).indexOf(value as string);
+		selected_index = old_selected_index;
+		if (selected_index === -1) {
+			old_value = value;
+			selected_index = null;
+		} else {
+			[input_text, old_value] = choices[selected_index];
+			old_input_text = input_text;
+		}
+		set_input_text();
+	}
+
+	$: {
+		if (
+			selected_index !== old_selected_index &&
+			selected_index !== null &&
+			initialized
+		) {
+			[input_text, value] = choices[selected_index];
+			old_selected_index = selected_index;
+			dispatch("select", {
+				index: selected_index,
+				value: choices_values[selected_index],
+				selected: true
+			});
+		}
+	}
+
+	$: if (JSON.stringify(old_value ?? "") !== JSON.stringify(value ?? "")) {
+		set_input_text();
+		handle_change(dispatch, value, value_is_output);
+		old_value = value;
+	}
+
+	function set_choice_names_values(): void {
+		choices_names = choices.map((c) => c[0]);
+		choices_values = choices.map((c) => c[1]);
+	}
+
+	$: choices, set_choice_names_values();
+
+	const is_browser = typeof window !== "undefined";
+
+	$: {
+		if (choices !== old_choices) {
+			if (!allow_custom_value) {
+				set_input_text();
+			}
+			old_choices = choices;
+			filtered_indices = handle_filter(choices, input_text);
+			if (!allow_custom_value && filtered_indices.length > 0) {
+				active_index = filtered_indices[0];
+			}
+			if (is_browser && filter_input === document.activeElement) {
+				show_options = true;
+			}
+		}
+	}
+
+	$: {
+		if (input_text !== old_input_text) {
+			filtered_indices = handle_filter(choices, input_text);
+			old_input_text = input_text;
+			if (!allow_custom_value && filtered_indices.length > 0) {
+				active_index = filtered_indices[0];
+			}
+		}
+	}
+
+	function set_input_text(): void {
+		set_choice_names_values();
+		if (value === undefined || (Array.isArray(value) && value.length === 0)) {
+			input_text = "";
+			selected_index = null;
+		} else if (choices_values.includes(value as string)) {
+			input_text = choices_names[choices_values.indexOf(value as string)];
+			selected_index = choices_values.indexOf(value as string);
+		} else if (allow_custom_value) {
+			input_text = value as string;
+			selected_index = null;
+		} else {
+			input_text = "";
+			selected_index = null;
+		}
+		old_selected_index = selected_index;
+	}
+
+	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;
+		}
+		show_options = false;
+		active_index = null;
+		filter_input.blur();
+	}
+
+	function handle_focus(e: FocusEvent): void {
+		filtered_indices = choices.map((_, i) => i);
+		show_options = true;
+		dispatch("focus");
+	}
+
+	function handle_blur(): void {
+		if (!allow_custom_value) {
+			input_text = choices_names[choices_values.indexOf(value as string)];
+		} else {
+			value = input_text;
+		}
+		show_options = false;
+		active_index = null;
+		dispatch("blur");
+	}
+
+	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) {
+				selected_index = 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);
+				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();
+			}
+		}
+	}
+
+	afterUpdate(() => {
+		value_is_output = false;
+		initialized = true;
+	});
+</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}
+					{disabled}
+					autocomplete="off"
+					bind:value={input_text}
+					bind:this={filter_input}
+					on:keydown={handle_key_down}
+					on:keyup={(e) =>
+						dispatch("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}
+		/>
+	</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>

5.49.1/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>

5.49.1/dropdown/shared/Multiselect.svelte

@@ -0,0 +1,421 @@
+<script lang="ts">
+	import { afterUpdate, createEventDispatcher } from "svelte";
+	import { _ } from "svelte-i18n";
+	import { BlockTitle } from "@gradio/atoms";
+	import { Remove, DropdownArrow } from "@gradio/icons";
+	import type { KeyUpData, SelectData, I18nFormatter } from "@gradio/utils";
+	import DropdownOptions from "./DropdownOptions.svelte";
+	import { handle_filter, handle_change, handle_shared_keys } from "./utils";
+
+	type Item = string | number;
+
+	export let label: string;
+	export let info: string | undefined = undefined;
+	export let value: Item | Item[] | undefined = [];
+	let old_value: typeof value = [];
+	export let value_is_output = false;
+	export let max_choices: number | null = null;
+	export let choices: [string, Item][];
+	let old_choices: typeof choices;
+	export let disabled = false;
+	export let show_label: boolean;
+	export let container = true;
+	export let allow_custom_value = false;
+	export let filterable = true;
+	export let i18n: I18nFormatter;
+
+	let filter_input: HTMLElement;
+	let input_text = "";
+	let old_input_text = "";
+	let show_options = false;
+	let choices_names: string[];
+	let choices_values: (string | number)[];
+
+	// All of these are indices with respect to the choices array
+	let filtered_indices: number[] = [];
+	let active_index: number | null = null;
+	// selected_index consists of indices from choices or strings if allow_custom_value is true and user types in a custom value
+	let selected_indices: (number | string)[] = [];
+	let old_selected_index: (number | string)[] = [];
+
+	const dispatch = createEventDispatcher<{
+		change: string | string[] | undefined;
+		input: undefined;
+		select: SelectData;
+		blur: undefined;
+		focus: undefined;
+		key_up: KeyUpData;
+	}>();
+
+	// Setting the initial value of the multiselect dropdown
+	if (Array.isArray(value)) {
+		value.forEach((element) => {
+			const index = choices.map((c) => c[1]).indexOf(element);
+			if (index !== -1) {
+				selected_indices.push(index);
+			} else {
+				selected_indices.push(element);
+			}
+		});
+	}
+
+	$: {
+		choices_names = choices.map((c) => c[0]);
+		choices_values = choices.map((c) => c[1]);
+	}
+
+	$: {
+		if (choices !== old_choices || input_text !== old_input_text) {
+			filtered_indices = handle_filter(choices, input_text);
+			old_choices = choices;
+			old_input_text = input_text;
+			if (!allow_custom_value) {
+				active_index = filtered_indices[0];
+			}
+		}
+	}
+
+	$: {
+		if (JSON.stringify(value) != JSON.stringify(old_value)) {
+			handle_change(dispatch, value, value_is_output);
+			old_value = Array.isArray(value) ? value.slice() : value;
+		}
+	}
+
+	$: {
+		if (
+			JSON.stringify(selected_indices) != JSON.stringify(old_selected_index)
+		) {
+			value = selected_indices.map((index) =>
+				typeof index === "number" ? choices_values[index] : index
+			);
+			old_selected_index = selected_indices.slice();
+		}
+	}
+
+	function handle_blur(): void {
+		if (!allow_custom_value) {
+			input_text = "";
+		}
+
+		if (allow_custom_value && input_text !== "") {
+			add_selected_choice(input_text);
+			input_text = "";
+		}
+
+		show_options = false;
+		active_index = null;
+		dispatch("blur");
+	}
+
+	function remove_selected_choice(option_index: number | string): void {
+		selected_indices = selected_indices.filter((v) => v !== option_index);
+		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): void {
+		if (max_choices === null || selected_indices.length < max_choices) {
+			selected_indices = [...selected_indices, option_index];
+			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 === max_choices) {
+			show_options = false;
+			active_index = null;
+			filter_input.blur();
+		}
+	}
+
+	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 = "";
+	}
+
+	function remove_all(e: any): void {
+		selected_indices = [];
+		input_text = "";
+		e.preventDefault();
+	}
+
+	function handle_focus(e: FocusEvent): void {
+		filtered_indices = choices.map((_, i) => i);
+		if (max_choices === null || selected_indices.length < max_choices) {
+			show_options = true;
+		}
+		dispatch("focus");
+	}
+
+	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 (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 === max_choices) {
+			show_options = false;
+			active_index = null;
+		}
+	}
+
+	function set_selected_indices(): void {
+		if (value === undefined) {
+			selected_indices = [];
+		} else if (Array.isArray(value)) {
+			selected_indices = value
+				.map((v) => {
+					const index = choices_values.indexOf(v);
+					if (index !== -1) {
+						return index;
+					}
+					if (allow_custom_value) {
+						return v;
+					}
+					// Instead of returning null, skip this iteration
+					return undefined;
+				})
+				.filter((val): val is string | number => val !== undefined);
+		}
+	}
+
+	$: value, set_selected_indices();
+
+	afterUpdate(() => {
+		value_is_output = false;
+	});
+</script>
+
+<label class:container>
+	<BlockTitle {show_label} {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={i18n("common.remove") + " " + s}
+						>
+							<Remove />
+						</div>
+					{/if}
+				</div>
+			{/each}
+			<div class="secondary-wrap">
+				<input
+					class="border-none"
+					class:subdued={(!choices_names.includes(input_text) &&
+						!allow_custom_value) ||
+						selected_indices.length === max_choices}
+					{disabled}
+					autocomplete="off"
+					bind:value={input_text}
+					bind:this={filter_input}
+					on:keydown={handle_key_down}
+					on:keyup={(e) =>
+						dispatch("key_up", {
+							key: e.key,
+							input_value: input_text
+						})}
+					on:blur={handle_blur}
+					on:focus={handle_focus}
+					readonly={!filterable}
+				/>
+
+				{#if !disabled}
+					{#if selected_indices.length > 0}
+						<div
+							role="button"
+							tabindex="0"
+							class="token-remove remove-all"
+							title={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}
+			{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>

5.49.1/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];
+}