diff --git a/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts index 146ee8b5ae..f03a2384d0 100644 --- a/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts +++ b/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts @@ -1,19 +1,29 @@ // @vitest-environment happy-dom -import { computed, nextTick, ref } from "vue"; +import { computed, isRef, nextTick, ref } from "vue"; import { beforeEach, describe, expect, it } from "vitest"; -import { DATA_GRID_COL_AUTO_FIT_MAX_WIDTH, DATA_GRID_COL_MIN_WIDTH } from "@/lib/dataGrid/dataGridColumnWidth"; +import { DATA_GRID_COL_AUTO_FIT_MAX_WIDTH, DATA_GRID_COL_MIN_WIDTH, sampleDataGridColumnValues } from "@/lib/dataGrid/dataGridColumnWidth"; import { clearDataGridColumnWidthStates, createDataGridColumnMeasurementSignature, createDataGridColumnStructureSignature, DATA_GRID_COLUMN_WIDTH_STATE_LIMIT, dataGridColumnWidthStateCount, loadDataGridColumnWidthState, saveDataGridColumnWidthState } from "@/lib/dataGrid/dataGridColumnWidthState"; -import { DATA_GRID_ROW_NUM_WIDTH, dataGridRowNumberColumnWidth, resizeDataGridColumnWidth, resolveDataGridMaxRowNumber, useDataGridColumnResize } from "@/composables/useDataGridColumnResize"; +import { DATA_GRID_ROW_NUM_WIDTH, dataGridRowNumberColumnWidth, resizeDataGridColumnWidth, useDataGridColumnResize } from "@/composables/useDataGridColumnResize"; -function createResizeState(options: { columns: string[]; rows: Array>; columnIndexes?: number[]; columnTypes?: string[]; cacheKey?: string; density?: "compact" | "standard" | "comfortable"; compactColumnHeaderActions?: boolean; headerTextWidth?: number }) { +function createResizeState(options: { + columns: string[]; + rows: Array> | ReturnType>>>; + columnIndexes?: number[]; + columnTypes?: string[]; + cacheKey?: string; + density?: "compact" | "standard" | "comfortable"; + compactColumnHeaderActions?: boolean; + headerTextWidth?: number; +}) { const compact = ref(options.compactColumnHeaderActions ?? true); const headerTextWidth = ref(options.headerTextWidth); const headerMeasurementKey = ref(0); const density = ref(options.density ?? "standard"); + const rows = isRef(options.rows) ? options.rows : ref(options.rows); const state = useDataGridColumnResize({ columns: computed(() => options.columns), - sourceRows: computed(() => options.rows), + sourceRows: computed(() => rows.value), columnIndexes: computed(() => options.columnIndexes ?? options.columns.map((_, index) => index)), density, compactColumnHeaderActions: computed(() => compact.value), @@ -24,6 +34,7 @@ function createResizeState(options: { columns: string[]; rows: Array { }); state.initColumnWidths(); - // standard valueTextLimit=40, 120 chars → truncated to 40: 40×8+24=344 - // header "description"=11×8+85=173 < 344 → 344 - expect(state.columnWidths.value[0]).toBe(344); + // standard valueTextLimit=40, 120 chars → truncated to 40: 40×8+24+12=356 + // header "description"=11×8+59=147 < 356 → 356 + expect(state.columnWidths.value[0]).toBe(356); state.autoFitColumn(0); - expect(state.columnWidths.value[0]).toBeGreaterThan(344); + expect(state.columnWidths.value[0]).toBeGreaterThan(356); expect(state.columnWidths.value[0]).toBeLessThanOrEqual(DATA_GRID_COL_AUTO_FIT_MAX_WIDTH); }); @@ -122,6 +133,15 @@ describe("useDataGridColumnResize", () => { first.onResizeStart(1, new MouseEvent("mousedown", { clientX: 100, cancelable: true })); document.dispatchEvent(new MouseEvent("mouseup", { clientX: 160 })); expect(first.columnWidths.value[1]).toBe(originalWidth + 60); + const persisted = loadDataGridColumnWidthState( + { + cacheKey: "result-a", + structureSignature: createDataGridColumnStructureSignature(["id", "name"]), + measurementSignature: createDataGridColumnMeasurementSignature("standard", true, 0), + }, + [0, 1], + ); + expect(persisted?.userSizedColumnIndexes).toEqual(new Set([1])); const remounted = createResizeState({ columns: ["id", "name"], @@ -177,15 +197,15 @@ describe("useDataGridColumnResize", () => { const structureSignature = createDataGridColumnStructureSignature(["id"]); const measurementSignature = createDataGridColumnMeasurementSignature("standard", true, 14); for (let index = 0; index < DATA_GRID_COLUMN_WIDTH_STATE_LIMIT; index++) { - saveDataGridColumnWidthState({ cacheKey: `result-${index}`, structureSignature, measurementSignature }, [0], [100 + index]); + saveDataGridColumnWidthState({ cacheKey: `result-${index}`, structureSignature, measurementSignature }, [0], [100 + index], new Set()); } - expect(loadDataGridColumnWidthState({ cacheKey: "result-0", structureSignature, measurementSignature }, [0])).toEqual([100]); - saveDataGridColumnWidthState({ cacheKey: `result-${DATA_GRID_COLUMN_WIDTH_STATE_LIMIT}`, structureSignature, measurementSignature }, [0], [100 + DATA_GRID_COLUMN_WIDTH_STATE_LIMIT]); + expect(loadDataGridColumnWidthState({ cacheKey: "result-0", structureSignature, measurementSignature }, [0])?.widths).toEqual([100]); + saveDataGridColumnWidthState({ cacheKey: `result-${DATA_GRID_COLUMN_WIDTH_STATE_LIMIT}`, structureSignature, measurementSignature }, [0], [100 + DATA_GRID_COLUMN_WIDTH_STATE_LIMIT], new Set()); expect(dataGridColumnWidthStateCount()).toBe(DATA_GRID_COLUMN_WIDTH_STATE_LIMIT); expect(loadDataGridColumnWidthState({ cacheKey: "result-1", structureSignature, measurementSignature }, [0])).toBeUndefined(); - expect(loadDataGridColumnWidthState({ cacheKey: "result-0", structureSignature, measurementSignature }, [0])).toEqual([100]); - expect(loadDataGridColumnWidthState({ cacheKey: `result-${DATA_GRID_COLUMN_WIDTH_STATE_LIMIT}`, structureSignature, measurementSignature }, [0])).toEqual([100 + DATA_GRID_COLUMN_WIDTH_STATE_LIMIT]); + expect(loadDataGridColumnWidthState({ cacheKey: "result-0", structureSignature, measurementSignature }, [0])?.widths).toEqual([100]); + expect(loadDataGridColumnWidthState({ cacheKey: `result-${DATA_GRID_COLUMN_WIDTH_STATE_LIMIT}`, structureSignature, measurementSignature }, [0])?.widths).toEqual([100 + DATA_GRID_COLUMN_WIDTH_STATE_LIMIT]); }); it("recalculates column widths when compactColumnHeaderActions changes", async () => { @@ -274,11 +294,132 @@ describe("useDataGridColumnResize", () => { state.initColumnWidths(); // P95 of 50 samples ignores the single 200-char outlier; - // "short" = 5 chars → 5×8+24=64, header "data"=4×8+59=91 → max=91 + // "short" = 5 chars → 5×8+24+12=76, header "data"=4×8+59=91 → max=91 expect(state.columnWidths.value[0]).toBeLessThan(600); expect(state.columnWidths.value[0]).toBe(91); }); + it("sizes short numeric columns from large sample values", () => { + const state = createResizeState({ + columns: ["id"], + rows: Array.from({ length: 20 }, (_, index) => [1_217_001 + index]), + density: "standard", + compactColumnHeaderActions: true, + }); + + state.initColumnWidths(); + + // "1217001" → 7×8+24+12=92, wider than header-only "id" (~75) + expect(state.columnWidths.value[0]).toBeGreaterThanOrEqual(92); + }); + + it("grows cached narrow columns when later pages introduce larger values", async () => { + const rows = ref>>([[1], [2], [3]]); + const state = createResizeState({ + columns: ["id"], + rows, + density: "standard", + compactColumnHeaderActions: true, + cacheKey: "result-grow", + }); + + state.initColumnWidths(); + const narrowWidth = state.columnWidths.value[0]; + + rows.value = Array.from({ length: 20 }, (_, index) => [1_217_001 + index]); + await nextTick(); + + expect(state.columnWidths.value[0]).toBeGreaterThan(narrowWidth); + expect(state.columnWidths.value[0]).toBeGreaterThanOrEqual(92); + + const remounted = createResizeState({ + columns: ["id"], + rows: Array.from({ length: 20 }, () => ["x".repeat(40)]), + density: "standard", + compactColumnHeaderActions: true, + cacheKey: "result-grow", + }); + remounted.initColumnWidths(); + expect(remounted.columnWidths.value[0]).toBe(356); + }); + + it("grows when the width percentile changes without changing the maximum value length", async () => { + const rows = ref>>([...Array.from({ length: 49 }, () => ["x"]), ["x".repeat(40)]]); + const state = createResizeState({ + columns: ["id"], + rows, + density: "standard", + compactColumnHeaderActions: true, + }); + + state.initColumnWidths(); + expect(state.columnWidths.value[0]).toBe(75); + + rows.value = [["x"], ...Array.from({ length: 49 }, () => ["x".repeat(40)])]; + await nextTick(); + + expect(state.columnWidths.value[0]).toBe(356); + }); + + it("preserves a manually narrowed width across page changes and remounts", async () => { + const rows = ref>>(Array.from({ length: 20 }, (_, index) => [1_217_001 + index])); + const state = createResizeState({ + columns: ["id"], + rows, + density: "standard", + compactColumnHeaderActions: true, + cacheKey: "manual-narrow", + }); + + state.initColumnWidths(); + state.onResizeStart(0, new MouseEvent("mousedown", { clientX: 100, cancelable: true })); + document.dispatchEvent(new MouseEvent("mouseup", { clientX: 0 })); + expect(state.columnWidths.value[0]).toBe(DATA_GRID_COL_MIN_WIDTH); + + rows.value = Array.from({ length: 20 }, () => ["x".repeat(40)]); + await nextTick(); + expect(state.columnWidths.value[0]).toBe(DATA_GRID_COL_MIN_WIDTH); + + const remounted = createResizeState({ + columns: ["id"], + rows, + density: "standard", + compactColumnHeaderActions: true, + cacheKey: "manual-narrow", + }); + remounted.initColumnWidths(); + expect(remounted.columnWidths.value[0]).toBe(DATA_GRID_COL_MIN_WIDTH); + }); + + it("preserves an explicit auto-fit width across page changes and remounts", async () => { + const rows = ref>>([[1], [2], [3]]); + const state = createResizeState({ + columns: ["id"], + rows, + density: "standard", + compactColumnHeaderActions: true, + cacheKey: "manual-auto-fit", + }); + + state.initColumnWidths(); + state.autoFitColumn(0); + const fittedWidth = state.columnWidths.value[0]; + + rows.value = Array.from({ length: 20 }, () => ["x".repeat(40)]); + await nextTick(); + expect(state.columnWidths.value[0]).toBe(fittedWidth); + + const remounted = createResizeState({ + columns: ["id"], + rows, + density: "standard", + compactColumnHeaderActions: true, + cacheKey: "manual-auto-fit", + }); + remounted.initColumnWidths(); + expect(remounted.columnWidths.value[0]).toBe(fittedWidth); + }); + it("comfortable mode is never narrower than standard for the same column", () => { const rows = Array.from({ length: 50 }, () => ["medium_value"]); @@ -302,6 +443,13 @@ describe("useDataGridColumnResize", () => { }); }); +describe("sampleDataGridColumnValues", () => { + it("includes both the head and tail of a long row window", () => { + const rows = Array.from({ length: 100 }, (_, index) => [index + 1, `row-${index + 1}`]); + expect(sampleDataGridColumnValues(rows, 0, 10)).toEqual([1, 2, 3, 4, 5, 96, 97, 98, 99, 100]); + }); +}); + describe("dataGridRowNumberColumnWidth", () => { it("keeps the default width for small page indexes", () => { expect(dataGridRowNumberColumnWidth(999)).toBe(DATA_GRID_ROW_NUM_WIDTH); diff --git a/apps/desktop/src/composables/useDataGridColumnResize.ts b/apps/desktop/src/composables/useDataGridColumnResize.ts index df161c1fd1..395093c0bd 100644 --- a/apps/desktop/src/composables/useDataGridColumnResize.ts +++ b/apps/desktop/src/composables/useDataGridColumnResize.ts @@ -1,5 +1,5 @@ import { ref, computed, watch, type ComputedRef, type Ref } from "vue"; -import { calculateDataGridColumnWidth, DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT, DATA_GRID_COL_AUTO_FIT_MAX_WIDTH, DATA_GRID_COL_MIN_WIDTH, COLUMN_WIDTH_DENSITY_PRESETS } from "@/lib/dataGrid/dataGridColumnWidth"; +import { calculateDataGridColumnWidth, DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT, DATA_GRID_COL_AUTO_FIT_MAX_WIDTH, DATA_GRID_COL_MIN_WIDTH, COLUMN_WIDTH_DENSITY_PRESETS, sampleDataGridColumnValues } from "@/lib/dataGrid/dataGridColumnWidth"; import { createDataGridColumnMeasurementSignature, loadDataGridColumnWidthState, removeDataGridColumnWidthState, saveDataGridColumnWidthState } from "@/lib/dataGrid/dataGridColumnWidthState"; import type { ColumnWidthDensity } from "@/stores/settingsStore"; @@ -49,6 +49,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions) const columnWidths = ref([]); let isResizing = false; let previousColumnIndexes: number[] = []; + let userSizedColumnIndexes = new Set(); function columnWidthStateIdentity() { return { @@ -59,47 +60,79 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions) } function persistColumnWidths() { - saveDataGridColumnWidthState(columnWidthStateIdentity(), previousColumnIndexes, columnWidths.value); + saveDataGridColumnWidthState(columnWidthStateIdentity(), previousColumnIndexes, columnWidths.value, userSizedColumnIndexes); } function sampleColumnValues(visibleColIdx: number): CellValue[] { const actualColIdx = columnIndexes.value[visibleColIdx]; - const rows = sourceRows.value; + if (actualColIdx === undefined) return []; const preset = COLUMN_WIDTH_DENSITY_PRESETS[density.value]; - const end = Math.min(rows.length, preset.sampleRows); - const values: CellValue[] = []; - for (let i = 0; i < end; i++) { - values.push(rows[i][actualColIdx] ?? null); + return sampleDataGridColumnValues(sourceRows.value, actualColIdx, preset.sampleRows); + } + + function neededColumnWidth(colIdx: number): number { + const colName = columns.value[colIdx]; + if (!colName) return DATA_GRID_COL_MIN_WIDTH; + return calculateDataGridColumnWidth({ + columnName: colName, + sampleValues: sampleColumnValues(colIdx), + density: density.value, + compactColumnHeaderActions: compactColumnHeaderActions.value, + headerTextWidth: measureHeaderText?.(colName), + }); + } + + const neededColumnWidths = computed(() => columns.value.map((_, colIdx) => neededColumnWidth(colIdx))); + const neededColumnWidthSignature = computed(() => neededColumnWidths.value.join("|")); + + /** Grow-only: late pages with larger keys must not stay stuck at a short-header / early-page width. */ + function growColumnWidthsToFitSamples(neededWidths = neededColumnWidths.value) { + if (columnWidths.value.length !== columns.value.length || columns.value.length === 0) return; + let grew = false; + const next = columnWidths.value.slice(); + for (let colIdx = 0; colIdx < columns.value.length; colIdx++) { + const actualColIdx = columnIndexes.value[colIdx]; + if (actualColIdx === undefined || userSizedColumnIndexes.has(actualColIdx)) continue; + const needed = neededWidths[colIdx] ?? DATA_GRID_COL_MIN_WIDTH; + if (needed > (next[colIdx] ?? 0)) { + next[colIdx] = needed; + grew = true; + } } - return values; + if (!grew) return; + columnWidths.value = next; + persistColumnWidths(); + } + + function markColumnUserSized(visibleColIdx: number) { + const actualColIdx = columnIndexes.value[visibleColIdx]; + if (actualColIdx !== undefined) userSizedColumnIndexes.add(actualColIdx); } function initColumnWidths(force = false) { + if (force) userSizedColumnIndexes.clear(); const previousWidthsByColumnIndex = new Map(); previousColumnIndexes.forEach((columnIndex, visibleIndex) => { const width = columnWidths.value[visibleIndex]; if (width !== undefined) previousWidthsByColumnIndex.set(columnIndex, width); }); const nextColumnIndexes = [...columnIndexes.value]; - const cachedWidths = !force && previousColumnIndexes.length === 0 ? loadDataGridColumnWidthState(columnWidthStateIdentity(), nextColumnIndexes) : undefined; + const cachedState = !force && previousColumnIndexes.length === 0 ? loadDataGridColumnWidthState(columnWidthStateIdentity(), nextColumnIndexes) : undefined; + if (cachedState) userSizedColumnIndexes = new Set(cachedState.userSizedColumnIndexes); + const currentNeededWidths = neededColumnWidths.value; if (force || columnWidths.value.length !== columns.value.length || previousColumnIndexes.join("\0") !== nextColumnIndexes.join("\0")) { - columnWidths.value = columns.value.map((colName, colIdx) => { + columnWidths.value = columns.value.map((_, colIdx) => { if (!force) { const existingWidth = previousWidthsByColumnIndex.get(nextColumnIndexes[colIdx]); if (existingWidth !== undefined) return existingWidth; - const cachedWidth = cachedWidths?.[colIdx]; + const cachedWidth = cachedState?.widths[colIdx]; if (cachedWidth !== undefined) return cachedWidth; } - return calculateDataGridColumnWidth({ - columnName: colName, - sampleValues: sampleColumnValues(colIdx), - density: density.value, - compactColumnHeaderActions: compactColumnHeaderActions.value, - headerTextWidth: measureHeaderText?.(colName), - }); + return currentNeededWidths[colIdx] ?? DATA_GRID_COL_MIN_WIDTH; }); } previousColumnIndexes = nextColumnIndexes; + growColumnWidthsToFitSamples(currentNeededWidths); } function onResizeStart(colIdx: number, event: MouseEvent) { @@ -136,6 +169,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions) cancelPendingFrame(); pendingClientX = e.clientX; applyPendingWidth(); + markColumnUserSized(colIdx); persistColumnWidths(); requestAnimationFrame(() => { isResizing = false; @@ -158,6 +192,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions) includeValues: true, headerTextWidth: measureHeaderText?.(colName), }); + markColumnUserSized(colIdx); persistColumnWidths(); } @@ -188,6 +223,7 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions) watch([() => options.cacheKey?.value, options.columnStructureSignature], () => { columnWidths.value = []; previousColumnIndexes = []; + userSizedColumnIndexes.clear(); initColumnWidths(); }); watch([density, compactColumnHeaderActions, () => options.headerMeasurementKey?.value], () => { @@ -195,10 +231,12 @@ export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions) removeDataGridColumnWidthState(options.cacheKey?.value); initColumnWidths(true); }); + watch(neededColumnWidthSignature, () => growColumnWidthsToFitSamples(neededColumnWidths.value)); return { columnWidths, initColumnWidths, + growColumnWidthsToFitSamples, onResizeStart, autoFitColumn, renderedColumnWidths, diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnWidth.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnWidth.ts index 3800efc9c4..80a4edd6ec 100644 --- a/apps/desktop/src/lib/dataGrid/dataGridColumnWidth.ts +++ b/apps/desktop/src/lib/dataGrid/dataGridColumnWidth.ts @@ -12,6 +12,8 @@ export const DATA_GRID_CELL_PADDING = 28; export const DATA_GRID_SAMPLE_ROWS = 50; export const DATA_GRID_VALUE_TEXT_LIMIT = 60; export const DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT = 160; +/** Extra px so tabular digits at default table font (13px) are not ellipsized by a tight charWidth estimate. */ +export const DATA_GRID_VALUE_WIDTH_SLACK = 12; export interface ColumnWidthDensityPreset { charWidth: number; @@ -112,7 +114,7 @@ export function calculateDataGridColumnWidth(options: { columnName: string; samp const text = displaySampleValue(value); if (text == null) continue; const displayLen = Math.min(text.length, valueTextLimit); - valueWidths.push(displayLen * preset.charWidth + preset.cellPadding); + valueWidths.push(displayLen * preset.charWidth + preset.cellPadding + DATA_GRID_VALUE_WIDTH_SLACK); } const valueWidth = percentileValue(valueWidths, preset.valueWidthPercentile); @@ -120,3 +122,21 @@ export function calculateDataGridColumnWidth(options: { columnName: string; samp return Math.max(DATA_GRID_COL_MIN_WIDTH, Math.round(maxContentWidth)); } + +/** Sample from the start and end of the row window so late pages / infinite-scroll tails affect default width. */ +export function sampleDataGridColumnValues(rows: readonly CellValue[][], columnIndex: number, sampleRows: number): CellValue[] { + const limit = Math.max(1, sampleRows); + if (rows.length <= limit) { + return rows.map((row) => row[columnIndex] ?? null); + } + const headCount = Math.ceil(limit / 2); + const tailCount = limit - headCount; + const values: CellValue[] = []; + for (let index = 0; index < headCount; index++) { + values.push(rows[index]?.[columnIndex] ?? null); + } + for (let index = rows.length - tailCount; index < rows.length; index++) { + values.push(rows[index]?.[columnIndex] ?? null); + } + return values; +} diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts index 4752c0e7bf..4d6c15b17c 100644 --- a/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts +++ b/apps/desktop/src/lib/dataGrid/dataGridColumnWidthState.ts @@ -6,6 +6,7 @@ interface DataGridColumnWidthState { structureSignature: string; measurementSignature: string; widthsByColumnIndex: Map; + userSizedColumnIndexes: Set; } interface DataGridColumnWidthStateIdentity { @@ -14,6 +15,11 @@ interface DataGridColumnWidthStateIdentity { measurementSignature: string; } +export interface DataGridColumnWidthStateSnapshot { + widths: Array; + userSizedColumnIndexes: Set; +} + const columnWidthStates = new Map(); function touchColumnWidthState(cacheKey: string, state: DataGridColumnWidthState) { @@ -29,7 +35,7 @@ export function createDataGridColumnMeasurementSignature(density: ColumnWidthDen return JSON.stringify([density, compactColumnHeaderActions, headerMeasurementKey ?? null]); } -export function loadDataGridColumnWidthState(identity: DataGridColumnWidthStateIdentity, columnIndexes: readonly number[]): Array | undefined { +export function loadDataGridColumnWidthState(identity: DataGridColumnWidthStateIdentity, columnIndexes: readonly number[]): DataGridColumnWidthStateSnapshot | undefined { const cacheKey = identity.cacheKey?.trim(); if (!cacheKey) return undefined; const state = columnWidthStates.get(cacheKey); @@ -39,22 +45,29 @@ export function loadDataGridColumnWidthState(identity: DataGridColumnWidthStateI return undefined; } touchColumnWidthState(cacheKey, state); - return columnIndexes.map((columnIndex) => state.widthsByColumnIndex.get(columnIndex)); + return { + widths: columnIndexes.map((columnIndex) => state.widthsByColumnIndex.get(columnIndex)), + userSizedColumnIndexes: new Set(state.userSizedColumnIndexes), + }; } -export function saveDataGridColumnWidthState(identity: DataGridColumnWidthStateIdentity, columnIndexes: readonly number[], widths: readonly number[]) { +export function saveDataGridColumnWidthState(identity: DataGridColumnWidthStateIdentity, columnIndexes: readonly number[], widths: readonly number[], userSizedColumnIndexes: ReadonlySet) { const cacheKey = identity.cacheKey?.trim(); if (!cacheKey || columnIndexes.length !== widths.length) return; const existing = columnWidthStates.get(cacheKey); const widthsByColumnIndex = existing?.structureSignature === identity.structureSignature && existing.measurementSignature === identity.measurementSignature ? new Map(existing.widthsByColumnIndex) : new Map(); + const nextUserSizedColumnIndexes = existing?.structureSignature === identity.structureSignature && existing.measurementSignature === identity.measurementSignature ? new Set(existing.userSizedColumnIndexes) : new Set(); 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); }); touchColumnWidthState(cacheKey, { structureSignature: identity.structureSignature, measurementSignature: identity.measurementSignature, widthsByColumnIndex, + userSizedColumnIndexes: nextUserSizedColumnIndexes, }); // Query result keys are session-scoped, so bound the in-memory cache instead of relying on store cleanup paths. while (columnWidthStates.size > DATA_GRID_COLUMN_WIDTH_STATE_LIMIT) { diff --git a/packages/app-tests/dataGridColumnWidth.test.ts b/packages/app-tests/dataGridColumnWidth.test.ts index 20cfbb1653..897218c289 100644 --- a/packages/app-tests/dataGridColumnWidth.test.ts +++ b/packages/app-tests/dataGridColumnWidth.test.ts @@ -7,8 +7,8 @@ test("default data grid column width remains compact for long values", () => { sampleValues: ["x".repeat(120)], }); - // standard: valueTextLimit=40, so 120 chars truncated to 40 → 40×8+24=344 - expect(width).toBe(344); + // standard: valueTextLimit=40, so 120 chars truncated to 40 → 40×8+24+12=356 + expect(width).toBe(356); }); test("auto-fit data grid column width expands long values beyond default width", () => { @@ -19,7 +19,7 @@ test("auto-fit data grid column width expands long values beyond default width", valueTextLimit: DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT, }); - expect(width).toBeGreaterThan(344); + expect(width).toBeGreaterThan(356); }); test("auto-fit data grid column width stays bounded for very long values", () => {