Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(grid): scale canvas scroll height beyond browser layout limit

lxk9558c4bf6267c1d
diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue
index 4a695b23ec..e6c82d4973 100644
--- a/apps/desktop/src/components/grid/DataGrid.vue
+++ b/apps/desktop/src/components/grid/DataGrid.vue
@@ -282,6 +282,9 @@ import {
MAX_CANVAS_DATA_GRID_PIXEL_RATIO,
canvasDataGridActionOverlayWidth,
canvasDataGridActionReservedWidth,
+ canvasDataGridContentHeight,
+ canvasDataGridDomScrollTop,
+ canvasDataGridVirtualScrollTop,
dataGridSearchMatchKey,
drawCanvasDataGrid,
resolveCanvasBackingStoreMetrics,
@@ -3414,7 +3417,7 @@ function applyPendingGridVerticalScrollbarDrag(clientY: number) {
scroller.scrollTop = nextScrollTop;
updateGridVerticalScrollbar(scroller);
if (useCanvasGridRows.value) {
- canvasScrollTop.value = scroller.scrollTop;
+ canvasScrollTop.value = canvasVirtualScrollTop(scroller.scrollTop, scroller.clientHeight);
drawCanvasGridNow();
}
}
@@ -4104,7 +4107,8 @@ function selectAndRevealLastLoadedRow() {
if (useCanvasGridRows.value) scrollCanvasRowIntoView(rowIndex, "end");
else scrollDomRowIntoView(rowIndex, "end");
const expectedScrollTop = Math.max(0, expectedRowBottom - scroller.clientHeight);
- if (scroller.scrollTop >= expectedScrollTop - 1) return;
+ const currentVirtualScrollTop = useCanvasGridRows.value ? canvasVirtualScrollTop(scroller.scrollTop, scroller.clientHeight) : scroller.scrollTop;
+ if (currentVirtualScrollTop >= expectedScrollTop - 1) return;
}
remainingFrames--;
if (remainingFrames > 0) requestAnimationFrame(revealWhenReady);
@@ -5875,7 +5879,7 @@ function scrollToCurrentMatch() {
const scroller = canvasScrollerElement();
if (!scroller) return;
const targetTop = Math.max(0, match.displayRow * CANVAS_DATA_GRID_ROW_HEIGHT - (scroller.clientHeight - CANVAS_DATA_GRID_ROW_HEIGHT) / 2);
- scroller.scrollTop = targetTop;
+ scroller.scrollTop = canvasDomScrollTop(targetTop, scroller.clientHeight);
syncCanvasViewport();
return;
}
@@ -5949,6 +5953,7 @@ const largeValueRuntimeInstance = useDataGridLargeValues({
showTranspose,
displayRowCount,
gridScrollerElement,
+ getScrollTop: () => (useCanvasGridRows.value ? canvasScrollTop.value : (gridScrollerElement()?.scrollTop ?? 0)),
displayItemAt,
getRowItem,
tableColumnForGridColumn,
@@ -6233,14 +6238,15 @@ function captureViewportAnchorForRefresh(): { row?: PersistedDataGridSelection;
// there. Anchoring would re-pin that row to the same on-screen offset even
// after a refresh prepends new rows above it (e.g. newly inserted rows
// under a DESC sort), pushing the new rows above the visible area (#8339).
- if (scroller.scrollTop <= 0) return null;
+ const currentScrollTop = useCanvasGridRows.value ? canvasVirtualScrollTop(scroller.scrollTop, scroller.clientHeight) : scroller.scrollTop;
+ if (currentScrollTop <= 0) return null;
const rowHeight = useCanvasGridRows.value ? CANVAS_DATA_GRID_ROW_HEIGHT : DOM_DATA_GRID_ROW_HEIGHT;
- const fallbackDisplayIndex = Math.max(0, Math.min(displayItems.value.length - 1, Math.floor(scroller.scrollTop / rowHeight)));
+ const fallbackDisplayIndex = Math.max(0, Math.min(displayItems.value.length - 1, Math.floor(currentScrollTop / rowHeight)));
const item = displayItems.value[fallbackDisplayIndex];
return {
row: item ? captureRowTargetForRefresh(item.id) : undefined,
fallbackDisplayIndex,
- offsetWithinRow: Math.max(0, scroller.scrollTop - fallbackDisplayIndex * rowHeight),
+ offsetWithinRow: Math.max(0, currentScrollTop - fallbackDisplayIndex * rowHeight),
};
}
@@ -6265,7 +6271,8 @@ function restoreViewportAnchorAfterRefresh(anchor: { row?: PersistedDataGridSele
const scroller = canvasMode ? canvasScrollerElement() : gridScrollerElement();
if (!scroller) return;
const rowHeight = canvasMode ? CANVAS_DATA_GRID_ROW_HEIGHT : DOM_DATA_GRID_ROW_HEIGHT;
- const nextScrollTop = Math.max(0, Math.min(displayRowIndex * rowHeight + anchor.offsetWithinRow, scroller.scrollHeight - scroller.clientHeight));
+ const virtualTargetTop = displayRowIndex * rowHeight + anchor.offsetWithinRow;
+ const nextScrollTop = canvasMode ? canvasDomScrollTop(virtualTargetTop, scroller.clientHeight) : Math.max(0, Math.min(virtualTargetTop, scroller.scrollHeight - scroller.clientHeight));
const virtualScroller = scrollerRef.value;
if (!canvasMode && virtualScroller && !(virtualScroller instanceof HTMLElement)) virtualScroller.scrollToPosition?.(nextScrollTop);
else scroller.scrollTop = nextScrollTop;
@@ -8063,7 +8070,25 @@ const canvasMeasuredDevicePixelSize = ref<CanvasDevicePixelSize | null>(null);
// 与实际屏幕视口像素尺寸不符而触发合成器重采样,导致表格数据模糊(issue #12475)。
const canvasBackingPixelRatio = computed(() => Math.min(MAX_CANVAS_DATA_GRID_PIXEL_RATIO, Math.max(1, canvasDevicePixelRatio.value)));
const useCanvasGridRows = computed(() => dataGridRenderMode.value === "canvas");
-const canvasContentHeight = computed(() => Math.max(1, displayRowCount.value * CANVAS_DATA_GRID_ROW_HEIGHT));
+const canvasContentHeight = computed(() => canvasDataGridContentHeight(displayRowCount.value));
+
+function canvasVirtualScrollTop(domScrollTop: number, viewportHeight = canvasViewportHeight.value): number {
+ return canvasDataGridVirtualScrollTop({
+ scrollTop: domScrollTop,
+ rowCount: displayRowCount.value,
+ rowHeight: CANVAS_DATA_GRID_ROW_HEIGHT,
+ viewportHeight,
+ });
+}
+
+function canvasDomScrollTop(virtualScrollTop: number, viewportHeight = canvasViewportHeight.value): number {
+ return canvasDataGridDomScrollTop({
+ virtualScrollTop,
+ rowCount: displayRowCount.value,
+ rowHeight: CANVAS_DATA_GRID_ROW_HEIGHT,
+ viewportHeight,
+ });
+}
// Clamp the sticky canvas/overlay to the content width. A viewport-wide sticky surface inflates the
// scroller's scrollWidth up to clientWidth, so with few columns it sits right on the overflow threshold
// and the custom horizontal scrollbar flickers while the pane shrinks (canvas width lags clientWidth).
@@ -8135,7 +8160,8 @@ function dataGridCellFromClientPoint(clientX: number, clientY: number): { rowInd
const clampedY = Math.min(rect.bottom - 1, Math.max(rect.top + 1, clientY));
if (useCanvasGridRows.value) {
- const rowIndex = Math.floor((scroller.scrollTop + clampedY - rect.top) / CANVAS_DATA_GRID_ROW_HEIGHT);
+ const virtualScrollTop = canvasVirtualScrollTop(scroller.scrollTop, scroller.clientHeight);
+ const rowIndex = Math.floor((virtualScrollTop + clampedY - rect.top) / CANVAS_DATA_GRID_ROW_HEIGHT);
const visibleColIdx = canvasColumnAt(scroller.scrollLeft + clampedX - rect.left - rowNumberWidth.value);
if (rowIndex < 0 || rowIndex >= displayRowCount.value || visibleColIdx < 0) return null;
const item = displayItemAt(rowIndex);
@@ -8158,7 +8184,8 @@ function dataGridRowFromClientPoint(_clientX: number, clientY: number): number |
const clampedY = Math.min(rect.bottom - 1, Math.max(rect.top + 1, clientY));
if (useCanvasGridRows.value) {
- const rowIndex = Math.floor((scroller.scrollTop + clampedY - rect.top) / CANVAS_DATA_GRID_ROW_HEIGHT);
+ const virtualScrollTop = canvasVirtualScrollTop(scroller.scrollTop, scroller.clientHeight);
+ const rowIndex = Math.floor((virtualScrollTop + clampedY - rect.top) / CANVAS_DATA_GRID_ROW_HEIGHT);
const item = displayItemAt(rowIndex);
return item?.displayIndex ?? null;
}
@@ -8178,7 +8205,7 @@ function syncCanvasViewportRaw(entries?: readonly ResizeObserverEntry[]) {
if (surfaceEntry) canvasMeasuredDevicePixelSize.value = dataGridCanvasDevicePixelSize(surfaceEntry);
canvasViewportWidth.value = scroller.clientWidth;
canvasViewportHeight.value = scroller.clientHeight;
- canvasScrollTop.value = scroller.scrollTop;
+ canvasScrollTop.value = canvasVirtualScrollTop(scroller.scrollTop, scroller.clientHeight);
updateGridScrollbarGutter(scroller);
updateGridHorizontalViewport(scroller);
canvasRuntime?.drawNow();
@@ -8317,7 +8344,8 @@ function canvasHitTest(event: MouseEvent): { rowIndex: number; visibleColIdx: nu
const rect = canvas.getBoundingClientRect();
const x = event.clientX - rect.left;
const y = event.clientY - rect.top;
- const rowIndex = Math.floor((scroller.scrollTop + y) / CANVAS_DATA_GRID_ROW_HEIGHT);
+ const virtualScrollTop = canvasVirtualScrollTop(scroller.scrollTop, scroller.clientHeight);
+ const rowIndex = Math.floor((virtualScrollTop + y) / CANVAS_DATA_GRID_ROW_HEIGHT);
if (rowIndex < 0 || rowIndex >= displayRowCount.value) return null;
if (x < rowNumberWidth.value) return { rowIndex, visibleColIdx: -1, rowNumber: true };
// 冻结列区域不受 scrollLeft 影响,需要特殊处理
@@ -8342,12 +8370,13 @@ function onCanvasScroll(event: Event) {
const scrollLeft = scroller.scrollLeft;
const viewportWidth = scroller.clientWidth;
const viewportHeight = scroller.clientHeight;
- const scrollTopChanged = canvasScrollTop.value !== scrollTop;
+ const virtualScrollTop = canvasVirtualScrollTop(scrollTop, viewportHeight);
+ const scrollTopChanged = canvasScrollTop.value !== virtualScrollTop;
const viewportHeightChanged = canvasViewportHeight.value !== viewportHeight;
const scrollLeftChanged = gridHorizontalScrollLeft.value !== scrollLeft;
const viewportWidthChanged = gridViewportWidth.value !== viewportWidth || canvasViewportWidth.value !== viewportWidth;
- if (canvasScrollTop.value !== scrollTop) canvasScrollTop.value = scrollTop;
+ if (canvasScrollTop.value !== virtualScrollTop) canvasScrollTop.value = virtualScrollTop;
if (canvasViewportWidth.value !== viewportWidth) canvasViewportWidth.value = viewportWidth;
if (canvasViewportHeight.value !== viewportHeight) canvasViewportHeight.value = viewportHeight;
if (scrollLeftChanged || viewportWidthChanged) {
@@ -8826,6 +8855,7 @@ function drawCanvasGrid() {
scroller,
width,
height,
+ virtualScrollTop: canvasVirtualScrollTop(scroller.scrollTop, height),
pixelRatio: canvasBackingPixelRatio.value,
devicePixelSize: canvasMeasuredDevicePixelSize.value,
isDark: isDark.value,
@@ -10766,22 +10796,25 @@ function scrollCanvasRowIntoView(rowIndex: number, block: DataGridScrollAlignmen
const target = Math.max(0, Math.min(displayRowCount.value - 1, rowIndex));
const scroller = canvasScrollerElement();
if (!scroller) return;
- scroller.scrollTop =
+ const currentVirtualScrollTop = canvasVirtualScrollTop(scroller.scrollTop, scroller.clientHeight);
+ const maxVirtualScrollTop = Math.max(0, displayRowCount.value * CANVAS_DATA_GRID_ROW_HEIGHT - scroller.clientHeight);
+ const targetVirtualScrollTop =
previousPageRowIndex === undefined
? dataGridRowScrollTop({
rowIndex: target,
rowHeight: CANVAS_DATA_GRID_ROW_HEIGHT,
viewportHeight: scroller.clientHeight,
- currentScrollTop: scroller.scrollTop,
+ currentScrollTop: currentVirtualScrollTop,
alignment: block,
})
: dataGridPageScrollTop({
previousRowIndex: previousPageRowIndex,
rowIndex: target,
rowHeight: CANVAS_DATA_GRID_ROW_HEIGHT,
- currentScrollTop: scroller.scrollTop,
- maximumScrollTop: scroller.scrollHeight - scroller.clientHeight,
+ currentScrollTop: currentVirtualScrollTop,
+ maximumScrollTop: maxVirtualScrollTop,
});
+ scroller.scrollTop = canvasDomScrollTop(targetVirtualScrollTop, scroller.clientHeight);
syncCanvasViewport();
}
diff --git a/apps/desktop/src/composables/useDataGridLargeValues.ts b/apps/desktop/src/composables/useDataGridLargeValues.ts
index ceeed18c71..3410490d5b 100644
--- a/apps/desktop/src/composables/useDataGridLargeValues.ts
+++ b/apps/desktop/src/composables/useDataGridLargeValues.ts
@@ -56,6 +56,7 @@ export interface UseDataGridLargeValuesOptions {
showTranspose: Ref<boolean>;
displayRowCount: ComputedRef<number>;
gridScrollerElement: () => HTMLElement | null;
+ getScrollTop?: () => number;
displayItemAt: (displayIndex: number) => LargeValueRowItem | undefined;
getRowItem: (rowId: number) => LargeValueRowItem | undefined;
tableColumnForGridColumn: (columnIndex: number) => ColumnInfo | undefined;
@@ -293,7 +294,8 @@ export function useDataGridLargeValues(options: UseDataGridLargeValuesOptions) {
)
return;
- const range = tableDataVisiblePreviewRowRange(scroller.scrollTop, scroller.clientHeight, CANVAS_DATA_GRID_ROW_HEIGHT, options.displayRowCount.value);
+ const scrollTop = options.getScrollTop?.() ?? scroller.scrollTop;
+ const range = tableDataVisiblePreviewRowRange(scrollTop, scroller.clientHeight, CANVAS_DATA_GRID_ROW_HEIGHT, options.displayRowCount.value);
if (!range) return;
const cache = visibleLargeValuePreviewCache(sourceResult);
const activeSourceRows = new Set<number>();
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/canvasDataGridMaxScrollHeight.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/canvasDataGridMaxScrollHeight.spec.ts
new file mode 100644
index 0000000000..533754732c
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/canvasDataGridMaxScrollHeight.spec.ts
@@ -0,0 +1,168 @@
+// @vitest-environment happy-dom
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { CANVAS_DATA_GRID_ROW_HEIGHT, MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT, canvasDataGridContentHeight, canvasDataGridDomScrollTop, canvasDataGridVirtualScrollTop, drawCanvasDataGrid, type DrawCanvasDataGridOptions } from "@/lib/dataGrid/canvasDataGridRenderer";
+
+function createMockCanvas(width = 800, height = 400) {
+ const canvas = document.createElement("canvas");
+ canvas.width = width;
+ canvas.height = height;
+ canvas.style.width = `${width}px`;
+ canvas.style.height = `${height}px`;
+ canvas.style.fontFamily = "sans-serif";
+ canvas.style.fontSize = "13px";
+ canvas.style.fontWeight = "400";
+ canvas.style.lineHeight = "normal";
+
+ const mockCtx = new Proxy(
+ {},
+ {
+ get: (_target, key) => {
+ if (key === "measureText") return () => ({ width: 0 });
+ if (key === "setTransform" || key === "clearRect" || key === "fillRect" || key === "beginPath" || key === "moveTo" || key === "lineTo" || key === "stroke" || key === "rect" || key === "strokeRect") {
+ return () => {};
+ }
+ return () => {};
+ },
+ set: () => true,
+ },
+ ) as unknown as CanvasRenderingContext2D;
+
+ vi.spyOn(canvas, "getContext").mockReturnValue(mockCtx);
+ return canvas;
+}
+
+function createMockScroller(scrollLeft = 0, scrollTop = 0, clientWidth = 800, clientHeight = 400) {
+ const scroller = document.createElement("div");
+ Object.defineProperty(scroller, "scrollLeft", { value: scrollLeft, writable: true, configurable: true });
+ Object.defineProperty(scroller, "scrollTop", { value: scrollTop, writable: true, configurable: true });
+ Object.defineProperty(scroller, "clientWidth", { value: clientWidth, writable: true, configurable: true });
+ Object.defineProperty(scroller, "clientHeight", { value: clientHeight, writable: true, configurable: true });
+ return scroller;
+}
+
+describe("canvasDataGrid max scroll height scaling (#12985)", () => {
+ beforeEach(() => {
+ vi.spyOn(window, "getComputedStyle").mockReturnValue({
+ fontFamily: "sans-serif",
+ fontSize: "13px",
+ fontWeight: "400",
+ lineHeight: "normal",
+ getPropertyValue: () => "",
+ } as unknown as CSSStyleDeclaration);
+ });
+ it("caps DOM content height at MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT for massive row counts", () => {
+ // Normal size: 1:1 rowHeight * rowCount
+ expect(canvasDataGridContentHeight(100)).toBe(100 * CANVAS_DATA_GRID_ROW_HEIGHT);
+ expect(canvasDataGridContentHeight(10_000)).toBe(260_000);
+
+ // Issue #12985: 1,847,762 rows * 26 = 48,041,812px exceeds browser layout unit limits (2^25 = 33,554,432px).
+ // It must be capped at MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT (16,000,000px).
+ const massiveRows = 1_847_762;
+ expect(massiveRows * CANVAS_DATA_GRID_ROW_HEIGHT).toBe(48_041_812);
+ expect(canvasDataGridContentHeight(massiveRows)).toBe(MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT);
+ expect(MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT).toBeLessThan(33_554_432);
+ });
+
+ it("maps scrollTop 1:1 when below the max scroll height limit", () => {
+ const rowCount = 1_000;
+ const viewportHeight = 400;
+
+ // Inside bounds: virtualScrollTop matches DOM scrollTop exactly
+ expect(canvasDataGridVirtualScrollTop({ scrollTop: 0, rowCount, viewportHeight })).toBe(0);
+ expect(canvasDataGridVirtualScrollTop({ scrollTop: 500, rowCount, viewportHeight })).toBe(500);
+ expect(canvasDataGridVirtualScrollTop({ scrollTop: 25_600, rowCount, viewportHeight })).toBe(25_600);
+
+ // DOM scroll top matches virtual scroll top exactly
+ expect(canvasDataGridDomScrollTop({ virtualScrollTop: 0, rowCount, viewportHeight })).toBe(0);
+ expect(canvasDataGridDomScrollTop({ virtualScrollTop: 500, rowCount, viewportHeight })).toBe(500);
+ expect(canvasDataGridDomScrollTop({ virtualScrollTop: 25_600, rowCount, viewportHeight })).toBe(25_600);
+ });
+
+ it("scales scrollTop proportionally across the full dataset when row count exceeds max scroll height", () => {
+ const rowCount = 1_847_762;
+ const viewportHeight = 1_000;
+ const virtualHeight = rowCount * CANVAS_DATA_GRID_ROW_HEIGHT; // 48,041,812
+ const maxDomScrollTop = MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT - viewportHeight; // 15,999,000
+ const maxVirtualScrollTop = virtualHeight - viewportHeight; // 48,040,812
+
+ // At the very top (first row)
+ expect(canvasDataGridVirtualScrollTop({ scrollTop: 0, rowCount, viewportHeight })).toBe(0);
+ expect(canvasDataGridDomScrollTop({ virtualScrollTop: 0, rowCount, viewportHeight })).toBe(0);
+
+ // At the very bottom (last row): must reach maxVirtualScrollTop so the final row is visible
+ expect(canvasDataGridVirtualScrollTop({ scrollTop: maxDomScrollTop, rowCount, viewportHeight })).toBe(maxVirtualScrollTop);
+ expect(canvasDataGridDomScrollTop({ virtualScrollTop: maxVirtualScrollTop, rowCount, viewportHeight })).toBe(maxDomScrollTop);
+
+ // At midpoint
+ const midDomScroll = maxDomScrollTop / 2;
+ const midVirtualScroll = canvasDataGridVirtualScrollTop({ scrollTop: midDomScroll, rowCount, viewportHeight });
+ expect(midVirtualScroll).toBeCloseTo(maxVirtualScrollTop / 2, 0);
+
+ // Roundtrip consistency
+ const roundtrip = canvasDataGridDomScrollTop({ virtualScrollTop: midVirtualScroll, rowCount, viewportHeight });
+ expect(roundtrip).toBeCloseTo(midDomScroll, 0);
+ });
+
+ it("handles empty and single-row tables without division by zero", () => {
+ expect(canvasDataGridVirtualScrollTop({ scrollTop: 0, rowCount: 0, viewportHeight: 500 })).toBe(0);
+ expect(canvasDataGridVirtualScrollTop({ scrollTop: 100, rowCount: 1, viewportHeight: 500 })).toBe(0);
+ expect(canvasDataGridDomScrollTop({ virtualScrollTop: 0, rowCount: 0, viewportHeight: 500 })).toBe(0);
+ expect(canvasDataGridDomScrollTop({ virtualScrollTop: 100, rowCount: 1, viewportHeight: 500 })).toBe(0);
+ });
+
+ it("draws the last row of a massive 1.8M-row dataset when virtualScrollTop is at the end", () => {
+ const rowCount = 1_847_762;
+ const viewportWidth = 800;
+ const viewportHeight = 500;
+ const virtualHeight = rowCount * CANVAS_DATA_GRID_ROW_HEIGHT;
+ const maxVirtualScrollTop = virtualHeight - viewportHeight;
+
+ const requestedRows: number[] = [];
+ const options: DrawCanvasDataGridOptions = {
+ canvas: createMockCanvas(viewportWidth, viewportHeight),
+ scroller: createMockScroller(0, MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT - viewportHeight, viewportWidth, viewportHeight),
+ width: viewportWidth,
+ height: viewportHeight,
+ virtualScrollTop: maxVirtualScrollTop,
+ isDark: false,
+ rowCount,
+ rowAt: (index) => {
+ requestedRows.push(index);
+ return {
+ id: index,
+ displayIndex: index,
+ data: [`row-${index}`],
+ isNew: false,
+ isDeleted: false,
+ isDirtyCol: [false],
+ status: "clean",
+ };
+ },
+ renderedColumnWidths: [400],
+ renderedColumnOffsets: [0, 400],
+ visibleColumnIndexes: [0],
+ rowNumberWidth: 80,
+ hoverCell: null,
+ isScrolling: false,
+ editingCell: null,
+ searchMatchKeys: new Set(),
+ currentSearchMatch: null,
+ formatCell: (val) => String(val),
+ isRowActive: () => false,
+ rowCellsUseSelectionVisual: () => false,
+ cellIsSelected: () => false,
+ cellCanHover: () => false,
+ infiniteScrollEnabled: false,
+ pageOffset: 0,
+ flatteningMultiLineEnabled: false,
+ };
+
+ const drawn = drawCanvasDataGrid(options);
+ expect(drawn).toBe(true);
+
+ // The very last row (index 1,847,761) must have been rendered!
+ expect(requestedRows).toContain(rowCount - 1);
+ expect(Math.max(...requestedRows)).toBe(rowCount - 1);
+ });
+});
diff --git a/apps/desktop/src/lib/dataGrid/canvasDataGridRenderer.ts b/apps/desktop/src/lib/dataGrid/canvasDataGridRenderer.ts
index f02f6871e0..1306e8f5b6 100644
--- a/apps/desktop/src/lib/dataGrid/canvasDataGridRenderer.ts
+++ b/apps/desktop/src/lib/dataGrid/canvasDataGridRenderer.ts
@@ -11,6 +11,48 @@ import { resolveDataGridRowNumberLabel } from "@/lib/dataGrid/dataGridRowNumber"
export const CANVAS_DATA_GRID_ROW_HEIGHT = 26;
export const MAX_CANVAS_DATA_GRID_PIXEL_RATIO = 4;
+/**
+ * Cross-browser maximum element scroll height to prevent browser layout clamping.
+ * Blink and WebKit clamp element layout dimensions to LayoutUnit::max() (33,554,432px = 2^25),
+ * while Gecko/Firefox clamps around 17,895,697px (~2^24). Keeping the DOM container
+ * height within 16,000,000px guarantees safe, uninterrupted virtual scrolling across all browsers.
+ */
+export const MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT = 16_000_000;
+
+export function canvasDataGridContentHeight(rowCount: number, rowHeight = CANVAS_DATA_GRID_ROW_HEIGHT, maxScrollHeight = MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT): number {
+ const virtualHeight = Math.max(1, rowCount * rowHeight);
+ return Math.min(virtualHeight, maxScrollHeight);
+}
+
+export function canvasDataGridVirtualScrollTop(options: { scrollTop: number; rowCount: number; rowHeight?: number; viewportHeight: number; maxScrollHeight?: number }): number {
+ const rowHeight = options.rowHeight ?? CANVAS_DATA_GRID_ROW_HEIGHT;
+ const maxScrollHeight = options.maxScrollHeight ?? MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT;
+ const virtualHeight = Math.max(1, options.rowCount * rowHeight);
+ const domHeight = Math.min(virtualHeight, maxScrollHeight);
+ const maxDomScrollTop = Math.max(0, domHeight - options.viewportHeight);
+ const maxVirtualScrollTop = Math.max(0, virtualHeight - options.viewportHeight);
+
+ if (maxDomScrollTop <= 0 || maxVirtualScrollTop <= 0) return 0;
+ if (virtualHeight <= maxScrollHeight) return Math.min(maxDomScrollTop, Math.max(0, options.scrollTop));
+
+ const ratio = Math.min(1, Math.max(0, options.scrollTop / maxDomScrollTop));
+ return ratio * maxVirtualScrollTop;
+}
+
+export function canvasDataGridDomScrollTop(options: { virtualScrollTop: number; rowCount: number; rowHeight?: number; viewportHeight: number; maxScrollHeight?: number }): number {
+ const rowHeight = options.rowHeight ?? CANVAS_DATA_GRID_ROW_HEIGHT;
+ const maxScrollHeight = options.maxScrollHeight ?? MAX_CANVAS_DATA_GRID_SCROLL_HEIGHT;
+ const virtualHeight = Math.max(1, options.rowCount * rowHeight);
+ const domHeight = Math.min(virtualHeight, maxScrollHeight);
+ const maxDomScrollTop = Math.max(0, domHeight - options.viewportHeight);
+ const maxVirtualScrollTop = Math.max(0, virtualHeight - options.viewportHeight);
+
+ if (maxDomScrollTop <= 0 || maxVirtualScrollTop <= 0) return 0;
+ if (virtualHeight <= maxScrollHeight) return Math.min(maxVirtualScrollTop, Math.max(0, options.virtualScrollTop));
+
+ const ratio = Math.min(1, Math.max(0, options.virtualScrollTop / maxVirtualScrollTop));
+ return ratio * maxDomScrollTop;
+}
export interface CanvasDevicePixelSize {
cssWidth: number;
@@ -63,6 +105,7 @@ export interface DrawCanvasDataGridOptions {
scroller: HTMLElement;
width: number;
height: number;
+ virtualScrollTop?: number;
pixelRatio?: number;
devicePixelSize?: CanvasDevicePixelSize | null;
isDark: boolean;
@@ -442,7 +485,7 @@ export function drawCanvasDataGrid(options: DrawCanvasDataGridOptions): boolean
const crosshairRowBg = rawCrosshairRowBg?.trim() || theme.cellCrosshairRow;
const crosshairColBg = rawCrosshairColBg?.trim() || theme.cellCrosshairCol;
- const scrollTop = scroller.scrollTop;
+ const scrollTop = options.virtualScrollTop ?? scroller.scrollTop;
const scrollLeft = scroller.scrollLeft;
const firstRow = Math.max(0, Math.floor(scrollTop / CANVAS_DATA_GRID_ROW_HEIGHT));
const lastRow = Math.min(rowCount - 1, Math.ceil((scrollTop + height) / CANVAS_DATA_GRID_ROW_HEIGHT));