fix(grid): grow columns without overriding user widths

This commit is contained in:
Freedom authored and GitHub committed 2026-07-31 16:27:06 +08:00
1 parent bdb941b606
commit 584848f732
5 files changed
+259 -40

No files matched your search

@@ -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<Array<string | number | boolean | null>>; columnIndexes?: number[]; columnTypes?: string[]; cacheKey?: string; density?: "compact" | "standard" | "comfortable"; compactColumnHeaderActions?: boolean; headerTextWidth?: number }) {
function createResizeState(options: {
columns: string[];
rows: Array<Array<string | number | boolean | null>> | ReturnType<typeof ref<Array<Array<string | number | boolean | null>>>>;
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<Array<strin
});
return {
...state,
rows,
setCompact(v: boolean) {
compact.value = v;
},
@@ -65,13 +76,13 @@ describe("useDataGridColumnResize", () => {
});
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<Array<Array<string | number | boolean | null>>>([[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<Array<string | number | boolean | null>>>([...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<Array<string | number | boolean | null>>>(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<Array<Array<string | number | boolean | null>>>([[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);
@@ -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<number[]>([]);
let isResizing = false;
let previousColumnIndexes: number[] = [];
let userSizedColumnIndexes = new Set<number>();
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<number, number>();
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,
@@ -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;
}
@@ -6,6 +6,7 @@ interface DataGridColumnWidthState {
structureSignature: string;
measurementSignature: string;
widthsByColumnIndex: Map<number, number>;
userSizedColumnIndexes: Set<number>;
}
interface DataGridColumnWidthStateIdentity {
@@ -14,6 +15,11 @@ interface DataGridColumnWidthStateIdentity {
measurementSignature: string;
}
export interface DataGridColumnWidthStateSnapshot {
widths: Array<number | undefined>;
userSizedColumnIndexes: Set<number>;
}
const columnWidthStates = new Map<string, DataGridColumnWidthState>();
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<number | undefined> | 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<number>) {
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<number, number>();
const nextUserSizedColumnIndexes = existing?.structureSignature === identity.structureSignature && existing.measurementSignature === identity.measurementSignature ? new Set(existing.userSizedColumnIndexes) : new Set<number>();
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) {