Upload folder using huggingface_hub

6.11.1/dataframe/Example.svelte

@@ -0,0 +1,118 @@
+<script lang="ts">
+	export let value: (string | number)[][] | string;
+	export let type: "gallery" | "table";
+	export let selected = false;
+	export let index: number;
+
+	let hovered = false;
+	let loaded = Array.isArray(value);
+	let is_empty = loaded && (value.length === 0 || value[0].length === 0);
+</script>
+
+{#if loaded}
+	<!-- TODO: fix-->
+	<!-- svelte-ignore a11y-no-static-element-interactions-->
+	<div
+		class:table={type === "table"}
+		class:gallery={type === "gallery"}
+		class:selected
+		on:mouseenter={() => (hovered = true)}
+		on:mouseleave={() => (hovered = false)}
+	>
+		{#if typeof value === "string"}
+			{value}
+		{:else if is_empty}
+			<table class="">
+				<tbody>
+					<tr>
+						<td>Empty</td>
+					</tr>
+				</tbody>
+			</table>
+		{:else}
+			<table class="">
+				<tbody>
+					{#each value.slice(0, 3) as row, i}
+						<tr>
+							{#each row.slice(0, 3) as cell, j}
+								<td>{cell}</td>
+							{/each}
+							{#if row.length > 3}
+								<td>…</td>
+							{/if}
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+			{#if value.length > 3}
+				<div
+					class="overlay"
+					class:odd={index % 2 != 0}
+					class:even={index % 2 == 0}
+					class:button={type === "gallery"}
+				></div>
+			{/if}
+		{/if}
+	</div>
+{/if}
+
+<style>
+	table {
+		position: relative;
+		border-collapse: collapse;
+	}
+
+	td {
+		border: 1px solid var(--table-border-color);
+		padding: var(--size-2);
+		font-size: var(--text-sm);
+		font-family: var(--font-mono);
+	}
+
+	.selected td {
+		border-color: var(--border-color-accent);
+	}
+
+	.table {
+		display: inline-block;
+		margin: 0 auto;
+	}
+
+	.gallery td:first-child {
+		border-left: none;
+	}
+
+	.gallery tr:first-child td {
+		border-top: none;
+	}
+
+	.gallery td:last-child {
+		border-right: none;
+	}
+
+	.gallery tr:last-child td {
+		border-bottom: none;
+	}
+
+	.overlay {
+		--gradient-to: transparent;
+		position: absolute;
+		bottom: 0;
+		background: linear-gradient(to bottom, transparent, var(--gradient-to));
+		width: var(--size-full);
+		height: 50%;
+	}
+
+	/* i dont know what i've done here but it is what it is */
+	.odd {
+		--gradient-to: var(--table-even-background-fill);
+	}
+
+	.even {
+		--gradient-to: var(--table-odd-background-fill);
+	}
+
+	.button {
+		--gradient-to: var(--background-fill-primary);
+	}
+</style>

6.11.1/dataframe/Index.svelte

@@ -0,0 +1,129 @@
+<script module lang="ts">
+	export { default as BaseDataFrame } from "./shared/Table.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import { tick } from "svelte";
+	import Table from "./shared/Table.svelte";
+	import StatusTracker from "@gradio/statustracker";
+	import { Block } from "@gradio/atoms";
+	import { Gradio } from "@gradio/utils";
+	import type { DataframeProps, DataframeEvents } from "./types";
+	import { dequal } from "dequal";
+
+	let _props = $props();
+	const gradio = new Gradio<DataframeEvents, DataframeProps>(_props);
+
+	let fullscreen = $state(gradio.props.fullscreen ?? false);
+
+	// align datatype array to current value headers using the original
+	// config-time header→datatype mapping.
+	// when columns are hidden or reordered, positional indices shift but
+	// the datatype prop doesn't update, the map keeps them synced
+	let aligned_datatype = $derived.by(() => {
+		const dt = gradio.props.datatype;
+		if (!Array.isArray(dt)) return dt;
+
+		const config_headers: string[] | undefined = (gradio.props as any).headers;
+		const current_headers = gradio.props.value?.headers;
+		if (!config_headers || !current_headers) return dt;
+
+		const map = new Map<string, string>();
+		for (let i = 0; i < Math.min(config_headers.length, dt.length); i++) {
+			map.set(config_headers[i], dt[i]);
+		}
+		return current_headers.map(
+			(h: string, i: number) => map.get(h) ?? dt[i] ?? "str"
+		);
+	});
+
+	let old_value = $state(
+		gradio.props.value ? JSON.stringify(gradio.props.value) : null
+	);
+
+	function handle_change(detail: any): void {
+		gradio.props.value = detail;
+		const serialized = JSON.stringify(detail);
+		if (serialized !== old_value) {
+			old_value = serialized;
+			gradio.dispatch("change", detail);
+		}
+	}
+
+	function handle_input(): void {
+		gradio.dispatch("input");
+	}
+
+	function handle_select(detail: any): void {
+		gradio.dispatch("select", detail);
+	}
+
+	function handle_edit(detail: any): void {
+		gradio.dispatch("edit", detail);
+	}
+
+	$effect(() => {
+		const v = gradio.props.value;
+		if (v) {
+			const serialized = JSON.stringify(v);
+			if (serialized !== old_value) {
+				old_value = serialized;
+				gradio.dispatch("change", v);
+			}
+		}
+	});
+</script>
+
+<Block
+	visible={gradio.shared.visible}
+	elem_id={gradio.shared.elem_id}
+	elem_classes={gradio.shared.elem_classes}
+	scale={gradio.shared.scale}
+	min_width={gradio.shared.min_width}
+	padding={false}
+	container={false}
+	overflow_behavior="visible"
+	{fullscreen}
+>
+	<StatusTracker
+		autoscroll={gradio.shared.autoscroll}
+		i18n={gradio.i18n}
+		{...gradio.shared.loading_status}
+	/>
+	<Table
+		headers={gradio.props.value?.headers ?? []}
+		values={gradio.props.value?.data ?? []}
+		display_value={gradio.props.value?.metadata?.display_value ?? null}
+		styling={gradio.props.value?.metadata?.styling ?? null}
+		col_count={gradio.props.col_count}
+		row_count={gradio.props.row_count}
+		label={gradio.shared.label}
+		show_label={gradio.shared.show_label}
+		wrap={gradio.props.wrap}
+		datatype={aligned_datatype}
+		latex_delimiters={gradio.props.latex_delimiters}
+		max_height={gradio.props.max_height}
+		editable={gradio.shared.interactive ?? true}
+		line_breaks={gradio.props.line_breaks}
+		column_widths={gradio.props.column_widths ?? []}
+		root={gradio.shared.root}
+		i18n={gradio.i18n}
+		upload={gradio.shared.client?.upload}
+		stream_handler={gradio.shared.client?.stream}
+		buttons={gradio.props.buttons}
+		max_chars={gradio.props.max_chars}
+		show_row_numbers={gradio.props.show_row_numbers}
+		show_search={gradio.props.show_search}
+		pinned_columns={gradio.props.pinned_columns}
+		static_columns={gradio.props.static_columns ?? []}
+		{fullscreen}
+		onfullscreen={() => {
+			fullscreen = !fullscreen;
+		}}
+		onchange={handle_change}
+		oninput={handle_input}
+		onselect={handle_select}
+		onedit={handle_edit}
+	/>
+</Block>

6.11.1/dataframe/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "@gradio/dataframe",
+	"version": "0.23.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"main_changeset": true,
+	"main": "./Index.svelte",
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/button": "workspace:^",
+		"@gradio/checkbox": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/markdown-code": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@types/d3-dsv": "^3.0.7",
+		"@types/katex": "^0.16.7",
+		"d3-dsv": "^3.0.1",
+		"dequal": "^2.0.3",
+		"@tanstack/table-core": "^8.21.3",
+		"@tanstack/virtual-core": "^3.13.6"
+	},
+	"exports": {
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/standalone/Index.svelte",
+			"types": "./dist/standalone/Index.svelte.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"peerDependencies": {
+		"svelte": ">=5.0.0"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/dataframe"
+	}
+}

6.11.1/dataframe/shared/BooleanCell.svelte

@@ -0,0 +1,55 @@
+<script lang="ts">
+	import { BaseCheckbox } from "@gradio/checkbox";
+
+	let {
+		value = $bindable(false),
+		editable = true,
+		on_change
+	}: {
+		value?: boolean;
+		editable?: boolean;
+		on_change: (value: boolean) => void;
+	} = $props();
+
+	function handle_change(val: boolean): void {
+		if (editable) {
+			on_change(val);
+		}
+	}
+</script>
+
+<div class="bool-cell" role="button" tabindex="-1">
+	<BaseCheckbox
+		bind:value
+		label=""
+		interactive={editable}
+		on_change={handle_change}
+	/>
+</div>
+
+<style>
+	.bool-cell {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: min-content;
+		height: var(--size-full);
+		margin: 0 auto;
+	}
+
+	.bool-cell :global(input:disabled) {
+		cursor: not-allowed;
+	}
+
+	.bool-cell :global(label) {
+		margin: 0;
+		width: 100%;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+	}
+
+	.bool-cell :global(span) {
+		display: none;
+	}
+</style>

6.11.1/dataframe/shared/CellMenu.svelte

@@ -0,0 +1,278 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import CellMenuIcons from "./CellMenuIcons.svelte";
+	import FilterMenu from "./FilterMenu.svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import type { SortDirection, FilterDatatype } from "./types";
+
+	let {
+		x,
+		y,
+		on_add_row_above,
+		on_add_row_below,
+		on_add_column_left,
+		on_add_column_right,
+		row,
+		col_count,
+		row_count,
+		on_delete_row,
+		on_delete_col,
+		can_delete_rows,
+		can_delete_cols,
+		on_sort = () => {},
+		on_clear_sort = () => {},
+		sort_direction = null,
+		sort_priority = null,
+		on_filter = () => {},
+		on_clear_filter = () => {},
+		filter_active = null,
+		editable = true,
+		i18n
+	}: {
+		x: number;
+		y: number;
+		on_add_row_above: () => void;
+		on_add_row_below: () => void;
+		on_add_column_left: () => void;
+		on_add_column_right: () => void;
+		row: number;
+		col_count: [number, "fixed" | "dynamic"];
+		row_count: [number, "fixed" | "dynamic"];
+		on_delete_row: () => void;
+		on_delete_col: () => void;
+		can_delete_rows: boolean;
+		can_delete_cols: boolean;
+		on_sort?: (direction: SortDirection) => void;
+		on_clear_sort?: () => void;
+		sort_direction?: SortDirection | null;
+		sort_priority?: number | null;
+		on_filter?: (
+			datatype: FilterDatatype,
+			selected_filter: string,
+			value: string
+		) => void;
+		on_clear_filter?: () => void;
+		filter_active?: boolean | null;
+		editable?: boolean;
+		i18n: I18nFormatter;
+	} = $props();
+
+	let menu_element: HTMLDivElement;
+	let active_filter_menu: { x: number; y: number } | null = $state(null);
+
+	let is_header = $derived(row === -1);
+	let can_add_rows = $derived(editable && row_count[1] === "dynamic");
+	let can_add_columns = $derived(editable && col_count[1] === "dynamic");
+
+	onMount(() => {
+		position_menu();
+	});
+
+	function position_menu(): void {
+		if (!menu_element) return;
+
+		const viewport_width = window.innerWidth;
+		const viewport_height = window.innerHeight;
+		const menu_rect = menu_element.getBoundingClientRect();
+
+		let new_x = x - 30;
+		let new_y = y - 20;
+
+		if (new_x + menu_rect.width > viewport_width) {
+			new_x = x - menu_rect.width + 10;
+		}
+
+		if (new_y + menu_rect.height > viewport_height) {
+			new_y = y - menu_rect.height + 10;
+		}
+
+		menu_element.style.left = `${new_x}px`;
+		menu_element.style.top = `${new_y}px`;
+	}
+
+	function toggle_filter_menu(): void {
+		if (filter_active) {
+			on_filter("string", "", "");
+			return;
+		}
+
+		const menu_rect = menu_element.getBoundingClientRect();
+		active_filter_menu = {
+			x: menu_rect.right,
+			y: menu_rect.top + menu_rect.height / 2
+		};
+	}
+</script>
+
+<div bind:this={menu_element} class="cell-menu" role="menu">
+	{#if is_header}
+		<button
+			role="menuitem"
+			onclick={() => on_sort("asc")}
+			class:active={sort_direction === "asc"}
+		>
+			<CellMenuIcons icon="sort-asc" />
+			{i18n("dataframe.sort_ascending")}
+			{#if sort_direction === "asc" && sort_priority !== null}
+				<span class="priority">{sort_priority}</span>
+			{/if}
+		</button>
+		<button
+			role="menuitem"
+			onclick={() => on_sort("desc")}
+			class:active={sort_direction === "desc"}
+		>
+			<CellMenuIcons icon="sort-desc" />
+			{i18n("dataframe.sort_descending")}
+			{#if sort_direction === "desc" && sort_priority !== null}
+				<span class="priority">{sort_priority}</span>
+			{/if}
+		</button>
+		<button role="menuitem" onclick={on_clear_sort}>
+			<CellMenuIcons icon="clear-sort" />
+			{i18n("dataframe.clear_sort")}
+		</button>
+		<button
+			role="menuitem"
+			onclick={(e) => {
+				e.stopPropagation();
+				toggle_filter_menu();
+			}}
+			class:active={filter_active || active_filter_menu}
+		>
+			<CellMenuIcons icon="filter" />
+			{i18n("dataframe.filter")}
+			{#if filter_active}
+				<span class="priority">1</span>
+			{/if}
+		</button>
+		<button role="menuitem" onclick={on_clear_filter}>
+			<CellMenuIcons icon="clear-filter" />
+			{i18n("dataframe.clear_filter")}
+		</button>
+	{/if}
+
+	{#if !is_header && can_add_rows}
+		<button
+			role="menuitem"
+			onclick={() => on_add_row_above()}
+			aria-label="Add row above"
+		>
+			<CellMenuIcons icon="add-row-above" />
+			{i18n("dataframe.add_row_above")}
+		</button>
+		<button
+			role="menuitem"
+			onclick={() => on_add_row_below()}
+			aria-label="Add row below"
+		>
+			<CellMenuIcons icon="add-row-below" />
+			{i18n("dataframe.add_row_below")}
+		</button>
+		{#if can_delete_rows}
+			<button
+				role="menuitem"
+				onclick={on_delete_row}
+				class="delete"
+				aria-label="Delete row"
+			>
+				<CellMenuIcons icon="delete-row" />
+				{i18n("dataframe.delete_row")}
+			</button>
+		{/if}
+	{/if}
+	{#if can_add_columns}
+		<button
+			role="menuitem"
+			onclick={() => on_add_column_left()}
+			aria-label="Add column to the left"
+		>
+			<CellMenuIcons icon="add-column-left" />
+			{i18n("dataframe.add_column_left")}
+		</button>
+		<button
+			role="menuitem"
+			onclick={() => on_add_column_right()}
+			aria-label="Add column to the right"
+		>
+			<CellMenuIcons icon="add-column-right" />
+			{i18n("dataframe.add_column_right")}
+		</button>
+		{#if can_delete_cols}
+			<button
+				role="menuitem"
+				onclick={on_delete_col}
+				class="delete"
+				aria-label="Delete column"
+			>
+				<CellMenuIcons icon="delete-column" />
+				{i18n("dataframe.delete_column")}
+			</button>
+		{/if}
+	{/if}
+</div>
+
+{#if active_filter_menu}
+	<FilterMenu {on_filter} />
+{/if}
+
+<style>
+	.cell-menu {
+		position: fixed;
+		z-index: var(--layer-1);
+		background: var(--background-fill-primary);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-sm);
+		padding: var(--size-1);
+		display: flex;
+		flex-direction: column;
+		gap: var(--size-1);
+		box-shadow: var(--shadow-drop-lg);
+		min-width: 150px;
+		width: max-content;
+	}
+
+	.cell-menu button {
+		background: none;
+		border: none;
+		cursor: pointer;
+		text-align: left;
+		padding: var(--size-1) var(--size-2);
+		border-radius: var(--radius-sm);
+		color: var(--body-text-color);
+		font-size: var(--text-sm);
+		transition:
+			background-color 0.2s,
+			color 0.2s;
+		display: flex;
+		align-items: center;
+		gap: var(--size-2);
+		position: relative;
+	}
+
+	.cell-menu button.active {
+		background-color: var(--background-fill-secondary);
+	}
+
+	.cell-menu button:hover {
+		background-color: var(--background-fill-secondary);
+	}
+
+	.cell-menu button :global(svg) {
+		fill: currentColor;
+		transition: fill 0.2s;
+	}
+
+	.priority {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		margin-left: auto;
+		font-size: var(--size-2);
+		background-color: var(--button-secondary-background-fill);
+		color: var(--body-text-color);
+		border-radius: var(--radius-sm);
+		width: var(--size-2-5);
+		height: var(--size-2-5);
+	}
+</style>

6.11.1/dataframe/shared/CellMenuButton.svelte

@@ -0,0 +1,46 @@
+<script lang="ts">
+	let { on_click }: { on_click: (event: MouseEvent) => void } = $props();
+</script>
+
+<button
+	aria-label="Open cell menu"
+	class="cell-menu-button"
+	aria-haspopup="menu"
+	onclick={on_click}
+	ontouchstart={(event) => {
+		event.preventDefault();
+		const touch = event.touches[0];
+		const mouseEvent = new MouseEvent("click", {
+			clientX: touch.clientX,
+			clientY: touch.clientY,
+			bubbles: true,
+			cancelable: true,
+			view: window
+		});
+		on_click(mouseEvent);
+	}}
+>
+	&#8942;
+</button>
+
+<style>
+	.cell-menu-button {
+		flex-shrink: 0;
+		display: none;
+		align-items: center;
+		justify-content: center;
+		background-color: var(--block-background-fill);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--block-radius);
+		width: var(--size-5);
+		height: var(--size-5);
+		min-width: var(--size-5);
+		padding: 0;
+		margin-right: var(--spacing-sm);
+		z-index: 2;
+		position: absolute;
+		right: var(--size-1);
+		top: 50%;
+		transform: translateY(-50%);
+	}
+</style>

6.11.1/dataframe/shared/CellMenuIcons.svelte

@@ -0,0 +1,240 @@
+<script lang="ts">
+	let { icon }: { icon: string } = $props();
+</script>
+
+{#if icon == "add-column-right"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<rect
+			x="4"
+			y="6"
+			width="4"
+			height="12"
+			stroke="currentColor"
+			stroke-width="2"
+			fill="none"
+		/>
+		<path
+			d="M12 12H19M16 8L19 12L16 16"
+			stroke="currentColor"
+			stroke-width="2"
+			fill="none"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "add-column-left"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<rect
+			x="16"
+			y="6"
+			width="4"
+			height="12"
+			stroke="currentColor"
+			stroke-width="2"
+			fill="none"
+		/>
+		<path
+			d="M12 12H5M8 8L5 12L8 16"
+			stroke="currentColor"
+			stroke-width="2"
+			fill="none"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "add-row-above"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<rect
+			x="6"
+			y="16"
+			width="12"
+			height="4"
+			stroke="currentColor"
+			stroke-width="2"
+		/>
+		<path
+			d="M12 12V5M8 8L12 5L16 8"
+			stroke="currentColor"
+			stroke-width="2"
+			fill="none"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "add-row-below"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<rect
+			x="6"
+			y="4"
+			width="12"
+			height="4"
+			stroke="currentColor"
+			stroke-width="2"
+		/>
+		<path
+			d="M12 12V19M8 16L12 19L16 16"
+			stroke="currentColor"
+			stroke-width="2"
+			fill="none"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "delete-row"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<rect
+			x="5"
+			y="10"
+			width="14"
+			height="4"
+			stroke="currentColor"
+			stroke-width="2"
+		/>
+		<path
+			d="M8 7L16 17M16 7L8 17"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "delete-column"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<rect
+			x="10"
+			y="5"
+			width="4"
+			height="14"
+			stroke="currentColor"
+			stroke-width="2"
+		/>
+		<path
+			d="M7 8L17 16M17 8L7 16"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "sort-asc"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<path
+			d="M8 16L12 12L16 16"
+			stroke="currentColor"
+			stroke-width="2"
+			fill="none"
+			stroke-linecap="round"
+			stroke-linejoin="round"
+		/>
+		<path
+			d="M12 12V19"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M5 7H19"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "sort-desc"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<path
+			d="M8 12L12 16L16 12"
+			stroke="currentColor"
+			stroke-width="2"
+			fill="none"
+			stroke-linecap="round"
+			stroke-linejoin="round"
+		/>
+		<path
+			d="M12 16V9"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M5 5H19"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "clear-sort"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<path
+			d="M5 5H19"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M5 9H15"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M5 13H11"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M5 17H7"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M17 17L21 21M21 17L17 21"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "filter"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<path
+			d="M5 5H19"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M8 9H16"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M11 13H13"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+	</svg>
+{:else if icon == "clear-filter"}
+	<svg viewBox="0 0 24 24" width="16" height="16">
+		<path
+			d="M5 5H19"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M8 9H16"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M11 13H13"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+		<path
+			d="M17 17L21 21M21 17L17 21"
+			stroke="currentColor"
+			stroke-width="2"
+			stroke-linecap="round"
+		/>
+	</svg>
+{/if}

6.11.1/dataframe/shared/DataCell.svelte

@@ -0,0 +1,189 @@
+<script lang="ts">
+	import EditableCell from "./EditableCell.svelte";
+	import CellMenuButton from "./CellMenuButton.svelte";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import type { CellValue } from "./types";
+	import type { Datatype } from "./utils/utils";
+
+	let {
+		value,
+		display_value = null,
+		datatype = "str",
+		row_idx,
+		col_idx,
+		col_style = "",
+		cell_style = "",
+		selection_classes = "",
+		is_editing = false,
+		is_flash = false,
+		is_static = false,
+		show_menu_button = false,
+		show_selection_buttons = false,
+		is_first_column = false,
+		latex_delimiters,
+		line_breaks = true,
+		editable = true,
+		max_chars = undefined,
+		i18n,
+		components = {},
+		is_dragging = false,
+		wrap_text = false,
+		onmousedown,
+		ondblclick,
+		oncontextmenu,
+		onblur,
+		on_menu_click,
+		on_select_column,
+		on_select_row
+	}: {
+		value: CellValue;
+		display_value?: string | null;
+		datatype?: Datatype;
+		row_idx: number;
+		col_idx: number;
+		col_style?: string;
+		cell_style?: string;
+		selection_classes?: string;
+		is_editing?: boolean;
+		is_flash?: boolean;
+		is_static?: boolean;
+		show_menu_button?: boolean;
+		show_selection_buttons?: boolean;
+		is_first_column?: boolean;
+		latex_delimiters: { left: string; right: string; display: boolean }[];
+		line_breaks?: boolean;
+		editable?: boolean;
+		max_chars?: number | undefined;
+		i18n: I18nFormatter;
+		components?: Record<string, any>;
+		is_dragging?: boolean;
+		wrap_text?: boolean;
+		onmousedown: (event: MouseEvent) => void;
+		ondblclick: (event: MouseEvent) => void;
+		oncontextmenu: (event: MouseEvent) => void;
+		onblur: (detail: {
+			blur_event: FocusEvent;
+			coords: [number, number];
+		}) => void;
+		on_menu_click: (event: MouseEvent) => void;
+		on_select_column: (col: number) => void;
+		on_select_row: (row: number) => void;
+	} = $props();
+
+	let is_selected = $derived(selection_classes !== "");
+</script>
+
+<div
+	class="body-cell {selection_classes}"
+	class:flash={is_flash}
+	class:first-column={is_first_column}
+	data-row={row_idx}
+	data-col={col_idx}
+	data-testid={`cell-${row_idx}-${col_idx}`}
+	{onmousedown}
+	{ondblclick}
+	{oncontextmenu}
+	style="{col_style} {cell_style}"
+>
+	<div class="cell-wrap">
+		<EditableCell
+			{value}
+			{display_value}
+			{latex_delimiters}
+			{line_breaks}
+			{editable}
+			{is_static}
+			edit={is_editing}
+			{datatype}
+			{onblur}
+			{max_chars}
+			{i18n}
+			{components}
+			{show_selection_buttons}
+			coords={[row_idx, col_idx]}
+			{on_select_column}
+			{on_select_row}
+			{is_dragging}
+			{wrap_text}
+		/>
+		{#if show_menu_button}
+			<CellMenuButton on_click={on_menu_click} />
+		{/if}
+	</div>
+</div>
+
+<style>
+	.body-cell {
+		--ring-color: transparent;
+		outline: none;
+		box-shadow:
+			inset 1px 0 0 var(--border-color-primary),
+			inset 0 0 0 1px var(--ring-color);
+		padding: 0;
+		overflow: visible;
+		box-sizing: border-box;
+	}
+
+	.body-cell.first-column {
+		box-shadow: inset 0 0 0 1px var(--ring-color);
+	}
+
+	.body-cell:hover :global(.cell-menu-button),
+	.body-cell.cell-selected :global(.cell-menu-button) {
+		display: flex;
+	}
+
+	.body-cell.cell-selected {
+		--ring-color: var(--color-accent);
+		--sel-top: inset 0 2px 0 0 var(--ring-color);
+		--sel-bottom: inset 0 -2px 0 0 var(--ring-color);
+		--sel-left: inset 2px 0 0 0 var(--ring-color);
+		--sel-right: inset -2px 0 0 0 var(--ring-color);
+		box-shadow:
+			var(--sel-top), var(--sel-bottom), var(--sel-left), var(--sel-right);
+		z-index: 2;
+		position: relative;
+	}
+
+	.body-cell.cell-selected.no-top {
+		--sel-top: inset 0 0 0 0 transparent;
+	}
+	.body-cell.cell-selected.no-bottom {
+		--sel-bottom: inset 0 0 0 0 transparent;
+	}
+	.body-cell.cell-selected.no-left {
+		--sel-left: inset 0 0 0 0 transparent;
+	}
+	.body-cell.cell-selected.no-right {
+		--sel-right: inset 0 0 0 0 transparent;
+	}
+
+	.body-cell.flash.cell-selected {
+		animation: flash-color 700ms ease-out;
+	}
+
+	@keyframes flash-color {
+		0%,
+		30% {
+			background: var(--color-accent-copied);
+		}
+		100% {
+			background: transparent;
+		}
+	}
+
+	.cell-wrap {
+		display: flex;
+		align-items: center;
+		justify-content: flex-start;
+		outline: none;
+		min-height: var(--size-9);
+		position: relative;
+		padding: var(--size-2);
+		box-sizing: border-box;
+		gap: var(--size-1);
+		overflow: visible;
+		min-width: 0;
+		height: 100%;
+	}
+</style>

6.11.1/dataframe/shared/EditableCell.svelte

@@ -0,0 +1,285 @@
+<script lang="ts">
+	import { MarkdownCode } from "@gradio/markdown-code";
+	import type { I18nFormatter } from "@gradio/utils";
+	import type { CellValue } from "./types";
+	import SelectionButtons from "./icons/SelectionButtons.svelte";
+	import BooleanCell from "./BooleanCell.svelte";
+
+	let {
+		edit,
+		value = $bindable(""),
+		display_value = null,
+		styling = "",
+		header = false,
+		datatype = "str",
+		latex_delimiters,
+		line_breaks = true,
+		editable = true,
+		is_static = false,
+		max_chars = null,
+		components = {},
+		i18n,
+		is_dragging = false,
+		wrap_text = false,
+		show_selection_buttons = false,
+		coords,
+		on_select_column = null,
+		on_select_row = null,
+		el = $bindable(null),
+		onblur,
+		onkeydown
+	}: {
+		edit: boolean;
+		value?: CellValue;
+		display_value?: string | null;
+		styling?: string;
+		header?: boolean;
+		datatype?:
+			| "str"
+			| "markdown"
+			| "html"
+			| "number"
+			| "bool"
+			| "date"
+			| "image";
+		latex_delimiters: {
+			left: string;
+			right: string;
+			display: boolean;
+		}[];
+		line_breaks?: boolean;
+		editable?: boolean;
+		is_static?: boolean;
+		max_chars?: number | null;
+		components?: Record<string, any>;
+		i18n: I18nFormatter;
+		is_dragging?: boolean;
+		wrap_text?: boolean;
+		show_selection_buttons?: boolean;
+		coords: [number, number];
+		on_select_column?: ((col: number) => void) | null;
+		on_select_row?: ((row: number) => void) | null;
+		el?: HTMLTextAreaElement | null;
+		onblur?: (detail: {
+			blur_event: FocusEvent;
+			coords: [number, number];
+		}) => void;
+		onkeydown?: (event: KeyboardEvent) => void;
+	} = $props();
+
+	function truncate_text(
+		text: CellValue,
+		max_length: number | null = null,
+		is_image = false
+	): string {
+		if (is_image) return String(text);
+		const str = String(text);
+		if (!max_length || max_length <= 0) return str;
+		if (str.length <= max_length) return str;
+		return str.slice(0, max_length) + "...";
+	}
+
+	let should_truncate = $derived(!edit && max_chars !== null && max_chars > 0);
+
+	let display_content = $derived(
+		editable ? value : display_value !== null ? display_value : value
+	);
+
+	let display_text = $derived(
+		should_truncate
+			? truncate_text(display_content, max_chars, datatype === "image")
+			: display_content
+	);
+
+	function use_focus(node: HTMLTextAreaElement): any {
+		requestAnimationFrame(() => {
+			node.focus();
+		});
+
+		return {};
+	}
+
+	function handle_blur(event: FocusEvent): void {
+		onblur?.({
+			blur_event: event,
+			coords: coords
+		});
+	}
+
+	function handle_keydown(event: KeyboardEvent): void {
+		onkeydown?.(event);
+	}
+
+	function commit_change(checked: boolean): void {
+		handle_blur({ target: { value } } as unknown as FocusEvent);
+	}
+
+	$effect(() => {
+		if (!edit) {
+			// Shim blur on removal for Safari and Firefox
+			handle_blur({ target: { value } } as unknown as FocusEvent);
+		}
+	});
+</script>
+
+{#if edit && datatype !== "bool"}
+	<textarea
+		readonly={is_static}
+		aria-readonly={is_static}
+		aria-label={is_static ? "Cell is read-only" : "Edit cell"}
+		bind:this={el}
+		bind:value
+		class:header
+		tabindex="-1"
+		onblur={handle_blur}
+		onmousedown={(e: MouseEvent) => e.stopPropagation()}
+		onclick={(e: MouseEvent) => e.stopPropagation()}
+		use:use_focus
+		onkeydown={handle_keydown}
+	/>
+{/if}
+
+{#if datatype === "bool" && typeof value === "boolean"}
+	<BooleanCell bind:value {editable} on_change={commit_change} />
+{:else}
+	<span
+		class:dragging={is_dragging}
+		onkeydown={handle_keydown}
+		tabindex="0"
+		role="button"
+		class:edit
+		class:expanded={edit}
+		class:multiline={header}
+		onfocus={(e) => e.preventDefault()}
+		style={styling}
+		data-editable={editable}
+		data-max-chars={max_chars}
+		data-expanded={edit}
+		placeholder=" "
+		class:text={datatype === "str"}
+		class:wrap={wrap_text}
+	>
+		{#if datatype === "image" && components.image}
+			{@const ImageComponent = components.image}
+			<ImageComponent
+				value={{ url: display_text }}
+				show_label={false}
+				label="cell-image"
+				show_download_button={false}
+				{i18n}
+				gradio={{ dispatch: () => {} }}
+			/>
+		{:else if datatype === "html"}
+			{@html display_text}
+		{:else if datatype === "markdown"}
+			<MarkdownCode
+				message={display_text.toLocaleString()}
+				{latex_delimiters}
+				{line_breaks}
+				chatbot={false}
+			/>
+		{:else}
+			{display_text}
+		{/if}
+	</span>
+{/if}
+
+{#if show_selection_buttons && coords && on_select_column && on_select_row}
+	<SelectionButtons
+		position="column"
+		{coords}
+		on_click={() => on_select_column(coords[1])}
+	/>
+	<SelectionButtons
+		position="row"
+		{coords}
+		on_click={() => on_select_row(coords[0])}
+	/>
+{/if}
+
+<style>
+	.dragging {
+		cursor: crosshair !important;
+	}
+
+	textarea {
+		position: absolute;
+		flex: 1 1 0%;
+		transform: translateX(-0.1px);
+		outline: none;
+		border: none;
+		background: transparent;
+		cursor: text;
+		width: calc(100% - var(--size-2));
+		resize: none;
+		height: 100%;
+		padding-left: 0;
+		font-size: inherit;
+		font-weight: inherit;
+		line-height: var(--line-lg);
+	}
+
+	textarea:focus {
+		outline: none;
+	}
+
+	span {
+		flex: 1 1 0%;
+		position: relative;
+		display: block;
+		outline: none;
+		-webkit-user-select: text;
+		-moz-user-select: text;
+		-ms-user-select: text;
+		user-select: text;
+		cursor: text;
+		width: 100%;
+		overflow-wrap: break-word;
+	}
+
+	span.text.expanded {
+		height: auto;
+		min-height: 100%;
+		white-space: pre-wrap;
+		word-break: break-word;
+		overflow: visible;
+	}
+
+	.multiline {
+		white-space: pre;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	.header {
+		transform: translateX(0);
+		font-weight: var(--weight-bold);
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		margin-left: var(--size-1);
+	}
+
+	.edit {
+		opacity: 0;
+		pointer-events: none;
+	}
+
+	span :global(img) {
+		max-height: 100px;
+		width: auto;
+		object-fit: contain;
+	}
+
+	textarea:read-only {
+		cursor: not-allowed;
+	}
+
+	.wrap,
+	.wrap.expanded {
+		white-space: normal;
+		word-wrap: break-word;
+		overflow-wrap: break-word;
+		word-wrap: break-word;
+	}
+</style>

6.11.1/dataframe/shared/EmptyRowButton.svelte

@@ -0,0 +1,29 @@
+<script lang="ts">
+	let { on_click }: { on_click: () => void } = $props();
+</script>
+
+<button class="add-row-button" onclick={on_click} aria-label="Add row">
+	+
+</button>
+
+<style>
+	.add-row-button {
+		width: 100%;
+		padding: var(--size-1);
+		background: transparent;
+		border: 1px dashed var(--border-color-primary);
+		border-radius: var(--radius-sm);
+		color: var(--body-text-color);
+		cursor: pointer;
+		transition: all 150ms;
+		margin-top: var(--size-2);
+		z-index: 10;
+		position: relative;
+		pointer-events: auto;
+	}
+
+	.add-row-button:hover {
+		background: var(--background-fill-secondary);
+		border-style: solid;
+	}
+</style>

6.11.1/dataframe/shared/Example.svelte

@@ -0,0 +1,29 @@
+<script lang="ts">
+	export let value: (string | number)[][];
+</script>
+
+<table class="input-dataframe-example">
+	{#each value.slice(0, 3) as row}
+		<tr>
+			{#each row.slice(0, 3) as cell}
+				<td class="p-2">{cell}</td>
+			{/each}
+			{#if row.length > 3}
+				<td class="p-2">...</td>
+			{/if}
+		</tr>
+	{/each}
+	{#if value.length > 3}
+		<tr>
+			{#each Array(Math.min(4, value[0].length)) as _}
+				<td class="p-2">...</td>
+			{/each}
+		</tr>
+	{/if}
+</table>
+
+<style>
+	table {
+		border-collapse: separate;
+	}
+</style>

6.11.1/dataframe/shared/FilterMenu.svelte

@@ -0,0 +1,255 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import { Check, DropdownArrow } from "@gradio/icons";
+	import type { FilterDatatype } from "./types";
+
+	let {
+		on_filter = () => {}
+	}: {
+		on_filter?: (
+			datatype: FilterDatatype,
+			selected_filter: string,
+			value: string
+		) => void;
+	} = $props();
+
+	let menu_element: HTMLDivElement;
+	let datatype: "string" | "number" = $state("string");
+	let current_filter = $state("Contains");
+	let filter_dropdown_open = $state(false);
+	let filter_input_value = $state("");
+
+	const filter_options = {
+		string: [
+			"Contains",
+			"Does not contain",
+			"Starts with",
+			"Ends with",
+			"Is",
+			"Is not",
+			"Is empty",
+			"Is not empty"
+		],
+		number: ["=", "≠", ">", "<", "≥", "≤", "Is empty", "Is not empty"]
+	};
+
+	onMount(() => {
+		position_menu();
+	});
+
+	function position_menu(): void {
+		if (!menu_element) return;
+
+		const viewport_width = window.innerWidth;
+		const viewport_height = window.innerHeight;
+		const menu_rect = menu_element.getBoundingClientRect();
+
+		const x = (viewport_width - menu_rect.width) / 2;
+		const y = (viewport_height - menu_rect.height) / 2;
+
+		menu_element.style.left = `${x}px`;
+		menu_element.style.top = `${y}px`;
+	}
+
+	function handle_filter_input(e: Event): void {
+		const target = e.target as HTMLInputElement;
+		filter_input_value = target.value;
+	}
+</script>
+
+<div>
+	<div class="background"></div>
+	<div bind:this={menu_element} class="filter-menu">
+		<div class="filter-datatype-container">
+			<span>Filter as</span>
+			<button
+				onclick={(e) => {
+					e.stopPropagation();
+					datatype = datatype === "string" ? "number" : "string";
+					current_filter = filter_options[datatype][0];
+				}}
+				aria-label={`Change filter type. Filtering ${datatype}s`}
+			>
+				{datatype}
+			</button>
+		</div>
+
+		<div class="input-container">
+			<div class="filter-dropdown">
+				<button
+					onclick={(e) => {
+						e.stopPropagation();
+						filter_dropdown_open = !filter_dropdown_open;
+					}}
+					aria-label={`Change filter. Using '${current_filter}'`}
+				>
+					{current_filter}
+					<DropdownArrow />
+				</button>
+
+				{#if filter_dropdown_open}
+					<div class="dropdown-filter-options">
+						{#each filter_options[datatype] as opt}
+							<button
+								onclick={(e) => {
+									e.stopPropagation();
+									current_filter = opt;
+									filter_dropdown_open = !filter_dropdown_open;
+								}}
+								class="filter-option"
+							>
+								{opt}
+							</button>
+						{/each}
+					</div>
+				{/if}
+			</div>
+
+			<input
+				type="text"
+				value={filter_input_value}
+				onclick={(e) => e.stopPropagation()}
+				oninput={handle_filter_input}
+				placeholder="Type a value"
+				class="filter-input"
+			/>
+		</div>
+
+		<button
+			class="check-button"
+			onclick={() => on_filter(datatype, current_filter, filter_input_value)}
+		>
+			<Check />
+		</button>
+	</div>
+</div>
+
+<style>
+	.background {
+		position: fixed;
+		top: 0;
+		left: 0;
+		width: 100vw;
+		height: 100vh;
+		background-color: rgba(0, 0, 0, 0.4);
+		z-index: 20;
+	}
+
+	.filter-menu {
+		position: fixed;
+		background: var(--background-fill-primary);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-sm);
+		padding: var(--size-2);
+		display: flex;
+		flex-direction: column;
+		gap: var(--size-2);
+		box-shadow: var(--shadow-drop-lg);
+		width: 300px;
+		z-index: 21;
+	}
+
+	.filter-datatype-container {
+		display: flex;
+		gap: var(--size-2);
+		align-items: center;
+	}
+
+	.filter-menu span {
+		font-size: var(--text-sm);
+		color: var(--body-text-color);
+	}
+
+	.filter-menu button {
+		height: var(--size-6);
+		background: none;
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-sm);
+		padding: var(--size-1) var(--size-2);
+		color: var(--body-text-color);
+		font-size: var(--text-sm);
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		gap: var(--size-2);
+	}
+
+	.filter-menu button:hover {
+		background-color: var(--background-fill-secondary);
+	}
+
+	.filter-input {
+		width: var(--size-full);
+		height: var(--size-6);
+		padding: var(--size-2);
+		padding-right: var(--size-8);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--table-radius);
+		font-size: var(--text-sm);
+		color: var(--body-text-color);
+		background: var(--background-fill-secondary);
+		transition: all 0.2s ease;
+	}
+
+	.filter-input:hover {
+		border-color: var(--border-color-secondary);
+		background: var(--background-fill-primary);
+	}
+
+	.filter-input:focus {
+		outline: none;
+		border-color: var(--color-accent);
+		background: var(--background-fill-primary);
+		box-shadow: 0 0 0 1px var(--color-accent);
+	}
+
+	.dropdown-filter-options {
+		display: flex;
+		flex-direction: column;
+		background: var(--background-fill-primary);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-sm);
+		box-shadow: var(--shadow-drop-md);
+		position: absolute;
+		z-index: var(--layer-1);
+	}
+
+	.dropdown-filter-options .filter-option {
+		border: none;
+		justify-content: flex-start;
+	}
+
+	.input-container {
+		display: flex;
+		gap: var(--size-2);
+		align-items: center;
+	}
+
+	.input-container button {
+		width: 130px;
+	}
+
+	:global(svg.dropdown-arrow) {
+		width: var(--size-4);
+		height: var(--size-4);
+		margin-left: auto;
+	}
+
+	.filter-menu .check-button {
+		background: var(--color-accent);
+		color: white;
+		border: none;
+		width: var(--size-full);
+		height: var(--size-6);
+		border-radius: var(--radius-sm);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		padding: var(--size-1);
+	}
+
+	.check-button:hover {
+		background: var(--color-accent-soft);
+	}
+</style>

6.11.1/dataframe/shared/HeaderCell.svelte

@@ -0,0 +1,218 @@
+<script lang="ts">
+	import EditableCell from "./EditableCell.svelte";
+	import CellMenuButton from "./CellMenuButton.svelte";
+	import Padlock from "./icons/Padlock.svelte";
+	import FilterIcon from "./icons/FilterIcon.svelte";
+	import SortButtonUp from "./icons/SortButtonUp.svelte";
+	import SortButtonDown from "./icons/SortButtonDown.svelte";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import type { SortDirection } from "./types";
+
+	let {
+		value,
+		col_idx,
+		is_editing = false,
+		is_selected = false,
+		is_static = false,
+		sort_direction = null,
+		sort_priority = null,
+		multi_sort = false,
+		is_filtered = false,
+		show_menu_button = false,
+		is_first_column = false,
+		latex_delimiters,
+		line_breaks = true,
+		editable = true,
+		max_chars = undefined,
+		i18n,
+		onclick,
+		on_menu_click,
+		on_end_edit
+	}: {
+		value: string;
+		col_idx: number;
+		is_editing?: boolean;
+		is_selected?: boolean;
+		is_static?: boolean;
+		sort_direction?: SortDirection | null;
+		sort_priority?: number | null;
+		multi_sort?: boolean;
+		is_filtered?: boolean;
+		show_menu_button?: boolean;
+		is_first_column?: boolean;
+		latex_delimiters: { left: string; right: string; display: boolean }[];
+		line_breaks?: boolean;
+		editable?: boolean;
+		max_chars?: number | undefined;
+		i18n: I18nFormatter;
+		onclick: (event: MouseEvent, col: number) => void;
+		on_menu_click: (event: MouseEvent, col: number) => void;
+		on_end_edit: (key: string) => void;
+	} = $props();
+</script>
+
+<th
+	class="header-cell"
+	class:focus={is_editing || is_selected}
+	class:sorted={sort_direction !== null}
+	class:filtered={is_filtered}
+	class:first-column={is_first_column}
+	onclick={(e) => onclick(e, col_idx)}
+	onmousedown={(e) => {
+		e.preventDefault();
+		e.stopPropagation();
+	}}
+	title={value}
+>
+	<div class="cell-wrap">
+		<div class="header-content">
+			<EditableCell
+				{value}
+				{latex_delimiters}
+				{line_breaks}
+				edit={is_editing}
+				onkeydown={(event) => {
+					if (["Enter", "Escape", "Tab"].includes(event.key)) {
+						on_end_edit(event.key);
+					}
+				}}
+				header
+				{editable}
+				{is_static}
+				{i18n}
+				{max_chars}
+				coords={[col_idx, 0]}
+			/>
+		</div>
+		{#if sort_direction || is_filtered || is_static}
+			<span class="header-icons">
+				{#if is_filtered}
+					<span class="filter-indicator" aria-label="Filtered">
+						<FilterIcon />
+					</span>
+				{/if}
+				{#if sort_direction}
+					<span
+						class="sort-indicator"
+						aria-label="Sorted {sort_direction}ending"
+					>
+						{#if sort_direction === "asc"}
+							<SortButtonUp size={13} />
+						{:else}
+							<SortButtonDown size={13} />
+						{/if}
+						{#if multi_sort && sort_priority != null}
+							<span class="sort-priority">{sort_priority}</span>
+						{/if}
+					</span>
+				{/if}
+
+				{#if is_static}
+					<Padlock size={11} />
+				{/if}
+			</span>
+		{/if}
+		{#if show_menu_button}
+			<CellMenuButton on_click={(e) => on_menu_click(e, col_idx)} />
+		{/if}
+	</div>
+</th>
+
+<style>
+	.header-cell {
+		--ring-color: transparent;
+		position: relative;
+		outline: none;
+		box-shadow:
+			inset 1px 0 0 var(--border-color-primary),
+			inset 0 0 0 1px var(--ring-color);
+		padding: 0;
+		background: var(--table-even-background-fill) !important;
+		font-weight: var(--weight-bold, 700);
+	}
+
+	.header-cell.first-column {
+		box-shadow: inset 0 0 0 1px var(--ring-color);
+	}
+
+	.header-cell:hover :global(.cell-menu-button),
+	.header-cell.focus :global(.cell-menu-button) {
+		display: flex;
+	}
+
+	.header-cell.focus {
+		--ring-color: var(--color-accent);
+		box-shadow:
+			inset 1px 0 0 var(--border-color-primary),
+			inset 0 0 0 2px var(--ring-color);
+		z-index: 4;
+	}
+
+	.header-cell.focus.first-column {
+		box-shadow: inset 0 0 0 2px var(--ring-color);
+	}
+
+	.header-content {
+		display: flex;
+		align-items: center;
+		gap: var(--size-1);
+		overflow: hidden;
+		min-width: 0;
+	}
+
+	.header-icons {
+		display: flex;
+		align-items: center;
+		gap: 2px;
+		flex-shrink: 0;
+		margin-left: auto;
+		opacity: 0.6;
+	}
+
+	.sort-indicator {
+		display: flex;
+		align-items: center;
+		position: relative;
+		margin-left: -5px;
+	}
+
+	.sort-priority {
+		font-size: 8px;
+		background: var(--button-secondary-background-fill);
+		border-radius: var(--radius-full);
+		width: 12px;
+		height: 12px;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		line-height: 1;
+	}
+
+	.filter-indicator {
+		display: flex;
+		align-items: center;
+		width: 16px;
+		height: 16px;
+		margin-top: 3px;
+	}
+
+	.filter-indicator :global(svg) {
+		width: 100%;
+		height: 100%;
+	}
+
+	.cell-wrap {
+		display: flex;
+		align-items: center;
+		justify-content: flex-start;
+		outline: none;
+		min-height: var(--size-9);
+		position: relative;
+		height: 100%;
+		padding: var(--size-2);
+		box-sizing: border-box;
+		gap: var(--size-1);
+		overflow: visible;
+		min-width: 0;
+	}
+</style>

6.11.1/dataframe/shared/RowNumber.svelte

@@ -0,0 +1,34 @@
+<script lang="ts">
+	let {
+		index = null,
+		is_header = false
+	}: { index?: number | null; is_header?: boolean } = $props();
+</script>
+
+{#if is_header}
+	<th tabindex="-1" class="row-number">
+		<div class="cell-wrap">
+			<div class="header-content">
+				<div class="header-text"></div>
+			</div>
+		</div>
+	</th>
+{:else}
+	<td class="row-number" tabindex="-1" data-row={index} data-col="row-number">
+		{index !== null ? index + 1 : ""}
+	</td>
+{/if}
+
+<style>
+	.row-number {
+		text-align: center;
+		padding: var(--size-1);
+		min-width: var(--size-12);
+		width: var(--size-12);
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+		font-weight: var(--weight-semibold);
+		border-right: 1px solid var(--border-color-primary);
+	}
+</style>

6.11.1/dataframe/shared/Table.svelte

@@ -0,0 +1,1364 @@
+<script lang="ts">
+	import {
+		createSvelteTable,
+		createSvelteVirtualizer,
+		getCoreRowModel,
+		getSortedRowModel,
+		getFilteredRowModel,
+		type ColumnDef,
+		type SortingState,
+		type ColumnFiltersState,
+		type ColumnPinningState
+	} from "./tanstack/index.js";
+	import { tick, onMount } from "svelte";
+	import { Upload } from "@gradio/upload";
+
+	import HeaderCell from "./HeaderCell.svelte";
+	import DataCell from "./DataCell.svelte";
+	import EmptyRowButton from "./EmptyRowButton.svelte";
+	import type { SelectData } from "@gradio/utils";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import { type Client } from "@gradio/client";
+	import type { Datatype, DataframeValue, EditData } from "./utils/utils";
+	import { cast_value_to_type } from "./utils/utils";
+	import CellMenu from "./CellMenu.svelte";
+	import Toolbar from "./Toolbar.svelte";
+	import type {
+		CellValue,
+		CellCoordinate,
+		SortDirection,
+		FilterDatatype
+	} from "./types";
+	import {
+		is_cell_in_selection,
+		is_cell_selected,
+		handle_click_outside as handle_click_outside_util
+	} from "./utils/selection_utils";
+	import { copy_table_data, handle_file_upload } from "./utils/table_utils";
+	import { gradio_filter_fn } from "./utils/filter";
+	import { create_column_measurement } from "./column_measurement.svelte.js";
+
+	let {
+		datatype,
+		label = null,
+		show_label = true,
+		headers = $bindable([]),
+		values = $bindable([]),
+		col_count,
+		row_count,
+		latex_delimiters,
+		components = {},
+		editable = true,
+		wrap = false,
+		root,
+		i18n,
+		max_height = 500,
+		line_breaks = true,
+		column_widths = [],
+		show_row_numbers = false,
+		upload,
+		stream_handler,
+		buttons = null,
+		value_is_output = $bindable(false),
+		max_chars = undefined,
+		show_search = "none",
+		pinned_columns = 0,
+		static_columns = [],
+		fullscreen = false,
+		display_value = null,
+		styling = null,
+		onchange,
+		oninput,
+		onselect,
+		onedit,
+		onsearch,
+		onfullscreen
+	}: {
+		datatype: Datatype | Datatype[];
+		label?: string | null;
+		show_label?: boolean;
+		headers?: (string | null)[];
+		values?: CellValue[][];
+		col_count: [number, "fixed" | "dynamic"];
+		row_count: [number, "fixed" | "dynamic"];
+		latex_delimiters: { left: string; right: string; display: boolean }[];
+		components?: Record<string, any>;
+		editable?: boolean;
+		wrap?: boolean;
+		root: string;
+		i18n: I18nFormatter;
+		max_height?: number;
+		line_breaks?: boolean;
+		column_widths?: string[];
+		show_row_numbers?: boolean;
+		upload: Client["upload"];
+		stream_handler: Client["stream"];
+		buttons?: string[] | null;
+		value_is_output?: boolean;
+		max_chars?: number | undefined;
+		show_search?: "none" | "search" | "filter";
+		pinned_columns?: number;
+		static_columns?: (string | number)[];
+		fullscreen?: boolean;
+		display_value?: string[][] | null;
+		styling?: string[][] | null;
+		onchange?: (detail: DataframeValue) => void;
+		oninput?: () => void;
+		onselect?: (detail: SelectData) => void;
+		onedit?: (detail: EditData) => void;
+		onsearch?: (detail: string | null) => void;
+		onfullscreen?: () => void;
+	} = $props();
+
+	type GradioRow = Record<string, CellValue> & { _index: number };
+
+	// convert values[][] into tanstack row objects
+	let row_data: GradioRow[] = $derived(
+		(values ?? []).map((row, i) => {
+			const obj: GradioRow = { _index: i };
+			(row ?? []).forEach((val, j) => {
+				const dtype = Array.isArray(datatype) ? datatype[j] : datatype;
+				obj[`col_${j}`] = cast_value_to_type(val, dtype);
+			});
+			return obj;
+		})
+	);
+
+	let resolved_headers = $derived.by(() => {
+		let h = headers ?? [];
+		if (col_count[1] === "fixed" && h.length < col_count[0]) {
+			h = [
+				...h,
+				...Array(col_count[0] - h.length)
+					.fill(null)
+					.map((_, i) => `${i + h.length}`)
+			];
+		}
+		if (!h.length) {
+			h = Array(col_count[0])
+				.fill(null)
+				.map((_, i) => `${i}`);
+		}
+		return h.map((v) => v ?? "");
+	});
+
+	let column_defs: ColumnDef<GradioRow, CellValue>[] = $derived(
+		resolved_headers.map((header_value, j) => ({
+			id: `col_${j}`,
+			accessorKey: `col_${j}`,
+			header: header_value,
+			size: column_widths[j] ? parseInt(column_widths[j]) || 150 : 150,
+			minSize: 45,
+			filterFn: gradio_filter_fn,
+			meta: {
+				colIndex: j,
+				datatype: Array.isArray(datatype) ? datatype[j] : datatype,
+				isStatic:
+					static_columns.includes(j) || static_columns.includes(header_value),
+				isPinned: j < pinned_columns
+			}
+		}))
+	);
+
+	let sorting: SortingState = $state([]);
+	let column_filters: ColumnFiltersState = $state([]);
+	let global_filter: string = $state("");
+	let column_pinning: ColumnPinningState = $derived({
+		left: column_defs.filter((_, i) => i < pinned_columns).map((c) => c.id!)
+	});
+
+	const table = createSvelteTable<GradioRow>({
+		get data() {
+			return row_data;
+		},
+		get columns() {
+			return column_defs;
+		},
+		state: {
+			get sorting() {
+				return sorting;
+			},
+			get columnFilters() {
+				return column_filters;
+			},
+			get globalFilter() {
+				return global_filter;
+			},
+			get columnPinning() {
+				return column_pinning;
+			}
+		},
+		onSortingChange: (updater) => {
+			sorting = typeof updater === "function" ? updater(sorting) : updater;
+		},
+		onColumnFiltersChange: (updater) => {
+			column_filters =
+				typeof updater === "function" ? updater(column_filters) : updater;
+		},
+		onGlobalFilterChange: (updater) => {
+			global_filter =
+				typeof updater === "function" ? updater(global_filter) : updater;
+		},
+		getCoreRowModel: getCoreRowModel(),
+		getSortedRowModel: getSortedRowModel(),
+		getFilteredRowModel: getFilteredRowModel(),
+		globalFilterFn: "includesString",
+		enableSorting: true,
+		enableMultiSort: true,
+		maxMultiSortColCount: 3
+	});
+
+	let rows = $derived(table.getRowModel().rows);
+	let header_groups = $derived(table.getHeaderGroups());
+
+	let scroll_container: HTMLDivElement;
+
+	const virtualizer = createSvelteVirtualizer<
+		HTMLDivElement,
+		HTMLTableRowElement
+	>({
+		get count() {
+			return rows.length;
+		},
+		getScrollElement: () => scroll_container,
+		estimateSize: () => 35,
+		overscan: 10,
+		measureElement: (el, _entry, instance) => {
+			const h = el.getBoundingClientRect().height;
+			if (h > 0) return h;
+
+			const idx = el.getAttribute("data-index");
+			if (idx != null) {
+				const cached = (instance as any).itemSizeCache?.get(Number(idx));
+				if (typeof cached === "number") return cached;
+			}
+			return 35;
+		}
+	});
+
+	let virtual_items = $derived(virtualizer.virtualItems());
+	let total_size = $derived(virtualizer.totalSize());
+
+	let selected_cells: CellCoordinate[] = $state([]);
+	let selected: CellCoordinate | false = $state(false);
+	let editing: CellCoordinate | false = $state(false);
+	let header_edit: number | false = $state(false);
+	let selected_header: number | false = $state(false);
+	let active_cell_menu: {
+		row: number;
+		col: number;
+		x: number;
+		y: number;
+	} | null = $state(null);
+	let active_header_menu: { col: number; x: number; y: number } | null =
+		$state(null);
+	let copy_flash = $state(false);
+	let is_dragging = $state(false);
+	let show_scroll_button = $state(false);
+	let dragging = $state(false); // file drag
+
+	let parent: HTMLDivElement;
+
+	function get_dtype(col: number): Datatype {
+		return Array.isArray(datatype) ? (datatype[col] ?? "str") : datatype;
+	}
+
+	function get_display_value(row: number, col: number): string {
+		if (display_value?.[row]?.[col] !== undefined)
+			return display_value[row][col];
+		return String(values?.[row]?.[col] ?? "");
+	}
+
+	function get_styling(row: number, col: number): string {
+		return styling?.[row]?.[col] ?? "";
+	}
+
+	function push_change(
+		new_values?: CellValue[][],
+		new_headers?: (string | null)[]
+	): void {
+		onchange?.({
+			data: new_values ?? values,
+			headers: (new_headers ?? resolved_headers) as string[],
+			metadata: null
+		});
+		if (!value_is_output) oninput?.();
+		value_is_output = false;
+	}
+
+	function handle_cell_click(
+		event: MouseEvent,
+		row: number,
+		col: number
+	): void {
+		event.preventDefault();
+		event.stopPropagation();
+
+		const coord: CellCoordinate = [row, col];
+		if (event.shiftKey && selected) {
+			// range select
+			const [r1, c1] = selected;
+			const [r2, c2] = coord;
+			const new_cells: CellCoordinate[] = [];
+			for (let r = Math.min(r1, r2); r <= Math.max(r1, r2); r++) {
+				for (let c = Math.min(c1, c2); c <= Math.max(c1, c2); c++) {
+					new_cells.push([r, c]);
+				}
+			}
+			selected_cells = new_cells;
+		} else if (event.metaKey || event.ctrlKey) {
+			// toggle select
+			const exists = selected_cells.some(([r, c]) => r === row && c === col);
+			selected_cells = exists
+				? selected_cells.filter(([r, c]) => !(r === row && c === col))
+				: [...selected_cells, coord];
+		} else {
+			selected_cells = [coord];
+		}
+
+		selected = coord;
+		header_edit = false;
+		selected_header = false;
+		active_cell_menu = null;
+		active_header_menu = null;
+
+		// click selects, does NOT enter edit mode (double-click or typing does)
+		editing = false;
+
+		onselect?.({
+			index: coord,
+			value: values?.[row]?.[col],
+			row_value: values?.[row] ?? [],
+			col_value: values?.map((r) => r[col]) ?? []
+		} as any);
+
+		tick().then(() => parent?.focus());
+	}
+
+	function handle_cell_dblclick(
+		event: MouseEvent,
+		row: number,
+		col: number
+	): void {
+		event.preventDefault();
+		event.stopPropagation();
+		if (!editable) return;
+		const col_is_static =
+			static_columns.includes(col) ||
+			static_columns.includes(resolved_headers[col]);
+		if (!col_is_static) {
+			editing = [row, col];
+		}
+	}
+
+	function handle_blur(detail: {
+		blur_event: FocusEvent;
+		coords: [number, number];
+	}): void {
+		const { coords } = detail;
+		const input_el = detail.blur_event.target as HTMLTextAreaElement;
+		if (!input_el || input_el.value === undefined) return;
+
+		const [row, col] = coords;
+		const old_value = values?.[row]?.[col];
+		const new_value = input_el.value;
+
+		if (String(old_value) !== String(new_value)) {
+			const new_values = values.map((r) => [...r]);
+			new_values[row][col] = new_value;
+			values = new_values;
+
+			onedit?.({
+				index: [row, col],
+				value: new_value,
+				previous_value: String(old_value ?? "")
+			});
+			push_change(new_values);
+		}
+	}
+
+	function handle_header_click(event: MouseEvent, col: number): void {
+		if (event.target instanceof HTMLAnchorElement) return;
+		event.preventDefault();
+		event.stopPropagation();
+		if (!editable) return;
+
+		editing = false;
+		selected = false;
+		selected_cells = [];
+		active_cell_menu = null;
+		active_header_menu = null;
+		selected_header = col;
+		header_edit = editable ? col : false;
+		parent?.focus();
+	}
+
+	function end_header_edit(key: string): void {
+		if (["Escape", "Enter", "Tab"].includes(key)) {
+			header_edit = false;
+			parent?.focus();
+		}
+	}
+
+	function toggle_header_menu(event: MouseEvent, col: number): void {
+		event.stopPropagation();
+		if (active_header_menu?.col === col) {
+			active_header_menu = null;
+		} else {
+			const th = (event.target as HTMLElement).closest("th");
+			if (th) {
+				const rect = th.getBoundingClientRect();
+				active_header_menu = { col, x: rect.right, y: rect.bottom };
+			}
+		}
+	}
+
+	function handle_sort(col: number, direction: SortDirection): void {
+		const col_id = `col_${col}`;
+		const desc = direction === "desc";
+		// if already sorted this way, remove it
+		const existing = sorting.findIndex((s) => s.id === col_id);
+		if (existing >= 0 && sorting[existing].desc === desc) {
+			sorting = sorting.filter((s) => s.id !== col_id);
+		} else {
+			sorting = [
+				...sorting.filter((s) => s.id !== col_id),
+				{ id: col_id, desc }
+			].slice(-3);
+		}
+	}
+
+	function clear_sort(): void {
+		sorting = [];
+	}
+
+	function handle_filter(
+		col: number,
+		dtype: FilterDatatype,
+		filter: string,
+		fvalue: string
+	): void {
+		const col_id = `col_${col}`;
+		const existing = column_filters.findIndex((f) => f.id === col_id);
+		if (existing >= 0) {
+			column_filters = column_filters.filter((f) => f.id !== col_id);
+		} else {
+			column_filters = [
+				...column_filters,
+				{ id: col_id, value: { dtype, filter, value: fvalue } }
+			];
+		}
+	}
+
+	function clear_filter(): void {
+		column_filters = [];
+	}
+
+	function handle_search(query: string | null): void {
+		global_filter = query ?? "";
+		onsearch?.(query);
+	}
+
+	function add_row(index?: number): void {
+		if (row_count[1] !== "dynamic") return;
+		const col_len = values[0]?.length || resolved_headers.length || 1;
+		const new_row: CellValue[] = Array(col_len).fill("");
+		const new_values = [...values];
+		if (index !== undefined) {
+			new_values.splice(index, 0, new_row);
+		} else {
+			new_values.push(new_row);
+		}
+		values = new_values;
+		push_change(new_values);
+		selected = [index ?? new_values.length - 1, 0];
+		parent?.focus();
+	}
+
+	function add_col(index?: number): void {
+		if (col_count[1] !== "dynamic") return;
+		const new_headers = [
+			...(headers ?? []),
+			`Header ${(headers?.length ?? 0) + 1}`
+		];
+		const new_values = values.map((row) => [...row, ""]);
+		if (index !== undefined) {
+			new_headers.splice(index, 0, new_headers.pop()!);
+			new_values.forEach((row) => row.splice(index, 0, row.pop()!));
+		}
+		values = new_values;
+		headers = new_headers;
+		push_change(new_values, new_headers);
+		parent?.focus();
+	}
+
+	function delete_row_at(index: number): void {
+		if (values.length <= 1) return;
+		values = [...values.slice(0, index), ...values.slice(index + 1)];
+		push_change(values);
+		active_cell_menu = null;
+		active_header_menu = null;
+	}
+
+	function delete_col_at(index: number): void {
+		if (col_count[1] !== "dynamic") return;
+		if ((values[0]?.length ?? 0) <= 1) return;
+		values = values.map((row) => [
+			...row.slice(0, index),
+			...row.slice(index + 1)
+		]);
+		headers = [
+			...(headers ?? []).slice(0, index),
+			...(headers ?? []).slice(index + 1)
+		];
+		push_change(values, headers as string[]);
+		active_cell_menu = null;
+		active_header_menu = null;
+		selected = false;
+		selected_cells = [];
+		editing = false;
+	}
+
+	function add_row_at(index: number, position: "above" | "below"): void {
+		add_row(position === "above" ? index : index + 1);
+		active_cell_menu = null;
+	}
+
+	function add_col_at(index: number, position: "left" | "right"): void {
+		add_col(position === "left" ? index : index + 1);
+		active_cell_menu = null;
+	}
+
+	// function handle_select_all(col: number, checked: boolean): void {
+	// 	values = values.map((row) => {
+	// 		const new_row = [...row];
+	// 		new_row[col] = checked;
+	// 		return new_row;
+	// 	});
+	// 	push_change(values);
+	// }
+
+	function commit_filter(): void {
+		if (!global_filter || show_search !== "filter") return;
+		// get the filtered rows from tanstack and push as new values
+		const filtered_values = rows.map((row) => {
+			const original_idx = row.original._index;
+			return values[original_idx];
+		});
+		values = filtered_values;
+		global_filter = "";
+		push_change(filtered_values);
+	}
+
+	async function handle_copy(): Promise<void> {
+		const data_for_copy = values.map((row) =>
+			row.map((val, j) => ({ id: `${j}`, value: val }))
+		);
+		const cells_to_copy = selected_cells.length > 0 ? selected_cells : null;
+		await copy_table_data(data_for_copy, cells_to_copy);
+		copy_flash = true;
+		setTimeout(() => (copy_flash = false), 800);
+	}
+
+	function handle_click_outside(event: Event): void {
+		if (handle_click_outside_util(event, parent)) {
+			selected_cells = [];
+			selected = false;
+			editing = false;
+			header_edit = false;
+			selected_header = false;
+			active_cell_menu = null;
+			active_header_menu = null;
+		}
+	}
+
+	function handle_keydown(e: KeyboardEvent): void {
+		if (!selected && selected_header === false) return;
+
+		const num_rows = rows.length;
+		const num_cols = resolved_headers.length;
+
+		if (selected) {
+			const [row, col] = selected;
+
+			switch (e.key) {
+				case "ArrowUp":
+					e.preventDefault();
+					if (row > 0) {
+						selected = [row - 1, col];
+						selected_cells = [selected];
+						editing = false;
+						virtualizer.instance.scrollToIndex(row - 1, { align: "auto" });
+					}
+					break;
+				case "ArrowDown":
+					e.preventDefault();
+					if (row < num_rows - 1) {
+						selected = [row + 1, col];
+						selected_cells = [selected];
+						editing = false;
+						virtualizer.instance.scrollToIndex(row + 1, { align: "auto" });
+					}
+					break;
+				case "ArrowLeft":
+					e.preventDefault();
+					if (col > 0) {
+						selected = [row, col - 1];
+						selected_cells = [selected];
+						editing = false;
+					}
+					break;
+				case "ArrowRight":
+					e.preventDefault();
+					if (col < num_cols - 1) {
+						selected = [row, col + 1];
+						selected_cells = [selected];
+						editing = false;
+					}
+					break;
+				case "Tab": {
+					e.preventDefault();
+					const was_editing = !!editing;
+					if (e.shiftKey) {
+						if (col > 0) selected = [row, col - 1];
+						else if (row > 0) selected = [row - 1, num_cols - 1];
+					} else {
+						if (col < num_cols - 1) selected = [row, col + 1];
+						else if (row < num_rows - 1) selected = [row + 1, 0];
+					}
+					selected_cells = [selected];
+					if (was_editing) {
+						const tab_col = (selected as CellCoordinate)[1];
+						const tab_static =
+							static_columns.includes(tab_col) ||
+							static_columns.includes(resolved_headers[tab_col]);
+						editing = editable && !tab_static ? selected : false;
+					} else {
+						editing = false;
+					}
+					if (!editing) tick().then(() => parent?.focus());
+					break;
+				}
+				case "Enter":
+					if (editing && e.shiftKey) {
+						// shift+enter inserts newline in textarea — don't intercept
+						return;
+					}
+					e.preventDefault();
+					if (editing) {
+						editing = false;
+						if (row < num_rows - 1) {
+							selected = [row + 1, col];
+							selected_cells = [selected];
+						}
+						tick().then(() => parent?.focus());
+					} else if (editable) {
+						const enter_static =
+							static_columns.includes(col) ||
+							static_columns.includes(resolved_headers[col]);
+						if (!enter_static) {
+							editing = [row, col];
+						}
+					}
+					break;
+				case "Escape":
+					editing = false;
+					tick().then(() => parent?.focus());
+					break;
+				case "Delete":
+				case "Backspace":
+					if (!editing && editable) {
+						e.preventDefault();
+						const new_values = values.map((r) => [...r]);
+						selected_cells.forEach(([r, c]) => {
+							if (!static_columns.includes(c)) {
+								new_values[r][c] = "";
+							}
+						});
+						values = new_values;
+						push_change(new_values);
+					}
+					break;
+				default:
+					// start editing on printable character
+					if (
+						editable &&
+						!editing &&
+						e.key.length === 1 &&
+						!e.ctrlKey &&
+						!e.metaKey &&
+						!static_columns.includes(col)
+					) {
+						editing = [row, col];
+					}
+					break;
+			}
+
+			if ((e.ctrlKey || e.metaKey) && e.key === "c") {
+				handle_copy();
+			}
+		}
+	}
+
+	function handle_scroll(): void {
+		if (scroll_container) {
+			show_scroll_button = scroll_container.scrollTop > 100;
+		}
+	}
+
+	function scroll_to_top(): void {
+		scroll_container?.scrollTo({ top: 0 });
+	}
+
+	function toggle_cell_menu(event: MouseEvent, row: number, col: number): void {
+		event.stopPropagation();
+		if (active_cell_menu?.row === row && active_cell_menu.col === col) {
+			active_cell_menu = null;
+		} else {
+			const cell = (event.target as HTMLElement).closest(".body-cell, td");
+			if (cell) {
+				const rect = cell.getBoundingClientRect();
+				active_cell_menu = { row, col, x: rect.right, y: rect.bottom };
+			}
+		}
+	}
+
+	function on_file_upload(file_data: any): void {
+		handle_file_upload(
+			typeof file_data === "string" ? file_data : (file_data?.data ?? ""),
+			(head) => {
+				headers = head.map((h: any) => h ?? "");
+				return (headers as string[]).map((h: string, i: number) => ({
+					id: `h_${i}`,
+					value: h
+				}));
+			},
+			(vals) => {
+				values = vals;
+				push_change(vals, headers as string[]);
+			}
+		);
+	}
+
+	onMount(() => {
+		document.addEventListener("click", handle_click_outside);
+		return () => document.removeEventListener("click", handle_click_outside);
+	});
+
+	function measure_row(node: HTMLElement) {
+		tick().then(() => {
+			console.log("measuring");
+			virtualizer.instance.measureElement(node as any);
+		});
+
+		return {
+			destroy() {}
+		};
+	}
+
+	let header_row_el: HTMLTableRowElement;
+	let header_table_el: HTMLTableElement;
+
+	const measurement = create_column_measurement({
+		header_row_el: () => header_row_el,
+		header_table_el: () => header_table_el,
+		resolved_headers: () => resolved_headers,
+		row_data: () => row_data,
+		show_row_numbers: () => show_row_numbers,
+		column_widths: () => column_widths,
+		on_resize: undefined
+	});
+
+	let disable_scroll = $derived(
+		active_cell_menu !== null || active_header_menu !== null
+	);
+	let selected_index = $derived(selected !== false ? selected[0] : false);
+
+	$effect(() => {
+		if (typeof selected_index === "number") {
+			virtualizer.instance.scrollToIndex(selected_index, { align: "auto" });
+		}
+	});
+
+	function get_sort_info(col: number): {
+		direction: SortDirection | null;
+		priority: number | null;
+	} {
+		const col_id = `col_${col}`;
+		const idx = sorting.findIndex((s) => s.id === col_id);
+		if (idx === -1) return { direction: null, priority: null };
+		return { direction: sorting[idx].desc ? "desc" : "asc", priority: idx + 1 };
+	}
+
+	function get_filter_active(col: number): boolean {
+		return column_filters.some((f) => f.id === `col_${col}`);
+	}
+</script>
+
+<svelte:window
+	onresize={() => {
+		active_cell_menu = null;
+		active_header_menu = null;
+	}}
+/>
+
+<div class="table-container" class:fullscreen>
+	{#if (label && label.length !== 0 && show_label) || (buttons === null ? true : buttons.includes("fullscreen")) || (buttons === null ? true : buttons.includes("copy")) || show_search !== "none"}
+		<div class="header-row">
+			{#if label && label.length !== 0 && show_label}
+				<div class="label"><p>{label}</p></div>
+			{/if}
+			<Toolbar
+				show_fullscreen_button={buttons === null
+					? true
+					: buttons.includes("fullscreen")}
+				{fullscreen}
+				on_copy={handle_copy}
+				show_copy_button={buttons === null ? true : buttons.includes("copy")}
+				{show_search}
+				onsearch={(query) => handle_search(query)}
+				{onfullscreen}
+				on_commit_filter={commit_filter}
+				current_search_query={global_filter || null}
+			/>
+		</div>
+	{/if}
+
+	<div
+		bind:this={parent}
+		class="table-wrap"
+		class:dragging={is_dragging}
+		class:no-wrap={!wrap}
+		class:menu-open={active_cell_menu || active_header_menu}
+		onkeydown={handle_keydown}
+		role="grid"
+		tabindex="0"
+	>
+		<Upload
+			{upload}
+			{stream_handler}
+			flex={false}
+			center={false}
+			boundedheight={false}
+			disable_click={true}
+			{root}
+			onload={on_file_upload}
+			bind:dragging
+			aria_label={i18n("dataframe.drop_to_upload")}
+		>
+			<div
+				class="virtual-table-viewport"
+				class:disable-scroll={disable_scroll}
+				bind:this={scroll_container}
+				onscroll={handle_scroll}
+				style="max-height: {max_height}px;"
+				role="grid"
+			>
+				{#if label && label.length !== 0}
+					<span class="sr-only">{label}</span>
+				{/if}
+				<!-- header row: uses table layout to auto-size columns by content -->
+				<table class="header-table" bind:this={header_table_el}>
+					<thead>
+						<tr bind:this={header_row_el}>
+							{#if show_row_numbers}
+								<th class="row-number-header">&nbsp;</th>
+							{/if}
+							{#each header_groups as headerGroup (headerGroup.id)}
+								{#each headerGroup.headers as header (header.id)}
+									{@const col_idx =
+										(header.column.columnDef.meta as any)?.colIndex ?? 0}
+									<HeaderCell
+										value={String(header.column.columnDef.header ?? "")}
+										{col_idx}
+										is_editing={header_edit === col_idx}
+										is_selected={selected_header === col_idx}
+										is_static={!!(header.column.columnDef.meta as any)
+											?.isStatic}
+										sort_direction={get_sort_info(col_idx).direction}
+										sort_priority={get_sort_info(col_idx).priority}
+										multi_sort={sorting.length > 1}
+										is_filtered={get_filter_active(col_idx)}
+										show_menu_button={col_count[1] === "dynamic"}
+										is_first_column={col_idx === 0 && !show_row_numbers}
+										{latex_delimiters}
+										{line_breaks}
+										{editable}
+										{max_chars}
+										{i18n}
+										onclick={handle_header_click}
+										on_menu_click={toggle_header_menu}
+										on_end_edit={end_header_edit}
+									/>
+								{/each}
+							{/each}
+						</tr>
+					</thead>
+					<!-- hidden sizing row: lets table-layout:auto consider body content widths too -->
+					<tbody class="sizing-body" aria-hidden="true">
+						{#if rows.length > 0}
+							{@const sizing_row = rows.reduce((widest, row) => {
+								const cells = row.getVisibleCells();
+								cells.forEach((cell, i) => {
+									const val = String(cell.getValue() ?? "");
+									if (!widest[i] || val.length > widest[i].length) {
+										widest[i] = val;
+									}
+								});
+								return widest;
+							}, [] as string[])}
+							<tr>
+								{#if show_row_numbers}
+									<td class="row-number-cell">{rows.length}</td>
+								{/if}
+								{#each sizing_row as val, ci}
+									{@const dtype = get_dtype(ci)}
+									<td
+										><div class="cell-wrap">
+											{#if dtype === "html" || dtype === "markdown"}{@html val}{:else}{val}{/if}
+										</div></td
+									>
+								{/each}
+							</tr>
+						{/if}
+					</tbody>
+				</table>
+
+				<!-- table body: absolutely positioned rows (standard tanstack virtual pattern) -->
+				<div
+					class="virtual-body"
+					style="height: {total_size}px; position: relative; flex-shrink: 0; width: {measurement.total_header_width
+						? `${measurement.total_header_width}px`
+						: '100%'};"
+				>
+					{#each virtual_items as virtual_row (virtual_row.key)}
+						{@const row = rows[virtual_row.index]}
+						{@const row_idx = row?.original._index ?? virtual_row.index}
+						{#if row}
+							<div
+								class="virtual-row"
+								class:row-odd={virtual_row.index % 2 !== 0}
+								data-index={virtual_row.index}
+								style="position: absolute; top: 0; left: 0; width: 100%; transform: translateY({virtual_row.start}px);{selected_cells.some(
+									([r]) => r === row_idx
+								)
+									? ' z-index: 3;'
+									: ''}"
+								use:measure_row={row}
+							>
+								{#if show_row_numbers}
+									<div
+										class="row-number-cell"
+										data-row={row_idx}
+										data-col="row-number"
+										style="flex: 0 0 {measurement.row_num_width}px; width: {measurement.row_num_width}px;"
+									>
+										{row_idx + 1}
+									</div>
+								{/if}
+								{#each row.getVisibleCells() as cell, ci (cell.id)}
+									{@const col_idx =
+										(cell.column.columnDef.meta as any)?.colIndex ?? 0}
+									{@const is_sel = is_cell_in_selection(
+										[row_idx, col_idx],
+										selected_cells
+									)}
+									<DataCell
+										value={cell.getValue() as CellValue}
+										display_value={get_display_value(row_idx, col_idx)}
+										datatype={get_dtype(col_idx)}
+										{row_idx}
+										{col_idx}
+										col_style={measurement.get_col_style(ci)}
+										cell_style={get_styling(row_idx, col_idx)}
+										selection_classes={is_cell_selected(
+											[row_idx, col_idx],
+											selected_cells
+										)}
+										is_editing={!!(
+											editing &&
+											editing[0] === row_idx &&
+											editing[1] === col_idx
+										)}
+										is_flash={copy_flash && is_sel}
+										is_static={!!(cell.column.columnDef.meta as any)?.isStatic}
+										show_menu_button={editable &&
+											selected_cells.length === 1 &&
+											selected_cells[0][0] === row_idx &&
+											selected_cells[0][1] === col_idx}
+										show_selection_buttons={selected_cells.length === 1 &&
+											selected_cells[0][0] === row_idx &&
+											selected_cells[0][1] === col_idx}
+										is_first_column={ci === 0 && !show_row_numbers}
+										{latex_delimiters}
+										{line_breaks}
+										{editable}
+										{max_chars}
+										{i18n}
+										{components}
+										{is_dragging}
+										wrap_text={wrap}
+										onmousedown={(e) => handle_cell_click(e, row_idx, col_idx)}
+										ondblclick={(e) =>
+											handle_cell_dblclick(e, row_idx, col_idx)}
+										oncontextmenu={(e) => {
+											e.preventDefault();
+											toggle_cell_menu(e, row_idx, col_idx);
+										}}
+										onblur={handle_blur}
+										on_menu_click={(e) => toggle_cell_menu(e, row_idx, col_idx)}
+										on_select_column={(c) => {
+											selected_cells = rows.map(
+												(_, r) => [r, c] as CellCoordinate
+											);
+											selected = selected_cells[0];
+										}}
+										on_select_row={(r) => {
+											selected_cells = resolved_headers.map(
+												(_, c) => [r, c] as CellCoordinate
+											);
+											selected = selected_cells[0];
+										}}
+									/>
+								{/each}
+							</div>
+						{/if}
+					{/each}
+				</div>
+			</div>
+		</Upload>
+
+		{#if show_scroll_button}
+			<button class="scroll-top-button" onclick={scroll_to_top}>&uarr;</button>
+		{/if}
+	</div>
+</div>
+
+{#if active_cell_menu || active_header_menu}
+	<CellMenu
+		x={active_cell_menu?.x ?? active_header_menu?.x ?? 0}
+		y={active_cell_menu?.y ?? active_header_menu?.y ?? 0}
+		row={active_header_menu ? -1 : (active_cell_menu?.row ?? 0)}
+		{col_count}
+		{row_count}
+		on_add_row_above={() => add_row_at(active_cell_menu?.row ?? -1, "above")}
+		on_add_row_below={() => add_row_at(active_cell_menu?.row ?? -1, "below")}
+		on_add_column_left={() =>
+			add_col_at(
+				active_cell_menu?.col ?? active_header_menu?.col ?? -1,
+				"left"
+			)}
+		on_add_column_right={() =>
+			add_col_at(
+				active_cell_menu?.col ?? active_header_menu?.col ?? -1,
+				"right"
+			)}
+		on_delete_row={() => delete_row_at(active_cell_menu?.row ?? -1)}
+		on_delete_col={() =>
+			delete_col_at(active_cell_menu?.col ?? active_header_menu?.col ?? -1)}
+		{editable}
+		can_delete_rows={!active_header_menu && values.length > 1 && editable}
+		can_delete_cols={values.length > 0 &&
+			(values[0]?.length ?? 0) > 1 &&
+			editable}
+		{i18n}
+		on_sort={active_header_menu
+			? (direction) => {
+					handle_sort(active_header_menu!.col, direction);
+					active_header_menu = null;
+				}
+			: undefined}
+		on_clear_sort={active_header_menu
+			? () => {
+					clear_sort();
+					active_header_menu = null;
+				}
+			: undefined}
+		sort_direction={active_header_menu
+			? get_sort_info(active_header_menu.col).direction
+			: null}
+		sort_priority={active_header_menu
+			? get_sort_info(active_header_menu.col).priority
+			: null}
+		on_filter={active_header_menu
+			? (dtype, filter, fvalue) => {
+					handle_filter(active_header_menu!.col, dtype, filter, fvalue);
+					active_header_menu = null;
+				}
+			: undefined}
+		on_clear_filter={active_header_menu
+			? () => {
+					clear_filter();
+					active_header_menu = null;
+				}
+			: undefined}
+		filter_active={active_header_menu
+			? get_filter_active(active_header_menu.col)
+			: null}
+	/>
+{/if}
+
+{#if values.length === 0 && editable && row_count[1] === "dynamic"}
+	<EmptyRowButton on_click={() => add_row()} />
+{/if}
+
+<style>
+	.table-container {
+		display: flex;
+		flex-direction: column;
+		gap: var(--size-2);
+		position: relative;
+		max-width: 100%;
+		overflow: hidden;
+	}
+
+	.table-container.fullscreen {
+		padding: var(--size-4);
+		height: 100%;
+		box-sizing: border-box;
+	}
+
+	.table-container.fullscreen .table-wrap {
+		flex: 1 1 auto;
+		min-height: 0;
+		display: flex;
+		flex-direction: column;
+	}
+
+	.table-container.fullscreen .table-wrap > :global(*) {
+		flex: 1 1 auto;
+		min-height: 0;
+		display: flex;
+		flex-direction: column;
+	}
+
+	.table-container.fullscreen .virtual-table-viewport {
+		max-height: none !important;
+		flex: 1 1 auto;
+		min-height: 0;
+	}
+
+	.table-wrap {
+		position: relative;
+		transition: 150ms;
+		width: 100%;
+	}
+
+	/* Constrain Upload component wrapper */
+	.table-wrap > :global(*) {
+		max-width: 100%;
+	}
+
+	.table-wrap.menu-open {
+		overflow: hidden;
+	}
+
+	.table-wrap:focus-within {
+		outline: none;
+	}
+
+	.table-wrap.dragging {
+		cursor: crosshair !important;
+		user-select: none;
+	}
+
+	.table-wrap.dragging * {
+		cursor: crosshair !important;
+		user-select: none;
+	}
+
+	.table-wrap > :global(button) {
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--table-radius);
+		overflow: hidden;
+	}
+
+	/* Virtual scroll container */
+	.virtual-table-viewport {
+		display: flex;
+		flex-direction: column;
+		overflow: auto;
+		position: relative;
+		-webkit-overflow-scrolling: touch;
+		min-width: 0;
+		max-width: 100%;
+		scrollbar-width: thin;
+		scrollbar-color: rgba(128, 128, 128, 0.5) transparent;
+	}
+
+	.virtual-table-viewport::-webkit-scrollbar {
+		width: 4px;
+		height: 4px;
+	}
+
+	.virtual-table-viewport::-webkit-scrollbar-thumb {
+		background-color: rgba(128, 128, 128, 0.5);
+		border-radius: 4px;
+	}
+
+	.virtual-table-viewport:hover {
+		scrollbar-color: rgba(160, 160, 160, 0.7) transparent;
+	}
+
+	.virtual-table-viewport.disable-scroll {
+		overflow: hidden !important;
+	}
+
+	/* Header table: auto-sizes columns by content, sticky */
+	.header-table {
+		width: 100%;
+		color: var(--body-text-color);
+		font-size: var(--input-text-size);
+		line-height: var(--line-md);
+		font-family: var(--font-mono);
+		border-spacing: 0;
+		border-collapse: separate;
+		table-layout: auto;
+		position: sticky;
+		top: 0;
+		z-index: 7;
+		flex-shrink: 0;
+	}
+
+	/* Hidden sizing row — visibility:collapse hides the row but keeps column width contribution */
+	.sizing-body tr {
+		visibility: collapse;
+	}
+
+	.sizing-body td {
+		padding: var(--size-2);
+		border: none;
+		white-space: nowrap;
+	}
+
+	/* Virtual body */
+	.virtual-body {
+		box-sizing: border-box;
+	}
+
+	.virtual-row {
+		display: flex;
+		align-items: stretch;
+		background: var(--table-odd-background-fill);
+
+		text-align: left;
+		font-size: var(--input-text-size);
+		line-height: var(--line-md);
+		font-family: var(--font-mono);
+		color: var(--body-text-color);
+		min-height: var(--size-9);
+	}
+
+	.virtual-row:last-child {
+		border-bottom: none;
+	}
+
+	.virtual-row.row-odd {
+		background: var(--table-even-background-fill);
+	}
+
+	.virtual-row:hover {
+		background: var(--table-row-focus);
+	}
+
+	/* Cell content wrapper (used in sizing-body) */
+	.cell-wrap {
+		display: flex;
+		align-items: center;
+		justify-content: flex-start;
+		outline: none;
+		min-height: var(--size-9);
+		position: relative;
+		height: 100%;
+		padding: var(--size-2);
+		box-sizing: border-box;
+		gap: var(--size-1);
+		overflow: visible;
+		min-width: 0;
+	}
+
+	/* Row number cells */
+	.row-number-header {
+		text-align: center;
+		padding: var(--size-1);
+		min-width: var(--size-12);
+		width: var(--size-12);
+		font-weight: var(--weight-semibold);
+		border-right: 1px solid var(--border-color-primary);
+		background: var(--table-even-background-fill) !important;
+	}
+
+	.row-number-cell {
+		text-align: center;
+		padding: var(--size-1);
+		min-width: var(--size-12);
+		width: var(--size-12);
+		flex-shrink: 0;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+		font-weight: var(--weight-semibold);
+		border-right: 1px solid var(--border-color-primary);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.no-wrap {
+		white-space: nowrap;
+	}
+
+	div:not(.no-wrap) :global(td) {
+		overflow-wrap: anywhere;
+	}
+
+	div.no-wrap :global(td) {
+		overflow-x: hidden;
+	}
+
+	.header-row {
+		display: flex;
+		justify-content: flex-end;
+		align-items: center;
+		gap: var(--size-2);
+		min-height: var(--size-6);
+		flex-wrap: nowrap;
+		width: 100%;
+	}
+
+	.header-row .label {
+		flex: 1 1 auto;
+		margin-right: auto;
+		font-family: var(--font-sans);
+	}
+
+	.header-row .label p {
+		margin: 0;
+		color: var(--block-label-text-color);
+		font-size: var(--block-label-text-size);
+		line-height: var(--line-sm);
+	}
+
+	.scroll-top-button {
+		position: absolute;
+		right: var(--size-4);
+		bottom: var(--size-4);
+		width: var(--size-8);
+		height: var(--size-8);
+		border-radius: var(--table-radius);
+		background: var(--color-accent);
+		color: white;
+		border: none;
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		font-size: var(--text-lg);
+		z-index: 9;
+		opacity: 0.5;
+	}
+
+	.scroll-top-button:hover {
+		opacity: 1;
+	}
+</style>

6.11.1/dataframe/shared/Toolbar.svelte

@@ -0,0 +1,208 @@
+<script lang="ts">
+	import { Copy, Check } from "@gradio/icons";
+	import { FullscreenButton } from "@gradio/atoms";
+	import { IconButton } from "@gradio/atoms";
+
+	let {
+		show_fullscreen_button = false,
+		show_copy_button = false,
+		show_search = "none",
+		fullscreen = false,
+		on_copy,
+		on_commit_filter,
+		current_search_query = null,
+		onsearch,
+		onfullscreen
+	}: {
+		show_fullscreen_button?: boolean;
+		show_copy_button?: boolean;
+		show_search?: "none" | "search" | "filter";
+		fullscreen?: boolean;
+		on_copy: () => Promise<void>;
+		on_commit_filter: () => void;
+		current_search_query?: string | null;
+		onsearch?: (query: string | null) => void;
+		onfullscreen?: () => void;
+	} = $props();
+
+	let copied = $state(false);
+	let timer: ReturnType<typeof setTimeout>;
+	let input_value = $state("");
+
+	function handle_search_input(e: Event): void {
+		const target = e.target as HTMLTextAreaElement;
+		input_value = target.value;
+		const new_query = input_value || null;
+		if (current_search_query !== new_query) {
+			current_search_query = new_query;
+			onsearch?.(current_search_query);
+		}
+	}
+
+	function copy_feedback(): void {
+		copied = true;
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			copied = false;
+		}, 2000);
+	}
+
+	async function handle_copy(): Promise<void> {
+		await on_copy();
+		copy_feedback();
+	}
+
+	$effect(() => {
+		return () => {
+			if (timer) clearTimeout(timer);
+		};
+	});
+</script>
+
+<div class="toolbar" role="toolbar" aria-label="Table actions">
+	<div class="toolbar-buttons">
+		{#if show_search !== "none"}
+			<div class="search-container">
+				<input
+					type="text"
+					value={current_search_query || ""}
+					oninput={handle_search_input}
+					placeholder={show_search === "filter" ? "Filter..." : "Search..."}
+					class="search-input"
+					class:filter-mode={show_search === "filter"}
+					title={`Enter text to ${show_search} the table`}
+				/>
+				{#if current_search_query && show_search === "filter"}
+					<button
+						class="toolbar-button check-button"
+						onclick={on_commit_filter}
+						aria-label="Apply filter and update dataframe values"
+						title="Apply filter and update dataframe values"
+					>
+						<Check />
+					</button>
+				{/if}
+			</div>
+		{/if}
+		{#if show_copy_button}
+			<IconButton
+				Icon={copied ? Check : Copy}
+				label={copied ? "Copied to clipboard" : "Copy table data"}
+				onclick={handle_copy}
+			/>
+		{/if}
+		{#if show_fullscreen_button}
+			<FullscreenButton {fullscreen} onclick={(_fs) => onfullscreen?.()} />
+		{/if}
+	</div>
+</div>
+
+<style>
+	.toolbar {
+		display: flex;
+		align-items: center;
+		gap: var(--size-2);
+		flex: 0 0 auto;
+		font-family: var(--font-sans);
+	}
+
+	.toolbar-buttons {
+		display: flex;
+		gap: var(--size-1);
+		flex-wrap: nowrap;
+		align-items: center;
+	}
+
+	.toolbar-button {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: var(--size-6);
+		height: var(--size-6);
+		padding: var(--size-1);
+		border: none;
+		border-radius: var(--radius-sm);
+		background: transparent;
+		color: var(--body-text-color-subdued);
+		cursor: pointer;
+		transition: all 0.2s;
+	}
+
+	.toolbar-button:hover {
+		background: var(--background-fill-secondary);
+		color: var(--body-text-color);
+	}
+
+	.toolbar-button :global(svg) {
+		width: var(--size-4);
+		height: var(--size-4);
+	}
+
+	.search-container {
+		position: relative;
+	}
+
+	.search-input {
+		width: var(--size-full);
+		height: var(--size-6);
+		padding: var(--size-2);
+		padding-right: var(--size-8);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--table-radius);
+		font-size: var(--text-sm);
+		color: var(--body-text-color);
+		background: var(--background-fill-secondary);
+		transition: all 0.2s ease;
+	}
+
+	.search-input:hover {
+		border-color: var(--border-color-secondary);
+		background: var(--background-fill-primary);
+	}
+
+	.search-input:focus {
+		outline: none;
+		border-color: var(--color-accent);
+		background: var(--background-fill-primary);
+		box-shadow: 0 0 0 1px var(--color-accent);
+	}
+
+	.check-button {
+		position: absolute;
+		right: var(--size-1);
+		top: 50%;
+		transform: translateY(-50%);
+		background: var(--color-accent);
+		color: white;
+		border: none;
+		width: var(--size-4);
+		height: var(--size-4);
+		border-radius: var(--radius-sm);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		padding: var(--size-1);
+	}
+
+	.check-button :global(svg) {
+		width: var(--size-3);
+		height: var(--size-3);
+	}
+
+	.check-button:hover {
+		background: var(--color-accent-soft);
+	}
+
+	.toolbar-buttons :global(.icon-button) {
+		background: transparent !important;
+		height: var(--size-6);
+		width: var(--size-6);
+	}
+
+	.toolbar-buttons :global(.icon-button:hover) {
+		background: var(--background-fill-secondary) !important;
+		color: var(--body-text-color) !important;
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-sm) !important;
+	}
+</style>

6.11.1/dataframe/shared/column_measurement.svelte.ts

@@ -0,0 +1,103 @@
+/**
+ * measures header cell positions/widths and provides inline styles
+ * for absolutely-positioned body cells to match.
+ */
+export function create_column_measurement(opts: {
+	header_row_el: () => HTMLTableRowElement | undefined;
+	header_table_el: () => HTMLTableElement | undefined;
+	resolved_headers: () => string[];
+	row_data: () => any[];
+	show_row_numbers: () => boolean;
+	column_widths: () => string[];
+	on_resize?: () => void;
+}): {
+	readonly col_widths: number[];
+	readonly col_lefts: number[];
+	readonly total_header_width: number;
+	readonly header_height: number;
+	readonly row_num_width: number;
+	get_col_style: (index: number) => string;
+} {
+	let col_widths: number[] = $state([]);
+	let total_header_width: number = $state(0);
+	let header_height: number = $state(0);
+
+	// use offsets (not just widths) avoids accumulated subpixel rounding errors
+	let col_lefts: number[] = $state([]);
+
+	function measure(): void {
+		const current_row_el = opts.header_row_el();
+		const current_table_el = opts.header_table_el();
+		if (!current_row_el) return;
+
+		const cells = current_row_el.querySelectorAll<HTMLElement>(".header-cell");
+		const table_rect = current_table_el?.getBoundingClientRect();
+		const table_left = table_rect?.left ?? 0;
+
+		col_lefts = Array.from(cells).map(
+			(c) => c.getBoundingClientRect().left - table_left
+		);
+		col_widths = Array.from(cells).map((c) => c.getBoundingClientRect().width);
+		if (current_table_el) {
+			total_header_width = table_rect?.width ?? 0;
+			header_height = table_rect?.height ?? 0;
+		}
+		opts.on_resize?.();
+	}
+
+	$effect(() => {
+		const table_el = opts.header_table_el();
+		const row_el = opts.header_row_el();
+		if (!table_el || !row_el) return;
+
+		// re-run when columns change so we observe new cells
+		opts.resolved_headers();
+
+		const ro = new ResizeObserver(measure);
+		ro.observe(table_el);
+
+		// observe individual header cells so content-driven column
+		// width changes (editing, data updates) trigger a re-measure
+		// even when the overall table dimensions stay the same
+		const cells = row_el.querySelectorAll<HTMLElement>(".header-cell");
+		cells.forEach((cell) => ro.observe(cell));
+
+		return () => ro.disconnect();
+	});
+
+	let row_num_width = $derived.by(() => {
+		if (!opts.show_row_numbers()) return 0;
+		const row_el = opts.header_row_el();
+		if (!row_el) return 0;
+		const el = row_el.querySelector<HTMLElement>(".row-number-header");
+		return el?.getBoundingClientRect().width ?? 48;
+	});
+
+	function get_col_style(index: number): string {
+		if (col_widths[index] !== undefined) {
+			return `width: ${col_widths[index]}px; flex: 0 0 ${col_widths[index]}px;`;
+		}
+		const user_widths = opts.column_widths();
+		if (user_widths[index]) return `width: ${user_widths[index]};`;
+		return "width: 150px;";
+	}
+
+	return {
+		get col_widths() {
+			return col_widths;
+		},
+		get col_lefts() {
+			return col_lefts;
+		},
+		get total_header_width() {
+			return total_header_width;
+		},
+		get header_height() {
+			return header_height;
+		},
+		get row_num_width() {
+			return row_num_width;
+		},
+		get_col_style
+	};
+}

6.11.1/dataframe/shared/icons/FilterIcon.svelte

@@ -0,0 +1,20 @@
+<svg viewBox="0 0 24 24" width="20" height="20">
+	<path
+		d="M5 5H19"
+		stroke="currentColor"
+		stroke-width="2"
+		stroke-linecap="round"
+	/>
+	<path
+		d="M8 9H16"
+		stroke="currentColor"
+		stroke-width="2"
+		stroke-linecap="round"
+	/>
+	<path
+		d="M11 13H13"
+		stroke="currentColor"
+		stroke-width="2"
+		stroke-linecap="round"
+	/>
+</svg>

6.11.1/dataframe/shared/icons/Padlock.svelte

@@ -0,0 +1,28 @@
+<script lang="ts">
+	let { size = 16 } = $props();
+</script>
+
+<div class="wrapper" aria-label="Static column">
+	<svg
+		xmlns="http://www.w3.org/2000/svg"
+		width={size}
+		height={size}
+		viewBox="0 0 24 24"
+		fill="none"
+		stroke="currentColor"
+		stroke-width="2"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	>
+		<rect x="3" y="11" width="18" height="11" rx="2" ry="2"></rect>
+		<path d="M7 11V7a5 5 0 0 1 10 0v4"></path>
+	</svg>
+</div>
+
+<style>
+	.wrapper {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+</style>

6.11.1/dataframe/shared/icons/SelectionButtons.svelte

@@ -0,0 +1,108 @@
+<script lang="ts">
+	let {
+		position,
+		coords,
+		on_click = null
+	}: {
+		position: "column" | "row";
+		coords: [number, number];
+		on_click?: (() => void) | null;
+	} = $props();
+
+	let is_first_position = $derived(
+		position === "column" ? coords[0] === 0 : coords[1] === 0
+	);
+	let direction = $derived(
+		position === "column"
+			? is_first_position
+				? "down"
+				: "up"
+			: is_first_position
+				? "right"
+				: "left"
+	);
+</script>
+
+<button
+	class="selection-button selection-button-{position} {is_first_position
+		? `move-${direction}`
+		: ''}"
+	onclick={(e: MouseEvent) => {
+		e.stopPropagation();
+		on_click && on_click();
+	}}
+	aria-label={`Select ${position}`}
+>
+	<span class={direction}>
+		<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+			<path
+				d="m16.707 13.293-4-4a1 1 0 0 0-1.414 0l-4 4A1 1 0 0 0 8 15h8a1 1 0 0 0 .707-1.707z"
+				data-name={direction}
+			/>
+		</svg>
+	</span>
+</button>
+
+<style>
+	.selection-button {
+		position: absolute;
+		background: var(--color-accent);
+		width: var(--size-3);
+		height: var(--size-5);
+		color: var(--background-fill-primary);
+	}
+
+	.selection-button-column {
+		top: -15px;
+		left: 50%;
+		transform: translateX(-50%) rotate(90deg);
+		border-radius: var(--radius-sm) 0 0 var(--radius-sm);
+	}
+
+	.selection-button-row {
+		left: calc(var(--size-2-5) * -1);
+		top: 50%;
+		transform: translateY(-50%);
+		border-radius: var(--radius-sm) 0 0 var(--radius-sm);
+	}
+
+	.move-down {
+		bottom: -14px;
+		top: auto;
+		border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+	}
+
+	.move-right {
+		left: auto;
+		right: calc(var(--size-2-5) * -1);
+		top: 50%;
+		transform: translateY(-50%);
+		border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+	}
+
+	svg {
+		fill: currentColor;
+	}
+
+	span {
+		display: flex;
+		width: 100%;
+		height: 100%;
+	}
+
+	.up {
+		transform: rotate(-90deg);
+	}
+
+	.down {
+		transform: rotate(90deg);
+	}
+
+	.left {
+		transform: rotate(-90deg);
+	}
+
+	.right {
+		transform: rotate(90deg);
+	}
+</style>

6.11.1/dataframe/shared/icons/SortButtonDown.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	let { size = 16 } = $props();
+</script>
+
+<svg
+	width={size}
+	height={size}
+	viewBox="0 0 16 16"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+>
+	<path
+		d="M4 8L8 12L12 8"
+		stroke="currentColor"
+		stroke-width="1.5"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	/>
+	<path
+		d="M8 12V4"
+		stroke="currentColor"
+		stroke-width="1.5"
+		stroke-linecap="round"
+	/>
+</svg>

6.11.1/dataframe/shared/icons/SortButtonUp.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	let { size = 16 } = $props();
+</script>
+
+<svg
+	width={size}
+	height={size}
+	viewBox="0 0 16 16"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+>
+	<path
+		d="M4 8L8 4L12 8"
+		stroke="currentColor"
+		stroke-width="1.5"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	/>
+	<path
+		d="M8 4V12"
+		stroke="currentColor"
+		stroke-width="1.5"
+		stroke-linecap="round"
+	/>
+</svg>

6.11.1/dataframe/shared/icons/SortIcon.svelte

@@ -0,0 +1,78 @@
+<script lang="ts">
+	import type { I18nFormatter } from "@gradio/utils";
+	import SortButtonUp from "./SortButtonUp.svelte";
+	import SortButtonDown from "./SortButtonDown.svelte";
+	import { IconButton } from "@gradio/atoms";
+	type SortDirection = "asc" | "desc";
+
+	let {
+		direction = null,
+		priority = null,
+		i18n,
+		onsort
+	}: {
+		direction?: SortDirection | null;
+		priority?: number | null;
+		i18n: I18nFormatter;
+		onsort?: (direction: SortDirection) => void;
+	} = $props();
+</script>
+
+<div class="sort-icons" role="group" aria-label={i18n("dataframe.sort_column")}>
+	{#if (direction === "asc" || direction === "desc") && priority !== null}
+		<span aria-label={`Sort priority: ${priority}`} class="priority"
+			>{priority}</span
+		>
+	{/if}
+	<IconButton
+		size="x-small"
+		label={i18n("dataframe.sort_ascending")}
+		Icon={SortButtonUp}
+		highlight={direction === "asc"}
+		onclick={(event) => {
+			event.stopPropagation();
+			onsort?.("asc");
+		}}
+	></IconButton>
+	<IconButton
+		size="x-small"
+		label={i18n("dataframe.sort_descending")}
+		Icon={SortButtonDown}
+		highlight={direction === "desc"}
+		onclick={(event) => {
+			event.stopPropagation();
+			onsort?.("desc");
+		}}
+	></IconButton>
+</div>
+
+<style>
+	.sort-icons {
+		display: flex;
+		flex-direction: column;
+		gap: 0;
+		margin-right: var(--spacing-sm);
+	}
+
+	.sort-icons :global(button) {
+		margin-bottom: var(--spacing-xs);
+		border: 1px solid var(--border-color-primary);
+		background: unset;
+	}
+
+	.priority {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		position: absolute;
+		font-size: var(--size-2);
+		left: 19px;
+		z-index: var(--layer-3);
+		top: var(--spacing-xs);
+		background-color: var(--button-secondary-background-fill);
+		color: var(--body-text-color);
+		border-radius: var(--radius-sm);
+		width: var(--size-2-5);
+		height: var(--size-2-5);
+	}
+</style>

6.11.1/dataframe/shared/tanstack/index.ts

@@ -0,0 +1,23 @@
+export { createSvelteTable } from "./table.svelte.js";
+
+export { createSvelteVirtualizer, type VirtualItem } from "./virtual.svelte.js";
+
+export {
+	createColumnHelper,
+	getCoreRowModel,
+	getSortedRowModel,
+	getFilteredRowModel,
+	type ColumnDef,
+	type TableOptions,
+	type Table,
+	type Header,
+	type Cell,
+	type Row,
+	type SortingState,
+	type ColumnFiltersState,
+	type ColumnPinningState,
+	type FilterFn,
+	type SortingFn,
+	type CellContext,
+	type HeaderContext
+} from "@tanstack/table-core";

6.11.1/dataframe/shared/tanstack/table.svelte.ts

@@ -0,0 +1,117 @@
+import {
+	createTable,
+	type RowData,
+	type TableOptions,
+	type TableOptionsResolved,
+	type TableState
+} from "@tanstack/table-core";
+
+/**
+ * Merges objects while preserving property getters for lazy evaluation.
+ * Properties are defined as getters that look up values from sources in
+ * reverse order at access time. This is critical: it means reading a
+ * property from the merged result doesn't happen until the property is
+ * actually accessed, not when mergeObjects is called.
+ */
+export function mergeObjects(...sources: any): any {
+	const target: Record<string, any> = {};
+	for (let i = 0; i < sources.length; i++) {
+		let source = sources[i];
+		if (typeof source === "function") source = source();
+		if (source) {
+			const descriptors = Object.getOwnPropertyDescriptors(source);
+			for (const key in descriptors) {
+				if (key in target) continue;
+				Object.defineProperty(target, key, {
+					enumerable: true,
+					get() {
+						for (let j = sources.length - 1; j >= 0; j--) {
+							let s = sources[j];
+							if (typeof s === "function") s = s();
+							const v = (s || {})[key];
+							if (v !== undefined) return v;
+						}
+					}
+				});
+			}
+		}
+	}
+	return target;
+}
+
+/**
+ * Creates a reactive TanStack Table for Svelte 5.
+ *
+ * The reactivity works through mergeObjects' lazy getters:
+ * - $effect.pre calls table.setOptions() with a merged object
+ * - The merged object has lazy getters for `data`, `columns`, `state`, etc.
+ * - TanStack stores this object but doesn't deep-read all properties immediately
+ * - When getRowModel() is called (in $derived), TanStack reads `data` and `columns`
+ *   through the lazy getters, which read the reactive $state/$derived values
+ * - onStateChange fires when TanStack mutates its own state → bumps version
+ * - version is read by getRowModel/getHeaderGroups → $derived re-evaluates
+ */
+export function createSvelteTable<TData extends RowData>(
+	options: TableOptions<TData>
+) {
+	const resolvedOptions: TableOptionsResolved<TData> = mergeObjects(
+		{
+			state: {},
+			onStateChange() {},
+			renderFallbackValue: null,
+			mergeOptions: (
+				defaultOptions: TableOptions<TData>,
+				opts: Partial<TableOptions<TData>>
+			) => {
+				return mergeObjects(defaultOptions, opts);
+			}
+		},
+		options
+	);
+
+	const table = createTable(resolvedOptions);
+	let state = $state<Partial<TableState>>(table.initialState);
+	let version = $state(0);
+
+	function updateOptions(): void {
+		table.setOptions((prev) => {
+			// mergeObjects creates lazy getters — `state` is NOT read here,
+			// only when TanStack accesses the `state` property later.
+			return mergeObjects(prev, options, {
+				state: mergeObjects(state, options.state || {}),
+				onStateChange: (updater: any) => {
+					if (updater instanceof Function) state = updater(state);
+					else state = mergeObjects(state, updater);
+					version += 1;
+					options.onStateChange?.(updater);
+				}
+			});
+		});
+	}
+
+	// Initial sync
+	updateOptions();
+
+	// Re-sync when options change. Because mergeObjects uses lazy getters,
+	// this effect's tracked dependencies are only the properties that
+	// table.setOptions() eagerly reads (which is minimal — mostly just
+	// checking if the options object reference changed).
+	$effect.pre(() => {
+		updateOptions();
+	});
+
+	return {
+		getRowModel: () => {
+			void version;
+			return table.getRowModel();
+		},
+		getHeaderGroups: () => {
+			void version;
+			return table.getHeaderGroups();
+		},
+		getColumn: (id: string) => {
+			void version;
+			return table.getColumn(id);
+		}
+	};
+}

6.11.1/dataframe/shared/tanstack/virtual.svelte.ts

@@ -0,0 +1,105 @@
+import {
+	Virtualizer,
+	elementScroll,
+	observeElementOffset,
+	observeElementRect,
+	type PartialKeys,
+	type VirtualizerOptions
+} from "@tanstack/virtual-core";
+import { untrack } from "svelte";
+
+export type { VirtualItem } from "@tanstack/virtual-core";
+
+/**
+ * Creates a reactive TanStack Virtualizer for Svelte 5.
+ *
+ * Returns a getter function that returns the virtualizer instance.
+ * Call the getter inside $derived or template expressions to create
+ * reactive dependencies on the virtualizer state.
+ */
+export function createSvelteVirtualizer<
+	TScrollElement extends Element,
+	TItemElement extends Element
+>(
+	options: PartialKeys<
+		VirtualizerOptions<TScrollElement, TItemElement>,
+		"observeElementRect" | "observeElementOffset" | "scrollToFn"
+	>
+): {
+	instance: Virtualizer<TScrollElement, TItemElement>;
+	virtualItems: () => ReturnType<
+		Virtualizer<TScrollElement, TItemElement>["getVirtualItems"]
+	>;
+	totalSize: () => number;
+} {
+	let version = $state(0);
+
+	const virtualizer = new Virtualizer<TScrollElement, TItemElement>({
+		observeElementRect: observeElementRect,
+		observeElementOffset: observeElementOffset,
+		scrollToFn: elementScroll,
+		...options,
+		onChange: (instance, sync) => {
+			if (sync) {
+				version += 1;
+			} else {
+				queueMicrotask(() => {
+					version += 1;
+				});
+			}
+			options.onChange?.(instance, sync);
+		}
+	});
+
+	$effect(() => {
+		const cleanup = virtualizer._didMount();
+		untrack(() => {
+			version += 1;
+		});
+		return cleanup;
+	});
+
+	let prev_count = 0;
+
+	$effect(() => {
+		const current_count = options.count;
+		virtualizer.setOptions({
+			observeElementRect: observeElementRect,
+			observeElementOffset: observeElementOffset,
+			scrollToFn: elementScroll,
+			...options,
+			onChange: (instance, sync) => {
+				if (sync) {
+					version += 1;
+				} else {
+					queueMicrotask(() => {
+						version += 1;
+					});
+				}
+				options.onChange?.(instance, sync);
+			}
+		});
+
+		if (prev_count === 0 && current_count > 0) {
+			virtualizer.measure();
+		}
+		prev_count = current_count;
+	});
+
+	$effect.pre(() => {
+		void version;
+		virtualizer._willUpdate();
+	});
+
+	return {
+		instance: virtualizer,
+		virtualItems: () => {
+			void version;
+			return virtualizer.getVirtualItems();
+		},
+		totalSize: () => {
+			void version;
+			return virtualizer.getTotalSize();
+		}
+	};
+}

6.11.1/dataframe/shared/types.ts

@@ -0,0 +1,34 @@
+export type CellCoordinate = [number, number];
+export type EditingState = CellCoordinate | false;
+
+export type Headers = (string | null)[];
+
+export interface HeadersWithIDs {
+	id: string;
+	value: string;
+}
+[];
+
+export type CellValue = string | number | boolean;
+
+export interface TableCell {
+	id: string;
+	value: CellValue;
+}
+
+export type TableData = TableCell[][];
+
+export type CountConfig = [number, "fixed" | "dynamic"];
+
+export type ElementRefs = Record<
+	string,
+	{
+		cell: null | HTMLTableCellElement;
+		input: null | HTMLTextAreaElement;
+	}
+>;
+
+export type DataBinding = Record<string, TableCell>;
+
+export type SortDirection = "asc" | "desc";
+export type FilterDatatype = "string" | "number";

6.11.1/dataframe/shared/utils/filter.ts

@@ -0,0 +1,66 @@
+/**
+ * Custom filter function for TanStack Table that handles Gradio's
+ * { dtype, filter, value } column filter format.
+ */
+export function gradio_filter_fn(
+	row: any,
+	columnId: string,
+	filterValue: any
+): boolean {
+	const { dtype, filter, value: fval } = filterValue;
+	const cell_value = String(row.getValue(columnId) ?? "");
+	const compare_val = fval ?? "";
+
+	if (dtype === "number") {
+		const num = parseFloat(cell_value);
+		const target = parseFloat(compare_val);
+		if (isNaN(num) || isNaN(target)) {
+			if (filter === "Is empty") return cell_value.trim() === "";
+			if (filter === "Is not empty") return cell_value.trim() !== "";
+			return true;
+		}
+		switch (filter) {
+			case "=":
+				return num === target;
+			case "≠":
+				return num !== target;
+			case ">":
+				return num > target;
+			case "<":
+				return num < target;
+			case "≥":
+				return num >= target;
+			case "≤":
+				return num <= target;
+			case "Is empty":
+				return cell_value.trim() === "";
+			case "Is not empty":
+				return cell_value.trim() !== "";
+			default:
+				return true;
+		}
+	}
+
+	const lower = cell_value.toLowerCase();
+	const target_lower = compare_val.toLowerCase();
+	switch (filter) {
+		case "Contains":
+			return lower.includes(target_lower);
+		case "Does not contain":
+			return !lower.includes(target_lower);
+		case "Starts with":
+			return lower.startsWith(target_lower);
+		case "Ends with":
+			return lower.endsWith(target_lower);
+		case "Is":
+			return lower === target_lower;
+		case "Is not":
+			return lower !== target_lower;
+		case "Is empty":
+			return cell_value.trim() === "";
+		case "Is not empty":
+			return cell_value.trim() !== "";
+		default:
+			return true;
+	}
+}

6.11.1/dataframe/shared/utils/selection_utils.ts

@@ -0,0 +1,234 @@
+import type { CellCoordinate, CellValue } from "./../types";
+
+export type CellData = { id: string; value: CellValue };
+
+export function is_cell_in_selection(
+	coords: [number, number],
+	selected_cells: [number, number][]
+): boolean {
+	const [row, col] = coords;
+	return selected_cells.some(([r, c]) => r === row && c === col);
+}
+
+export function is_cell_selected(
+	cell: CellCoordinate,
+	selected_cells: CellCoordinate[]
+): string {
+	const [row, col] = cell;
+	if (!selected_cells.some(([r, c]) => r === row && c === col)) return "";
+
+	const up = selected_cells.some(([r, c]) => r === row - 1 && c === col);
+	const down = selected_cells.some(([r, c]) => r === row + 1 && c === col);
+	const left = selected_cells.some(([r, c]) => r === row && c === col - 1);
+	const right = selected_cells.some(([r, c]) => r === row && c === col + 1);
+
+	return `cell-selected${up ? " no-top" : ""}${down ? " no-bottom" : ""}${left ? " no-left" : ""}${right ? " no-right" : ""}`;
+}
+
+export function get_range_selection(
+	start: CellCoordinate,
+	end: CellCoordinate
+): CellCoordinate[] {
+	const [start_row, start_col] = start;
+	const [end_row, end_col] = end;
+	const min_row = Math.min(start_row, end_row);
+	const max_row = Math.max(start_row, end_row);
+	const min_col = Math.min(start_col, end_col);
+	const max_col = Math.max(start_col, end_col);
+
+	const cells: CellCoordinate[] = [];
+	// add the start cell as the "anchor" cell so that when
+	// we press shift+arrow keys, the selection will always
+	// include the anchor cell.
+	cells.push(start);
+
+	for (let i = min_row; i <= max_row; i++) {
+		for (let j = min_col; j <= max_col; j++) {
+			if (i === start_row && j === start_col) continue;
+			cells.push([i, j]);
+		}
+	}
+	return cells;
+}
+
+export function handle_selection(
+	current: CellCoordinate,
+	selected_cells: CellCoordinate[],
+	event: { shiftKey: boolean; metaKey: boolean; ctrlKey: boolean }
+): CellCoordinate[] {
+	if (event.shiftKey && selected_cells.length > 0) {
+		return get_range_selection(
+			selected_cells[selected_cells.length - 1],
+			current
+		);
+	}
+
+	if (event.metaKey || event.ctrlKey) {
+		const is_cell_match = ([r, c]: CellCoordinate): boolean =>
+			r === current[0] && c === current[1];
+		const index = selected_cells.findIndex(is_cell_match);
+		return index === -1
+			? [...selected_cells, current]
+			: selected_cells.filter((_, i) => i !== index);
+	}
+
+	return [current];
+}
+
+export function handle_delete_key(
+	data: CellData[][],
+	selected_cells: CellCoordinate[]
+): CellData[][] {
+	const new_data = data.map((row) => [...row]);
+	selected_cells.forEach(([row, col]) => {
+		if (new_data[row] && new_data[row][col]) {
+			new_data[row][col] = { ...new_data[row][col], value: "" };
+		}
+	});
+	return new_data;
+}
+
+export function should_show_cell_menu(
+	cell: CellCoordinate,
+	selected_cells: CellCoordinate[],
+	editable: boolean
+): boolean {
+	const [row, col] = cell;
+	return (
+		editable &&
+		selected_cells.length === 1 &&
+		selected_cells[0][0] === row &&
+		selected_cells[0][1] === col
+	);
+}
+
+export function get_next_cell_coordinates(
+	current: CellCoordinate,
+	data: CellData[][],
+	shift_key: boolean
+): CellCoordinate | false {
+	const [row, col] = current;
+	const direction = shift_key ? -1 : 1;
+
+	if (data[row]?.[col + direction]) {
+		return [row, col + direction];
+	}
+
+	const next_row = row + (direction > 0 ? 1 : 0);
+	const prev_row = row + (direction < 0 ? -1 : 0);
+
+	if (direction > 0 && data[next_row]?.[0]) {
+		return [next_row, 0];
+	}
+
+	if (direction < 0 && data[prev_row]?.[data[0].length - 1]) {
+		return [prev_row, data[0].length - 1];
+	}
+
+	return false;
+}
+
+export function move_cursor(
+	event: KeyboardEvent,
+	current_coords: CellCoordinate,
+	data: CellData[][]
+): CellCoordinate | false {
+	const key = event.key as "ArrowRight" | "ArrowLeft" | "ArrowDown" | "ArrowUp";
+	const dir = {
+		ArrowRight: [0, 1],
+		ArrowLeft: [0, -1],
+		ArrowDown: [1, 0],
+		ArrowUp: [-1, 0]
+	}[key];
+
+	let i, j;
+	if (event.metaKey || event.ctrlKey) {
+		if (key === "ArrowRight") {
+			i = current_coords[0];
+			j = data[0].length - 1;
+		} else if (key === "ArrowLeft") {
+			i = current_coords[0];
+			j = 0;
+		} else if (key === "ArrowDown") {
+			i = data.length - 1;
+			j = current_coords[1];
+		} else if (key === "ArrowUp") {
+			i = 0;
+			j = current_coords[1];
+		} else {
+			return false;
+		}
+	} else {
+		i = current_coords[0] + dir[0];
+		j = current_coords[1] + dir[1];
+	}
+
+	if (i < 0 && j <= 0) {
+		return false;
+	}
+
+	const is_data = data[i]?.[j];
+	if (is_data) {
+		return [i, j];
+	}
+	return false;
+}
+
+export function get_current_indices(
+	id: string,
+	data: CellData[][]
+): [number, number] {
+	return data.reduce(
+		(acc, arr, i) => {
+			const j = arr.reduce(
+				(_acc, _data, k) => (id === _data.id ? k : _acc),
+				-1
+			);
+			return j === -1 ? acc : [i, j];
+		},
+		[-1, -1]
+	);
+}
+
+export function handle_click_outside(
+	event: Event,
+	parent: HTMLElement
+): boolean {
+	const [trigger] = event.composedPath() as HTMLElement[];
+	return !parent.contains(trigger);
+}
+
+export function select_column(data: any[][], col: number): CellCoordinate[] {
+	return Array.from({ length: data.length }, (_, i) => [i, col]);
+}
+
+export function select_row(data: any[][], row: number): CellCoordinate[] {
+	return Array.from({ length: data[0].length }, (_, i) => [row, i]);
+}
+
+export function calculate_selection_positions(
+	selected: CellCoordinate,
+	data: { id: string; value: CellValue }[][],
+	els: Record<string, { cell: HTMLTableCellElement | null }>,
+	parent: HTMLElement,
+	table: HTMLElement
+): { col_pos: string; row_pos: string | undefined } {
+	const [row, col] = selected;
+	if (!data[row]?.[col]) {
+		return { col_pos: "0px", row_pos: undefined };
+	}
+
+	const cell_id = data[row][col].id;
+	const cell_el = els[cell_id]?.cell;
+
+	if (!cell_el) {
+		return { col_pos: "0px", row_pos: undefined };
+	}
+
+	const cell_rect = cell_el.getBoundingClientRect();
+	const table_rect = table.getBoundingClientRect();
+	const col_pos = `${cell_rect.left - table_rect.left + cell_rect.width / 2}px`;
+	const row_pos = `${cell_rect.top - table_rect.top + cell_rect.height / 2}px`;
+
+	return { col_pos, row_pos };
+}

6.11.1/dataframe/shared/utils/table_utils.ts

@@ -0,0 +1,95 @@
+import type { CellValue, Headers, HeadersWithIDs, TableData } from "../types";
+import { dsvFormat } from "d3-dsv";
+
+export function make_cell_id(row: number, col: number): string {
+	return `cell-${row}-${col}`;
+}
+
+export function make_header_id(col: number): string {
+	return `header-${col}`;
+}
+
+export async function copy_table_data(
+	data: TableData,
+	selected_cells: [number, number][] | null
+): Promise<void> {
+	if (!data || !data.length) return;
+
+	const cells_to_copy =
+		selected_cells ||
+		data.flatMap((row, r) => row.map((_, c) => [r, c] as [number, number]));
+
+	const csv = cells_to_copy.reduce(
+		(acc: { [key: string]: { [key: string]: string } }, [row, col]) => {
+			acc[row] = acc[row] || {};
+			const value = String(data[row][col].value);
+			acc[row][col] =
+				value.includes(",") || value.includes('"') || value.includes("\n")
+					? `"${value.replace(/"/g, '""')}"`
+					: value;
+			return acc;
+		},
+		{}
+	);
+
+	const rows = Object.keys(csv).sort((a, b) => +a - +b);
+	if (!rows.length) return;
+
+	const cols = Object.keys(csv[rows[0]]).sort((a, b) => +a - +b);
+	const text = rows
+		.map((r) => cols.map((c) => csv[r][c] || "").join(","))
+		.join("\n");
+
+	try {
+		await navigator.clipboard.writeText(text);
+	} catch (err) {
+		throw new Error("Failed to copy to clipboard: " + (err as Error).message);
+	}
+}
+
+export function guess_delimiter(
+	text: string,
+	possibleDelimiters: string[]
+): string[] {
+	return possibleDelimiters.filter(weedOut);
+
+	function weedOut(delimiter: string): boolean {
+		var cache = -1;
+		return text.split("\n").every(checkLength);
+
+		function checkLength(line: string): boolean {
+			if (!line) return true;
+			var length = line.split(delimiter).length;
+			if (cache < 0) cache = length;
+			return cache === length && length > 1;
+		}
+	}
+}
+
+export function data_uri_to_blob(data_uri: string): Blob {
+	const byte_str = atob(data_uri.split(",")[1]);
+	const mime_str = data_uri.split(",")[0].split(":")[1].split(";")[0];
+	const ab = new ArrayBuffer(byte_str.length);
+	const ia = new Uint8Array(ab);
+	for (let i = 0; i < byte_str.length; i++) {
+		ia[i] = byte_str.charCodeAt(i);
+	}
+	return new Blob([ab], { type: mime_str });
+}
+
+export function handle_file_upload(
+	data_uri: string,
+	update_headers: (headers: Headers) => HeadersWithIDs[],
+	update_values: (values: CellValue[][]) => void
+): void {
+	const blob = data_uri_to_blob(data_uri);
+	const reader = new FileReader();
+	reader.addEventListener("loadend", (e) => {
+		if (!e?.target?.result || typeof e.target.result !== "string") return;
+		const [delimiter] = guess_delimiter(e.target.result, [",", "\t"]);
+		const [head, ...rest] = dsvFormat(delimiter).parseRows(e.target.result);
+		update_headers(head);
+		update_values(rest);
+	});
+	reader.readAsText(blob);
+}

6.11.1/dataframe/shared/utils/utils.ts

@@ -0,0 +1,58 @@
+import type { CellValue } from "../types";
+
+export type Headers = string[];
+export type Data = CellValue[][];
+
+export type Datatype =
+	| "str"
+	| "number"
+	| "bool"
+	| "date"
+	| "markdown"
+	| "html"
+	| "image";
+
+export type Metadata = {
+	[key: string]: string[][] | null;
+} | null;
+export type HeadersWithIDs = { value: string; id: string }[];
+export type DataframeValue = {
+	data: Data;
+	headers: Headers;
+	metadata?: Metadata;
+};
+
+/**
+ * Coerce a value to a given type.
+ * @param v - The value to coerce.
+ * @param t - The type to coerce to.
+ * @returns The coerced value.
+ */
+export function cast_value_to_type(v: any, t: Datatype): CellValue {
+	if (v === null || v === undefined) {
+		return v;
+	}
+	if (t === "number") {
+		const n = Number(v);
+		return isNaN(n) ? v : n;
+	}
+	if (t === "bool") {
+		if (typeof v === "boolean") return v;
+		if (typeof v === "number") return v !== 0;
+		const s = String(v).toLowerCase();
+		if (s === "true" || s === "1") return true;
+		if (s === "false" || s === "0") return false;
+		return v;
+	}
+	if (t === "date") {
+		const d = new Date(v);
+		return isNaN(d.getTime()) ? v : d.toISOString();
+	}
+	return v;
+}
+
+export interface EditData {
+	index: number | [number, number];
+	value: string;
+	previous_value: string;
+}

6.11.1/dataframe/standalone/Index.svelte

@@ -0,0 +1,741 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import Table from "../shared/Table.svelte";
+	import type { Datatype, DataframeValue } from "../shared/utils/utils";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { default_i18n } from "./default_i18n";
+
+	let {
+		i18n = undefined,
+		value = $bindable({
+			data: [["", "", ""]],
+			headers: ["1", "2", "3"],
+			metadata: null
+		}),
+		datatype = "str",
+		interactive = true,
+		show_row_numbers = false,
+		max_height = 500,
+		show_search = "none",
+		wrap = false,
+		line_breaks = true,
+		column_widths = [],
+		max_chars = undefined,
+		pinned_columns = 0,
+		static_columns = [],
+		fullscreen = $bindable(false),
+		label = null,
+		show_label = true,
+		latex_delimiters = [],
+		col_count = undefined,
+		row_count = undefined
+	}: {
+		i18n?: I18nFormatter | undefined;
+		value?: DataframeValue;
+		datatype?: Datatype | Datatype[];
+		interactive?: boolean;
+		show_row_numbers?: boolean;
+		max_height?: number;
+		show_search?: "none" | "search" | "filter";
+		wrap?: boolean;
+		line_breaks?: boolean;
+		column_widths?: string[];
+		max_chars?: number | undefined;
+		pinned_columns?: number;
+		static_columns?: (string | number)[];
+		fullscreen?: boolean;
+		label?: string | null;
+		show_label?: boolean;
+		latex_delimiters?: any[];
+		col_count?: [number, "fixed" | "dynamic"] | undefined;
+		row_count?: [number, "fixed" | "dynamic"] | undefined;
+	} = $props();
+
+	const i18n_fn = (key: string | null | undefined): string => {
+		if (!key) return "";
+		if (typeof i18n === "function") return (i18n as any)(key);
+		if (i18n && typeof i18n === "object")
+			return (i18n as any)[key] ?? default_i18n[key] ?? key;
+		return default_i18n[key] ?? key;
+	};
+
+	let resolved_row_count = $derived.by(() => {
+		if (
+			row_count &&
+			Array.isArray(row_count) &&
+			row_count.length === 2 &&
+			typeof row_count[0] === "number" &&
+			(row_count[1] === "fixed" || row_count[1] === "dynamic")
+		) {
+			return row_count as [number, "fixed" | "dynamic"];
+		}
+		return [1, "dynamic"] as [number, "fixed" | "dynamic"];
+	});
+
+	let resolved_col_count_base = $derived.by(() => {
+		if (
+			col_count &&
+			Array.isArray(col_count) &&
+			col_count.length === 2 &&
+			typeof col_count[0] === "number" &&
+			(col_count[1] === "fixed" || col_count[1] === "dynamic")
+		) {
+			return col_count as [number, "fixed" | "dynamic"];
+		}
+		const headerLength =
+			value && value.headers && typeof value.headers.length === "number"
+				? value.headers.length
+				: 3;
+		return [headerLength, "dynamic"] as [number, "fixed" | "dynamic"];
+	});
+
+	let resolved_col_count = $derived.by(() => {
+		if (
+			static_columns &&
+			static_columns.length > 0 &&
+			resolved_col_count_base[1] !== "fixed"
+		) {
+			return [resolved_col_count_base[0], "fixed"] as [
+				number,
+				"fixed" | "dynamic"
+			];
+		}
+		return resolved_col_count_base;
+	});
+
+	let root = "";
+
+	onMount(() => {
+		const handler = (e: KeyboardEvent): void => {
+			if (e.key === "Escape") {
+				fullscreen = false;
+			}
+		};
+		window.addEventListener("keydown", handler);
+		return () => window.removeEventListener("keydown", handler);
+	});
+</script>
+
+<div class="gradio-dataframe-standalone" class:fullscreen>
+	<Table
+		values={value.data}
+		headers={value.headers}
+		display_value={value?.metadata?.display_value ?? null}
+		styling={value?.metadata?.styling ?? null}
+		{datatype}
+		editable={interactive}
+		{show_row_numbers}
+		{max_height}
+		{show_search}
+		buttons={null}
+		{wrap}
+		{line_breaks}
+		{column_widths}
+		{max_chars}
+		{pinned_columns}
+		{static_columns}
+		{fullscreen}
+		{label}
+		{show_label}
+		{latex_delimiters}
+		col_count={resolved_col_count}
+		row_count={resolved_row_count}
+		{root}
+		i18n={i18n_fn}
+		onchange={(detail) => {
+			value.data = detail.data;
+			value.headers = detail.headers;
+		}}
+		onfullscreen={() => (fullscreen = !fullscreen)}
+		upload={async () => null}
+		stream_handler={() => new EventSource("about:blank")}
+	/>
+</div>
+
+<style>
+	.gradio-dataframe-standalone {
+		--gr-df-font-mono: unset;
+		--gr-df-font-sans: unset;
+		--gr-df-table-bg-even: unset;
+		--gr-df-table-bg-odd: unset;
+		--gr-df-table-border: unset;
+		--gr-df-table-radius: unset;
+
+		--gr-df-table-text: unset;
+		--gr-df-accent: unset;
+		--gr-df-accent-soft: unset;
+
+		--gr-df-input-background-fill: unset;
+		--gr-df-input-background-fill-focus: unset;
+		--gr-df-input-background-fill-hover: unset;
+		--gr-df-input-border-color: unset;
+		--gr-df-input-border-color-focus: unset;
+		--gr-df-input-placeholder-color: unset;
+		--gr-df-input-radius: unset;
+		--gr-df-input-text-size: unset;
+		--gr-df-copied-cell-color: unset;
+
+		--gr-df-checkbox-border-color: unset;
+		--gr-df-checkbox-background-color: unset;
+		--gr-df-checkbox-border-color-focus: unset;
+		--gr-df-checkbox-shadow: unset;
+		--gr-df-checkbox-border-radius: unset;
+
+		/* Dataframe-scoped defaults (only used as fallbacks) */
+		--df-font-mono: var(
+			--gr-df-font-mono,
+			"IBM Plex Mono",
+			ui-monospace,
+			Consolas,
+			monospace
+		);
+		--df-font-sans: var(
+			--gr-df-font-sans,
+			"Source Sans Pro",
+			ui-sans-serif,
+			system-ui,
+			sans-serif
+		);
+		--df-table-radius: var(--df-radius-sm, 4px);
+		--df-border-color-primary: var(--gr-df-table-border, var(--df-neutral-200));
+		--df-background-fill-primary: #ffffff;
+		--df-background-fill-secondary: #f8fafc;
+		--df-color-accent: #7c3aed;
+		--df-color-accent-soft: #f3e8ff;
+		--df-color-accent-copied: #faf5ff;
+		--df-body-text-color: #111827;
+		--df-block-background-fill: #ffffff;
+		--df-block-radius: var(--df-radius-sm, 4px);
+		--df-table-even-background-fill: #ffffff;
+		--df-table-odd-background-fill: #f9fafb;
+
+		--df-background-fill-primary-dark: var(--df-neutral-950, #0f0f11);
+		--df-background-fill-secondary-dark: var(--df-neutral-900, #18181b);
+		--df-body-text-color-dark: var(--df-neutral-100, #f4f4f5);
+		--df-block-background-fill-dark: var(--df-neutral-800, #27272a);
+		--df-table-even-background-fill-dark: var(--df-neutral-950, #0f0f11);
+		--df-table-odd-background-fill-dark: var(--df-neutral-900, #18181b);
+		--df-border-color-primary-dark: var(--df-neutral-700, #3f3f46);
+		--df-color-accent-dark: var(--df-primary-600, #ea580c);
+		--df-color-accent-soft-dark: var(--df-neutral-700, #3f3f46);
+		--df-radius-sm: 4px;
+		--df-size-1: 4px;
+		--df-size-2: 8px;
+		--df-size-4: 16px;
+		--df-size-6: 24px;
+		--df-size-8: 32px;
+		--df-size-12: 48px;
+		--df-size-3: 12px;
+		--df-size-5: 20px;
+		--df-size-7: 28px;
+		--df-size-9: 36px;
+		--df-size-10: 40px;
+		--df-size-11: 44px;
+		--df-size-14: 56px;
+		--df-size-px: 1px;
+		--df-size-full: 100%;
+		--df-text-sm: 12px;
+		--df-size-0-5: 2px;
+		--df-size-1-5: 6px;
+		--df-size-2-5: 10px;
+		--df-text-md: 14px;
+		--df-text-lg: 16px;
+		--df-radius-100: 100%;
+		--df-radius-xs: 2px;
+		--df-radius-sm: 4px;
+		--df-radius-md: 6px;
+		--df-radius-lg: 8px;
+		--df-radius-xl: 12px;
+		--df-radius-2xl: 16px;
+		--df-radius-3xl: 22px;
+		--df-input-text-size: var(--df-text-md, 14px);
+
+		--df-primary-50: #fff7ed;
+		--df-primary-100: #ffedd5;
+		--df-primary-200: #fed7aa;
+		--df-primary-300: #fdba74;
+		--df-primary-400: #fb923c;
+		--df-primary-500: #f97316;
+		--df-primary-600: #ea580c;
+
+		--df-neutral-50: #fafafa;
+		--df-neutral-100: #f4f4f5;
+		--df-neutral-200: #e4e4e7;
+		--df-neutral-300: #d4d4d8;
+		--df-neutral-400: #bbbbc2;
+		--df-neutral-500: #71717a;
+		--df-neutral-600: #52525b;
+		--df-neutral-700: #3f3f46;
+		--df-neutral-800: #27272a;
+		--df-neutral-900: #18181b;
+		--df-neutral-950: #0f0f11;
+
+		/* Secondary palette (scoped) */
+		--df-secondary-50: #eff6ff;
+		--df-secondary-100: #dbeafe;
+		--df-secondary-200: #bfdbfe;
+		--df-secondary-300: #93c5fd;
+		--df-secondary-400: #60a5fa;
+		--df-secondary-500: #3b82f6;
+
+		--neutral-50: var(--df-neutral-50, #f9fafb);
+		--neutral-100: var(--df-neutral-100, #f3f4f6);
+		--neutral-200: var(--df-neutral-200, #e5e7eb);
+		--neutral-300: var(--df-neutral-300, #d1d5db);
+		--neutral-400: var(--df-neutral-400, #9ca3af);
+		--neutral-500: var(--df-neutral-500, #6b7280);
+		--neutral-600: var(--df-neutral-600, #4b5563);
+		--neutral-700: var(--df-neutral-700, #374151);
+		--neutral-800: var(--df-neutral-800, #1f2937);
+		--neutral-900: var(--df-neutral-900, #111827);
+		--neutral-950: var(--df-neutral-950, #0b0f19);
+
+		--secondary-50: var(--df-secondary-50, #eff6ff);
+		--secondary-100: var(--df-secondary-100, #dbeafe);
+		--secondary-200: var(--df-secondary-200, #bfdbfe);
+
+		--df-spacing-xxs: 1px;
+		--df-spacing-xs: 2px;
+		--df-spacing-sm: 4px;
+		--df-spacing-md: 6px;
+		--df-spacing-lg: 8px;
+		--df-spacing-xl: 10px;
+		--df-spacing-xxl: 16px;
+
+		--df-radius-xxs: 1px;
+		--df-radius-xxl: 22px;
+
+		--df-text-xxs: 9px;
+		--df-text-xs: 10px;
+		--df-text-xl: 22px;
+		--df-text-xxl: 26px;
+
+		--df-body-background-fill: var(
+			--df-background-fill-primary,
+			var(--background-fill-primary, #ffffff)
+		);
+		--df-body-text-color: var(--gr-df-table-text, --df-neutral-800);
+		--df-body-text-size: var(--df-text-md, 14px);
+		--df-body-text-weight: 400;
+
+		--df-color-accent: var(--df-primary-500, #f97316);
+		--df-color-accent-soft: var(--df-primary-50, #fff7ed);
+		--df-background-fill-primary: white;
+		--df-background-fill-secondary: var(--df-neutral-50, #f9fafb);
+		--df-border-color-accent: var(--df-primary-300, #fdba74);
+		--df-body-text-color-subdued: var(--df-neutral-400, #9ca3af);
+		--df-table-text-color: var(--df-body-text-color, #111827);
+		--df-shadow-drop: rgba(0, 0, 0, 0.05) 0px 1px 2px 0px;
+		--df-shadow-drop-lg:
+			0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);
+		--df-shadow-inset: rgba(0, 0, 0, 0.05) 0px 2px 4px 0px inset;
+		--df-shadow-spread: 3px;
+
+		--df-bw-svt-p-top: 0px;
+		--df-bw-svt-p-bottom: 0px;
+
+		--df-border-color-secondary: var(--df-border-color-accent, #fdba74);
+		--df-shadow-md:
+			0 12px 16px -4px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+
+		--df-checkbox-border-radius: var(--df-radius-sm, 4px);
+		--df-checkbox-shadow: none;
+		--df-checkbox-border-color: var(--df-neutral-300, #d4d4d8);
+		--df-checkbox-background-color: var(--df-background-fill-primary, #ffffff);
+		--df-checkbox-background-color-selected: var(
+			--df-color-accent,
+			var(--color-accent)
+		);
+		--df-checkbox-border-color-focus: var(--df-color-accent, #f97316);
+		--df-button-transition: none;
+		--df-block-background-fill: var(--df-background-fill-primary, white);
+		--df-block-border-color: var(
+			--df-border-color-primary,
+			var(--df-neutral-200, #e5e7eb)
+		);
+		--df-block-border-width: 1px;
+		--df-input-text-size: 0.95rem;
+		--df-line-md: 1.5;
+		--df-line-lg: 1.75;
+
+		--df-input-background-fill: var(--df-background-fill-primary, #ffffff);
+		--df-input-background-fill-focus: var(
+			--df-input-background-fill,
+			var(--df-background-fill-primary, #ffffff)
+		);
+		--df-input-background-fill-hover: var(
+			--df-input-background-fill,
+			var(--df-background-fill-primary, #ffffff)
+		);
+		--df-input-border-color: var(--df-border-color-primary, #e5e7eb);
+		--df-input-border-color-focus: var(--secondary-300, #93c5fd);
+		--df-input-border-color-hover: var(
+			--df-input-border-color,
+			var(--df-border-color-primary, #e5e7eb)
+		);
+		--df-input-border-width: 1px;
+		--df-input-padding: var(--df-spacing-xl, 10px);
+		--df-input-placeholder-color: var(--neutral-400, #9ca3af);
+		--df-input-radius: var(--df-radius-sm, 4px);
+		--df-input-shadow: none;
+		--df-input-shadow-focus:
+			0 0 0 var(--shadow-spread, 3px) var(--secondary-50, #eff6ff),
+			var(--shadow-inset, rgba(0, 0, 0, 0.05) 0px 2px 4px 0px inset);
+
+		--table-radius: var(--gr-df-table-radius, var(--df-table-radius, 4px));
+		--table-row-hover: var(--gr-df-table-row-hover, var(--color-accent-soft));
+		--cell-padding: var(--gr-df-cell-padding, var(--size-2));
+		--df-font-size: var(--gr-df-font-size, var(--text-md));
+		--background-fill-primary: var(--df-background-fill-primary, #ffffff);
+		--background-fill-primary-dark: var(
+			--df-background-fill-primary-dark,
+			var(--neutral-950, #0f0f11)
+		);
+		--background-fill-secondary: var(--df-background-fill-secondary, #f8fafc);
+		--background-fill-secondary-dark: var(
+			--df-background-fill-secondary-dark,
+			var(--neutral-900, #18181b)
+		);
+		--color-accent: var(--gr-df-accent, var(--df-color-accent, #7c3aed));
+		--color-accent-soft: var(
+			--gr-df-accent-soft,
+			var(--df-color-accent-soft, #f3e8ff)
+		);
+		--color-accent-copied: var(
+			--gr-df-copied-cell-color,
+			var(--color-accent-soft)
+		);
+		--body-text-color: var(--df-body-text-color, #111827);
+		--block-background-fill: var(
+			--df-block-background-fill,
+			var(--background-fill-primary)
+		);
+		--block-radius: var(--df-block-radius, var(--radius-sm, 4px));
+		--table-even-background-fill: var(
+			--gr-df-table-bg-even,
+			var(--df-table-even-background-fill, #ffffff)
+		);
+		--table-odd-background-fill: var(
+			--gr-df-table-bg-odd,
+			var(--df-table-odd-background-fill, #f9fafb)
+		);
+		--border-color-primary: var(--df-border-color-primary, #e5e7eb);
+		--radius-sm: var(--df-radius-sm, 4px);
+		--size-1: var(--df-size-1, 4px);
+		--size-2: var(--df-size-2, 8px);
+		--size-3: var(--df-size-3, 12px);
+		--size-4: var(--df-size-4, 16px);
+		--size-5: var(--df-size-5, 20px);
+		--size-6: var(--df-size-6, 24px);
+		--size-7: var(--df-size-7, 28px);
+		--size-8: var(--df-size-8, 32px);
+		--size-9: var(--df-size-9, 36px);
+		--size-10: var(--df-size-10, 40px);
+		--size-11: var(--df-size-11, 44px);
+		--size-12: var(--df-size-12, 48px);
+		--size-14: var(--df-size-14, 56px);
+		--size-16: var(--df-size-16, 64px);
+		--size-20: var(--df-size-20, 80px);
+		--size-24: var(--df-size-24, 96px);
+
+		--size-px: var(--df-size-px, 1px);
+		--size-full: var(--df-size-full, 100%);
+		--size-0-5: var(--df-size-0-5, 2px);
+		--size-1-5: var(--df-size-1-5, 6px);
+		--size-2-5: var(--df-size-2-5, 10px);
+		--input-text-size: var(--df-input-text-size, 0.95rem);
+		--text-sm: var(--df-text-sm, 12px);
+		--text-md: var(--df-text-md, 14px);
+		--text-lg: var(--df-text-lg, 16px);
+		--text-xl: var(--df-text-xl, 22px);
+		--text-xxl: var(--df-text-xxl, 26px);
+
+		--spacing-xxs: var(--df-spacing-xxs, 1px);
+		--spacing-xs: var(--df-spacing-xs, 2px);
+		--spacing-sm: var(--df-spacing-sm, 4px);
+		--spacing-md: var(--df-spacing-md, 6px);
+		--spacing-lg: var(--df-spacing-lg, 8px);
+		--spacing-xl: var(--df-spacing-xl, 10px);
+		--spacing-xxl: var(--df-spacing-xxl, 16px);
+
+		--radius-xxs: var(--df-radius-xxs, 1px);
+		--radius-xs: var(--df-radius-xs, 2px);
+		--radius-sm: var(--df-radius-sm, 4px);
+		--radius-md: var(--df-radius-md, 6px);
+		--radius-lg: var(--df-radius-lg, 8px);
+		--radius-xl: var(--df-radius-xl, 12px);
+		--radius-2xl: var(--df-radius-2xl, 16px);
+		--radius-3xl: var(--df-radius-3xl, 22px);
+		--radius-full: var(--df-radius-full, 9999px);
+		--font-mono: var(--df-font-mono, "Courier New", Courier, monospace);
+		--font-sans: var(
+			--df-font-sans,
+			"Source Sans Pro",
+			ui-sans-serif,
+			system-ui,
+			sans-serif
+		);
+
+		--input-background-fill: var(
+			--gr-df-input-background-fill,
+			var(--df-input-background-fill, var(--background-fill-primary, #ffffff))
+		);
+		--input-background-fill-focus: var(
+			--gr-df-input-background-fill-focus,
+			var(
+				--df-input-background-fill-focus,
+				var(--input-background-fill, var(--background-fill-primary, #ffffff))
+			)
+		);
+		--input-background-fill-hover: var(
+			--gr-df-input-background-fill-hover,
+			var(
+				--df-input-background-fill-hover,
+				var(--input-background-fill, var(--background-fill-primary, #ffffff))
+			)
+		);
+		--input-border-color: var(
+			--gr-df-input-border-color,
+			var(--df-input-border-color, var(--border-color-primary, #e5e7eb))
+		);
+		--input-border-color-focus: var(
+			--gr-df-input-border-color-focus,
+			var(--df-input-border-color-focus, var(--secondary-300, #93c5fd))
+		);
+		--input-border-color-hover: var(
+			--gr-df-input-border-color-hover,
+			var(
+				--df-input-border-color-hover,
+				var(--input-border-color, var(--border-color-primary, #e5e7eb))
+			)
+		);
+		--input-border-width: var(
+			--gr-df-input-border-width,
+			var(--df-input-border-width, 1px)
+		);
+
+		--weight-bold: var(--df-weight-bold, 700);
+		--weight-semibold: var(--df-weight-semibold, 600);
+		--checkbox-border-radius: var(
+			--gr-df-checkbox-border-radius,
+			var(--df-checkbox-border-radius, var(--df-radius-sm, 4px))
+		);
+		--checkbox-shadow: var(
+			--gr-df-checkbox-shadow,
+			var(--df-checkbox-shadow, none)
+		);
+		--checkbox-border-color: var(
+			--gr-df-checkbox-border-color,
+			var(--df-checkbox-border-color, var(--df-neutral-300, #d4d4d8))
+		);
+		--checkbox-background-color: var(
+			--gr-df-checkbox-background-color,
+			var(
+				--df-checkbox-background-color,
+				var(--df-background-fill-primary, #ffffff)
+			)
+		);
+		--checkbox-background-color-selected: var(
+			--gr-df-checkbox-background-color,
+			var(--df-checkbox-background-color-selected, var(--color-accent))
+		);
+		--checkbox-border-color-focus: var(
+			--gr-df-checkbox-border-color-focus,
+			var(--df-checkbox-border-color-focus, var(--df-color-accent, #f97316))
+		);
+		--checkbox-check: url("data:image/svg+xml,%3csvg viewBox='0 0 16 16' fill='white' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M12.207 4.793a1 1 0 010 1.414l-5 5a1 1 0 01-1.414 0l-2-2a1 1 0 011.414-1.414L6.5 9.086l4.293-4.293a1 1 0 011.414 0z'/%3e%3c/svg%3e");
+		--button-transition: var(--df-button-transition, none);
+		--max-height: var(--df-max-height, 500px);
+		--df-layer-1: 10;
+		--df-layer-2: 20;
+		--df-layer-3: 30;
+		--df-layer-4: 40;
+		--df-layer-5: 50;
+		--df-layer-below: -1;
+		--df-layer-top: 2147483647;
+
+		--layer-1: var(--df-layer-1, 10);
+		--layer-2: var(--df-layer-2, 20);
+		--layer-3: var(--df-layer-3, 30);
+		--layer-4: var(--df-layer-4, 40);
+		--layer-5: var(--df-layer-5, 50);
+		--layer-below: var(--df-layer-below, -1);
+		--layer-top: var(--df-layer-top, 2147483647);
+
+		--line-md: var(--df-line-md, 1.5);
+		--line-lg: var(--df-line-lg, 1.75);
+
+		--shadow-xs:
+			0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px 0 rgba(0, 0, 0, 0.06);
+		--shadow-sm:
+			0 4px 6px -2px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.06);
+		--shadow-md:
+			0 12px 16px -4px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+		--shadow-lg:
+			0 20px 24px -4px rgba(0, 0, 0, 0.1), 0 8px 8px -4px rgba(0, 0, 0, 0.04);
+		--shadow-drop: rgba(0, 0, 0, 0.05) 0px 1px 2px 0px;
+		--shadow-drop-lg:
+			0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);
+		--shadow-inset: rgba(0, 0, 0, 0.05) 0px 2px 4px 0px inset;
+		--shadow-spread: 3px;
+	}
+
+	.gradio-dataframe-standalone.fullscreen {
+		position: fixed;
+		top: 0;
+		left: 0;
+		width: 100vw;
+		height: 100vh;
+		z-index: 1000;
+		overflow: auto;
+		border-radius: 0;
+		background-color: var(--block-background-fill);
+	}
+
+	:global(.dark) .gradio-dataframe-standalone {
+		--df-background-fill-primary: var(--df-background-fill-primary-dark);
+		--df-background-fill-secondary: var(--df-background-fill-secondary-dark);
+		--df-body-text-color: var(--df-body-text-color-dark);
+		--df-block-background-fill: var(--df-block-background-fill-dark);
+		--df-table-even-background-fill: var(--df-table-even-background-fill-dark);
+		--df-table-odd-background-fill: var(--df-table-odd-background-fill-dark);
+		--df-border-color-primary: var(--df-border-color-primary-dark);
+		--df-color-accent: var(--df-color-accent-dark);
+		--df-color-accent-soft: var(--df-color-accent-soft-dark);
+	}
+
+	:global(.gradio-container),
+	:global(*),
+	:global(::before),
+	:global(::after) {
+		box-sizing: border-box;
+		border-width: 0;
+		border-style: solid;
+	}
+
+	:global(.gradio-container) :global(textarea) {
+		padding-top: var(--input-padding, var(--df-input-padding, 10px));
+		padding-bottom: var(--input-padding, var(--df-input-padding, 10px));
+		box-sizing: border-box;
+	}
+
+	:global(button),
+	:global(input),
+	:global(select),
+	:global(textarea) {
+		margin: 0;
+		padding: 0;
+		color: inherit;
+		font-weight: inherit;
+		font-size: 100%;
+		line-height: inherit;
+		font-family: inherit;
+	}
+
+	:global([type="text"]),
+	:global([type="url"]),
+	:global([type="number"]),
+	:global([multiple]),
+	:global(textarea),
+	:global(select) {
+		--tw-shadow: 0 0 #0000;
+		appearance: none;
+		border-width: 1px;
+		border-color: #6b7280;
+		border-radius: 0px;
+		background-color: #fff;
+		padding-top: 0.5rem;
+		padding-right: 0.75rem;
+		padding-bottom: 0.5rem;
+		padding-left: 0.75rem;
+		font-size: 1rem;
+		line-height: 1.5rem;
+	}
+
+	:global(button),
+	:global(input[type="button"]),
+	:global(input[type="submit"]) {
+		-webkit-appearance: button;
+		appearance: button;
+		background-image: none;
+		background-color: transparent;
+	}
+
+	:global(.sr-only) {
+		clip: rect(0, 0, 0, 0);
+		position: absolute;
+		margin: -1px;
+		border-width: 0;
+		padding: 0;
+		width: 1px;
+		height: 1px;
+		overflow: hidden;
+		white-space: nowrap;
+	}
+
+	:global(input[type="checkbox"]) {
+		accent-color: var(--color-accent);
+	}
+
+	:global(label) {
+		display: flex;
+		align-items: center;
+		transition: all 0.15s ease;
+		cursor: pointer;
+		/* default label color */
+		color: #111111;
+		font-weight: 400;
+		font-size: 14px;
+		line-height: 1.5;
+	}
+
+	:global(label) > * + * {
+		margin-left: 8px;
+	}
+
+	:global(input) {
+		--ring-color: transparent;
+		position: relative;
+		/* default shadow */
+		box-shadow: none;
+		border: 1px solid #888888;
+		border-radius: 6px;
+		background-color: #ffffff;
+		line-height: 1;
+	}
+
+	:global(input:checked),
+	:global(input:checked:hover),
+	:global(input:checked:focus) {
+		/* checked state: orange */
+		background-image: none;
+		background-color: #f97316;
+		border-color: #f97316;
+	}
+
+	:global(input:checked:focus) {
+		background-image: none;
+		background-color: #f97316;
+		border-color: #f97316;
+	}
+
+	:global(input:hover) {
+		border-color: #1e90ff;
+		background-color: #e6f0ff;
+	}
+
+	:global(input:focus) {
+		border-color: #f97316;
+		background-color: #fff4e6;
+	}
+
+	:global(input[disabled]),
+	:global(.disabled) {
+		cursor: not-allowed !important;
+		opacity: 0.6;
+	}
+
+	:global(input:hover) {
+		cursor: pointer;
+	}
+</style>

6.11.1/dataframe/standalone/default_i18n.ts

@@ -0,0 +1,32 @@
+export const default_i18n: Record<string, string> = {
+	"dataframe.add_row_above": "Add row above",
+	"dataframe.add_row_below": "Add row below",
+	"dataframe.delete_row": "Delete row",
+	"dataframe.add_column_left": "Add column left",
+	"dataframe.add_column_right": "Add column right",
+	"dataframe.delete_column": "Delete column",
+	"dataframe.sort_asc": "Sort ascending",
+	"dataframe.sort_desc": "Sort descending",
+	"dataframe.sort_ascending": "Sort ascending",
+	"dataframe.sort_descending": "Sort descending",
+	"dataframe.clear_sort": "Clear sort",
+	"dataframe.filter": "Filter",
+	"dataframe.clear_filter": "Clear filter",
+	"dataframe.copy": "Copy",
+	"dataframe.paste": "Paste",
+	"dataframe.cut": "Cut",
+	"dataframe.select_all": "Select all",
+	"dataframe.fullscreen": "Fullscreen",
+	"dataframe.exit_fullscreen": "Exit fullscreen",
+	"dataframe.search": "Search",
+	"dataframe.export": "Export",
+	"dataframe.import": "Import",
+	"dataframe.edit": "Edit",
+	"dataframe.save": "Save",
+	"dataframe.cancel": "Cancel",
+	"dataframe.confirm": "Confirm",
+	"dataframe.reset": "Reset",
+	"dataframe.clear": "Clear",
+	"dataframe.undo": "Undo",
+	"dataframe.redo": "Redo"
+};

6.11.1/dataframe/standalone/stubs/Upload.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+	export const aria_label = "";
+	export const root = "";
+	export const upload: any = null;
+	export const stream_handler: any = null;
+</script>
+
+<div>
+	<slot />
+</div>
+
+<style>
+	div {
+		width: 100%;
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--table-radius);
+		overflow: hidden;
+	}
+</style>

6.11.1/dataframe/standalone/stubs/upload.ts

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

6.11.1/dataframe/types.ts

@@ -0,0 +1,34 @@
+import type { SelectData } from "@gradio/utils";
+import type { LoadingStatus } from "@gradio/statustracker";
+import type { DataframeValue, Datatype, EditData } from "./shared/utils/utils";
+
+export interface DataframeEvents {
+	change: DataframeValue;
+	input: never;
+	select: SelectData;
+	edit: EditData;
+	clear_status: LoadingStatus;
+}
+
+export interface DataframeProps {
+	value: DataframeValue;
+	col_count: [number, "fixed" | "dynamic"];
+	row_count: [number, "fixed" | "dynamic"];
+	wrap: boolean;
+	datatype: Datatype | Datatype[];
+	line_breaks: boolean;
+	column_widths: string[];
+	latex_delimiters: {
+		left: string;
+		right: string;
+		display: boolean;
+	}[];
+	max_height: number;
+	buttons: string[] | null;
+	max_chars: number | undefined;
+	show_row_numbers: boolean;
+	show_search: "none" | "search" | "filter";
+	pinned_columns: number;
+	static_columns: (string | number)[];
+	fullscreen: boolean;
+}