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): 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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): DataGridColum
for (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: DataGri
measurementSignature: 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) {