Upload folder using huggingface_hub

6.0.2/tabs/Index.svelte

@@ -0,0 +1,47 @@
+<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 = $state(gradio.props.selected);
+
+	$effect(() => {
+		if (old_selected !== gradio.props.selected) {
+			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}
+		on:change={() => gradio.dispatch("change")}
+		on:select={(e) => gradio.dispatch("select", e.detail)}
+		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}
+		on:change={() => gradio.dispatch("change")}
+		on:select={(e) => gradio.dispatch("select", e.detail)}
+		initial_tabs={gradio.props.initial_tabs}
+	>
+		<slot />
+	</Tabs>
+{/if}

6.0.2/tabs/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "@gradio/tabs",
+	"version": "0.5.2",
+	"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.43.4"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/tabs"
+	}
+}

6.0.2/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.0.2/tabs/shared/Tabs.svelte

@@ -0,0 +1,406 @@
+<script context="module" lang="ts">
+	export const TABS = {};
+
+	export interface Tab {
+		label: string;
+		id: string | number;
+		elem_id: string | undefined;
+		visible: boolean | "hidden";
+		interactive: boolean;
+		scale: number | null;
+	}
+</script>
+
+<script lang="ts">
+	import { setContext, createEventDispatcher, tick, onMount } from "svelte";
+	import OverflowIcon from "./OverflowIcon.svelte";
+	import { writable } from "svelte/store";
+	import type { SelectData } from "@gradio/utils";
+
+	export let visible: boolean | "hidden" = true;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let selected: number | string;
+	export let initial_tabs: Tab[];
+
+	let tabs: (Tab | null)[] = [...initial_tabs];
+	let visible_tabs: (Tab | null)[] = [...initial_tabs];
+	let overflow_tabs: (Tab | null)[] = [];
+	let overflow_menu_open = false;
+	let overflow_menu: HTMLElement;
+
+	$: has_tabs = 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>(
+		tabs.findIndex((t) => t?.id === selected) || 0
+	);
+	const dispatch = createEventDispatcher<{
+		change: undefined;
+		select: SelectData;
+	}>();
+
+	let is_overflowing = false;
+	let overflow_has_selected_tab = false;
+	let tab_els: Record<string | number, HTMLElement> = {};
+
+	onMount(() => {
+		if (!tab_nav_el) return;
+		const observer = new IntersectionObserver((entries) => {
+			handle_menu_overflow();
+		});
+		observer.observe(tab_nav_el);
+	});
+
+	setContext(TABS, {
+		register_tab: (tab: Tab, order: number) => {
+			tabs[order] = tab;
+
+			if ($selected_tab === false && tab.visible !== false && 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): void {
+		const tab_to_activate = tabs.find((t) => t?.id === id);
+		if (
+			id !== undefined &&
+			tab_to_activate &&
+			tab_to_activate.interactive &&
+			tab_to_activate.visible !== false &&
+			$selected_tab !== tab_to_activate.id
+		) {
+			selected = id;
+			$selected_tab = id;
+			$selected_tab_index = tabs.findIndex((t) => t?.id === id);
+			dispatch("change");
+			overflow_menu_open = false;
+		}
+	}
+
+	$: (tabs, selected !== null && change_tab(selected));
+	$: (tabs, tab_nav_el, tab_els, handle_menu_overflow());
+
+	function handle_outside_click(event: MouseEvent): void {
+		if (
+			overflow_menu_open &&
+			overflow_menu &&
+			!overflow_menu.contains(event.target as Node)
+		) {
+			overflow_menu_open = false;
+		}
+	}
+
+	async function handle_menu_overflow(): Promise<void> {
+		if (!tab_nav_el) return;
+
+		await tick();
+		const tab_nav_size = tab_nav_el.getBoundingClientRect();
+
+		let max_width = tab_nav_size.width;
+		const tab_sizes = get_tab_sizes(tabs, tab_els);
+		let last_visible_index = 0;
+		const offset = tab_nav_size.left;
+
+		for (let i = tabs.length - 1; i >= 0; i--) {
+			const tab = tabs[i];
+			if (!tab) continue;
+			const tab_rect = tab_sizes[tab.id];
+			if (!tab_rect) continue;
+			if (tab_rect.right - offset < max_width) {
+				last_visible_index = i;
+				break;
+			}
+		}
+
+		overflow_tabs = tabs.slice(last_visible_index + 1);
+		visible_tabs = tabs.slice(0, last_visible_index + 1);
+
+		overflow_has_selected_tab = handle_overflow_has_selected_tab($selected_tab);
+		is_overflowing = overflow_tabs.length > 0;
+	}
+
+	$: overflow_has_selected_tab =
+		handle_overflow_has_selected_tab($selected_tab);
+
+	function handle_overflow_has_selected_tab(
+		selected_tab: number | string | false
+	): boolean {
+		if (selected_tab === false) return false;
+		return overflow_tabs.some((t) => t?.id === selected_tab);
+	}
+
+	function get_tab_sizes(
+		tabs: (Tab | null)[],
+		tab_els: Record<string | number, HTMLElement>
+	): Record<string | number, DOMRect> {
+		const tab_sizes: Record<string | number, DOMRect> = {};
+		tabs.forEach((tab) => {
+			if (!tab) return;
+			tab_sizes[tab.id] = tab_els[tab.id]?.getBoundingClientRect();
+		});
+		return tab_sizes;
+	}
+
+	$: tab_scale =
+		tabs[$selected_tab_index >= 0 ? $selected_tab_index : 0]?.scale;
+</script>
+
+<svelte:window
+	on:resize={handle_menu_overflow}
+	on:click={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 t && t?.visible !== false && t?.visible !== "hidden"}
+						<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 t && t?.visible !== false}
+						<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}
+							on:click={() => {
+								if (t.id !== $selected_tab) {
+									change_tab(t.id);
+									dispatch("select", { value: t.label, index: i, id: t.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) => t?.visible !== false)}
+				bind:this={overflow_menu}
+			>
+				<button
+					on:click|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}
+						{#if t?.visible !== false}
+							<button
+								on:click={() => change_tab(t?.id)}
+								class:selected={t?.id === $selected_tab}
+							>
+								{t?.label}
+							</button>
+						{/if}
+					{/each}
+				</div>
+			</span>
+		</div>
+	{/if}
+	<slot />
+</div>
+
+<style>
+	.tabs {
+		position: relative;
+		display: flex;
+		flex-direction: column;
+		gap: var(--layout-gap);
+	}
+
+	.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);
+	}
+
+	.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.0.2/tabs/shared/Walkthrough.svelte

@@ -0,0 +1,449 @@
+<script context="module" lang="ts">
+	import { TABS, type Tab } from "./Tabs.svelte";
+</script>
+
+<script lang="ts">
+	import { setContext, createEventDispatcher, tick, onMount } from "svelte";
+	import { writable } from "svelte/store";
+	import type { SelectData } from "@gradio/utils";
+
+	export let visible: boolean | "hidden" = true;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let selected: number | string;
+	export let initial_tabs: Tab[];
+
+	let tabs: (Tab | null)[] = [...initial_tabs];
+	let stepper_container: HTMLDivElement;
+	let show_labels_for_all = true;
+	let measurement_container: HTMLDivElement;
+	let step_buttons: HTMLButtonElement[] = [];
+	let step_labels: HTMLSpanElement[] = [];
+	let label_height = 0;
+	let compact = false;
+	let recompute_overflow = true;
+	$: has_tabs = tabs.length > 0;
+
+	const selected_tab = writable<false | number | string>(
+		selected || tabs[0]?.id || false
+	);
+	const selected_tab_index = writable<number>(
+		tabs.findIndex((t) => t?.id === selected) || 0
+	);
+	const dispatch = createEventDispatcher<{
+		change: undefined;
+		select: SelectData;
+	}>();
+
+	async function check_overflow(): Promise<void> {
+		if (!stepper_container || !measurement_container || !recompute_overflow)
+			return;
+		recompute_overflow = false;
+		await tick();
+
+		// First, show all labels to measure
+		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;
+
+	onMount(() => {
+		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 && tab.visible && 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 &&
+			tab_to_activate.visible &&
+			$selected_tab !== tab_to_activate.id
+		) {
+			selected = id;
+			$selected_tab = id;
+			$selected_tab_index = tabs.findIndex((t) => t?.id === id);
+			dispatch("change");
+		}
+	}
+
+	$: (tabs,
+		selected !== null &&
+			change_tab(
+				selected,
+				tabs.findIndex((t) => t?.id === selected)
+			));
+	$: (tabs, check_overflow());
+	$: ($selected_tab_index, check_overflow());
+
+	$: tab_scale =
+		tabs[$selected_tab_index >= 0 ? $selected_tab_index : 0]?.scale;
+</script>
+
+<svelte:window on:resize={check_overflow} />
+
+<div
+	class="stepper {elem_classes.join(' ')}"
+	class:hide={!visible}
+	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 t?.visible}
+						<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}
+								on:click={() => {
+									if (i <= $selected_tab_index && t.id !== $selected_tab) {
+										change_tab(t.id, i);
+										dispatch("select", { 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;
+	}
+
+	.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.0.2/tabs/types.ts

@@ -0,0 +1,16 @@
+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;
+}