Upload folder using huggingface_hub

6.18.1/tabs/Index.svelte

@@ -0,0 +1,64 @@
+<script context="module" lang="ts">
+	export { default as BaseTabs, TABS, type Tab } from "./shared/Tabs.svelte";
+</script>
+
+<script lang="ts">
+	import { Gradio } from "@gradio/utils";
+	import Tabs from "./shared/Tabs.svelte";
+	import Walkthrough from "./shared/Walkthrough.svelte";
+	import type { TabsProps, TabsEvents } from "./types";
+
+	let props = $props();
+	const gradio = new Gradio<TabsEvents, TabsProps>(props);
+
+	let old_selected = gradio.props.selected;
+
+	$effect(() => {
+		if (old_selected !== gradio.props.selected) {
+			const i = gradio.props.initial_tabs.findIndex(
+				(t) => t.id === gradio.props.selected
+			);
+			if (i >= 0) {
+				gradio.dispatch("gradio_tab_select", {
+					value: gradio.props.initial_tabs[i].label,
+					index: i,
+					id: gradio.props.initial_tabs[i].id,
+					component_id: gradio.props.initial_tabs[i].component_id
+				});
+			}
+			old_selected = gradio.props.selected;
+		}
+	});
+</script>
+
+{#if gradio.props.name === "walkthrough"}
+	<Walkthrough
+		visible={gradio.shared.visible}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		bind:selected={gradio.props.selected}
+		onchange={() => gradio.dispatch("change")}
+		onselect={(data) => {
+			gradio.dispatch("select", data);
+			gradio.dispatch("gradio_tab_select", data);
+		}}
+		initial_tabs={gradio.props.initial_tabs}
+	>
+		<slot />
+	</Walkthrough>
+{:else}
+	<Tabs
+		visible={gradio.shared.visible}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		bind:selected={gradio.props.selected}
+		onchange={() => gradio.dispatch("change")}
+		onselect={(data) => {
+			gradio.dispatch("select", data);
+			gradio.dispatch("gradio_tab_select", data);
+		}}
+		initial_tabs={gradio.props.initial_tabs}
+	>
+		<slot />
+	</Tabs>
+{/if}

6.18.1/tabs/WithChild.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">
+	import Tabs from "./Index.svelte";
+	let props = $props();
+</script>
+
+<Tabs {...props}>
+	<div data-testid="slot-content">tab panel content</div>
+</Tabs>

6.18.1/tabs/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "@gradio/tabs",
+	"version": "0.7.0",
+	"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"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"@gradio/utils": "workspace:^"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/tabs"
+	}
+}

6.18.1/tabs/shared/OverflowIcon.svelte

@@ -0,0 +1,11 @@
+<svg
+	width="16"
+	height="16"
+	viewBox="0 0 16 16"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+>
+	<circle cx="2.5" cy="8" r="1.5" fill="currentColor" />
+	<circle cx="8" cy="8" r="1.5" fill="currentColor" />
+	<circle cx="13.5" cy="8" r="1.5" fill="currentColor" />
+</svg>

6.18.1/tabs/shared/Tabs.svelte

@@ -0,0 +1,473 @@
+<script context="module" lang="ts">
+	import type { SelectData } from "@gradio/utils";
+
+	export const TABS = {};
+
+	export interface Tab {
+		label: string;
+		id: string | number;
+		elem_id: string | undefined;
+		visible: boolean | "hidden";
+		interactive: boolean;
+		scale: number | null;
+		component_id: number;
+	}
+
+	export type TabSelectData = SelectData & {
+		id: string | number;
+		component_id: string | number;
+	};
+
+	function is_visible_tab(tab: Tab | null | undefined): tab is Tab {
+		return !!tab && tab.visible !== false && tab.visible !== "hidden";
+	}
+
+	function find_tab_index(tabs: (Tab | null)[], id: string | number): number {
+		const index = tabs.findIndex((t) => t?.id === id);
+		return index === -1 ? 0 : index;
+	}
+</script>
+
+<script lang="ts">
+	import { setContext, tick, untrack } from "svelte";
+	import OverflowIcon from "./OverflowIcon.svelte";
+	import { writable } from "svelte/store";
+
+	let {
+		visible = true,
+		elem_id = "",
+		elem_classes = [],
+		selected = $bindable(),
+		initial_tabs,
+		onchange,
+		onselect
+	}: {
+		visible?: boolean | "hidden";
+		elem_id?: string;
+		elem_classes?: string[];
+		selected: number | string;
+		initial_tabs: Tab[];
+		onchange?: () => void;
+		onselect?: (data: TabSelectData) => void;
+	} = $props();
+
+	let tabs = $state<(Tab | null)[]>([...initial_tabs]);
+	let visible_tabs = $state<(Tab | null)[]>([...initial_tabs]);
+	let overflow_tabs = $state<(Tab | null)[]>([]);
+	let overflow_menu_open = $state(false);
+	let overflow_menu: HTMLElement;
+
+	let mounted_tab_orders = new Set<number>();
+
+	$effect(() => {
+		const new_tabs = initial_tabs;
+		untrack(() => _sync_tabs(new_tabs));
+	});
+
+	function _sync_tabs(new_tabs: Tab[]): void {
+		tick().then(() => {
+			untrack(() => {
+				for (let i = 0; i < new_tabs.length; i++) {
+					if (new_tabs[i] && !mounted_tab_orders.has(i)) {
+						tabs[i] = new_tabs[i];
+					}
+				}
+				handle_menu_overflow();
+			});
+		});
+	}
+
+	let has_tabs = $derived(tabs.length > 0);
+
+	let tab_nav_el: HTMLDivElement;
+
+	const selected_tab = writable<false | number | string>(
+		selected ?? tabs[0]?.id ?? false
+	);
+	const selected_tab_index = writable<number>(find_tab_index(tabs, selected));
+
+	let is_overflowing = $state(false);
+	let overflow_has_selected_tab = $state(false);
+	let tab_els: Record<string | number, HTMLElement> = $state({});
+
+	function sync_tab_entry(tab: Tab, order: number): void {
+		tabs[order] = tab;
+		visible_tabs = visible_tabs.map((t) => (t?.id === tab.id ? tab : t));
+		overflow_tabs = overflow_tabs.map((t) => (t?.id === tab.id ? tab : t));
+	}
+
+	setContext(TABS, {
+		register_tab: (tab: Tab, order: number) => {
+			mounted_tab_orders.add(order);
+			sync_tab_entry(tab, order);
+
+			if ($selected_tab === false && is_visible_tab(tab) && tab.interactive) {
+				$selected_tab = tab.id;
+				$selected_tab_index = order;
+			} else if ($selected_tab === tab.id) {
+				$selected_tab_index = order;
+			}
+			handle_menu_overflow();
+			return order;
+		},
+		unregister_tab: (tab: Tab, order: number) => {
+			mounted_tab_orders.delete(order);
+			if ($selected_tab === tab.id) {
+				$selected_tab = tabs[0]?.id ?? false;
+			}
+			tabs[order] = null;
+			visible_tabs = visible_tabs.filter((t) => t?.id !== tab.id);
+			overflow_tabs = overflow_tabs.filter((t) => t?.id !== tab.id);
+			handle_menu_overflow();
+		},
+		selected_tab,
+		selected_tab_index
+	});
+
+	function change_tab(id: string | number | undefined): void {
+		const tab_to_activate = tabs.find((t) => t?.id === id);
+		if (
+			id !== undefined &&
+			tab_to_activate &&
+			tab_to_activate.interactive &&
+			is_visible_tab(tab_to_activate) &&
+			$selected_tab !== tab_to_activate.id
+		) {
+			selected = id;
+			$selected_tab = id;
+			$selected_tab_index = tabs.findIndex((t) => t?.id === id);
+			onchange?.();
+			overflow_menu_open = false;
+		}
+	}
+
+	$effect(() => {
+		if (selected !== null) change_tab(selected);
+	});
+
+	$effect(() => {
+		if (!tab_nav_el) return;
+		handle_menu_overflow();
+		const ro = new ResizeObserver(() => {
+			handle_menu_overflow();
+		});
+		ro.observe(tab_nav_el);
+		return () => ro.disconnect();
+	});
+
+	function handle_outside_click(event: MouseEvent): void {
+		if (
+			overflow_menu_open &&
+			overflow_menu &&
+			!overflow_menu.contains(event.target as Node)
+		) {
+			overflow_menu_open = false;
+		}
+	}
+
+	const OVERFLOW_BTN_RESERVE = 48;
+
+	async function handle_menu_overflow(): Promise<void> {
+		if (!tab_nav_el) return;
+
+		await tick();
+		await new Promise((r) => requestAnimationFrame(r));
+
+		if (!tab_nav_el) return;
+
+		const available = tab_nav_el.clientWidth;
+
+		let cumulative = 0;
+		let split_index = tabs.length;
+
+		for (let i = 0; i < tabs.length; i++) {
+			const tab = tabs[i];
+			if (!is_visible_tab(tab)) continue;
+			const el = tab_els[tab.id];
+			if (!el) continue;
+			cumulative += el.getBoundingClientRect().width;
+			const has_more = tabs.slice(i + 1).some((t) => is_visible_tab(t));
+			const limit = has_more ? available - OVERFLOW_BTN_RESERVE : available;
+			if (cumulative > limit) {
+				split_index = i;
+				break;
+			}
+		}
+
+		visible_tabs = tabs.slice(0, split_index);
+		overflow_tabs = tabs.slice(split_index);
+
+		overflow_has_selected_tab = handle_overflow_has_selected_tab($selected_tab);
+		is_overflowing = overflow_tabs.filter((t) => is_visible_tab(t)).length > 0;
+	}
+
+	$effect(() => {
+		overflow_has_selected_tab = handle_overflow_has_selected_tab($selected_tab);
+	});
+
+	function handle_overflow_has_selected_tab(
+		selected_tab_value: number | string | false
+	): boolean {
+		if (selected_tab_value === false) return false;
+		return overflow_tabs.some((t) => t?.id === selected_tab_value);
+	}
+
+	let tab_scale = $derived(
+		tabs[$selected_tab_index >= 0 ? $selected_tab_index : 0]?.scale
+	);
+</script>
+
+<svelte:window onresize={handle_menu_overflow} onclick={handle_outside_click} />
+
+<div
+	class="tabs {elem_classes.join(' ')}"
+	class:hide={visible === false}
+	class:hidden={visible === "hidden"}
+	id={elem_id}
+	style:flex-grow={tab_scale}
+>
+	{#if has_tabs}
+		<div class="tab-wrapper">
+			<div class="tab-container visually-hidden" aria-hidden="true">
+				{#each tabs as t, i}
+					{#if is_visible_tab(t)}
+						<button bind:this={tab_els[t.id]}>
+							{t?.label}
+						</button>
+					{/if}
+				{/each}
+			</div>
+			<div class="tab-container" bind:this={tab_nav_el} role="tablist">
+				{#each visible_tabs as t, i}
+					{#if is_visible_tab(t)}
+						<button
+							role="tab"
+							class:selected={t.id === $selected_tab}
+							aria-selected={t.id === $selected_tab}
+							aria-controls={t.elem_id}
+							disabled={!t.interactive}
+							aria-disabled={!t.interactive}
+							id={t.elem_id ? t.elem_id + "-button" : null}
+							data-tab-id={t.id}
+							onclick={() => {
+								if (t.id !== $selected_tab) {
+									change_tab(t.id);
+									onselect?.({
+										value: t.label,
+										index: i,
+										id: t.id,
+										component_id: t.component_id
+									});
+								}
+							}}
+						>
+							{t?.label !== undefined ? t?.label : "Tab " + (i + 1)}
+						</button>
+					{/if}
+				{/each}
+			</div>
+			<span
+				class="overflow-menu"
+				class:hide={!is_overflowing ||
+					!overflow_tabs.some((t) => is_visible_tab(t))}
+				bind:this={overflow_menu}
+			>
+				<button
+					onclick={(e) => {
+						e.stopPropagation();
+						overflow_menu_open = !overflow_menu_open;
+					}}
+					class:overflow-item-selected={overflow_has_selected_tab}
+				>
+					<OverflowIcon />
+				</button>
+				<div class="overflow-dropdown" class:hide={!overflow_menu_open}>
+					{#each overflow_tabs as t, i}
+						{#if is_visible_tab(t)}
+							<button
+								onclick={() => {
+									change_tab(t?.id);
+									onselect?.({
+										value: t.label,
+										index: i,
+										id: t.id,
+										component_id: t.component_id
+									});
+								}}
+								class:selected={t?.id === $selected_tab}
+							>
+								{t?.label}
+							</button>
+						{/if}
+					{/each}
+				</div>
+			</span>
+		</div>
+	{/if}
+	<slot />
+</div>
+
+<style>
+	.tabs {
+		position: relative;
+		flex-direction: column;
+	}
+
+	.hide {
+		display: none;
+	}
+
+	.hidden {
+		display: none !important;
+	}
+
+	.tab-wrapper {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		position: relative;
+		height: var(--size-8);
+		padding-bottom: var(--size-2);
+		margin-bottom: var(--layout-gap);
+	}
+
+	.tab-container {
+		display: flex;
+		align-items: center;
+		width: 100%;
+		position: relative;
+		overflow: hidden;
+		height: var(--size-8);
+	}
+
+	.tab-container::after {
+		content: "";
+		position: absolute;
+		bottom: 0;
+		left: 0;
+		right: 0;
+		height: 1px;
+		background-color: var(--border-color-primary);
+	}
+
+	.overflow-menu {
+		flex-shrink: 0;
+		margin-left: var(--size-2);
+	}
+
+	button {
+		margin-bottom: 0;
+		border: none;
+		border-radius: 0;
+		padding: 0 var(--size-4);
+		color: var(--body-text-color);
+		font-weight: var(--section-header-text-weight);
+		font-size: var(--section-header-text-size);
+		transition: background-color color 0.2s ease-out;
+		background-color: transparent;
+		height: 100%;
+		display: flex;
+		align-items: center;
+		white-space: nowrap;
+		position: relative;
+	}
+
+	button:disabled {
+		opacity: 0.5;
+		cursor: not-allowed;
+	}
+
+	button:hover:not(:disabled):not(.selected) {
+		background-color: var(--background-fill-secondary);
+		color: var(--body-text-color);
+	}
+
+	.selected {
+		background-color: transparent;
+		color: var(--color-accent);
+		position: relative;
+	}
+
+	.selected::after {
+		content: "";
+		position: absolute;
+		bottom: 0;
+		left: 0;
+		width: 100%;
+		height: 2px;
+		background-color: var(--color-accent);
+		animation: fade-grow 0.2s ease-out forwards;
+		transform-origin: center;
+		z-index: 1;
+	}
+
+	@keyframes fade-grow {
+		from {
+			opacity: 0;
+			transform: scaleX(0.8);
+		}
+		to {
+			opacity: 1;
+			transform: scaleX(1);
+		}
+	}
+
+	.overflow-dropdown {
+		position: absolute;
+		top: calc(100% + var(--size-2));
+		right: 0;
+		background-color: var(--background-fill-primary);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-sm);
+		z-index: var(--layer-5);
+		box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+		padding: var(--size-2);
+		min-width: 150px;
+		width: max-content;
+	}
+
+	.overflow-dropdown button {
+		display: block;
+		width: 100%;
+		text-align: left;
+		padding: var(--size-2);
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	.overflow-menu > button {
+		padding: var(--size-1) var(--size-2);
+		min-width: auto;
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-sm);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.overflow-menu > button:hover {
+		background-color: var(--background-fill-secondary);
+	}
+
+	.overflow-menu :global(svg) {
+		width: 16px;
+		height: 16px;
+	}
+
+	.overflow-item-selected :global(svg) {
+		color: var(--color-accent);
+	}
+
+	.visually-hidden {
+		position: absolute;
+		width: 1px;
+		height: 1px;
+		padding: 0;
+		margin: -1px;
+		overflow: hidden;
+		clip: rect(0, 0, 0, 0);
+		white-space: nowrap;
+		border: 0;
+	}
+</style>

6.18.1/tabs/shared/Walkthrough.svelte

@@ -0,0 +1,481 @@
+<script context="module" lang="ts">
+	import { TABS, type Tab } from "./Tabs.svelte";
+
+	function is_visible_tab(tab: Tab | null | undefined): tab is Tab {
+		return !!tab && tab.visible !== false && tab.visible !== "hidden";
+	}
+
+	function find_tab_index(tabs: (Tab | null)[], id: string | number): number {
+		const index = tabs.findIndex((t) => t?.id === id);
+		return index === -1 ? 0 : index;
+	}
+</script>
+
+<script lang="ts">
+	import { setContext, tick } from "svelte";
+	import { writable } from "svelte/store";
+	import type { SelectData } from "@gradio/utils";
+
+	let {
+		visible = true,
+		elem_id = "",
+		elem_classes = [],
+		selected = $bindable(),
+		initial_tabs,
+		onchange,
+		onselect
+	}: {
+		visible?: boolean | "hidden";
+		elem_id?: string;
+		elem_classes?: string[];
+		selected: number | string;
+		initial_tabs: Tab[];
+		onchange?: () => void;
+		onselect?: (data: SelectData) => void;
+	} = $props();
+
+	let tabs = $state<(Tab | null)[]>([...initial_tabs]);
+	let stepper_container: HTMLDivElement;
+	let show_labels_for_all = $state(true);
+	let measurement_container: HTMLDivElement;
+	let step_buttons: HTMLButtonElement[] = $state([]);
+	let step_labels: HTMLSpanElement[] = $state([]);
+	let label_height = $state(0);
+	let compact = $state(false);
+	let recompute_overflow = $state(true);
+
+	let has_tabs = $derived(tabs.length > 0);
+
+	const selected_tab = writable<false | number | string>(
+		selected ?? tabs[0]?.id ?? false
+	);
+	const selected_tab_index = writable<number>(find_tab_index(tabs, selected));
+
+	async function check_overflow(): Promise<void> {
+		if (!stepper_container || !measurement_container || !recompute_overflow)
+			return;
+		recompute_overflow = false;
+		await tick();
+
+		show_labels_for_all = true;
+		await tick();
+
+		const SEP_WIDTH = 50;
+		const button_width =
+			step_buttons[0].getBoundingClientRect().width * step_buttons.length +
+			SEP_WIDTH * (step_buttons.length - 1);
+
+		const containerWidth = stepper_container.getBoundingClientRect().width;
+		const does_it_fit = button_width < containerWidth;
+
+		if (!does_it_fit) {
+			show_labels_for_all = false;
+			compact = true;
+			return;
+		}
+
+		let max_height = 0;
+		let is_overlapping = false;
+		let last_right = 0;
+
+		for (const label of step_labels) {
+			const { height, width, left, right } = label.getBoundingClientRect();
+			if (height > max_height) {
+				max_height = height;
+			}
+			if (last_right && left - 10 < last_right && !is_overlapping) {
+				is_overlapping = true;
+			}
+			last_right = right;
+		}
+		label_height = max_height;
+
+		if (is_overlapping) {
+			show_labels_for_all = false;
+		}
+	}
+
+	let last_width = 0;
+
+	$effect(() => {
+		check_overflow();
+
+		const observer = new ResizeObserver((entries) => {
+			if (entries[0].contentRect.width === last_width) return;
+			last_width = entries[0].contentRect.width;
+			compact = false;
+			recompute_overflow = true;
+			check_overflow();
+		});
+
+		if (stepper_container) {
+			observer.observe(stepper_container);
+		}
+
+		return () => {
+			observer.disconnect();
+		};
+	});
+
+	setContext(TABS, {
+		register_tab: (tab: Tab, order: number) => {
+			tabs[order] = tab;
+
+			if ($selected_tab === false && is_visible_tab(tab) && tab.interactive) {
+				$selected_tab = tab.id;
+				$selected_tab_index = order;
+			}
+			return order;
+		},
+		unregister_tab: (tab: Tab, order: number) => {
+			if ($selected_tab === tab.id) {
+				$selected_tab = tabs[0]?.id ?? false;
+			}
+			tabs[order] = null;
+		},
+		selected_tab,
+		selected_tab_index
+	});
+
+	function change_tab(id: string | number | undefined, index: number): void {
+		const tab_to_activate = tabs.find((t) => t?.id === id);
+		if (
+			id !== undefined &&
+			tab_to_activate &&
+			tab_to_activate.interactive &&
+			is_visible_tab(tab_to_activate) &&
+			$selected_tab !== tab_to_activate.id
+		) {
+			selected = id;
+			$selected_tab = id;
+			$selected_tab_index = tabs.findIndex((t) => t?.id === id);
+			onchange?.();
+		}
+	}
+
+	$effect(() => {
+		tabs;
+		if (selected !== null) {
+			change_tab(
+				selected,
+				tabs.findIndex((t) => t?.id === selected)
+			);
+		}
+	});
+
+	$effect(() => {
+		tabs;
+		check_overflow();
+	});
+
+	$effect(() => {
+		$selected_tab_index;
+		check_overflow();
+	});
+
+	let tab_scale = $derived(
+		tabs[$selected_tab_index >= 0 ? $selected_tab_index : 0]?.scale
+	);
+</script>
+
+<svelte:window onresize={check_overflow} />
+
+<div
+	class="stepper {elem_classes.join(' ')}"
+	class:hide={visible === false}
+	class:hidden={visible === "hidden"}
+	id={elem_id}
+	style:flex-grow={tab_scale}
+	class:compact
+>
+	{#if has_tabs}
+		{#if compact}
+			<p class="step-title">
+				<strong>Step {($selected_tab_index || 0) + 1}/{tabs.length}:</strong>
+				{tabs[$selected_tab_index]?.label || "Walkthrough"}
+			</p>
+		{/if}
+		<div
+			class="stepper-wrapper"
+			bind:this={stepper_container}
+			style:--label-height={label_height + "px"}
+		>
+			<div
+				class="stepper-container"
+				bind:this={measurement_container}
+				role="tablist"
+			>
+				{#each tabs as t, i}
+					{#if is_visible_tab(t)}
+						<div class="step-item">
+							<button
+								bind:this={step_buttons[i]}
+								role="tab"
+								class="step-button"
+								class:active={t.id === $selected_tab}
+								class:completed={t.id < $selected_tab}
+								class:pending={t.id > $selected_tab}
+								aria-selected={t.id === $selected_tab}
+								aria-controls={t.elem_id}
+								disabled={!t.interactive || i > $selected_tab_index}
+								aria-disabled={!t.interactive || i > $selected_tab_index}
+								id={t.elem_id ? t.elem_id + "-button" : null}
+								data-tab-id={t.id}
+								onclick={() => {
+									if (i <= $selected_tab_index && t.id !== $selected_tab) {
+										change_tab(t.id, i);
+										onselect?.({ value: t.label, index: i });
+									}
+								}}
+							>
+								<span class="step-number">
+									{#if t.id < $selected_tab}
+										<svg
+											width="12"
+											height="10"
+											viewBox="0 0 12 10"
+											fill="none"
+											xmlns="http://www.w3.org/2000/svg"
+										>
+											<path
+												d="M1 5L4.5 8.5L11 1.5"
+												stroke="currentColor"
+												stroke-width="2"
+												stroke-linecap="round"
+												stroke-linejoin="round"
+											/>
+										</svg>
+									{:else}
+										{i + 1}
+									{/if}
+								</span>
+								{#if !compact}
+									<span
+										bind:this={step_labels[i]}
+										class="step-label"
+										class:visible={show_labels_for_all ||
+											i === $selected_tab_index}
+									>
+										{t?.label !== undefined ? t?.label : "Step " + (i + 1)}
+									</span>
+								{/if}
+							</button>
+						</div>
+						{#if i < tabs.length - 1 && !compact}
+							<div
+								class="step-connector"
+								class:completed={i < $selected_tab_index}
+							></div>
+						{/if}
+					{/if}
+				{/each}
+			</div>
+		</div>
+	{/if}
+	<slot />
+</div>
+
+<style>
+	.stepper {
+		position: relative;
+		display: flex;
+		flex-direction: column;
+		gap: var(--layout-gap);
+	}
+
+	.compact.stepper {
+		gap: 0;
+	}
+
+	.hide {
+		display: none;
+	}
+
+	.hidden {
+		display: none !important;
+	}
+
+	.stepper-wrapper {
+		display: flex;
+		align-items: center;
+		position: relative;
+		padding-top: var(--size-4);
+		padding-bottom: calc(var(--label-height) + var(--size-4));
+	}
+
+	.compact .stepper-wrapper {
+		padding-top: var(--size-2);
+		padding-bottom: var(--size-6);
+	}
+
+	.stepper-container {
+		display: flex;
+		justify-content: space-between;
+		align-items: flex-start;
+		width: 100%;
+		position: relative;
+		padding: var(--size-2);
+		gap: var(--size-1);
+	}
+
+	.compact .stepper-container {
+		justify-content: center;
+		gap: 2px;
+		padding: 0;
+	}
+
+	.step-item {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		flex: 1 1 0;
+		position: relative;
+	}
+
+	.compact .step-item {
+		/* flex: 0 0 auto; */
+		width: 100%;
+	}
+
+	.step-button {
+		position: relative;
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		gap: var(--size-1);
+
+		border: none;
+		background: transparent;
+		cursor: pointer;
+		border-radius: var(--radius-md);
+		transition: background-color 0.2s ease;
+		font-size: var(--text-sm);
+		color: var(--body-text-color-subdued);
+		white-space: nowrap;
+		z-index: 1;
+		position: relative;
+	}
+
+	.compact .step-button {
+		padding: 0;
+		width: 100%;
+		border: none;
+	}
+
+	.compact .step-number {
+		height: 10px;
+		width: 100%;
+		border-radius: 0;
+		border: none;
+	}
+
+	.step-button:hover:not(:disabled) {
+		background-color: var(--background-fill-secondary);
+	}
+
+	.step-button:disabled {
+		cursor: not-allowed;
+		opacity: 0.5;
+	}
+
+	.step-button.active {
+		color: var(--body-text-color);
+	}
+
+	.step-button.completed {
+		color: var(--body-text-color);
+	}
+
+	.step-button.pending {
+		color: var(--body-text-color-subdued);
+	}
+
+	.step-number {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 32px;
+		height: 32px;
+		border-radius: 50%;
+		font-size: var(--text-sm);
+		font-weight: var(--weight-semibold);
+		transition: background-color 0.2s ease;
+		flex-shrink: 0;
+	}
+
+	.active .step-number {
+		background-color: var(--color-accent);
+		color: white;
+		box-shadow: 0 0 0 4px rgba(var(--color-accent-rgb), 0.1);
+	}
+
+	.completed .step-number {
+		background-color: var(--color-accent);
+		color: white;
+	}
+
+	.compact .completed .step-number {
+		color: transparent;
+	}
+
+	.compact .pending .step-number {
+		color: transparent;
+		background-color: var(--body-text-color-subdued);
+	}
+
+	.compact .active .step-number {
+		color: transparent;
+	}
+
+	.pending .step-number {
+		background-color: var(--button-secondary-background-fill);
+		color: var(--button-secondary-text-color);
+	}
+
+	.compact .step-item:last-child .step-number {
+		border-top-right-radius: var(--radius-xs);
+		border-bottom-right-radius: var(--radius-xs);
+	}
+	.compact .step-item:first-child .step-number {
+		border-top-left-radius: var(--radius-xs);
+		border-bottom-left-radius: var(--radius-xs);
+	}
+
+	.step-label {
+		font-size: var(--text-md);
+		line-height: 1.2;
+		text-align: center;
+		max-width: 120px;
+		position: absolute;
+		bottom: -20px;
+		display: none;
+	}
+
+	.step-label.visible {
+		display: block;
+	}
+
+	.step-connector {
+		width: 100%;
+		height: 2px;
+		background-color: var(--border-color-primary);
+		transition: background-color 0.3s ease;
+		z-index: 0;
+		transform: translate(0, 15px);
+	}
+
+	.step-connector.completed {
+		background-color: var(--color-accent);
+	}
+
+	:global(.dark) .pending .step-number {
+		background-color: var(--neutral-800);
+		color: var(--neutral-400);
+		border-color: var(--neutral-600);
+	}
+
+	:global(.dark) .step-connector {
+		background-color: var(--neutral-600);
+	}
+</style>

6.18.1/tabs/types.ts

@@ -0,0 +1,22 @@
+import type { SelectData } from "@gradio/utils";
+import type { Tab } from "./shared/Tabs.svelte";
+
+export interface TabsProps {
+	visible: boolean | "hidden";
+	elem_id: string;
+	elem_classes: string[];
+	selected: number | string;
+	initial_tabs: Tab[];
+	name: "tabs" | "walkthrough";
+}
+
+export interface TabsEvents {
+	change: never;
+	select: SelectData;
+	gradio_tab_select: {
+		value: string;
+		index: number;
+		id: string | number;
+		component_id: string | number;
+	};
+}