Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

refactor(data-table): convert column header menu items to React components (#9749)

Kiran Gadhave9f17e8edc834
diff --git a/frontend/src/components/data-table/__tests__/header-items.test.tsx b/frontend/src/components/data-table/__tests__/header-items.test.tsx
index 6fd5023ce6..9af6d9f8aa 100644
--- a/frontend/src/components/data-table/__tests__/header-items.test.tsx
+++ b/frontend/src/components/data-table/__tests__/header-items.test.tsx
@@ -1,6 +1,11 @@
/* Copyright 2026 Marimo. All rights reserved. */
-import type { Column, SortingState } from "@tanstack/react-table";
+import type {
+ Column,
+ SortDirection,
+ SortingState,
+ Table,
+} from "@tanstack/react-table";
import { fireEvent, render, screen } from "@testing-library/react";
import { describe, expect, it, vi } from "vitest";
import {
@@ -8,7 +13,23 @@ import {
DropdownMenuContent,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu";
-import { HideColumn } from "../header-items";
+import {
+ ColumnPinning,
+ ColumnWrapping,
+ CopyColumn,
+ DataType,
+ FormatOptions,
+ HideColumn,
+ Sorts,
+} from "../header-items";
+
+const renderInMenu = (node: React.ReactNode) =>
+ render(
+ <DropdownMenu open={true}>
+ <DropdownMenuTrigger />
+ <DropdownMenuContent>{node}</DropdownMenuContent>
+ </DropdownMenu>,
+ );
describe("multi-column sorting logic", () => {
// Extract the core sorting logic to test in isolation
@@ -167,14 +188,6 @@ describe("HideColumn", () => {
toggleVisibility,
}) as unknown as Column<unknown, unknown>;
- const renderInMenu = (node: React.ReactNode) =>
- render(
- <DropdownMenu open={true}>
- <DropdownMenuTrigger />
- <DropdownMenuContent>{node}</DropdownMenuContent>
- </DropdownMenu>,
- );
-
it("renders 'Hide column' when canHide is true", () => {
renderInMenu(<HideColumn column={makeColumn()} />);
expect(screen.getByText("Hide column")).toBeInTheDocument();
@@ -192,3 +205,200 @@ describe("HideColumn", () => {
expect(toggleVisibility).toHaveBeenCalledWith(false);
});
});
+
+describe("DataType", () => {
+ const makeColumn = (dtype?: string) =>
+ ({
+ columnDef: { meta: dtype === undefined ? {} : { dtype } },
+ }) as unknown as Column<unknown, unknown>;
+
+ it("renders the dtype label when present", () => {
+ renderInMenu(<DataType column={makeColumn("int64")} />);
+ expect(screen.getByText("int64")).toBeInTheDocument();
+ });
+
+ it("returns null when dtype is absent", () => {
+ renderInMenu(<DataType column={makeColumn()} />);
+ expect(screen.queryByText("int64")).toBeNull();
+ });
+});
+
+describe("Sorts", () => {
+ const makeColumn = ({
+ canSort = true,
+ sorted = false,
+ sortIndex = 0,
+ }: {
+ canSort?: boolean;
+ sorted?: false | SortDirection;
+ sortIndex?: number;
+ } = {}) =>
+ ({
+ getCanSort: () => canSort,
+ getIsSorted: () => sorted,
+ getSortIndex: () => sortIndex,
+ clearSorting: vi.fn(),
+ toggleSorting: vi.fn(),
+ }) as unknown as Column<unknown, unknown>;
+
+ const makeTable = (sorting: SortingState) =>
+ ({
+ getState: () => ({ sorting }),
+ resetSorting: vi.fn(),
+ }) as unknown as Table<unknown>;
+
+ it("returns null when the column cannot sort", () => {
+ renderInMenu(<Sorts column={makeColumn({ canSort: false })} />);
+ expect(screen.queryByText("Asc")).toBeNull();
+ });
+
+ it("renders Asc and Desc items", () => {
+ renderInMenu(<Sorts column={makeColumn()} />);
+ expect(screen.getByText("Asc")).toBeInTheDocument();
+ expect(screen.getByText("Desc")).toBeInTheDocument();
+ });
+
+ it("offers single-column 'Clear sort' when sorted without multi-sort", () => {
+ renderInMenu(<Sorts column={makeColumn({ sorted: "asc" })} />);
+ expect(screen.getByText("Clear sort")).toBeInTheDocument();
+ });
+
+ it("offers 'Clear all sorts' when the table has multiple sorts", () => {
+ renderInMenu(
+ <Sorts
+ column={makeColumn({ sorted: "asc" })}
+ table={makeTable([
+ { id: "a", desc: false },
+ { id: "b", desc: true },
+ ])}
+ />,
+ );
+ expect(screen.getByText("Clear all sorts")).toBeInTheDocument();
+ });
+});
+
+describe("CopyColumn", () => {
+ const makeColumn = ({
+ canCopy = true,
+ id = "name",
+ }: {
+ canCopy?: boolean;
+ id?: string;
+ } = {}) =>
+ ({
+ id,
+ getCanCopy: () => canCopy,
+ }) as unknown as Column<unknown, unknown>;
+
+ it("renders 'Copy column name' when copyable", () => {
+ renderInMenu(<CopyColumn column={makeColumn()} />);
+ expect(screen.getByText("Copy column name")).toBeInTheDocument();
+ });
+
+ it("returns null when the column cannot be copied", () => {
+ renderInMenu(<CopyColumn column={makeColumn({ canCopy: false })} />);
+ expect(screen.queryByText("Copy column name")).toBeNull();
+ });
+});
+
+describe("ColumnPinning", () => {
+ const makeColumn = ({
+ canPin = true,
+ pinned = false,
+ }: {
+ canPin?: boolean;
+ pinned?: false | "left" | "right";
+ } = {}) =>
+ ({
+ getCanPin: () => canPin,
+ getIsPinned: () => pinned,
+ pin: vi.fn(),
+ }) as unknown as Column<unknown, unknown>;
+
+ it("returns null when the column cannot be pinned", () => {
+ renderInMenu(<ColumnPinning column={makeColumn({ canPin: false })} />);
+ expect(screen.queryByText("Freeze left")).toBeNull();
+ });
+
+ it("offers freeze options when unpinned", () => {
+ renderInMenu(<ColumnPinning column={makeColumn()} />);
+ expect(screen.getByText("Freeze left")).toBeInTheDocument();
+ expect(screen.getByText("Freeze right")).toBeInTheDocument();
+ });
+
+ it("offers 'Unfreeze' when pinned", () => {
+ renderInMenu(<ColumnPinning column={makeColumn({ pinned: "left" })} />);
+ expect(screen.getByText("Unfreeze")).toBeInTheDocument();
+ });
+});
+
+describe("ColumnWrapping", () => {
+ const makeColumn = ({
+ canWrap = true,
+ wrapping = "nowrap",
+ }: {
+ canWrap?: boolean;
+ wrapping?: "wrap" | "nowrap";
+ } = {}) =>
+ ({
+ getCanWrap: () => canWrap,
+ getColumnWrapping: () => wrapping,
+ toggleColumnWrapping: vi.fn(),
+ }) as unknown as Column<unknown, unknown>;
+
+ it("returns null when the column cannot wrap", () => {
+ renderInMenu(<ColumnWrapping column={makeColumn({ canWrap: false })} />);
+ expect(screen.queryByText("Wrap text")).toBeNull();
+ });
+
+ it("offers 'Wrap text' when not wrapping", () => {
+ renderInMenu(<ColumnWrapping column={makeColumn()} />);
+ expect(screen.getByText("Wrap text")).toBeInTheDocument();
+ });
+
+ it("offers 'No wrap text' when wrapping", () => {
+ renderInMenu(<ColumnWrapping column={makeColumn({ wrapping: "wrap" })} />);
+ expect(screen.getByText("No wrap text")).toBeInTheDocument();
+ });
+});
+
+describe("FormatOptions", () => {
+ const makeColumn = ({
+ dataType = "number",
+ canFormat = true,
+ }: {
+ dataType?: string;
+ canFormat?: boolean;
+ } = {}) =>
+ ({
+ columnDef: { meta: { dataType } },
+ getCanFormat: () => canFormat,
+ getColumnFormatting: () => undefined,
+ setColumnFormatting: vi.fn(),
+ }) as unknown as Column<unknown, unknown>;
+
+ it("renders the 'Format' submenu trigger for formattable columns", () => {
+ renderInMenu(<FormatOptions column={makeColumn()} locale="en-US" />);
+ expect(screen.getByText("Format")).toBeInTheDocument();
+ });
+
+ it("returns null when the column cannot be formatted", () => {
+ renderInMenu(
+ <FormatOptions
+ column={makeColumn({ canFormat: false })}
+ locale="en-US"
+ />,
+ );
+ expect(screen.queryByText("Format")).toBeNull();
+ });
+
+ it("returns null when the data type has no format options", () => {
+ renderInMenu(
+ <FormatOptions
+ column={makeColumn({ dataType: "unknown" })}
+ locale="en-US"
+ />,
+ );
+ expect(screen.queryByText("Format")).toBeNull();
+ });
+});
diff --git a/frontend/src/components/data-table/column-header.tsx b/frontend/src/components/data-table/column-header.tsx
index 4e898f3ba9..87126f6a71 100644
--- a/frontend/src/components/data-table/column-header.tsx
+++ b/frontend/src/components/data-table/column-header.tsx
@@ -17,14 +17,14 @@ import { useFilterEditor } from "./filter-editor-context";
import { EDITABLE_FILTER_TYPES, isMembershipFilterType } from "./filters";
import {
ClearFilterMenuItem,
+ ColumnPinning,
+ ColumnWrapping,
+ CopyColumn,
+ DataType,
+ FormatOptions,
HideColumn,
- renderColumnPinning,
- renderColumnWrapping,
- renderCopyColumn,
- renderDataType,
- renderFormatOptions,
renderSortIcon,
- renderSorts,
+ Sorts,
} from "./header-items";
interface DataTableColumnHeaderProps<
@@ -36,6 +36,11 @@ interface DataTableColumnHeaderProps<
subheader?: React.ReactNode;
justify?: "left" | "center" | "right";
calculateTopKRows?: CalculateTopKRows;
+ /**
+ * Optional: only used to surface multi-column sort actions ("Clear all
+ * sorts"). Omitted by call sites that define their header inside column
+ * definitions, where the table instance isn't yet available.
+ */
table?: Table<TData>;
}
@@ -119,12 +124,12 @@ export const DataTableColumnHeader = <TData, TValue>({
</button>
</DropdownMenuTrigger>
<DropdownMenuContent align="start">
- {renderDataType(column)}
- {renderSorts(column, table)}
- {renderCopyColumn(column)}
- {renderColumnPinning(column)}
- {renderColumnWrapping(column)}
- {renderFormatOptions(column, locale)}
+ <DataType column={column} />
+ <Sorts column={column} table={table} />
+ <CopyColumn column={column} />
+ <ColumnPinning column={column} />
+ <ColumnWrapping column={column} />
+ <FormatOptions column={column} locale={locale} />
<HideColumn column={column} />
{canEditFilter && <DropdownMenuSeparator />}
{canEditFilter && (
diff --git a/frontend/src/components/data-table/header-items.tsx b/frontend/src/components/data-table/header-items.tsx
index 7519372d60..7bffe887dc 100644
--- a/frontend/src/components/data-table/header-items.tsx
+++ b/frontend/src/components/data-table/header-items.tsx
@@ -29,10 +29,13 @@ import { formattingExample } from "./column-formatting/feature";
import { formatOptions } from "./column-formatting/types";
import { NAMELESS_COLUMN_PREFIX } from "./columns";
-export function renderFormatOptions<TData, TValue>(
- column: Column<TData, TValue>,
- locale: string,
-) {
+export function FormatOptions<TData, TValue>({
+ column,
+ locale,
+}: {
+ column: Column<TData, TValue>;
+ locale: string;
+}) {
const dataType: DataType | undefined = column.columnDef.meta?.dataType;
const columnFormatOptions = dataType ? formatOptions[dataType] : [];
@@ -83,9 +86,11 @@ export function renderFormatOptions<TData, TValue>(
);
}
-export function renderColumnWrapping<TData, TValue>(
- column: Column<TData, TValue>,
-) {
+export function ColumnWrapping<TData, TValue>({
+ column,
+}: {
+ column: Column<TData, TValue>;
+}) {
if (!column.getCanWrap?.() || !column.getColumnWrapping) {
return null;
}
@@ -108,9 +113,11 @@ export function renderColumnWrapping<TData, TValue>(
);
}
-export function renderColumnPinning<TData, TValue>(
- column: Column<TData, TValue>,
-) {
+export function ColumnPinning<TData, TValue>({
+ column,
+}: {
+ column: Column<TData, TValue>;
+}) {
if (!column.getCanPin?.() || !column.getIsPinned) {
return null;
}
@@ -157,7 +164,11 @@ export function HideColumn<TData, TValue>({
);
}
-export function renderCopyColumn<TData, TValue>(column: Column<TData, TValue>) {
+export function CopyColumn<TData, TValue>({
+ column,
+}: {
+ column: Column<TData, TValue>;
+}) {
if (!column.getCanCopy?.()) {
return null;
}
@@ -177,10 +188,19 @@ export function renderCopyColumn<TData, TValue>(column: Column<TData, TValue>) {
const AscIcon = ArrowUpNarrowWideIcon;
const DescIcon = ArrowDownWideNarrowIcon;
-export function renderSorts<TData, TValue>(
- column: Column<TData, TValue>,
- table?: Table<TData>,
-) {
+/**
+ * `table` is optional: it is only needed to detect multi-column sorting and
+ * offer "Clear all sorts". Call sites that build their header inside column
+ * definitions (where the table instance isn't yet in scope) omit it and fall
+ * back to single-column "Clear sort".
+ */
+export function Sorts<TData, TValue>({
+ column,
+ table,
+}: {
+ column: Column<TData, TValue>;
+ table?: Table<TData>;
+}) {
if (!column.getCanSort()) {
return null;
}
@@ -271,7 +291,11 @@ export function renderSortIcon<TData, TValue>(column: Column<TData, TValue>) {
return <Icon className="h-3 w-3" />;
}
-export function renderDataType<TData, TValue>(column: Column<TData, TValue>) {
+export function DataType<TData, TValue>({
+ column,
+}: {
+ column: Column<TData, TValue>;
+}) {
const dtype: string | undefined = column.columnDef.meta?.dtype;
if (!dtype) {
return null;