🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
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.tsxindex 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.mdnew file mode 100644index 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.tsxindex 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 equalreturn 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;+};