Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

fix(tables): keep row resizing out of expensive cell renders (#18536)

Nikita Kabardin44eaf9df3f1f
diff --git a/web/src/components/table/DataTable.stories.tsx b/web/src/components/table/DataTable.stories.tsx
index b6cf966d2b..c3e1aa0cc1 100644
--- a/web/src/components/table/DataTable.stories.tsx
+++ b/web/src/components/table/DataTable.stories.tsx
@@ -1,7 +1,7 @@
/* eslint-disable no-nested-ternary */
import preview from "../../../.storybook/preview";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { expect, fn } from "storybook/test";
+import { expect, fireEvent, fn } from "storybook/test";
import {
type OnChangeFn,
type PaginationState,
@@ -18,6 +18,7 @@ import { type LangfuseColumnDef } from "@/src/components/table/types";
import {
resolveRowHeightRendering,
useRowHeightRendering,
+ type CustomHeights,
type RowHeight,
} from "@/src/components/table/data-table-row-height-switch";
import { Badge } from "@/src/components/ui/badge";
@@ -1530,3 +1531,486 @@ export const TestManualIOCellBackground = meta.story({
await expect(row.cells[outputIndex]).toHaveClass("bg-surface-output");
},
});
+
+function ResizeProbeCell({ rowIndex }: ResizeProbeCellProps) {
+ const rendering = useRowHeightRendering();
+ const counts = useRef({ renders: 0, commits: 0 });
+ const element = useRef<HTMLSpanElement>(null);
+ counts.current.renders += 1;
+ useEffect(() => {
+ counts.current.commits += 1;
+ element.current?.setAttribute(
+ "data-commit-count",
+ String(counts.current.commits),
+ );
+ });
+ return (
+ <span
+ ref={element}
+ data-testid={`resize-probe-${rowIndex}`}
+ data-render-count={counts.current.renders}
+ >
+ {rendering?.compact ? "compact" : "expanded"}
+ </span>
+ );
+}
+
+const resizeStoryColumns: LangfuseColumnDef<ResizeStoryRow>[] = [
+ {
+ accessorKey: "mode",
+ id: "mode",
+ header: "Cell rendering",
+ cell: ({ row }) => <ResizeProbeCell rowIndex={row.index} />,
+ },
+ { accessorKey: "value", header: "Value" },
+ { accessorKey: "status", header: "Status" },
+];
+
+function RowHeightLifecycleStory({
+ rowHeight = "s",
+ customRowHeights,
+ customRowHeightPx,
+ onCustomRowHeightChange,
+ initialRowCount = 2,
+}: RowHeightLifecycleStoryProps) {
+ const [rows, setRows] = useState<ResizeStoryRow[]>(() =>
+ [
+ { id: "first", value: "First value", status: "Ready", mode: 0 },
+ { id: "following", value: "Following value", status: "Ready", mode: 1 },
+ ].slice(0, initialRowCount),
+ );
+ const [loading, setLoading] = useState(false);
+ const [showStatus, setShowStatus] = useState(false);
+ const [presets, setPresets] = useState(customRowHeights);
+ const [heightPx, setHeightPx] = useState<number | undefined>(
+ customRowHeightPx ?? undefined,
+ );
+ const handleValuesRefresh = () => {
+ setRows((current) =>
+ current.map((row) => ({
+ ...row,
+ value: `${row.value} loaded`,
+ })),
+ );
+ };
+ const handleFirstRowReplacement = () => {
+ setRows((current) =>
+ current.map((row, index) =>
+ index === 0 ? { ...row, id: `${row.id}-replacement` } : row,
+ ),
+ );
+ };
+ const handleFollowingRowReplacement = () => {
+ setRows((current) =>
+ current.map((row, index) =>
+ index === 1 ? { ...row, id: `${row.id}-replacement` } : row,
+ ),
+ );
+ };
+ const handleFollowingRowAppend = () => {
+ setRows((current) => [
+ ...current,
+ { id: "following", value: "Following value", status: "Ready", mode: 1 },
+ ]);
+ };
+ const handleLoadingToggle = () => setLoading((current) => !current);
+ const handleShowStatus = () => setShowStatus(true);
+ const handlePresetsRefresh = () =>
+ setPresets((current) => current && { ...current });
+ const handleHeightCommit = (next: number) => {
+ setHeightPx(next);
+ onCustomRowHeightChange?.(next);
+ };
+ return (
+ <>
+ <div className="mb-4 flex flex-wrap gap-2">
+ <Button onClick={handleValuesRefresh}>Refresh values</Button>
+ <Button onClick={handleFirstRowReplacement}>Replace first row</Button>
+ <Button onClick={handleFollowingRowReplacement}>
+ Replace following row
+ </Button>
+ <Button onClick={handleFollowingRowAppend} disabled={rows.length > 1}>
+ Append following row
+ </Button>
+ <Button onClick={handleLoadingToggle}>
+ {loading ? "Finish loading" : "Start loading"}
+ </Button>
+ <Button onClick={handleShowStatus}>Show status</Button>
+ <Button onClick={handlePresetsRefresh}>Refresh presets</Button>
+ </div>
+ <DataTable<ResizeStoryRow, unknown>
+ tableName="story-row-height-lifecycle"
+ columns={resizeStoryColumns}
+ data={{ isLoading: loading, isError: false, data: rows }}
+ columnVisibility={{ status: showStatus }}
+ hidePagination
+ rowHeight={rowHeight}
+ customRowHeights={presets}
+ customRowHeightPx={heightPx}
+ onCustomRowHeightChange={handleHeightCommit}
+ />
+ </>
+ );
+}
+
+const settleResize = () =>
+ new Promise<void>((resolve) => {
+ requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+ });
+
+async function pointAtResizeHandle(
+ handle: HTMLElement,
+ type: string,
+ clientY: number,
+ pointerId = 1,
+) {
+ fireEvent(
+ handle,
+ new PointerEvent(type, {
+ bubbles: true,
+ cancelable: true,
+ button: 0,
+ pointerId,
+ clientY,
+ }),
+ );
+ await settleResize();
+}
+
+function resizeFrames(canvasElement: HTMLElement, rowIndex: number) {
+ return Array.from(
+ canvasElement.querySelectorAll<HTMLElement>(
+ `tr[data-row-index="${rowIndex}"] [data-row-height]`,
+ ),
+ );
+}
+
+function resizeProbeCounts(canvasElement: HTMLElement, rowIndex: number) {
+ const probe = canvasElement.querySelector<HTMLElement>(
+ `[data-testid="resize-probe-${rowIndex}"]`,
+ );
+ if (!probe) throw new globalThis.Error(`Missing row ${rowIndex} probe`);
+ return {
+ renders: Number(probe.dataset.renderCount),
+ commits: Number(probe.dataset.commitCount),
+ };
+}
+
+function expectResizeHeight(
+ canvasElement: HTMLElement,
+ rowIndex: number,
+ px: number,
+) {
+ const frames = resizeFrames(canvasElement, rowIndex);
+ expect(frames.length).toBeGreaterThan(0);
+ for (const frame of frames) expect(frame).toHaveStyle({ height: `${px}px` });
+}
+
+export const PixelResizeKeepsCellsMounted = meta.story({
+ name: "(Test) Pixel Resize Keeps Cells Mounted",
+ args: { rowHeight: "m", onCustomRowHeightChange: fn() },
+ render: (args) => <RowHeightLifecycleStory {...args} />,
+ play: async ({ canvas, canvasElement }) => {
+ await settleResize();
+ const before = [0, 1].map((index) =>
+ resizeProbeCounts(canvasElement, index),
+ );
+ const handle = canvas.getByRole("slider", { name: "Row height" });
+ await pointAtResizeHandle(handle, "pointerdown", 100);
+ for (const y of [101, 108, 116, 124, 140]) {
+ await pointAtResizeHandle(handle, "pointermove", y);
+ }
+ expect(
+ [0, 1].map((index) => resizeProbeCounts(canvasElement, index)),
+ ).toEqual(before);
+ expectResizeHeight(canvasElement, 0, 136);
+ expectResizeHeight(canvasElement, 1, 96);
+ await pointAtResizeHandle(handle, "pointercancel", 140);
+ },
+});
+
+export const MediumBoundaryUpdatesOnlyResizedRow = meta.story({
+ name: "(Test) Medium Boundary Updates Only Resized Row",
+ args: { rowHeight: "s", onCustomRowHeightChange: fn() },
+ render: (args) => <RowHeightLifecycleStory {...args} />,
+ play: async ({ canvas, canvasElement }) => {
+ await settleResize();
+ const handle = canvas.getByRole("slider", { name: "Row height" });
+ await pointAtResizeHandle(handle, "pointerdown", 0);
+ for (const [y, mode] of [
+ [68, "expanded"],
+ [67, "compact"],
+ ] as const) {
+ const before = [0, 1].map((index) =>
+ resizeProbeCounts(canvasElement, index),
+ );
+ await pointAtResizeHandle(handle, "pointermove", y);
+ expect(canvas.getByTestId("resize-probe-0")).toHaveTextContent(mode);
+ expect(canvas.getByTestId("resize-probe-1")).toHaveTextContent("compact");
+ expect(resizeProbeCounts(canvasElement, 0)).toEqual({
+ renders: before[0].renders + 1,
+ commits: before[0].commits + 1,
+ });
+ expect(resizeProbeCounts(canvasElement, 1)).toEqual(before[1]);
+ const after = resizeProbeCounts(canvasElement, 0);
+ await pointAtResizeHandle(handle, "pointermove", y);
+ expect(resizeProbeCounts(canvasElement, 0)).toEqual(after);
+ expect(resizeProbeCounts(canvasElement, 1)).toEqual(before[1]);
+ }
+ await pointAtResizeHandle(handle, "pointercancel", 67);
+ },
+});
+
+export const EquivalentRefreshKeepsResizeActive = meta.story({
+ name: "(Test) Equivalent Refresh Keeps Resize Active",
+ args: {
+ rowHeight: "s",
+ customRowHeights: {
+ s: "h-48",
+ m: "h-64",
+ l: "h-96",
+ } satisfies CustomHeights,
+ onCustomRowHeightChange: fn(),
+ },
+ render: (args) => <RowHeightLifecycleStory {...args} />,
+ play: async ({ args, canvas, canvasElement, userEvent }) => {
+ const handle = canvas.getByRole("slider", { name: "Row height" });
+ const frames = resizeFrames(canvasElement, 0);
+ await pointAtResizeHandle(handle, "pointerdown", 0);
+ await pointAtResizeHandle(handle, "pointermove", 100);
+ for (const button of ["Refresh values", "Refresh presets"]) {
+ await userEvent.click(canvas.getByRole("button", { name: button }));
+ await settleResize();
+ expect(canvas.getByRole("slider", { name: "Row height" })).toBe(handle);
+ resizeFrames(canvasElement, 0).forEach((frame, index) =>
+ expect(frame).toBe(frames[index]),
+ );
+ expectResizeHeight(canvasElement, 0, 292);
+ expect(canvas.getByTestId("resize-probe-0")).toHaveTextContent(
+ "expanded",
+ );
+ }
+ expect(canvas.getByText("First value loaded")).toBeVisible();
+ await pointAtResizeHandle(handle, "pointermove", 160);
+ expectResizeHeight(canvasElement, 0, 352);
+ await pointAtResizeHandle(handle, "pointerup", 160);
+ expect(args.onCustomRowHeightChange).toHaveBeenCalledTimes(1);
+ expect(args.onCustomRowHeightChange).toHaveBeenCalledWith(352);
+ },
+});
+
+export const MembershipChangesCancelResize = meta.story({
+ name: "(Test) Row Column And Loading Changes Cancel Resize",
+ args: { rowHeight: "s", onCustomRowHeightChange: fn() },
+ render: (args) => <RowHeightLifecycleStory {...args} />,
+ play: async ({ args, canvas, canvasElement, userEvent }) => {
+ for (const button of [
+ "Replace first row",
+ "Show status",
+ "Start loading",
+ ]) {
+ const oldHandle = canvas.getByRole("slider", { name: "Row height" });
+ const oldFrames = resizeFrames(canvasElement, 0);
+ await pointAtResizeHandle(oldHandle, "pointerdown", 0);
+ await pointAtResizeHandle(oldHandle, "pointermove", 100);
+ expect(canvas.getByTestId("resize-probe-0")).toHaveTextContent(
+ "expanded",
+ );
+ await userEvent.click(canvas.getByRole("button", { name: button }));
+ if (button === "Start loading") {
+ expect(oldHandle).not.toBeInTheDocument();
+ await userEvent.click(
+ canvas.getByRole("button", { name: "Finish loading" }),
+ );
+ }
+ await settleResize();
+ const handle = canvas.getByRole("slider", { name: "Row height" });
+ if (button !== "Show status") {
+ expect(handle).not.toBe(oldHandle);
+ expect(resizeFrames(canvasElement, 0)[0]).not.toBe(oldFrames[0]);
+ } else {
+ expect(resizeFrames(canvasElement, 0)).toHaveLength(
+ oldFrames.length + 1,
+ );
+ }
+ expectResizeHeight(canvasElement, 0, 28);
+ expect(canvas.getByTestId("resize-probe-0")).toHaveTextContent("compact");
+ await pointAtResizeHandle(handle, "pointermove", 160);
+ await pointAtResizeHandle(handle, "pointerup", 160);
+ expect(args.onCustomRowHeightChange).not.toHaveBeenCalled();
+ expectResizeHeight(canvasElement, 0, 28);
+ }
+ },
+});
+
+export const CanceledPointersRestoreRowHeight = meta.story({
+ name: "(Test) Canceled Pointers Restore Row Height",
+ args: { rowHeight: "s", onCustomRowHeightChange: fn() },
+ render: (args) => <RowHeightLifecycleStory {...args} />,
+ play: async ({ args, canvas, canvasElement }) => {
+ const handle = canvas.getByRole("slider", { name: "Row height" });
+ for (const eventType of ["pointercancel", "lostpointercapture"]) {
+ await pointAtResizeHandle(handle, "pointerdown", 0);
+ await pointAtResizeHandle(handle, "pointermove", 100);
+ expectResizeHeight(canvasElement, 0, 128);
+ expect(canvas.getByTestId("resize-probe-0")).toHaveTextContent(
+ "expanded",
+ );
+ await pointAtResizeHandle(handle, eventType, 100);
+ expectResizeHeight(canvasElement, 0, 28);
+ expect(canvas.getByTestId("resize-probe-0")).toHaveTextContent("compact");
+ expect(handle).toHaveAttribute("aria-valuenow", "28");
+ expect(args.onCustomRowHeightChange).not.toHaveBeenCalled();
+ await pointAtResizeHandle(handle, "pointerup", 100);
+ expect(args.onCustomRowHeightChange).not.toHaveBeenCalled();
+ }
+ },
+});
+
+export const OverlappingPointersKeepFirstResize = meta.story({
+ name: "(Test) Overlapping Pointers Keep First Resize",
+ args: { rowHeight: "s", onCustomRowHeightChange: fn() },
+ render: (args) => <RowHeightLifecycleStory {...args} />,
+ play: async ({ args, canvas, canvasElement }) => {
+ const first = canvas.getByRole("slider", { name: "Row height" });
+ const second = canvasElement.querySelector<HTMLElement>(
+ 'tr[data-row-index="1"] [data-row-resize-edge="last"]',
+ );
+ if (!second) throw new globalThis.Error("Missing second row handle");
+ await pointAtResizeHandle(first, "pointerdown", 0, 1);
+ await pointAtResizeHandle(first, "pointermove", 100, 1);
+ await pointAtResizeHandle(second, "pointerdown", 0, 2);
+ await pointAtResizeHandle(second, "pointermove", 200, 2);
+ await pointAtResizeHandle(second, "pointerup", 200, 2);
+ expect(args.onCustomRowHeightChange).not.toHaveBeenCalled();
+ expectResizeHeight(canvasElement, 0, 128);
+ expectResizeHeight(canvasElement, 1, 28);
+ await pointAtResizeHandle(first, "pointerup", 160, 1);
+ expect(args.onCustomRowHeightChange).toHaveBeenCalledTimes(1);
+ expect(args.onCustomRowHeightChange).toHaveBeenCalledWith(188);
+ expectResizeHeight(canvasElement, 0, 188);
+ expectResizeHeight(canvasElement, 1, 188);
+ },
+});
+
+async function assertLowerHalfHandleRemoval(
+ canvasElement: HTMLElement,
+ previewed: boolean,
+ replaceFollowingRow: () => Promise<void>,
+ onCustomRowHeightChange: DataTableDemoProps["onCustomRowHeightChange"],
+) {
+ const lower = canvasElement.querySelector<HTMLElement>(
+ 'tr[data-row-index="1"] [data-row-resize-edge="below"]',
+ );
+ if (!lower) throw new globalThis.Error("Missing lower half handle");
+ const frames = resizeFrames(canvasElement, 0);
+ await pointAtResizeHandle(lower, "pointerdown", 0);
+ if (previewed) await pointAtResizeHandle(lower, "pointermove", 100);
+ await replaceFollowingRow();
+ await settleResize();
+ expect(lower).not.toBeInTheDocument();
+ resizeFrames(canvasElement, 0).forEach((frame, index) =>
+ expect(frame).toBe(frames[index]),
+ );
+ expectResizeHeight(canvasElement, 0, 28);
+ const probe = canvasElement.querySelector('[data-testid="resize-probe-0"]');
+ expect(probe).toHaveTextContent("compact");
+ const handle = canvasElement.querySelector<HTMLElement>(
+ '[role="slider"][aria-label="Row height"]',
+ );
+ if (!handle) throw new globalThis.Error("Missing row height slider");
+ await pointAtResizeHandle(handle, "pointerdown", 0, 2);
+ await pointAtResizeHandle(handle, "pointermove", 48, 2);
+ await pointAtResizeHandle(handle, "pointerup", 48, 2);
+ expect(onCustomRowHeightChange).toHaveBeenCalledTimes(1);
+ expect(onCustomRowHeightChange).toHaveBeenCalledWith(76);
+}
+
+export const RemovedLowerHandleReleasesPendingResize = meta.story({
+ name: "(Test) Removed Lower Handle Releases Pending Resize",
+ args: { rowHeight: "s", onCustomRowHeightChange: fn() },
+ render: (args) => <RowHeightLifecycleStory {...args} />,
+ play: async ({ args, canvas, canvasElement, userEvent }) => {
+ await assertLowerHalfHandleRemoval(
+ canvasElement,
+ false,
+ async () => {
+ await userEvent.click(
+ canvas.getByRole("button", { name: "Replace following row" }),
+ );
+ },
+ args.onCustomRowHeightChange,
+ );
+ },
+});
+
+export const RemovedLowerHandleRollsBackPreview = meta.story({
+ name: "(Test) Removed Lower Handle Rolls Back Preview",
+ args: { rowHeight: "s", onCustomRowHeightChange: fn() },
+ render: (args) => <RowHeightLifecycleStory {...args} />,
+ play: async ({ args, canvas, canvasElement, userEvent }) => {
+ await assertLowerHalfHandleRemoval(
+ canvasElement,
+ true,
+ async () => {
+ await userEvent.click(
+ canvas.getByRole("button", { name: "Replace following row" }),
+ );
+ },
+ args.onCustomRowHeightChange,
+ );
+ },
+});
+
+export const RemovedKeyboardHandleCancelsResize = meta.story({
+ name: "(Test) Removed Keyboard Handle Cancels Resize",
+ args: {
+ rowHeight: "s",
+ customRowHeightPx: 80,
+ onCustomRowHeightChange: fn(),
+ },
+ render: (args) => <RowHeightLifecycleStory {...args} initialRowCount={1} />,
+ play: async ({ args, canvas, canvasElement }) => {
+ const handle = canvas.getByRole("slider", { name: "Row height" });
+ const frames = resizeFrames(canvasElement, 0);
+ handle.focus();
+ fireEvent.keyDown(handle, { key: "ArrowDown" });
+ await settleResize();
+ expectResizeHeight(canvasElement, 0, 96);
+ expect(canvas.getByTestId("resize-probe-0")).toHaveTextContent("expanded");
+ fireEvent.click(
+ canvas.getByRole("button", { name: "Append following row" }),
+ );
+ await settleResize();
+ expect(handle).not.toBeInTheDocument();
+ resizeFrames(canvasElement, 0).forEach((frame, index) =>
+ expect(frame).toBe(frames[index]),
+ );
+ expect(args.onCustomRowHeightChange).not.toHaveBeenCalled();
+ expectResizeHeight(canvasElement, 0, 80);
+ expect(canvas.getByTestId("resize-probe-0")).toHaveTextContent("compact");
+ const replacement = canvas.getByRole("slider", { name: "Row height" });
+ await pointAtResizeHandle(replacement, "pointerdown", 0, 2);
+ await pointAtResizeHandle(replacement, "pointermove", 48, 2);
+ await pointAtResizeHandle(replacement, "pointerup", 48, 2);
+ expect(args.onCustomRowHeightChange).toHaveBeenCalledTimes(1);
+ expect(args.onCustomRowHeightChange).toHaveBeenCalledWith(128);
+ },
+});
+
+type ResizeStoryRow = {
+ id: string;
+ value: string;
+ status: string;
+ mode: number;
+};
+
+type ResizeProbeCellProps = { rowIndex: number };
+
+type RowHeightLifecycleStoryProps = Pick<
+ DataTableDemoProps,
+ | "rowHeight"
+ | "customRowHeights"
+ | "customRowHeightPx"
+ | "onCustomRowHeightChange"
+> & { initialRowCount?: number };
diff --git a/web/src/components/table/README.md b/web/src/components/table/README.md
new file mode 100644
index 0000000000..802265a459
--- /dev/null
+++ b/web/src/components/table/README.md
@@ -0,0 +1,23 @@
+# Data table rendering
+
+`data-table.tsx` owns the TanStack table, headers and body snapshot. The body
+renders loading/empty states and creates one local row-height preview store per
+mount. `TableDataRow` subscribes only to its compact/expanded mode; selection
+subscriptions stay in `TableRowComponent` and the selection store.
+
+Row resizing is a DOM integration owned by the body. Pointer and keyboard
+movement update only the target row's frame heights and the slider's announced
+value. Pixel movement does not render the body or cell content. Crossing Medium
+updates only the target row's mode. Release commits one shared height through the
+caller's persisted setting and restores the dragged row's scroll anchor.
+Gestures survive value refreshes and equivalent preset heights. Replacing their
+frames or active handle, loading placeholders, or losing capture cancels the
+preview before it can persist.
+
+`data-table-row-height-switch.tsx` owns presets, persisted custom heights, bounds
+and the compact/expanded rendering contract. Its context supplies that semantic
+mode to IO/tag cells; it does not publish continuous pixels.
+
+Columns use design-system factories, with production IO/media bindings supplied
+by `ConnectedIOTableCell`. The body memo compares explicit table snapshots because
+TanStack's table instance is mutable.
diff --git a/web/src/components/table/data-table.tsx b/web/src/components/table/data-table.tsx
index a7d7a56c18..6b18e345c4 100644
--- a/web/src/components/table/data-table.tsx
+++ b/web/src/components/table/data-table.tsx
@@ -25,6 +25,7 @@ import {
clampCustomRowHeightPx,
getRowHeightTailwindClass,
minCustomRowHeightPx,
+ mediumRowHeightPx,
resolveRowHeightRendering,
rowHeightPresetForPx,
} from "@/src/components/table/data-table-row-height-switch";
@@ -62,6 +63,8 @@ import {
} from "@tanstack/react-table";
import { type DataTablePeekViewProps } from "@/src/components/table/peek";
import isEqual from "lodash/isEqual";
+import { useStore } from "zustand";
+import { createStore, type StoreApi } from "zustand/vanilla";
import { useRouter } from "next/router";
import { useColumnSizing } from "@/src/components/table/hooks/useColumnSizing";
@@ -1041,13 +1044,24 @@ function TableBodyComponent<TData>({
);
const dragRef = useRef<{
pointerId: number;
+ handle: HTMLDivElement;
startY: number;
startHeight: number;
rowIndex: number;
} | null>(null);
- const [preview, setPreview] = useState<{
+ const [previewStore] = useState(() =>
+ createStore<{ rowIndex: number | null; compact: boolean }>(() => ({
+ rowIndex: null,
+ compact: true,
+ })),
+ );
+ const previewRef = useRef<{
rowIndex: number;
px: number;
+ committedPx: number;
+ minPx: number;
+ mediumPx: number;
+ frames: HTMLElement[];
} | null>(null);
const committedRendering = resolveRowHeightRendering(
{
@@ -1058,12 +1072,118 @@ function TableBodyComponent<TData>({
);
const previewCommitRef = useRef<number | null>(null);
const keyGestureStartRef = useRef<number | null>(null);
+ const keyGestureHandleRef = useRef<HTMLDivElement | null>(null);
const anchorRef = useRef<{ rowIndex: number; top: number } | null>(null);
const [anchorEpoch, setAnchorEpoch] = useState(0);
const tableBodyRef = useRef<HTMLTableSectionElement>(null);
const [measuredPx, setMeasuredPx] = useState<number | undefined>(undefined);
const minRowHeightPx = minCustomRowHeightPx(customRowHeights);
- const announcedPx = preview?.px ?? rowHeightPx ?? measuredPx;
+ const compactThresholdPx = mediumRowHeightPx(customRowHeights);
+ const announcedPx = rowHeightPx ?? measuredPx;
+ const committedHeightRef = useRef(committedRendering.heightPx);
+ committedHeightRef.current = committedRendering.heightPx;
+
+ // Pixel movement belongs to the DOM integration. React subscribes only to
+ // the compact/expanded boundary of the row being resized.
+ const previewRowHeight = (rowIndex: number, px: number) => {
+ let preview = previewRef.current;
+ if (preview?.rowIndex === rowIndex && preview.px === px) return;
+ if (preview?.rowIndex !== rowIndex) {
+ preview = {
+ rowIndex,
+ px,
+ committedPx: committedRendering.heightPx,
+ minPx: minRowHeightPx,
+ mediumPx: compactThresholdPx,
+ frames: Array.from(
+ tableBodyRef.current?.querySelectorAll<HTMLElement>(
+ `tr[data-row-index="${rowIndex}"] [data-row-height]`,
+ ) ?? [],
+ ),
+ };
+ previewRef.current = preview;
+ }
+ preview.px = px;
+ for (const frame of preview.frames) {
+ frame.style.height = `${px}px`;
+ frame.style.maxHeight = `${px}px`;
+ }
+ tableBodyRef.current
+ ?.querySelector('[role="slider"]')
+ ?.setAttribute("aria-valuenow", String(px));
+ const compact = px < compactThresholdPx;
+ const current = previewStore.getState();
+ if (current.rowIndex !== rowIndex || current.compact !== compact) {
+ previewStore.setState({ rowIndex, compact });
+ }
+ };
+
+ const clearRowHeightPreview = useCallback(() => {
+ const preview = previewRef.current;
+ if (!preview) return;
+ for (const frame of preview.frames) {
+ frame.style.height = `${committedHeightRef.current}px`;
+ frame.style.maxHeight = `${committedHeightRef.current}px`;
+ }
+ tableBodyRef.current
+ ?.querySelector('[role="slider"]')
+ ?.setAttribute("aria-valuenow", String(committedHeightRef.current));
+ previewRef.current = null;
+ previewStore.setState({ rowIndex: null });
+ }, [previewStore]);
+
+ const cancelRowHeightGesture = useCallback(() => {
+ const drag = dragRef.current;
+ dragRef.current = null;
+ if (drag?.handle.hasPointerCapture?.(drag.pointerId)) {
+ drag.handle.releasePointerCapture(drag.pointerId);
+ }
+ previewCommitRef.current = null;
+ keyGestureStartRef.current = null;
+ keyGestureHandleRef.current = null;
+ clearRowHeightPreview();
+ }, [clearRowHeightPreview]);
+
+ // Refreshed values can keep the same DOM frames. Retain the gesture in
+ // that case, but cancel before paint if its row/cells or sizing are replaced.
+ useLayoutEffect(() => {
+ const handle = dragRef.current?.handle ?? keyGestureHandleRef.current;
+ if (handle && !tableBodyRef.current?.contains(handle)) {
+ cancelRowHeightGesture();
+ return;
+ }
+ const preview = previewRef.current;
+ if (!preview) return;
+ const frames = Array.from(
+ tableBodyRef.current?.querySelectorAll<HTMLElement>(
+ `tr[data-row-index="${preview.rowIndex}"] [data-row-height]`,
+ ) ?? [],
+ );
+ if (
+ !rowResizeEnabled ||
+ preview.committedPx !== committedRendering.heightPx ||
+ preview.minPx !== minRowHeightPx ||
+ preview.mediumPx !== compactThresholdPx ||
+ frames.length !== preview.frames.length ||
+ frames.some((frame, index) => frame !== preview.frames[index])
+ ) {
+ cancelRowHeightGesture();
+ }
+ }, [
+ rowModelRows,
+ visibleColumns,
+ data.isLoading,
+ rowResizeEnabled,
+ committedRendering.heightPx,
+ minRowHeightPx,
+ compactThresholdPx,
+ cancelRowHeightGesture,
+ ]);
+
+ useLayoutEffect(
+ () => () => cancelRowHeightGesture(),
+ [cancelRowHeightGesture],
+ );
const rememberRowAnchor = (rowIndex: number) => {
const row = tableBodyRef.current?.querySelector<HTMLElement>(
@@ -1113,6 +1233,7 @@ function TableBodyComponent<TData>({
// button is 0 for a primary press. Some pointers report -1 until the
// button is known; only an explicit non-primary button should bail.
if (event.button > 0) return;
+ if (dragRef.current || keyGestureStartRef.current != null) return;
event.preventDefault();
event.stopPropagation();
// The lower half lives in the next row. Its target is the row above
@@ -1126,6 +1247,7 @@ function TableBodyComponent<TData>({
if (startHeight == null || startHeight <= 0) return;
dragRef.current = {
pointerId: event.pointerId,
+ handle: event.currentTarget,
startY: event.clientY,
startHeight,
rowIndex,
@@ -1142,13 +1264,13 @@ function TableBodyComponent<TData>({
const drag = dragRef.current;
if (!drag || event.pointerId !== drag.pointerId) return;
event.preventDefault();
- setPreview({
- rowIndex: drag.rowIndex,
- px: clampCustomRowHeightPx(
+ previewRowHeight(
+ drag.rowIndex,
+ clampCustomRowHeightPx(
drag.startHeight + (event.clientY - drag.startY),
minRowHeightPx,
),
- });
+ );
};
const finishResize = (event: React.PointerEvent<HTMLDivElement>) => {
@@ -1159,42 +1281,49 @@ function TableBodyComponent<TData>({
drag.startHeight + (event.clientY - drag.startY),
minRowHeightPx,
);
- setPreview(null);
+ rememberRowAnchor(drag.rowIndex);
+ clearRowHeightPreview();
if (next === Math.round(drag.startHeight)) {
anchorRef.current = null;
return;
}
- rememberRowAnchor(drag.rowIndex);
setAnchorEpoch((epoch) => epoch + 1);
onCommitRowHeight?.(next);
};
+ const cancelResize = (event: React.PointerEvent<HTMLDivElement>) => {
+ const drag = dragRef.current;
+ if (!drag || event.pointerId !== drag.pointerId) return;
+ cancelRowHeightGesture();
+ };
+
const commitKeyboardResize = () => {
const next = previewCommitRef.current;
const start = keyGestureStartRef.current;
if (next == null && start == null) return;
previewCommitRef.current = null;
keyGestureStartRef.current = null;
- setPreview(null);
+ keyGestureHandleRef.current = null;
+ rememberRowAnchor(0);
+ clearRowHeightPreview();
if (next == null || start == null || next === Math.round(start)) {
anchorRef.current = null;
return;
}
- // The slider lives on the first row.
- rememberRowAnchor(0);
setAnchorEpoch((epoch) => epoch + 1);
onCommitRowHeight?.(next);
};
const onResizeKeyDown = (event: React.KeyboardEvent<HTMLDivElement>) => {
if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+ if (dragRef.current) return;
event.preventDefault();
event.stopPropagation();
const sized = event.currentTarget
.closest("td")
?.querySelector<HTMLElement>("[data-row-height]");
const fallback =
- preview?.px ??
+ previewRef.current?.px ??
rowHeightPx ??
measuredPx ??
sized?.getBoundingClientRect().height ??
@@ -1202,28 +1331,12 @@ function TableBodyComponent<TData>({
const current = previewCommitRef.current ?? fallback;
if (keyGestureStartRef.current == null) {
keyGestureStartRef.current = current;
+ keyGestureHandleRef.current = event.currentTarget;
}
const delta = event.key === "ArrowDown" ? 16 : -16;
const next = clampCustomRowHeightPx(current + delta, minRowHeightPx);
previewCommitRef.current = next;
- setPreview({ rowIndex: 0, px: next });
- };
-
- const renderingForRow = (rowIndex: number) => {
- if (preview == null || preview.rowIndex !== rowIndex) {
- return { rendering: committedRendering, previewing: false };
- }
- return {
- previewing: true,
- rendering: resolveRowHeightRendering(
- {
- preset: rowHeight ?? "s",
- customPx: rowHeightPx ?? null,
- previewPx: preview.px,
- },
- customRowHeights,
- ),
- };
+ previewRowHeight(0, next);
};
const framePropsFor = (
@@ -1310,148 +1423,33 @@ function TableBodyComponent<TData>({
))}
</RowHeightRenderingProvider>
) : rowModelRows.length ? (
- rowModelRows.map((row) => {
- const { rendering, previewing } = renderingForRow(row.index);
- const cells = row.getVisibleCells().map((cell, cellIndex) => {
- const cellValue = cell.getValue();
- const isStringCell = typeof cellValue === "string";
- const isSmallRowHeight = rendering.compact;
- const columnDef = cell.column.columnDef as LangfuseColumnDef<TData>;
- const isLastRow = row.index === rowModelRows.length - 1;
- const isPrimaryHandle = row.index === 0 && cellIndex === 0;
- // Each border has a 6px strip: 3px in the row above and 3px at
- // the top of the next row. The lower half lives in the next row
- // so the rest of that row still receives clicks. Both halves
- // resize the row above the line. The last row's strip hangs 3px
- // below its own bottom edge.
- const resizeEdges: RowResizeEdge[] = [];
- if (rowResizeEnabled && row.index > 0) resizeEdges.push("below");
- if (rowResizeEnabled && isLastRow) resizeEdges.push("last");
- else if (rowResizeEnabled) resizeEdges.push("above");
- const primaryEdge: RowResizeEdge | null = isPrimaryHandle
- ? isLastRow
- ? "last"
- : "above"
- : null;
-
- return (
- <TableCell
- key={cell.id}
- className={cn(
- "border-b text-xs first:pl-2",
- rowResizeEnabled ? "overflow-visible" : "overflow-hidden",
- rowResizeEnabled && "relative",
- getCellPaddingClassName(columnDef.cellPadding ?? cellPadding),
- isSmallRowHeight && "whitespace-nowrap",
- getPinningClasses(cell.column),
- getCellBackgroundClassName(columnDef.cellBackground),
- columnDef.cellClassName,
- columnDef.hideBelowMd && "hidden md:table-cell",
- )}
- style={{
- ...getCommonPinningStyles(cell.column),
- width: columnDef.isFlexWidth
- ? "auto"
- : `calc(var(--col-${cell.column.id}-size) * 1px)`,
- }}
- >
- <div
- {...framePropsFor(rendering, previewing, rowResizeEnabled)}
- >
- {isStringCell && isSmallRowHeight ? (
- <div
- className="min-w-0 truncate leading-normal"
- title={getPlainTextFromReactNode(
- flexRender(
- cell.column.columnDef.cell,
- cell.getContext(),
- ),
- )}
- >
- {flexRender(
- cell.column.columnDef.cell,
- cell.getContext(),
- )}
- </div>
- ) : isStringCell && !isSmallRowHeight ? (
- <div className="flex h-full min-h-0 w-full min-w-0 flex-col overflow-hidden text-ellipsis">
- {flexRender(
- cell.column.columnDef.cell,
- cell.getContext(),
- )}
- </div>
- ) : (
- flexRender(cell.column.columnDef.cell, cell.getContext())
- )}
- </div>
- {resizeEdges.map((edge) => {
- const primary = edge === primaryEdge;
- return (
- <div
- key={edge}
- data-row-resize-handle=""
- data-row-resize-edge={edge}
- data-row-resize-target={
- edge === "below" ? row.index - 1 : row.index
- }
- role={primary ? "slider" : undefined}
- aria-orientation={primary ? "vertical" : undefined}
- aria-label={primary ? "Row height" : undefined}
- aria-valuemin={primary ? minRowHeightPx : undefined}
- aria-valuemax={
- primary ? MAX_CUSTOM_ROW_HEIGHT_PX : undefined
- }
- aria-valuenow={primary ? announcedPx : undefined}
- aria-hidden={primary ? undefined : true}
- tabIndex={primary ? 0 : undefined}
- onPointerDown={onResizePointerDown}
- onPointerMove={onResizePointerMove}
- onPointerUp={finishResize}
- onPointerCancel={finishResize}
- onKeyDown={primary ? onResizeKeyDown : undefined}
- onKeyUp={primary ? commitKeyboardResize : undefined}
- onBlur={primary ? commitKeyboardResize : undefined}
- onClick={(event) => {
- event.preventDefault();
- event.stopPropagation();
- }}
- style={rowResizeHandleStyle(edge)}
- className={cn(
- // Invisible. The row-resize cursor is the pointer
- // affordance; keyboard focus keeps a hairline ring.
- "absolute inset-x-0 z-[1] cursor-row-resize touch-none bg-transparent select-none",
- primary &&
- "focus-visible:ring-ring focus-visible:ring-1 focus-visible:outline-none focus-visible:ring-inset",
- )}
- />
- );
- })}
- </TableCell>
- );
- });
-
- return (
- <RowHeightRenderingProvider
- key={row.id}
- compact={rendering.compact}
- expandedRead={rendering.expandedRead}
- >
- {renderRow ? (
- renderRow({ row, children: cells })
- ) : (
- <TableRowComponent
- row={row}
- onRowClick={onRowClick}
- getRowClassName={getRowClassName}
- highlightAllRows={highlightAllRows}
- selectionStore={selectionStore}
- >
- {cells}
- </TableRowComponent>
- )}
- </RowHeightRenderingProvider>
- );
- })
+ rowModelRows.map((row) => (
+ <TableDataRow
+ key={row.id}
+ row={row}
+ lastRowIndex={rowModelRows.length - 1}
+ previewStore={previewStore}
+ committedRendering={committedRendering}
+ rowheighttw={rowheighttw}
+ rowHeightPx={rowHeightPx}
+ rowResizeEnabled={rowResizeEnabled}
+ topAlignCells={topAlignCells}
+ cellPadding={cellPadding}
+ minRowHeightPx={minRowHeightPx}
+ announcedPx={announcedPx}
+ onResizePointerDown={onResizePointerDown}
+ onResizePointerMove={onResizePointerMove}
+ finishResize={finishResize}
+ cancelResize={cancelResize}
+ onResizeKeyDown={onResizeKeyDown}
+ commitKeyboardResize={commitKeyboardResize}
+ renderRow={renderRow}
+ onRowClick={onRowClick}
+ getRowClassName={getRowClassName}
+ highlightAllRows={highlightAllRows}
+ selectionStore={selectionStore}
+ />
+ ))
) : (
<TableRow className="hover:bg-transparent">
<TableCell colSpan={columns.length} className="h-24">
@@ -1472,6 +1470,175 @@ function TableBodyComponent<TData>({
);
}
+function TableDataRow<TData>({
+ row,
+ lastRowIndex,
+ previewStore,
+ committedRendering,
+ rowheighttw,
+ rowHeightPx,
+ rowResizeEnabled,
+ topAlignCells,
+ cellPadding,
+ minRowHeightPx,
+ announcedPx,
+ onResizePointerDown,
+ onResizePointerMove,
+ finishResize,
+ cancelResize,
+ onResizeKeyDown,
+ commitKeyboardResize,
+ renderRow,
+ onRowClick,
+ getRowClassName,
+ highlightAllRows,
+ selectionStore,
+}: TableDataRowProps<TData>) {
+ const compact = useStore(previewStore, (state) =>
+ state.rowIndex === row.index ? state.compact : committedRendering.compact,
+ );
+ const cells = row.getVisibleCells().map((cell, cellIndex) => {
+ const cellValue = cell.getValue();
+ const isStringCell = typeof cellValue === "string";
+ const isSmallRowHeight = compact;
+ const columnDef = cell.column.columnDef as LangfuseColumnDef<TData>;
+ const isLastRow = row.index === lastRowIndex;
+ const isPrimaryHandle = row.index === 0 && cellIndex === 0;
+ // Each border has a 6px strip: 3px in the row above and 3px at
+ // the top of the next row. The lower half lives in the next row
+ // so the rest of that row still receives clicks. Both halves
+ // resize the row above the line. The last row's strip hangs 3px
+ // below its own bottom edge.
+ const resizeEdges: RowResizeEdge[] = [];
+ if (rowResizeEnabled && row.index > 0) resizeEdges.push("below");
+ if (rowResizeEnabled && isLastRow) resizeEdges.push("last");
+ else if (rowResizeEnabled) resizeEdges.push("above");
+ const primaryEdge: RowResizeEdge | null = isPrimaryHandle
+ ? isLastRow
+ ? "last"
+ : "above"
+ : null;
+
+ return (
+ <TableCell
+ key={cell.id}
+ className={cn(
+ "border-b text-xs first:pl-2",
+ rowResizeEnabled ? "overflow-visible" : "overflow-hidden",
+ rowResizeEnabled && "relative",
+ getCellPaddingClassName(columnDef.cellPadding ?? cellPadding),
+ isSmallRowHeight && "whitespace-nowrap",
+ getPinningClasses(cell.column),
+ getCellBackgroundClassName(columnDef.cellBackground),
+ columnDef.cellClassName,
+ columnDef.hideBelowMd && "hidden md:table-cell",
+ )}
+ style={{
+ ...getCommonPinningStyles(cell.column),
+ width: columnDef.isFlexWidth
+ ? "auto"
+ : `calc(var(--col-${cell.column.id}-size) * 1px)`,
+ }}
+ >
+ <div
+ {...rowHeightFrameProps({
+ rowheighttw,
+ heightPx:
+ rowHeightPx != null || rowResizeEnabled
+ ? committedRendering.heightPx
+ : undefined,
+ presetClass: rowHeightPx == null,
+ compact,
+ topAlignCells,
+ measure: rowResizeEnabled,
+ clipContent: rowResizeEnabled,
+ })}
+ >
+ {isStringCell && isSmallRowHeight ? (
+ <div
+ className="min-w-0 truncate leading-normal"
+ title={getPlainTextFromReactNode(
+ flexRender(cell.column.columnDef.cell, cell.getContext()),
+ )}
+ >
+ {flexRender(cell.column.columnDef.cell, cell.getContext())}
+ </div>
+ ) : isStringCell && !isSmallRowHeight ? (
+ <div className="flex h-full min-h-0 w-full min-w-0 flex-col overflow-hidden text-ellipsis">
+ {flexRender(cell.column.columnDef.cell, cell.getContext())}
+ </div>
+ ) : (
+ flexRender(cell.column.columnDef.cell, cell.getContext())
+ )}
+ </div>
+ {resizeEdges.map((edge) => {
+ const primary = edge === primaryEdge;
+ return (
+ <div
+ key={edge}
+ data-row-resize-handle=""
+ data-row-resize-edge={edge}
+ data-row-resize-target={
+ edge === "below" ? row.index - 1 : row.index
+ }
+ role={primary ? "slider" : undefined}
+ aria-orientation={primary ? "vertical" : undefined}
+ aria-label={primary ? "Row height" : undefined}
+ aria-valuemin={primary ? minRowHeightPx : undefined}
+ aria-valuemax={primary ? MAX_CUSTOM_ROW_HEIGHT_PX : undefined}
+ aria-valuenow={primary ? announcedPx : undefined}
+ aria-hidden={primary ? undefined : true}
+ tabIndex={primary ? 0 : undefined}
+ onPointerDown={onResizePointerDown}
+ onPointerMove={onResizePointerMove}
+ onPointerUp={finishResize}
+ onPointerCancel={cancelResize}
+ onLostPointerCapture={cancelResize}
+ onKeyDown={primary ? onResizeKeyDown : undefined}
+ onKeyUp={primary ? commitKeyboardResize : undefined}
+ onBlur={primary ? commitKeyboardResize : undefined}
+ onClick={(event) => {
+ event.preventDefault();
+ event.stopPropagation();
+ }}
+ style={rowResizeHandleStyle(edge)}
+ className={cn(
+ // Invisible. The row-resize cursor is the pointer
+ // affordance; keyboard focus keeps a hairline ring.
+ "absolute inset-x-0 z-[1] cursor-row-resize touch-none bg-transparent select-none",
+ primary &&
+ "focus-visible:ring-ring focus-visible:ring-1 focus-visible:outline-none focus-visible:ring-inset",
+ )}
+ />
+ );
+ })}
+ </TableCell>
+ );
+ });
+
+ return (
+ <RowHeightRenderingProvider
+ key={row.id}
+ compact={compact}
+ expandedRead={!compact}
+ >
+ {renderRow ? (
+ renderRow({ row, children: cells })
+ ) : (
+ <TableRowComponent
+ row={row}
+ onRowClick={onRowClick}
+ getRowClassName={getRowClassName}
+ highlightAllRows={highlightAllRows}
+ selectionStore={selectionStore}
+ >
+ {cells}
+ </TableRowComponent>
+ )}
+ </RowHeightRenderingProvider>
+ );
+}
+
// Optimize table rendering performance by memoizing the table body
// This is critical for two high-frequency re-render scenarios:
// 1. During column resizing: When users drag column headers, it can trigger
@@ -1527,3 +1694,35 @@ const MemoizedTableBody = React.memo(TableBodyComponent, (prev, next) => {
// If all checks pass, components are equal
return true;
}) as typeof TableBodyComponent;
+
+type RowHeightPreviewStore = StoreApi<{
+ rowIndex: number | null;
+ compact: boolean;
+}>;
+
+type TableDataRowProps<TData> = Pick<
+ TableBodyComponentProps<TData>,
+ | "rowheighttw"
+ | "rowHeightPx"
+ | "renderRow"
+ | "onRowClick"
+ | "getRowClassName"
+ | "highlightAllRows"
+ | "selectionStore"
+> & {
+ row: Row<TData>;
+ lastRowIndex: number;
+ previewStore: RowHeightPreviewStore;
+ committedRendering: ReturnType<typeof resolveRowHeightRendering>;
+ rowResizeEnabled: boolean;
+ topAlignCells: boolean;
+ cellPadding: DataTableCellPadding;
+ minRowHeightPx: number;
+ announcedPx?: number;
+ onResizePointerDown: React.PointerEventHandler<HTMLDivElement>;
+ onResizePointerMove: React.PointerEventHandler<HTMLDivElement>;
+ finishResize: React.PointerEventHandler<HTMLDivElement>;
+ cancelResize: React.PointerEventHandler<HTMLDivElement>;
+ onResizeKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+ commitKeyboardResize: () => void;
+};