Upload folder using huggingface_hub

5.49.1/dataframe/Example.svelte

@@ -0,0 +1,114 @@
+<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="">
+				<tr>
+					<td>Empty</td>
+				</tr>
+			</table>
+		{:else}
+			<table class="">
+				{#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}
+			</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>

5.49.1/dataframe/Index.svelte

@@ -0,0 +1,123 @@
+<svelte:options accessors={true} />
+
+<script context="module" lang="ts">
+	export { default as BaseDataFrame } from "./shared/Table.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio, SelectData } from "@gradio/utils";
+	import { Block } from "@gradio/atoms";
+	import Table from "./shared/Table.svelte";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import type { Datatype, DataframeValue } from "./shared/utils/utils";
+	import Image from "@gradio/image";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible: boolean | "hidden" = true;
+	export let value: DataframeValue = {
+		data: [["", "", ""]],
+		headers: ["1", "2", "3"],
+		metadata: null
+	};
+	export let value_is_output = false;
+	export let col_count: [number, "fixed" | "dynamic"];
+	export let row_count: [number, "fixed" | "dynamic"];
+	export let label: string | null = null;
+	export let show_label = true;
+	export let wrap: boolean;
+	export let datatype: Datatype | Datatype[];
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let root: string;
+
+	export let line_breaks = true;
+	export let column_widths: string[] = [];
+	export let gradio: Gradio<{
+		change: never;
+		select: SelectData;
+		input: never;
+		clear_status: LoadingStatus;
+		search: string | null;
+		edit: SelectData;
+	}>;
+	export let latex_delimiters: {
+		left: string;
+		right: string;
+		display: boolean;
+	}[];
+	export let max_height: number | undefined = undefined;
+	export let loading_status: LoadingStatus;
+	export let interactive: boolean;
+	export let show_fullscreen_button = false;
+	export let max_chars: number | undefined = undefined;
+	export let show_copy_button = false;
+	export let show_row_numbers = false;
+	export let show_search: "none" | "search" | "filter" = "none";
+	export let pinned_columns = 0;
+	export let static_columns: (string | number)[] = [];
+	export let fullscreen = false;
+</script>
+
+<Block
+	{visible}
+	padding={false}
+	{elem_id}
+	{elem_classes}
+	container={false}
+	{scale}
+	{min_width}
+	overflow_behavior="visible"
+	bind:fullscreen
+>
+	<StatusTracker
+		autoscroll={gradio.autoscroll}
+		i18n={gradio.i18n}
+		{...loading_status}
+		on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+	<Table
+		{root}
+		{label}
+		{show_label}
+		{row_count}
+		{col_count}
+		values={value.data}
+		display_value={value.metadata?.display_value}
+		styling={value.metadata?.styling}
+		headers={value.headers}
+		{fullscreen}
+		on:change={(e) => {
+			value.data = e.detail.data;
+			value.headers = e.detail.headers;
+			gradio.dispatch("change");
+		}}
+		on:input={(e) => gradio.dispatch("input")}
+		on:select={(e) => gradio.dispatch("select", e.detail)}
+		on:edit={(e) => gradio.dispatch("edit", e.detail)}
+		on:fullscreen={({ detail }) => {
+			fullscreen = detail;
+		}}
+		{wrap}
+		{datatype}
+		{latex_delimiters}
+		editable={interactive}
+		{max_height}
+		i18n={gradio.i18n}
+		{line_breaks}
+		{column_widths}
+		upload={(...args) => gradio.client.upload(...args)}
+		stream_handler={(...args) => gradio.client.stream(...args)}
+		bind:value_is_output
+		{show_fullscreen_button}
+		{max_chars}
+		{show_copy_button}
+		{show_row_numbers}
+		{show_search}
+		{pinned_columns}
+		components={{ image: Image }}
+		{static_columns}
+	/>
+</Block>

5.49.1/dataframe/package.json

@@ -0,0 +1,50 @@
+{
+	"name": "@gradio/dataframe",
+	"version": "0.20.1",
+	"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/icons": "workspace:^",
+		"@gradio/markdown-code": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@types/d3-dsv": "^3.0.0",
+		"@types/katex": "^0.16.0",
+		"d3-dsv": "^3.0.1",
+		"dequal": "^2.0.2"
+	},
+	"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": ">=4.0.0 <6.0.0"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/dataframe"
+	}
+}

5.49.1/dataframe/shared/BooleanCell.svelte

@@ -0,0 +1,49 @@
+<script lang="ts">
+	import { BaseCheckbox } from "@gradio/checkbox";
+
+	export let value = false;
+	export let editable = true;
+	export let on_change: (value: boolean) => void;
+
+	function handle_change(event: CustomEvent<boolean>): void {
+		if (editable) {
+			on_change(event.detail);
+		}
+	}
+</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>

5.49.1/dataframe/shared/CellMenu.svelte

@@ -0,0 +1,253 @@
+<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 "./context/dataframe_context";
+
+	export let x: number;
+	export let y: number;
+	export let on_add_row_above: () => void;
+	export let on_add_row_below: () => void;
+	export let on_add_column_left: () => void;
+	export let on_add_column_right: () => void;
+	export let row: number;
+	export let col_count: [number, "fixed" | "dynamic"];
+	export let row_count: [number, "fixed" | "dynamic"];
+	export let on_delete_row: () => void;
+	export let on_delete_col: () => void;
+	export let can_delete_rows: boolean;
+	export let can_delete_cols: boolean;
+	export let on_sort: (direction: SortDirection) => void = () => {};
+	export let on_clear_sort: () => void = () => {};
+	export let sort_direction: SortDirection | null = null;
+	export let sort_priority: number | null = null;
+	export let on_filter: (
+		datatype: FilterDatatype,
+		selected_filter: string,
+		value: string
+	) => void = () => {};
+	export let on_clear_filter: () => void = () => {};
+	export let filter_active: boolean | null = null;
+	export let editable = true;
+
+	export let i18n: I18nFormatter;
+	let menu_element: HTMLDivElement;
+	let active_filter_menu: { x: number; y: number } | null = null;
+
+	$: is_header = row === -1;
+	$: can_add_rows = editable && row_count[1] === "dynamic";
+	$: can_add_columns = 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"
+			on:click={() => 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"
+			on:click={() => 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" on:click={on_clear_sort}>
+			<CellMenuIcons icon="clear-sort" />
+			{i18n("dataframe.clear_sort")}
+		</button>
+		<button
+			role="menuitem"
+			on:click|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" on:click={on_clear_filter}>
+			<CellMenuIcons icon="clear-filter" />
+			{i18n("dataframe.clear_filter")}
+		</button>
+	{/if}
+
+	{#if !is_header && can_add_rows}
+		<button
+			role="menuitem"
+			on:click={() => on_add_row_above()}
+			aria-label="Add row above"
+		>
+			<CellMenuIcons icon="add-row-above" />
+			{i18n("dataframe.add_row_above")}
+		</button>
+		<button
+			role="menuitem"
+			on:click={() => 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"
+				on:click={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"
+			on:click={() => 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"
+			on:click={() => 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"
+				on:click={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: 9;
+		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;
+		z-index: var(--layer-1);
+	}
+
+	.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>

5.49.1/dataframe/shared/CellMenuButton.svelte

@@ -0,0 +1,46 @@
+<script lang="ts">
+	export let on_click: (event: MouseEvent) => void;
+</script>
+
+<button
+	aria-label="Open cell menu"
+	class="cell-menu-button"
+	aria-haspopup="menu"
+	on:click={on_click}
+	on:touchstart={(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>

5.49.1/dataframe/shared/CellMenuIcons.svelte

@@ -0,0 +1,240 @@
+<script lang="ts">
+	export let icon: string;
+</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}

5.49.1/dataframe/shared/EditableCell.svelte

@@ -0,0 +1,261 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	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";
+
+	export let edit: boolean;
+	export let value: CellValue = "";
+	export let display_value: string | null = null;
+	export let styling = "";
+	export let header = false;
+	export let datatype:
+		| "str"
+		| "markdown"
+		| "html"
+		| "number"
+		| "bool"
+		| "date"
+		| "image" = "str";
+	export let latex_delimiters: {
+		left: string;
+		right: string;
+		display: boolean;
+	}[];
+	export let line_breaks = true;
+	export let editable = true;
+	export let is_static = false;
+	export let max_chars: number | null = null;
+	export let components: Record<string, any> = {};
+	export let i18n: I18nFormatter;
+	export let is_dragging = false;
+	export let wrap_text = false;
+
+	export let show_selection_buttons = false;
+	export let coords: [number, number];
+	export let on_select_column: ((col: number) => void) | null = null;
+	export let on_select_row: ((row: number) => void) | null = null;
+	export let el: HTMLTextAreaElement | null;
+
+	const dispatch = createEventDispatcher<{
+		blur: { blur_event: FocusEvent; coords: [number, number] };
+		keydown: KeyboardEvent;
+	}>();
+
+	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) + "...";
+	}
+
+	$: should_truncate = !edit && max_chars !== null && max_chars > 0;
+
+	$: display_content = editable
+		? value
+		: display_value !== null
+			? display_value
+			: value;
+
+	$: display_text = 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 {
+		dispatch("blur", {
+			blur_event: event,
+			coords: coords
+		});
+	}
+
+	function handle_keydown(event: KeyboardEvent): void {
+		dispatch("keydown", event);
+	}
+
+	function commit_change(checked: boolean): void {
+		handle_blur({ target: { value } } as unknown as FocusEvent);
+	}
+
+	$: 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"
+		on:blur={handle_blur}
+		on:mousedown|stopPropagation
+		on:click|stopPropagation
+		use:use_focus
+		on:keydown={handle_keydown}
+	/>
+{/if}
+
+{#if datatype === "bool" && typeof value === "boolean"}
+	<BooleanCell bind:value {editable} on_change={commit_change} />
+{:else}
+	<span
+		class:dragging={is_dragging}
+		on:keydown={handle_keydown}
+		tabindex="0"
+		role="button"
+		class:edit
+		class:expanded={edit}
+		class:multiline={header}
+		on:focus|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}
+			<svelte:component
+				this={components.image}
+				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: inline-block;
+		outline: none;
+		-webkit-user-select: text;
+		-moz-user-select: text;
+		-ms-user-select: text;
+		user-select: text;
+		cursor: text;
+		width: 100%;
+		height: 100%;
+		overflow: hidden;
+	}
+
+	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>

5.49.1/dataframe/shared/EmptyRowButton.svelte

@@ -0,0 +1,29 @@
+<script lang="ts">
+	export let on_click: () => void;
+</script>
+
+<button class="add-row-button" on:click={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>

5.49.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>

5.49.1/dataframe/shared/FilterMenu.svelte

@@ -0,0 +1,247 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import { Check, DropdownArrow } from "@gradio/icons";
+	import type { FilterDatatype } from "./context/dataframe_context";
+
+	export let on_filter: (
+		datatype: FilterDatatype,
+		selected_filter: string,
+		value: string
+	) => void = () => {};
+
+	let menu_element: HTMLDivElement;
+	let datatype: "string" | "number" = "string";
+	let current_filter = "Contains";
+	let filter_dropdown_open = false;
+	let filter_input_value = "";
+
+	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
+				on:click|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
+					on:click|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
+								on:click|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}
+				on:click|stopPropagation
+				on:input={handle_filter_input}
+				placeholder="Type a value"
+				class="filter-input"
+			/>
+		</div>
+
+		<button
+			class="check-button"
+			on:click={() => 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>

5.49.1/dataframe/shared/RowNumber.svelte

@@ -0,0 +1,32 @@
+<script lang="ts">
+	export let index: number | null = null;
+	export let is_header = false;
+</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>

5.49.1/dataframe/shared/Table.svelte

@@ -0,0 +1,1270 @@
+<script lang="ts" context="module">
+	import {
+		create_dataframe_context,
+		type SortDirection,
+		type FilterDatatype
+	} from "./context/dataframe_context";
+</script>
+
+<script lang="ts">
+	import { afterUpdate, createEventDispatcher, tick, onMount } from "svelte";
+	import { dequal } from "dequal/lite";
+	import { Upload } from "@gradio/upload";
+
+	import EditableCell from "./EditableCell.svelte";
+	import RowNumber from "./RowNumber.svelte";
+	import TableHeader from "./TableHeader.svelte";
+	import TableCell from "./TableCell.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 VirtualTable from "./VirtualTable.svelte";
+	import type {
+		Headers,
+		DataframeValue,
+		Datatype,
+		EditData
+	} from "./utils/utils";
+	import CellMenu from "./CellMenu.svelte";
+	import Toolbar from "./Toolbar.svelte";
+	import type { CellCoordinate, CellValue } from "./types";
+	import {
+		is_cell_selected,
+		should_show_cell_menu,
+		get_current_indices,
+		handle_click_outside as handle_click_outside_util,
+		calculate_selection_positions
+	} from "./utils/selection_utils";
+	import {
+		copy_table_data,
+		get_max,
+		handle_file_upload
+	} from "./utils/table_utils";
+	import { make_headers, process_data } from "./utils/data_processing";
+	import { handle_keydown, handle_cell_blur } from "./utils/keyboard_utils";
+	import {
+		create_drag_handlers,
+		type DragState,
+		type DragHandlers
+	} from "./utils/drag_utils";
+	import { sort_data_and_preserve_selection } from "./utils/sort_utils";
+	import { filter_data_and_preserve_selection } from "./utils/filter_utils";
+
+	export let datatype: Datatype | Datatype[];
+	export let label: string | null = null;
+	export let show_label = true;
+	export let headers: Headers = [];
+	export let values: CellValue[][] = [];
+	export let col_count: [number, "fixed" | "dynamic"];
+	export let row_count: [number, "fixed" | "dynamic"];
+	export let latex_delimiters: {
+		left: string;
+		right: string;
+		display: boolean;
+	}[];
+	export let components: Record<string, any> = {};
+
+	export let editable = true;
+	export let wrap = false;
+	export let root: string;
+	export let i18n: I18nFormatter;
+
+	export let max_height = 500;
+	export let line_breaks = true;
+	export let column_widths: string[] = [];
+	export let show_row_numbers = false;
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let show_fullscreen_button = false;
+	export let show_copy_button = false;
+	export let value_is_output = false;
+	export let max_chars: number | undefined = undefined;
+	export let show_search: "none" | "search" | "filter" = "none";
+	export let pinned_columns = 0;
+	export let static_columns: (string | number)[] = [];
+	export let fullscreen = false;
+
+	const df_ctx = create_dataframe_context({
+		show_fullscreen_button,
+		show_copy_button,
+		show_search,
+		show_row_numbers,
+		editable,
+		pinned_columns,
+		show_label,
+		line_breaks,
+		wrap,
+		max_height,
+		column_widths,
+		max_chars,
+		static_columns
+	});
+
+	const { state: df_state, actions: df_actions } = df_ctx;
+
+	$: selected_cells = $df_state.ui_state.selected_cells;
+	$: selected = $df_state.ui_state.selected;
+	$: editing = $df_state.ui_state.editing;
+	$: header_edit = $df_state.ui_state.header_edit;
+	$: selected_header = $df_state.ui_state.selected_header;
+	$: active_cell_menu = $df_state.ui_state.active_cell_menu;
+	$: active_header_menu = $df_state.ui_state.active_header_menu;
+	$: copy_flash = $df_state.ui_state.copy_flash;
+
+	$: actual_pinned_columns =
+		pinned_columns && data?.[0]?.length
+			? Math.min(pinned_columns, data[0].length)
+			: 0;
+
+	onMount(() => {
+		df_ctx.parent_element = parent;
+		df_ctx.get_data_at = get_data_at;
+		df_ctx.get_column = get_column;
+		df_ctx.get_row = get_row;
+		df_ctx.dispatch = dispatch;
+		init_drag_handlers();
+
+		const observer = new IntersectionObserver((entries) => {
+			entries.forEach((entry) => {
+				if (entry.isIntersecting && !is_visible) {
+					width_calculated = false;
+				}
+				is_visible = entry.isIntersecting;
+			});
+		});
+		observer.observe(parent);
+		document.addEventListener("click", handle_click_outside);
+		window.addEventListener("resize", handle_resize);
+
+		const global_mouse_up = (event: MouseEvent): void => {
+			if (is_dragging || drag_start) {
+				handle_mouse_up(event);
+			}
+		};
+		document.addEventListener("mouseup", global_mouse_up);
+
+		return () => {
+			observer.disconnect();
+			document.removeEventListener("click", handle_click_outside);
+			window.removeEventListener("resize", handle_resize);
+			document.removeEventListener("mouseup", global_mouse_up);
+		};
+	});
+
+	$: {
+		if (data || _headers || els) {
+			df_ctx.data = data;
+			df_ctx.headers = _headers;
+			df_ctx.els = els;
+			df_ctx.display_value = display_value;
+			df_ctx.styling = styling;
+		}
+	}
+
+	const dispatch = createEventDispatcher<{
+		change: DataframeValue;
+		input: undefined;
+		select: SelectData;
+		search: string | null;
+		edit: EditData;
+	}>();
+
+	let els: Record<
+		string,
+		{ cell: null | HTMLTableCellElement; input: null | HTMLTextAreaElement }
+	> = {};
+	let data_binding: Record<string, (typeof data)[0][0]> = {};
+	let _headers = make_headers(headers, col_count, els, make_id);
+	let old_headers: string[] = headers;
+	let data: { id: string; value: CellValue; display_value?: string }[][] = [[]];
+	let old_val: undefined | CellValue[][] = undefined;
+	let search_results: {
+		id: string;
+		value: CellValue;
+		display_value?: string;
+		styling?: string;
+	}[][] = [[]];
+	let dragging = false;
+	let color_accent_copied: string;
+	let filtered_to_original_map: number[] = [];
+
+	onMount(() => {
+		const color = getComputedStyle(document.documentElement)
+			.getPropertyValue("--color-accent")
+			.trim();
+		color_accent_copied = color + "40"; // 80 is 50% opacity in hex
+		document.documentElement.style.setProperty(
+			"--color-accent-copied",
+			color_accent_copied
+		);
+	});
+
+	const get_data_at = (row: number, col: number): CellValue =>
+		data?.[row]?.[col]?.value;
+
+	const get_column = (col: number): CellValue[] =>
+		data?.map((row) => row[col]?.value) ?? [];
+
+	const get_row = (row: number): CellValue[] =>
+		data?.[row]?.map((cell) => cell.value) ?? [];
+
+	$: {
+		if (!dequal(headers, old_headers)) {
+			_headers = make_headers(headers, col_count, els, make_id);
+			old_headers = JSON.parse(JSON.stringify(headers));
+		}
+	}
+
+	function make_id(): string {
+		return Math.random().toString(36).substring(2, 15);
+	}
+
+	export let display_value: string[][] | null = null;
+	export let styling: string[][] | null = null;
+
+	$: if (!dequal(values, old_val)) {
+		if (parent) {
+			// only clear column widths when the data structure changes
+			const is_reset =
+				values.length === 0 || (values.length === 1 && values[0].length === 0);
+			const is_different_structure =
+				old_val !== undefined &&
+				(values.length !== old_val.length ||
+					(values[0] && old_val[0] && values[0].length !== old_val[0].length));
+
+			if (is_reset || is_different_structure) {
+				for (let i = 0; i < 50; i++) {
+					parent.style.removeProperty(`--cell-width-${i}`);
+				}
+				last_width_data_length = 0;
+				last_width_column_count = 0;
+				width_calculated = false;
+			}
+		}
+
+		// only reset sort state when values are changed
+		const is_reset =
+			values.length === 0 || (values.length === 1 && values[0].length === 0);
+		const is_different_structure =
+			old_val !== undefined &&
+			(values.length !== old_val.length ||
+				(values[0] && old_val[0] && values[0].length !== old_val[0].length));
+
+		data = process_data(
+			values as CellValue[][],
+			els,
+			data_binding,
+			make_id,
+			display_value,
+			datatype
+		);
+		old_val = JSON.parse(JSON.stringify(values)) as CellValue[][];
+
+		if (is_reset || is_different_structure) {
+			df_actions.reset_sort_state();
+		} else if ($df_state.sort_state.sort_columns.length > 0) {
+			sort_data(data, display_value, styling);
+		} else {
+			df_actions.handle_sort(-1, "asc");
+			df_actions.reset_sort_state();
+		}
+
+		if ($df_state.filter_state.filter_columns.length > 0) {
+			filter_data(data, display_value, styling);
+		} else {
+			df_actions.reset_filter_state();
+		}
+
+		if ($df_state.current_search_query) {
+			df_actions.handle_search(null);
+		}
+
+		if (parent && cells.length > 0 && (is_reset || is_different_structure)) {
+			width_calculated = false;
+		}
+	}
+
+	$: if ($df_state.current_search_query !== undefined) {
+		const cell_map = new Map();
+		filtered_to_original_map = [];
+
+		data.forEach((row, row_idx) => {
+			if (
+				row.some((cell) =>
+					String(cell?.value)
+						.toLowerCase()
+						.includes($df_state.current_search_query?.toLowerCase() || "")
+				)
+			) {
+				filtered_to_original_map.push(row_idx);
+			}
+			row.forEach((cell, col_idx) => {
+				cell_map.set(cell.id, {
+					value: cell.value,
+					display_value:
+						cell.display_value !== undefined
+							? cell.display_value
+							: String(cell.value),
+					styling: styling?.[row_idx]?.[col_idx] || ""
+				});
+			});
+		});
+
+		const filtered = df_actions.filter_data(data);
+
+		search_results = filtered.map((row) =>
+			row.map((cell) => {
+				const original = cell_map.get(cell.id);
+				return {
+					...cell,
+					display_value:
+						original?.display_value !== undefined
+							? original.display_value
+							: String(cell.value),
+					styling: original?.styling || ""
+				};
+			})
+		);
+	} else {
+		filtered_to_original_map = [];
+	}
+
+	let previous_headers = _headers.map((h) => h.value);
+	let previous_data = data.map((row) => row.map((cell) => cell.value));
+
+	$: {
+		if (data || _headers) {
+			df_actions.trigger_change(
+				data,
+				_headers,
+				previous_data,
+				previous_headers,
+				value_is_output,
+				dispatch
+			);
+			previous_data = data.map((row) => row.map((cell) => cell.value));
+			previous_headers = _headers.map((h) => h.value);
+		}
+	}
+
+	function handle_sort(col: number, direction: SortDirection): void {
+		df_actions.handle_sort(col, direction);
+		sort_data(data, display_value, styling);
+	}
+
+	function clear_sort(): void {
+		df_actions.reset_sort_state();
+		sort_data(data, display_value, styling);
+	}
+
+	$: {
+		if ($df_state.filter_state.filter_columns.length > 0) {
+			filter_data(data, display_value, styling);
+		}
+
+		if ($df_state.sort_state.sort_columns.length > 0) {
+			sort_data(data, display_value, styling);
+			df_actions.update_row_order(data);
+		}
+	}
+
+	function handle_filter(
+		col: number,
+		datatype: FilterDatatype,
+		filter: string,
+		value: string
+	): void {
+		df_actions.handle_filter(col, datatype, filter, value);
+		filter_data(data, display_value, styling);
+	}
+
+	function clear_filter(): void {
+		df_actions.reset_filter_state();
+		filter_data(data, display_value, styling);
+	}
+
+	async function edit_header(i: number, _select = false): Promise<void> {
+		if (!editable || header_edit === i || col_count[1] !== "dynamic") return;
+		df_actions.set_header_edit(i);
+	}
+
+	function handle_header_click(event: MouseEvent, col: number): void {
+		if (event.target instanceof HTMLAnchorElement) {
+			return;
+		}
+		event.preventDefault();
+		event.stopPropagation();
+		if (!editable) return;
+		df_actions.set_editing(false);
+		df_actions.handle_header_click(col, editable);
+		parent.focus();
+	}
+
+	function end_header_edit(event: CustomEvent<KeyboardEvent>): void {
+		if (!editable) return;
+		df_actions.end_header_edit(event.detail.key);
+		parent.focus();
+	}
+
+	async function add_row(index?: number): Promise<void> {
+		parent.focus();
+
+		if (row_count[1] !== "dynamic") return;
+
+		const new_row = Array(data[0]?.length || headers.length)
+			.fill(0)
+			.map((_, i) => {
+				const _id = make_id();
+				els[_id] = { cell: null, input: null };
+				return { id: _id, value: "" };
+			});
+
+		if (data.length === 0) {
+			data = [new_row];
+		} else if (index !== undefined && index >= 0 && index <= data.length) {
+			data.splice(index, 0, new_row);
+		} else {
+			data.push(new_row);
+		}
+
+		selected = [index !== undefined ? index : data.length - 1, 0];
+	}
+
+	async function add_col(index?: number): Promise<void> {
+		parent.focus();
+		if (col_count[1] !== "dynamic") return;
+
+		const result = df_actions.add_col(data, headers, make_id, index);
+
+		result.data.forEach((row) => {
+			row.forEach((cell) => {
+				if (!els[cell.id]) {
+					els[cell.id] = { cell: null, input: null };
+				}
+			});
+		});
+
+		data = result.data;
+		headers = result.headers;
+
+		await tick();
+
+		requestAnimationFrame(() => {
+			edit_header(index !== undefined ? index : data[0].length - 1, true);
+			const new_w = parent.querySelectorAll("tbody")[1].offsetWidth;
+			parent.querySelectorAll("table")[1].scrollTo({ left: new_w });
+		});
+	}
+
+	function handle_click_outside(event: Event): void {
+		if (handle_click_outside_util(event, parent)) {
+			df_actions.clear_ui_state();
+			header_edit = false;
+			selected_header = false;
+		}
+	}
+
+	$: max = get_max(data);
+
+	let width_calc_timeout: ReturnType<typeof setTimeout>;
+	$: if (cells[0] && cells[0]?.clientWidth) {
+		clearTimeout(width_calc_timeout);
+		width_calc_timeout = setTimeout(() => set_cell_widths(), 100);
+	}
+
+	let width_calculated = false;
+	$: if (cells[0] && !width_calculated) {
+		set_cell_widths();
+		width_calculated = true;
+	}
+	let cells: HTMLTableCellElement[] = [];
+	let parent: HTMLDivElement;
+	let table: HTMLTableElement;
+	let last_width_data_length = 0;
+	let last_width_column_count = 0;
+
+	function set_cell_widths(): void {
+		const column_count = data[0]?.length || 0;
+		if ($df_state.filter_state.filter_columns.length > 0) {
+			return;
+		}
+		if (
+			last_width_data_length === data.length &&
+			last_width_column_count === column_count &&
+			$df_state.sort_state.sort_columns.length > 0
+		) {
+			return;
+		}
+
+		if (!parent) {
+			return;
+		}
+
+		last_width_data_length = data.length;
+		last_width_column_count = column_count;
+
+		const widths = cells.map((el) => el?.clientWidth || 0);
+		if (widths.length === 0) return;
+
+		if (show_row_numbers) {
+			parent.style.setProperty(`--cell-width-row-number`, `${widths[0]}px`);
+		}
+
+		for (let i = 0; i < 50; i++) {
+			if (!column_widths[i]) {
+				parent.style.removeProperty(`--cell-width-${i}`);
+			} else if (column_widths[i].endsWith("%")) {
+				const percentage = parseFloat(column_widths[i]);
+				const pixel_width = Math.floor((percentage / 100) * parent.clientWidth);
+				parent.style.setProperty(`--cell-width-${i}`, `${pixel_width}px`);
+			} else {
+				parent.style.setProperty(`--cell-width-${i}`, column_widths[i]);
+			}
+		}
+
+		widths.forEach((width, i) => {
+			if (!column_widths[i]) {
+				const calculated_width = `${Math.max(width, 45)}px`;
+				parent.style.setProperty(`--cell-width-${i}`, calculated_width);
+			}
+		});
+	}
+
+	function get_cell_width(index: number): string {
+		return `var(--cell-width-${index})`;
+	}
+
+	let table_height: number =
+		values.slice(0, (max_height / values.length) * 37).length * 37 + 37;
+	let scrollbar_width = 0;
+
+	function sort_data(
+		_data: typeof data,
+		_display_value: string[][] | null,
+		_styling: string[][] | null
+	): void {
+		const result = sort_data_and_preserve_selection(
+			_data,
+			_display_value,
+			_styling,
+			$df_state.sort_state.sort_columns,
+			selected,
+			get_current_indices
+		);
+
+		data = result.data;
+		selected = result.selected;
+	}
+
+	function filter_data(
+		_data: typeof data,
+		_display_value: string[][] | null,
+		_styling: string[][] | null
+	): void {
+		const result = filter_data_and_preserve_selection(
+			_data,
+			_display_value,
+			_styling,
+			$df_state.filter_state.filter_columns,
+			selected,
+			get_current_indices,
+			$df_state.filter_state.initial_data?.data,
+			$df_state.filter_state.initial_data?.display_value,
+			$df_state.filter_state.initial_data?.styling
+		);
+		data = result.data;
+		selected = result.selected;
+	}
+
+	$: selected_index = !!selected && selected[0];
+
+	let is_visible = false;
+
+	const set_copy_flash = (value: boolean): void => {
+		df_actions.set_copy_flash(value);
+		if (value) {
+			setTimeout(() => df_actions.set_copy_flash(false), 800);
+		}
+	};
+
+	let previous_selected_cells: [number, number][] = [];
+
+	$: {
+		if (copy_flash && !dequal(selected_cells, previous_selected_cells)) {
+			set_copy_flash(false);
+		}
+		previous_selected_cells = selected_cells;
+	}
+
+	function handle_blur(
+		event: CustomEvent<{
+			blur_event: FocusEvent;
+			coords: [number, number];
+		}>
+	): void {
+		const { blur_event, coords } = event.detail;
+		handle_cell_blur(blur_event, df_ctx, coords);
+	}
+
+	function toggle_header_menu(event: MouseEvent, col: number): void {
+		event.stopPropagation();
+		if (active_header_menu && active_header_menu.col === col) {
+			df_actions.set_active_header_menu(null);
+		} else {
+			const header = (event.target as HTMLElement).closest("th");
+			if (header) {
+				const rect = header.getBoundingClientRect();
+				df_actions.set_active_header_menu({
+					col,
+					x: rect.right,
+					y: rect.bottom
+				});
+			}
+		}
+	}
+
+	afterUpdate(() => {
+		value_is_output = false;
+	});
+
+	function delete_col_at(index: number): void {
+		if (col_count[1] !== "dynamic") return;
+		if (data[0].length <= 1) return;
+
+		const result = df_actions.delete_col_at(data, headers, index);
+		data = result.data;
+		headers = result.headers;
+		_headers = make_headers(headers, col_count, els, make_id);
+		df_actions.set_active_cell_menu(null);
+		df_actions.set_active_header_menu(null);
+		df_actions.set_selected(false);
+		df_actions.set_selected_cells([]);
+		df_actions.set_editing(false);
+	}
+
+	function delete_row_at(index: number): void {
+		data = df_actions.delete_row_at(data, index);
+		df_actions.set_active_cell_menu(null);
+		df_actions.set_active_header_menu(null);
+	}
+
+	let selected_cell_coords: CellCoordinate;
+	$: if (selected !== false) selected_cell_coords = selected;
+
+	$: if (selected !== false) {
+		const positions = calculate_selection_positions(
+			selected,
+			data,
+			els,
+			parent,
+			table
+		);
+		document.documentElement.style.setProperty(
+			"--selected-col-pos",
+			positions.col_pos
+		);
+		document.documentElement.style.setProperty(
+			"--selected-row-pos",
+			positions.row_pos || "0px"
+		);
+	}
+
+	function commit_filter(): void {
+		if ($df_state.current_search_query && show_search === "filter") {
+			const filtered_data: CellValue[][] = [];
+			const filtered_display_values: string[][] = [];
+			const filtered_styling: string[][] = [];
+
+			search_results.forEach((row) => {
+				const data_row: CellValue[] = [];
+				const display_row: string[] = [];
+				const styling_row: string[] = [];
+
+				row.forEach((cell) => {
+					data_row.push(cell.value);
+					display_row.push(
+						cell.display_value !== undefined
+							? cell.display_value
+							: String(cell.value)
+					);
+					styling_row.push(cell.styling || "");
+				});
+
+				filtered_data.push(data_row);
+				filtered_display_values.push(display_row);
+				filtered_styling.push(styling_row);
+			});
+
+			const change_payload = {
+				data: filtered_data,
+				headers: _headers.map((h) => h.value),
+				metadata: {
+					display_value: filtered_display_values,
+					styling: filtered_styling
+				}
+			};
+
+			dispatch("change", change_payload);
+
+			if (!value_is_output) {
+				dispatch("input");
+			}
+
+			df_actions.handle_search(null);
+		}
+	}
+
+	let viewport: HTMLTableElement;
+	let show_scroll_button = false;
+
+	function scroll_to_top(): void {
+		viewport.scrollTo({
+			top: 0
+		});
+	}
+
+	function handle_resize(): void {
+		df_actions.set_active_cell_menu(null);
+		df_actions.set_active_header_menu(null);
+		selected_cells = [];
+		selected = false;
+		editing = false;
+		width_calculated = false;
+		set_cell_widths();
+	}
+
+	function add_row_at(index: number, position: "above" | "below"): void {
+		const row_index = position === "above" ? index : index + 1;
+		add_row(row_index);
+		active_cell_menu = null;
+		active_header_menu = null;
+	}
+
+	function add_col_at(index: number, position: "left" | "right"): void {
+		const col_index = position === "left" ? index : index + 1;
+		add_col(col_index);
+		active_cell_menu = null;
+		active_header_menu = null;
+	}
+
+	export function reset_sort_state(): void {
+		df_actions.reset_sort_state();
+	}
+
+	function handle_select_all(col: number, checked: boolean): void {
+		data = data.map((row) => {
+			const new_row = [...row];
+			if (new_row[col]) {
+				new_row[col] = {
+					...new_row[col],
+					value: checked.toString()
+				};
+			}
+			return new_row;
+		});
+	}
+
+	let is_dragging = false;
+	let drag_start: [number, number] | null = null;
+	let mouse_down_pos: { x: number; y: number } | null = null;
+
+	const drag_state: DragState = {
+		is_dragging,
+		drag_start,
+		mouse_down_pos
+	};
+
+	$: {
+		is_dragging = drag_state.is_dragging;
+		drag_start = drag_state.drag_start;
+		mouse_down_pos = drag_state.mouse_down_pos;
+	}
+
+	let drag_handlers: DragHandlers;
+
+	function init_drag_handlers(): void {
+		drag_handlers = create_drag_handlers(
+			drag_state,
+			(value) => (is_dragging = value),
+			(cells) => df_actions.set_selected_cells(cells),
+			(cell) => df_actions.set_selected(cell),
+			(event, row, col) => df_actions.handle_cell_click(event, row, col),
+			show_row_numbers,
+			parent
+		);
+	}
+
+	$: if (parent) init_drag_handlers();
+
+	$: handle_mouse_down = drag_handlers?.handle_mouse_down || (() => {});
+	$: handle_mouse_move = drag_handlers?.handle_mouse_move || (() => {});
+	$: handle_mouse_up = drag_handlers?.handle_mouse_up || (() => {});
+
+	function get_cell_display_value(row: number, col: number): string {
+		const is_search_active = $df_state.current_search_query !== undefined;
+
+		if (is_search_active && search_results?.[row]?.[col]) {
+			return search_results[row][col].display_value !== undefined
+				? search_results[row][col].display_value
+				: String(search_results[row][col].value);
+		}
+
+		if (data?.[row]?.[col]) {
+			return data[row][col].display_value !== undefined
+				? data[row][col].display_value
+				: String(data[row][col].value);
+		}
+
+		return "";
+	}
+</script>
+
+<svelte:window on:resize={() => set_cell_widths()} />
+
+<div class="table-container">
+	{#if (label && label.length !== 0 && show_label) || show_fullscreen_button || show_copy_button || 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}
+				{fullscreen}
+				on_copy={async () => await copy_table_data(data, null)}
+				{show_copy_button}
+				{show_search}
+				on:search={(e) => df_actions.handle_search(e.detail)}
+				on:fullscreen
+				on_commit_filter={commit_filter}
+				current_search_query={$df_state.current_search_query}
+			/>
+		</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}
+		on:keydown={(e) => handle_keydown(e, df_ctx)}
+		on:mousemove={handle_mouse_move}
+		on:mouseup={handle_mouse_up}
+		on:mouseleave={handle_mouse_up}
+		role="grid"
+		tabindex="0"
+	>
+		<table bind:this={table} aria-hidden="true">
+			{#if label && label.length !== 0}
+				<caption class="sr-only">{label}</caption>
+			{/if}
+			<thead>
+				<tr>
+					{#if show_row_numbers}
+						<RowNumber is_header={true} />
+					{/if}
+					{#each _headers as { value, id }, i (id)}
+						<TableHeader
+							bind:value={_headers[i].value}
+							{i}
+							{actual_pinned_columns}
+							{header_edit}
+							{selected_header}
+							{headers}
+							{get_cell_width}
+							{handle_header_click}
+							{toggle_header_menu}
+							{end_header_edit}
+							sort_columns={$df_state.sort_state.sort_columns}
+							filter_columns={$df_state.filter_state.filter_columns}
+							{latex_delimiters}
+							{line_breaks}
+							{max_chars}
+							{editable}
+							is_static={static_columns.includes(i)}
+							{i18n}
+							bind:el={els[id].input}
+							{col_count}
+							datatype={Array.isArray(datatype) ? datatype[i] : datatype}
+							{data}
+							on_select_all={handle_select_all}
+						/>
+					{/each}
+				</tr>
+			</thead>
+			<tbody>
+				<tr>
+					{#if show_row_numbers}
+						<RowNumber index={0} />
+					{/if}
+					{#each max as { value, id }, j (id)}
+						<td tabindex="-1" bind:this={cells[j]}>
+							<div class="cell-wrap">
+								<EditableCell
+									{value}
+									{latex_delimiters}
+									{line_breaks}
+									datatype={Array.isArray(datatype) ? datatype[j] : datatype}
+									edit={false}
+									el={null}
+									{editable}
+									{i18n}
+									show_selection_buttons={selected_cells.length === 1 &&
+										selected_cells[0][0] === 0 &&
+										selected_cells[0][1] === j}
+									coords={selected_cell_coords}
+									on_select_column={df_actions.handle_select_column}
+									on_select_row={df_actions.handle_select_row}
+									{is_dragging}
+									on:blur={handle_blur}
+								/>
+							</div>
+						</td>
+					{/each}
+				</tr>
+			</tbody>
+		</table>
+		<Upload
+			{upload}
+			{stream_handler}
+			flex={false}
+			center={false}
+			boundedheight={false}
+			disable_click={true}
+			{root}
+			on:load={({ detail }) =>
+				handle_file_upload(
+					detail.data,
+					(head) => {
+						_headers = make_headers(
+							head.map((h) => h ?? ""),
+							col_count,
+							els,
+							make_id
+						);
+						return _headers;
+					},
+					(vals) => {
+						values = vals;
+					}
+				)}
+			bind:dragging
+			aria_label={i18n("dataframe.drop_to_upload")}
+		>
+			<div class="table-wrap">
+				<VirtualTable
+					bind:items={search_results}
+					{max_height}
+					bind:actual_height={table_height}
+					bind:table_scrollbar_width={scrollbar_width}
+					selected={selected_index}
+					disable_scroll={active_cell_menu !== null ||
+						active_header_menu !== null}
+					bind:viewport
+					bind:show_scroll_button
+					{label}
+					on:scroll_top={(_) => {}}
+				>
+					<tr slot="thead">
+						{#if show_row_numbers}
+							<RowNumber is_header={true} />
+						{/if}
+						{#each _headers as { value, id }, i (id)}
+							<TableHeader
+								bind:value={_headers[i].value}
+								{i}
+								{actual_pinned_columns}
+								{header_edit}
+								{selected_header}
+								{headers}
+								{get_cell_width}
+								{handle_header_click}
+								{toggle_header_menu}
+								{end_header_edit}
+								sort_columns={$df_state.sort_state.sort_columns}
+								filter_columns={$df_state.filter_state.filter_columns}
+								{latex_delimiters}
+								{line_breaks}
+								{max_chars}
+								{editable}
+								is_static={static_columns.includes(i)}
+								{i18n}
+								bind:el={els[id].input}
+								{col_count}
+								datatype={Array.isArray(datatype) ? datatype[i] : datatype}
+								{data}
+								on_select_all={handle_select_all}
+							/>
+						{/each}
+					</tr>
+					<tr slot="tbody" let:item let:index class:row-odd={index % 2 === 0}>
+						{#if show_row_numbers}
+							<RowNumber {index} />
+						{/if}
+						{#each item as { value, id }, j (id)}
+							<TableCell
+								bind:value={search_results[index][j].value}
+								display_value={get_cell_display_value(index, j)}
+								index={$df_state.current_search_query !== undefined &&
+								filtered_to_original_map[index] !== undefined
+									? filtered_to_original_map[index]
+									: index}
+								{j}
+								{actual_pinned_columns}
+								{get_cell_width}
+								handle_cell_click={(e, r, c) => handle_mouse_down(e, r, c)}
+								{handle_blur}
+								toggle_cell_menu={df_actions.toggle_cell_menu}
+								{is_cell_selected}
+								{should_show_cell_menu}
+								{selected_cells}
+								{copy_flash}
+								{active_cell_menu}
+								styling={search_results[index][j].styling}
+								{latex_delimiters}
+								{line_breaks}
+								datatype={Array.isArray(datatype) ? datatype[j] : datatype}
+								{editing}
+								{max_chars}
+								{editable}
+								is_static={static_columns.includes(j)}
+								{i18n}
+								{components}
+								handle_select_column={df_actions.handle_select_column}
+								handle_select_row={df_actions.handle_select_row}
+								bind:el={els[id]}
+								{is_dragging}
+								{wrap}
+							/>
+						{/each}
+					</tr>
+				</VirtualTable>
+			</div>
+		</Upload>
+		{#if show_scroll_button}
+			<button class="scroll-top-button" on:click={scroll_to_top}>
+				&uarr;
+			</button>
+		{/if}
+	</div>
+</div>
+{#if data.length === 0 && editable && row_count[1] === "dynamic"}
+	<EmptyRowButton on_click={() => add_row()} />
+{/if}
+
+{#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 && data.length > 1 && editable}
+		can_delete_cols={data.length > 0 && data[0]?.length > 1 && editable}
+		{i18n}
+		on_sort={active_header_menu
+			? (direction) => {
+					if (active_header_menu) {
+						handle_sort(active_header_menu.col, direction);
+						df_actions.set_active_header_menu(null);
+					}
+				}
+			: undefined}
+		on_clear_sort={active_header_menu
+			? () => {
+					clear_sort();
+					df_actions.set_active_header_menu(null);
+				}
+			: undefined}
+		sort_direction={active_header_menu
+			? $df_state.sort_state.sort_columns.find(
+					(item) => item.col === (active_header_menu?.col ?? -1)
+				)?.direction ?? null
+			: null}
+		sort_priority={active_header_menu
+			? $df_state.sort_state.sort_columns.findIndex(
+					(item) => item.col === (active_header_menu?.col ?? -1)
+				) + 1 || null
+			: null}
+		on_filter={active_header_menu
+			? (datatype, filter, value) => {
+					if (active_header_menu) {
+						handle_filter(active_header_menu.col, datatype, filter, value);
+						df_actions.set_active_header_menu(null);
+					}
+				}
+			: undefined}
+		on_clear_filter={active_header_menu
+			? () => {
+					clear_filter();
+					df_actions.set_active_header_menu(null);
+				}
+			: undefined}
+		filter_active={active_header_menu
+			? $df_state.filter_state.filter_columns.some(
+					(c) => c.col === (active_header_menu?.col ?? -1)
+				)
+			: null}
+	/>
+{/if}
+
+<style>
+	.table-container {
+		display: flex;
+		flex-direction: column;
+		gap: var(--size-2);
+		position: relative;
+	}
+
+	.table-wrap {
+		position: relative;
+		transition: 150ms;
+	}
+
+	.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;
+	}
+
+	table {
+		position: absolute;
+		opacity: 0;
+		z-index: -1;
+		transition: 150ms;
+		width: var(--size-full);
+		table-layout: auto;
+		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;
+	}
+
+	thead {
+		position: sticky;
+		top: 0;
+		z-index: 5;
+		box-shadow: var(--shadow-drop);
+	}
+
+	thead :global(th.pinned-column) {
+		position: sticky;
+		z-index: 6;
+		background: var(--table-even-background-fill) !important;
+	}
+
+	.dragging {
+		border-color: var(--color-accent);
+	}
+
+	.no-wrap {
+		white-space: nowrap;
+	}
+
+	div:not(.no-wrap) td {
+		overflow-wrap: anywhere;
+	}
+
+	div.no-wrap td {
+		overflow-x: hidden;
+	}
+
+	tr {
+		background: var(--table-even-background-fill);
+	}
+
+	tr.row-odd {
+		background: var(--table-odd-background-fill);
+	}
+
+	.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);
+		position: relative;
+		z-index: 4;
+	}
+
+	.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;
+	}
+
+	tr {
+		border-bottom: 1px solid var(--border-color-primary);
+		text-align: left;
+	}
+</style>

5.49.1/dataframe/shared/TableCell.svelte

@@ -0,0 +1,330 @@
+<script lang="ts">
+	import EditableCell from "./EditableCell.svelte";
+	import CellMenuButton from "./CellMenuButton.svelte";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import type { Datatype } from "./utils/utils";
+	import type { CellValue } from "./types";
+	import { is_cell_in_selection } from "./utils/selection_utils";
+
+	export let value: CellValue;
+	export let index: number;
+	export let j: number;
+	export let actual_pinned_columns: number;
+	export let get_cell_width: (index: number) => string;
+	export let handle_cell_click: (
+		event: MouseEvent,
+		row: number,
+		col: number
+	) => void;
+	export let handle_blur: (
+		event: CustomEvent<{
+			blur_event: FocusEvent;
+			coords: [number, number];
+		}>
+	) => void;
+	export let toggle_cell_menu: (
+		event: MouseEvent,
+		row: number,
+		col: number
+	) => void;
+	export let is_cell_selected: (
+		coords: [number, number],
+		selected_cells: [number, number][]
+	) => string;
+	export let should_show_cell_menu: (
+		coords: [number, number],
+		selected_cells: [number, number][],
+		editable: boolean
+	) => boolean;
+	export let selected_cells: [number, number][];
+	export let copy_flash: boolean;
+	export let active_cell_menu: {
+		row: number;
+		col: number;
+		x: number;
+		y: number;
+	} | null;
+	export let styling: string | undefined;
+	export let latex_delimiters: {
+		left: string;
+		right: string;
+		display: boolean;
+	}[];
+	export let line_breaks: boolean;
+	export let datatype: Datatype;
+	export let editing: [number, number] | false;
+	export let max_chars: number | undefined;
+	export let editable: boolean;
+	export let is_static = false;
+	export let i18n: I18nFormatter;
+	export let components: Record<string, any> = {};
+	export let el: {
+		cell: HTMLTableCellElement | null;
+		input: HTMLTextAreaElement | null;
+	};
+	export let handle_select_column: (col: number) => void;
+	export let handle_select_row: (row: number) => void;
+	export let is_dragging: boolean;
+	export let display_value: string | undefined;
+	export let wrap = false;
+
+	function get_cell_position(col_index: number): string {
+		if (col_index >= actual_pinned_columns) {
+			return "auto";
+		}
+
+		if (col_index === 0) {
+			return "0";
+		}
+
+		const previous_widths = Array(col_index)
+			.fill(0)
+			.map((_, idx) => {
+				return get_cell_width(idx);
+			})
+			.join(" + ");
+
+		return `calc(${previous_widths})`;
+	}
+
+	$: cell_classes = is_cell_selected([index, j], selected_cells || []);
+	$: is_in_selection = is_cell_in_selection([index, j], selected_cells);
+	$: has_no_top = cell_classes.includes("no-top");
+	$: has_no_bottom = cell_classes.includes("no-bottom");
+	$: has_no_left = cell_classes.includes("no-left");
+	$: has_no_right = cell_classes.includes("no-right");
+</script>
+
+<td
+	class:pinned-column={j < actual_pinned_columns}
+	class:last-pinned={j === actual_pinned_columns - 1}
+	tabindex={j < actual_pinned_columns ? -1 : 0}
+	bind:this={el.cell}
+	data-row={index}
+	data-col={j}
+	data-testid={`cell-${index}-${j}`}
+	on:mousedown={(e) => handle_cell_click(e, index, j)}
+	on:contextmenu|preventDefault={(e) => toggle_cell_menu(e, index, j)}
+	style="width: {get_cell_width(j)}; left: {get_cell_position(j)}; {styling ||
+		''}"
+	class:flash={copy_flash && is_in_selection}
+	class:cell-selected={is_in_selection}
+	class:no-top={has_no_top}
+	class:no-bottom={has_no_bottom}
+	class:no-left={has_no_left}
+	class:no-right={has_no_right}
+	class:menu-active={active_cell_menu &&
+		active_cell_menu.row === index &&
+		active_cell_menu.col === j}
+	class:dragging={is_dragging}
+>
+	<div class="cell-wrap">
+		<EditableCell
+			bind:value
+			bind:el={el.input}
+			display_value={display_value !== undefined
+				? display_value
+				: String(value)}
+			{latex_delimiters}
+			{line_breaks}
+			{editable}
+			{is_static}
+			edit={editing && editing[0] === index && editing[1] === j}
+			{datatype}
+			on:focus={() => {
+				const row = index;
+				const col = j;
+				if (!selected_cells.some(([r, c]) => r === row && c === col)) {
+					selected_cells = [[row, col]];
+				}
+			}}
+			on:blur={handle_blur}
+			{max_chars}
+			{i18n}
+			{components}
+			show_selection_buttons={selected_cells.length === 1 &&
+				selected_cells[0][0] === index &&
+				selected_cells[0][1] === j}
+			coords={[index, j]}
+			on_select_column={handle_select_column}
+			on_select_row={handle_select_row}
+			{is_dragging}
+			wrap_text={wrap}
+		/>
+		{#if editable && should_show_cell_menu([index, j], selected_cells, editable)}
+			<CellMenuButton on_click={(event) => toggle_cell_menu(event, index, j)} />
+		{/if}
+	</div>
+</td>
+
+<style>
+	td {
+		--ring-color: transparent;
+		position: relative;
+		outline: none;
+		box-shadow: inset 0 0 0 1px var(--ring-color);
+		padding: 0;
+		border-right-width: 0px;
+		border-left-width: 1px;
+		border-style: solid;
+		border-color: var(--border-color-primary);
+	}
+
+	.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;
+		margin: 0;
+		gap: var(--size-1);
+		overflow: visible;
+		min-width: 0;
+		border-radius: var(--table-radius);
+	}
+
+	.cell-selected {
+		--ring-color: var(--color-accent);
+		box-shadow: inset 0 0 0 2px var(--ring-color);
+		z-index: 2;
+		position: relative;
+	}
+
+	.cell-selected :global(.cell-menu-button) {
+		display: flex;
+	}
+
+	.flash.cell-selected {
+		animation: flash-color 700ms ease-out;
+	}
+
+	@keyframes flash-color {
+		0%,
+		30% {
+			background: var(--color-accent-copied);
+		}
+
+		100% {
+			background: transparent;
+		}
+	}
+
+	.pinned-column {
+		position: sticky;
+		z-index: 3;
+		border-right: none;
+	}
+
+	.pinned-column:nth-child(odd) {
+		background: var(--table-odd-background-fill);
+	}
+
+	.pinned-column:nth-child(even) {
+		background: var(--table-even-background-fill);
+	}
+
+	td:first-child {
+		border-left-width: 0px;
+	}
+
+	:global(tr:last-child) td:first-child {
+		border-bottom-left-radius: var(--table-radius);
+	}
+
+	:global(tr:last-child) td:last-child {
+		border-bottom-right-radius: var(--table-radius);
+	}
+
+	.dragging {
+		cursor: crosshair;
+	}
+
+	/* Add back the cell selection border styles */
+	.cell-selected.no-top {
+		box-shadow:
+			inset 2px 0 0 var(--ring-color),
+			inset -2px 0 0 var(--ring-color),
+			inset 0 -2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-bottom {
+		box-shadow:
+			inset 2px 0 0 var(--ring-color),
+			inset -2px 0 0 var(--ring-color),
+			inset 0 2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-left {
+		box-shadow:
+			inset 0 2px 0 var(--ring-color),
+			inset -2px 0 0 var(--ring-color),
+			inset 0 -2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-right {
+		box-shadow:
+			inset 0 2px 0 var(--ring-color),
+			inset 2px 0 0 var(--ring-color),
+			inset 0 -2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-top.no-left {
+		box-shadow:
+			inset -2px 0 0 var(--ring-color),
+			inset 0 -2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-top.no-right {
+		box-shadow:
+			inset 2px 0 0 var(--ring-color),
+			inset 0 -2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-bottom.no-left {
+		box-shadow:
+			inset -2px 0 0 var(--ring-color),
+			inset 0 2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-bottom.no-right {
+		box-shadow:
+			inset 2px 0 0 var(--ring-color),
+			inset 0 2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-top.no-bottom {
+		box-shadow:
+			inset 2px 0 0 var(--ring-color),
+			inset -2px 0 0 var(--ring-color);
+	}
+
+	.cell-selected.no-left.no-right {
+		box-shadow:
+			inset 0 2px 0 var(--ring-color),
+			inset 0 -2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-top.no-left.no-right {
+		box-shadow: inset 0 -2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-bottom.no-left.no-right {
+		box-shadow: inset 0 2px 0 var(--ring-color);
+	}
+
+	.cell-selected.no-left.no-top.no-bottom {
+		box-shadow: inset -2px 0 0 var(--ring-color);
+	}
+
+	.cell-selected.no-right.no-top.no-bottom {
+		box-shadow: inset 2px 0 0 var(--ring-color);
+	}
+
+	.cell-selected.no-top.no-bottom.no-left.no-right {
+		box-shadow: none;
+	}
+</style>

5.49.1/dataframe/shared/TableHeader.svelte

@@ -0,0 +1,344 @@
+<script lang="ts">
+	import EditableCell from "./EditableCell.svelte";
+	import CellMenuButton from "./CellMenuButton.svelte";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import { get_sort_status } from "./utils/sort_utils";
+	import Padlock from "./icons/Padlock.svelte";
+	import SortArrowUp from "./icons/SortArrowUp.svelte";
+	import SortArrowDown from "./icons/SortArrowDown.svelte";
+	import type { SortDirection } from "./context/dataframe_context";
+	import CellMenuIcons from "./CellMenuIcons.svelte";
+	import type { FilterDatatype } from "./context/dataframe_context";
+	import type { Datatype } from "./utils/utils";
+	import { BaseCheckbox } from "@gradio/checkbox";
+	export let value: string;
+	export let i: number;
+	export let datatype: Datatype = "str";
+	export let actual_pinned_columns: number;
+	export let header_edit: number | false;
+	export let selected_header: number | false;
+	export let headers: string[];
+	export let get_cell_width: (index: number) => string;
+	export let handle_header_click: (event: MouseEvent, col: number) => void;
+	export let toggle_header_menu: (event: MouseEvent, col: number) => void;
+	export let end_header_edit: (event: CustomEvent<KeyboardEvent>) => void;
+	export let sort_columns: { col: number; direction: SortDirection }[] = [];
+	export let filter_columns: {
+		col: number;
+		datatype: FilterDatatype;
+		filter: string;
+		value: string;
+	}[] = [];
+
+	export let latex_delimiters: {
+		left: string;
+		right: string;
+		display: boolean;
+	}[];
+	export let line_breaks: boolean;
+	export let max_chars: number | undefined;
+	export let editable: boolean;
+	export let i18n: I18nFormatter;
+	export let el: HTMLTextAreaElement | null;
+	export let is_static: boolean;
+	export let col_count: [number, "fixed" | "dynamic"];
+	export let data: any[] = [];
+	export let on_select_all:
+		| ((col: number, checked: boolean) => void)
+		| undefined = undefined;
+
+	$: can_add_columns = col_count && col_count[1] === "dynamic";
+	$: is_bool_column = datatype === "bool";
+
+	$: select_all_state = (() => {
+		if (!is_bool_column || data.length === 0) return "unchecked";
+		const true_count = data.filter(
+			(row) => row[i]?.value === true || row[i]?.value === "true"
+		).length;
+		if (true_count === 0) return "unchecked";
+		if (true_count === data.length) return "checked";
+		return "indeterminate";
+	})();
+
+	$: sort_index = sort_columns.findIndex((item) => item.col === i);
+	$: filter_index = filter_columns.findIndex((item) => item.col === i);
+	$: sort_priority = sort_index !== -1 ? sort_index + 1 : null;
+	$: current_direction =
+		sort_index !== -1 ? sort_columns[sort_index].direction : null;
+
+	function get_header_position(col_index: number): string {
+		if (col_index >= actual_pinned_columns) {
+			return "auto";
+		}
+
+		if (col_index === 0) {
+			return "0";
+		}
+
+		const previous_widths = Array(col_index)
+			.fill(0)
+			.map((_, idx) => {
+				return get_cell_width(idx);
+			})
+			.join(" + ");
+
+		return `calc(${previous_widths})`;
+	}
+</script>
+
+<th
+	class:pinned-column={i < actual_pinned_columns}
+	class:last-pinned={i === actual_pinned_columns - 1}
+	class:focus={header_edit === i || selected_header === i}
+	class:sorted={sort_index !== -1}
+	class:filtered={filter_index !== -1}
+	aria-sort={get_sort_status(value, sort_columns, headers) === "none"
+		? "none"
+		: get_sort_status(value, sort_columns, headers) === "asc"
+			? "ascending"
+			: "descending"}
+	style="width: {get_cell_width(i)}; left: {get_header_position(i)};"
+	on:click={(event) => handle_header_click(event, i)}
+	on:mousedown={(event) => {
+		event.preventDefault();
+		event.stopPropagation();
+	}}
+	title={value}
+>
+	<div class="cell-wrap">
+		<div class="header-content">
+			{#if is_bool_column && editable && on_select_all}
+				<div
+					class="select-all-checkbox"
+					role="button"
+					tabindex="0"
+					on:click|stopPropagation
+					on:keydown|stopPropagation={(e) => {
+						if (e.key === "Enter" || e.key === " ") {
+							e.preventDefault();
+						}
+					}}
+					on:mousedown|stopPropagation
+				>
+					<BaseCheckbox
+						value={select_all_state === "checked"}
+						indeterminate={select_all_state === "indeterminate"}
+						label=""
+						interactive={true}
+						on:select={() => {
+							if (on_select_all) {
+								const new_value = select_all_state !== "checked";
+								on_select_all(i, new_value);
+							}
+						}}
+					/>
+				</div>
+			{/if}
+			<button
+				class="header-button"
+				on:click={(event) => handle_header_click(event, i)}
+				on:mousedown={(event) => {
+					event.preventDefault();
+					event.stopPropagation();
+				}}
+				title={value}
+			>
+				<EditableCell
+					{max_chars}
+					bind:value
+					bind:el
+					{latex_delimiters}
+					{line_breaks}
+					edit={header_edit === i}
+					on:keydown={(event) => {
+						if (
+							event.detail.key === "Enter" ||
+							event.detail.key === "Escape" ||
+							event.detail.key === "Tab"
+						) {
+							end_header_edit(event);
+						}
+					}}
+					header
+					{editable}
+					{is_static}
+					{i18n}
+					coords={[i, 0]}
+				/>
+				{#if sort_index !== -1}
+					<div class="sort-indicators">
+						<span class="sort-arrow">
+							{#if current_direction === "asc"}
+								<SortArrowUp size={12} />
+							{:else}
+								<SortArrowDown size={12} />
+							{/if}
+						</span>
+						{#if sort_columns.length > 1}
+							<span class="sort-priority">
+								{sort_priority}
+							</span>
+						{/if}
+					</div>
+				{/if}
+				{#if filter_index !== -1}
+					<div class="filter-indicators">
+						<span class="filter-icon">
+							<CellMenuIcons icon="filter" />
+						</span>
+					</div>
+				{/if}
+			</button>
+			{#if is_static}
+				<Padlock />
+			{/if}
+		</div>
+		{#if can_add_columns}
+			<CellMenuButton on_click={(event) => toggle_header_menu(event, i)} />
+		{/if}
+	</div>
+</th>
+
+<style>
+	th {
+		--ring-color: transparent;
+		position: relative;
+		outline: none;
+		box-shadow: inset 0 0 0 1px var(--ring-color);
+		padding: 0;
+		background: var(--table-even-background-fill);
+		border-right-width: 0px;
+		border-left-width: 1px;
+		border-style: solid;
+		border-color: var(--border-color-primary);
+	}
+
+	th:first-child {
+		border-top-left-radius: var(--table-radius);
+		border-bottom-left-radius: var(--table-radius);
+		border-left-width: 0px;
+	}
+
+	th:last-child {
+		border-top-right-radius: var(--table-radius);
+		border-bottom-right-radius: var(--table-radius);
+	}
+
+	th.focus {
+		--ring-color: var(--color-accent);
+		box-shadow: inset 0 0 0 2px var(--ring-color);
+		z-index: 4;
+	}
+
+	th.focus :global(.cell-menu-button) {
+		display: flex;
+	}
+
+	th:hover :global(.cell-menu-button) {
+		display: flex;
+	}
+
+	.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;
+		margin: 0;
+		gap: var(--size-1);
+		overflow: visible;
+		min-width: 0;
+		border-radius: var(--table-radius);
+	}
+
+	.header-content {
+		display: flex;
+		align-items: center;
+		overflow: hidden;
+		flex-grow: 1;
+		min-width: 0;
+		white-space: normal;
+		overflow-wrap: break-word;
+		word-break: normal;
+		height: 100%;
+		gap: var(--size-1);
+	}
+
+	.header-button {
+		display: flex;
+		text-align: left;
+		width: 100%;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		display: flex;
+		align-items: center;
+		position: relative;
+	}
+
+	.sort-indicators {
+		display: flex;
+		align-items: center;
+		margin-left: var(--size-1);
+		gap: var(--size-1);
+	}
+
+	.sort-arrow {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		color: var(--body-text-color);
+	}
+
+	.sort-priority {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		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);
+		padding: var(--size-1-5);
+	}
+
+	.filter-indicators {
+		display: flex;
+		align-items: center;
+		margin-left: var(--size-1);
+		gap: var(--size-1);
+	}
+
+	.filter-icon {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		color: var(--body-text-color);
+	}
+
+	.pinned-column {
+		position: sticky;
+		z-index: 5;
+		border-right: none;
+	}
+
+	.select-all-checkbox {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		margin-right: var(--size-1);
+		flex-shrink: 0;
+	}
+
+	.select-all-checkbox :global(label) {
+		margin: 0;
+	}
+
+	.select-all-checkbox :global(span) {
+		display: none;
+	}
+</style>

5.49.1/dataframe/shared/Toolbar.svelte

@@ -0,0 +1,198 @@
+<script lang="ts">
+	import { Copy, Check } from "@gradio/icons";
+	import { FullscreenButton } from "@gradio/atoms";
+	import { onDestroy } from "svelte";
+	import { createEventDispatcher } from "svelte";
+	import { IconButton } from "@gradio/atoms";
+
+	export let show_fullscreen_button = false;
+	export let show_copy_button = false;
+	export let show_search: "none" | "search" | "filter" = "none";
+	export let fullscreen = false;
+	export let on_copy: () => Promise<void>;
+	export let on_commit_filter: () => void;
+
+	const dispatch = createEventDispatcher<{
+		search: string | null;
+	}>();
+
+	let copied = false;
+	let timer: ReturnType<typeof setTimeout>;
+	export let current_search_query: string | null = null;
+	let input_value = "";
+
+	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;
+			dispatch("search", 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();
+	}
+
+	onDestroy(() => {
+		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 || ""}
+					on:input={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"
+						on:click={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"}
+				on:click={handle_copy}
+			/>
+		{/if}
+		{#if show_fullscreen_button}
+			<FullscreenButton {fullscreen} on:fullscreen />
+		{/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>

5.49.1/dataframe/shared/VirtualTable.svelte

@@ -0,0 +1,379 @@
+<script lang="ts">
+	import { onMount, tick, createEventDispatcher } from "svelte";
+
+	export let items: any[][] = [];
+
+	export let max_height: number;
+	export let actual_height: number;
+	export let table_scrollbar_width: number;
+	export let start = 0;
+	export let end = 20;
+	export let selected: number | false;
+	export let disable_scroll = false;
+	export let show_scroll_button = false;
+	export let viewport: HTMLTableElement;
+	export let label: string | null = null;
+
+	const dispatch = createEventDispatcher<{
+		scroll_top: number;
+	}>();
+
+	let height = "100%";
+
+	let average_height = 30;
+	let bottom = 0;
+	let contents: HTMLTableSectionElement;
+	let head_height = 0;
+	let foot_height = 0;
+	let height_map: number[] = [];
+	let mounted: boolean;
+	let rows: HTMLCollectionOf<HTMLTableRowElement>;
+	let top = 0;
+	let viewport_height = 200;
+	let visible: { index: number; data: any[] }[] = [];
+	let viewport_box: DOMRectReadOnly;
+
+	$: viewport_height = viewport_box?.height || 200;
+
+	const is_browser = typeof window !== "undefined";
+	const raf = is_browser
+		? window.requestAnimationFrame
+		: (cb: (...args: any[]) => void) => cb();
+
+	$: {
+		if (mounted && viewport_height && viewport.offsetParent) {
+			sortedItems, raf(refresh_height_map);
+		}
+	}
+
+	async function refresh_height_map(): Promise<void> {
+		if (!viewport) {
+			return;
+		}
+
+		if (sortedItems.length < start) {
+			await scroll_to_index(sortedItems.length - 1, { behavior: "auto" });
+		}
+
+		const scrollTop = Math.max(0, viewport.scrollTop);
+		show_scroll_button = scrollTop > 100;
+		table_scrollbar_width = viewport.offsetWidth - viewport.clientWidth;
+
+		// acquire height map for currently visible rows
+		for (let v = 0; v < rows.length; v += 1) {
+			height_map[start + v] = rows[v].getBoundingClientRect().height;
+		}
+		let i = 0;
+		let y = head_height;
+		// loop items to find new start
+		while (i < sortedItems.length) {
+			const row_height = height_map[i] || average_height;
+			// keep a page of rows buffered above
+			if (y + row_height > scrollTop - max_height) {
+				start = i;
+				top = y - head_height;
+				break;
+			}
+			y += row_height;
+			i += 1;
+		}
+
+		let content_height = head_height;
+		while (i < sortedItems.length) {
+			const row_height = height_map[i] || average_height;
+			content_height += row_height;
+			i += 1;
+			// keep a page of rows buffered below
+			if (content_height - head_height > 3 * max_height) {
+				break;
+			}
+		}
+
+		end = i;
+		const remaining = sortedItems.length - end;
+
+		const scrollbar_height = viewport.offsetHeight - viewport.clientHeight;
+		if (scrollbar_height > 0) {
+			content_height += scrollbar_height;
+		}
+
+		let filtered_height_map = height_map.filter((v) => typeof v === "number");
+		average_height =
+			filtered_height_map.reduce((a, b) => a + b, 0) /
+				filtered_height_map.length || 30;
+
+		bottom = remaining * average_height;
+		if (!isFinite(bottom)) {
+			bottom = 200000;
+		}
+		height_map.length = sortedItems.length;
+		while (i < sortedItems.length) {
+			i += 1;
+			height_map[i] = average_height;
+		}
+		if (max_height && content_height > max_height) {
+			actual_height = max_height;
+		} else {
+			actual_height = content_height;
+		}
+	}
+
+	$: scroll_and_render(selected);
+
+	async function scroll_and_render(n: number | false): Promise<void> {
+		raf(async () => {
+			if (typeof n !== "number") return;
+			const direction = typeof n !== "number" ? false : is_in_view(n);
+			if (direction === true) {
+				return;
+			}
+			if (direction === "back") {
+				await scroll_to_index(n, { behavior: "instant" });
+			}
+
+			if (direction === "forwards") {
+				await scroll_to_index(n, { behavior: "instant" }, true);
+			}
+		});
+	}
+
+	function is_in_view(n: number): "back" | "forwards" | true {
+		const current = rows && rows[n - start];
+		if (!current && n < start) {
+			return "back";
+		}
+		if (!current && n >= end - 1) {
+			return "forwards";
+		}
+
+		const { top: viewport_top } = viewport.getBoundingClientRect();
+		const { top, bottom } = current.getBoundingClientRect();
+
+		if (top - viewport_top < 37) {
+			return "back";
+		}
+
+		if (bottom - viewport_top > viewport_height) {
+			return "forwards";
+		}
+
+		return true;
+	}
+
+	export async function scroll_to_index(
+		index: number,
+		opts: ScrollToOptions,
+		align_end = false
+	): Promise<void> {
+		await tick();
+
+		const _itemHeight = average_height;
+
+		let distance = index * _itemHeight;
+		if (align_end) {
+			distance = distance - viewport_height + _itemHeight + head_height;
+		}
+
+		const scrollbar_height = viewport.offsetHeight - viewport.clientHeight;
+		if (scrollbar_height > 0) {
+			distance += scrollbar_height;
+		}
+
+		const _opts = {
+			top: distance,
+			behavior: "smooth" as ScrollBehavior,
+			...opts
+		};
+
+		viewport.scrollTo(_opts);
+	}
+
+	$: sortedItems = items;
+
+	$: visible = is_browser
+		? sortedItems.slice(start, end).map((data, i) => {
+				return { index: i + start, data };
+			})
+		: sortedItems
+				.slice(0, (max_height / sortedItems.length) * average_height + 1)
+				.map((data, i) => {
+					return { index: i + start, data };
+				});
+
+	onMount(() => {
+		rows = contents.children as HTMLCollectionOf<HTMLTableRowElement>;
+		mounted = true;
+	});
+</script>
+
+<svelte-virtual-table-viewport>
+	<div>
+		<table
+			class="table"
+			class:disable-scroll={disable_scroll}
+			bind:this={viewport}
+			bind:contentRect={viewport_box}
+			on:scroll={refresh_height_map}
+			style="height: {height}; --bw-svt-p-top: {top}px; --bw-svt-p-bottom: {bottom}px; --bw-svt-head-height: {head_height}px; --bw-svt-foot-height: {foot_height}px; --bw-svt-avg-row-height: {average_height}px; --max-height: {max_height}px"
+		>
+			{#if label && label.length !== 0}
+				<caption class="sr-only">{label}</caption>
+			{/if}
+			<thead class="thead" bind:offsetHeight={head_height}>
+				<slot name="thead" />
+			</thead>
+			<tbody bind:this={contents} class="tbody">
+				{#if visible.length && visible[0].data.length}
+					{#each visible as item (item.data[0].id)}
+						<slot name="tbody" item={item.data} index={item.index}>
+							<tr>
+								<td>Missing Table Row</td>
+							</tr>
+						</slot>
+					{/each}
+				{/if}
+			</tbody>
+			<tfoot class="tfoot" bind:offsetHeight={foot_height}>
+				<slot name="tfoot" />
+			</tfoot>
+		</table>
+	</div>
+</svelte-virtual-table-viewport>
+
+<style type="text/css">
+	table {
+		position: relative;
+		overflow: auto;
+		-webkit-overflow-scrolling: touch;
+		max-height: var(--max-height);
+		box-sizing: border-box;
+		display: block;
+		padding: 0;
+		margin: 0;
+		color: var(--body-text-color);
+		font-size: var(--input-text-size);
+		line-height: var(--line-md);
+		font-family: var(--font-mono);
+		border-spacing: 0;
+		width: 100%;
+		scroll-snap-type: x proximity;
+		border-collapse: separate;
+		scrollbar-width: thin;
+		scrollbar-color: rgba(128, 128, 128, 0.5) transparent;
+	}
+
+	table::-webkit-scrollbar {
+		width: 4px;
+		height: 4px;
+	}
+
+	table::-webkit-scrollbar-track {
+		background: transparent;
+	}
+
+	table::-webkit-scrollbar-thumb {
+		background-color: rgba(128, 128, 128, 0.5);
+		border-radius: 4px;
+	}
+
+	table:hover {
+		scrollbar-color: rgba(160, 160, 160, 0.7) transparent;
+	}
+
+	table:hover::-webkit-scrollbar-thumb {
+		background-color: rgba(160, 160, 160, 0.7);
+		border-radius: 4px;
+		width: 4px;
+	}
+
+	@media (hover: none) {
+		table {
+			scrollbar-color: rgba(160, 160, 160, 0.7) transparent;
+		}
+
+		table::-webkit-scrollbar-thumb {
+			background-color: rgba(160, 160, 160, 0.7);
+			border-radius: 4px;
+		}
+	}
+
+	@media (pointer: coarse) {
+		table::-webkit-scrollbar {
+			width: 8px;
+			height: 8px;
+		}
+	}
+
+	table :is(thead, tfoot, tbody) {
+		display: table;
+		table-layout: fixed;
+		width: 100%;
+		box-sizing: border-box;
+	}
+
+	tbody {
+		overflow-x: scroll;
+		overflow-y: hidden;
+	}
+
+	table tbody {
+		padding-top: var(--bw-svt-p-top);
+		padding-bottom: var(--bw-svt-p-bottom);
+	}
+	tbody {
+		position: relative;
+		box-sizing: border-box;
+		border: 0px solid currentColor;
+	}
+
+	tbody > :global(tr:last-child) {
+		border: none;
+	}
+
+	table :global(td) {
+		scroll-snap-align: start;
+	}
+
+	tbody :global(td.pinned-column) {
+		position: sticky;
+		z-index: 3;
+	}
+
+	tbody :global(tr:nth-child(odd)) :global(td.pinned-column) {
+		background: var(--table-odd-background-fill);
+	}
+
+	tbody :global(tr:nth-child(even)) :global(td.pinned-column) {
+		background: var(--table-even-background-fill);
+	}
+
+	tbody :global(td.last-pinned) {
+		border-right: 1px solid var(--border-color-primary);
+	}
+
+	thead {
+		position: sticky;
+		top: 0;
+		left: 0;
+		background: var(--background-fill-primary);
+		z-index: 7;
+	}
+
+	thead :global(th) {
+		background: var(--table-even-background-fill) !important;
+	}
+
+	thead :global(th.pinned-column) {
+		position: sticky;
+		z-index: 7;
+		background: var(--table-even-background-fill) !important;
+	}
+
+	thead :global(th.last-pinned) {
+		border-right: 1px solid var(--border-color-primary);
+	}
+
+	.table.disable-scroll {
+		overflow: hidden !important;
+	}
+</style>

5.49.1/dataframe/shared/context/dataframe_context.ts

@@ -0,0 +1,701 @@
+import { getContext, setContext } from "svelte";
+import { dequal } from "dequal";
+import { writable, get } from "svelte/store";
+import { sort_table_data } from "../utils/table_utils";
+import type { CellValue } from "../types";
+import { tick } from "svelte";
+import {
+	handle_selection,
+	get_next_cell_coordinates,
+	get_range_selection,
+	move_cursor
+} from "../utils/selection_utils";
+
+export const DATAFRAME_KEY = Symbol("dataframe");
+
+export type SortDirection = "asc" | "desc";
+export type FilterDatatype = "string" | "number";
+export type CellCoordinate = [number, number];
+
+interface DataFrameState {
+	config: {
+		show_fullscreen_button: boolean;
+		show_copy_button: boolean;
+		show_search: "none" | "search" | "filter";
+		show_row_numbers: boolean;
+		editable: boolean;
+		pinned_columns: number;
+		show_label: boolean;
+		line_breaks: boolean;
+		wrap: boolean;
+		max_height: number;
+		column_widths: string[];
+		max_chars?: number;
+		static_columns?: CellValue[];
+	};
+	current_search_query: string | null;
+	sort_state: {
+		sort_columns: { col: number; direction: SortDirection }[];
+		row_order: number[];
+		initial_data: {
+			data: { id: string; value: CellValue }[][];
+			display_value: string[][] | null;
+			styling: string[][] | null;
+		} | null;
+	};
+	filter_state: {
+		filter_columns: {
+			col: number;
+			datatype: FilterDatatype;
+			filter: string;
+			value: string;
+		}[];
+		initial_data: {
+			data: { id: string; value: CellValue }[][];
+			display_value: string[][] | null;
+			styling: string[][] | null;
+		} | null;
+	};
+	ui_state: {
+		active_cell_menu: { row: number; col: number; x: number; y: number } | null;
+		active_header_menu: { col: number; x: number; y: number } | null;
+		selected_cells: CellCoordinate[];
+		selected: CellCoordinate | false;
+		editing: CellCoordinate | false;
+		header_edit: number | false;
+		selected_header: number | false;
+		active_button: {
+			type: "header" | "cell";
+			row?: number;
+			col: number;
+		} | null;
+		copy_flash: boolean;
+	};
+}
+
+interface DataFrameActions {
+	handle_search: (query: string | null) => void;
+	handle_sort: (col: number, direction: SortDirection) => void;
+	handle_filter: (
+		col: number,
+		datatype: FilterDatatype,
+		filter: string,
+		value: string
+	) => void;
+	get_sort_status: (name: string, headers: string[]) => "none" | "asc" | "desc";
+	sort_data: (
+		data: any[][],
+		display_value: string[][] | null,
+		styling: string[][] | null
+	) => void;
+	update_row_order: (data: any[][]) => void;
+	filter_data: (data: any[][]) => any[][];
+	add_row: (data: any[][], make_id: () => string, index?: number) => any[][];
+	add_col: (
+		data: any[][],
+		headers: string[],
+		make_id: () => string,
+		index?: number
+	) => { data: any[][]; headers: string[] };
+	add_row_at: (
+		data: any[][],
+		index: number,
+		position: "above" | "below",
+		make_id: () => string
+	) => any[][];
+	add_col_at: (
+		data: any[][],
+		headers: string[],
+		index: number,
+		position: "left" | "right",
+		make_id: () => string
+	) => { data: any[][]; headers: string[] };
+	delete_row: (data: any[][], index: number) => any[][];
+	delete_col: (
+		data: any[][],
+		headers: string[],
+		index: number
+	) => { data: any[][]; headers: string[] };
+	delete_row_at: (data: any[][], index: number) => any[][];
+	delete_col_at: (
+		data: any[][],
+		headers: string[],
+		index: number
+	) => { data: any[][]; headers: string[] };
+	trigger_change: (
+		data: any[][],
+		headers: any[],
+		previous_data: any[][],
+		previous_headers: string[],
+		value_is_output: boolean,
+		dispatch: (e: "change" | "input" | "edit", detail?: any) => void
+	) => Promise<void>;
+	reset_sort_state: () => void;
+	reset_filter_state: () => void;
+	set_active_cell_menu: (
+		menu: { row: number; col: number; x: number; y: number } | null
+	) => void;
+	set_active_header_menu: (
+		menu: { col: number; x: number; y: number } | null
+	) => void;
+	set_selected_cells: (cells: CellCoordinate[]) => void;
+	set_selected: (selected: CellCoordinate | false) => void;
+	set_editing: (editing: CellCoordinate | false) => void;
+	clear_ui_state: () => void;
+	set_header_edit: (header_index: number | false) => void;
+	set_selected_header: (header_index: number | false) => void;
+	handle_header_click: (col: number, editable: boolean) => void;
+	end_header_edit: (key: string) => void;
+	get_selected_cells: () => CellCoordinate[];
+	get_active_cell_menu: () => {
+		row: number;
+		col: number;
+		x: number;
+		y: number;
+	} | null;
+	get_active_button: () => {
+		type: "header" | "cell";
+		row?: number;
+		col: number;
+	} | null;
+	set_active_button: (
+		button: { type: "header" | "cell"; row?: number; col: number } | null
+	) => void;
+	set_copy_flash: (value: boolean) => void;
+	handle_cell_click: (event: MouseEvent, row: number, col: number) => void;
+	toggle_cell_menu: (event: MouseEvent, row: number, col: number) => void;
+	toggle_cell_button: (row: number, col: number) => void;
+	handle_select_column: (col: number) => void;
+	handle_select_row: (row: number) => void;
+	get_next_cell_coordinates: typeof get_next_cell_coordinates;
+	get_range_selection: typeof get_range_selection;
+	move_cursor: typeof move_cursor;
+}
+
+export interface DataFrameContext {
+	state: ReturnType<typeof writable<DataFrameState>>;
+	actions: DataFrameActions;
+	data?: any[][];
+	headers?: { id: string; value: string }[];
+	display_value?: string[][] | null;
+	styling?: string[][] | null;
+	els?: Record<
+		string,
+		{ cell: HTMLTableCellElement | null; input: HTMLTextAreaElement | null }
+	>;
+	parent_element?: HTMLElement;
+	get_data_at?: (row: number, col: number) => CellValue;
+	get_column?: (col: number) => CellValue[];
+	get_row?: (row: number) => CellValue[];
+	dispatch?: (e: "change" | "select" | "search" | "edit", detail?: any) => void;
+}
+
+function create_actions(
+	state: ReturnType<typeof writable<DataFrameState>>,
+	context: DataFrameContext
+): DataFrameActions {
+	const update_state = (
+		updater: (s: DataFrameState) => Partial<DataFrameState>
+	): void => state.update((s) => ({ ...s, ...updater(s) }));
+
+	const add_row = (
+		data: any[][],
+		make_id: () => string,
+		index?: number
+	): any[][] => {
+		const new_row = data[0]?.length
+			? Array(data[0].length)
+					.fill(null)
+					.map(() => ({ value: "", id: make_id() }))
+			: [{ value: "", id: make_id() }];
+		const new_data = [...data];
+		index !== undefined
+			? new_data.splice(index, 0, new_row)
+			: new_data.push(new_row);
+		return new_data;
+	};
+
+	const add_col = (
+		data: any[][],
+		headers: string[],
+		make_id: () => string,
+		index?: number
+	): { data: any[][]; headers: string[] } => {
+		const new_headers = [...headers, `Header ${headers.length + 1}`];
+		const new_data = data.map((row) => [...row, { value: "", id: make_id() }]);
+		if (index !== undefined) {
+			new_headers.splice(index, 0, new_headers.pop()!);
+			new_data.forEach((row) => row.splice(index, 0, row.pop()!));
+		}
+		return { data: new_data, headers: new_headers };
+	};
+
+	const update_array = (
+		source: { id: string; value: CellValue }[][] | string[][] | null,
+		target: any[] | null | undefined
+	): void => {
+		if (source && target) {
+			target.splice(0, target.length, ...JSON.parse(JSON.stringify(source)));
+		}
+	};
+
+	return {
+		handle_search: (query) =>
+			update_state((s) => ({ current_search_query: query })),
+		handle_sort: (col, direction) =>
+			update_state((s) => {
+				const sort_cols = s.sort_state.sort_columns.filter(
+					(c) => c.col !== col
+				);
+				if (
+					!s.sort_state.sort_columns.some(
+						(c) => c.col === col && c.direction === direction
+					)
+				) {
+					sort_cols.push({ col, direction });
+				}
+
+				const initial_data =
+					s.sort_state.initial_data ||
+					(context.data && sort_cols.length > 0
+						? {
+								data: JSON.parse(JSON.stringify(context.data)),
+								display_value: context.display_value
+									? JSON.parse(JSON.stringify(context.display_value))
+									: null,
+								styling: context.styling
+									? JSON.parse(JSON.stringify(context.styling))
+									: null
+							}
+						: null);
+
+				return {
+					sort_state: {
+						...s.sort_state,
+						sort_columns: sort_cols.slice(-3),
+						initial_data: initial_data
+					}
+				};
+			}),
+		handle_filter: (col, datatype, filter, value) =>
+			update_state((s) => {
+				const filter_cols = s.filter_state.filter_columns.some(
+					(c) => c.col === col
+				)
+					? s.filter_state.filter_columns.filter((c) => c.col !== col)
+					: [
+							...s.filter_state.filter_columns,
+							{ col, datatype, filter, value }
+						];
+
+				const initial_data =
+					s.filter_state.initial_data ||
+					(context.data && filter_cols.length > 0
+						? {
+								data: JSON.parse(JSON.stringify(context.data)),
+								display_value: context.display_value
+									? JSON.parse(JSON.stringify(context.display_value))
+									: null,
+								styling: context.styling
+									? JSON.parse(JSON.stringify(context.styling))
+									: null
+							}
+						: null);
+
+				return {
+					filter_state: {
+						...s.filter_state,
+						filter_columns: filter_cols,
+						initial_data: initial_data
+					}
+				};
+			}),
+		get_sort_status: (name, headers) => {
+			const s = get(state);
+			const sort_item = s.sort_state.sort_columns.find(
+				(item) => headers[item.col] === name
+			);
+			return sort_item ? sort_item.direction : "none";
+		},
+		sort_data: (data, display_value, styling) => {
+			const {
+				sort_state: { sort_columns }
+			} = get(state);
+			if (sort_columns.length)
+				sort_table_data(data, display_value, styling, sort_columns);
+		},
+		update_row_order: (data) =>
+			update_state((s) => ({
+				sort_state: {
+					...s.sort_state,
+					row_order:
+						s.sort_state.sort_columns.length && data[0]
+							? [...Array(data.length)]
+									.map((_, i) => i)
+									.sort((a, b) => {
+										for (const { col, direction } of s.sort_state
+											.sort_columns) {
+											const comp =
+												(data[a]?.[col]?.value ?? "") <
+												(data[b]?.[col]?.value ?? "")
+													? -1
+													: 1;
+											if (comp) return direction === "asc" ? comp : -comp;
+										}
+										return 0;
+									})
+							: [...Array(data.length)].map((_, i) => i)
+				}
+			})),
+		filter_data: (data) => {
+			const query = get(state).current_search_query?.toLowerCase();
+			return query
+				? data.filter((row) =>
+						row.some((cell) =>
+							String(cell?.value).toLowerCase().includes(query)
+						)
+					)
+				: data;
+		},
+		add_row,
+		add_col,
+		add_row_at: (data, index, position, make_id) =>
+			add_row(data, make_id, position === "above" ? index : index + 1),
+		add_col_at: (data, headers, index, position, make_id) =>
+			add_col(data, headers, make_id, position === "left" ? index : index + 1),
+		delete_row: (data, index) =>
+			data.length > 1 ? data.filter((_, i) => i !== index) : data,
+		delete_col: (data, headers, index) =>
+			headers.length > 1
+				? {
+						data: data.map((row) => row.filter((_, i) => i !== index)),
+						headers: headers.filter((_, i) => i !== index)
+					}
+				: { data, headers },
+		delete_row_at: (data, index) =>
+			data.length > 1
+				? [...data.slice(0, index), ...data.slice(index + 1)]
+				: data,
+		delete_col_at: (data, headers, index) =>
+			headers.length > 1
+				? {
+						data: data.map((row) => [
+							...row.slice(0, index),
+							...row.slice(index + 1)
+						]),
+						headers: [...headers.slice(0, index), ...headers.slice(index + 1)]
+					}
+				: { data, headers },
+		trigger_change: async (
+			data,
+			headers,
+			previous_data,
+			previous_headers,
+			value_is_output,
+			dispatch
+		) => {
+			const s = get(state);
+			if (s.current_search_query) return;
+
+			const current_headers = headers.map((h) => h.value);
+			const current_data = data.map((row) => row.map((cell) => cell.value));
+
+			if (
+				!dequal(current_data, previous_data) ||
+				!dequal(current_headers, previous_headers)
+			) {
+				if (!dequal(current_headers, previous_headers)) {
+					update_state((s) => ({
+						sort_state: { sort_columns: [], row_order: [], initial_data: null },
+						filter_state: { filter_columns: [], initial_data: null }
+					}));
+				}
+				dispatch("change", {
+					data: data.map((row) => row.map((cell) => cell.value)),
+					headers: current_headers,
+					metadata: null
+				});
+				const index = s.ui_state.selected;
+				if (index) {
+					dispatch("edit", {
+						index,
+						value: data[index[0]][index[1]].value,
+						previous_value: previous_data[index[0]][index[1]]
+					});
+				}
+				if (!value_is_output) dispatch("input");
+			}
+		},
+		reset_sort_state: () =>
+			update_state((s) => {
+				if (s.sort_state.initial_data && context.data) {
+					const original = s.sort_state.initial_data;
+
+					update_array(original.data, context.data);
+					update_array(original.display_value, context.display_value);
+					update_array(original.styling, context.styling);
+				}
+
+				return {
+					sort_state: { sort_columns: [], row_order: [], initial_data: null }
+				};
+			}),
+		reset_filter_state: () =>
+			update_state((s) => {
+				if (s.filter_state.initial_data && context.data) {
+					const original = s.filter_state.initial_data;
+
+					update_array(original.data, context.data);
+					update_array(original.display_value, context.display_value);
+					update_array(original.styling, context.styling);
+				}
+
+				return {
+					filter_state: { filter_columns: [], initial_data: null }
+				};
+			}),
+		set_active_cell_menu: (menu) =>
+			update_state((s) => ({
+				ui_state: { ...s.ui_state, active_cell_menu: menu }
+			})),
+		set_active_header_menu: (menu) =>
+			update_state((s) => ({
+				ui_state: { ...s.ui_state, active_header_menu: menu }
+			})),
+		set_selected_cells: (cells) =>
+			update_state((s) => ({
+				ui_state: { ...s.ui_state, selected_cells: cells }
+			})),
+		set_selected: (selected) =>
+			update_state((s) => ({ ui_state: { ...s.ui_state, selected } })),
+		set_editing: (editing) =>
+			update_state((s) => ({ ui_state: { ...s.ui_state, editing } })),
+		clear_ui_state: () =>
+			update_state((s) => ({
+				ui_state: {
+					active_cell_menu: null,
+					active_header_menu: null,
+					selected_cells: [],
+					selected: false,
+					editing: false,
+					header_edit: false,
+					selected_header: false,
+					active_button: null,
+					copy_flash: false
+				}
+			})),
+		set_header_edit: (header_index) =>
+			update_state((s) => ({
+				ui_state: {
+					...s.ui_state,
+					selected_cells: [],
+					selected_header: header_index,
+					header_edit: header_index
+				}
+			})),
+		set_selected_header: (header_index) =>
+			update_state((s) => ({
+				ui_state: {
+					...s.ui_state,
+					selected_header: header_index,
+					selected: false,
+					selected_cells: []
+				}
+			})),
+		handle_header_click: (col, editable) =>
+			update_state((s) => ({
+				ui_state: {
+					...s.ui_state,
+					active_cell_menu: null,
+					active_header_menu: null,
+					selected: false,
+					selected_cells: [],
+					selected_header: col,
+					header_edit: editable ? col : false
+				}
+			})),
+		end_header_edit: (key) => {
+			if (["Escape", "Enter", "Tab"].includes(key)) {
+				update_state((s) => ({
+					ui_state: { ...s.ui_state, selected: false, header_edit: false }
+				}));
+			}
+		},
+		get_selected_cells: () => get(state).ui_state.selected_cells,
+		get_active_cell_menu: () => get(state).ui_state.active_cell_menu,
+		get_active_button: () => get(state).ui_state.active_button,
+		set_active_button: (button) =>
+			update_state((s) => ({
+				ui_state: { ...s.ui_state, active_button: button }
+			})),
+		set_copy_flash: (value) =>
+			update_state((s) => ({ ui_state: { ...s.ui_state, copy_flash: value } })),
+		handle_cell_click: (event, row, col) => {
+			event.preventDefault();
+			event.stopPropagation();
+
+			const s = get(state);
+			if (s.config.show_row_numbers && col === -1) return;
+
+			let actual_row = row;
+			if (s.current_search_query && context.data) {
+				const filtered_indices: number[] = [];
+				context.data.forEach((dataRow, idx) => {
+					if (
+						dataRow.some((cell) =>
+							String(cell?.value)
+								.toLowerCase()
+								.includes(s.current_search_query?.toLowerCase() || "")
+						)
+					) {
+						filtered_indices.push(idx);
+					}
+				});
+				actual_row = filtered_indices[row] ?? row;
+			}
+
+			const cells = handle_selection(
+				[actual_row, col],
+				s.ui_state.selected_cells,
+				event
+			);
+			update_state((s) => ({
+				ui_state: {
+					...s.ui_state,
+					active_cell_menu: null,
+					active_header_menu: null,
+					selected_header: false,
+					header_edit: false,
+					selected_cells: cells,
+					selected: cells[0]
+				}
+			}));
+
+			if (s.config.editable && cells.length === 1) {
+				update_state((s) => ({
+					ui_state: { ...s.ui_state, editing: [actual_row, col] }
+				}));
+				tick().then(() =>
+					context.els![context.data![actual_row][col].id]?.input?.focus()
+				);
+			} else {
+				// ensure parent has focus for keyboard navigation
+				tick().then(() => {
+					if (context.parent_element) {
+						context.parent_element.focus();
+					}
+				});
+			}
+
+			context.dispatch?.("select", {
+				index: [actual_row, col],
+				col_value: context.get_column!(col),
+				row_value: context.get_row!(actual_row),
+				value: context.get_data_at!(actual_row, col)
+			});
+		},
+		toggle_cell_menu: (event, row, col) => {
+			event.stopPropagation();
+			const current_menu = get(state).ui_state.active_cell_menu;
+			if (current_menu?.row === row && current_menu.col === col) {
+				update_state((s) => ({
+					ui_state: { ...s.ui_state, active_cell_menu: null }
+				}));
+			} else {
+				const cell = (event.target as HTMLElement).closest("td");
+				if (cell) {
+					const rect = cell.getBoundingClientRect();
+					update_state((s) => ({
+						ui_state: {
+							...s.ui_state,
+							active_cell_menu: { row, col, x: rect.right, y: rect.bottom }
+						}
+					}));
+				}
+			}
+		},
+		toggle_cell_button: (row, col) => {
+			const current_button = get(state).ui_state.active_button;
+			const new_button =
+				current_button?.type === "cell" &&
+				current_button.row === row &&
+				current_button.col === col
+					? null
+					: { type: "cell" as const, row, col };
+			update_state((s) => ({
+				ui_state: { ...s.ui_state, active_button: new_button }
+			}));
+		},
+		handle_select_column: (col) => {
+			if (!context.data) return;
+			const cells = context.data.map((_, row) => [row, col] as CellCoordinate);
+			update_state((s) => ({
+				ui_state: {
+					...s.ui_state,
+					selected_cells: cells,
+					selected: cells[0],
+					editing: false
+				}
+			}));
+			setTimeout(() => context.parent_element?.focus(), 0);
+		},
+		handle_select_row: (row) => {
+			if (!context.data || !context.data[0]) return;
+			const cells = context.data[0].map(
+				(_, col) => [row, col] as CellCoordinate
+			);
+			update_state((s) => ({
+				ui_state: {
+					...s.ui_state,
+					selected_cells: cells,
+					selected: cells[0],
+					editing: false
+				}
+			}));
+			setTimeout(() => context.parent_element?.focus(), 0);
+		},
+		get_next_cell_coordinates,
+		get_range_selection,
+		move_cursor
+	};
+}
+
+export function create_dataframe_context(
+	config: DataFrameState["config"]
+): DataFrameContext {
+	const state = writable<DataFrameState>({
+		config,
+		current_search_query: null,
+		sort_state: { sort_columns: [], row_order: [], initial_data: null },
+		filter_state: { filter_columns: [], initial_data: null },
+		ui_state: {
+			active_cell_menu: null,
+			active_header_menu: null,
+			selected_cells: [],
+			selected: false,
+			editing: false,
+			header_edit: false,
+			selected_header: false,
+			active_button: null,
+			copy_flash: false
+		}
+	});
+
+	const context: DataFrameContext = { state, actions: null as any };
+	context.actions = create_actions(state, context);
+
+	const instance_id = Symbol(
+		`dataframe_${Math.random().toString(36).substring(2)}`
+	);
+	setContext(instance_id, context);
+	setContext(DATAFRAME_KEY, { instance_id, context });
+
+	return context;
+}
+
+export function get_dataframe_context(): DataFrameContext {
+	const ctx = getContext<{ instance_id: symbol; context: DataFrameContext }>(
+		DATAFRAME_KEY
+	);
+	return ctx?.context ?? getContext<DataFrameContext>(DATAFRAME_KEY);
+}

5.49.1/dataframe/shared/icons/FilterIcon.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">
+</script>
+
+<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+	<path
+		d="M4 4h16v2.67l-6.67 6.67v8L9.33 19v-5.66L2.67 6.67V4h1.33z"
+		stroke="currentColor"
+		stroke-width="2"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	/>
+</svg>

5.49.1/dataframe/shared/icons/Padlock.svelte

@@ -0,0 +1,24 @@
+<div class="wrapper" aria-label="Static column">
+	<svg
+		xmlns="http://www.w3.org/2000/svg"
+		width="13"
+		height="13"
+		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>

5.49.1/dataframe/shared/icons/SelectionButtons.svelte

@@ -0,0 +1,93 @@
+<script lang="ts">
+	export let position: "column" | "row";
+	export let coords: [number, number];
+	export let on_click: (() => void) | null = null;
+
+	$: is_first_position =
+		position === "column" ? coords[0] === 0 : coords[1] === 0;
+	$: direction =
+		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}`
+		: ''}"
+	on:click|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);
+		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);
+		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>

5.49.1/dataframe/shared/icons/SortArrowDown.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	export let size = 16;
+</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>

5.49.1/dataframe/shared/icons/SortArrowUp.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	export let size = 16;
+</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>

5.49.1/dataframe/shared/icons/SortButtonDown.svelte

@@ -0,0 +1,14 @@
+<svg
+	viewBox="0 0 24 24"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+	focusable="false"
+>
+	<path
+		d="M7 10l5 5 5-5"
+		stroke="currentColor"
+		stroke-width="2"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	/>
+</svg>

5.49.1/dataframe/shared/icons/SortButtonUp.svelte

@@ -0,0 +1,15 @@
+<svg
+	viewBox="0 0 24 24"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+	aria-hidden="true"
+	focusable="false"
+>
+	<path
+		d="M7 14l5-5 5 5"
+		stroke="currentColor"
+		stroke-width="2"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	/>
+</svg>

5.49.1/dataframe/shared/icons/SortIcon.svelte

@@ -0,0 +1,72 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	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";
+	export let direction: SortDirection | null = null;
+	export let priority: number | null = null;
+	export let i18n: I18nFormatter;
+
+	const dispatch = createEventDispatcher<{ sort: SortDirection }>();
+</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"}
+		on:click={(event) => {
+			event.stopPropagation();
+			dispatch("sort", "asc");
+		}}
+	></IconButton>
+	<IconButton
+		size="x-small"
+		label={i18n("dataframe.sort_descending")}
+		Icon={SortButtonDown}
+		highlight={direction === "desc"}
+		on:click={(event) => {
+			event.stopPropagation();
+			dispatch("sort", "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>

5.49.1/dataframe/shared/types.ts

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

5.49.1/dataframe/shared/utils/data_processing.ts

@@ -0,0 +1,77 @@
+import type { Datatype, Headers, HeadersWithIDs } from "./utils";
+import type { CellValue } from "../types";
+import { cast_value_to_type } from "./utils";
+
+export function make_headers(
+	_head: Headers,
+	col_count: [number, "fixed" | "dynamic"],
+	els: Record<
+		string,
+		{ cell: null | HTMLTableCellElement; input: null | HTMLTextAreaElement }
+	>,
+	make_id: () => string
+): HeadersWithIDs {
+	let _h = _head || [];
+	if (col_count[1] === "fixed" && _h.length < col_count[0]) {
+		const fill = Array(col_count[0] - _h.length)
+			.fill("")
+			.map((_, i) => `${i + _h.length}`);
+		_h = _h.concat(fill);
+	}
+
+	if (!_h || _h.length === 0) {
+		return Array(col_count[0])
+			.fill(0)
+			.map((_, i) => {
+				const _id = make_id();
+				els[_id] = { cell: null, input: null };
+				return { id: _id, value: JSON.stringify(i + 1) };
+			});
+	}
+
+	return _h.map((h, i) => {
+		const _id = make_id();
+		els[_id] = { cell: null, input: null };
+		return { id: _id, value: h ?? "" };
+	});
+}
+
+export function process_data(
+	values: CellValue[][],
+	els: Record<
+		string,
+		{ cell: null | HTMLTableCellElement; input: null | HTMLTextAreaElement }
+	>,
+	data_binding: Record<string, any>,
+	make_id: () => string,
+	display_value: string[][] | null = null,
+	datatype: Datatype | Datatype[]
+): { id: string; value: CellValue; display_value?: string }[][] {
+	if (!values || values.length === 0) {
+		return [];
+	}
+
+	const result = values.map((row, i) => {
+		return row.map((value, j) => {
+			const _id = make_id();
+			els[_id] = { cell: null, input: null };
+			data_binding[_id] = value;
+
+			let display = display_value?.[i]?.[j];
+
+			if (display === undefined) {
+				display = String(value);
+			}
+
+			const dtype = Array.isArray(datatype) ? datatype[j] : datatype;
+
+			return {
+				id: _id,
+				value: cast_value_to_type(value, dtype),
+				display_value: display
+			};
+		});
+	});
+
+	return result;
+}

5.49.1/dataframe/shared/utils/drag_utils.ts

@@ -0,0 +1,105 @@
+import type { CellCoordinate } from "../types";
+import { get_range_selection } from "../utils/selection_utils";
+
+export type DragState = {
+	is_dragging: boolean;
+	drag_start: CellCoordinate | null;
+	mouse_down_pos: { x: number; y: number } | null;
+};
+
+export type DragHandlers = {
+	handle_mouse_down: (event: MouseEvent, row: number, col: number) => void;
+	handle_mouse_move: (event: MouseEvent) => void;
+	handle_mouse_up: (event: MouseEvent) => void;
+};
+
+export function create_drag_handlers(
+	state: DragState,
+	set_is_dragging: (value: boolean) => void,
+	set_selected_cells: (cells: CellCoordinate[]) => void,
+	set_selected: (cell: CellCoordinate | false) => void,
+	handle_cell_click: (event: MouseEvent, row: number, col: number) => void,
+	show_row_numbers: boolean,
+	parent_element?: HTMLElement
+): DragHandlers {
+	const start_drag = (event: MouseEvent, row: number, col: number): void => {
+		const target = event.target as HTMLElement;
+		const is_checkbox_click =
+			(target as HTMLInputElement).type === "checkbox" ||
+			target.closest('input[type="checkbox"]') ||
+			target.closest(".bool-cell");
+
+		if (
+			event.target instanceof HTMLAnchorElement ||
+			(show_row_numbers && col === -1) ||
+			is_checkbox_click
+		)
+			return;
+
+		event.preventDefault();
+		event.stopPropagation();
+
+		state.mouse_down_pos = { x: event.clientX, y: event.clientY };
+		state.drag_start = [row, col];
+
+		if (!event.shiftKey && !event.metaKey && !event.ctrlKey) {
+			set_selected_cells([[row, col]]);
+			set_selected([row, col]);
+			handle_cell_click(event, row, col);
+		}
+	};
+
+	const update_selection = (event: MouseEvent): void => {
+		const cell = (event.target as HTMLElement).closest("td");
+		if (!cell) return;
+
+		const row = parseInt(cell.getAttribute("data-row") || "0");
+		const col = parseInt(cell.getAttribute("data-col") || "0");
+
+		if (isNaN(row) || isNaN(col)) return;
+
+		const selection_range = get_range_selection(state.drag_start!, [row, col]);
+		set_selected_cells(selection_range);
+		set_selected([row, col]);
+	};
+
+	const end_drag = (event: MouseEvent): void => {
+		if (!state.is_dragging && state.drag_start) {
+			handle_cell_click(event, state.drag_start[0], state.drag_start[1]);
+		} else if (state.is_dragging && parent_element) {
+			parent_element.focus();
+		}
+
+		state.is_dragging = false;
+		set_is_dragging(false);
+		state.drag_start = null;
+		state.mouse_down_pos = null;
+	};
+
+	return {
+		handle_mouse_down: start_drag,
+
+		handle_mouse_move(event: MouseEvent): void {
+			if (!state.drag_start || !state.mouse_down_pos) return;
+
+			if (!(event.buttons & 1)) {
+				end_drag(event);
+				return;
+			}
+
+			const dx = Math.abs(event.clientX - state.mouse_down_pos.x);
+			const dy = Math.abs(event.clientY - state.mouse_down_pos.y);
+
+			if (!state.is_dragging && (dx > 3 || dy > 3)) {
+				state.is_dragging = true;
+				set_is_dragging(true);
+			}
+
+			if (state.is_dragging) {
+				update_selection(event);
+			}
+		},
+
+		handle_mouse_up: end_drag
+	};
+}

5.49.1/dataframe/shared/utils/filter_utils.ts

@@ -0,0 +1,208 @@
+import { filter_table_data } from "./table_utils";
+import type { CellValue } from "../types";
+
+export type FilterDatatype = "string" | "number";
+
+export function filter_data(
+	data: { id: string; value: CellValue }[][],
+	filter_columns: {
+		col: number;
+		datatype: FilterDatatype;
+		filter: string;
+		value: string;
+	}[]
+): number[] {
+	if (!data || !data.length || !data[0]) {
+		return [];
+	}
+	let row_indices = [...Array(data.length)].map((_, i) => i);
+
+	if (filter_columns.length > 0) {
+		filter_columns.forEach((column) => {
+			if (column.datatype === "string") {
+				switch (column.filter) {
+					case "Contains":
+						row_indices = row_indices.filter((i) =>
+							data[i][column.col]?.value.toString().includes(column.value)
+						);
+						break;
+					case "Does not contain":
+						row_indices = row_indices.filter(
+							(i) =>
+								!data[i][column.col]?.value.toString().includes(column.value)
+						);
+						break;
+					case "Starts with":
+						row_indices = row_indices.filter((i) =>
+							data[i][column.col]?.value.toString().startsWith(column.value)
+						);
+						break;
+					case "Ends with":
+						row_indices = row_indices.filter((i) =>
+							data[i][column.col]?.value.toString().endsWith(column.value)
+						);
+						break;
+					case "Is":
+						row_indices = row_indices.filter(
+							(i) => data[i][column.col]?.value.toString() === column.value
+						);
+						break;
+					case "Is not":
+						row_indices = row_indices.filter(
+							(i) => !(data[i][column.col]?.value.toString() === column.value)
+						);
+						break;
+					case "Is empty":
+						row_indices = row_indices.filter(
+							(i) => data[i][column.col]?.value.toString() === ""
+						);
+						break;
+					case "Is not empty":
+						row_indices = row_indices.filter(
+							(i) => !(data[i][column.col]?.value.toString() === "")
+						);
+						break;
+				}
+			} else if (column.datatype === "number") {
+				switch (column.filter) {
+					case "=":
+						row_indices = row_indices.filter((i) => {
+							if (
+								!isNaN(Number(data[i][column.col]?.value)) &&
+								!isNaN(Number(column.value))
+							) {
+								return (
+									Number(data[i][column.col]?.value) === Number(column.value)
+								);
+							}
+							return false;
+						});
+						break;
+					case "≠":
+						row_indices = row_indices.filter((i) => {
+							if (
+								!isNaN(Number(data[i][column.col]?.value)) &&
+								!isNaN(Number(column.value))
+							) {
+								return !(
+									Number(data[i][column.col]?.value) === Number(column.value)
+								);
+							}
+							return false;
+						});
+						break;
+					case ">":
+						row_indices = row_indices.filter((i) => {
+							if (
+								!isNaN(Number(data[i][column.col]?.value)) &&
+								!isNaN(Number(column.value))
+							) {
+								return (
+									Number(data[i][column.col]?.value) > Number(column.value)
+								);
+							}
+							return false;
+						});
+						break;
+					case "<":
+						row_indices = row_indices.filter((i) => {
+							if (
+								!isNaN(Number(data[i][column.col]?.value)) &&
+								!isNaN(Number(column.value))
+							) {
+								return (
+									Number(data[i][column.col]?.value) < Number(column.value)
+								);
+							}
+							return false;
+						});
+						break;
+					case "≥":
+						row_indices = row_indices.filter((i) => {
+							if (
+								!isNaN(Number(data[i][column.col]?.value)) &&
+								!isNaN(Number(column.value))
+							) {
+								return (
+									Number(data[i][column.col]?.value) >= Number(column.value)
+								);
+							}
+							return false;
+						});
+						break;
+					case "≤":
+						row_indices = row_indices.filter((i) => {
+							if (
+								!isNaN(Number(data[i][column.col]?.value)) &&
+								!isNaN(Number(column.value))
+							) {
+								return (
+									Number(data[i][column.col]?.value) <= Number(column.value)
+								);
+							}
+							return false;
+						});
+						break;
+					case "Is empty":
+						row_indices = row_indices.filter(
+							(i) => data[i][column.col]?.value.toString() === ""
+						);
+						break;
+					case "Is not empty":
+						row_indices = row_indices.filter((i) => {
+							if (!isNaN(Number(data[i][column.col]?.value))) {
+								return !(data[i][column.col]?.value.toString() === "");
+							}
+							return false;
+						});
+						break;
+				}
+			}
+		});
+		return row_indices;
+	}
+	return [...Array(data.length)].map((_, i) => i);
+}
+
+export function filter_data_and_preserve_selection(
+	data: { id: string; value: CellValue }[][],
+	display_value: string[][] | null,
+	styling: string[][] | null,
+	filter_columns: {
+		col: number;
+		datatype: FilterDatatype;
+		filter: string;
+		value: string;
+	}[],
+	selected: [number, number] | false,
+	get_current_indices: (
+		id: string,
+		data: { id: string; value: CellValue }[][]
+	) => [number, number],
+	original_data?: { id: string; value: CellValue }[][],
+	original_display_value?: string[][] | null,
+	original_styling?: string[][] | null
+): { data: typeof data; selected: [number, number] | false } {
+	let id = null;
+	if (selected && selected[0] in data && selected[1] in data[selected[0]]) {
+		id = data[selected[0]][selected[1]].id;
+	}
+
+	filter_table_data(
+		data,
+		display_value,
+		styling,
+		filter_columns,
+		original_data,
+		original_display_value,
+		original_styling
+	);
+
+	let new_selected = selected;
+	if (id) {
+		const [i, j] = get_current_indices(id, data);
+		new_selected = [i, j];
+	}
+
+	return { data, selected: new_selected };
+}

5.49.1/dataframe/shared/utils/keyboard_utils.ts

@@ -0,0 +1,309 @@
+import { dequal } from "dequal/lite";
+import { handle_delete_key } from "../utils/selection_utils";
+import type { DataFrameContext } from "../context/dataframe_context";
+import { tick } from "svelte";
+import { get } from "svelte/store";
+import { copy_table_data } from "./table_utils";
+
+async function save_cell_value(
+	input_value: string,
+	ctx: DataFrameContext,
+	row: number,
+	col: number
+): Promise<void> {
+	if (!ctx.data || !ctx.data[row] || !ctx.data[row][col]) return;
+
+	const old_value = ctx.data[row][col].value;
+	ctx.data[row][col].value = input_value;
+	if (ctx.data[row][col].display_value !== undefined) {
+		ctx.data[row][col].display_value = input_value;
+	}
+
+	if (old_value !== input_value && ctx.dispatch) {
+		ctx.dispatch("change", {
+			data: ctx.data.map((row) => row.map((cell) => cell.value)),
+			headers: ctx.headers?.map((h) => h.value) || [],
+			metadata: null
+		});
+	}
+
+	ctx.actions.set_selected([row, col]);
+}
+
+export async function handle_cell_blur(
+	event: FocusEvent,
+	ctx: DataFrameContext,
+	coords: [number, number]
+): Promise<void> {
+	if (!ctx.data || !ctx.headers || !ctx.els) return;
+
+	const input_el = event.target as HTMLInputElement;
+	if (!input_el || input_el.value === undefined) return;
+
+	await save_cell_value(input_el.value, ctx, coords[0], coords[1]);
+}
+
+function handle_header_navigation(
+	event: KeyboardEvent,
+	ctx: DataFrameContext
+): boolean {
+	const state = get(ctx.state);
+	const selected_header = state.ui_state.selected_header;
+	const header_edit = state.ui_state.header_edit;
+	const headers = ctx.headers || [];
+
+	if (selected_header === false || header_edit !== false) return false;
+
+	switch (event.key) {
+		case "ArrowDown":
+			ctx.actions.set_selected_header(false);
+			ctx.actions.set_selected([0, selected_header as number]);
+			ctx.actions.set_selected_cells([[0, selected_header as number]]);
+			return true;
+		case "ArrowLeft":
+			ctx.actions.set_selected_header(
+				selected_header > 0 ? selected_header - 1 : selected_header
+			);
+			return true;
+		case "ArrowRight":
+			ctx.actions.set_selected_header(
+				selected_header < headers.length - 1
+					? selected_header + 1
+					: selected_header
+			);
+			return true;
+		case "Escape":
+			event.preventDefault();
+			ctx.actions.set_selected_header(false);
+			return true;
+		case "Enter":
+			event.preventDefault();
+			if (state.config.editable) {
+				ctx.actions.set_header_edit(selected_header);
+			}
+			return true;
+	}
+	return false;
+}
+
+// eslint-disable-next-line complexity
+function handle_delete_operation(
+	event: KeyboardEvent,
+	ctx: DataFrameContext
+): boolean {
+	if (!ctx.data || !ctx.headers || !ctx.els || !ctx.dispatch) return false;
+
+	const state = get(ctx.state);
+	if (!state.config.editable) return false;
+	if (event.key !== "Delete" && event.key !== "Backspace") return false;
+
+	const editing = state.ui_state.editing;
+	const selected_cells = state.ui_state.selected_cells;
+
+	const static_columns = state.config.static_columns || [];
+	if (selected_cells.some(([_, col]) => static_columns.includes(col))) {
+		return false;
+	}
+
+	if (editing) {
+		const [row, col] = editing;
+		const input_el = ctx.els[ctx.data[row][col].id]?.input;
+		if (input_el && input_el.selectionStart !== input_el.selectionEnd) {
+			return false;
+		}
+		if (
+			event.key === "Delete" &&
+			input_el?.selectionStart !== input_el?.value.length
+		) {
+			return false;
+		}
+		if (event.key === "Backspace" && input_el?.selectionStart !== 0) {
+			return false;
+		}
+	}
+
+	event.preventDefault();
+	if (selected_cells.length > 0) {
+		const new_data = handle_delete_key(ctx.data, selected_cells);
+		ctx.dispatch("change", {
+			data: new_data.map((row) => row.map((cell) => cell.value)),
+			headers: ctx.headers.map((h) => h.value),
+			metadata: null
+		});
+	}
+	return true;
+}
+
+function handle_arrow_keys(
+	event: KeyboardEvent,
+	ctx: DataFrameContext,
+	i: number,
+	j: number
+): boolean {
+	const state = get(ctx.state);
+	const editing = state.ui_state.editing;
+	const selected_cells = state.ui_state.selected_cells;
+
+	if (editing) return false;
+	if (!ctx.data) return false;
+
+	event.preventDefault();
+
+	const next_coords = ctx.actions.move_cursor(event, [i, j], ctx.data);
+	if (next_coords) {
+		if (event.shiftKey) {
+			ctx.actions.set_selected_cells(
+				ctx.actions.get_range_selection(
+					selected_cells.length > 0 ? selected_cells[0] : [i, j],
+					next_coords
+				)
+			);
+			ctx.actions.set_editing(false);
+		} else {
+			ctx.actions.set_selected_cells([next_coords]);
+			ctx.actions.set_editing(false);
+		}
+		ctx.actions.set_selected(next_coords);
+	} else if (next_coords === false && event.key === "ArrowUp" && i === 0) {
+		ctx.actions.set_selected_header(j);
+		ctx.actions.set_selected(false);
+		ctx.actions.set_selected_cells([]);
+		ctx.actions.set_editing(false);
+	}
+	return true;
+}
+
+async function handle_enter_key(
+	event: KeyboardEvent,
+	ctx: DataFrameContext,
+	i: number,
+	j: number
+): Promise<boolean> {
+	if (!ctx.data || !ctx.els) return false;
+
+	const state = get(ctx.state);
+	if (!state.config.editable) return false;
+
+	const editing = state.ui_state.editing;
+	if (editing && event.shiftKey) return false;
+
+	event.preventDefault();
+
+	if (editing && dequal(editing, [i, j])) {
+		const cell_id = ctx.data[i][j].id;
+		const input_el = ctx.els[cell_id]?.input;
+		if (input_el) {
+			await save_cell_value(input_el.value, ctx, i, j);
+		}
+		ctx.actions.set_editing(false);
+		await tick();
+		ctx.parent_element?.focus();
+	} else {
+		ctx.actions.set_editing([i, j]);
+	}
+
+	return true;
+}
+
+function handle_tab_key(
+	event: KeyboardEvent,
+	ctx: DataFrameContext,
+	i: number,
+	j: number
+): boolean {
+	if (!ctx.data) return false;
+
+	event.preventDefault();
+	ctx.actions.set_editing(false);
+	const next_cell = ctx.actions.get_next_cell_coordinates(
+		[i, j],
+		ctx.data,
+		event.shiftKey
+	);
+	if (next_cell) {
+		ctx.actions.set_selected_cells([next_cell]);
+		ctx.actions.set_selected(next_cell);
+		if (get(ctx.state).config.editable) {
+			ctx.actions.set_editing(next_cell);
+		}
+	}
+	return true;
+}
+
+function handle_default_key(
+	event: KeyboardEvent,
+	ctx: DataFrameContext,
+	i: number,
+	j: number
+): boolean {
+	const state = get(ctx.state);
+	if (!state.config.editable) return false;
+
+	const editing = state.ui_state.editing;
+
+	if (event.key.length === 1 && (!editing || !dequal(editing, [i, j]))) {
+		ctx.actions.set_editing([i, j]);
+		return true;
+	}
+	return false;
+}
+
+async function handle_cell_navigation(
+	event: KeyboardEvent,
+	ctx: DataFrameContext
+): Promise<boolean> {
+	if (!ctx.data) return false;
+
+	const state = get(ctx.state);
+	const selected = state.ui_state.selected;
+	const selected_cells = state.ui_state.selected_cells;
+
+	if (!selected) return false;
+	if (event.key === "c" && (event.metaKey || event.ctrlKey)) {
+		event.preventDefault();
+		if (selected_cells.length > 0) {
+			await copy_table_data(ctx.data, selected_cells);
+		}
+		ctx.actions.set_copy_flash(true);
+		return true;
+	}
+
+	const [i, j] = selected;
+
+	switch (event.key) {
+		case "ArrowRight":
+		case "ArrowLeft":
+		case "ArrowDown":
+		case "ArrowUp":
+			return handle_arrow_keys(event, ctx, i, j);
+		case "Escape":
+			if (!state.config.editable) return false;
+			event.preventDefault();
+			ctx.actions.set_editing(false);
+			tick().then(() => {
+				if (ctx.parent_element) {
+					ctx.parent_element.focus();
+				}
+			});
+
+			return true;
+		case "Enter":
+			return await handle_enter_key(event, ctx, i, j);
+		case "Tab":
+			return handle_tab_key(event, ctx, i, j);
+		case "Delete":
+		case "Backspace":
+			return handle_delete_operation(event, ctx);
+		default:
+			return handle_default_key(event, ctx, i, j);
+	}
+}
+
+export async function handle_keydown(
+	event: KeyboardEvent,
+	context: DataFrameContext
+): Promise<void> {
+	if (handle_header_navigation(event, context)) return;
+	if (handle_delete_operation(event, context)) return;
+	await handle_cell_navigation(event, context);
+}

5.49.1/dataframe/shared/utils/menu_utils.ts

@@ -0,0 +1,115 @@
+export function toggle_header_menu(
+	event: MouseEvent,
+	col: number,
+	active_header_menu: { col: number; x: number; y: number } | null,
+	set_active_header_menu: (
+		menu: { col: number; x: number; y: number } | null
+	) => void
+): void {
+	event.stopPropagation();
+	if (active_header_menu && active_header_menu.col === col) {
+		set_active_header_menu(null);
+	} else {
+		const header = (event.target as HTMLElement).closest("th");
+		if (header) {
+			const rect = header.getBoundingClientRect();
+			set_active_header_menu({ col, x: rect.right, y: rect.bottom });
+		}
+	}
+}
+
+export function toggle_cell_menu(
+	event: MouseEvent,
+	row: number,
+	col: number,
+	active_cell_menu: { row: number; col: number; x: number; y: number } | null,
+	set_active_cell_menu: (
+		menu: { row: number; col: number; x: number; y: number } | null
+	) => void
+): void {
+	event.stopPropagation();
+	if (
+		active_cell_menu &&
+		active_cell_menu.row === row &&
+		active_cell_menu.col === col
+	) {
+		set_active_cell_menu(null);
+	} else {
+		const cell = (event.target as HTMLElement).closest("td");
+		if (cell) {
+			const rect = cell.getBoundingClientRect();
+			set_active_cell_menu({ row, col, x: rect.right, y: rect.bottom });
+		}
+	}
+}
+
+export function add_row_at(
+	index: number,
+	position: "above" | "below",
+	add_row: (index?: number) => void,
+	clear_menus: () => void
+): void {
+	const row_index = position === "above" ? index : index + 1;
+	add_row(row_index);
+	clear_menus();
+}
+
+export function add_col_at(
+	index: number,
+	position: "left" | "right",
+	add_col: (index?: number) => void,
+	clear_menus: () => void
+): void {
+	const col_index = position === "left" ? index : index + 1;
+	add_col(col_index);
+	clear_menus();
+}
+
+export function delete_row_at(
+	index: number,
+	delete_row: (index: number) => void,
+	clear_menus: () => void
+): void {
+	delete_row(index);
+	clear_menus();
+}
+
+export function delete_col_at(
+	index: number,
+	delete_col: (index: number) => void,
+	clear_menus: () => void
+): void {
+	delete_col(index);
+	clear_menus();
+}
+
+export function toggle_header_button(
+	col: number,
+	active_button: { type: "header" | "cell"; row?: number; col: number } | null,
+	set_active_button: (
+		button: { type: "header" | "cell"; row?: number; col: number } | null
+	) => void
+): void {
+	set_active_button(
+		active_button?.type === "header" && active_button.col === col
+			? null
+			: { type: "header", col }
+	);
+}
+
+export function toggle_cell_button(
+	row: number,
+	col: number,
+	active_button: { type: "header" | "cell"; row?: number; col: number } | null,
+	set_active_button: (
+		button: { type: "header" | "cell"; row?: number; col: number } | null
+	) => void
+): void {
+	set_active_button(
+		active_button?.type === "cell" &&
+			active_button.row === row &&
+			active_button.col === col
+			? null
+			: { type: "cell", row, col }
+	);
+}

5.49.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 };
+}

5.49.1/dataframe/shared/utils/sort_utils.ts

@@ -0,0 +1,91 @@
+import type { Headers, CellValue } from "../types";
+import { sort_table_data } from "./table_utils";
+
+export type SortDirection = "asc" | "desc";
+
+export function get_sort_status(
+	name: string,
+	sort_columns: { col: number; direction: SortDirection }[],
+	headers: Headers
+): "none" | "asc" | "desc" {
+	if (!sort_columns.length) return "none";
+
+	const sort_item = sort_columns.find((item) => {
+		const col = item.col;
+		if (col < 0 || col >= headers.length) return false;
+		return headers[col] === name;
+	});
+
+	if (!sort_item) return "none";
+	return sort_item.direction;
+}
+
+export function sort_data(
+	data: { id: string; value: CellValue }[][],
+	sort_columns: { col: number; direction: SortDirection }[]
+): number[] {
+	if (!data || !data.length || !data[0]) {
+		return [];
+	}
+
+	if (sort_columns.length > 0) {
+		const row_indices = [...Array(data.length)].map((_, i) => i);
+		row_indices.sort((row_a_idx, row_b_idx) => {
+			const row_a = data[row_a_idx];
+			const row_b = data[row_b_idx];
+
+			for (const { col: sort_by, direction } of sort_columns) {
+				if (
+					!row_a ||
+					!row_b ||
+					sort_by < 0 ||
+					sort_by >= row_a.length ||
+					sort_by >= row_b.length ||
+					!row_a[sort_by] ||
+					!row_b[sort_by]
+				) {
+					continue;
+				}
+
+				const val_a = row_a[sort_by].value;
+				const val_b = row_b[sort_by].value;
+				const comparison = val_a < val_b ? -1 : val_a > val_b ? 1 : 0;
+
+				if (comparison !== 0) {
+					return direction === "asc" ? comparison : -comparison;
+				}
+			}
+
+			return 0;
+		});
+		return row_indices;
+	}
+	return [...Array(data.length)].map((_, i) => i);
+}
+
+export function sort_data_and_preserve_selection(
+	data: { id: string; value: CellValue }[][],
+	display_value: string[][] | null,
+	styling: string[][] | null,
+	sort_columns: { col: number; direction: SortDirection }[],
+	selected: [number, number] | false,
+	get_current_indices: (
+		id: string,
+		data: { id: string; value: CellValue }[][]
+	) => [number, number]
+): { data: typeof data; selected: [number, number] | false } {
+	let id = null;
+	if (selected && selected[0] in data && selected[1] in data[selected[0]]) {
+		id = data[selected[0]][selected[1]].id;
+	}
+
+	sort_table_data(data, display_value, styling, sort_columns);
+
+	let new_selected = selected;
+	if (id) {
+		const [i, j] = get_current_indices(id, data);
+		new_selected = [i, j];
+	}
+
+	return { data, selected: new_selected };
+}

5.49.1/dataframe/shared/utils/table_utils.ts

@@ -0,0 +1,194 @@
+import type {
+	CellValue,
+	Headers,
+	HeadersWithIDs,
+	TableCell,
+	TableData
+} from "../types";
+import { sort_data } from "./sort_utils";
+import { filter_data } from "./filter_utils";
+import type { SortDirection } from "./sort_utils";
+import type { FilterDatatype } from "./filter_utils";
+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 function get_max(data: TableData): TableCell[] {
+	if (!data || !data.length) return [];
+	let max = data[0].slice();
+	for (let i = 0; i < data.length; i++) {
+		for (let j = 0; j < data[i].length; j++) {
+			if (`${max[j].value}`.length < `${data[i][j].value}`.length) {
+				max[j] = data[i][j];
+			}
+		}
+	}
+	return max;
+}
+
+export function sort_table_data(
+	data: TableData,
+	display_value: string[][] | null,
+	styling: string[][] | null,
+	sort_columns: { col: number; direction: SortDirection }[]
+): void {
+	if (!sort_columns.length) return;
+	if (!data || !data.length) return;
+
+	const indices = sort_data(data, sort_columns);
+
+	const new_data = indices.map((i: number) => data[i]);
+	data.splice(0, data.length, ...new_data);
+
+	if (display_value) {
+		const new_display = indices.map((i: number) => display_value[i]);
+		display_value.splice(0, display_value.length, ...new_display);
+	}
+
+	if (styling) {
+		const new_styling = indices.map((i: number) => styling[i]);
+		styling.splice(0, styling.length, ...new_styling);
+	}
+}
+
+export function filter_table_data(
+	data: TableData,
+	display_value: string[][] | null,
+	styling: string[][] | null,
+	filter_columns: {
+		col: number;
+		datatype: FilterDatatype;
+		filter: string;
+		value: string;
+	}[],
+	original_data?: TableData,
+	original_display_value?: string[][] | null,
+	original_styling?: string[][] | null
+): void {
+	const base_data = original_data ?? data;
+	const base_display_value = original_display_value ?? display_value;
+	const base_styling = original_styling ?? styling;
+
+	if (!filter_columns.length) {
+		data.splice(0, data.length, ...base_data.map((row) => [...row]));
+		if (display_value && base_display_value) {
+			display_value.splice(
+				0,
+				display_value.length,
+				...base_display_value.map((row) => [...row])
+			);
+		}
+		if (styling && base_styling) {
+			styling.splice(0, styling.length, ...base_styling.map((row) => [...row]));
+		}
+		return;
+	}
+	if (!data || !data.length) return;
+
+	const indices = filter_data(base_data, filter_columns);
+
+	const new_data = indices.map((i: number) => base_data[i]);
+	data.splice(0, data.length, ...new_data);
+
+	if (display_value && base_display_value) {
+		const new_display = indices.map((i: number) => base_display_value[i]);
+		display_value.splice(0, display_value.length, ...new_display);
+	}
+
+	if (styling && base_styling) {
+		const new_styling = indices.map((i: number) => base_styling[i]);
+		styling.splice(0, styling.length, ...new_styling);
+	}
+}
+
+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);
+	}
+}
+
+// File Import/Export
+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);
+}

5.49.1/dataframe/shared/utils/utils.ts

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

5.49.1/dataframe/standalone/Index.svelte

@@ -0,0 +1,718 @@
+<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";
+
+	export let i18n: I18nFormatter | undefined = undefined;
+	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;
+	};
+
+	export let value: DataframeValue = {
+		data: [["", "", ""]],
+		headers: ["1", "2", "3"],
+		metadata: null
+	};
+	export let datatype: Datatype | Datatype[] = "str";
+	export let interactive = true;
+	export let show_row_numbers = false;
+	export let max_height = 500;
+	export let show_search: "none" | "search" | "filter" = "none";
+	export let show_copy_button = false;
+	export let show_fullscreen_button = false;
+	export let wrap = false;
+	export let line_breaks = true;
+	export let column_widths: string[] = [];
+	export let max_chars: number | undefined = undefined;
+	export let pinned_columns = 0;
+	export let static_columns: (string | number)[] = [];
+	export let fullscreen = false;
+	export let label: string | null = null;
+	export let show_label = true;
+	export let latex_delimiters: any[] = [];
+	export let col_count: [number, "fixed" | "dynamic"] | undefined = undefined;
+	export let row_count: [number, "fixed" | "dynamic"] | undefined = undefined;
+
+	// mirrors default row count and column count logic in dataframe.py
+	$: resolved_row_count = (() => {
+		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"];
+	})();
+	$: resolved_col_count = (() => {
+		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"];
+	})();
+	$: if (
+		static_columns &&
+		static_columns.length > 0 &&
+		resolved_col_count[1] !== "fixed"
+	) {
+		resolved_col_count = [resolved_col_count[0], "fixed"];
+	}
+
+	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}
+		styling={value?.metadata?.styling}
+		{datatype}
+		editable={interactive}
+		{show_row_numbers}
+		{max_height}
+		{show_search}
+		{show_copy_button}
+		{show_fullscreen_button}
+		{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}
+		on:change={(e) => {
+			value.data = e.detail.data;
+			value.headers = e.detail.headers;
+		}}
+		on:blur
+		on:keydown
+		on:input
+		on:select
+		on:fullscreen={(e) => (fullscreen = e.detail)}
+		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>

5.49.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"
+};

5.49.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>

5.49.1/dataframe/standalone/stubs/upload.ts

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