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.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
feat(table): date/datetime/time filter UI (#9615)
Kiran Gadhave3e9bffe2029f
diff --git a/frontend/src/components/data-table/__tests__/column-header.test.tsx b/frontend/src/components/data-table/__tests__/column-header.test.tsxindex 0f4b85b14c..311f4598cc 100644--- a/frontend/src/components/data-table/__tests__/column-header.test.tsx+++ b/frontend/src/components/data-table/__tests__/column-header.test.tsx@@ -2,7 +2,11 @@import type { Column } from "@tanstack/react-table";import { fireEvent, render, screen, within } from "@testing-library/react";import { beforeAll, describe, expect, it, vi } from "vitest";-import { NumberFilterMenu, TextFilterMenu } from "../column-header";+import {+ DateFilterMenu,+ NumberFilterMenu,+ TextFilterMenu,+} from "../column-header";import { Filter } from "../filters";beforeAll(() => {@@ -201,3 +205,104 @@ describe("TextFilterMenu", () => {expect(screen.getByRole("button", { name: /apply/i })).not.toBeDisabled();});});++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("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" }),+ );+ });+});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.tsxindex 2cf8788dfa..702170f9e4 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@@ -26,7 +26,14 @@ beforeAll(() => {function makeColumn(id: string,- filterType: "text" | "number" | "boolean" | "select",+ filterType:+ | "text"+ | "number"+ | "boolean"+ | "select"+ | "date"+ | "datetime"+ | "time",): Column<unknown, unknown> {return {id,@@ -35,7 +42,13 @@ function makeColumn(}function mockTable(): Table<unknown> {- const columns = [makeColumn("name", "text"), makeColumn("age", "number")];+ 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),@@ -144,6 +157,79 @@ describe("FilterPillEditor — snapshot rehydration", () => {});});+describe("FilterPillEditor — date/datetime/time", () => {+ it("rehydrates a date between snapshot with the range picker", () => {+ renderWithProviders(+ <FilterPillEditor+ snapshot={{+ columnId: "when",+ value: Filter.date({+ operator: "between",+ min: new Date("2024-01-01T00:00:00Z"),+ max: new Date("2024-06-01T00:00:00Z"),+ }),+ }}+ table={mockTable()}+ onClose={vi.fn()}+ />,+ );+ expect(screen.getByLabelText("range")).toBeInTheDocument();+ expect(screen.queryByLabelText("value")).not.toBeInTheDocument();+ });++ it("rehydrates a datetime <= snapshot with a single value picker", () => {+ renderWithProviders(+ <FilterPillEditor+ snapshot={{+ columnId: "at",+ value: Filter.datetime({+ operator: "<=",+ value: new Date("2024-06-01T12:00:00Z"),+ }),+ }}+ table={mockTable()}+ onClose={vi.fn()}+ />,+ );+ expect(screen.getByLabelText("value")).toBeInTheDocument();+ expect(screen.queryByLabelText("range")).not.toBeInTheDocument();+ });++ it("renders min/max TimeFields for time between", () => {+ renderWithProviders(+ <FilterPillEditor+ snapshot={{+ columnId: "clock",+ value: Filter.time({+ operator: "between",+ min: new Date("2024-01-01T08:00:00Z"),+ max: new Date("2024-01-01T17:00:00Z"),+ }),+ }}+ table={mockTable()}+ onClose={vi.fn()}+ />,+ );+ expect(screen.getByLabelText("min")).toBeInTheDocument();+ expect(screen.getByLabelText("max")).toBeInTheDocument();+ });++ it("hides the value slot for date is_null", () => {+ renderWithProviders(+ <FilterPillEditor+ snapshot={{+ columnId: "when",+ value: Filter.date({ operator: "is_null" }),+ }}+ table={mockTable()}+ onClose={vi.fn()}+ />,+ );+ expect(screen.queryByText("Value")).not.toBeInTheDocument();+ expect(screen.queryByLabelText("range")).not.toBeInTheDocument();+ });+});+describe("FilterPillEditor — apply", () => {it("commits a number > filter via setColumnFilters", () => {const table = mockTable();diff --git a/frontend/src/components/data-table/__tests__/filters.test.ts b/frontend/src/components/data-table/__tests__/filters.test.tsindex 2256236959..e1e9e0714c 100644--- a/frontend/src/components/data-table/__tests__/filters.test.ts+++ b/frontend/src/components/data-table/__tests__/filters.test.ts@@ -215,22 +215,93 @@ describe("filterToFilterCondition", () => {]);});- it("handles date filter with min and max", () => {- const min = new Date("2024-01-01");- const max = new Date("2024-12-31");+ it("handles date between filter", () => {+ const min = new Date(2024, 0, 1);+ const max = new Date(2024, 11, 31);const result = filterToFilterCondition("created",- Filter.date({ min, max }),+ Filter.date({ operator: "between", min, max }),);- expect(result).toHaveLength(2);- expect(result[0]).toMatchObject({- operator: ">=",- value: min.toISOString(),- });- expect(result[1]).toMatchObject({- operator: "<=",- value: max.toISOString(),- });+ expect(result).toEqual([+ {+ column_id: "created",+ operator: "between",+ value: { min: "2024-01-01", max: "2024-12-31" },+ type: "condition",+ negate: false,+ },+ ]);+ });++ it("handles date comparison filter", () => {+ const value = new Date(2024, 5, 15);+ const result = filterToFilterCondition(+ "created",+ Filter.date({ operator: ">=", value }),+ );+ expect(result).toEqual([+ {+ column_id: "created",+ operator: ">=",+ value: "2024-06-15",+ type: "condition",+ negate: false,+ },+ ]);+ });++ it("handles datetime between filter as local ISO string without TZ", () => {+ const min = new Date(2024, 0, 1, 0, 0, 0);+ const max = new Date(2024, 11, 31, 23, 59, 59);+ const result = filterToFilterCondition(+ "created",+ Filter.datetime({ operator: "between", min, max }),+ );+ expect(result).toEqual([+ {+ column_id: "created",+ operator: "between",+ value: {+ min: "2024-01-01T00:00:00",+ max: "2024-12-31T23:59:59",+ },+ type: "condition",+ negate: false,+ },+ ]);+ });++ it("handles time between filter as HH:MM:SS", () => {+ const min = new Date(2024, 0, 1, 9, 30, 0);+ const max = new Date(2024, 0, 1, 17, 45, 15);+ const result = filterToFilterCondition(+ "start",+ Filter.time({ operator: "between", min, max }),+ );+ expect(result).toEqual([+ {+ column_id: "start",+ operator: "between",+ value: { min: "09:30:00", max: "17:45:15" },+ type: "condition",+ negate: false,+ },+ ]);+ });++ it("handles date is_null filter", () => {+ const result = filterToFilterCondition(+ "created",+ Filter.date({ operator: "is_null" }),+ );+ expect(result).toEqual([+ {+ column_id: "created",+ operator: "is_null",+ type: "condition",+ negate: false,+ },+ ]);});it("every condition has type and negate fields", () => {diff --git a/frontend/src/components/data-table/column-header.tsx b/frontend/src/components/data-table/column-header.tsxindex f556fbb464..5567bd7feb 100644--- a/frontend/src/components/data-table/column-header.tsx+++ b/frontend/src/components/data-table/column-header.tsx@@ -44,14 +44,19 @@ import { OPERATOR_LABELS } from "./operator-labels";import {type ColumnFilterForType,type ColumnFilterValue,+ DATETIME_OPS,Filter,- NUMBER_COMPARISON_OPS,- type NumberComparisonOp,+ isDatetimeComparisonOp,+ isNumberComparisonOp,+ isTextScalarOp,NUMBER_OPS,TEXT_OPS,- TEXT_SCALAR_OPS,- type TextScalarOp,} from "./filters";+import {+ type DateLikeFilterType,+ DateLikeInput,+ DateLikeRangeInput,+} from "./date-filter-inputs";import {ClearFilterMenuItem,FilterButtons,@@ -283,19 +288,21 @@ export function renderMenuItemFilter<TData, TValue>(return null;}- if (filterType === "time") {- // Not implemented- return null;- }-- if (filterType === "datetime") {- // Not implemented- return null;- }-- if (filterType === "date") {- // 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);@@ -369,12 +376,6 @@ const BooleanFilter = <TData, TValue>({);};-const NUMBER_COMPARISON_SET: ReadonlySet<OperatorType> = new Set(- NUMBER_COMPARISON_OPS,-);-const isNumberComparisonOp = (op: OperatorType): op is NumberComparisonOp =>- NUMBER_COMPARISON_SET.has(op);-type NumberComparisonFilter = Extract<ColumnFilterForType<"number">,{ value: number }@@ -485,9 +486,134 @@ export const NumberFilterMenu = <TData, TValue>({);};-const TEXT_SCALAR_SET: ReadonlySet<OperatorType> = new Set(TEXT_SCALAR_OPS);-const isTextScalarOp = (op: OperatorType): op is TextScalarOp =>- TEXT_SCALAR_SET.has(op);+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,diff --git a/frontend/src/components/data-table/date-filter-inputs.tsx b/frontend/src/components/data-table/date-filter-inputs.tsxnew file mode 100644index 0000000000..0a5a0de10f--- /dev/null+++ b/frontend/src/components/data-table/date-filter-inputs.tsx@@ -0,0 +1,325 @@+/* Copyright 2026 Marimo. All rights reserved. */+import type {+ CalendarDate,+ CalendarDateTime,+ Time,+} from "@internationalized/date";+import { parseDate, parseDateTime, parseTime } from "@internationalized/date";+import { MinusIcon } from "lucide-react";+import { useState } from "react";+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";++export type DateLikeFilterType = Extract<+ FilterType,+ "date" | "datetime" | "time"+>;++function dateToAria(+ filterType: DateLikeFilterType,+ d: Date,+): DateValue | TimeValue {+ switch (filterType) {+ case "date":+ return parseDate(dateToISODate(d));+ case "datetime":+ return parseDateTime(dateToISODateTime(d));+ case "time":+ return parseTime(dateToISOTime(d));+ }+}++function ariaToDate(+ filterType: DateLikeFilterType,+ aria: DateValue | TimeValue,+): Date {+ if (filterType === "time") {+ const t = aria as Time;+ return new Date(1970, 0, 1, t.hour, t.minute, t.second, t.millisecond);+ }+ if (filterType === "date") {+ const c = aria as CalendarDate;+ return new Date(c.year, c.month - 1, c.day);+ }+ const c = aria as Partial<CalendarDateTime> & CalendarDate;+ return new Date(+ c.year,+ c.month - 1,+ c.day,+ c.hour ?? 0,+ c.minute ?? 0,+ c.second ?? 0,+ c.millisecond ?? 0,+ );+}++// Parses a pasted string into a Date appropriate for the filter type.+// Accepts ISO, US, RFC formats via the Date constructor; time-only strings+// (HH:MM[:SS]) are handled explicitly since `new Date("12:30")` is invalid.+export function parsePastedDate(+ filterType: DateLikeFilterType,+ text: string,+): Date | undefined {+ const trimmed = text.trim();+ if (!trimmed) {+ return undefined;+ }++ const timeMatch =+ filterType === "time"+ ? trimmed.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?\s*(am|pm)?$/i)+ : null;+ if (timeMatch) {+ const [, hStr, mStr, sStr, ampm] = timeMatch;+ let hour = Number.parseInt(hStr, 10);+ const minute = Number.parseInt(mStr, 10);+ const second = sStr ? Number.parseInt(sStr, 10) : 0;+ if (ampm) {+ const isPm = ampm.toLowerCase() === "pm";+ if (hour === 12) {+ hour = isPm ? 12 : 0;+ } else if (isPm) {+ hour += 12;+ }+ }+ return new Date(1970, 0, 1, hour, minute, second);+ }++ const dateOnlyMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})$/);+ if (dateOnlyMatch) {+ const [, y, m, d] = dateOnlyMatch;+ return new Date(+ Number.parseInt(y, 10),+ Number.parseInt(m, 10) - 1,+ Number.parseInt(d, 10),+ );+ }++ // Parse ISO datetimes as wall-clock to stay consistent with the picker's+ // local-time basis. Trailing `Z` or offsets are stripped so that pasting+ // `2024-01-15T08:30:00Z` displays `08:30` instead of being shifted by the+ // viewer's timezone.+ const isoMatch = trimmed.match(+ /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?$/,+ );+ if (isoMatch) {+ const [, y, mo, d, h, mi, s] = isoMatch;+ return new Date(+ Number.parseInt(y, 10),+ Number.parseInt(mo, 10) - 1,+ Number.parseInt(d, 10),+ Number.parseInt(h, 10),+ Number.parseInt(mi, 10),+ s ? Number.parseInt(s, 10) : 0,+ );+ }++ const parsed = new Date(trimmed);+ if (Number.isNaN(parsed.getTime())) {+ return undefined;+ }+ return parsed;+}++function parsePastedRange(+ filterType: DateLikeFilterType,+ text: string,+): { min: Date; max: Date } | undefined {+ const parts = text.split(/\s+(?:-|–|—|to)\s+/i);+ if (parts.length === 2) {+ const min = parsePastedDate(filterType, parts[0]);+ const max = parsePastedDate(filterType, parts[1]);+ if (min && max) {+ return { min, max };+ }+ }+ const single = parsePastedDate(filterType, text);+ if (single) {+ return { min: single, max: single };+ }+ return undefined;+}++interface DateLikeInputProps {+ filterType: DateLikeFilterType;+ value: Date | undefined;+ onChange: (value: Date | undefined) => void;+ "aria-label"?: string;+ className?: string;+}++export const DateLikeInput = ({+ filterType,+ value,+ onChange,+ "aria-label": ariaLabel,+ className,+}: DateLikeInputProps) => {+ const [seedKey, setSeedKey] = useState(0);+ const [seed, setSeed] = useState(value);++ const handleChange = (next: DateValue | TimeValue | null) => {+ if (next === null) {+ return;+ }+ onChange(ariaToDate(filterType, next));+ };++ const handlePaste = (e: React.ClipboardEvent<HTMLDivElement>) => {+ const text = e.clipboardData.getData("text");+ const parsed = parsePastedDate(filterType, text);+ if (!parsed) {+ return;+ }+ e.preventDefault();+ onChange(parsed);+ setSeed(parsed);+ setSeedKey((k) => k + 1);+ };++ const seedValue =+ seed === undefined ? undefined : dateToAria(filterType, seed);++ return (+ <div onPasteCapture={handlePaste} className="contents">+ {filterType === "time" ? (+ <TimeField<Time>+ key={seedKey}+ aria-label={ariaLabel}+ defaultValue={seedValue as Time | undefined}+ onChange={handleChange}+ className={className}+ />+ ) : filterType === "date" ? (+ <DatePicker<CalendarDate>+ key={seedKey}+ aria-label={ariaLabel}+ defaultValue={seedValue as CalendarDate | undefined}+ onChange={handleChange}+ className={className}+ />+ ) : (+ <DatePicker<CalendarDateTime>+ key={seedKey}+ aria-label={ariaLabel}+ defaultValue={seedValue as CalendarDateTime | undefined}+ granularity="second"+ onChange={handleChange}+ className={className}+ />+ )}+ </div>+ );+};++interface DateLikeRangeInputProps {+ filterType: DateLikeFilterType;+ min: Date | undefined;+ max: Date | undefined;+ onRangeChange: (min: Date | undefined, max: Date | undefined) => void;+ className?: string;+}++export const DateLikeRangeInput = ({+ filterType,+ min,+ max,+ onRangeChange,+ className,+}: DateLikeRangeInputProps) => {+ const [seedKey, setSeedKey] = useState(0);+ const [seedMin, setSeedMin] = useState(min);+ const [seedMax, setSeedMax] = useState(max);++ const handlePaste = (e: React.ClipboardEvent<HTMLDivElement>) => {+ const text = e.clipboardData.getData("text");+ const parsed = parsePastedRange(filterType, text);+ if (!parsed) {+ return;+ }+ e.preventDefault();+ e.stopPropagation();+ onRangeChange(parsed.min, parsed.max);+ setSeedMin(parsed.min);+ setSeedMax(parsed.max);+ setSeedKey((k) => k + 1);+ };++ if (filterType === "time") {+ return (+ <div onPasteCapture={handlePaste} className="flex gap-1 items-center">+ <DateLikeInput+ key={`min-${seedKey}`}+ filterType="time"+ value={seedMin}+ onChange={(nextMin) => onRangeChange(nextMin, max)}+ aria-label="min"+ className={className}+ />+ <MinusIcon className="h-5 w-5 text-muted-foreground" />+ <DateLikeInput+ key={`max-${seedKey}`}+ filterType="time"+ value={seedMax}+ onChange={(nextMax) => onRangeChange(min, nextMax)}+ aria-label="max"+ className={className}+ />+ </div>+ );+ }++ const handleChange = (next: { start: DateValue; end: DateValue } | null) => {+ if (next === null) {+ return;+ }+ onRangeChange(+ ariaToDate(filterType, next.start),+ ariaToDate(filterType, next.end),+ );+ };++ const seedRange =+ seedMin === undefined || seedMax === undefined+ ? undefined+ : {+ start: dateToAria(filterType, seedMin),+ end: dateToAria(filterType, seedMax),+ };++ return (+ <div onPasteCapture={handlePaste} className="contents">+ {filterType === "date" ? (+ <DateRangePicker<CalendarDate>+ key={seedKey}+ aria-label="range"+ defaultValue={+ seedRange as { start: CalendarDate; end: CalendarDate } | undefined+ }+ onChange={handleChange}+ className={className}+ />+ ) : (+ <DateRangePicker<CalendarDateTime>+ key={seedKey}+ aria-label="range"+ defaultValue={+ seedRange as+ | { start: CalendarDateTime; end: CalendarDateTime }+ | undefined+ }+ granularity="second"+ onChange={handleChange}+ className={className}+ />+ )}+ </div>+ );+};diff --git a/frontend/src/components/data-table/filter-pill-editor.tsx b/frontend/src/components/data-table/filter-pill-editor.tsxindex 28f17c210f..86d2a87e7c 100644--- a/frontend/src/components/data-table/filter-pill-editor.tsx+++ b/frontend/src/components/data-table/filter-pill-editor.tsx@@ -17,23 +17,46 @@ import {SelectValue,} from "../ui/select";import { Button } from "../ui/button";+import { DateLikeInput, DateLikeRangeInput } from "./date-filter-inputs";import { FilterByValuesPicker } from "./filter-by-values-picker";import { RegexInput } from "./regex-input";import {type ColumnFilterValue,+ DATETIME_OPS,Filter,+ isDatetimeComparisonOp,+ isNumberComparisonOp,+ isTextScalarOp,MEMBERSHIP_OPS,- NUMBER_COMPARISON_OPS,- type NumberComparisonOp,NUMBER_OPS,TEXT_OPS,- TEXT_SCALAR_OPS,- type TextScalarOp,} from "./filters";import { OPERATOR_LABELS } from "./operator-labels";import { Tooltip } from "../ui/tooltip";-type EditableFilterType = "number" | "text" | "boolean" | "select";+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;@@ -46,6 +69,9 @@ const OPERATORS_BY_TYPE: Record<text: TEXT_OPS,boolean: BOOLEAN_OPS,select: SELECT_OPS,+ date: DATETIME_OPS,+ datetime: DATETIME_OPS,+ time: DATETIME_OPS,};const DEFAULT_OPERATOR: Record<EditableFilterType, OperatorType> = {@@ -53,6 +79,9 @@ const DEFAULT_OPERATOR: Record<EditableFilterType, OperatorType> = {text: "contains",boolean: "is_true",select: "in",+ date: "between",+ datetime: "between",+ time: "between",};const OPERATORS_WITHOUT_VALUE = new Set<OperatorType>([@@ -63,22 +92,14 @@ const OPERATORS_WITHOUT_VALUE = new Set<OperatorType>(["is_empty",]);-const NUMBER_COMPARISON_SET: ReadonlySet<OperatorType> = new Set(- NUMBER_COMPARISON_OPS,-);-const TEXT_SCALAR_SET: ReadonlySet<OperatorType> = new Set(TEXT_SCALAR_OPS);--const isNumberComparisonOp = (op: OperatorType): op is NumberComparisonOp =>- NUMBER_COMPARISON_SET.has(op);-const isTextScalarOp = (op: OperatorType): op is TextScalarOp =>- TEXT_SCALAR_SET.has(op);-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: "date-between"; min?: Date; max?: Date }+ | { kind: "date-single"; value?: Date }| { kind: "none" };interface Snapshot {@@ -116,7 +137,13 @@ export const FilterPillEditor = <TData,>({const editableColumns = table.getAllColumns().filter((c) => {const ft = c.columnDef.meta?.filterType;return (- ft === "number" || ft === "text" || ft === "boolean" || ft === "select"+ ft === "number" ||+ ft === "text" ||+ ft === "boolean" ||+ ft === "select" ||+ ft === "date" ||+ ft === "datetime" ||+ ft === "time");});@@ -200,7 +227,7 @@ export const FilterPillEditor = <TData,>({const operatorTriggerRef = useRef<HTMLButtonElement>(null);useEffect(() => {const firstInput = valueSlotRef.current?.querySelector<HTMLElement>(- 'input, [role="combobox"], button',+ 'input, [role="spinbutton"], [role="combobox"], button',);if (firstInput) {firstInput.focus();@@ -216,6 +243,11 @@ export const FilterPillEditor = <TData,>({e.preventDefault();handleApply();}}+ onKeyDownCapture={(e) => {+ if (e.key === "Tab") {+ e.stopPropagation();+ }+ }}><div className="flex flex-col gap-1"><label className="text-xs text-muted-foreground" htmlFor={columnId}>@@ -426,6 +458,36 @@ const ValueSlot = <TData, TValue>({/>);}+ if (isDateLikeType(type) && operator === "between") {+ const v =+ value.kind === "date-between" ? value : { kind: "date-between" as const };+ return (+ <DateLikeRangeInput+ key={`${column?.id ?? "_"}-${operator}`}+ filterType={type}+ min={v.min}+ max={v.max}+ onRangeChange={(min, max) =>+ onChange({ kind: "date-between", min, max })+ }+ className="border-input"+ />+ );+ }+ if (isDateLikeType(type) && isDatetimeComparisonOp(operator)) {+ const v =+ value.kind === "date-single" ? value : { kind: "date-single" as const };+ return (+ <DateLikeInput+ key={`${column?.id ?? "_"}-${operator}`}+ filterType={type}+ value={v.value}+ onChange={(next) => onChange({ kind: "date-single", value: next })}+ aria-label="value"+ className="border-input"+ />+ );+ }if (type === "select" && column) {const v = value.kind === "options" ? value : { kind: "options" as const };return (@@ -443,19 +505,18 @@ const ValueSlot = <TData, TValue>({};function getEditableType(value: ColumnFilterValue): EditableFilterType {- if (value.type === "number") {- return "number";- }- if (value.type === "text") {- return "text";- }- if (value.type === "boolean") {- return "boolean";- }- if (value.type === "select") {- return "select";+ switch (value.type) {+ case "number":+ case "text":+ case "boolean":+ case "select":+ case "date":+ case "datetime":+ case "time":+ return value.type;+ default:+ return "text";}- return "text";}function toDraftValue(value: ColumnFilterValue): DraftValue {@@ -486,6 +547,21 @@ function toDraftValue(value: ColumnFilterValue): DraftValue {if (value.type === "select") {return { kind: "options", options: [...value.options] };}+ if (+ value.type === "date" ||+ value.type === "datetime" ||+ value.type === "time"+ ) {+ switch (value.operator) {+ case "between":+ return { kind: "date-between", min: value.min, max: value.max };+ case "is_null":+ case "is_not_null":+ return { kind: "none" };+ default:+ return { kind: "date-single", value: value.value };+ }+ }return { kind: "none" };}@@ -509,6 +585,11 @@ function emptyDraftFor(if (type === "select") {return { kind: "options", options: [] };}+ if (isDateLikeType(type)) {+ return operator === "between"+ ? { kind: "date-between" }+ : { kind: "date-single" };+ }return { kind: "none" };}@@ -516,7 +597,7 @@ function getMissingValueMessage(type: EditableFilterType,operator: OperatorType,): string {- if (type === "number" && operator === "between") {+ if (operator === "between") {return "Min and max are required";}if (type === "text" && (operator === "in" || operator === "not_in")) {@@ -611,5 +692,33 @@ function buildFilterValue({operator: operator === "not_in" ? "not_in" : "in",});}+ if (isDateLikeType(type)) {+ const factory =+ type === "date"+ ? Filter.date+ : type === "datetime"+ ? Filter.datetime+ : Filter.time;+ if (operator === "is_null" || operator === "is_not_null") {+ return factory({ operator });+ }+ if (operator === "between") {+ if (+ draft.kind !== "date-between" ||+ draft.min === undefined ||+ draft.max === undefined+ ) {+ return undefined;+ }+ return factory({ operator: "between", min: draft.min, max: draft.max });+ }+ if (!isDatetimeComparisonOp(operator)) {+ return undefined;+ }+ if (draft.kind !== "date-single" || draft.value === undefined) {+ return undefined;+ }+ return factory({ operator, value: draft.value });+ }return undefined;}diff --git a/frontend/src/components/data-table/filter-pills.tsx b/frontend/src/components/data-table/filter-pills.tsxindex 68a6e57672..8e0b9486b4 100644--- a/frontend/src/components/data-table/filter-pills.tsx+++ b/frontend/src/components/data-table/filter-pills.tsx@@ -12,7 +12,11 @@ import { Badge } from "../ui/badge";import { Button } from "../ui/button";import { Popover, PopoverContent, PopoverTrigger } from "../ui/popover";import { FilterPillEditor } from "./filter-pill-editor";-import type { ColumnFilterValue } from "./filters";+import {+ type ColumnFilterValue,+ dateToISODate,+ dateToISODateTime,+} from "./filters";import { OPERATOR_LABELS } from "./operator-labels";import { stringifyUnknownValue } from "./utils";@@ -82,13 +86,6 @@ const FilterPill = <TData,>({return null;}- // this is temporary, with more operator & datatype support this goes away- const isReadOnly =- "type" in value &&- (value.type === "date" ||- value.type === "datetime" ||- value.type === "time");-const twoSegment = formatted.value === undefined;const handleRemove = (e: React.MouseEvent) => {@@ -130,20 +127,8 @@ const FilterPill = <TData,>({</Button>);- if (isReadOnly) {- return (- <Badge- variant="outline"- className="bg-background border-border text-foreground"- >- {segments}- {removeButton}- </Badge>- );- }-return (- <Popover open={open} onOpenChange={setOpen} modal={true}>+ <Popover open={open} onOpenChange={setOpen} modal={false}><Badgevariant="outline"className={cn(@@ -249,23 +234,31 @@ function formatValue(};}}- if (value.type === "date") {- return formatMinMaxLegacy(- value.min?.toISOString(),- value.max?.toISOString(),- );- }- if (value.type === "time") {- return formatMinMaxLegacy(- value.min ? timeFormatter.format(value.min) : undefined,- value.max ? timeFormatter.format(value.max) : undefined,- );- }- if (value.type === "datetime") {- return formatMinMaxLegacy(- value.min?.toISOString(),- value.max?.toISOString(),- );+ 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"}` };@@ -282,22 +275,3 @@ function formatValue(logNever(value);return undefined;}--function formatMinMaxLegacy(- min: string | number | undefined,- max: string | number | undefined,-): FormattedFilter | undefined {- if (min === undefined && max === undefined) {- return;- }- if (min === max) {- return { operator: "==", value: String(min) };- }- if (min === undefined) {- return { operator: "<=", value: String(max) };- }- if (max === undefined) {- return { operator: ">=", value: String(min) };- }- return { operator: "between", value: `${min} - ${max}` };-}diff --git a/frontend/src/components/data-table/filters.ts b/frontend/src/components/data-table/filters.tsindex 3f7311b3e7..06f78d2c6d 100644--- a/frontend/src/components/data-table/filters.ts+++ b/frontend/src/components/data-table/filters.ts@@ -51,6 +51,15 @@ export const TEXT_SCALAR_OPS = ["ends_with",] as const;+export const DATETIME_COMPARISON_OPS = [+ "==",+ "!=",+ ">",+ ">=",+ "<",+ "<=",+] as const;+export const NUMBER_OPS = ["between",...NUMBER_COMPARISON_OPS,@@ -62,11 +71,26 @@ export const TEXT_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;@@ -83,6 +107,11 @@ type TextFilterOpts =| { 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 objectexport const Filter = {number(opts: NumberFilterOpts) {@@ -97,19 +126,19 @@ export const Filter = {...opts,} as const;},- date(opts: { min?: Date; max?: Date; operator?: OperatorType }) {+ date(opts: DateLikeFilterOpts) {return {type: "date",...opts,} as const;},- datetime(opts: { min?: Date; max?: Date; operator?: OperatorType }) {+ datetime(opts: DateLikeFilterOpts) {return {type: "datetime",...opts,} as const;},- time(opts: { min?: Date; max?: Date; operator?: OperatorType }) {+ time(opts: DateLikeFilterOpts) {return {type: "time",...opts,@@ -135,6 +164,26 @@ 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<@@ -235,71 +284,44 @@ export function filterToFilterCondition(default:assertNever(filter);}- case "datetime": {- const conditions: FilterConditionType[] = [];- if (filter.min !== undefined) {- conditions.push({- column_id: columnId,- operator: ">=",- value: filter.min.toISOString(),- type: "condition",- negate: false,- });- }- if (filter.max !== undefined) {- conditions.push({- column_id: columnId,- operator: "<=",- value: filter.max.toISOString(),- type: "condition",- negate: false,- });- }- return conditions;- }- case "date": {- const conditions: FilterConditionType[] = [];- if (filter.min !== undefined) {- conditions.push({- column_id: columnId,- operator: ">=",- value: filter.min.toISOString(),- type: "condition",- negate: false,- });- }- if (filter.max !== undefined) {- conditions.push({- column_id: columnId,- operator: "<=",- value: filter.max.toISOString(),- type: "condition",- negate: false,- });- }- return conditions;- }+ case "date":+ case "datetime":case "time": {- const conditions: FilterConditionType[] = [];- if (filter.min !== undefined) {- conditions.push({- column_id: columnId,- operator: ">=",- value: filter.min.toISOString(),- type: "condition",- negate: false,- });- }- if (filter.max !== undefined) {- conditions.push({- column_id: columnId,- operator: "<=",- value: filter.max.toISOString(),- type: "condition",- negate: false,- });+ 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);}- return conditions;}case "boolean":if (filter.value) {diff --git a/frontend/src/core/websocket/transports/ws.ts b/frontend/src/core/websocket/transports/ws.tsindex a29e534d71..6dbac4bc7a 100644--- a/frontend/src/core/websocket/transports/ws.ts+++ b/frontend/src/core/websocket/transports/ws.ts@@ -55,7 +55,9 @@ export class WsTransport implements IConnectionTransport {// Match native EventTarget dedupe: a second addEventListener with the// same listener is a no-op. Without this, repeated adds leak wrappers// on the inner socket and double-fire on close.- if (this.closeWrappers.has(userCb)) return;+ if (this.closeWrappers.has(userCb)) {+ return;+ }const wrapper: ConnectionTransportCallback<"close"> = (e) => {if (this.inner.retryCount >= MAX_RETRIES) {userCb(diff --git a/marimo/_plugins/ui/_impl/dataframes/transforms/handlers.py b/marimo/_plugins/ui/_impl/dataframes/transforms/handlers.pyindex 8685fef332..62f3eb2149 100644--- a/marimo/_plugins/ui/_impl/dataframes/transforms/handlers.py+++ b/marimo/_plugins/ui/_impl/dataframes/transforms/handlers.py@@ -66,6 +66,12 @@ def convert_value(v: Any, converter: Callable[[str], Any]) -> Any:Convert a value whether it's a list or single value.Ignore None as they usually raise errors when converted"""+ if isinstance(v, RangeValue):+ return RangeValue(+ min=converter(str(v.min)),+ max=converter(str(v.max)),+ )+if isinstance(v, (tuple, list)):return [converter(str(item)) if item is not None else None for item in vdiff --git a/tests/_plugins/ui/_impl/dataframes/test_handlers.py b/tests/_plugins/ui/_impl/dataframes/test_handlers.pyindex 58735a24ab..cf1b60d507 100644--- a/tests/_plugins/ui/_impl/dataframes/test_handlers.py+++ b/tests/_plugins/ui/_impl/dataframes/test_handlers.py@@ -1,7 +1,7 @@# Copyright 2026 Marimo. All rights reserved.from __future__ import annotations-from datetime import date+from datetime import date, datetime, timefrom decimal import Decimalfrom typing import Any, cast@@ -2759,6 +2759,134 @@ class TestTransformHandler:result = apply(df, transform)assert df_size(result) == 0+ @staticmethod+ @pytest.mark.parametrize(+ ("df", "expected"),+ list(+ zip(+ create_test_dataframes(+ {+ "d": [+ date(2024, 1, 1),+ date(2024, 6, 15),+ date(2024, 12, 31),+ ]+ },+ exclude=["pandas"],+ ),+ create_test_dataframes(+ {"d": [date(2024, 6, 15)]}, exclude=["pandas"]+ ),+ strict=False,+ )+ ),+ )+ def test_filter_between_date_iso_string(+ df: DataFrameType, expected: DataFrameType+ ) -> None:+ transform = FilterRowsTransform(+ type=TransformType.FILTER_ROWS,+ operation="keep_rows",+ where=FilterGroup(+ children=[+ FilterCondition(+ column_id="d",+ operator="between",+ value=RangeValue(min="2024-03-01", max="2024-09-01"),+ )+ ]+ ),+ )+ result = apply(df, transform)+ assert_frame_equal(result, expected)++ @staticmethod+ @pytest.mark.parametrize(+ ("df", "expected"),+ list(+ zip(+ create_test_dataframes(+ {+ "dt": [+ datetime(2024, 1, 1, 0, 0, 0),+ datetime(2024, 6, 15, 12, 30, 0),+ datetime(2024, 12, 31, 23, 59, 59),+ ]+ },+ exclude=["pandas"],+ ),+ create_test_dataframes(+ {"dt": [datetime(2024, 6, 15, 12, 30, 0)]},+ exclude=["pandas"],+ ),+ strict=False,+ )+ ),+ )+ def test_filter_between_datetime_iso_string(+ df: DataFrameType, expected: DataFrameType+ ) -> None:+ transform = FilterRowsTransform(+ type=TransformType.FILTER_ROWS,+ operation="keep_rows",+ where=FilterGroup(+ children=[+ FilterCondition(+ column_id="dt",+ operator="between",+ value=RangeValue(+ min="2024-03-01T00:00:00",+ max="2024-09-01T00:00:00",+ ),+ )+ ]+ ),+ )+ result = apply(df, transform)+ assert_frame_equal(result, expected)++ @staticmethod+ @pytest.mark.parametrize(+ ("df", "expected"),+ list(+ zip(+ create_test_dataframes(+ {+ "t": [+ time(8, 0, 0),+ time(12, 30, 0),+ time(18, 0, 0),+ ]+ },+ exclude=["pandas", "pyarrow", "ibis"],+ ),+ create_test_dataframes(+ {"t": [time(12, 30, 0)]},+ exclude=["pandas", "pyarrow", "ibis"],+ ),+ strict=False,+ )+ ),+ )+ def test_filter_between_time_iso_string(+ df: DataFrameType, expected: DataFrameType+ ) -> None:+ transform = FilterRowsTransform(+ type=TransformType.FILTER_ROWS,+ operation="keep_rows",+ where=FilterGroup(+ children=[+ FilterCondition(+ column_id="t",+ operator="between",+ value=RangeValue(min="10:00:00", max="15:00:00"),+ )+ ]+ ),+ )+ result = apply(df, transform)+ assert_frame_equal(result, expected)+# --- is_empty operator ---@staticmethod