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.

feat(table): unified filter pill UI with overflow strip (#9638)

Kiran Gadhave4f7706e63958
diff --git a/frontend/src/components/data-table/__tests__/column-header.test.ts b/frontend/src/components/data-table/__tests__/column-header.test.ts
deleted file mode 100644
index 947e757c3e..0000000000
--- a/frontend/src/components/data-table/__tests__/column-header.test.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { describe, expect, it } from "vitest";
-import { seedFromFilter } from "../column-header";
-import { Filter } from "../filters";
-
-describe("seedFromFilter", () => {
- it("returns empty defaults when there is no filter", () => {
- expect(seedFromFilter(undefined)).toEqual({
- values: [],
- operator: "in",
- });
- });
-
- it("seeds values from an `in` select filter", () => {
- const filter = Filter.select({
- options: ["Flying", "Ground"],
- operator: "in",
- });
- expect(seedFromFilter(filter)).toEqual({
- values: ["Flying", "Ground"],
- operator: "in",
- });
- });
-
- it("preserves `not_in` so reapplying does not silently flip to `in`", () => {
- const filter = Filter.select({
- options: ["Fire"],
- operator: "not_in",
- });
- expect(seedFromFilter(filter)).toEqual({
- values: ["Fire"],
- operator: "not_in",
- });
- });
-
- it("returns a fresh array (callers may mutate without affecting the filter)", () => {
- const options = ["a", "b"];
- const filter = Filter.select({ options, operator: "in" });
- const seeded = seedFromFilter(filter);
- seeded.values.push("c");
- expect(options).toEqual(["a", "b"]);
- });
-
- it("ignores non-select filters and falls back to defaults", () => {
- expect(
- seedFromFilter(Filter.text({ text: "abc", operator: "equals" })),
- ).toEqual({
- values: [],
- operator: "in",
- });
- expect(
- seedFromFilter(Filter.number({ operator: "between", min: 0, max: 10 })),
- ).toEqual({
- values: [],
- operator: "in",
- });
- expect(
- seedFromFilter(Filter.boolean({ value: true, operator: "is_true" })),
- ).toEqual({
- values: [],
- operator: "in",
- });
- });
-});
diff --git a/frontend/src/components/data-table/__tests__/column-header.test.tsx b/frontend/src/components/data-table/__tests__/column-header.test.tsx
index 311f4598cc..2a5409b193 100644
--- a/frontend/src/components/data-table/__tests__/column-header.test.tsx
+++ b/frontend/src/components/data-table/__tests__/column-header.test.tsx
@@ -1,308 +1,141 @@
/* Copyright 2026 Marimo. All rights reserved. */
import type { Column } from "@tanstack/react-table";
-import { fireEvent, render, screen, within } from "@testing-library/react";
+import { fireEvent, render, screen } from "@testing-library/react";
import { beforeAll, describe, expect, it, vi } from "vitest";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import { DataTableColumnHeader } from "../column-header";
import {
- DateFilterMenu,
- NumberFilterMenu,
- TextFilterMenu,
-} from "../column-header";
-import { Filter } from "../filters";
+ type AddFilterRequest,
+ FilterEditorProvider,
+} from "../filter-editor-context";
+import { buildFilterTestTable } from "./filter-test-utils";
beforeAll(() => {
global.HTMLElement.prototype.scrollIntoView = () => {
- // jsdom does not implement scrollIntoView; Radix calls it on open.
+ // jsdom does not implement scrollIntoView
};
- // Radix Select gates pointer interactions on hasPointerCapture; jsdom omits it.
if (!global.HTMLElement.prototype.hasPointerCapture) {
global.HTMLElement.prototype.hasPointerCapture = () => false;
}
if (!global.HTMLElement.prototype.releasePointerCapture) {
global.HTMLElement.prototype.releasePointerCapture = () => {
- // no-op
+ // noop for jsdom
};
}
});
-function mockColumn(initial?: ReturnType<typeof Filter.number>): Column<
- unknown,
- unknown
-> & {
- setFilterValue: ReturnType<typeof vi.fn>;
-} {
- let filterValue = initial;
- const setFilterValue = vi.fn((next) => {
- filterValue = next;
- });
- return {
- id: "age",
- columnDef: { meta: { dataType: "number", filterType: "number" } },
- getFilterValue: () => filterValue,
- setFilterValue,
- } as unknown as Column<unknown, unknown> & {
- setFilterValue: ReturnType<typeof vi.fn>;
- };
+function renderHeader(opts: {
+ column: Column<unknown, unknown>;
+ requestAddFilter?: (req: AddFilterRequest) => void;
+ withProvider: boolean;
+}) {
+ const { column, requestAddFilter, withProvider } = opts;
+ const headerNode = (
+ <DataTableColumnHeader column={column} header={column.id} />
+ );
+ return render(
+ <TooltipProvider>
+ {withProvider ? (
+ <FilterEditorProvider
+ value={{ requestAddFilter: requestAddFilter ?? vi.fn() }}
+ >
+ {headerNode}
+ </FilterEditorProvider>
+ ) : (
+ headerNode
+ )}
+ </TooltipProvider>,
+ );
}
-describe("NumberFilterMenu", () => {
- it("shows all expected operators in the dropdown", () => {
- const column = mockColumn();
- render(<NumberFilterMenu column={column} />);
- const trigger = screen.getByRole("combobox");
- fireEvent.click(trigger);
- const listbox = screen.getByRole("listbox");
- const labels = within(listbox)
- .getAllByRole("option")
- .map((o) => o.textContent);
- expect(labels).toEqual([
- "Between",
- "Equals",
- "Doesn't equal",
- "Greater than",
- "Greater than or equal",
- "Less than",
- "Less than or equal",
- "Is null",
- "Is not null",
- ]);
- });
-
- it("between mode disables Apply until both min and max are defined", () => {
- const column = mockColumn();
- render(<NumberFilterMenu column={column} />);
- const apply = screen.getByRole("button", { name: /apply/i });
- expect(apply).toBeDisabled();
-
- const min = screen.getByLabelText("min");
- fireEvent.change(min, { target: { value: "1" } });
- fireEvent.blur(min);
- expect(apply).toBeDisabled();
+const openMenu = () => {
+ const trigger = screen.getByLabelText("Column options");
+ trigger.focus();
+ fireEvent.keyDown(trigger, { key: "Enter" });
+};
- const max = screen.getByLabelText("max");
- fireEvent.change(max, { target: { value: "10" } });
- fireEvent.blur(max);
- expect(apply).not.toBeDisabled();
- });
-
- it("comparison mode shows a single value field seeded from current filter", () => {
- const column = mockColumn(Filter.number({ operator: ">", value: 18 }));
- render(<NumberFilterMenu column={column} />);
- const value = screen.getByLabelText("value") as HTMLInputElement;
- expect(value).toBeInTheDocument();
- expect(value.value).toBe("18");
- expect(screen.queryByLabelText("min")).not.toBeInTheDocument();
- expect(screen.queryByLabelText("max")).not.toBeInTheDocument();
- });
-
- it("selecting a nullish operator hides value inputs and commits on Apply", () => {
- const column = mockColumn();
- render(<NumberFilterMenu column={column} />);
- fireEvent.click(screen.getByRole("combobox"));
- const listbox = screen.getByRole("listbox");
- fireEvent.click(within(listbox).getByText("Is null"));
- expect(column.setFilterValue).not.toHaveBeenCalled();
- expect(screen.queryByLabelText("min")).not.toBeInTheDocument();
- expect(screen.queryByLabelText("max")).not.toBeInTheDocument();
- expect(screen.queryByLabelText("value")).not.toBeInTheDocument();
- fireEvent.click(screen.getByRole("button", { name: /apply/i }));
- expect(column.setFilterValue).toHaveBeenCalledWith(
- Filter.number({ operator: "is_null" }),
- );
- });
-});
-
-function mockTextColumn(initial?: ReturnType<typeof Filter.text>): Column<
- unknown,
- unknown
-> & {
- setFilterValue: ReturnType<typeof vi.fn>;
-} {
- let filterValue = initial;
- const setFilterValue = vi.fn((next) => {
- filterValue = next;
- });
- return {
- id: "name",
- columnDef: { meta: { dataType: "string", filterType: "text" } },
- getFilterValue: () => filterValue,
- setFilterValue,
- } as unknown as Column<unknown, unknown> & {
- setFilterValue: ReturnType<typeof vi.fn>;
- };
-}
-
-describe("TextFilterMenu", () => {
- it("shows all 11 text operators in the dropdown", () => {
- const column = mockTextColumn();
- render(<TextFilterMenu column={column} />);
- fireEvent.click(screen.getByRole("combobox"));
- const listbox = screen.getByRole("listbox");
- const labels = within(listbox)
- .getAllByRole("option")
- .map((o) => o.textContent);
- expect(labels).toEqual([
- "Contains",
- "Equals",
- "Doesn't equal",
- "Matches regex",
- "Starts with",
- "Ends with",
- "Is in",
- "Not in",
- "Is empty",
- "Is null",
- "Is not null",
+describe("DataTableColumnHeader — filter menu", () => {
+ it("renders Filter and Filter-by-values items for text columns inside a provider", () => {
+ const { table } = buildFilterTestTable([
+ { id: "name", filterType: "text" },
]);
+ renderHeader({ column: table.getColumn("name")!, withProvider: true });
+ openMenu();
+ expect(screen.getByText("Filter")).toBeInTheDocument();
+ expect(screen.getByText("Filter by values")).toBeInTheDocument();
});
- it("single-string operator renders a text input seeded from current filter", () => {
- const column = mockTextColumn(
- Filter.text({ operator: "equals", text: "alice" }),
- );
- render(<TextFilterMenu column={column} />);
- const input = screen.getByPlaceholderText("Text...") as HTMLInputElement;
- expect(input).toBeInTheDocument();
- expect(input.value).toBe("alice");
- });
-
- it("'in' operator renders the creatable values picker", async () => {
- const column = mockTextColumn(
- Filter.text({ operator: "in", values: ["a", "b"] }),
- );
- const calculateTopKRows = vi.fn(async () => ({
- data: [["a", 1] as [unknown, number]],
- }));
- render(
- <TextFilterMenu column={column} calculateTopKRows={calculateTopKRows} />,
- );
- expect(
- await screen.findByPlaceholderText(/Search or add a value/i),
- ).toBeInTheDocument();
- expect(screen.queryByPlaceholderText("Text...")).not.toBeInTheDocument();
- });
-
- it("selecting is_empty hides the value UI and commits on Apply", () => {
- const column = mockTextColumn();
- render(<TextFilterMenu column={column} />);
- fireEvent.click(screen.getByRole("combobox"));
- const listbox = screen.getByRole("listbox");
- fireEvent.click(within(listbox).getByText("Is empty"));
- expect(column.setFilterValue).not.toHaveBeenCalled();
- expect(screen.queryByPlaceholderText("Text...")).not.toBeInTheDocument();
- fireEvent.click(screen.getByRole("button", { name: /apply/i }));
- expect(column.setFilterValue).toHaveBeenCalledWith(
- Filter.text({ operator: "is_empty" }),
- );
+ it("renders Filter and Filter-by-values items for number columns", () => {
+ const { table } = buildFilterTestTable([
+ { id: "age", filterType: "number" },
+ ]);
+ renderHeader({ column: table.getColumn("age")!, withProvider: true });
+ openMenu();
+ expect(screen.getByText("Filter")).toBeInTheDocument();
+ expect(screen.getByText("Filter by values")).toBeInTheDocument();
+ });
+
+ it.each(["date", "datetime", "time", "boolean"] as const)(
+ "hides Filter-by-values for %s columns",
+ (filterType) => {
+ const { table } = buildFilterTestTable([{ id: "col", filterType }]);
+ renderHeader({ column: table.getColumn("col")!, withProvider: true });
+ openMenu();
+ expect(screen.getByText("Filter")).toBeInTheDocument();
+ expect(screen.queryByText("Filter by values")).not.toBeInTheDocument();
+ },
+ );
+
+ it("hides both items when filterType is missing", () => {
+ const { table } = buildFilterTestTable([{ id: "opaque" }]);
+ renderHeader({ column: table.getColumn("opaque")!, withProvider: true });
+ openMenu();
+ expect(screen.queryByText("Filter")).not.toBeInTheDocument();
+ expect(screen.queryByText("Filter by values")).not.toBeInTheDocument();
+ });
+
+ it("hides both items when no FilterEditorProvider is present", () => {
+ const { table } = buildFilterTestTable([
+ { id: "name", filterType: "text" },
+ ]);
+ renderHeader({ column: table.getColumn("name")!, withProvider: false });
+ openMenu();
+ expect(screen.queryByText("Filter")).not.toBeInTheDocument();
+ expect(screen.queryByText("Filter by values")).not.toBeInTheDocument();
});
- it("apply is disabled when scalar text is empty", () => {
- const column = mockTextColumn();
- render(<TextFilterMenu column={column} />);
- expect(screen.getByRole("button", { name: /apply/i })).toBeDisabled();
- fireEvent.change(screen.getByPlaceholderText("Text..."), {
- target: { value: "x" },
+ it("invokes requestAddFilter with columnId when Filter is clicked", () => {
+ const requestAddFilter = vi.fn();
+ const { table } = buildFilterTestTable([
+ { id: "name", filterType: "text" },
+ ]);
+ renderHeader({
+ column: table.getColumn("name")!,
+ requestAddFilter,
+ withProvider: true,
});
- expect(screen.getByRole("button", { name: /apply/i })).not.toBeDisabled();
+ openMenu();
+ fireEvent.click(screen.getByText("Filter"));
+ expect(requestAddFilter).toHaveBeenCalledTimes(1);
+ expect(requestAddFilter).toHaveBeenCalledWith({ columnId: "name" });
});
-});
-
-type DateFilterValue = ReturnType<typeof Filter.date>;
-function mockDateColumn(
- filterType: "date" | "datetime" | "time" = "date",
- initial?: DateFilterValue,
-): Column<unknown, unknown> & {
- setFilterValue: ReturnType<typeof vi.fn>;
-} {
- let filterValue = initial;
- const setFilterValue = vi.fn((next) => {
- filterValue = next;
- });
- return {
- id: "when",
- columnDef: { meta: { dataType: filterType, filterType } },
- getFilterValue: () => filterValue,
- setFilterValue,
- } as unknown as Column<unknown, unknown> & {
- setFilterValue: ReturnType<typeof vi.fn>;
- };
-}
-
-describe("DateFilterMenu", () => {
- it("shows all expected operators in the dropdown", () => {
- const column = mockDateColumn("date");
- render(<DateFilterMenu column={column} filterType="date" />);
- fireEvent.click(screen.getByRole("combobox"));
- const listbox = screen.getByRole("listbox");
- const labels = within(listbox)
- .getAllByRole("option")
- .map((o) => o.textContent);
- expect(labels).toEqual([
- "Between",
- "Equals",
- "Doesn't equal",
- "Greater than",
- "Greater than or equal",
- "Less than",
- "Less than or equal",
- "Is null",
- "Is not null",
+ it("invokes requestAddFilter with operator='in' when Filter by values is clicked", () => {
+ const requestAddFilter = vi.fn();
+ const { table } = buildFilterTestTable([
+ { id: "name", filterType: "text" },
]);
- });
-
- it("defaults to between mode and disables Apply until both bounds set", () => {
- const column = mockDateColumn("date");
- render(<DateFilterMenu column={column} filterType="date" />);
- expect(screen.getByLabelText("range")).toBeInTheDocument();
- expect(screen.getByRole("button", { name: /apply/i })).toBeDisabled();
- expect(screen.queryByLabelText("value")).not.toBeInTheDocument();
- });
-
- it("seeds between min/max from current filter", () => {
- const column = mockDateColumn(
- "date",
- Filter.date({
- operator: "between",
- min: new Date("2024-01-01T00:00:00Z"),
- max: new Date("2024-06-01T00:00:00Z"),
- }),
- );
- render(<DateFilterMenu column={column} filterType="date" />);
- expect(screen.getByLabelText("range")).toBeInTheDocument();
- expect(screen.getByRole("button", { name: /apply/i })).not.toBeDisabled();
- });
-
- it("comparison operator swaps range for a single value picker", () => {
- const column = mockDateColumn(
- "date",
- Filter.date({
- operator: ">",
- value: new Date("2024-01-01T00:00:00Z"),
- }),
- );
- render(<DateFilterMenu column={column} filterType="date" />);
- expect(screen.getByLabelText("value")).toBeInTheDocument();
- expect(screen.queryByLabelText("range")).not.toBeInTheDocument();
- });
-
- it("time filter type renders two TimeFields for between", () => {
- const column = mockDateColumn("time");
- render(<DateFilterMenu column={column} filterType="time" />);
- expect(screen.getByLabelText("min")).toBeInTheDocument();
- expect(screen.getByLabelText("max")).toBeInTheDocument();
- });
-
- it("selecting a nullish operator hides value inputs and commits on Apply", () => {
- const column = mockDateColumn("date");
- render(<DateFilterMenu column={column} filterType="date" />);
- fireEvent.click(screen.getByRole("combobox"));
- const listbox = screen.getByRole("listbox");
- fireEvent.click(within(listbox).getByText("Is null"));
- expect(screen.queryByLabelText("range")).not.toBeInTheDocument();
- expect(screen.queryByLabelText("value")).not.toBeInTheDocument();
- fireEvent.click(screen.getByRole("button", { name: /apply/i }));
- expect(column.setFilterValue).toHaveBeenCalledWith(
- Filter.date({ operator: "is_null" }),
- );
+ renderHeader({
+ column: table.getColumn("name")!,
+ requestAddFilter,
+ withProvider: true,
+ });
+ openMenu();
+ fireEvent.click(screen.getByText("Filter by values"));
+ expect(requestAddFilter).toHaveBeenCalledTimes(1);
+ expect(requestAddFilter).toHaveBeenCalledWith({
+ columnId: "name",
+ operator: "in",
+ });
});
});
diff --git a/frontend/src/components/data-table/__tests__/date-filter-inputs.test.tsx b/frontend/src/components/data-table/__tests__/date-filter-inputs.test.tsx
new file mode 100644
index 0000000000..33f27ce540
--- /dev/null
+++ b/frontend/src/components/data-table/__tests__/date-filter-inputs.test.tsx
@@ -0,0 +1,33 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { describe, expect, it } from "vitest";
+import { dateToLocalISODate } from "@/utils/dates";
+import { parsePastedRange } from "../date-filter-inputs";
+
+describe("parsePastedRange", () => {
+ it.each([
+ ["hyphen", "2026-02-01 - 2026-04-01"],
+ ["en dash", "2026-02-01 – 2026-04-01"],
+ ["em dash", "2026-02-01 — 2026-04-01"],
+ ["to", "2026-02-01 to 2026-04-01"],
+ ["TO (uppercase)", "2026-02-01 TO 2026-04-01"],
+ ["and", "2026-02-01 and 2026-04-01"],
+ ["AND (uppercase)", "2026-02-01 AND 2026-04-01"],
+ ])("splits a date range pasted with %s separator", (_, text) => {
+ const result = parsePastedRange("date", text);
+ expect(result).toBeDefined();
+ expect(result && dateToLocalISODate(result.min)).toBe("2026-02-01");
+ expect(result && dateToLocalISODate(result.max)).toBe("2026-04-01");
+ });
+
+ it("returns a degenerate range for a single pasted date", () => {
+ const result = parsePastedRange("date", "2026-03-15");
+ expect(result).toBeDefined();
+ expect(result && dateToLocalISODate(result.min)).toBe("2026-03-15");
+ expect(result && dateToLocalISODate(result.max)).toBe("2026-03-15");
+ });
+
+ it("returns undefined for unparsable input", () => {
+ expect(parsePastedRange("date", "Sunday and Monday")).toBeUndefined();
+ expect(parsePastedRange("date", "not a date")).toBeUndefined();
+ });
+});
diff --git a/frontend/src/components/data-table/__tests__/filter-pill-editor.test.tsx b/frontend/src/components/data-table/__tests__/filter-pill-editor.test.tsx
index 702170f9e4..e3e7db898f 100644
--- a/frontend/src/components/data-table/__tests__/filter-pill-editor.test.tsx
+++ b/frontend/src/components/data-table/__tests__/filter-pill-editor.test.tsx
@@ -1,10 +1,17 @@
/* Copyright 2026 Marimo. All rights reserved. */
-import type { Column, Table } from "@tanstack/react-table";
import { fireEvent, render, screen } from "@testing-library/react";
import { beforeAll, describe, expect, it, vi } from "vitest";
import { TooltipProvider } from "@/components/ui/tooltip";
-import { FilterPillEditor } from "../filter-pill-editor";
-import { Filter } from "../filters";
+import {
+ buildEditorSnapshot,
+ buildEmptyFilterValue,
+ FilterPillEditor,
+} from "../filter-pill-editor";
+import { defaultFilterValueFor, Filter } from "../filters";
+import {
+ buildFilterTestTable,
+ type FilterColumnSpec,
+} from "./filter-test-utils";
const renderWithProviders = (ui: React.ReactElement) =>
render(<TooltipProvider>{ui}</TooltipProvider>);
@@ -24,37 +31,15 @@ beforeAll(() => {
}
});
-function makeColumn(
- id: string,
- filterType:
- | "text"
- | "number"
- | "boolean"
- | "select"
- | "date"
- | "datetime"
- | "time",
-): Column<unknown, unknown> {
- return {
- id,
- columnDef: { meta: { filterType, dataType: "string" } },
- } as unknown as Column<unknown, unknown>;
-}
+const DEFAULT_COLUMNS: FilterColumnSpec[] = [
+ { id: "name", filterType: "text" },
+ { id: "age", filterType: "number" },
+ { id: "when", filterType: "date" },
+ { id: "at", filterType: "datetime" },
+ { id: "clock", filterType: "time" },
+];
-function mockTable(): Table<unknown> {
- const columns = [
- makeColumn("name", "text"),
- makeColumn("age", "number"),
- makeColumn("when", "date"),
- makeColumn("at", "datetime"),
- makeColumn("clock", "time"),
- ];
- return {
- getAllColumns: () => columns,
- getColumn: (id: string) => columns.find((c) => c.id === id),
- setColumnFilters: vi.fn(),
- } as unknown as Table<unknown>;
-}
+const mockTable = () => buildFilterTestTable(DEFAULT_COLUMNS).table;
async function calculateTopK() {
return {
@@ -111,7 +96,8 @@ describe("FilterPillEditor — snapshot rehydration", () => {
onClose={vi.fn()}
/>,
);
- expect(await screen.findByText("[a, b]")).toBeInTheDocument();
+ expect(await screen.findByText("a")).toBeInTheDocument();
+ expect(screen.getByText("b")).toBeInTheDocument();
});
it("rehydrates a text contains snapshot with seeded text", () => {
@@ -232,7 +218,7 @@ describe("FilterPillEditor — date/datetime/time", () => {
describe("FilterPillEditor — apply", () => {
it("commits a number > filter via setColumnFilters", () => {
- const table = mockTable();
+ const { table, setColumnFilters } = buildFilterTestTable(DEFAULT_COLUMNS);
const onClose = vi.fn();
renderWithProviders(
<FilterPillEditor
@@ -245,11 +231,10 @@ describe("FilterPillEditor — apply", () => {
/>,
);
fireEvent.click(screen.getByLabelText("Apply filter"));
- expect(table.setColumnFilters).toHaveBeenCalledTimes(1);
+ expect(setColumnFilters).toHaveBeenCalledTimes(1);
expect(onClose).toHaveBeenCalledTimes(1);
- const updater = (table.setColumnFilters as ReturnType<typeof vi.fn>).mock
- .calls[0][0];
+ const updater = setColumnFilters.mock.calls[0][0];
const next = updater([]);
expect(next).toEqual([
{
@@ -259,3 +244,55 @@ describe("FilterPillEditor — apply", () => {
]);
});
});
+
+describe("defaultFilterValueFor", () => {
+ it.each([
+ ["number", "between", { type: "number", operator: "between" }],
+ ["number", ">", { type: "number", operator: ">" }],
+ ["text", "contains", { type: "text", operator: "contains" }],
+ ["text", "in", { type: "text", operator: "in", values: [] }],
+ ["text", "not_in", { type: "text", operator: "not_in", values: [] }],
+ ["boolean", "is_true", { type: "boolean", operator: "is_true" }],
+ ["number", "in", { type: "number", operator: "in", values: [] }],
+ ["number", "not_in", { type: "number", operator: "not_in", values: [] }],
+ ["date", "between", { type: "date", operator: "between" }],
+ ["datetime", "between", { type: "datetime", operator: "between" }],
+ ["time", "between", { type: "time", operator: "between" }],
+ ] as const)("seeds %s + %s", (type, operator, expected) => {
+ expect(defaultFilterValueFor(type, operator)).toEqual(expected);
+ });
+});
+
+describe("buildEmptyFilterValue", () => {
+ it.each([
+ ["name", { type: "text", operator: "contains" }],
+ ["age", { type: "number", operator: "between" }],
+ ["when", { type: "date", operator: "==" }],
+ ["at", { type: "datetime", operator: "==" }],
+ ["clock", { type: "time", operator: "between" }],
+ ] as const)(
+ "picks the dtype-default operator for %s",
+ (columnId, expected) => {
+ const column = mockTable().getColumn(columnId)!;
+ expect(buildEmptyFilterValue(column)).toEqual(expected);
+ },
+ );
+});
+
+describe("buildEditorSnapshot", () => {
+ it("uses dtype-default operator when none provided", () => {
+ const column = mockTable().getColumn("name")!;
+ expect(buildEditorSnapshot(column)).toEqual({
+ columnId: "name",
+ value: { type: "text", operator: "contains" },
+ });
+ });
+
+ it("honors an explicit operator override", () => {
+ const column = mockTable().getColumn("name")!;
+ expect(buildEditorSnapshot(column, { operator: "in" })).toEqual({
+ columnId: "name",
+ value: { type: "text", operator: "in", values: [] },
+ });
+ });
+});
diff --git a/frontend/src/components/data-table/__tests__/filter-pills.test.tsx b/frontend/src/components/data-table/__tests__/filter-pills.test.tsx
new file mode 100644
index 0000000000..51a8fb88eb
--- /dev/null
+++ b/frontend/src/components/data-table/__tests__/filter-pills.test.tsx
@@ -0,0 +1,287 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import type { ColumnFiltersState } from "@tanstack/react-table";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import { AddFilterButton } from "../add-filter-button";
+import { FilterPills } from "../filter-pills";
+import { buildEditorSnapshot } from "../filter-pill-editor";
+import { Filter, type Snapshot } from "../filters";
+import {
+ buildFilterTestTable,
+ type FilterColumnSpec,
+} from "./filter-test-utils";
+
+const renderWithProviders = (ui: React.ReactElement) =>
+ render(<TooltipProvider>{ui}</TooltipProvider>);
+
+beforeAll(() => {
+ global.HTMLElement.prototype.scrollIntoView = () => {
+ // jsdom does not implement scrollIntoView; cmdk calls it on selection.
+ };
+ if (!global.HTMLElement.prototype.hasPointerCapture) {
+ global.HTMLElement.prototype.hasPointerCapture = () => false;
+ }
+ if (!global.HTMLElement.prototype.scrollTo) {
+ global.HTMLElement.prototype.scrollTo = () => {
+ // noop for jsdom
+ };
+ }
+});
+
+const DEFAULT_COLUMNS: FilterColumnSpec[] = [
+ { id: "name", filterType: "text" },
+ { id: "age", filterType: "number" },
+ { id: "when", filterType: "date" },
+];
+
+const mockTable = (specs: FilterColumnSpec[] = DEFAULT_COLUMNS) =>
+ buildFilterTestTable(specs).table;
+
+describe("FilterPills — strip gating", () => {
+ it("renders nothing when there are no filters and no pending add-snapshot", () => {
+ const { container } = renderWithProviders(
+ <FilterPills
+ filters={[]}
+ table={mockTable()}
+ addFilterSnapshot={null}
+ onAddFilterSnapshotChange={vi.fn()}
+ />,
+ );
+ expect(container.firstChild).toBeNull();
+ });
+
+ it("renders the strip and + button when at least one filter exists", () => {
+ const filters: ColumnFiltersState = [
+ {
+ id: "age",
+ value: Filter.number({ operator: ">", value: 18 }),
+ },
+ ];
+ renderWithProviders(
+ <FilterPills
+ filters={filters}
+ table={mockTable()}
+ addFilterSnapshot={null}
+ onAddFilterSnapshotChange={vi.fn()}
+ />,
+ );
+ expect(screen.getByLabelText("Add filter")).toBeInTheDocument();
+ expect(screen.getByLabelText("Edit filter on age")).toBeInTheDocument();
+ });
+
+ it("mounts the strip with no filters when a pending add-snapshot is set", () => {
+ const table = mockTable();
+ const snapshot: Snapshot = buildEditorSnapshot(table.getAllColumns()[0]);
+ renderWithProviders(
+ <FilterPills
+ filters={[]}
+ table={table}
+ addFilterSnapshot={snapshot}
+ onAddFilterSnapshotChange={vi.fn()}
+ />,
+ );
+ expect(screen.getByLabelText("Add filter")).toBeInTheDocument();
+ });
+});
+
+describe("AddFilterButton", () => {
+ it("does not render when there are no editable columns", () => {
+ const table = mockTable([{ id: "opaque" }]);
+ const { container } = renderWithProviders(
+ <AddFilterButton
+ table={table}
+ snapshot={null}
+ onSnapshotChange={vi.fn()}
+ />,
+ );
+ expect(container.firstChild).toBeNull();
+ });
+
+ it("seeds the editor with the first editable column's dtype default on click", () => {
+ const table = mockTable();
+ const onSnapshotChange = vi.fn();
+ renderWithProviders(
+ <AddFilterButton
+ table={table}
+ snapshot={null}
+ onSnapshotChange={onSnapshotChange}
+ />,
+ );
+ fireEvent.click(screen.getByLabelText("Add filter"));
+ expect(onSnapshotChange).toHaveBeenCalledTimes(1);
+ expect(onSnapshotChange).toHaveBeenCalledWith({
+ columnId: "name",
+ value: { type: "text", operator: "contains" },
+ });
+ });
+
+ it("clears the snapshot when the popover closes", () => {
+ const onSnapshotChange = vi.fn();
+ const snapshot: Snapshot = {
+ columnId: "age",
+ value: Filter.number({ operator: ">", value: 5 }),
+ };
+ renderWithProviders(
+ <AddFilterButton
+ table={mockTable()}
+ snapshot={snapshot}
+ onSnapshotChange={onSnapshotChange}
+ />,
+ );
+ // Pressing Escape closes the popover via radix.
+ fireEvent.keyDown(document.body, { key: "Escape" });
+ expect(onSnapshotChange).toHaveBeenCalledWith(null);
+ });
+
+ it("renders the editor when a snapshot is provided", () => {
+ renderWithProviders(
+ <AddFilterButton
+ table={mockTable()}
+ snapshot={{
+ columnId: "age",
+ value: Filter.number({ operator: ">", value: 7 }),
+ }}
+ onSnapshotChange={vi.fn()}
+ />,
+ );
+ expect(screen.getByLabelText("Apply filter")).toBeInTheDocument();
+ expect(screen.getByDisplayValue("7")).toBeInTheDocument();
+ });
+});
+
+describe("FilterPills — pill edit", () => {
+ it("opens the editor with the pill's snapshot when clicked", () => {
+ const filters: ColumnFiltersState = [
+ {
+ id: "age",
+ value: Filter.number({ operator: ">", value: 42 }),
+ },
+ ];
+ renderWithProviders(
+ <FilterPills
+ filters={filters}
+ table={mockTable()}
+ addFilterSnapshot={null}
+ onAddFilterSnapshotChange={vi.fn()}
+ />,
+ );
+ fireEvent.click(screen.getByLabelText("Edit filter on age"));
+ expect(screen.getByLabelText("Apply filter")).toBeInTheDocument();
+ expect(screen.getByDisplayValue("42")).toBeInTheDocument();
+ });
+
+ it("splices in place via editIndex when applying an edit", () => {
+ const { table, setColumnFilters } = buildFilterTestTable(DEFAULT_COLUMNS);
+ const filters: ColumnFiltersState = [
+ {
+ id: "name",
+ value: Filter.text({ operator: "contains", text: "foo" }),
+ },
+ {
+ id: "age",
+ value: Filter.number({ operator: ">", value: 1 }),
+ },
+ ];
+ renderWithProviders(
+ <FilterPills
+ filters={filters}
+ table={table}
+ addFilterSnapshot={null}
+ onAddFilterSnapshotChange={vi.fn()}
+ />,
+ );
+ fireEvent.click(screen.getByLabelText("Edit filter on age"));
+ fireEvent.click(screen.getByLabelText("Apply filter"));
+
+ const updater = setColumnFilters.mock.calls[0][0];
+ const next = updater(filters);
+ expect(next).toHaveLength(2);
+ expect(next[0].id).toBe("name");
+ expect(next[1]).toEqual({
+ id: "age",
+ value: { type: "number", operator: ">", value: 1 },
+ });
+ });
+});
+
+describe("FilterPills — column-header trigger integration", () => {
+ it("opens the editor under the + button with a column-header-supplied snapshot", () => {
+ // Simulates what DataTable does when column-header calls
+ // requestAddFilter({ columnId: "name" }): it computes a snapshot via
+ // buildEditorSnapshot and passes it down as addFilterSnapshot.
+ const table = mockTable();
+ const snapshot = buildEditorSnapshot(table.getColumn("name")!);
+ renderWithProviders(
+ <FilterPills
+ filters={[]}
+ table={table}
+ addFilterSnapshot={snapshot}
+ onAddFilterSnapshotChange={vi.fn()}
+ />,
+ );
+ expect(screen.getByLabelText("Apply filter")).toBeInTheDocument();
+ // Default text operator is "contains" — the text input renders.
+ expect(screen.getByPlaceholderText("Text…")).toBeInTheDocument();
+ });
+
+ it("pre-selects 'in' operator when column-header 'Filter by values' is used", () => {
+ const table = mockTable();
+ const snapshot = buildEditorSnapshot(table.getColumn("name")!, {
+ operator: "in",
+ });
+ renderWithProviders(
+ <FilterPills
+ filters={[]}
+ table={table}
+ addFilterSnapshot={snapshot}
+ onAddFilterSnapshotChange={vi.fn()}
+ />,
+ );
+ expect(snapshot.value).toEqual({
+ type: "text",
+ operator: "in",
+ values: [],
+ });
+ expect(screen.getByLabelText("Apply filter")).toBeInTheDocument();
+ });
+});
+
+describe("FilterPills — overflow", () => {
+ it("does not render the 'See all' button when there is no overflow", () => {
+ const filters: ColumnFiltersState = [
+ { id: "age", value: Filter.number({ operator: ">", value: 5 }) },
+ ];
+ renderWithProviders(
+ <FilterPills
+ filters={filters}
+ table={mockTable()}
+ addFilterSnapshot={null}
+ onAddFilterSnapshotChange={vi.fn()}
+ />,
+ );
+ expect(screen.queryByLabelText("See all filters")).toBeNull();
+ });
+});
+
+describe("FilterPill — value truncation", () => {
+ it("renders the value with truncation classes inside a tooltip trigger", () => {
+ const filters: ColumnFiltersState = [
+ {
+ id: "name",
+ value: Filter.text({ operator: "contains", text: "x".repeat(100) }),
+ },
+ ];
+ renderWithProviders(
+ <FilterPills
+ filters={filters}
+ table={mockTable()}
+ addFilterSnapshot={null}
+ onAddFilterSnapshotChange={vi.fn()}
+ />,
+ );
+ const valueSpan = screen.getByText(/^"x{100}"$/);
+ expect(valueSpan.className).toMatch(/overflow-hidden/);
+ expect(valueSpan.className).toMatch(/text-ellipsis/);
+ });
+});
diff --git a/frontend/src/components/data-table/__tests__/filter-test-utils.ts b/frontend/src/components/data-table/__tests__/filter-test-utils.ts
new file mode 100644
index 0000000000..4b122e15b3
--- /dev/null
+++ b/frontend/src/components/data-table/__tests__/filter-test-utils.ts
@@ -0,0 +1,47 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import {
+ type ColumnDef,
+ getCoreRowModel,
+ type Table,
+ useReactTable,
+} from "@tanstack/react-table";
+import { renderHook } from "@testing-library/react";
+import { vi } from "vitest";
+import type { FilterType } from "../filters";
+
+export interface FilterColumnSpec {
+ id: string;
+ filterType?: FilterType;
+ dtype?: string;
+}
+
+export interface FilterTestHarness {
+ table: Table<unknown>;
+ setColumnFilters: ReturnType<typeof vi.fn>;
+}
+
+export function buildFilterTestTable(
+ specs: FilterColumnSpec[],
+): FilterTestHarness {
+ const setColumnFilters = vi.fn();
+ const columns: Array<ColumnDef<unknown>> = specs.map((spec) => ({
+ id: spec.id,
+ accessorFn: () => undefined,
+ header: spec.id,
+ meta: {
+ ...(spec.filterType !== undefined ? { filterType: spec.filterType } : {}),
+ ...(spec.dtype !== undefined ? { dtype: spec.dtype } : {}),
+ },
+ }));
+ const { result } = renderHook(() =>
+ useReactTable<unknown>({
+ data: [],
+ columns,
+ locale: "en-US",
+ getCoreRowModel: getCoreRowModel(),
+ onColumnFiltersChange: setColumnFilters,
+ }),
+ );
+ return { table: result.current, setColumnFilters };
+}
diff --git a/frontend/src/components/data-table/__tests__/filters.test.ts b/frontend/src/components/data-table/__tests__/filters.test.ts
index e1e9e0714c..92c7029f3f 100644
--- a/frontend/src/components/data-table/__tests__/filters.test.ts
+++ b/frontend/src/components/data-table/__tests__/filters.test.ts
@@ -172,7 +172,7 @@ describe("filterToFilterCondition", () => {
it("handles boolean true filter", () => {
const result = filterToFilterCondition(
"active",
- Filter.boolean({ value: true }),
+ Filter.boolean({ operator: "is_true" }),
);
expect(result).toEqual([
{
@@ -187,7 +187,7 @@ describe("filterToFilterCondition", () => {
it("handles boolean false filter", () => {
const result = filterToFilterCondition(
"active",
- Filter.boolean({ value: false }),
+ Filter.boolean({ operator: "is_false" }),
);
expect(result).toEqual([
{
@@ -199,16 +199,16 @@ describe("filterToFilterCondition", () => {
]);
});
- it("handles select in filter", () => {
+ it("handles number in filter", () => {
const result = filterToFilterCondition(
"status",
- Filter.select({ options: ["a", "b"], operator: "in" }),
+ Filter.number({ operator: "in", values: [1, 2] }),
);
expect(result).toEqual([
{
column_id: "status",
operator: "in",
- value: ["a", "b"],
+ value: [1, 2],
type: "condition",
negate: false,
},
diff --git a/frontend/src/components/data-table/add-filter-button.tsx b/frontend/src/components/data-table/add-filter-button.tsx
new file mode 100644
index 0000000000..628cd1f7a3
--- /dev/null
+++ b/frontend/src/components/data-table/add-filter-button.tsx
@@ -0,0 +1,85 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+"use no memo";
+
+import type { Column, Table } from "@tanstack/react-table";
+import { PlusIcon } from "lucide-react";
+import type { CalculateTopKRows } from "@/plugins/impl/DataTablePlugin";
+import { Button } from "../ui/button";
+import { Popover, PopoverContent, PopoverTrigger } from "../ui/popover";
+import {
+ buildEditorSnapshot,
+ editableColumns,
+ FilterPillEditor,
+} from "./filter-pill-editor";
+import type { Snapshot } from "./filters";
+
+interface AddFilterButtonProps<TData> {
+ table: Table<TData>;
+ calculateTopKRows?: CalculateTopKRows;
+ snapshot: Snapshot | null;
+ onSnapshotChange: (snapshot: Snapshot | null) => void;
+}
+
+export const AddFilterButton = <TData,>({
+ table,
+ calculateTopKRows,
+ snapshot,
+ onSnapshotChange,
+}: AddFilterButtonProps<TData>) => {
+ const columns = editableColumns(table);
+
+ if (columns.length === 0) {
+ return null;
+ }
+
+ const handleOpenChange = (open: boolean) => {
+ if (!open) {
+ onSnapshotChange(null);
+ return;
+ }
+ if (snapshot === null) {
+ onSnapshotChange(
+ buildEditorSnapshot(columns[0] as Column<unknown, unknown>),
+ );
+ }
+ };
+
+ return (
+ <Popover
+ open={snapshot !== null}
+ onOpenChange={handleOpenChange}
+ modal={false}
+ >
+ <PopoverTrigger asChild={true}>
+ <Button
+ type="button"
+ size="icon"
+ variant="ghost"
+ className="h-5 w-5 -mr-1 rounded-full text-muted-foreground hover:text-foreground"
+ aria-label="Add filter"
+ >
+ <PlusIcon className="h-3.5 w-3.5" aria-hidden={true} />
+ </Button>
+ </PopoverTrigger>
+ {snapshot !== null && (
+ <PopoverContent
+ className="w-auto p-0"
+ align="start"
+ alignOffset={-10}
+ sideOffset={10}
+ avoidCollisions={true}
+ onOpenAutoFocus={(e) => e.preventDefault()}
+ onCloseAutoFocus={(e) => e.preventDefault()}
+ >
+ <FilterPillEditor
+ key={`${snapshot.columnId}:${snapshot.value.operator}`}
+ snapshot={snapshot}
+ table={table}
+ calculateTopKRows={calculateTopKRows}
+ onClose={() => onSnapshotChange(null)}
+ />
+ </PopoverContent>
+ )}
+ </Popover>
+ );
+};
diff --git a/frontend/src/components/data-table/column-header.tsx b/frontend/src/components/data-table/column-header.tsx
index 5567bd7feb..d8843bc3d9 100644
--- a/frontend/src/components/data-table/column-header.tsx
+++ b/frontend/src/components/data-table/column-header.tsx
@@ -2,71 +2,27 @@
"use no memo";
import type { Column, Table } from "@tanstack/react-table";
-import {
- EllipsisIcon,
- FilterIcon,
- MinusIcon,
- TextIcon,
- XIcon,
-} from "lucide-react";
-import { useState } from "react";
+import { EllipsisIcon, FilterIcon, ListFilterIcon } from "lucide-react";
import { useLocale } from "react-aria";
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
- DropdownMenuPortal,
DropdownMenuSeparator,
- DropdownMenuSub,
- DropdownMenuSubContent,
- DropdownMenuSubTrigger,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu";
import type { CalculateTopKRows } from "@/plugins/impl/DataTablePlugin";
-import type { OperatorType } from "@/plugins/impl/data-frames/utils/operators";
-import { logNever } from "@/utils/assertNever";
import { cn } from "@/utils/cn";
-import { Button } from "../ui/button";
-import { DraggablePopover } from "../ui/draggable-popover";
-import { Input } from "../ui/input";
-import { RegexInput } from "./regex-input";
-import { NumberField } from "../ui/number-field";
-import { PopoverClose } from "../ui/popover";
-import {
- Select,
- SelectContent,
- SelectItem,
- SelectTrigger,
- SelectValue,
-} from "../ui/select";
-import { FilterByValuesList } from "./filter-by-values-picker";
-import { OPERATOR_LABELS } from "./operator-labels";
-import {
- type ColumnFilterForType,
- type ColumnFilterValue,
- DATETIME_OPS,
- Filter,
- isDatetimeComparisonOp,
- isNumberComparisonOp,
- isTextScalarOp,
- NUMBER_OPS,
- TEXT_OPS,
-} from "./filters";
-import {
- type DateLikeFilterType,
- DateLikeInput,
- DateLikeRangeInput,
-} from "./date-filter-inputs";
+import { useFilterEditor } from "./filter-editor-context";
+import { EDITABLE_FILTER_TYPES, isMembershipFilterType } from "./filters";
import {
ClearFilterMenuItem,
- FilterButtons,
renderColumnPinning,
renderColumnWrapping,
renderCopyColumn,
renderDataType,
- renderFilterByValues,
renderFormatOptions,
- renderSortFilterIcon,
+ renderSortIcon,
renderSorts,
} from "./header-items";
@@ -88,11 +44,10 @@ export const DataTableColumnHeader = <TData, TValue>({
subheader,
justify,
className,
- calculateTopKRows,
table,
}: DataTableColumnHeaderProps<TData, TValue>) => {
- const [isFilterValueOpen, setIsFilterValueOpen] = useState(false);
const { locale } = useLocale();
+ const editor = useFilterEditor();
// No header
if (!header) {
@@ -116,68 +71,101 @@ export const DataTableColumnHeader = <TData, TValue>({
}
const hasFilter = column.getFilterValue() !== undefined;
+ const filterType = column.columnDef.meta?.filterType;
+ const canEditFilter =
+ editor !== null &&
+ column.getCanFilter() &&
+ filterType !== undefined &&
+ EDITABLE_FILTER_TYPES.has(filterType);
+ const canFilterByValues =
+ canEditFilter &&
+ filterType !== undefined &&
+ isMembershipFilterType(filterType);
return (
- <>
+ <div
+ className={cn("group flex flex-col my-1 w-full select-none", className)}
+ >
<div
- className={cn("group flex flex-col my-1 w-full select-none", className)}
+ className={cn(
+ "flex items-center gap-1",
+ justify === "right" && "flex-row-reverse",
+ justify === "center" && "mx-auto",
+ )}
>
- <div
- className={cn(
- "flex items-center gap-1",
- justify === "right" && "flex-row-reverse",
- justify === "center" && "mx-auto",
- )}
- >
- {justify === "center" ? (
- <>
- {column.getCanSort() && <SortButton column={column} />}
- <span>{header}</span>
- </>
- ) : (
- <>
- <span>{header}</span>
- {column.getCanSort() && <SortButton column={column} />}
- </>
- )}
- <DropdownMenu modal={false}>
- <DropdownMenuTrigger asChild={true}>
- <button
- type="button"
- className="inline-flex items-center justify-center h-5 w-5 rounded hover:bg-(--slate-4) text-muted-foreground opacity-0 group-hover:opacity-100 focus:opacity-100 group-focus-within:opacity-100 data-[state=open]:opacity-100 data-[state=open]:text-accent-foreground"
- aria-label="Column options"
- data-testid="data-table-column-menu-button"
+ {justify === "center" ? (
+ <>
+ {column.getCanSort() && <SortButton column={column} />}
+ {hasFilter && <FilterIndicator />}
+ <span>{header}</span>
+ </>
+ ) : (
+ <>
+ <span>{header}</span>
+ {hasFilter && <FilterIndicator />}
+ {column.getCanSort() && <SortButton column={column} />}
+ </>
+ )}
+ <DropdownMenu modal={false}>
+ <DropdownMenuTrigger asChild={true}>
+ <button
+ type="button"
+ className="inline-flex items-center justify-center h-5 w-5 rounded hover:bg-(--slate-4) text-muted-foreground opacity-0 group-hover:opacity-100 focus:opacity-100 group-focus-within:opacity-100 data-[state=open]:opacity-100 data-[state=open]:text-accent-foreground"
+ aria-label="Column options"
+ data-testid="data-table-column-menu-button"
+ >
+ <EllipsisIcon className="h-3.5 w-3.5" />
+ </button>
+ </DropdownMenuTrigger>
+ <DropdownMenuContent align="start">
+ {renderDataType(column)}
+ {renderSorts(column, table)}
+ {renderCopyColumn(column)}
+ {renderColumnPinning(column)}
+ {renderColumnWrapping(column)}
+ {renderFormatOptions(column, locale)}
+ {canEditFilter && <DropdownMenuSeparator />}
+ {canEditFilter && (
+ <DropdownMenuItem
+ onSelect={() =>
+ editor.requestAddFilter({ columnId: column.id })
+ }
>
- <EllipsisIcon className="h-3.5 w-3.5" />
- </button>
- </DropdownMenuTrigger>
- <DropdownMenuContent align="start">
- {renderDataType(column)}
- {renderSorts(column, table)}
- {renderCopyColumn(column)}
- {renderColumnPinning(column)}
- {renderColumnWrapping(column)}
- {renderFormatOptions(column, locale)}
- <DropdownMenuSeparator />
- {renderMenuItemFilter(column, calculateTopKRows)}
- {renderFilterByValues(column, setIsFilterValueOpen)}
- {hasFilter && <ClearFilterMenuItem column={column} />}
- </DropdownMenuContent>
- </DropdownMenu>
- </div>
- {subheader}
+ <FilterIcon className="mo-dropdown-icon" />
+ Filter
+ </DropdownMenuItem>
+ )}
+ {canFilterByValues && (
+ <DropdownMenuItem
+ onSelect={() =>
+ editor.requestAddFilter({
+ columnId: column.id,
+ operator: "in",
+ })
+ }
+ >
+ <ListFilterIcon className="mo-dropdown-icon" />
+ Filter by values
+ </DropdownMenuItem>
+ )}
+ {hasFilter && <ClearFilterMenuItem column={column} />}
+ </DropdownMenuContent>
+ </DropdownMenu>
</div>
- {isFilterValueOpen && (
- <PopoverFilterByValues
- setIsFilterValueOpen={setIsFilterValueOpen}
- calculateTopKRows={calculateTopKRows}
- column={column}
- />
- )}
- </>
+ {subheader}
+ </div>
);
};
+const FilterIndicator = () => (
+ <span
+ className="inline-flex items-center justify-center h-5 w-5 text-primary"
+ aria-label="Column is filtered"
+ >
+ <FilterIcon className="h-3 w-3" aria-hidden={true} />
+ </span>
+);
+
const SortButton = <TData, TValue>({
column,
}: {
@@ -215,594 +203,7 @@ const SortButton = <TData, TValue>({
}
data-testid="data-table-sort-button"
>
- {renderSortFilterIcon(column)}
+ {renderSortIcon(column)}
</button>
);
};
-
-export function renderMenuItemFilter<TData, TValue>(
- column: Column<TData, TValue>,
- calculateTopKRows?: CalculateTopKRows,
-) {
- const canFilter = column.getCanFilter();
- if (!canFilter) {
- return null;
- }
-
- const filterType = column.columnDef.meta?.filterType;
- if (!filterType) {
- return null;
- }
-
- const filterMenuItem = (
- <DropdownMenuSubTrigger>
- <FilterIcon className="mo-dropdown-icon" />
- Filter
- </DropdownMenuSubTrigger>
- );
-
- if (filterType === "boolean") {
- return (
- <DropdownMenuSub>
- {filterMenuItem}
- <DropdownMenuPortal>
- <DropdownMenuSubContent>
- <BooleanFilter column={column} />
- </DropdownMenuSubContent>
- </DropdownMenuPortal>
- </DropdownMenuSub>
- );
- }
-
- if (filterType === "text") {
- return (
- <DropdownMenuSub>
- {filterMenuItem}
- <DropdownMenuPortal>
- <DropdownMenuSubContent>
- <TextFilterMenu
- column={column}
- calculateTopKRows={calculateTopKRows}
- />
- </DropdownMenuSubContent>
- </DropdownMenuPortal>
- </DropdownMenuSub>
- );
- }
-
- if (filterType === "number") {
- return (
- <DropdownMenuSub>
- {filterMenuItem}
- <DropdownMenuPortal>
- <DropdownMenuSubContent>
- <NumberFilterMenu column={column} />
- </DropdownMenuSubContent>
- </DropdownMenuPortal>
- </DropdownMenuSub>
- );
- }
-
- if (filterType === "select") {
- // Not implemented
- return null;
- }
-
- if (
- filterType === "date" ||
- filterType === "datetime" ||
- filterType === "time"
- ) {
- return (
- <DropdownMenuSub>
- {filterMenuItem}
- <DropdownMenuPortal>
- <DropdownMenuSubContent>
- <DateFilterMenu column={column} filterType={filterType} />
- </DropdownMenuSubContent>
- </DropdownMenuPortal>
- </DropdownMenuSub>
- );
- }
-
- logNever(filterType);
- return null;
-}
-
-const OperatorSelect = ({
- operator,
- options,
- onChange,
-}: {
- operator: OperatorType;
- options: readonly OperatorType[];
- onChange: (next: OperatorType) => void;
-}) => (
- <Select value={operator} onValueChange={(v) => onChange(v as OperatorType)}>
- <SelectTrigger className="border-border shadow-none! ring-0! w-full mb-0.5">
- <SelectValue />
- </SelectTrigger>
- <SelectContent>
- {options.map((op) => (
- <SelectItem key={op} value={op}>
- {OPERATOR_LABELS[op]}
- </SelectItem>
- ))}
- </SelectContent>
- </Select>
-);
-
-const BooleanFilter = <TData, TValue>({
- column,
-}: {
- column: Column<TData, TValue>;
-}) => {
- return (
- <>
- <DropdownMenuItem
- onClick={() =>
- column.setFilterValue(
- Filter.boolean({ value: true, operator: "is_true" }),
- )
- }
- >
- True
- </DropdownMenuItem>
- <DropdownMenuItem
- onClick={() =>
- column.setFilterValue(
- Filter.boolean({ value: false, operator: "is_false" }),
- )
- }
- >
- False
- </DropdownMenuItem>
- <DropdownMenuSeparator />
- <DropdownMenuItem
- onClick={() =>
- column.setFilterValue(Filter.boolean({ operator: "is_null" }))
- }
- >
- Is null
- </DropdownMenuItem>
- <DropdownMenuItem
- onClick={() =>
- column.setFilterValue(Filter.boolean({ operator: "is_not_null" }))
- }
- >
- Is not null
- </DropdownMenuItem>
- </>
- );
-};
-
-type NumberComparisonFilter = Extract<
- ColumnFilterForType<"number">,
- { value: number }
->;
-const isNumberComparisonFilter = (
- filter: ColumnFilterForType<"number">,
-): filter is NumberComparisonFilter => isNumberComparisonOp(filter.operator);
-
-export const NumberFilterMenu = <TData, TValue>({
- column,
-}: {
- column: Column<TData, TValue>;
-}) => {
- const currentFilter = column.getFilterValue() as
- | ColumnFilterForType<"number">
- | undefined;
- const hasFilter = currentFilter !== undefined;
-
- const [operator, setOperator] = useState<OperatorType>(
- currentFilter?.operator ?? "between",
- );
- const [min, setMin] = useState<number | undefined>(
- currentFilter?.operator === "between" ? currentFilter.min : undefined,
- );
- const [max, setMax] = useState<number | undefined>(
- currentFilter?.operator === "between" ? currentFilter.max : undefined,
- );
- const [value, setValue] = useState<number | undefined>(
- currentFilter !== undefined && isNumberComparisonFilter(currentFilter)
- ? currentFilter.value
- : undefined,
- );
-
- const isComparison = isNumberComparisonOp(operator);
- const isNullish = operator === "is_null" || operator === "is_not_null";
-
- const applyDisabled =
- (operator === "between" && (min === undefined || max === undefined)) ||
- (isComparison && value === undefined);
-
- const handleApply = () => {
- if (isNullish) {
- column.setFilterValue(Filter.number({ operator }));
- return;
- }
- if (operator === "between" && min !== undefined && max !== undefined) {
- column.setFilterValue(Filter.number({ operator: "between", min, max }));
- return;
- }
- if (isComparison && value !== undefined) {
- column.setFilterValue(Filter.number({ operator, value }));
- }
- };
-
- const handleClear = () => {
- setMin(undefined);
- setMax(undefined);
- setValue(undefined);
- column.setFilterValue(undefined);
- };
-
- const handleOperatorChange = (next: OperatorType) => {
- setOperator(next);
- };
-
- return (
- <div className="flex flex-col gap-1 pt-3 px-2">
- <OperatorSelect
- operator={operator}
- options={NUMBER_OPS}
- onChange={handleOperatorChange}
- />
- {operator === "between" && (
- <div className="flex gap-1 items-center">
- <NumberField
- value={min}
- onChange={setMin}
- aria-label="min"
- placeholder="min"
- className="shadow-none! border-border hover:shadow-none!"
- />
- <MinusIcon className="h-5 w-5 text-muted-foreground" />
- <NumberField
- value={max}
- onChange={setMax}
- aria-label="max"
- placeholder="max"
- className="shadow-none! border-border hover:shadow-none!"
- />
- </div>
- )}
- {isComparison && (
- <NumberField
- value={value}
- onChange={setValue}
- aria-label="value"
- placeholder="value"
- className="shadow-none! border-border hover:shadow-none!"
- />
- )}
- <FilterButtons
- onApply={handleApply}
- onClear={handleClear}
- clearButtonDisabled={!hasFilter}
- applyButtonDisabled={applyDisabled}
- />
- </div>
- );
-};
-
-type DateComparisonFilter = Extract<
- ColumnFilterForType<DateLikeFilterType>,
- { value: Date }
->;
-const isDateComparisonFilter = (
- filter: ColumnFilterForType<DateLikeFilterType>,
-): filter is DateComparisonFilter => isDatetimeComparisonOp(filter.operator);
-
-export const DateFilterMenu = <TData, TValue>({
- column,
- filterType,
-}: {
- column: Column<TData, TValue>;
- filterType: DateLikeFilterType;
-}) => {
- const currentFilter = column.getFilterValue() as
- | ColumnFilterForType<DateLikeFilterType>
- | undefined;
- const hasFilter = currentFilter !== undefined;
-
- const [operator, setOperator] = useState<OperatorType>(
- currentFilter?.operator ?? "between",
- );
- const [min, setMin] = useState<Date | undefined>(
- currentFilter?.operator === "between" ? currentFilter.min : undefined,
- );
- const [max, setMax] = useState<Date | undefined>(
- currentFilter?.operator === "between" ? currentFilter.max : undefined,
- );
- const [value, setValue] = useState<Date | undefined>(
- currentFilter !== undefined && isDateComparisonFilter(currentFilter)
- ? currentFilter.value
- : undefined,
- );
-
- const isComparison = isDatetimeComparisonOp(operator);
- const isNullish = operator === "is_null" || operator === "is_not_null";
-
- const applyDisabled =
- (operator === "between" && (min === undefined || max === undefined)) ||
- (isComparison && value === undefined);
-
- const buildFilter = (
- opts: Parameters<typeof Filter.date>[0],
- ): ColumnFilterForType<DateLikeFilterType> => {
- switch (filterType) {
- case "date":
- return Filter.date(opts);
- case "datetime":
- return Filter.datetime(opts);
- case "time":
- return Filter.time(opts);
- }
- };
-
- const handleApply = () => {
- if (isNullish) {
- column.setFilterValue(buildFilter({ operator }));
- return;
- }
- if (operator === "between" && min !== undefined && max !== undefined) {
- column.setFilterValue(buildFilter({ operator: "between", min, max }));
- return;
- }
- if (isComparison && value !== undefined) {
- column.setFilterValue(buildFilter({ operator, value }));
- }
- };
-
- const [resetKey, setResetKey] = useState(0);
- const handleClear = () => {
- setMin(undefined);
- setMax(undefined);
- setValue(undefined);
- setResetKey((k) => k + 1);
- column.setFilterValue(undefined);
- };
-
- const handleOperatorChange = (next: OperatorType) => {
- setOperator(next);
- };
-
- return (
- <div
- className="flex flex-col gap-1 pt-3 px-2"
- onKeyDownCapture={(e) => {
- if (e.key === "Tab") {
- e.stopPropagation();
- }
- }}
- >
- <OperatorSelect
- operator={operator}
- options={DATETIME_OPS}
- onChange={handleOperatorChange}
- />
- {operator === "between" && (
- <DateLikeRangeInput
- key={`${filterType}-${resetKey}`}
- filterType={filterType}
- min={min}
- max={max}
- onRangeChange={(nextMin, nextMax) => {
- setMin(nextMin);
- setMax(nextMax);
- }}
- className="shadow-none! border-border hover:shadow-none!"
- />
- )}
- {isComparison && (
- <DateLikeInput
- key={`${filterType}-${resetKey}`}
- filterType={filterType}
- value={value}
- onChange={setValue}
- aria-label="value"
- className="shadow-none! border-border hover:shadow-none!"
- />
- )}
- <FilterButtons
- onApply={handleApply}
- onClear={handleClear}
- clearButtonDisabled={!hasFilter}
- applyButtonDisabled={applyDisabled}
- />
- </div>
- );
-};
-
-export const TextFilterMenu = <TData, TValue>({
- column,
- calculateTopKRows,
-}: {
- column: Column<TData, TValue>;
- calculateTopKRows?: CalculateTopKRows;
-}) => {
- const currentFilter = column.getFilterValue() as
- | ColumnFilterForType<"text">
- | undefined;
- const hasFilter = currentFilter !== undefined;
-
- const [operator, setOperator] = useState<OperatorType>(
- currentFilter?.operator ?? "contains",
- );
- const [text, setText] = useState<string>(
- currentFilter && "text" in currentFilter ? currentFilter.text : "",
- );
- const [values, setValues] = useState<string[]>(
- currentFilter && "values" in currentFilter ? [...currentFilter.values] : [],
- );
-
- const isScalar = isTextScalarOp(operator);
- const isMulti = operator === "in" || operator === "not_in";
- const isNullish =
- operator === "is_null" ||
- operator === "is_not_null" ||
- operator === "is_empty";
-
- const applyDisabled =
- (isScalar && text === "") || (isMulti && values.length === 0);
-
- const handleApply = () => {
- if (isNullish) {
- column.setFilterValue(Filter.text({ operator }));
- return;
- }
- if (isScalar && text !== "") {
- column.setFilterValue(Filter.text({ operator, text }));
- return;
- }
- if (isMulti && values.length > 0) {
- column.setFilterValue(Filter.text({ operator, values }));
- }
- };
-
- const handleClear = () => {
- setText("");
- setValues([]);
- column.setFilterValue(undefined);
- };
-
- const handleOperatorChange = (next: OperatorType) => {
- setOperator(next);
- };
-
- return (
- <div className="flex flex-col gap-1 pt-3 px-2">
- <OperatorSelect
- operator={operator}
- options={TEXT_OPS}
- onChange={handleOperatorChange}
- />
- {isScalar && operator === "regex" && (
- <RegexInput
- value={text}
- onChange={setText}
- onKeyDown={(e) => {
- e.stopPropagation();
- if (e.key === "Enter") {
- handleApply();
- }
- }}
- />
- )}
- {isScalar && operator !== "regex" && (
- <Input
- type="text"
- icon={<TextIcon className="h-3 w-3 text-muted-foreground mb-1" />}
- value={text}
- onChange={(e) => setText(e.target.value)}
- placeholder="Text..."
- onKeyDown={(e) => {
- e.stopPropagation();
- if (e.key === "Enter") {
- handleApply();
- }
- }}
- className="shadow-none! border-border hover:shadow-none!"
- />
- )}
- {isMulti && (
- <FilterByValuesList
- column={column}
- calculateTopKRows={calculateTopKRows}
- chosenValues={new Set(values)}
- onChange={(next) => setValues(next.map(String))}
- creatable={true}
- />
- )}
- <FilterButtons
- onApply={handleApply}
- onClear={handleClear}
- clearButtonDisabled={!hasFilter}
- applyButtonDisabled={applyDisabled}
- />
- </div>
- );
-};
-
-/**
- * Seed the filter-by-values picker from a column's existing filter value.
- *
- * Reopening the picker should reflect what's already applied. Only `select`
- * filters carry checkbox-style values; other filter shapes (number, text,
- * etc.) seed an empty list.
- */
-export function seedFromFilter(value: ColumnFilterValue | undefined): {
- values: unknown[];
- operator: Extract<OperatorType, "in" | "not_in">;
-} {
- if (value && "type" in value && value.type === "select") {
- return {
- values: [...value.options],
- operator: value.operator === "not_in" ? "not_in" : "in",
- };
- }
- return { values: [], operator: "in" };
-}
-
-const PopoverFilterByValues = <TData, TValue>({
- setIsFilterValueOpen,
- calculateTopKRows,
- column,
-}: {
- setIsFilterValueOpen: (open: boolean) => void;
- calculateTopKRows?: CalculateTopKRows;
- column: Column<TData, TValue>;
-}) => {
- const seed = seedFromFilter(
- column.getFilterValue() as ColumnFilterValue | undefined,
- );
-
- const [chosenValues, setChosenValues] = useState<Set<unknown>>(
- () => new Set(seed.values),
- );
-
- const handleApply = () => {
- if (chosenValues.size === 0) {
- column.setFilterValue(undefined);
- return;
- }
- column.setFilterValue(
- Filter.select({
- options: [...chosenValues],
- operator: seed.operator,
- }),
- );
- };
-
- return (
- <DraggablePopover
- open={true}
- onOpenChange={(open) => !open && setIsFilterValueOpen(false)}
- className="w-80 p-0"
- >
- <PopoverClose className="absolute top-2 right-2">
- <Button
- variant="link"
- size="sm"
- onClick={() => setIsFilterValueOpen(false)}
- >
- <XIcon className="h-4 w-4" />
- </Button>
- </PopoverClose>
- <div className="flex flex-col gap-1.5 py-2">
- <FilterByValuesList
- column={column}
- calculateTopKRows={calculateTopKRows}
- chosenValues={chosenValues}
- onChange={(values) => setChosenValues(new Set(values))}
- />
- <FilterButtons
- onApply={handleApply}
- onClear={() => setChosenValues(new Set())}
- clearButtonDisabled={chosenValues.size === 0}
- />
- </div>
- </DraggablePopover>
- );
-};
diff --git a/frontend/src/components/data-table/context-menu.tsx b/frontend/src/components/data-table/context-menu.tsx
index 89dbd24f2f..f2aaf9b7dc 100644
--- a/frontend/src/components/data-table/context-menu.tsx
+++ b/frontend/src/components/data-table/context-menu.tsx
@@ -16,7 +16,11 @@ import {
ContextMenuTrigger,
} from "../ui/context-menu";
import { DATA_CELL_ID } from "./cell-utils";
-import { Filter } from "./filters";
+import {
+ Filter,
+ isMembershipFilterType,
+ type MembershipFilterType,
+} from "./filters";
import { selectedCellsAtom } from "./range-focus/atoms";
import { getClipboardContent, getRawValue } from "./utils";
@@ -97,15 +101,21 @@ export const CellContextMenu = <TData,>({
};
const column = cell.column;
- const canFilter = column.getCanFilter() && column.columnDef.meta?.filterType;
+ const filterType = column.columnDef.meta?.filterType;
+ const membershipFilterType: MembershipFilterType | undefined =
+ column.getCanFilter() && filterType && isMembershipFilterType(filterType)
+ ? filterType
+ : undefined;
- const handleFilterCell = (operator: "in" | "not_in") => {
- column.setFilterValue(
- Filter.select({
- options: [rawValue],
- operator,
- }),
- );
+ const handleFilterCell = (
+ type: MembershipFilterType,
+ operator: "in" | "not_in",
+ ) => {
+ const filter =
+ type === "number"
+ ? Filter.number({ operator, values: [rawValue] })
+ : Filter.text({ operator, values: [rawValue] });
+ column.setFilterValue(filter);
};
return (
@@ -120,14 +130,18 @@ export const CellContextMenu = <TData,>({
Copy selected cells
</ContextMenuItem>
)}
- {canFilter && (
+ {membershipFilterType && (
<>
<ContextMenuSeparator />
- <ContextMenuItem onClick={() => handleFilterCell("in")}>
+ <ContextMenuItem
+ onClick={() => handleFilterCell(membershipFilterType, "in")}
+ >
<FilterIcon className="mo-dropdown-icon h-3 w-3" />
Filter by this value
</ContextMenuItem>
- <ContextMenuItem onClick={() => handleFilterCell("not_in")}>
+ <ContextMenuItem
+ onClick={() => handleFilterCell(membershipFilterType, "not_in")}
+ >
<FilterIcon className="mo-dropdown-icon h-3 w-3" />
Remove rows with this value
</ContextMenuItem>
diff --git a/frontend/src/components/data-table/data-table.tsx b/frontend/src/components/data-table/data-table.tsx
index 33f3e68a33..d60691dbf2 100644
--- a/frontend/src/components/data-table/data-table.tsx
+++ b/frontend/src/components/data-table/data-table.tsx
@@ -5,6 +5,7 @@
// https://github.com/TanStack/table/issues/5567
import {
+ type Column,
type ColumnDef,
type ColumnFiltersState,
ColumnPinning,
@@ -41,7 +42,13 @@ import { ColumnFormattingFeature } from "./column-formatting/feature";
import { ColumnWrappingFeature } from "./column-wrapping/feature";
import { CopyColumnFeature } from "./copy-column/feature";
import type { ExportActionProps } from "./export-actions";
+import {
+ type AddFilterRequest,
+ FilterEditorProvider,
+} from "./filter-editor-context";
+import { buildEditorSnapshot } from "./filter-pill-editor";
import { FilterPills } from "./filter-pills";
+import type { Snapshot } from "./filters";
import { FocusRowFeature } from "./focus-row/feature";
import { useColumnPinning } from "./hooks/use-column-pinning";
import { useScrollContainerHeight } from "./hooks/use-scroll-container-height";
@@ -289,67 +296,92 @@ const DataTableInternal = <TData,>({
const tableRef = useScrollContainerHeight({ maxHeight, virtualize });
+ const [addFilterSnapshot, setAddFilterSnapshot] =
+ React.useState<Snapshot | null>(null);
+
+ // useMemo instead of useCallback because need to pass it as object
+ const filterEditor = React.useMemo(
+ () => ({
+ requestAddFilter: (request: AddFilterRequest) => {
+ const column = table.getColumn(request.columnId);
+ if (!column) {
+ return;
+ }
+ setAddFilterSnapshot(
+ buildEditorSnapshot(column as Column<unknown, unknown>, {
+ operator: request.operator,
+ }),
+ );
+ },
+ }),
+ [table],
+ );
+
return (
- <div className={cn(wrapperClassName, "flex flex-col space-y-1")}>
- <FilterPills
- filters={filters}
- table={table}
- calculateTopKRows={calculateTopKRows}
- />
- <CellSelectionProvider>
- <div
- part="table-wrapper"
- className={cn(className || "rounded-md border overflow-hidden")}
- >
- <TableTopBar
- enableSearch={enableSearch}
- searchQuery={searchQuery}
- onSearchQueryChange={onSearchQueryChange}
- reloading={reloading}
- showChartBuilder={showChartBuilder}
- isChartBuilderOpen={isChartBuilderOpen}
- toggleDisplayHeader={toggleDisplayHeader}
- showTableExplorer={showTableExplorer}
- togglePanel={togglePanel}
- isAnyPanelOpen={isAnyPanelOpen}
- downloadAs={downloadAs}
- sizeBytes={sizeBytes}
- />
- <Table
- className={cn(
- "relative",
- columns.length <= AUTO_WIDTH_MAX_COLUMNS ? "w-auto" : "w-full",
- )}
- ref={tableRef}
+ <FilterEditorProvider value={filterEditor}>
+ <div className={cn(wrapperClassName, "flex flex-col space-y-1")}>
+ <FilterPills
+ filters={filters}
+ table={table}
+ calculateTopKRows={calculateTopKRows}
+ addFilterSnapshot={addFilterSnapshot}
+ onAddFilterSnapshotChange={setAddFilterSnapshot}
+ />
+ <CellSelectionProvider>
+ <div
+ part="table-wrapper"
+ className={cn(className || "rounded-md border overflow-hidden")}
>
- {showLoadingBar && (
- <thead className="absolute top-0 left-0 h-[3px] w-1/2 bg-primary animate-slide" />
- )}
- {renderTableHeader(table, virtualize || Boolean(maxHeight))}
- <DataTableBody
+ <TableTopBar
+ enableSearch={enableSearch}
+ searchQuery={searchQuery}
+ onSearchQueryChange={onSearchQueryChange}
+ reloading={reloading}
+ showChartBuilder={showChartBuilder}
+ isChartBuilderOpen={isChartBuilderOpen}
+ toggleDisplayHeader={toggleDisplayHeader}
+ showTableExplorer={showTableExplorer}
+ togglePanel={togglePanel}
+ isAnyPanelOpen={isAnyPanelOpen}
+ downloadAs={downloadAs}
+ sizeBytes={sizeBytes}
+ />
+ <Table
+ className={cn(
+ "relative",
+ columns.length <= AUTO_WIDTH_MAX_COLUMNS ? "w-auto" : "w-full",
+ )}
+ ref={tableRef}
+ >
+ {showLoadingBar && (
+ <thead className="absolute top-0 left-0 h-[3px] w-1/2 bg-primary animate-slide" />
+ )}
+ {renderTableHeader(table, virtualize || Boolean(maxHeight))}
+ <DataTableBody
+ table={table}
+ columns={columns}
+ rowViewerPanelOpen={rowViewerPanelOpen}
+ getRowIndex={getPaginatedRowIndex}
+ viewedRowIdx={viewedRowIdx}
+ virtualize={virtualize}
+ />
+ </Table>
+ <TableBottomBar
+ part="table-footer"
+ className="pt-1.5 pb-0.5 border-t border-border"
+ totalColumns={totalColumns}
+ pagination={pagination}
+ selection={selection}
+ onRowSelectionChange={onRowSelectionChange}
table={table}
- columns={columns}
- rowViewerPanelOpen={rowViewerPanelOpen}
- getRowIndex={getPaginatedRowIndex}
- viewedRowIdx={viewedRowIdx}
- virtualize={virtualize}
+ getRowIds={getRowIds}
+ showPageSizeSelector={showPageSizeSelector}
+ tableLoading={reloading}
/>
- </Table>
- <TableBottomBar
- part="table-footer"
- className="pt-1.5 pb-0.5 border-t border-border"
- totalColumns={totalColumns}
- pagination={pagination}
- selection={selection}
- onRowSelectionChange={onRowSelectionChange}
- table={table}
- getRowIds={getRowIds}
- showPageSizeSelector={showPageSizeSelector}
- tableLoading={reloading}
- />
- </div>
- </CellSelectionProvider>
- </div>
+ </div>
+ </CellSelectionProvider>
+ </div>
+ </FilterEditorProvider>
);
};
diff --git a/frontend/src/components/data-table/date-filter-inputs.tsx b/frontend/src/components/data-table/date-filter-inputs.tsx
index 0a5a0de10f..ba7fa1010c 100644
--- a/frontend/src/components/data-table/date-filter-inputs.tsx
+++ b/frontend/src/components/data-table/date-filter-inputs.tsx
@@ -11,11 +11,11 @@ import type { DateValue, TimeValue } from "react-aria-components";
import { TimeField } from "@/components/ui/date-input";
import { DatePicker, DateRangePicker } from "@/components/ui/date-picker";
import {
- dateToISODate,
- dateToISODateTime,
- dateToISOTime,
- type FilterType,
-} from "./filters";
+ dateToLocalISODate,
+ dateToLocalISODateTime,
+ dateToLocalISOTime,
+} from "@/utils/dates";
+import type { FilterType } from "./filters";
export type DateLikeFilterType = Extract<
FilterType,
@@ -28,11 +28,11 @@ function dateToAria(
): DateValue | TimeValue {
switch (filterType) {
case "date":
- return parseDate(dateToISODate(d));
+ return parseDate(dateToLocalISODate(d));
case "datetime":
- return parseDateTime(dateToISODateTime(d));
+ return parseDateTime(dateToLocalISODateTime(d));
case "time":
- return parseTime(dateToISOTime(d));
+ return parseTime(dateToLocalISOTime(d));
}
}
@@ -128,11 +128,11 @@ export function parsePastedDate(
return parsed;
}
-function parsePastedRange(
+export function parsePastedRange(
filterType: DateLikeFilterType,
text: string,
): { min: Date; max: Date } | undefined {
- const parts = text.split(/\s+(?:-|–|—|to)\s+/i);
+ const parts = text.split(/\s+(?:-|–|—|to|and)\s+/i);
if (parts.length === 2) {
const min = parsePastedDate(filterType, parts[0]);
const max = parsePastedDate(filterType, parts[1]);
@@ -194,6 +194,7 @@ export const DateLikeInput = ({
key={seedKey}
aria-label={ariaLabel}
defaultValue={seedValue as Time | undefined}
+ hourCycle={24}
onChange={handleChange}
className={className}
/>
@@ -211,6 +212,7 @@ export const DateLikeInput = ({
aria-label={ariaLabel}
defaultValue={seedValue as CalendarDateTime | undefined}
granularity="second"
+ hourCycle={24}
onChange={handleChange}
className={className}
/>
@@ -316,6 +318,7 @@ export const DateLikeRangeInput = ({
| undefined
}
granularity="second"
+ hourCycle={24}
onChange={handleChange}
className={className}
/>
diff --git a/frontend/src/components/data-table/filter-by-values-picker.tsx b/frontend/src/components/data-table/filter-by-values-picker.tsx
index 25a7b9b4a2..44390ed8bd 100644
--- a/frontend/src/components/data-table/filter-by-values-picker.tsx
+++ b/frontend/src/components/data-table/filter-by-values-picker.tsx
@@ -7,7 +7,6 @@ import { useMemo, useState } from "react";
import { useAsyncData } from "@/hooks/useAsyncData";
import { ErrorBanner } from "@/plugins/impl/common/error-banner";
import type { CalculateTopKRows } from "@/plugins/impl/DataTablePlugin";
-import { cn } from "@/utils/cn";
import { Logger } from "@/utils/Logger";
import { Sets } from "@/utils/sets";
import { smartMatch } from "@/utils/smartMatch";
@@ -24,6 +23,7 @@ import {
import { Popover, PopoverContent, PopoverTrigger } from "../ui/popover";
import { SentinelCell } from "./sentinel-cell";
import { detectSentinel, stringifyUnknownValue } from "./utils";
+import { CompactChipRow } from "./value-chips";
const TOP_K_ROWS = 30;
@@ -42,19 +42,14 @@ export const FilterByValuesPicker = <TData, TValue>({
onChange,
creatable = false,
}: Props<TData, TValue>) => {
- const [open, setOpen] = useState(false);
+ const [open, setOpen] = useState(chosenValues.length === 0);
const chosenValuesSet = useMemo(() => new Set(chosenValues), [chosenValues]);
- const selectedValuesStr = useMemo(() => {
- if (chosenValuesSet.size === 0) {
- return "Select values…";
- }
- const items = [...chosenValuesSet].map((v) =>
- stringifyUnknownValue({ value: v }),
- );
- return `[${items.join(", ")}]`;
- }, [chosenValuesSet]);
+ const displayItems = useMemo(
+ () => [...chosenValuesSet].map((v) => stringifyUnknownValue({ value: v })),
+ [chosenValuesSet],
+ );
return (
<Popover open={open} onOpenChange={setOpen}>
@@ -65,14 +60,13 @@ export const FilterByValuesPicker = <TData, TValue>({
size="xs"
className="h-6 mb-1 w-full justify-between font-normal"
>
- <span
- className={cn(
- "truncate",
- chosenValuesSet.size === 0 && "text-muted-foreground",
- )}
- >
- {selectedValuesStr}
- </span>
+ {displayItems.length === 0 ? (
+ <span className="truncate text-muted-foreground">
+ Select values…
+ </span>
+ ) : (
+ <CompactChipRow items={displayItems} max={3} />
+ )}
<ChevronDownIcon className="h-4 w-4 opacity-50 shrink-0" />
</Button>
</PopoverTrigger>
diff --git a/frontend/src/components/data-table/filter-editor-context.tsx b/frontend/src/components/data-table/filter-editor-context.tsx
new file mode 100644
index 0000000000..6f805a594c
--- /dev/null
+++ b/frontend/src/components/data-table/filter-editor-context.tsx
@@ -0,0 +1,34 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+/**
+ * Lets descendants of `DataTable` (column headers, etc.) ask the table to open
+ * the filter pill editor for a given column. The table owns the pending
+ * snapshot state and renders the editor anchored under the pills strip's
+ * `+` button; consumers only fire intent via `requestAddFilter`.
+ *
+ * `useFilterEditor()` returns `null` outside a provider, which callers treat as
+ * "filter editor not available" and hide the corresponding menu items.
+ */
+
+import { createContext, useContext } from "react";
+import type { OperatorType } from "@/plugins/impl/data-frames/utils/operators";
+
+export interface AddFilterRequest {
+ columnId: string;
+ /** Pre-select an operator (e.g. `"in"` for "Filter by values"); defaults to the column dtype's default. */
+ operator?: OperatorType;
+}
+
+interface FilterEditorContextValue {
+ requestAddFilter: (request: AddFilterRequest) => void;
+}
+
+const FilterEditorContext = createContext<FilterEditorContextValue | null>(
+ null,
+);
+
+export const FilterEditorProvider = FilterEditorContext.Provider;
+
+export function useFilterEditor(): FilterEditorContextValue | null {
+ return useContext(FilterEditorContext);
+}
diff --git a/frontend/src/components/data-table/filter-pill-editor.tsx b/frontend/src/components/data-table/filter-pill-editor.tsx
index 86d2a87e7c..9e3942d777 100644
--- a/frontend/src/components/data-table/filter-pill-editor.tsx
+++ b/frontend/src/components/data-table/filter-pill-editor.tsx
@@ -6,6 +6,7 @@ import { CheckIcon, MinusIcon, Trash2Icon, XIcon } from "lucide-react";
import { useEffect, useId, useRef, useState } from "react";
import type { CalculateTopKRows } from "@/plugins/impl/DataTablePlugin";
import type { OperatorType } from "@/plugins/impl/data-frames/utils/operators";
+import { Button } from "../ui/button";
import { Combobox, ComboboxItem } from "../ui/combobox";
import { Input } from "../ui/input";
import { NumberField } from "../ui/number-field";
@@ -16,95 +17,98 @@ import {
SelectTrigger,
SelectValue,
} from "../ui/select";
-import { Button } from "../ui/button";
+import { Tooltip } from "../ui/tooltip";
import { DateLikeInput, DateLikeRangeInput } from "./date-filter-inputs";
import { FilterByValuesPicker } from "./filter-by-values-picker";
-import { RegexInput } from "./regex-input";
import {
type ColumnFilterValue,
- DATETIME_OPS,
+ columnEditableType,
+ DEFAULT_OPERATOR_FOR_TYPE,
+ defaultFilterValueFor,
+ EDITABLE_FILTER_TYPES,
Filter,
- isDatetimeComparisonOp,
- isNumberComparisonOp,
+ type FilterType,
+ isComparisonOp,
+ isDateLikeType,
isTextScalarOp,
- MEMBERSHIP_OPS,
- NUMBER_OPS,
- TEXT_OPS,
+ OPERATORS_BY_TYPE,
+ OPERATORS_WITHOUT_VALUE,
+ type Snapshot,
} from "./filters";
import { OPERATOR_LABELS } from "./operator-labels";
-import { Tooltip } from "../ui/tooltip";
-
-type EditableFilterType =
- | "number"
- | "text"
- | "boolean"
- | "select"
- | "date"
- | "datetime"
- | "time";
-
-type DateLikeEditableFilterType = Extract<
- EditableFilterType,
- "date" | "datetime" | "time"
->;
-
-const DATE_LIKE_TYPES: ReadonlySet<EditableFilterType> = new Set([
- "date",
- "datetime",
- "time",
-]);
-
-const isDateLikeType = (
- type: EditableFilterType,
-): type is DateLikeEditableFilterType => DATE_LIKE_TYPES.has(type);
-
-const BOOLEAN_OPS = ["is_true", "is_false", "is_null", "is_not_null"] as const;
-const SELECT_OPS = MEMBERSHIP_OPS;
-
-const OPERATORS_BY_TYPE: Record<
- EditableFilterType,
- ReadonlyArray<OperatorType>
-> = {
- number: NUMBER_OPS,
- text: TEXT_OPS,
- boolean: BOOLEAN_OPS,
- select: SELECT_OPS,
- date: DATETIME_OPS,
- datetime: DATETIME_OPS,
- time: DATETIME_OPS,
-};
-
-const DEFAULT_OPERATOR: Record<EditableFilterType, OperatorType> = {
- number: "between",
- text: "contains",
- boolean: "is_true",
- select: "in",
- date: "between",
- datetime: "between",
- time: "between",
-};
-
-const OPERATORS_WITHOUT_VALUE = new Set<OperatorType>([
- "is_true",
- "is_false",
- "is_null",
- "is_not_null",
- "is_empty",
-]);
+import { RegexInput } from "./regex-input";
type DraftValue =
| { kind: "between"; min?: number; max?: number }
| { kind: "single-number"; value?: number }
| { kind: "single-text"; text?: string }
- | { kind: "multi-text"; values?: string[] }
- | { kind: "options"; options?: unknown[] }
+ | { kind: "multi-values"; values?: unknown[] }
| { kind: "date-between"; min?: Date; max?: Date }
| { kind: "date-single"; value?: Date }
| { kind: "none" };
-interface Snapshot {
- columnId: string;
- value: ColumnFilterValue;
+interface NumberTextDraft {
+ min?: string;
+ max?: string;
+ value?: string;
+}
+
+const EMPTY_NUMBER_TEXT_DRAFT: NumberTextDraft = {};
+
+function parseDraftNumber(text: string | undefined): number | undefined {
+ if (text === undefined || text.trim() === "") {
+ return undefined;
+ }
+ const n = Number.parseFloat(text);
+ return Number.isFinite(n) ? n : undefined;
+}
+
+function mergeNumberTextDraft(
+ draft: DraftValue,
+ textDraft: NumberTextDraft,
+): DraftValue {
+ if (draft.kind === "between") {
+ return {
+ kind: "between",
+ min: parseDraftNumber(textDraft.min) ?? draft.min,
+ max: parseDraftNumber(textDraft.max) ?? draft.max,
+ };
+ }
+ if (draft.kind === "single-number") {
+ return {
+ kind: "single-number",
+ value: parseDraftNumber(textDraft.value) ?? draft.value,
+ };
+ }
+ return draft;
+}
+
+export function buildEmptyFilterValue(
+ column: Column<unknown, unknown>,
+): ColumnFilterValue {
+ const type = columnEditableType(column);
+ return defaultFilterValueFor(type, DEFAULT_OPERATOR_FOR_TYPE[type]);
+}
+
+export function buildEditorSnapshot(
+ column: Column<unknown, unknown>,
+ opts?: { operator?: OperatorType },
+): Snapshot {
+ const type = columnEditableType(column);
+ const operator = opts?.operator ?? DEFAULT_OPERATOR_FOR_TYPE[type];
+ return {
+ columnId: column.id,
+ value: defaultFilterValueFor(type, operator),
+ };
+}
+
+export function editableColumns<TData>(
+ table: Table<TData>,
+): Array<Column<TData, unknown>> {
+ return table.getAllColumns().filter((c) => {
+ const ft = c.columnDef.meta?.filterType;
+ return ft !== undefined && EDITABLE_FILTER_TYPES.has(ft);
+ });
}
interface FilterPillEditorProps<TData> {
@@ -112,6 +116,7 @@ interface FilterPillEditorProps<TData> {
table: Table<TData>;
calculateTopKRows?: CalculateTopKRows;
onClose: () => void;
+ editIndex?: number; // skip for creating new pill; when passed edits the pill at idx instead
}
export const FilterPillEditor = <TData,>({
@@ -119,33 +124,26 @@ export const FilterPillEditor = <TData,>({
table,
calculateTopKRows,
onClose,
+ editIndex,
}: FilterPillEditorProps<TData>) => {
const columnId = useId();
const operatorId = useId();
const valueId = useId();
- const snapshotType = getEditableType(snapshot.value);
+ const snapshotType: FilterType = snapshot.value.type;
const snapshotOperator = snapshot.value.operator as OperatorType;
const snapshotDraft = toDraftValue(snapshot.value);
const [draftColumnId, setDraftColumnId] = useState<string>(snapshot.columnId);
- const [draftType, setDraftType] = useState<EditableFilterType>(snapshotType);
+ const [draftType, setDraftType] = useState<FilterType>(snapshotType);
const [draftOperator, setDraftOperator] =
useState<OperatorType>(snapshotOperator);
const [draftValue, setDraftValue] = useState<DraftValue>(snapshotDraft);
+ const [numberTextDraft, setNumberTextDraft] = useState<NumberTextDraft>(
+ EMPTY_NUMBER_TEXT_DRAFT,
+ );
- const editableColumns = table.getAllColumns().filter((c) => {
- const ft = c.columnDef.meta?.filterType;
- return (
- ft === "number" ||
- ft === "text" ||
- ft === "boolean" ||
- ft === "select" ||
- ft === "date" ||
- ft === "datetime" ||
- ft === "time"
- );
- });
+ const columnOptions = editableColumns(table);
const rehydrateIfMatchesSnapshot = (args: {
id: string;
@@ -161,15 +159,18 @@ export const FilterPillEditor = <TData,>({
return;
}
const nextColumn = table.getColumn(nextColumnId);
- const nextColumnType = (nextColumn?.columnDef.meta?.filterType ??
- "text") as EditableFilterType;
+ if (!nextColumn) {
+ return;
+ }
+ const nextColumnType = columnEditableType(nextColumn);
let nextOperator = draftOperator;
if (nextColumnType !== draftType) {
- nextOperator = DEFAULT_OPERATOR[nextColumnType];
+ nextOperator = DEFAULT_OPERATOR_FOR_TYPE[nextColumnType];
setDraftType(nextColumnType);
setDraftOperator(nextOperator);
setDraftValue(emptyDraftFor(nextColumnType, nextOperator));
+ setNumberTextDraft(EMPTY_NUMBER_TEXT_DRAFT);
}
setDraftColumnId(nextColumnId);
rehydrateIfMatchesSnapshot({
@@ -184,6 +185,7 @@ export const FilterPillEditor = <TData,>({
if (nextEmpty.kind !== draftValue.kind) {
setDraftValue(nextEmpty);
}
+ setNumberTextDraft(EMPTY_NUMBER_TEXT_DRAFT);
rehydrateIfMatchesSnapshot({
id: draftColumnId,
operator: nextOp,
@@ -193,7 +195,7 @@ export const FilterPillEditor = <TData,>({
const pendingValue = buildFilterValue({
type: draftType,
operator: draftOperator,
- draft: draftValue,
+ draft: mergeNumberTextDraft(draftValue, numberTextDraft),
});
const applyDisabled = pendingValue === undefined;
const applyTooltip = applyDisabled
@@ -206,17 +208,23 @@ export const FilterPillEditor = <TData,>({
}
const value = pendingValue;
table.setColumnFilters((filters) => {
- const dropIds = new Set([snapshot.columnId, draftColumnId]);
- const filtered = filters.filter((f) => !dropIds.has(f.id));
- return [...filtered, { id: draftColumnId, value }];
+ // assume new filter pill is being created
+ if (editIndex === undefined) {
+ return [{ id: draftColumnId, value }, ...filters];
+ }
+ const next = [...filters];
+ next[editIndex] = { id: draftColumnId, value };
+ return next;
});
onClose();
};
const handleClear = () => {
- table.setColumnFilters((filters) =>
- filters.filter((f) => f.id !== snapshot.columnId),
- );
+ if (editIndex !== undefined) {
+ table.setColumnFilters((filters) =>
+ filters.filter((_, i) => i !== editIndex),
+ );
+ }
onClose();
};
@@ -261,7 +269,7 @@ export const FilterPillEditor = <TData,>({
placeholder="Select column…"
displayValue={(id) => id}
>
- {editableColumns.map((c) => (
+ {columnOptions.map((c) => (
<ComboboxItem key={c.id} value={c.id}>
{c.id}
</ComboboxItem>
@@ -304,6 +312,9 @@ export const FilterPillEditor = <TData,>({
operator={draftOperator}
value={draftValue}
onChange={setDraftValue}
+ onNumberTextChange={(field, text) =>
+ setNumberTextDraft((prev) => ({ ...prev, [field]: text }))
+ }
column={table.getColumn(draftColumnId) ?? null}
calculateTopKRows={calculateTopKRows}
/>
@@ -355,10 +366,11 @@ export const FilterPillEditor = <TData,>({
interface ValueSlotProps<TData, TValue> {
id?: string;
- type: EditableFilterType;
+ type: FilterType;
operator: OperatorType;
value: DraftValue;
onChange: (next: DraftValue) => void;
+ onNumberTextChange: (field: "min" | "max" | "value", text: string) => void;
column: Column<TData, TValue> | null;
calculateTopKRows?: CalculateTopKRows;
}
@@ -369,6 +381,7 @@ const ValueSlot = <TData, TValue>({
operator,
value,
onChange,
+ onNumberTextChange,
column,
calculateTopKRows,
}: ValueSlotProps<TData, TValue>) => {
@@ -380,6 +393,7 @@ const ValueSlot = <TData, TValue>({
id={id}
value={v.min}
onChange={(n) => onChange({ kind: "between", min: n, max: v.max })}
+ onInputText={(t) => onNumberTextChange("min", t)}
aria-label="min"
placeholder="min"
className="border-input flex-1 min-w-0"
@@ -388,6 +402,7 @@ const ValueSlot = <TData, TValue>({
<NumberField
value={v.max}
onChange={(n) => onChange({ kind: "between", min: v.min, max: n })}
+ onInputText={(t) => onNumberTextChange("max", t)}
aria-label="max"
placeholder="max"
className="border-input flex-1 min-w-0"
@@ -395,7 +410,7 @@ const ValueSlot = <TData, TValue>({
</div>
);
}
- if (type === "number" && isNumberComparisonOp(operator)) {
+ if (type === "number" && isComparisonOp(operator)) {
const v =
value.kind === "single-number"
? value
@@ -405,6 +420,7 @@ const ValueSlot = <TData, TValue>({
id={id}
value={v.value}
onChange={(n) => onChange({ kind: "single-number", value: n })}
+ onInputText={(t) => onNumberTextChange("value", t)}
aria-label="value"
placeholder="value"
className="border-input w-24 min-w-0"
@@ -412,22 +428,20 @@ const ValueSlot = <TData, TValue>({
);
}
if (
- type === "text" &&
+ (type === "text" || type === "number") &&
(operator === "in" || operator === "not_in") &&
column
) {
const v =
- value.kind === "multi-text" ? value : { kind: "multi-text" as const };
+ value.kind === "multi-values" ? value : { kind: "multi-values" as const };
return (
- <div className="w-48">
+ <div className="min-w-[14rem] w-fit max-w-[24rem]">
<FilterByValuesPicker
column={column}
calculateTopKRows={calculateTopKRows}
chosenValues={v.values ?? []}
- onChange={(next) =>
- onChange({ kind: "multi-text", values: next.map(String) })
- }
- creatable={true}
+ onChange={(next) => onChange({ kind: "multi-values", values: next })}
+ creatable={type === "text"}
/>
</div>
);
@@ -474,7 +488,7 @@ const ValueSlot = <TData, TValue>({
/>
);
}
- if (isDateLikeType(type) && isDatetimeComparisonOp(operator)) {
+ if (isDateLikeType(type) && isComparisonOp(operator)) {
const v =
value.kind === "date-single" ? value : { kind: "date-single" as const };
return (
@@ -488,42 +502,17 @@ const ValueSlot = <TData, TValue>({
/>
);
}
- if (type === "select" && column) {
- const v = value.kind === "options" ? value : { kind: "options" as const };
- return (
- <div className="flex w-48">
- <FilterByValuesPicker
- column={column}
- calculateTopKRows={calculateTopKRows}
- chosenValues={v.options ?? []}
- onChange={(values) => onChange({ kind: "options", options: values })}
- />
- </div>
- );
- }
return null;
};
-function getEditableType(value: ColumnFilterValue): EditableFilterType {
- switch (value.type) {
- case "number":
- case "text":
- case "boolean":
- case "select":
- case "date":
- case "datetime":
- case "time":
- return value.type;
- default:
- return "text";
- }
-}
-
function toDraftValue(value: ColumnFilterValue): DraftValue {
if (value.type === "number") {
switch (value.operator) {
case "between":
return { kind: "between", min: value.min, max: value.max };
+ case "in":
+ case "not_in":
+ return { kind: "multi-values", values: [...value.values] };
case "is_null":
case "is_not_null":
return { kind: "none" };
@@ -535,7 +524,7 @@ function toDraftValue(value: ColumnFilterValue): DraftValue {
switch (value.operator) {
case "in":
case "not_in":
- return { kind: "multi-text", values: [...value.values] };
+ return { kind: "multi-values", values: [...value.values] };
case "is_null":
case "is_not_null":
case "is_empty":
@@ -544,9 +533,6 @@ function toDraftValue(value: ColumnFilterValue): DraftValue {
return { kind: "single-text", text: value.text };
}
}
- if (value.type === "select") {
- return { kind: "options", options: [...value.options] };
- }
if (
value.type === "date" ||
value.type === "datetime" ||
@@ -565,25 +551,20 @@ function toDraftValue(value: ColumnFilterValue): DraftValue {
return { kind: "none" };
}
-function emptyDraftFor(
- type: EditableFilterType,
- operator: OperatorType,
-): DraftValue {
+function emptyDraftFor(type: FilterType, operator: OperatorType): DraftValue {
if (OPERATORS_WITHOUT_VALUE.has(operator)) {
return { kind: "none" };
}
+ if (operator === "in" || operator === "not_in") {
+ return { kind: "multi-values", values: [] };
+ }
if (type === "number") {
return operator === "between"
? { kind: "between" }
: { kind: "single-number" };
}
if (type === "text") {
- return operator === "in" || operator === "not_in"
- ? { kind: "multi-text", values: [] }
- : { kind: "single-text" };
- }
- if (type === "select") {
- return { kind: "options", options: [] };
+ return { kind: "single-text" };
}
if (isDateLikeType(type)) {
return operator === "between"
@@ -594,13 +575,13 @@ function emptyDraftFor(
}
function getMissingValueMessage(
- type: EditableFilterType,
+ _type: FilterType,
operator: OperatorType,
): string {
if (operator === "between") {
return "Min and max are required";
}
- if (type === "text" && (operator === "in" || operator === "not_in")) {
+ if (operator === "in" || operator === "not_in") {
return "Pick at least one value";
}
return "Value is required";
@@ -611,7 +592,7 @@ function buildFilterValue({
operator,
draft,
}: {
- type: EditableFilterType;
+ type: FilterType;
operator: OperatorType;
draft: DraftValue;
}): ColumnFilterValue | undefined {
@@ -633,7 +614,17 @@ function buildFilterValue({
max: draft.max,
});
}
- if (!isNumberComparisonOp(operator)) {
+ if (operator === "in" || operator === "not_in") {
+ if (
+ draft.kind !== "multi-values" ||
+ !draft.values ||
+ draft.values.length === 0
+ ) {
+ return undefined;
+ }
+ return Filter.number({ operator, values: draft.values });
+ }
+ if (!isComparisonOp(operator)) {
return undefined;
}
if (draft.kind !== "single-number" || draft.value === undefined) {
@@ -651,7 +642,7 @@ function buildFilterValue({
}
if (operator === "in" || operator === "not_in") {
if (
- draft.kind !== "multi-text" ||
+ draft.kind !== "multi-values" ||
!draft.values ||
draft.values.length === 0
) {
@@ -668,29 +659,15 @@ function buildFilterValue({
return Filter.text({ operator, text: draft.text });
}
if (type === "boolean") {
- if (operator === "is_true") {
- return Filter.boolean({ value: true, operator: "is_true" });
- }
- if (operator === "is_false") {
- return Filter.boolean({ value: false, operator: "is_false" });
- }
- if (operator === "is_null" || operator === "is_not_null") {
- return Filter.boolean({ operator });
- }
- return undefined;
- }
- if (type === "select") {
if (
- draft.kind !== "options" ||
- !draft.options ||
- draft.options.length === 0
+ operator === "is_true" ||
+ operator === "is_false" ||
+ operator === "is_null" ||
+ operator === "is_not_null"
) {
- return undefined;
+ return Filter.boolean({ operator });
}
- return Filter.select({
- options: draft.options,
- operator: operator === "not_in" ? "not_in" : "in",
- });
+ return undefined;
}
if (isDateLikeType(type)) {
const factory =
@@ -712,7 +689,7 @@ function buildFilterValue({
}
return factory({ operator: "between", min: draft.min, max: draft.max });
}
- if (!isDatetimeComparisonOp(operator)) {
+ if (!isComparisonOp(operator)) {
return undefined;
}
if (draft.kind !== "date-single" || draft.value === undefined) {
diff --git a/frontend/src/components/data-table/filter-pills.tsx b/frontend/src/components/data-table/filter-pills.tsx
index 8e0b9486b4..487a7b8e5f 100644
--- a/frontend/src/components/data-table/filter-pills.tsx
+++ b/frontend/src/components/data-table/filter-pills.tsx
@@ -2,62 +2,154 @@
"use no memo";
import type { ColumnFiltersState, Table } from "@tanstack/react-table";
-import { XIcon } from "lucide-react";
-import { useState } from "react";
-import { type DateFormatter, useDateFormatter } from "react-aria";
+import { MoreHorizontalIcon, XIcon } from "lucide-react";
+import { useLayoutEffect, useRef, useState } from "react";
+import { useLocale } from "react-aria";
import type { CalculateTopKRows } from "@/plugins/impl/DataTablePlugin";
-import { logNever } from "@/utils/assertNever";
import { cn } from "@/utils/cn";
import { Badge } from "../ui/badge";
import { Button } from "../ui/button";
-import { Popover, PopoverContent, PopoverTrigger } from "../ui/popover";
-import { FilterPillEditor } from "./filter-pill-editor";
+import { DraggablePopover } from "../ui/draggable-popover";
import {
- type ColumnFilterValue,
- dateToISODate,
- dateToISODateTime,
-} from "./filters";
-import { OPERATOR_LABELS } from "./operator-labels";
-import { stringifyUnknownValue } from "./utils";
+ Popover,
+ PopoverClose,
+ PopoverContent,
+ PopoverTrigger,
+} from "../ui/popover";
+import { Tooltip } from "../ui/tooltip";
+import { AddFilterButton } from "./add-filter-button";
+import { FilterPillEditor } from "./filter-pill-editor";
+import { type ColumnFilterValue, formatValue, type Snapshot } from "./filters";
+import { extractTimezone } from "./types";
+import { ChipWithComma, CompactChipRow } from "./value-chips";
interface Props<TData> {
filters: ColumnFiltersState | undefined;
table: Table<TData>;
calculateTopKRows?: CalculateTopKRows;
+ addFilterSnapshot: Snapshot | null;
+ onAddFilterSnapshotChange: (snapshot: Snapshot | null) => void;
}
+const useHasOverflow = (
+ ref: React.RefObject<HTMLElement | null>,
+ signature: string,
+): boolean => {
+ const [hasOverflow, setHasOverflow] = useState(false);
+ useLayoutEffect(() => {
+ const el = ref.current;
+ if (!el) {
+ return;
+ }
+ const measure = () => setHasOverflow(el.scrollWidth > el.clientWidth);
+ measure();
+ const ro = new ResizeObserver(measure);
+ ro.observe(el);
+ return () => ro.disconnect();
+ // biome-ignore lint/correctness/useExhaustiveDependencies: signature triggers re-measure on filter content change
+ }, [ref, signature]);
+ return hasOverflow;
+};
+
export const FilterPills = <TData,>({
filters,
table,
calculateTopKRows,
+ addFilterSnapshot,
+ onAddFilterSnapshotChange,
}: Props<TData>) => {
- const timeFormatter = useDateFormatter({
- hour: "2-digit",
- minute: "2-digit",
- second: "2-digit",
- });
+ const { locale } = useLocale();
+
+ const containerRef = useRef<HTMLDivElement | null>(null);
+ const [overflowOpen, setOverflowOpen] = useState(false);
+ const allFilters = filters ?? [];
+ const signature = allFilters
+ .map((f) => `${f.id}:${JSON.stringify(f.value)}`)
+ .join("|");
+ const hasOverflow = useHasOverflow(containerRef, signature);
- if (!filters || filters.length === 0) {
+ if (allFilters.length === 0 && addFilterSnapshot === null) {
return null;
}
+ const renderPill = (filter: ColumnFiltersState[number], index: number) => (
+ <FilterPill
+ key={`${filter.id}:${index}`}
+ columnId={filter.id}
+ value={filter.value as ColumnFilterValue}
+ index={index}
+ locale={locale}
+ table={table}
+ calculateTopKRows={calculateTopKRows}
+ onRemove={() =>
+ table.setColumnFilters((current) =>
+ current.filter((_, i) => i !== index),
+ )
+ }
+ />
+ );
+
return (
- <div part="filter-pills" className="flex flex-wrap gap-2 px-1 py-2">
- {filters.map((filter) => (
- <FilterPill
- key={filter.id}
- columnId={filter.id}
- value={filter.value as ColumnFilterValue}
- timeFormatter={timeFormatter}
- table={table}
- calculateTopKRows={calculateTopKRows}
- onRemove={() =>
- table.setColumnFilters((filters) =>
- filters.filter((f) => f.id !== filter.id),
- )
- }
- />
- ))}
+ <div
+ part="filter-pills"
+ className="relative flex items-center gap-2 px-1 py-2"
+ >
+ <AddFilterButton
+ table={table}
+ calculateTopKRows={calculateTopKRows}
+ snapshot={addFilterSnapshot}
+ onSnapshotChange={onAddFilterSnapshotChange}
+ />
+ <div
+ ref={containerRef}
+ className={cn(
+ "flex flex-nowrap items-center gap-2 overflow-hidden min-w-0 flex-1",
+ hasOverflow &&
+ "mask-[linear-gradient(to_right,black_calc(100%-2rem),transparent)]",
+ )}
+ >
+ {allFilters.map((filter, index) => renderPill(filter, index))}
+ </div>
+ {hasOverflow && (
+ <button
+ type="button"
+ onClick={() => setOverflowOpen(true)}
+ className="shrink-0 inline-flex items-center gap-0.5 rounded-full border border-border bg-background px-2 py-0.5 text-xs text-foreground hover:bg-accent hover:text-accent-foreground"
+ aria-label="See all filters"
+ >
+ <MoreHorizontalIcon className="h-3.5 w-3.5" aria-hidden={true} />
+ <span>See all</span>
+ </button>
+ )}
+ {hasOverflow && (
+ <DraggablePopover
+ open={overflowOpen}
+ onOpenChange={setOverflowOpen}
+ className="w-fit max-w-[min(90vw,40rem)] p-0"
+ >
+ <PopoverClose className="absolute top-2 right-2" aria-label="Close">
+ <XIcon className="h-4 w-4" aria-hidden={true} />
+ </PopoverClose>
+ <div className="flex flex-col pt-7">
+ <div className="max-h-80 overflow-y-auto flex flex-col items-start gap-2 px-3 pb-2">
+ {allFilters.map((filter, index) => renderPill(filter, index))}
+ </div>
+ <div className="flex justify-end border-t border-border px-3 py-2">
+ <Button
+ type="button"
+ size="sm"
+ variant="ghost"
+ onClick={() => {
+ table.setColumnFilters([]);
+ setOverflowOpen(false);
+ }}
+ >
+ Clear all
+ </Button>
+ </div>
+ </div>
+ </DraggablePopover>
+ )}
</div>
);
};
@@ -65,7 +157,8 @@ export const FilterPills = <TData,>({
interface FilterPillProps<TData> {
columnId: string;
value: ColumnFilterValue;
- timeFormatter: DateFormatter;
+ index: number;
+ locale: string;
table: Table<TData>;
calculateTopKRows?: CalculateTopKRows;
onRemove: () => void;
@@ -74,28 +167,63 @@ interface FilterPillProps<TData> {
const FilterPill = <TData,>({
columnId,
value,
- timeFormatter,
+ index,
+ locale,
table,
calculateTopKRows,
onRemove,
}: FilterPillProps<TData>) => {
const [open, setOpen] = useState(false);
- const formatted = formatValue(value, timeFormatter);
+ const timezone = extractTimezone(
+ table.getColumn(columnId)?.columnDef.meta?.dtype,
+ );
+ const formatted = formatValue(value, { locale, timezone });
if (!formatted) {
return null;
}
- const twoSegment = formatted.value === undefined;
+ const twoSegment =
+ formatted.kind === "scalar" && formatted.value === undefined;
const handleRemove = (e: React.MouseEvent) => {
e.stopPropagation();
onRemove();
};
- const segments = (
+ const renderValue = (truncateValue: boolean) => {
+ if (formatted.kind === "scalar") {
+ return (
+ <span
+ className={cn(
+ "font-semibold text-foreground",
+ truncateValue &&
+ "inline-block max-w-[24ch] overflow-hidden text-ellipsis whitespace-nowrap align-middle",
+ )}
+ >
+ {formatted.value}
+ </span>
+ );
+ }
+ if (truncateValue) {
+ return <CompactChipRow items={formatted.items} max={3} />;
+ }
+ return (
+ <span className="grid grid-cols-[repeat(5,max-content)] gap-1">
+ {formatted.items.map((item, i) => (
+ <ChipWithComma
+ key={i}
+ value={item}
+ showComma={i < formatted.items.length - 1}
+ />
+ ))}
+ </span>
+ );
+ };
+
+ const renderSegments = (truncateValue: boolean) => (
<>
- <span className="text-foreground">{columnId}</span>
+ <span className="font-semibold text-foreground">{columnId}</span>
<Separator />
<span
className={cn(
@@ -108,12 +236,17 @@ const FilterPill = <TData,>({
{!twoSegment && (
<>
<Separator />
- <span className="text-foreground">{formatted.value}</span>
+ {renderValue(truncateValue)}
</>
)}
</>
);
+ const tooltip = (
+ <span className="inline-flex items-center">{renderSegments(false)}</span>
+ );
+ const segments = renderSegments(true);
+
const removeButton = (
<Button
type="button"
@@ -138,16 +271,20 @@ const FilterPill = <TData,>({
"transition-colors",
)}
>
- <PopoverTrigger asChild={true}>
- <button
- type="button"
- className="inline-flex items-center cursor-pointer bg-transparent border-0 p-0 [font:inherit] text-inherit"
- aria-label={`Edit filter on ${columnId}`}
- >
- {segments}
- </button>
- </PopoverTrigger>
- {removeButton}
+ <Tooltip content={tooltip} delayDuration={600}>
+ <span className="inline-flex items-center">
+ <PopoverTrigger asChild={true}>
+ <button
+ type="button"
+ className="inline-flex items-center whitespace-nowrap cursor-pointer bg-transparent border-0 p-0 [font:inherit] text-inherit"
+ aria-label={`Edit filter on ${columnId}`}
+ >
+ {segments}
+ </button>
+ </PopoverTrigger>
+ {removeButton}
+ </span>
+ </Tooltip>
</Badge>
<PopoverContent
className="w-auto p-0"
@@ -156,9 +293,11 @@ const FilterPill = <TData,>({
sideOffset={10}
avoidCollisions={true}
onOpenAutoFocus={(e) => e.preventDefault()}
+ onCloseAutoFocus={(e) => e.preventDefault()}
>
<FilterPillEditor
snapshot={{ columnId, value }}
+ editIndex={index}
table={table}
calculateTopKRows={calculateTopKRows}
onClose={() => setOpen(false)}
@@ -173,105 +312,3 @@ function Separator() {
<span aria-hidden={true} className="mx-1.5 w-px h-3 bg-foreground/30" />
);
}
-
-interface FormattedFilter {
- operator: string;
- value?: string;
-}
-
-function formatValue(
- value: ColumnFilterValue,
- timeFormatter: DateFormatter,
-): FormattedFilter | undefined {
- if (!("type" in value)) {
- return;
- }
-
- if (value.operator === "is_null") {
- return { operator: "is null" };
- }
- if (value.operator === "is_not_null") {
- return { operator: "is not null" };
- }
-
- if (value.type === "number") {
- switch (value.operator) {
- case "between":
- return {
- operator: OPERATOR_LABELS.between.toLowerCase(),
- value: `${value.min} - ${value.max}`,
- };
- case "==":
- case "!=":
- case ">":
- case ">=":
- case "<":
- case "<=":
- return { operator: value.operator, value: String(value.value) };
- }
- }
- if (value.type === "text") {
- switch (value.operator) {
- case "in":
- case "not_in": {
- const items = value.values.map((v) => `"${v}"`);
- return {
- operator: value.operator === "in" ? "is in" : "not in",
- value: `[${items.join(", ")}]`,
- };
- }
- case "is_empty":
- return { operator: "is empty" };
- case "contains":
- case "equals":
- case "does_not_equal":
- case "regex":
- case "starts_with":
- case "ends_with":
- return {
- operator: OPERATOR_LABELS[value.operator].toLowerCase(),
- value: `"${value.text}"`,
- };
- }
- }
- if (
- value.type === "date" ||
- value.type === "datetime" ||
- value.type === "time"
- ) {
- const format =
- value.type === "time"
- ? (d: Date) => timeFormatter.format(d)
- : value.type === "date"
- ? dateToISODate
- : dateToISODateTime;
- switch (value.operator) {
- case "between":
- return {
- operator: OPERATOR_LABELS.between.toLowerCase(),
- value: `${format(value.min)} - ${format(value.max)}`,
- };
- case "==":
- case "!=":
- case ">":
- case ">=":
- case "<":
- case "<=":
- return { operator: value.operator, value: format(value.value) };
- }
- }
- if (value.type === "boolean") {
- return { operator: `is ${value.value ? "True" : "False"}` };
- }
- if (value.type === "select") {
- const stringifiedOptions = value.options.map((o) =>
- stringifyUnknownValue({ value: o }),
- );
- return {
- operator: value.operator === "in" ? "is in" : "not in",
- value: `[${stringifiedOptions.join(", ")}]`,
- };
- }
- logNever(value);
- return undefined;
-}
diff --git a/frontend/src/components/data-table/filters.ts b/frontend/src/components/data-table/filters.ts
deleted file mode 100644
index 06f78d2c6d..0000000000
--- a/frontend/src/components/data-table/filters.ts
+++ /dev/null
@@ -1,386 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-"use no memo";
-
-import type { ColumnFiltersState, RowData } from "@tanstack/react-table";
-import type { DataType } from "@/core/kernel/messages";
-import type {
- FilterConditionType,
- FilterGroupType,
-} from "@/plugins/impl/data-frames/schema";
-import type { ColumnId } from "@/plugins/impl/data-frames/types";
-import type { OperatorType } from "@/plugins/impl/data-frames/utils/operators";
-import { assertNever } from "@/utils/assertNever";
-import { Logger } from "@/utils/Logger";
-
-declare module "@tanstack/react-table" {
- //allows us to define custom properties for our columns
- interface ColumnMeta<TData extends RowData, TValue> {
- rowHeader?: boolean;
- dtype?: string;
- dataType?: DataType;
- filterType?: FilterType;
- minFractionDigits?: number;
- }
-}
-
-export type FilterType =
- | "text"
- | "number"
- | "date"
- | "datetime"
- | "time"
- | "select"
- | "boolean";
-
-export const NULLISH_OPS = ["is_null", "is_not_null"] as const;
-export const MEMBERSHIP_OPS = ["in", "not_in"] as const;
-export const NUMBER_COMPARISON_OPS = [
- "==",
- "!=",
- ">",
- ">=",
- "<",
- "<=",
-] as const;
-export const TEXT_SCALAR_OPS = [
- "contains",
- "equals",
- "does_not_equal",
- "regex",
- "starts_with",
- "ends_with",
-] as const;
-
-export const DATETIME_COMPARISON_OPS = [
- "==",
- "!=",
- ">",
- ">=",
- "<",
- "<=",
-] as const;
-
-export const NUMBER_OPS = [
- "between",
- ...NUMBER_COMPARISON_OPS,
- ...NULLISH_OPS,
-] as const;
-export const TEXT_OPS = [
- ...TEXT_SCALAR_OPS,
- ...MEMBERSHIP_OPS,
- "is_empty",
- ...NULLISH_OPS,
-] as const;
-export const DATETIME_OPS = [
- "between",
- ...DATETIME_COMPARISON_OPS,
- ...NULLISH_OPS,
-] as const;
-
-export type NullishOp = (typeof NULLISH_OPS)[number];
-export type MembershipOp = (typeof MEMBERSHIP_OPS)[number];
-export type NumberComparisonOp = (typeof NUMBER_COMPARISON_OPS)[number];
-export type TextScalarOp = (typeof TEXT_SCALAR_OPS)[number];
-export type DatetimeComparisonOp = (typeof DATETIME_COMPARISON_OPS)[number];
-
-const makeOpGuard = <T extends OperatorType>(ops: readonly T[]) => {
- const set = new Set<OperatorType>(ops);
- return (op: OperatorType): op is T => set.has(op);
-};
-
-export const isNumberComparisonOp = makeOpGuard(NUMBER_COMPARISON_OPS);
-export const isTextScalarOp = makeOpGuard(TEXT_SCALAR_OPS);
-export const isDatetimeComparisonOp = makeOpGuard(DATETIME_COMPARISON_OPS);
-
-interface NullishOpts {
- operator: NullishOp;
-}
-
-type NumberFilterOpts =
- | { operator: "between"; min: number; max: number }
- | { operator: NumberComparisonOp; value: number }
- | NullishOpts;
-
-type TextFilterOpts =
- | { operator: TextScalarOp; text: string }
- | { operator: MembershipOp; values: string[] }
- | { operator: "is_empty" }
- | NullishOpts;
-
-type DateLikeFilterOpts =
- | { operator: "between"; min: Date; max: Date }
- | { operator: DatetimeComparisonOp; value: Date }
- | NullishOpts;
-
-// Filter is a factory function that creates a filter object
-export const Filter = {
- number(opts: NumberFilterOpts) {
- return {
- type: "number",
- ...opts,
- } as const;
- },
- text(opts: TextFilterOpts) {
- return {
- type: "text",
- ...opts,
- } as const;
- },
- date(opts: DateLikeFilterOpts) {
- return {
- type: "date",
- ...opts,
- } as const;
- },
- datetime(opts: DateLikeFilterOpts) {
- return {
- type: "datetime",
- ...opts,
- } as const;
- },
- time(opts: DateLikeFilterOpts) {
- return {
- type: "time",
- ...opts,
- } as const;
- },
- boolean(opts: { value?: boolean; operator?: OperatorType }) {
- return {
- type: "boolean",
- ...opts,
- } as const;
- },
- select(opts: { options: unknown[]; operator: OperatorType }) {
- return {
- type: "select",
- ...opts,
- } as const;
- },
-};
-export type ColumnFilterValue = ReturnType<
- (typeof Filter)[keyof typeof Filter]
->;
-export type ColumnFilterForType<T extends FilterType> = T extends FilterType
- ? Extract<ColumnFilterValue, { type: T }>
- : never;
-
-function pad2(n: number): string {
- return n.toString().padStart(2, "0");
-}
-
-function pad4(n: number): string {
- return n.toString().padStart(4, "0");
-}
-
-export function dateToISODate(d: Date): string {
- return `${pad4(d.getFullYear())}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
-}
-
-export function dateToISOTime(d: Date): string {
- return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
-}
-
-export function dateToISODateTime(d: Date): string {
- return `${dateToISODate(d)}T${dateToISOTime(d)}`;
-}
-
-function isNullishFilter(
- filter: ColumnFilterValue,
-): filter is Extract<
- ColumnFilterValue,
- { operator: "is_null" | "is_not_null" }
-> {
- return filter.operator === "is_null" || filter.operator === "is_not_null";
-}
-
-export function filterToFilterCondition(
- columnIdString: string,
- filter: ColumnFilterValue | undefined,
-): FilterConditionType[] {
- if (!filter) {
- return [];
- }
- const columnId = columnIdString as ColumnId;
-
- if (isNullishFilter(filter)) {
- return [
- {
- column_id: columnId,
- operator: filter.operator,
- type: "condition",
- negate: false,
- },
- ];
- }
-
- switch (filter.type) {
- case "number":
- switch (filter.operator) {
- case "between":
- return [
- {
- column_id: columnId,
- operator: "between",
- value: { min: filter.min, max: filter.max },
- type: "condition",
- negate: false,
- },
- ];
- case "==":
- case "!=":
- case ">":
- case ">=":
- case "<":
- case "<=":
- return [
- {
- column_id: columnId,
- operator: filter.operator,
- value: filter.value,
- type: "condition",
- negate: false,
- },
- ];
- default:
- assertNever(filter);
- }
- case "text":
- switch (filter.operator) {
- case "contains":
- case "equals":
- case "does_not_equal":
- case "regex":
- case "starts_with":
- case "ends_with":
- return [
- {
- column_id: columnId,
- operator: filter.operator,
- value: filter.text,
- type: "condition",
- negate: false,
- },
- ];
- case "in":
- case "not_in":
- return [
- {
- column_id: columnId,
- operator: filter.operator,
- value: filter.values,
- type: "condition",
- negate: false,
- },
- ];
- case "is_empty":
- return [
- {
- column_id: columnId,
- operator: "is_empty",
- type: "condition",
- negate: false,
- },
- ];
- default:
- assertNever(filter);
- }
- case "date":
- case "datetime":
- case "time": {
- const encode =
- filter.type === "date"
- ? dateToISODate
- : filter.type === "time"
- ? dateToISOTime
- : dateToISODateTime;
- switch (filter.operator) {
- case "between":
- return [
- {
- column_id: columnId,
- operator: "between",
- value: { min: encode(filter.min), max: encode(filter.max) },
- type: "condition",
- negate: false,
- },
- ];
- case "==":
- case "!=":
- case ">":
- case ">=":
- case "<":
- case "<=":
- return [
- {
- column_id: columnId,
- operator: filter.operator,
- value: encode(filter.value),
- type: "condition",
- negate: false,
- },
- ];
- default:
- assertNever(filter);
- }
- }
- case "boolean":
- if (filter.value) {
- return [
- {
- column_id: columnId,
- operator: "is_true",
- type: "condition",
- negate: false,
- },
- ];
- }
- if (!filter.value) {
- return [
- {
- column_id: columnId,
- operator: "is_false",
- type: "condition",
- negate: false,
- },
- ];
- }
-
- return [];
- case "select": {
- let operator = filter.operator;
- if (filter.operator !== "in" && filter.operator !== "not_in") {
- Logger.warn("Invalid operator for select filter", {
- operator: filter.operator,
- });
- operator = "in";
- }
- return [
- {
- column_id: columnId,
- operator,
- value: filter.options,
- type: "condition",
- negate: false,
- },
- ];
- }
-
- default:
- assertNever(filter);
- }
-}
-
-export function filtersToFilterGroup(
- columnFilters: ColumnFiltersState,
-): FilterGroupType {
- const conditions = columnFilters.flatMap((filter) =>
- filterToFilterCondition(filter.id, filter.value as ColumnFilterValue),
- );
- // To maintain existing behavior "and" all the conditions
- return {
- type: "group",
- operator: "and",
- children: conditions,
- negate: false,
- };
-}
diff --git a/frontend/src/components/data-table/filters/builders.ts b/frontend/src/components/data-table/filters/builders.ts
new file mode 100644
index 0000000000..c26814c2ab
--- /dev/null
+++ b/frontend/src/components/data-table/filters/builders.ts
@@ -0,0 +1,102 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type {
+ BooleanOp,
+ ComparisonOp,
+ MembershipOp,
+ NullishOp,
+ TextScalarOp,
+} from "./operators";
+import type { FilterType } from "./types";
+
+interface NullishOpts {
+ operator: NullishOp;
+}
+
+interface MembershipOpts {
+ operator: MembershipOp;
+ values: unknown[];
+}
+
+interface BetweenRangeOpts<T> {
+ operator: "between";
+ min: T;
+ max: T;
+}
+
+type NumberFilterOpts =
+ | { operator: ComparisonOp; value: number }
+ | BetweenRangeOpts<number>
+ | MembershipOpts
+ | NullishOpts;
+
+type TextFilterOpts =
+ | { operator: TextScalarOp; text: string }
+ | { operator: "is_empty" }
+ | MembershipOpts
+ | NullishOpts;
+
+type DateLikeFilterOpts =
+ | { operator: ComparisonOp; value: Date }
+ | BetweenRangeOpts<Date>
+ | NullishOpts;
+
+interface BooleanFilterOpts {
+ operator: BooleanOp;
+}
+
+// Filter is a factory function that creates a filter object
+export const Filter = {
+ number(opts: NumberFilterOpts) {
+ return {
+ type: "number",
+ ...opts,
+ } as const;
+ },
+ text(opts: TextFilterOpts) {
+ return {
+ type: "text",
+ ...opts,
+ } as const;
+ },
+ date(opts: DateLikeFilterOpts) {
+ return {
+ type: "date",
+ ...opts,
+ } as const;
+ },
+ datetime(opts: DateLikeFilterOpts) {
+ return {
+ type: "datetime",
+ ...opts,
+ } as const;
+ },
+ time(opts: DateLikeFilterOpts) {
+ return {
+ type: "time",
+ ...opts,
+ } as const;
+ },
+ boolean(opts: BooleanFilterOpts) {
+ return {
+ type: "boolean",
+ ...opts,
+ } as const;
+ },
+};
+
+export type ColumnFilterValue = ReturnType<
+ (typeof Filter)[keyof typeof Filter]
+>;
+export type ColumnFilterForType<T extends FilterType> = T extends FilterType
+ ? Extract<ColumnFilterValue, { type: T }>
+ : never;
+export type MembershipFilterType = Extract<
+ ColumnFilterValue,
+ { operator: "in" | "not_in" }
+>["type"];
+
+export interface Snapshot {
+ columnId: string;
+ value: ColumnFilterValue;
+}
diff --git a/frontend/src/components/data-table/filters/defaults.ts b/frontend/src/components/data-table/filters/defaults.ts
new file mode 100644
index 0000000000..f5b98b9e14
--- /dev/null
+++ b/frontend/src/components/data-table/filters/defaults.ts
@@ -0,0 +1,31 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+"use no memo";
+
+import type { Column } from "@tanstack/react-table";
+import type { OperatorType } from "@/plugins/impl/data-frames/utils/operators";
+import type { ColumnFilterValue } from "./builders";
+import { isMembershipFilterType, isMembershipOp } from "./guards";
+import { EDITABLE_FILTER_TYPES, type FilterType } from "./types";
+
+export function columnEditableType<TData, TValue>(
+ column: Column<TData, TValue>,
+): FilterType {
+ const ft = column.columnDef.meta?.filterType;
+ if (!ft || !EDITABLE_FILTER_TYPES.has(ft)) {
+ throw new Error(
+ `Invalid or missing filterType for column ${column.id}: ${ft}`,
+ );
+ }
+ return ft;
+}
+
+/** Minimal ColumnFilterValue for a (type, operator) pair, seeding extra fields for shapes that require them. */
+export function defaultFilterValueFor(
+ type: FilterType,
+ operator: OperatorType,
+): ColumnFilterValue {
+ if (isMembershipFilterType(type) && isMembershipOp(operator)) {
+ return { type, operator, values: [] };
+ }
+ return { type, operator } as ColumnFilterValue;
+}
diff --git a/frontend/src/components/data-table/filters/format.ts b/frontend/src/components/data-table/filters/format.ts
new file mode 100644
index 0000000000..bf1c409017
--- /dev/null
+++ b/frontend/src/components/data-table/filters/format.ts
@@ -0,0 +1,131 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { logNever } from "@/utils/assertNever";
+import {
+ dateToLocalISODate,
+ dateToLocalISOTime,
+ exactDateTime,
+} from "@/utils/dates";
+import { OPERATOR_LABELS } from "../operator-labels";
+import { stringifyUnknownValue } from "../utils";
+import type { ColumnFilterValue } from "./builders";
+import type { FormattedFilter } from "./types";
+
+interface FormatContext {
+ locale: string;
+ timezone: string | undefined;
+}
+
+export function formatValue(
+ value: ColumnFilterValue,
+ ctx: FormatContext,
+): FormattedFilter | undefined {
+ if (!("type" in value)) {
+ return;
+ }
+
+ if (value.operator === "is_null") {
+ return { kind: "scalar", operator: "is null" };
+ }
+ if (value.operator === "is_not_null") {
+ return { kind: "scalar", operator: "is not null" };
+ }
+
+ if (value.type === "number") {
+ switch (value.operator) {
+ case "between":
+ return {
+ kind: "scalar",
+ operator: OPERATOR_LABELS.between.toLowerCase(),
+ value: `${value.min} - ${value.max}`,
+ };
+ case "==":
+ case "!=":
+ case ">":
+ case ">=":
+ case "<":
+ case "<=":
+ return {
+ kind: "scalar",
+ operator: value.operator,
+ value: String(value.value),
+ };
+ case "in":
+ case "not_in":
+ return {
+ kind: "list",
+ operator: value.operator === "in" ? "is in" : "not in",
+ items: value.values
+ .map((v) => stringifyUnknownValue({ value: v }))
+ .toSorted((a, b) => a.localeCompare(b)),
+ };
+ }
+ }
+ if (value.type === "text") {
+ switch (value.operator) {
+ case "in":
+ case "not_in":
+ return {
+ kind: "list",
+ operator: value.operator === "in" ? "is in" : "not in",
+ items: value.values
+ .map((v) => stringifyUnknownValue({ value: v }))
+ .toSorted((a, b) => a.localeCompare(b)),
+ };
+ case "is_empty":
+ return { kind: "scalar", operator: "is empty" };
+ case "contains":
+ case "equals":
+ case "does_not_equal":
+ case "regex":
+ case "starts_with":
+ case "ends_with":
+ return {
+ kind: "scalar",
+ operator: OPERATOR_LABELS[value.operator].toLowerCase(),
+ value: `"${value.text}"`,
+ };
+ }
+ }
+ if (
+ value.type === "date" ||
+ value.type === "datetime" ||
+ value.type === "time"
+ ) {
+ const format =
+ value.type === "date"
+ ? dateToLocalISODate
+ : value.type === "time"
+ ? dateToLocalISOTime
+ : (d: Date) => exactDateTime(d, ctx.timezone, ctx.locale);
+ switch (value.operator) {
+ case "between":
+ return {
+ kind: "scalar",
+ operator: OPERATOR_LABELS.between.toLowerCase(),
+ value: `${format(value.min)} - ${format(value.max)}`,
+ };
+ case "==":
+ case "!=":
+ case ">":
+ case ">=":
+ case "<":
+ case "<=":
+ return {
+ kind: "scalar",
+ operator: value.operator,
+ value: format(value.value),
+ };
+ }
+ }
+ if (value.type === "boolean") {
+ switch (value.operator) {
+ case "is_true":
+ return { kind: "scalar", operator: "is True" };
+ case "is_false":
+ return { kind: "scalar", operator: "is False" };
+ }
+ }
+ logNever(value);
+ return undefined;
+}
diff --git a/frontend/src/components/data-table/filters/guards.ts b/frontend/src/components/data-table/filters/guards.ts
new file mode 100644
index 0000000000..8fc28b746a
--- /dev/null
+++ b/frontend/src/components/data-table/filters/guards.ts
@@ -0,0 +1,51 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { OperatorType } from "@/plugins/impl/data-frames/utils/operators";
+import type { ColumnFilterValue, MembershipFilterType } from "./builders";
+import {
+ COMPARISON_OPS,
+ type MembershipOp,
+ type NullishOp,
+ OPERATORS_BY_TYPE,
+ TEXT_SCALAR_OPS,
+} from "./operators";
+import type { FilterType } from "./types";
+
+const makeOpGuard = <T extends OperatorType>(ops: readonly T[]) => {
+ const set = new Set<OperatorType>(ops);
+ return (op: OperatorType): op is T => set.has(op);
+};
+
+export const isComparisonOp = makeOpGuard(COMPARISON_OPS);
+export const isTextScalarOp = makeOpGuard(TEXT_SCALAR_OPS);
+
+export function isMembershipOp(op: OperatorType): op is MembershipOp {
+ return op === "in" || op === "not_in";
+}
+
+export function isNullishFilter(
+ filter: ColumnFilterValue,
+): filter is Extract<ColumnFilterValue, { operator: NullishOp }> {
+ return filter.operator === "is_null" || filter.operator === "is_not_null";
+}
+
+export type DateLikeFilterType = Extract<
+ FilterType,
+ "date" | "datetime" | "time"
+>;
+
+const DATE_LIKE_TYPES: ReadonlySet<FilterType> = new Set([
+ "date",
+ "datetime",
+ "time",
+]);
+
+export const isDateLikeType = (type: FilterType): type is DateLikeFilterType =>
+ DATE_LIKE_TYPES.has(type);
+
+export function isMembershipFilterType(
+ type: FilterType,
+): type is MembershipFilterType {
+ const ops = OPERATORS_BY_TYPE[type];
+ return ops.includes("in") || ops.includes("not_in");
+}
diff --git a/frontend/src/components/data-table/filters/index.ts b/frontend/src/components/data-table/filters/index.ts
new file mode 100644
index 0000000000..9683563c23
--- /dev/null
+++ b/frontend/src/components/data-table/filters/index.ts
@@ -0,0 +1,7 @@
+export * from "./builders";
+export * from "./defaults";
+export * from "./format";
+export * from "./guards";
+export * from "./operators";
+export * from "./serialize";
+export * from "./types";
diff --git a/frontend/src/components/data-table/filters/operators.ts b/frontend/src/components/data-table/filters/operators.ts
new file mode 100644
index 0000000000..2e3e33b743
--- /dev/null
+++ b/frontend/src/components/data-table/filters/operators.ts
@@ -0,0 +1,76 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { OperatorType } from "@/plugins/impl/data-frames/utils/operators";
+import type { FilterType } from "./types";
+
+// Primitive operator groups — each describes one shape of filter value.
+export const NULLISH_OPS = ["is_null", "is_not_null"] as const;
+export const MEMBERSHIP_OPS = ["in", "not_in"] as const;
+export const COMPARISON_OPS = ["==", "!=", ">", ">=", "<", "<="] as const;
+export const TEXT_SCALAR_OPS = [
+ "contains",
+ "equals",
+ "does_not_equal",
+ "regex",
+ "starts_with",
+ "ends_with",
+] as const;
+export const BOOLEAN_VALUE_OPS = ["is_true", "is_false"] as const;
+export const EMPTY_OPS = ["is_empty"] as const;
+
+// Operators that carry no payload — `{ operator }` with no other field.
+export const UNARY_OPS = [
+ ...NULLISH_OPS,
+ ...BOOLEAN_VALUE_OPS,
+ ...EMPTY_OPS,
+] as const;
+
+// Per-type op lists used by the editor and validators.
+export const BOOLEAN_OPS = [...BOOLEAN_VALUE_OPS, ...NULLISH_OPS] as const;
+export const NUMBER_OPS = [
+ "between",
+ ...COMPARISON_OPS,
+ ...MEMBERSHIP_OPS,
+ ...NULLISH_OPS,
+] as const;
+export const TEXT_OPS = [
+ ...TEXT_SCALAR_OPS,
+ ...MEMBERSHIP_OPS,
+ ...EMPTY_OPS,
+ ...NULLISH_OPS,
+] as const;
+export const DATETIME_OPS = [
+ "between",
+ ...COMPARISON_OPS,
+ ...NULLISH_OPS,
+] as const;
+
+export type NullishOp = (typeof NULLISH_OPS)[number];
+export type MembershipOp = (typeof MEMBERSHIP_OPS)[number];
+export type ComparisonOp = (typeof COMPARISON_OPS)[number];
+export type TextScalarOp = (typeof TEXT_SCALAR_OPS)[number];
+export type BooleanValueOp = (typeof BOOLEAN_VALUE_OPS)[number];
+export type BooleanOp = (typeof BOOLEAN_OPS)[number];
+
+export const OPERATORS_BY_TYPE: Record<
+ FilterType,
+ ReadonlyArray<OperatorType>
+> = {
+ number: NUMBER_OPS,
+ text: TEXT_OPS,
+ boolean: BOOLEAN_OPS,
+ date: DATETIME_OPS,
+ datetime: DATETIME_OPS,
+ time: DATETIME_OPS,
+};
+
+export const DEFAULT_OPERATOR_FOR_TYPE: Record<FilterType, OperatorType> = {
+ number: "between",
+ text: "contains",
+ boolean: "is_true",
+ date: "==",
+ datetime: "==",
+ time: "between",
+};
+
+export const OPERATORS_WITHOUT_VALUE = new Set<OperatorType>(UNARY_OPS);
diff --git a/frontend/src/components/data-table/filters/serialize.ts b/frontend/src/components/data-table/filters/serialize.ts
new file mode 100644
index 0000000000..044de77444
--- /dev/null
+++ b/frontend/src/components/data-table/filters/serialize.ts
@@ -0,0 +1,186 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { ColumnFiltersState } from "@tanstack/react-table";
+import type {
+ FilterConditionType,
+ FilterGroupType,
+} from "@/plugins/impl/data-frames/schema";
+import type { ColumnId } from "@/plugins/impl/data-frames/types";
+import { assertNever } from "@/utils/assertNever";
+import {
+ dateToLocalISODate,
+ dateToLocalISODateTime,
+ dateToLocalISOTime,
+} from "@/utils/dates";
+import type { ColumnFilterValue } from "./builders";
+import { isNullishFilter } from "./guards";
+
+export function filterToFilterCondition(
+ columnIdString: string,
+ filter: ColumnFilterValue | undefined,
+): FilterConditionType[] {
+ if (!filter) {
+ return [];
+ }
+ const columnId = columnIdString as ColumnId;
+
+ if (isNullishFilter(filter)) {
+ return [
+ {
+ column_id: columnId,
+ operator: filter.operator,
+ type: "condition",
+ negate: false,
+ },
+ ];
+ }
+
+ switch (filter.type) {
+ case "number":
+ switch (filter.operator) {
+ case "between":
+ return [
+ {
+ column_id: columnId,
+ operator: "between",
+ value: { min: filter.min, max: filter.max },
+ type: "condition",
+ negate: false,
+ },
+ ];
+ case "==":
+ case "!=":
+ case ">":
+ case ">=":
+ case "<":
+ case "<=":
+ return [
+ {
+ column_id: columnId,
+ operator: filter.operator,
+ value: filter.value,
+ type: "condition",
+ negate: false,
+ },
+ ];
+ case "in":
+ case "not_in":
+ return [
+ {
+ column_id: columnId,
+ operator: filter.operator,
+ value: filter.values,
+ type: "condition",
+ negate: false,
+ },
+ ];
+ default:
+ assertNever(filter);
+ }
+ case "text":
+ switch (filter.operator) {
+ case "contains":
+ case "equals":
+ case "does_not_equal":
+ case "regex":
+ case "starts_with":
+ case "ends_with":
+ return [
+ {
+ column_id: columnId,
+ operator: filter.operator,
+ value: filter.text,
+ type: "condition",
+ negate: false,
+ },
+ ];
+ case "in":
+ case "not_in":
+ return [
+ {
+ column_id: columnId,
+ operator: filter.operator,
+ value: filter.values,
+ type: "condition",
+ negate: false,
+ },
+ ];
+ case "is_empty":
+ return [
+ {
+ column_id: columnId,
+ operator: "is_empty",
+ type: "condition",
+ negate: false,
+ },
+ ];
+ default:
+ assertNever(filter);
+ }
+ case "date":
+ case "datetime":
+ case "time": {
+ const encode =
+ filter.type === "date"
+ ? dateToLocalISODate
+ : filter.type === "time"
+ ? dateToLocalISOTime
+ : dateToLocalISODateTime;
+ switch (filter.operator) {
+ case "between":
+ return [
+ {
+ column_id: columnId,
+ operator: "between",
+ value: { min: encode(filter.min), max: encode(filter.max) },
+ type: "condition",
+ negate: false,
+ },
+ ];
+ case "==":
+ case "!=":
+ case ">":
+ case ">=":
+ case "<":
+ case "<=":
+ return [
+ {
+ column_id: columnId,
+ operator: filter.operator,
+ value: encode(filter.value),
+ type: "condition",
+ negate: false,
+ },
+ ];
+ default:
+ assertNever(filter);
+ }
+ }
+ case "boolean":
+ return [
+ {
+ column_id: columnId,
+ operator: filter.operator,
+ type: "condition",
+ negate: false,
+ },
+ ];
+ default:
+ assertNever(filter);
+ }
+}
+
+export function filtersToFilterGroup(
+ columnFilters: ColumnFiltersState,
+): FilterGroupType {
+ const conditions = columnFilters.flatMap((filter) =>
+ filterToFilterCondition(filter.id, filter.value as ColumnFilterValue),
+ );
+ // To maintain existing behavior "and" all the conditions
+ return {
+ type: "group",
+ operator: "and",
+ children: conditions,
+ negate: false,
+ };
+}
diff --git a/frontend/src/components/data-table/filters/types.ts b/frontend/src/components/data-table/filters/types.ts
new file mode 100644
index 0000000000..c6b25fc08f
--- /dev/null
+++ b/frontend/src/components/data-table/filters/types.ts
@@ -0,0 +1,33 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { RowData } from "@tanstack/react-table";
+import type { DataType } from "@/core/kernel/messages";
+
+declare module "@tanstack/react-table" {
+ //allows us to define custom properties for our columns
+ interface ColumnMeta<TData extends RowData, TValue> {
+ rowHeader?: boolean;
+ dtype?: string;
+ dataType?: DataType;
+ filterType?: FilterType;
+ minFractionDigits?: number;
+ }
+}
+
+const FILTER_TYPES = [
+ "text",
+ "number",
+ "date",
+ "datetime",
+ "time",
+ "boolean",
+] as const;
+export type FilterType = (typeof FILTER_TYPES)[number];
+
+export const EDITABLE_FILTER_TYPES: ReadonlySet<FilterType> = new Set(
+ FILTER_TYPES,
+);
+
+export type FormattedFilter =
+ | { kind: "scalar"; operator: string; value?: string }
+ | { kind: "list"; operator: string; items: string[] };
diff --git a/frontend/src/components/data-table/header-items.tsx b/frontend/src/components/data-table/header-items.tsx
index 4742251367..18e7759ba3 100644
--- a/frontend/src/components/data-table/header-items.tsx
+++ b/frontend/src/components/data-table/header-items.tsx
@@ -9,9 +9,6 @@ import {
ChevronsUpDown,
CopyIcon,
FilterX,
- FunnelPlusIcon,
- ListFilterIcon,
- ListFilterPlusIcon,
PinOffIcon,
WrapTextIcon,
} from "lucide-react";
@@ -27,7 +24,6 @@ import type { DataType } from "@/core/kernel/messages";
import { cn } from "@/utils/cn";
import { copyToClipboard } from "@/utils/copy";
import { DATA_TYPE_ICON } from "../datasets/icons";
-import { Button } from "../ui/button";
import { formattingExample } from "./column-formatting/feature";
import { formatOptions } from "./column-formatting/types";
import { NAMELESS_COLUMN_PREFIX } from "./columns";
@@ -242,26 +238,18 @@ export function renderSorts<TData, TValue>(
);
}
-export function renderSortFilterIcon<TData, TValue>(
- column: Column<TData, TValue>,
-) {
+export function renderSortIcon<TData, TValue>(column: Column<TData, TValue>) {
if (!column.getCanSort()) {
return null;
}
const isSorted = column.getIsSorted();
- const isFiltered = column.getFilterValue() !== undefined;
- let Icon: React.FC<React.SVGProps<SVGSVGElement>>;
- if (isFiltered && isSorted) {
- Icon = ListFilterPlusIcon;
- } else if (isFiltered) {
- Icon = FunnelPlusIcon;
- } else if (isSorted) {
- Icon = isSorted === "desc" ? DescIcon : AscIcon;
- } else {
- Icon = ChevronsUpDown;
- }
+ const Icon: React.FC<React.SVGProps<SVGSVGElement>> = isSorted
+ ? isSorted === "desc"
+ ? DescIcon
+ : AscIcon
+ : ChevronsUpDown;
return <Icon className="h-3 w-3" />;
}
@@ -292,68 +280,3 @@ export const ClearFilterMenuItem = <TData, TValue>({
Clear filter
</DropdownMenuItem>
);
-
-export function renderFilterByValues<TData, TValue>(
- column: Column<TData, TValue>,
- setIsFilterValueOpen: (open: boolean) => void,
-) {
- const canFilter = column.getCanFilter();
- if (!canFilter) {
- return null;
- }
-
- const columnType = column.columnDef.meta?.dataType;
- // skip boolean as this can be easily filtered through normal filters
- if (columnType === "boolean") {
- return null;
- }
-
- // there are some edge cases which do not support filtering (eg. dicts with None values)
- const filterType = column.columnDef.meta?.filterType;
- if (!filterType) {
- return null;
- }
-
- return (
- <DropdownMenuSub>
- <DropdownMenuItem onClick={() => setIsFilterValueOpen(true)}>
- <ListFilterIcon className="mo-dropdown-icon" />
- Filter by values
- </DropdownMenuItem>
- </DropdownMenuSub>
- );
-}
-
-export const FilterButtons = ({
- onApply,
- onClear,
- clearButtonDisabled,
- applyButtonDisabled,
-}: {
- onApply: () => void;
- onClear: () => void;
- clearButtonDisabled?: boolean;
- applyButtonDisabled?: boolean;
-}) => {
- return (
- <div className="flex gap-2 px-2 justify-between">
- <Button
- variant="link"
- size="sm"
- onClick={onApply}
- disabled={applyButtonDisabled}
- >
- Apply
- </Button>
- <Button
- variant="linkDestructive"
- size="sm"
- className=""
- onClick={onClear}
- disabled={clearButtonDisabled}
- >
- Clear
- </Button>
- </div>
- );
-};
diff --git a/frontend/src/components/data-table/value-chips.tsx b/frontend/src/components/data-table/value-chips.tsx
new file mode 100644
index 0000000000..dbeb139de5
--- /dev/null
+++ b/frontend/src/components/data-table/value-chips.tsx
@@ -0,0 +1,52 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type React from "react";
+
+export const Chip = ({ children }: { children: React.ReactNode }) => (
+ <span className="inline-flex items-center rounded-sm bg-muted/50 px-1 font-mono text-xs font-normal leading-tight text-foreground">
+ {children}
+ </span>
+);
+
+export const MoreChip = ({ count }: { count: number }) => (
+ <span className="inline-flex items-center px-1 text-xs italic text-muted-foreground">
+ +{count}
+ </span>
+);
+
+interface ChipWithCommaProps {
+ value: string;
+ showComma: boolean;
+}
+
+export const ChipWithComma = ({ value, showComma }: ChipWithCommaProps) => (
+ <span className="inline-flex items-center">
+ <Chip>{value}</Chip>
+ {showComma && <span className="text-muted-foreground">,</span>}
+ </span>
+);
+
+interface CompactChipRowProps {
+ items: string[];
+ max?: number;
+}
+
+export const CompactChipRow = ({ items, max = 3 }: CompactChipRowProps) => {
+ if (items.length === 0) {
+ return null;
+ }
+ const visible = items.slice(0, max);
+ const hidden = Math.max(0, items.length - max);
+ return (
+ <span className="inline-flex items-center gap-1">
+ {visible.map((item, i) => (
+ <ChipWithComma
+ key={i}
+ value={item}
+ showComma={i < visible.length - 1}
+ />
+ ))}
+ {hidden > 0 && <MoreChip count={hidden} />}
+ </span>
+ );
+};
diff --git a/frontend/src/components/ui/number-field.tsx b/frontend/src/components/ui/number-field.tsx
index cfad73e700..4791ede54a 100644
--- a/frontend/src/components/ui/number-field.tsx
+++ b/frontend/src/components/ui/number-field.tsx
@@ -15,10 +15,17 @@ import { maxFractionalDigits } from "@/utils/numbers";
export interface NumberFieldProps extends AriaNumberFieldProps {
placeholder?: string;
variant?: "default" | "xs";
+ /**
+ * Fires on every keystroke with the raw text currently in the input.
+ * React-aria's `onChange` only fires on commit (blur/Enter/stepper); use this
+ * when callers need to peek at the in-progress value, e.g. to enable an Apply
+ * button while the user is still typing.
+ */
+ onInputText?: (text: string) => void;
}
export const NumberField = React.forwardRef<HTMLInputElement, NumberFieldProps>(
- ({ placeholder, variant = "default", ...props }, ref) => {
+ ({ placeholder, variant = "default", onInputText, ...props }, ref) => {
const { locale } = useLocale();
return (
<AriaNumberField
@@ -48,6 +55,11 @@ export const NumberField = React.forwardRef<HTMLInputElement, NumberFieldProps>(
e.stopPropagation();
}
}}
+ onInput={
+ onInputText
+ ? (e) => onInputText(e.currentTarget.value)
+ : undefined
+ }
className={cn(
"flex-1",
"w-full",
diff --git a/frontend/src/utils/dates.ts b/frontend/src/utils/dates.ts
index 0f409156f9..95d9bb6a5d 100644
--- a/frontend/src/utils/dates.ts
+++ b/frontend/src/utils/dates.ts
@@ -134,6 +134,45 @@ export function timeAgo(
return value.toString();
}
+function pad2(n: number): string {
+ return n.toString().padStart(2, "0");
+}
+
+function pad4(n: number): string {
+ return n.toString().padStart(4, "0");
+}
+
+/**
+ * Format a Date as `YYYY-MM-DD` using the date's local-time fields.
+ *
+ * The output reflects what the user sees in their own timezone (the calendar
+ * day on their clock), not the UTC day. Use this when round-tripping values
+ * that originated from local-time inputs — date pickers, "filter on this
+ * day", calendar UI — so the displayed and serialized days agree.
+ *
+ * Not suitable for cross-timezone storage; use `Date.toISOString()` for that.
+ */
+export function dateToLocalISODate(d: Date): string {
+ return `${pad4(d.getFullYear())}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+}
+
+/**
+ * Format a Date as `HH:MM:SS` using the date's local-time fields.
+ *
+ * See `dateToLocalISODate` for the rationale on local vs UTC.
+ */
+export function dateToLocalISOTime(d: Date): string {
+ return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+}
+
+/**
+ * Format a Date as `YYYY-MM-DDTHH:MM:SS` (no timezone suffix) using local
+ * fields. See `dateToLocalISODate` for the rationale on local vs UTC.
+ */
+export function dateToLocalISODateTime(d: Date): string {
+ return `${dateToLocalISODate(d)}T${dateToLocalISOTime(d)}`;
+}
+
export const supportedDateFormats = ["yyyy", "yyyy-MM", "yyyy-MM-dd"] as const;
export type DateFormat = (typeof supportedDateFormats)[number];