@marimo-team/islands 0.25.3-dev31 → 0.25.3-dev310

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

@@ -14,6 +14,7 @@ import {
   renderCellValue,
 } from "../columns";
 import { getMimeValues, isMimeValue, MimeCell } from "../mime-cell";
+import { buildHighlightPattern } from "../search-highlight";
 import type { FieldTypesWithExternalType } from "../types";
 import { uniformSample } from "../uniformSample";
 import { UrlDetector } from "../url-detector";
@@ -240,6 +241,7 @@ describe("generateColumns", () => {
     // "age" is a number column — should auto right-align
     // oxlint-disable-next-line typescript/no-explicit-any
     const cell = (columns[1].cell as any)({
+      table: { options: { meta: {} } },
       column: {
         columnDef: columns[1],
       },
@@ -251,6 +253,7 @@ describe("generateColumns", () => {
     // "name" is a string column — should remain left-aligned
     // oxlint-disable-next-line typescript/no-explicit-any
     const nameCell = (columns[0].cell as any)({
+      table: { options: { meta: {} } },
       column: {
         columnDef: columns[0],
       },
@@ -271,6 +274,7 @@ describe("generateColumns", () => {
     // "age" is numeric but explicitly set to left
     // oxlint-disable-next-line typescript/no-explicit-any
     const cell = (columns[1].cell as any)({
+      table: { options: { meta: {} } },
       column: {
         columnDef: columns[1],
       },
@@ -311,6 +315,7 @@ describe("generateColumns", () => {
     // Assuming getCellStyleClass is a function that returns a class name
     // oxlint-disable-next-line typescript/no-explicit-any
     const cell = (columns[0].cell as any)({
+      table: { options: { meta: {} } },
       column: {
         columnDef: columns[0],
       },
@@ -1359,3 +1364,103 @@ test("column_widths sets fixed size and meta.width", () => {
   expect(b?.size).toBeUndefined();
   expect(b?.meta?.width).toBeUndefined();
 });
+
+describe("renderCellValue with highlightPattern", () => {
+  const createColumn = (
+    dataType: "string" | "number" | "boolean" | "date",
+    dtype = "object",
+  ) =>
+    ({
+      id: "col",
+      columnDef: { meta: { dataType, dtype } },
+      getColumnFormatting: () => undefined,
+      getColumnWrapping: () => undefined,
+      applyColumnFormatting: (value: unknown) => value,
+    }) as unknown as Column<unknown>;
+
+  const renderCell = (
+    column: Column<unknown>,
+    value: unknown,
+    highlightQuery: string,
+  ) =>
+    render(
+      <I18nProvider locale="en-US">
+        <TooltipProvider>
+          {renderCellValue({
+            column,
+            renderValue: () => value,
+            getValue: () => value,
+            selectCell: undefined,
+            cellStyles: "",
+            highlightPattern: buildHighlightPattern(highlightQuery),
+          })}
+        </TooltipProvider>
+      </I18nProvider>,
+    );
+
+  const markTexts = (container: HTMLElement) =>
+    [...container.querySelectorAll("mark")].map((m) => m.textContent);
+
+  it("marks a match in a string cell", () => {
+    const { container } = renderCell(
+      createColumn("string"),
+      "Alice Smith",
+      "smi",
+    );
+    expect(markTexts(container)).toEqual(["Smi"]);
+  });
+
+  it("marks only the middle text when the string has edge whitespace", () => {
+    const { container } = renderCell(createColumn("string"), "  a b  ", " ");
+    expect(markTexts(container)).toEqual([" "]);
+    const edgeMarkers = container.querySelectorAll("span[aria-label]");
+    expect(edgeMarkers).toHaveLength(2);
+    for (const marker of edgeMarkers) {
+      expect(marker.querySelector("mark")).toBeNull();
+    }
+  });
+
+  it("marks a match in the locale display of a number", () => {
+    const { container } = renderCell(createColumn("number"), 1234.5, "234");
+    expect(markTexts(container)).toEqual(["234"]);
+    expect(container.textContent).toBe("1,234.5");
+  });
+
+  it("does not mark a number when the locale display hides the raw match", () => {
+    const { container } = renderCell(createColumn("number"), 1234, "1234");
+    expect(markTexts(container)).toEqual([]);
+    expect(container.textContent).toBe("1,234");
+  });
+
+  it("marks a boolean cell", () => {
+    const { container } = renderCell(createColumn("boolean"), false, "false");
+    expect(markTexts(container)).toEqual(["False"]);
+  });
+
+  it("marks a date cell by its display string", () => {
+    const { container } = renderCell(
+      createColumn("date", "date"),
+      new Date(2026, 0, 15),
+      "2026",
+    );
+    expect(markTexts(container)).toEqual(["2026"]);
+  });
+
+  it("renders no mark for an empty query", () => {
+    for (const [column, value] of [
+      [createColumn("string"), "Alice"],
+      [createColumn("number"), 12],
+      [createColumn("boolean"), false],
+      [createColumn("date", "date"), new Date(2026, 0, 15)],
+    ] as const) {
+      const { container } = renderCell(column, value, "");
+      expect(markTexts(container)).toEqual([]);
+    }
+  });
+
+  it("renders no mark in the trigger of a long-string popout", () => {
+    const value = "x".repeat(60);
+    const { container } = renderCell(createColumn("string"), value, "xxx");
+    expect(markTexts(container)).toEqual([]);
+  });
+});

package/src/components/data-table/__tests__/context-menu-interaction.test.tsx

@@ -0,0 +1,130 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { type Cell, createTable, getCoreRowModel } from "@tanstack/react-table";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { useRef } from "react";
+import { expect, it, vi } from "vitest";
+import { SetupMocks } from "@/__mocks__/common";
+import { DataTableContextMenu } from "../context-menu";
+
+SetupMocks.resizeObserver();
+
+const rows = [{ value: "first" }, { value: "second" }];
+const columns = [
+  { accessorKey: "value", meta: { filterType: "text" as const } },
+];
+
+function createCells() {
+  const table = createTable({
+    data: rows,
+    columns,
+    locale: "en-US",
+    getCoreRowModel: getCoreRowModel(),
+    onColumnFiltersChange: () => undefined,
+    state: {},
+    onStateChange: () => undefined,
+    renderFallbackValue: null,
+  });
+  return table.getRowModel().rows.map((row) => row.getAllCells()[0]);
+}
+
+function Harness({ cells }: { cells: Cell<(typeof rows)[number], unknown>[] }) {
+  const contextMenuRef = useRef<Cell<(typeof rows)[number], unknown> | null>(
+    null,
+  );
+  const tableRef = useRef<HTMLTableSectionElement>(null);
+  const tableBody = (
+    <tbody ref={tableRef}>
+      <tr>
+        <td>empty</td>
+      </tr>
+      {cells.map((cell) => {
+        return (
+          <tr key={cell.id}>
+            <td
+              data-cell-id={cell.id}
+              onContextMenu={() => {
+                contextMenuRef.current = cell;
+              }}
+            >
+              {String(cell.getValue())}
+            </td>
+          </tr>
+        );
+      })}
+    </tbody>
+  );
+  return (
+    <table>
+      <DataTableContextMenu
+        contextMenuRef={contextMenuRef}
+        tableRef={tableRef}
+        tableBody={tableBody}
+        copyAllCells={() => undefined}
+      />
+    </table>
+  );
+}
+
+it("filters the latest right-clicked cell when the menu is already open", () => {
+  const onFilter = vi.fn();
+  const table = createTable({
+    data: rows,
+    columns,
+    locale: "en-US",
+    getCoreRowModel: getCoreRowModel(),
+    onColumnFiltersChange: onFilter,
+    state: {},
+    onStateChange: () => undefined,
+    renderFallbackValue: null,
+  });
+  render(
+    <Harness
+      cells={table.getRowModel().rows.map((row) => row.getAllCells()[0])}
+    />,
+  );
+
+  const firstCell = screen.getByText("first");
+  const secondCell = screen.getByText("second");
+  fireEvent.contextMenu(firstCell);
+  expect(firstCell).toHaveClass("bg-(--green-4)");
+  expect(
+    screen.getByRole("menuitem", { name: "Filter by this value" }),
+  ).toBeInTheDocument();
+  fireEvent.contextMenu(secondCell);
+  expect(firstCell).not.toHaveClass("bg-(--green-4)");
+  expect(secondCell).toHaveClass("bg-(--green-4)");
+  fireEvent.click(
+    screen.getByRole("menuitem", { name: "Filter by this value" }),
+  );
+  expect(firstCell).not.toHaveClass("bg-(--green-4)");
+  expect(secondCell).not.toHaveClass("bg-(--green-4)");
+
+  const update = onFilter.mock.calls.at(-1)?.[0];
+  expect(update([])).toEqual([
+    {
+      id: "value",
+      value: { type: "text", operator: "equals", text: "second" },
+    },
+  ]);
+});
+
+it("does not reuse a previous cell after the menu closes", () => {
+  render(<Harness cells={createCells()} />);
+
+  const firstCell = screen.getByText("first");
+  fireEvent.contextMenu(firstCell);
+  expect(firstCell).toHaveClass("bg-(--green-4)");
+  fireEvent.keyDown(document.activeElement ?? document.body, {
+    key: "Escape",
+  });
+  expect(firstCell).not.toHaveClass("bg-(--green-4)");
+  expect(screen.queryByRole("menu")).not.toBeInTheDocument();
+
+  // Right-clicking outside any data cell must not resurrect the old one
+  fireEvent.contextMenu(screen.getByText("empty"));
+  expect(firstCell).not.toHaveClass("bg-(--green-4)");
+  expect(
+    screen.queryByRole("menuitem", { name: "Filter by this value" }),
+  ).not.toBeInTheDocument();
+});

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

@@ -260,6 +260,7 @@ describe("DataTable", () => {
     );
 
     const cells = within(screen.getAllByRole("row")[1]).getAllByRole("cell");
+    cells[1].scrollIntoView = vi.fn();
     // Start a pending hover-show on cell A, then focus cell B before it fires.
     fireEvent.mouseOver(cells[0], { buttons: 0 });
     fireEvent.focus(cells[1]);

package/src/components/data-table/__tests__/date-popover.test.tsx

@@ -0,0 +1,72 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { render, screen } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { I18nProvider } from "react-aria";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { DatePopover } from "../date-popover";
+
+vi.mock("@/components/ui/tooltip", () => ({
+  Tooltip: ({ content }: { content: ReactNode }) => content,
+}));
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("DatePopover", () => {
+  it.each([0, 123])(
+    "updates the local timezone and time on rerender with %i milliseconds",
+    (milliseconds) => {
+      const NativeDateTimeFormat = Intl.DateTimeFormat;
+      let systemTimezone = "America/Los_Angeles";
+      vi.spyOn(Intl, "DateTimeFormat").mockImplementation(
+        function (locales, options) {
+          return new NativeDateTimeFormat(locales, {
+            ...options,
+            timeZone: options?.timeZone ?? systemTimezone,
+          });
+        },
+      );
+
+      const date = new Date("2026-01-15T12:00:00Z");
+      date.setUTCMilliseconds(milliseconds);
+      const content = () => (
+        <I18nProvider locale="en-US">
+          <DatePopover date={date} type="datetime">
+            timestamp
+          </DatePopover>
+        </I18nProvider>
+      );
+      const { rerender } = render(content());
+      const previousTime =
+        screen.getByText(systemTimezone).nextElementSibling?.textContent;
+      const utcTime = screen.getByText("UTC").nextElementSibling?.textContent;
+
+      systemTimezone = "Asia/Tokyo";
+      rerender(content());
+
+      const expected = new NativeDateTimeFormat("en-US", {
+        timeZone: systemTimezone,
+        ...(milliseconds
+          ? {
+              year: "numeric",
+              month: "2-digit",
+              day: "2-digit",
+              hour: "2-digit",
+              minute: "2-digit",
+              second: "2-digit",
+              fractionalSecondDigits: 3,
+            }
+          : { dateStyle: "long", timeStyle: "medium" }),
+      }).format(date);
+      expect(screen.queryByText("America/Los_Angeles")).toBeNull();
+      expect(
+        screen.getByText(systemTimezone).nextElementSibling?.textContent,
+      ).toBe(expected);
+      expect(expected).not.toBe(previousTime);
+      expect(screen.getByText("UTC").nextElementSibling?.textContent).toBe(
+        utcTime,
+      );
+    },
+  );
+});

package/src/components/data-table/__tests__/export-actions.test.tsx

@@ -531,6 +531,23 @@ describe("ExportActions dialog", () => {
     expect(downloadByURL).not.toHaveBeenCalled();
   });
 
+  it("does not revive an earlier source failure when switching back", async () => {
+    downloadAs.mockRejectedValueOnce(new Error("First source failed"));
+    const { rerenderExportActions } = renderExportActions({
+      metadataSource: "first",
+    });
+    await openDialog();
+    fireEvent.click(screen.getByRole("button", { name: "Download CSV" }));
+    expect(await screen.findByRole("alert")).toHaveTextContent(
+      "First source failed",
+    );
+
+    rerenderExportActions({ metadataSource: "second" });
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+    rerenderExportActions({ metadataSource: "first" });
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+  });
+
   async function startGeoParquetInstall(strictMode = false) {
     const getExportMetadata = vi.fn().mockResolvedValue(geometryMetadata);
     downloadAs.mockResolvedValueOnce({
@@ -914,6 +931,94 @@ describe("ExportActions dialog", () => {
     expect(within(dialog).queryByRole("group")).not.toBeInTheDocument();
   });
 
+  it("describes format options with their description and current settings", async () => {
+    renderExportActions({
+      getExportMetadata: vi.fn().mockResolvedValue(geometryMetadata),
+    });
+    await openDialog();
+    await screen.findByRole("button", { name: "GeoParquet options" });
+
+    for (const [label, description] of [
+      ["CSV", "Comma-separated values Comma · UTF-8"],
+      ["TSV", "Best for Excel and Google Sheets UTF-8"],
+      ["JSON", "Raw JSON data Escapes non-ASCII"],
+      ["GeoParquet", "Parquet with geometry and CRS metadata location"],
+      ["GeoJSON", "Geometry in longitude and latitude location"],
+    ]) {
+      expect(
+        screen.getByRole("button", { name: `${label} options` }),
+      ).toHaveAccessibleDescription(description);
+    }
+
+    const csvOptions = screen.getByRole("button", { name: "CSV options" });
+    fireEvent.click(csvOptions);
+    fireEvent.change(screen.getByRole("combobox", { name: "Delimiter" }), {
+      target: { value: ";" },
+    });
+    expect(csvOptions).toHaveAccessibleDescription(
+      "Comma-separated values Semicolon · UTF-8",
+    );
+    fireEvent.click(csvOptions);
+    expect(csvOptions).toHaveAccessibleDescription(
+      "Comma-separated values Semicolon · UTF-8",
+    );
+  });
+
+  it.each([
+    ["CSV", "Comma-separated values"],
+    ["TSV", "Best for Excel and Google Sheets"],
+    ["JSON", "Raw JSON data"],
+    ["GeoParquet", "Parquet with geometry and CRS metadata"],
+    ["GeoJSON", "Geometry in longitude and latitude"],
+  ])(
+    "toggles %s options from the row label and description",
+    async (label, description) => {
+      renderExportActions({
+        getExportMetadata: vi.fn().mockResolvedValue(geometryMetadata),
+      });
+      await openDialog();
+      const toggle = await screen.findByRole("button", {
+        name: `${label} options`,
+      });
+
+      fireEvent.click(screen.getByText(label));
+      expect(toggle).toHaveAttribute("aria-expanded", "true");
+      expect(
+        screen.getByRole("group", { name: `${label} options` }),
+      ).toBeInTheDocument();
+
+      fireEvent.click(screen.getByText(description));
+      expect(toggle).toHaveAttribute("aria-expanded", "false");
+      expect(
+        screen.queryByRole("group", { name: `${label} options` }),
+      ).not.toBeInTheDocument();
+    },
+  );
+
+  it("keeps download and copy independent of row expansion", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        text: vi.fn().mockResolvedValue("name,value\n"),
+      }),
+    );
+    renderExportActions();
+    await openDialog();
+    const toggle = screen.getByRole("button", { name: "CSV options" });
+
+    fireEvent.click(screen.getByRole("button", { name: "Download CSV" }));
+    await waitFor(() => expect(downloadByURL).toHaveBeenCalled());
+    expect(toggle).toHaveAttribute("aria-expanded", "false");
+
+    fireEvent.click(screen.getByText("CSV"));
+    fireEvent.click(screen.getByRole("button", { name: "Copy CSV" }));
+    expect(toggle).toHaveAttribute("aria-expanded", "true");
+    await waitFor(() => {
+      expect(copyToClipboard).toHaveBeenCalledWith("name,value\n");
+    });
+  });
+
   it("sends only changed CSV options with a download", async () => {
     renderExportActions();
     await openDialog();

package/src/components/data-table/__tests__/keyboard-selection.test.tsx

@@ -0,0 +1,188 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { act, fireEvent, render, screen, within } from "@testing-library/react";
+import { useState } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import { copyToClipboard } from "@/utils/copy";
+import type { CellSelectionState } from "../cell-selection/types";
+import { DataTable } from "../data-table";
+
+vi.mock("@/utils/copy", () => ({ copyToClipboard: vi.fn() }));
+
+function SelectableTable({ multiple = false }: { multiple?: boolean }) {
+  const [selection, setSelection] = useState<CellSelectionState>([]);
+  return (
+    <TooltipProvider>
+      <DataTable
+        data={[{ name: "Alice" }, { name: "Bob" }]}
+        columns={[{ accessorKey: "name", header: "Name" }]}
+        totalRows={2}
+        totalColumns={1}
+        pagination={false}
+        selection={multiple ? "multi-cell" : "single-cell"}
+        cellSelection={selection}
+        onCellSelectionChange={setSelection}
+      />
+    </TooltipProvider>
+  );
+}
+
+describe("table keyboard access", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it("includes the initial focused cell when extending a keyboard range", () => {
+    render(<SelectableTable />);
+    const [alice, bob] = screen.getAllByRole("gridcell");
+    act(() => alice.focus());
+    fireEvent.keyDown(alice, { key: "ArrowDown", shiftKey: true });
+    fireEvent.keyDown(bob, { key: "c", ctrlKey: true });
+    expect(copyToClipboard).toHaveBeenLastCalledWith("Alice\nBob", undefined);
+    fireEvent.keyDown(bob, { key: "ArrowUp", shiftKey: true });
+    fireEvent.keyDown(alice, { key: "c", ctrlKey: true });
+    expect(copyToClipboard).toHaveBeenLastCalledWith("Alice", undefined);
+  });
+
+  it.each(["Enter", " "])(
+    "copies the activated cell with %s, including after an older selection",
+    (key) => {
+      render(<SelectableTable />);
+      const [alice, bob] = screen.getAllByRole("gridcell");
+      for (const [cell, value] of [
+        [alice, "Alice"],
+        [bob, "Bob"],
+      ] as const) {
+        act(() => cell.focus());
+        fireEvent.keyDown(cell, { key });
+        fireEvent.keyDown(cell, { key: "c", ctrlKey: true });
+        expect(copyToClipboard).toHaveBeenLastCalledWith(value, undefined);
+        expect(cell).toHaveAttribute("aria-selected", "true");
+      }
+    },
+  );
+
+  it("moves focus and activation together inside a shadow root", () => {
+    vi.useFakeTimers();
+    const host = document.createElement("div");
+    document.body.append(host);
+    const shadow = host.attachShadow({ mode: "open" });
+    const container = document.createElement("div");
+    shadow.append(container);
+    const view = render(<SelectableTable />, { container });
+    try {
+      const [alice, bob] = within(container).getAllByRole("gridcell");
+      alice.scrollIntoView = vi.fn();
+      bob.scrollIntoView = vi.fn();
+      act(() => alice.focus());
+      fireEvent.keyDown(alice, { key: "ArrowDown" });
+      act(() => vi.runAllTimers());
+      expect(shadow.activeElement).toBe(bob);
+      fireEvent.keyDown(bob, { key: " " });
+      expect(bob).toHaveAttribute("aria-selected", "true");
+      expect(alice).toHaveAttribute("aria-selected", "false");
+    } finally {
+      view.unmount();
+      host.remove();
+    }
+  });
+
+  it("does not move focus away from a nested control after navigation", () => {
+    vi.useFakeTimers();
+    render(<SelectableTable />);
+    const [alice, bob] = screen.getAllByRole("gridcell");
+    alice.scrollIntoView = vi.fn();
+    bob.scrollIntoView = vi.fn();
+    const button = document.createElement("button");
+    alice.append(button);
+    act(() => alice.focus());
+    fireEvent.keyDown(alice, { key: "ArrowDown" });
+    act(() => {
+      button.focus();
+      vi.runAllTimers();
+    });
+    expect(button).toHaveFocus();
+  });
+
+  it("ignores stale scheduled focus when moving between cells", () => {
+    vi.useFakeTimers();
+    render(<SelectableTable />);
+    const [alice, bob] = screen.getAllByRole("gridcell");
+    alice.scrollIntoView = vi.fn();
+    bob.scrollIntoView = vi.fn();
+    act(() => {
+      alice.focus();
+      bob.focus();
+      vi.runAllTimers();
+    });
+    expect(bob).toHaveFocus();
+    expect(alice.scrollIntoView).not.toHaveBeenCalled();
+    expect(bob.scrollIntoView).toHaveBeenCalledOnce();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+  it.each([false, true])(
+    "selects focused cells without a preceding click (multiple=%s)",
+    (multiple) => {
+      render(<SelectableTable multiple={multiple} />);
+      const [alice, bob] = screen.getAllByRole("gridcell");
+      alice.focus();
+      fireEvent.keyDown(alice, { key: "Enter" });
+      expect(alice).toHaveAttribute("aria-selected", "true");
+      bob.focus();
+      fireEvent.keyDown(bob, { key: " " });
+      expect(bob).toHaveAttribute("aria-selected", "true");
+      expect(alice).toHaveAttribute("aria-selected", String(multiple));
+      fireEvent.keyDown(bob, { key: " " });
+      expect(bob).toHaveAttribute("aria-selected", "false");
+    },
+  );
+
+  it("does not intercept keys from embedded buttons", () => {
+    const select = vi.fn();
+    render(
+      <TooltipProvider>
+        <DataTable
+          data={[{ name: "Alice" }]}
+          columns={[
+            {
+              accessorKey: "name",
+              cell: () => <button type="button">Open person</button>,
+            },
+          ]}
+          totalRows={1}
+          totalColumns={1}
+          pagination={false}
+          selection="single-cell"
+          onCellSelectionChange={select}
+        />
+      </TooltipProvider>,
+    );
+    const button = screen.getByRole("button", { name: "Open person" });
+    for (const key of ["Enter", " ", "ArrowDown"]) {
+      expect(fireEvent.keyDown(button, { key })).toBe(true);
+    }
+    expect(select).not.toHaveBeenCalled();
+  });
+
+  it("names search controls and clears a query", () => {
+    render(
+      <TooltipProvider>
+        <DataTable
+          data={[{ name: "Alice" }]}
+          columns={[{ accessorKey: "name" }]}
+          totalRows={1}
+          totalColumns={1}
+          pagination={false}
+          showSearch={true}
+          onSearchQueryChange={vi.fn()}
+        />
+      </TooltipProvider>,
+    );
+    const search = screen.getByRole("textbox", { name: "Search table" });
+    fireEvent.change(search, { target: { value: "Alice" } });
+    fireEvent.click(screen.getByRole("button", { name: "Clear table search" }));
+    expect(search).toHaveValue("");
+  });
+});