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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(grid): invalidate only auto-calculated column widths on font or density changes (#12913)
lxk955d696e1f7441c
diff --git a/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.tsindex 64132287d8..78aa9c8149 100644--- a/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts+++ b/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts@@ -415,6 +415,49 @@ describe("useDataGridColumnResize", () => {expect(remounted.columnWidths.value[0]).not.toBe(fittedWidth);});+ it("preserves manually resized column widths while invalidating auto columns when density or font metrics change", async () => {+ const state = createResizeState({+ columns: ["id", "description"],+ rows: [[1, "x".repeat(120)]],+ cacheKey: "result-manual-preservation",+ });+ state.initColumnWidths();++ const initialAutoWidth = state.columnWidths.value[1];++ // User manually resizes column 0+ state.onResizeStart(0, new MouseEvent("mousedown", { clientX: 100, cancelable: true }));+ document.dispatchEvent(new MouseEvent("mouseup", { clientX: 260 }));+ const manualWidth = state.columnWidths.value[0];+ expect(manualWidth).toBeGreaterThan(160);++ // Change density from standard to compact+ state.setDensity("compact");+ await nextTick();++ // Manually resized column 0 preserves its exact width+ expect(state.columnWidths.value[0]).toBe(manualWidth);+ // Auto calculated column 1 recalculates with compact density+ expect(state.columnWidths.value[1]).not.toBe(initialAutoWidth);++ // Remount with compact density and new font metric+ state.setHeaderTextWidth(220);+ await nextTick();+ const remounted = createResizeState({+ columns: ["id", "description"],+ rows: [[2, "short"]],+ cacheKey: "result-manual-preservation",+ density: "compact",+ headerTextWidth: 220,+ });+ remounted.initColumnWidths();++ // Manually resized column 0 is restored from cache+ expect(remounted.columnWidths.value[0]).toBe(manualWidth);+ // Auto column 1 is recalculated from the new rows and font metrics+ expect(remounted.columnWidths.value[1]).not.toBe(initialAutoWidth);+ });+it("evicts the least recently used width states at the cache limit", () => {const structureSignature = createDataGridColumnStructureSignature(["id"]);const measurementSignature = createDataGridColumnMeasurementSignature("standard", true, 14);diff --git a/apps/desktop/src/composables/useDataGridColumnResize.ts b/apps/desktop/src/composables/useDataGridColumnResize.tsindex 4b32a6e735..a86c2710fe 100644--- a/apps/desktop/src/composables/useDataGridColumnResize.ts+++ b/apps/desktop/src/composables/useDataGridColumnResize.ts@@ -53,9 +53,10 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)const columnWidths = ref<number[]>([]);let isResizing = false;let previousColumnIndexes: number[] = [];- // Replaced wholesale instead of mutated so reactive consumers (renderedColumnWidths)- // re-run when a column becomes user-sized and stops receiving spare width.- const userSizedColumnIndexes = shallowRef<Set<number>>(new Set());+ // User manual drag/input vs auto-calculated (default or auto-fit).+ // Only manual widths survive font metrics/density changes and persist across sessions.+ const manualColumnIndexes = shallowRef<Set<number>>(new Set());+ const autoFittedColumnIndexes = shallowRef<Set<number>>(new Set());function columnWidthStateIdentity() {return {@@ -66,7 +67,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)}function persistColumnWidths() {- saveDataGridColumnWidthState(columnWidthStateIdentity(), previousColumnIndexes, columnWidths.value, userSizedColumnIndexes.value);+ saveDataGridColumnWidthState(columnWidthStateIdentity(), previousColumnIndexes, columnWidths.value, manualColumnIndexes.value, autoFittedColumnIndexes.value);}function sampleColumnValues(visibleColIdx: number): CellValue[] {@@ -100,7 +101,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)const next = columnWidths.value.slice();for (let colIdx = 0; colIdx < columns.value.length; colIdx++) {const actualColIdx = columnIndexes.value[colIdx];- if (actualColIdx === undefined || userSizedColumnIndexes.value.has(actualColIdx)) continue;+ if (actualColIdx === undefined || manualColumnIndexes.value.has(actualColIdx) || autoFittedColumnIndexes.value.has(actualColIdx)) continue;const needed = neededWidths[colIdx] ?? DATA_GRID_COL_MIN_WIDTH;if (needed > (next[colIdx] ?? 0)) {next[colIdx] = needed;@@ -112,16 +113,41 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)persistColumnWidths();}- function markColumnUserSized(visibleColIdx: number) {+ function markColumnManualSized(visibleColIdx: number) {const actualColIdx = columnIndexes.value[visibleColIdx];- if (actualColIdx === undefined || userSizedColumnIndexes.value.has(actualColIdx)) return;- const next = new Set(userSizedColumnIndexes.value);- next.add(actualColIdx);- userSizedColumnIndexes.value = next;+ if (actualColIdx === undefined) return;+ if (autoFittedColumnIndexes.value.has(actualColIdx)) {+ const nextAuto = new Set(autoFittedColumnIndexes.value);+ nextAuto.delete(actualColIdx);+ autoFittedColumnIndexes.value = nextAuto;+ }+ if (!manualColumnIndexes.value.has(actualColIdx)) {+ const nextManual = new Set(manualColumnIndexes.value);+ nextManual.add(actualColIdx);+ manualColumnIndexes.value = nextManual;+ }+ }++ function markColumnAutoFitted(visibleColIdx: number) {+ const actualColIdx = columnIndexes.value[visibleColIdx];+ if (actualColIdx === undefined) return;+ if (manualColumnIndexes.value.has(actualColIdx)) {+ const nextManual = new Set(manualColumnIndexes.value);+ nextManual.delete(actualColIdx);+ manualColumnIndexes.value = nextManual;+ }+ if (!autoFittedColumnIndexes.value.has(actualColIdx)) {+ const nextAuto = new Set(autoFittedColumnIndexes.value);+ nextAuto.add(actualColIdx);+ autoFittedColumnIndexes.value = nextAuto;+ }}function initColumnWidths(force = false) {- if (force) userSizedColumnIndexes.value = new Set();+ if (force) {+ manualColumnIndexes.value = new Set();+ autoFittedColumnIndexes.value = new Set();+ }const previousWidthsByColumnIndex = new Map<number, number>();previousColumnIndexes.forEach((columnIndex, visibleIndex) => {const width = columnWidths.value[visibleIndex];@@ -129,7 +155,10 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)});const nextColumnIndexes = [...columnIndexes.value];const cachedState = !force && previousColumnIndexes.length === 0 ? loadDataGridColumnWidthState(columnWidthStateIdentity(), nextColumnIndexes) : undefined;- if (cachedState) userSizedColumnIndexes.value = new Set(cachedState.userSizedColumnIndexes);+ if (cachedState) {+ manualColumnIndexes.value = new Set(cachedState.userSizedColumnIndexes);+ autoFittedColumnIndexes.value = new Set(cachedState.autoFittedColumnIndexes ?? []);+ }const currentNeededWidths = neededColumnWidths.value ?? [];const columnCount = columns.value?.length ?? 0;if (force || columnWidths.value.length !== columnCount || previousColumnIndexes.join("\0") !== nextColumnIndexes.join("\0")) {@@ -158,7 +187,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)// as-is instead of re-stretching it with the remaining surplus, and the// stored (persisted) width matches what the cursor moved.const startWidth = renderedColumnWidths.value[colIdx] ?? DATA_GRID_COL_MIN_WIDTH;- markColumnUserSized(colIdx);+ markColumnManualSized(colIdx);columnWidths.value[colIdx] = startWidth;let pendingClientX = startX;let resizeFrame = 0;@@ -189,7 +218,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)cancelPendingFrame();pendingClientX = e.clientX;applyPendingWidth();- markColumnUserSized(colIdx);+ markColumnManualSized(colIdx);persistColumnWidths();requestAnimationFrame(() => {isResizing = false;@@ -222,7 +251,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)const width = autoFitColumnWidth(colIdx);if (width === undefined) return;columnWidths.value[colIdx] = width;- markColumnUserSized(colIdx);+ markColumnAutoFitted(colIdx);persistColumnWidths();}@@ -237,7 +266,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)for (let colIdx = 0; colIdx < columns.value.length; colIdx++) {const width = autoFitColumnWidth(colIdx);if (width === undefined) continue;- markColumnUserSized(colIdx);+ markColumnAutoFitted(colIdx);if (next[colIdx] !== width) {next[colIdx] = width;changed = true;@@ -257,7 +286,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)if (surplus <= 0) return widths;const flexibleIndexes = widths.flatMap((_, visibleIndex) => {const actualIndex = columnIndexes.value[visibleIndex];- return actualIndex !== undefined && !userSizedColumnIndexes.value.has(actualIndex) ? [visibleIndex] : [];+ return actualIndex !== undefined && !manualColumnIndexes.value.has(actualIndex) && !autoFittedColumnIndexes.value.has(actualIndex) ? [visibleIndex] : [];});if (flexibleIndexes.length === 0) return widths;const base = Math.floor(surplus / flexibleIndexes.length);@@ -291,13 +320,39 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions)watch([() => options.cacheKey?.value, options.columnStructureSignature], () => {columnWidths.value = [];previousColumnIndexes = [];- userSizedColumnIndexes.value = new Set();+ manualColumnIndexes.value = new Set();+ autoFittedColumnIndexes.value = new Set();initColumnWidths();});+ function recomputeAutoColumnWidths() {+ if (columnWidths.value.length === 0) {+ initColumnWidths();+ return;+ }+ const nextColumnIndexes = [...columnIndexes.value];+ const currentNeededWidths = neededColumnWidths.value ?? [];+ autoFittedColumnIndexes.value = new Set();+ columnWidths.value = (columns.value ?? []).map((_, colIdx) => {+ const actualColIdx = nextColumnIndexes[colIdx];+ if (actualColIdx !== undefined && manualColumnIndexes.value.has(actualColIdx)) {+ const existingWidth = columnWidths.value[colIdx];+ if (existingWidth !== undefined) return existingWidth;+ }+ return currentNeededWidths[colIdx] ?? DATA_GRID_COL_MIN_WIDTH;+ });+ previousColumnIndexes = nextColumnIndexes;+ growColumnWidthsToFitSamples(currentNeededWidths);+ if (manualColumnIndexes.value.size > 0) {+ persistColumnWidths();+ } else {+ removeDataGridColumnWidthState(options.cacheKey?.value);+ }+ }+watch([density, compactColumnHeaderActions, () => options.headerMeasurementKey?.value], () => {- // Widths measured with different density or font metrics are unsafe to reuse.- removeDataGridColumnWidthState(options.cacheKey?.value);- initColumnWidths(true);+ // Font metrics and density changes invalidate only auto-calculated column widths.+ // User-sized column widths represent explicit pixel choices and must be preserved.+ recomputeAutoColumnWidths();});watch(neededColumnWidthSignature, () => growColumnWidthsToFitSamples(neededColumnWidths.value));diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnWidthState.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnWidthState.spec.tsindex f0111f41b1..31d16c6f22 100644--- a/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnWidthState.spec.ts+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnWidthState.spec.ts@@ -65,12 +65,25 @@ describe("dataGridColumnWidthState", () => {expect(loaded).toBeUndefined();});- it("rejects persisted widths when measurement signature does not match", () => {+ it("invalidates auto-calculated widths but retains user-sized widths across measurement changes", () => {const identity = { cacheKey: "result-font-change", structureSignature, measurementSignature };saveDataGridColumnWidthState(identity, [0, 1], [100, 200], new Set([1]));const differentMeasurement = createDataGridColumnMeasurementSignature("standard", true, [16, "Roboto"]);const loaded = loadDataGridColumnWidthState({ cacheKey: "result-font-change", structureSignature, measurementSignature: differentMeasurement }, [0, 1]);+ expect(loaded).toEqual({+ widths: [undefined, 200],+ userSizedColumnIndexes: new Set([1]),+ autoFittedColumnIndexes: new Set(),+ });+ });++ it("completely invalidates cached widths when measurement changes and no columns are user-sized", () => {+ const identity = { cacheKey: "result-font-change-auto-only", structureSignature, measurementSignature };+ saveDataGridColumnWidthState(identity, [0, 1], [100, 200], new Set());++ const differentMeasurement = createDataGridColumnMeasurementSignature("standard", true, [16, "Roboto"]);+ const loaded = loadDataGridColumnWidthState({ cacheKey: "result-font-change-auto-only", structureSignature, measurementSignature: differentMeasurement }, [0, 1]);expect(loaded).toBeUndefined();});diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.tsindex 63e258c05d..414a9dc561 100644--- a/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts@@ -10,6 +10,7 @@ interface DataGridColumnWidthState {measurementSignature: string;widthsByColumnIndex: Map<number, number>;userSizedColumnIndexes: Set<number>;+ autoFittedColumnIndexes?: Set<number>;}interface StoredDataGridColumnWidthState {@@ -18,6 +19,7 @@ interface StoredDataGridColumnWidthState {measurementSignature: string;widths: Array<[number, number]>;userSizedColumnIndexes: number[];+ autoFittedColumnIndexes?: number[];}interface DataGridColumnWidthStateIdentity {@@ -29,6 +31,7 @@ interface DataGridColumnWidthStateIdentity {export interface DataGridColumnWidthStateSnapshot {widths: Array<number | undefined>;userSizedColumnIndexes: Set<number>;+ autoFittedColumnIndexes?: Set<number>;}const columnWidthStates = new Map<string, DataGridColumnWidthState>();@@ -88,12 +91,19 @@ function loadPersistentDataGridColumnWidthState(cacheKey: string): DataGridColumfor (const index of parsed.userSizedColumnIndexes) {if (typeof index === "number") userSizedColumnIndexes.add(index);}+ const autoFittedColumnIndexes = new Set<number>();+ if (Array.isArray(parsed.autoFittedColumnIndexes)) {+ for (const index of parsed.autoFittedColumnIndexes) {+ if (typeof index === "number") autoFittedColumnIndexes.add(index);+ }+ }touchStorageKey(cacheKey);return {structureSignature: parsed.structureSignature,measurementSignature: parsed.measurementSignature,widthsByColumnIndex,userSizedColumnIndexes,+ autoFittedColumnIndexes,};} catch {removeStorageKey(cacheKey);@@ -108,6 +118,7 @@ function savePersistentDataGridColumnWidthState(cacheKey: string, state: DataGrimeasurementSignature: state.measurementSignature,widths: Array.from(state.widthsByColumnIndex.entries()),userSizedColumnIndexes: Array.from(state.userSizedColumnIndexes),+ ...(state.autoFittedColumnIndexes && state.autoFittedColumnIndexes.size > 0 ? { autoFittedColumnIndexes: Array.from(state.autoFittedColumnIndexes) } : {}),};safeLocalStorageSet(`${STORAGE_PREFIX}${cacheKey}`, JSON.stringify(payload));touchStorageKey(cacheKey);@@ -144,35 +155,95 @@ export function loadDataGridColumnWidthState(identity: DataGridColumnWidthStateI}}if (!state) return undefined;- if (state.structureSignature !== identity.structureSignature || state.measurementSignature !== identity.measurementSignature) {+ if (state.structureSignature !== identity.structureSignature) {columnWidthStates.delete(cacheKey);removePersistentDataGridColumnWidthState(cacheKey);return undefined;}+ if (state.measurementSignature !== identity.measurementSignature) {+ if (state.userSizedColumnIndexes.size === 0) {+ columnWidthStates.delete(cacheKey);+ removePersistentDataGridColumnWidthState(cacheKey);+ return undefined;+ }+ const userWidthsByColumnIndex = new Map<number, number>();+ for (const columnIndex of state.userSizedColumnIndexes) {+ const width = state.widthsByColumnIndex.get(columnIndex);+ if (width !== undefined && Number.isFinite(width)) {+ userWidthsByColumnIndex.set(columnIndex, width);+ }+ }+ if (userWidthsByColumnIndex.size === 0) {+ columnWidthStates.delete(cacheKey);+ removePersistentDataGridColumnWidthState(cacheKey);+ return undefined;+ }+ state.measurementSignature = identity.measurementSignature;+ state.widthsByColumnIndex = userWidthsByColumnIndex;+ state.autoFittedColumnIndexes?.clear();+ touchColumnWidthState(cacheKey, state);+ savePersistentDataGridColumnWidthState(cacheKey, state);+ return {+ widths: columnIndexes.map((columnIndex) => (state.userSizedColumnIndexes.has(columnIndex) ? state.widthsByColumnIndex.get(columnIndex) : undefined)),+ userSizedColumnIndexes: new Set(state.userSizedColumnIndexes),+ autoFittedColumnIndexes: new Set(),+ };+ }touchColumnWidthState(cacheKey, state);return {widths: columnIndexes.map((columnIndex) => state.widthsByColumnIndex.get(columnIndex)),userSizedColumnIndexes: new Set(state.userSizedColumnIndexes),+ autoFittedColumnIndexes: new Set(state.autoFittedColumnIndexes ?? []),};}-export function saveDataGridColumnWidthState(identity: DataGridColumnWidthStateIdentity, columnIndexes: readonly number[], widths: readonly number[], userSizedColumnIndexes: ReadonlySet<number>) {+export function saveDataGridColumnWidthState(identity: DataGridColumnWidthStateIdentity, columnIndexes: readonly number[], widths: readonly number[], userSizedColumnIndexes: ReadonlySet<number>, autoFittedColumnIndexes?: ReadonlySet<number>) {const cacheKey = identity.cacheKey?.trim();if (!cacheKey || columnIndexes.length !== widths.length) return;const existing = columnWidthStates.get(cacheKey) ?? loadPersistentDataGridColumnWidthState(cacheKey);- const widthsByColumnIndex = existing?.structureSignature === identity.structureSignature && existing.measurementSignature === identity.measurementSignature ? new Map(existing.widthsByColumnIndex) : new Map<number, number>();- const nextUserSizedColumnIndexes = existing?.structureSignature === identity.structureSignature && existing.measurementSignature === identity.measurementSignature ? new Set(existing.userSizedColumnIndexes) : new Set<number>();+ const sameStructure = existing?.structureSignature === identity.structureSignature;+ const sameMeasurement = existing?.measurementSignature === identity.measurementSignature;+ const widthsByColumnIndex = new Map<number, number>();+ const nextUserSizedColumnIndexes = new Set<number>();+ const nextAutoFittedColumnIndexes = new Set<number>();++ if (sameStructure && existing) {+ for (const [columnIndex, width] of existing.widthsByColumnIndex) {+ if (sameMeasurement || existing.userSizedColumnIndexes.has(columnIndex)) {+ widthsByColumnIndex.set(columnIndex, width);+ }+ }+ for (const columnIndex of existing.userSizedColumnIndexes) {+ nextUserSizedColumnIndexes.add(columnIndex);+ }+ if (sameMeasurement && existing.autoFittedColumnIndexes) {+ for (const columnIndex of existing.autoFittedColumnIndexes) {+ nextAutoFittedColumnIndexes.add(columnIndex);+ }+ }+ }+columnIndexes.forEach((columnIndex, visibleIndex) => {const width = widths[visibleIndex];if (Number.isFinite(width)) widthsByColumnIndex.set(columnIndex, width);- if (userSizedColumnIndexes.has(columnIndex)) nextUserSizedColumnIndexes.add(columnIndex);- else nextUserSizedColumnIndexes.delete(columnIndex);+ if (userSizedColumnIndexes.has(columnIndex)) {+ nextUserSizedColumnIndexes.add(columnIndex);+ nextAutoFittedColumnIndexes.delete(columnIndex);+ } else {+ nextUserSizedColumnIndexes.delete(columnIndex);+ }+ if (autoFittedColumnIndexes?.has(columnIndex)) {+ nextAutoFittedColumnIndexes.add(columnIndex);+ } else if (autoFittedColumnIndexes !== undefined) {+ nextAutoFittedColumnIndexes.delete(columnIndex);+ }});const nextState: DataGridColumnWidthState = {structureSignature: identity.structureSignature,measurementSignature: identity.measurementSignature,widthsByColumnIndex,userSizedColumnIndexes: nextUserSizedColumnIndexes,+ autoFittedColumnIndexes: nextAutoFittedColumnIndexes,};touchColumnWidthState(cacheKey, nextState);if (nextUserSizedColumnIndexes.size > 0) {