@marimo-team/frontend 0.23.2-dev2 → 0.23.2-dev21

package/src/components/data-table/__tests__/filters.test.ts

@@ -0,0 +1,304 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { describe, expect, it } from "vitest";
+import {
+  filterToFilterCondition,
+  filtersToFilterGroup,
+  Filter,
+} from "../filters";
+import {
+  FilterConditionSchema,
+  FilterGroupSchema,
+} from "@/plugins/impl/data-frames/schema";
+
+describe("filterToFilterCondition", () => {
+  it("returns empty array for undefined filter", () => {
+    expect(filterToFilterCondition("col", undefined)).toEqual([]);
+  });
+
+  it("handles is_null filter", () => {
+    const result = filterToFilterCondition(
+      "col",
+      Filter.number({ operator: "is_null" }),
+    );
+    expect(result).toEqual([
+      {
+        column_id: "col",
+        operator: "is_null",
+        value: undefined,
+        type: "condition",
+        negate: false,
+      },
+    ]);
+  });
+
+  it("handles is_not_null filter", () => {
+    const result = filterToFilterCondition(
+      "col",
+      Filter.number({ operator: "is_not_null" }),
+    );
+    expect(result).toEqual([
+      {
+        column_id: "col",
+        operator: "is_not_null",
+        value: undefined,
+        type: "condition",
+        negate: false,
+      },
+    ]);
+  });
+
+  it("handles number filter with min only", () => {
+    const result = filterToFilterCondition("age", Filter.number({ min: 18 }));
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      column_id: "age",
+      operator: ">=",
+      value: 18,
+      type: "condition",
+      negate: false,
+    });
+  });
+
+  it("handles number filter with max only", () => {
+    const result = filterToFilterCondition("age", Filter.number({ max: 65 }));
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      column_id: "age",
+      operator: "<=",
+      value: 65,
+      type: "condition",
+      negate: false,
+    });
+  });
+
+  it("handles number filter with min and max", () => {
+    const result = filterToFilterCondition(
+      "age",
+      Filter.number({ min: 18, max: 65 }),
+    );
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({ operator: ">=", value: 18 });
+    expect(result[1]).toMatchObject({ operator: "<=", value: 65 });
+  });
+
+  it("handles text filter", () => {
+    const result = filterToFilterCondition(
+      "name",
+      Filter.text({ text: "foo", operator: "contains" }),
+    );
+    expect(result).toEqual([
+      {
+        column_id: "name",
+        operator: "contains",
+        value: "foo",
+        type: "condition",
+        negate: false,
+      },
+    ]);
+  });
+
+  it("handles boolean true filter", () => {
+    const result = filterToFilterCondition(
+      "active",
+      Filter.boolean({ value: true }),
+    );
+    expect(result).toEqual([
+      {
+        column_id: "active",
+        operator: "is_true",
+        value: undefined,
+        type: "condition",
+        negate: false,
+      },
+    ]);
+  });
+
+  it("handles boolean false filter", () => {
+    const result = filterToFilterCondition(
+      "active",
+      Filter.boolean({ value: false }),
+    );
+    expect(result).toEqual([
+      {
+        column_id: "active",
+        operator: "is_false",
+        value: undefined,
+        type: "condition",
+        negate: false,
+      },
+    ]);
+  });
+
+  it("handles select in filter", () => {
+    const result = filterToFilterCondition(
+      "status",
+      Filter.select({ options: ["a", "b"], operator: "in" }),
+    );
+    expect(result).toEqual([
+      {
+        column_id: "status",
+        operator: "in",
+        value: ["a", "b"],
+        type: "condition",
+        negate: false,
+      },
+    ]);
+  });
+
+  it("handles date filter with min and max", () => {
+    const min = new Date("2024-01-01");
+    const max = new Date("2024-12-31");
+    const result = filterToFilterCondition(
+      "created",
+      Filter.date({ min, max }),
+    );
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({
+      operator: ">=",
+      value: min.toISOString(),
+    });
+    expect(result[1]).toMatchObject({
+      operator: "<=",
+      value: max.toISOString(),
+    });
+  });
+
+  it("every condition has type and negate fields", () => {
+    const result = filterToFilterCondition(
+      "col",
+      Filter.number({ min: 1, max: 10 }),
+    );
+    for (const condition of result) {
+      expect(condition).toHaveProperty("type", "condition");
+      expect(condition).toHaveProperty("negate", false);
+    }
+  });
+});
+
+describe("filtersToFilterGroup", () => {
+  it("returns empty AND group for no filters", () => {
+    const result = filtersToFilterGroup([]);
+    expect(result).toEqual({
+      type: "group",
+      operator: "and",
+      children: [],
+      negate: false,
+    });
+  });
+
+  it("wraps single filter in AND group", () => {
+    const result = filtersToFilterGroup([
+      { id: "age", value: Filter.number({ min: 18 }) },
+    ]);
+    expect(result.type).toBe("group");
+    expect(result.operator).toBe("and");
+    expect(result.negate).toBe(false);
+    expect(result.children).toHaveLength(1);
+  });
+
+  it("wraps multiple filters in AND group", () => {
+    const result = filtersToFilterGroup([
+      { id: "age", value: Filter.number({ min: 18 }) },
+      { id: "name", value: Filter.text({ text: "foo", operator: "contains" }) },
+    ]);
+    expect(result.children).toHaveLength(2);
+    expect(result.operator).toBe("and");
+  });
+
+  it("flattens multi-condition filters", () => {
+    const result = filtersToFilterGroup([
+      { id: "age", value: Filter.number({ min: 18, max: 65 }) },
+    ]);
+    // min + max = 2 conditions
+    expect(result.children).toHaveLength(2);
+  });
+});
+
+describe("schema validation", () => {
+  it("FilterConditionSchema accepts valid condition", () => {
+    const result = FilterConditionSchema.safeParse({
+      column_id: "age",
+      operator: ">=",
+      value: 18,
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.type).toBe("condition");
+      expect(result.data.negate).toBe(false);
+    }
+  });
+
+  it("FilterConditionSchema defaults type and negate", () => {
+    const result = FilterConditionSchema.safeParse({
+      column_id: "age",
+      operator: "==",
+      value: 5,
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.type).toBe("condition");
+      expect(result.data.negate).toBe(false);
+    }
+  });
+
+  it("FilterConditionSchema accepts negate=true", () => {
+    const result = FilterConditionSchema.safeParse({
+      column_id: "age",
+      operator: "==",
+      value: 5,
+      negate: true,
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.negate).toBe(true);
+    }
+  });
+
+  it("FilterGroupSchema accepts valid group", () => {
+    const result = FilterGroupSchema.safeParse({
+      type: "group",
+      operator: "and",
+      children: [{ column_id: "age", operator: ">=", value: 18 }],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("FilterGroupSchema accepts nested groups", () => {
+    const result = FilterGroupSchema.safeParse({
+      type: "group",
+      operator: "or",
+      children: [
+        {
+          type: "group",
+          operator: "and",
+          children: [
+            { column_id: "a", operator: "==", value: 1 },
+            { column_id: "b", operator: ">", value: 2 },
+          ],
+        },
+        { column_id: "c", operator: "==", value: 3 },
+      ],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("FilterGroupSchema rejects invalid operator", () => {
+    const result = FilterGroupSchema.safeParse({
+      type: "group",
+      operator: "xor",
+      children: [],
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("FilterGroupSchema defaults fields", () => {
+    const result = FilterGroupSchema.safeParse({});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.type).toBe("group");
+      expect(result.data.operator).toBe("and");
+      expect(result.data.children).toEqual([]);
+      expect(result.data.negate).toBe(false);
+    }
+  });
+});

package/src/components/data-table/__tests__/pagination.test.tsx

@@ -1,144 +1,58 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { expect, test } from "vitest";
-import { getPageRanges } from "../pagination";
-import type { PageRange } from "../types";
+import { matchingPageRanges } from "../pagination";
 
-function getLabels(currentPage: number): string[] {
-  const ranges = getPageRanges(currentPage, 200);
-  return ranges.map((item: PageRange) =>
-    item.type === "ellipsis" ? "..." : String(item.page),
-  );
-}
+test("empty prefix returns no ranges", () => {
+  expect(matchingPageRanges("", 500)).toEqual([]);
+});
+
+test("zero prefix returns no ranges", () => {
+  expect(matchingPageRanges("0", 500)).toEqual([]);
+});
 
-test("pagination start / middle / end", () => {
-  expect(getLabels(1)).toMatchInlineSnapshot(`
-    [
-      "1",
-      "2",
-      "3",
-      "4",
-      "5",
-      "6",
-      "7",
-      "8",
-      "9",
-      "10",
-      "...",
-      "96",
-      "97",
-      "98",
-      "99",
-      "100",
-      "101",
-      "102",
-      "103",
-      "104",
-      "105",
-      "...",
-      "191",
-      "192",
-      "193",
-      "194",
-      "195",
-      "196",
-      "197",
-      "198",
-      "199",
-      "200",
-    ]
-  `);
+test("leading-zero prefix returns no ranges", () => {
+  expect(matchingPageRanges("01", 500)).toEqual([]);
+});
+
+test("single digit prefix", () => {
+  expect(matchingPageRanges("5", 500)).toEqual([
+    [5, 5],
+    [50, 59],
+    [500, 500],
+  ]);
+});
 
-  // all fall in the top/middle/bottom 10
-  expect(getLabels(1)).toEqual(getLabels(10));
-  expect(getLabels(96)).toEqual(getLabels(105));
-  expect(getLabels(191)).toEqual(getLabels(200));
+test("single digit prefix with exact totalPages boundary", () => {
+  expect(matchingPageRanges("5", 55)).toEqual([
+    [5, 5],
+    [50, 55],
+  ]);
+});
+
+test("multi-digit prefix", () => {
+  expect(matchingPageRanges("12", 5000)).toEqual([
+    [12, 12],
+    [120, 129],
+    [1200, 1299],
+  ]);
+});
+
+test("prefix larger than totalPages returns no ranges", () => {
+  expect(matchingPageRanges("999", 100)).toEqual([]);
+});
 
-  // Check off by one
-  expect(getLabels(1)).not.toEqual(getLabels(11));
-  expect(getLabels(1)).not.toEqual(getLabels(95));
-  expect(getLabels(1)).not.toEqual(getLabels(106));
-  expect(getLabels(1)).not.toEqual(getLabels(190));
+test("prefix equal to totalPages", () => {
+  expect(matchingPageRanges("100", 100)).toEqual([[100, 100]]);
 });
 
-test("pagination lower middle", () => {
-  expect(getLabels(50)).toMatchInlineSnapshot(`
-    [
-      "1",
-      "2",
-      "3",
-      "4",
-      "5",
-      "6",
-      "7",
-      "8",
-      "9",
-      "10",
-      "...",
-      "50",
-      "...",
-      "96",
-      "97",
-      "98",
-      "99",
-      "100",
-      "101",
-      "102",
-      "103",
-      "104",
-      "105",
-      "...",
-      "191",
-      "192",
-      "193",
-      "194",
-      "195",
-      "196",
-      "197",
-      "198",
-      "199",
-      "200",
-    ]
-  `);
+test("prefix 1 with small totalPages", () => {
+  expect(matchingPageRanges("1", 10)).toEqual([
+    [1, 1],
+    [10, 10],
+  ]);
 });
 
-test("pagination upper middle", () => {
-  expect(getLabels(150)).toMatchInlineSnapshot(`
-    [
-      "1",
-      "2",
-      "3",
-      "4",
-      "5",
-      "6",
-      "7",
-      "8",
-      "9",
-      "10",
-      "...",
-      "96",
-      "97",
-      "98",
-      "99",
-      "100",
-      "101",
-      "102",
-      "103",
-      "104",
-      "105",
-      "...",
-      "150",
-      "...",
-      "191",
-      "192",
-      "193",
-      "194",
-      "195",
-      "196",
-      "197",
-      "198",
-      "199",
-      "200",
-    ]
-  `);
+test("prefix 1 with totalPages=1", () => {
+  expect(matchingPageRanges("1", 1)).toEqual([[1, 1]]);
 });

package/src/components/data-table/column-explorer-panel/column-explorer.tsx

@@ -74,7 +74,7 @@ export const ColumnExplorerPanel = ({
   return (
     <div className="mb-3">
       <span className="text-xs font-semibold ml-2 flex">
-        {prettifyRowColumnCount(totalRows, totalColumns, locale)}
+        {prettifyRowColumnCount({ numRows: totalRows, totalColumns, locale })}
         <CopyClipboardIcon
           tooltip="Copy column names"
           value={columns?.map(([columnName]) => columnName).join(",\n") || ""}