@dbcdk/react-components 0.0.197 → 0.0.199

package/dist/components/table/hooks/useResizeHeaderExtras.js

@@ -0,0 +1,62 @@
+'use client';
+import { jsx } from 'react/jsx-runtime';
+import * as React from 'react';
+import ColumnResizer from '../components/column-resizer/ColumnResizer';
+
+function useResizeHeaderExtras({
+  table,
+  widths,
+  actionReservePx,
+  neighborResizeRef,
+  setColumnSizing
+}) {
+  return React.useCallback(
+    ({ index }) => {
+      var _a, _b, _c, _d;
+      const headerGroups = table.getHeaderGroups();
+      const leafHeaders = headerGroups.length > 0 ? headerGroups[headerGroups.length - 1].headers : [];
+      const header = leafHeaders[index];
+      const neighbor = leafHeaders[index + 1];
+      if (!header || !neighbor) return null;
+      const canResize = (_c = (_b = (_a = header.column).getCanResize) == null ? void 0 : _b.call(_a)) != null ? _c : false;
+      const handler = (_d = header.getResizeHandler) == null ? void 0 : _d.call(header);
+      if (!canResize || !handler) return null;
+      const handleResizeStart = (event) => {
+        var _a2, _b2, _c2, _d2;
+        const startWidth = widths == null ? void 0 : widths[header.column.id];
+        const neighborStartWidth = widths == null ? void 0 : widths[neighbor.column.id];
+        if (startWidth == null || neighborStartWidth == null) return;
+        const neighborReserve = index + 1 === leafHeaders.length - 1 ? actionReservePx : 0;
+        const { columnDef } = header.column;
+        const neighborDef = neighbor.column.columnDef;
+        neighborResizeRef.current = {
+          columnId: header.column.id,
+          neighborId: neighbor.column.id,
+          // TanStack drags from its own size (columnDef.size), not the width on
+          // screen; applyNeighborResize only uses its offset from this.
+          tanstackStartWidth: header.getSize(),
+          startWidth,
+          neighborStartWidth,
+          min: (_a2 = columnDef.minSize) != null ? _a2 : 0,
+          max: (_b2 = columnDef.maxSize) != null ? _b2 : Infinity,
+          neighborMin: ((_c2 = neighborDef.minSize) != null ? _c2 : 0) + neighborReserve,
+          neighborMax: ((_d2 = neighborDef.maxSize) != null ? _d2 : Infinity) + neighborReserve
+        };
+        const displayedWidths = widths != null ? widths : {};
+        setColumnSizing(
+          (prev) => Object.fromEntries(
+            Object.entries(prev).map(([id, width]) => {
+              var _a3;
+              return [id, (_a3 = displayedWidths[id]) != null ? _a3 : width];
+            })
+          )
+        );
+        handler(event);
+      };
+      return /* @__PURE__ */ jsx(ColumnResizer, { id: header.column.id, handler: handleResizeStart });
+    },
+    [table, widths, actionReservePx, neighborResizeRef, setColumnSizing]
+  );
+}
+
+export { useResizeHeaderExtras };

package/dist/components/table/hooks/useUiSorting.cjs

@@ -0,0 +1,18 @@
+'use client';
+'use strict';
+
+var react = require('react');
+var tanstackTable_utils = require('../tanstackTable.utils');
+
+function useUiSorting(controlledSorting) {
+  const isControlled = controlledSorting != null;
+  const [uiSorting, setUiSorting] = react.useState(controlledSorting != null ? controlledSorting : []);
+  react.useEffect(() => {
+    if (!isControlled) return;
+    if (tanstackTable_utils.sortingEqual(uiSorting, controlledSorting)) return;
+    setUiSorting(controlledSorting);
+  }, [isControlled, controlledSorting, uiSorting]);
+  return [uiSorting, setUiSorting];
+}
+
+exports.useUiSorting = useUiSorting;

package/dist/components/table/hooks/useUiSorting.d.ts

@@ -0,0 +1,3 @@
+import type { SortingState } from '@tanstack/react-table';
+/** Sorting shown in the header; follows `controlledSorting` when given, but can be set ahead of it. */
+export declare function useUiSorting(controlledSorting: SortingState | undefined): readonly [SortingState, import("react").Dispatch<import("react").SetStateAction<SortingState>>];

package/dist/components/table/hooks/useUiSorting.js

@@ -0,0 +1,16 @@
+'use client';
+import { useState, useEffect } from 'react';
+import { sortingEqual } from '../tanstackTable.utils';
+
+function useUiSorting(controlledSorting) {
+  const isControlled = controlledSorting != null;
+  const [uiSorting, setUiSorting] = useState(controlledSorting != null ? controlledSorting : []);
+  useEffect(() => {
+    if (!isControlled) return;
+    if (sortingEqual(uiSorting, controlledSorting)) return;
+    setUiSorting(controlledSorting);
+  }, [isControlled, controlledSorting, uiSorting]);
+  return [uiSorting, setUiSorting];
+}
+
+export { useUiSorting };

package/dist/components/table/table.utils.cjs

@@ -1,9 +1,27 @@
 'use strict';
 
 const SELECTION_COLUMN_PX = 32;
-const ACTIONS_COLUMN_PX = 0;
+const HEADER_ACTIONS_RESERVE_PX = 20;
 const ROW_ACTIONS_RESERVE_PX = 32;
 const DEFAULT_COLUMN_PX = 150;
+const DEFAULT_VIEW_MODE = "wrapped";
+function showsExpandToggle(expandableRows, viewMode) {
+  return Boolean(expandableRows) && viewMode !== "wrapped";
+}
+function reservesRowActionsSpace(args) {
+  return args.hasRowActions || args.showHeader && args.hasHeaderActions;
+}
+function getActionsReserve(args) {
+  const { hasRowActions, hasSettings, hasOtherHeaderActions, showHeader } = args;
+  const reserves = reservesRowActionsSpace({
+    hasRowActions,
+    hasHeaderActions: hasSettings || hasOtherHeaderActions,
+    showHeader
+  });
+  if (!reserves) return { px: 0, compactHeader: false };
+  const compactHeader = showHeader && hasSettings && !hasOtherHeaderActions && !hasRowActions;
+  return { px: compactHeader ? HEADER_ACTIONS_RESERVE_PX : ROW_ACTIONS_RESERVE_PX, compactHeader };
+}
 function getVisibleColumns(columns) {
   return columns.filter((column) => !column.hidden);
 }
@@ -46,10 +64,12 @@ function getCellDisplayValue(row, column) {
   return empty;
 }
 
-exports.ACTIONS_COLUMN_PX = ACTIONS_COLUMN_PX;
 exports.DEFAULT_COLUMN_PX = DEFAULT_COLUMN_PX;
+exports.DEFAULT_VIEW_MODE = DEFAULT_VIEW_MODE;
+exports.HEADER_ACTIONS_RESERVE_PX = HEADER_ACTIONS_RESERVE_PX;
 exports.ROW_ACTIONS_RESERVE_PX = ROW_ACTIONS_RESERVE_PX;
 exports.SELECTION_COLUMN_PX = SELECTION_COLUMN_PX;
+exports.getActionsReserve = getActionsReserve;
 exports.getAriaSort = getAriaSort;
 exports.getCellDisplayValue = getCellDisplayValue;
 exports.getHeaderLabel = getHeaderLabel;
@@ -57,5 +77,7 @@ exports.getNextSortDirection = getNextSortDirection;
 exports.getVisibleColumns = getVisibleColumns;
 exports.isActiveSort = isActiveSort;
 exports.isModifierClick = isModifierClick;
+exports.reservesRowActionsSpace = reservesRowActionsSpace;
 exports.shouldAllowWrap = shouldAllowWrap;
 exports.shouldToggleOnKey = shouldToggleOnKey;
+exports.showsExpandToggle = showsExpandToggle;

package/dist/components/table/table.utils.d.ts

@@ -1,7 +1,13 @@
 import type { ReactNode } from 'react';
-import type { ColumnItem } from './Table.types';
+import type { ColumnItem, ViewMode } from './Table.types';
 export declare const SELECTION_COLUMN_PX: 32;
-export declare const ACTIONS_COLUMN_PX: 0;
+/**
+ * Smaller reserve used when the only action is the header's settings button:
+ * the button overlaps the header cell's own padding. Must match
+ * `.thMainWithHeaderActionsReserve` in Table.module.css
+ * (component-size-sm 30px - spacing-sm 12px + spacing-2xs 2px).
+ */
+export declare const HEADER_ACTIONS_RESERVE_PX: 20;
 /**
  * Space kept free at the inline end of the last column for the row actions
  * button and header actions. Must match `--table-row-actions-reserve-inline`
@@ -9,7 +15,39 @@ export declare const ACTIONS_COLUMN_PX: 0;
  */
 export declare const ROW_ACTIONS_RESERVE_PX: 32;
 export declare const DEFAULT_COLUMN_PX: 150;
+/** View mode when neither the `viewMode` prop nor table settings set one. */
+export declare const DEFAULT_VIEW_MODE: ViewMode;
+/**
+ * Whether rows show the expand toggle: only in compact mode, since wrapped
+ * rows already show their full content.
+ */
+export declare function showsExpandToggle(expandableRows: boolean | undefined, viewMode: ViewMode): boolean;
 export type SortDirection = 'asc' | 'desc' | null;
+/**
+ * Whether the last column reserves `ROW_ACTIONS_RESERVE_PX` at its inline end:
+ * row actions (context menu, expand toggle) always do, header actions (e.g.
+ * the settings menu) only while the header row that holds them is shown.
+ */
+export declare function reservesRowActionsSpace(args: {
+    hasRowActions: boolean;
+    hasHeaderActions: boolean;
+    showHeader: boolean;
+}): boolean;
+/**
+ * How much space the last column reserves for actions: none, the smaller
+ * `HEADER_ACTIONS_RESERVE_PX` when the header's settings button is the only
+ * action, or the full `ROW_ACTIONS_RESERVE_PX`. Shared by Table and
+ * TanstackTable so the computed widths match the header's padding.
+ */
+export declare function getActionsReserve(args: {
+    hasRowActions: boolean;
+    hasSettings: boolean;
+    hasOtherHeaderActions: boolean;
+    showHeader: boolean;
+}): {
+    px: number;
+    compactHeader: boolean;
+};
 export declare function getVisibleColumns<T>(columns: Array<ColumnItem<T>>): Array<ColumnItem<T>>;
 export declare function getHeaderLabel(header: string | (() => ReactNode)): ReactNode;
 export declare function isActiveSort(sortById: string | undefined, columnId: string): boolean;

package/dist/components/table/table.utils.js

@@ -1,7 +1,25 @@
 const SELECTION_COLUMN_PX = 32;
-const ACTIONS_COLUMN_PX = 0;
+const HEADER_ACTIONS_RESERVE_PX = 20;
 const ROW_ACTIONS_RESERVE_PX = 32;
 const DEFAULT_COLUMN_PX = 150;
+const DEFAULT_VIEW_MODE = "wrapped";
+function showsExpandToggle(expandableRows, viewMode) {
+  return Boolean(expandableRows) && viewMode !== "wrapped";
+}
+function reservesRowActionsSpace(args) {
+  return args.hasRowActions || args.showHeader && args.hasHeaderActions;
+}
+function getActionsReserve(args) {
+  const { hasRowActions, hasSettings, hasOtherHeaderActions, showHeader } = args;
+  const reserves = reservesRowActionsSpace({
+    hasRowActions,
+    hasHeaderActions: hasSettings || hasOtherHeaderActions,
+    showHeader
+  });
+  if (!reserves) return { px: 0, compactHeader: false };
+  const compactHeader = showHeader && hasSettings && !hasOtherHeaderActions && !hasRowActions;
+  return { px: compactHeader ? HEADER_ACTIONS_RESERVE_PX : ROW_ACTIONS_RESERVE_PX, compactHeader };
+}
 function getVisibleColumns(columns) {
   return columns.filter((column) => !column.hidden);
 }
@@ -44,4 +62,4 @@ function getCellDisplayValue(row, column) {
   return empty;
 }
 
-export { ACTIONS_COLUMN_PX, DEFAULT_COLUMN_PX, ROW_ACTIONS_RESERVE_PX, SELECTION_COLUMN_PX, getAriaSort, getCellDisplayValue, getHeaderLabel, getNextSortDirection, getVisibleColumns, isActiveSort, isModifierClick, shouldAllowWrap, shouldToggleOnKey };
+export { DEFAULT_COLUMN_PX, DEFAULT_VIEW_MODE, HEADER_ACTIONS_RESERVE_PX, ROW_ACTIONS_RESERVE_PX, SELECTION_COLUMN_PX, getActionsReserve, getAriaSort, getCellDisplayValue, getHeaderLabel, getNextSortDirection, getVisibleColumns, isActiveSort, isModifierClick, reservesRowActionsSpace, shouldAllowWrap, shouldToggleOnKey, showsExpandToggle };

package/dist/components/table/tanstackTable.utils.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var columnLayout_utils = require('./columnLayout.utils');
 var table_utils = require('./table.utils');
 
 function getColumnId(def, index) {
@@ -74,124 +75,59 @@ function getSortPropsFromSorting(sorting) {
   };
 }
 function clamp(value, min, max) {
-  const lowerBounded = Math.max(min, value);
-  if (max == null || !Number.isFinite(max)) return lowerBounded;
-  return Math.min(lowerBounded, max);
+  return Math.min(Math.max(value, min), max);
 }
-function toIntegerTrackWidths(tracks, targetWidth) {
-  const floored = tracks.map((track) => ({
-    id: track.id,
-    width: Math.floor(track.width),
-    fraction: track.width - Math.floor(track.width)
-  }));
-  const baseTotal = floored.reduce((sum, track) => sum + track.width, 0);
-  let remainder = Math.max(0, targetWidth - baseTotal);
-  floored.slice().sort((a, b) => b.fraction - a.fraction).forEach((track) => {
-    if (remainder <= 0) return;
-    track.width += 1;
-    remainder -= 1;
-  });
-  return Object.fromEntries(floored.map((track) => [track.id, track.width]));
+function applyNeighborResize(next, resize) {
+  const proposed = next[resize.columnId];
+  if (proposed == null) return next;
+  const total = resize.startWidth + resize.neighborStartWidth;
+  const min = Math.min(resize.min, resize.startWidth);
+  const max = Math.max(resize.max, resize.startWidth);
+  const neighborMin = Math.min(resize.neighborMin, resize.neighborStartWidth);
+  const neighborMax = Math.max(resize.neighborMax, resize.neighborStartWidth);
+  const width = Math.round(
+    clamp(
+      resize.startWidth + proposed - resize.tanstackStartWidth,
+      Math.max(min, total - neighborMax),
+      Math.min(max, total - neighborMin)
+    )
+  );
+  return { ...next, [resize.columnId]: width, [resize.neighborId]: total - width };
 }
 function buildDistributedColumnWidths(args) {
   const {
     table,
     hasSelection,
-    hasContextMenu = false,
+    hasContextMenu,
+    contextMenuReservePx = table_utils.ROW_ACTIONS_RESERVE_PX,
     defaultMinPx,
     columnSizing,
     availableWidth
   } = args;
-  const leaf = table.getVisibleLeafColumns();
-  const selectionWidth = hasSelection ? table_utils.SELECTION_COLUMN_PX : 0;
-  const contextMenuWidth = hasContextMenu ? 0 : 0;
-  const tracks = leaf.map((c) => {
+  const visibleColumns = table.getVisibleLeafColumns();
+  const tracks = visibleColumns.map((c, index) => {
     var _a, _b, _c, _d;
     const def = c.columnDef;
     const meta = (_a = def.meta) != null ? _a : {};
     const min = Math.max(1, Number((_b = def.minSize) != null ? _b : defaultMinPx));
     const max = def.maxSize != null ? Math.max(min, Number(def.maxSize)) : void 0;
     const resizedPxRaw = columnSizing[c.id];
-    const resizedPx = resizedPxRaw != null ? Math.round(clamp(Number(resizedPxRaw), min, max)) : void 0;
-    if (resizedPx != null) {
-      return {
-        id: c.id,
-        width: resizedPx,
-        weight: 0,
-        min,
-        max: resizedPx,
-        fixed: true
-      };
-    }
+    const reserve = hasContextMenu && index === visibleColumns.length - 1 ? contextMenuReservePx : 0;
+    const fixedWidth = resizedPxRaw != null ? Math.round(clamp(Number(resizedPxRaw), min + reserve, (max != null ? max : Infinity) + reserve)) : void 0;
     const rawWeight = Number((_d = (_c = meta.weight) != null ? _c : def.size) != null ? _d : table_utils.DEFAULT_COLUMN_PX);
     const weight = Number.isFinite(rawWeight) && rawWeight > 0 ? rawWeight : table_utils.DEFAULT_COLUMN_PX;
-    return {
-      id: c.id,
-      width: min,
-      weight,
-      min,
-      max,
-      fixed: false
-    };
+    return { id: c.id, min, max, weight, fixedWidth };
+  });
+  return columnLayout_utils.distributeColumnWidths({
+    tracks,
+    hasSelection,
+    hasContextMenu,
+    contextMenuReservePx,
+    availableWidth
   });
-  const lastTrack = tracks[tracks.length - 1];
-  if (hasContextMenu && lastTrack && !lastTrack.fixed) {
-    lastTrack.min += table_utils.ROW_ACTIONS_RESERVE_PX;
-    lastTrack.width += table_utils.ROW_ACTIONS_RESERVE_PX;
-    if (lastTrack.max != null) lastTrack.max += table_utils.ROW_ACTIONS_RESERVE_PX;
-  }
-  const fixedWidth = selectionWidth + contextMenuWidth + tracks.reduce((sum, track) => sum + track.width, 0);
-  let remaining = Math.max(0, availableWidth - fixedWidth);
-  let active = tracks.filter(
-    (track) => !track.fixed && (track.max == null || track.width < track.max)
-  );
-  while (remaining > 0.5 && active.length > 0) {
-    const totalWeight = active.reduce((sum, track) => sum + track.weight, 0);
-    if (totalWeight <= 0) break;
-    let consumed = 0;
-    const nextActive = [];
-    for (const track of active) {
-      const share = remaining * track.weight / totalWeight;
-      const maxGrow = track.max == null ? share : Math.max(0, track.max - track.width);
-      const growth = Math.min(share, maxGrow);
-      track.width += growth;
-      consumed += growth;
-      if (track.max == null || track.width < track.max - 0.5) {
-        nextActive.push(track);
-      }
-    }
-    if (consumed <= 0.5) break;
-    remaining -= consumed;
-    active = nextActive;
-  }
-  const flexible = tracks.filter((track) => !track.fixed);
-  if (remaining > 0.5 && flexible.length > 0 && flexible.every((track) => track.max != null)) {
-    const stretchable = flexible.filter((track) => track.max > track.min);
-    const totalWeight = stretchable.reduce((sum, track) => sum + track.weight, 0);
-    if (totalWeight > 0) {
-      for (const track of stretchable) {
-        track.width += remaining * track.weight / totalWeight;
-      }
-    }
-  }
-  const floatTrackTotal = tracks.reduce((sum, track) => sum + track.width, 0);
-  const maxTrackWidth = availableWidth - selectionWidth - contextMenuWidth;
-  const targetTrackWidth = Math.min(
-    floatTrackTotal <= maxTrackWidth ? Math.floor(floatTrackTotal) : Math.ceil(floatTrackTotal),
-    maxTrackWidth
-  );
-  const widths = toIntegerTrackWidths(tracks, targetTrackWidth);
-  const totalWidth = selectionWidth + contextMenuWidth + Object.values(widths).reduce((sum, width) => sum + width, 0);
-  return {
-    selectionWidth: hasSelection ? table_utils.SELECTION_COLUMN_PX : void 0,
-    contextMenuWidth: hasContextMenu ? 0 : void 0,
-    widths,
-    totalWidth,
-    availableWidth,
-    shouldOverflow: totalWidth > availableWidth
-  };
 }
 
+exports.applyNeighborResize = applyNeighborResize;
 exports.buildColumnVisibilityFromVisibleIds = buildColumnVisibilityFromVisibleIds;
 exports.buildDistributedColumnWidths = buildDistributedColumnWidths;
 exports.getColumnId = getColumnId;

package/dist/components/table/tanstackTable.utils.d.ts

@@ -1,4 +1,5 @@
 import type { ColumnDef, ColumnSizingState, SortingState, VisibilityState } from '@tanstack/react-table';
+import { type DistributedColumnWidths } from './columnLayout.utils';
 import { ColumnItem } from './Table.types';
 type AnyRecord = Record<string, any>;
 export declare function getColumnId<T>(def: ColumnDef<T, any>, index: number): string;
@@ -11,19 +12,34 @@ export declare function getSortPropsFromSorting(sorting: SortingState): {
     sortById?: string;
     sortDirection: 'asc' | 'desc' | null;
 };
+/** The two columns a drag moves width between, as captured on resize start. */
+export type NeighborResize = {
+    columnId: string;
+    neighborId: string;
+    /** TanStack's own start size; its updates are this plus the drag offset. */
+    tanstackStartWidth: number;
+    startWidth: number;
+    neighborStartWidth: number;
+    min: number;
+    max: number;
+    neighborMin: number;
+    neighborMax: number;
+};
+/**
+ * Applies a TanStack resize update as a move of width between the dragged
+ * column and its right neighbour, so their sum (and every other column) stays
+ * put. Both columns stay within their bounds, widened to their start widths
+ * so a column already outside its bounds doesn't jump when grabbed.
+ */
+export declare function applyNeighborResize(next: ColumnSizingState, resize: NeighborResize): ColumnSizingState;
 export declare function buildDistributedColumnWidths(args: {
     table: any;
     hasSelection: boolean;
     hasContextMenu?: boolean;
+    /** Space the last column reserves for actions; see `getActionsReserve`. */
+    contextMenuReservePx?: number;
     defaultMinPx: number;
     columnSizing: ColumnSizingState;
     availableWidth: number;
-}): {
-    selectionWidth?: number;
-    contextMenuWidth?: number;
-    widths: Record<string, number>;
-    totalWidth: number;
-    availableWidth: number;
-    shouldOverflow: boolean;
-};
+}): DistributedColumnWidths;
 export {};

package/dist/components/table/tanstackTable.utils.js

@@ -1,4 +1,5 @@
-import { DEFAULT_COLUMN_PX, ROW_ACTIONS_RESERVE_PX, SELECTION_COLUMN_PX } from './table.utils';
+import { distributeColumnWidths } from './columnLayout.utils';
+import { ROW_ACTIONS_RESERVE_PX, DEFAULT_COLUMN_PX } from './table.utils';
 
 function getColumnId(def, index) {
   const d = def;
@@ -72,122 +73,56 @@ function getSortPropsFromSorting(sorting) {
   };
 }
 function clamp(value, min, max) {
-  const lowerBounded = Math.max(min, value);
-  if (max == null || !Number.isFinite(max)) return lowerBounded;
-  return Math.min(lowerBounded, max);
+  return Math.min(Math.max(value, min), max);
 }
-function toIntegerTrackWidths(tracks, targetWidth) {
-  const floored = tracks.map((track) => ({
-    id: track.id,
-    width: Math.floor(track.width),
-    fraction: track.width - Math.floor(track.width)
-  }));
-  const baseTotal = floored.reduce((sum, track) => sum + track.width, 0);
-  let remainder = Math.max(0, targetWidth - baseTotal);
-  floored.slice().sort((a, b) => b.fraction - a.fraction).forEach((track) => {
-    if (remainder <= 0) return;
-    track.width += 1;
-    remainder -= 1;
-  });
-  return Object.fromEntries(floored.map((track) => [track.id, track.width]));
+function applyNeighborResize(next, resize) {
+  const proposed = next[resize.columnId];
+  if (proposed == null) return next;
+  const total = resize.startWidth + resize.neighborStartWidth;
+  const min = Math.min(resize.min, resize.startWidth);
+  const max = Math.max(resize.max, resize.startWidth);
+  const neighborMin = Math.min(resize.neighborMin, resize.neighborStartWidth);
+  const neighborMax = Math.max(resize.neighborMax, resize.neighborStartWidth);
+  const width = Math.round(
+    clamp(
+      resize.startWidth + proposed - resize.tanstackStartWidth,
+      Math.max(min, total - neighborMax),
+      Math.min(max, total - neighborMin)
+    )
+  );
+  return { ...next, [resize.columnId]: width, [resize.neighborId]: total - width };
 }
 function buildDistributedColumnWidths(args) {
   const {
     table,
     hasSelection,
-    hasContextMenu = false,
+    hasContextMenu,
+    contextMenuReservePx = ROW_ACTIONS_RESERVE_PX,
     defaultMinPx,
     columnSizing,
     availableWidth
   } = args;
-  const leaf = table.getVisibleLeafColumns();
-  const selectionWidth = hasSelection ? SELECTION_COLUMN_PX : 0;
-  const contextMenuWidth = hasContextMenu ? 0 : 0;
-  const tracks = leaf.map((c) => {
+  const visibleColumns = table.getVisibleLeafColumns();
+  const tracks = visibleColumns.map((c, index) => {
     var _a, _b, _c, _d;
     const def = c.columnDef;
     const meta = (_a = def.meta) != null ? _a : {};
     const min = Math.max(1, Number((_b = def.minSize) != null ? _b : defaultMinPx));
     const max = def.maxSize != null ? Math.max(min, Number(def.maxSize)) : void 0;
     const resizedPxRaw = columnSizing[c.id];
-    const resizedPx = resizedPxRaw != null ? Math.round(clamp(Number(resizedPxRaw), min, max)) : void 0;
-    if (resizedPx != null) {
-      return {
-        id: c.id,
-        width: resizedPx,
-        weight: 0,
-        min,
-        max: resizedPx,
-        fixed: true
-      };
-    }
+    const reserve = hasContextMenu && index === visibleColumns.length - 1 ? contextMenuReservePx : 0;
+    const fixedWidth = resizedPxRaw != null ? Math.round(clamp(Number(resizedPxRaw), min + reserve, (max != null ? max : Infinity) + reserve)) : void 0;
     const rawWeight = Number((_d = (_c = meta.weight) != null ? _c : def.size) != null ? _d : DEFAULT_COLUMN_PX);
     const weight = Number.isFinite(rawWeight) && rawWeight > 0 ? rawWeight : DEFAULT_COLUMN_PX;
-    return {
-      id: c.id,
-      width: min,
-      weight,
-      min,
-      max,
-      fixed: false
-    };
+    return { id: c.id, min, max, weight, fixedWidth };
+  });
+  return distributeColumnWidths({
+    tracks,
+    hasSelection,
+    hasContextMenu,
+    contextMenuReservePx,
+    availableWidth
   });
-  const lastTrack = tracks[tracks.length - 1];
-  if (hasContextMenu && lastTrack && !lastTrack.fixed) {
-    lastTrack.min += ROW_ACTIONS_RESERVE_PX;
-    lastTrack.width += ROW_ACTIONS_RESERVE_PX;
-    if (lastTrack.max != null) lastTrack.max += ROW_ACTIONS_RESERVE_PX;
-  }
-  const fixedWidth = selectionWidth + contextMenuWidth + tracks.reduce((sum, track) => sum + track.width, 0);
-  let remaining = Math.max(0, availableWidth - fixedWidth);
-  let active = tracks.filter(
-    (track) => !track.fixed && (track.max == null || track.width < track.max)
-  );
-  while (remaining > 0.5 && active.length > 0) {
-    const totalWeight = active.reduce((sum, track) => sum + track.weight, 0);
-    if (totalWeight <= 0) break;
-    let consumed = 0;
-    const nextActive = [];
-    for (const track of active) {
-      const share = remaining * track.weight / totalWeight;
-      const maxGrow = track.max == null ? share : Math.max(0, track.max - track.width);
-      const growth = Math.min(share, maxGrow);
-      track.width += growth;
-      consumed += growth;
-      if (track.max == null || track.width < track.max - 0.5) {
-        nextActive.push(track);
-      }
-    }
-    if (consumed <= 0.5) break;
-    remaining -= consumed;
-    active = nextActive;
-  }
-  const flexible = tracks.filter((track) => !track.fixed);
-  if (remaining > 0.5 && flexible.length > 0 && flexible.every((track) => track.max != null)) {
-    const stretchable = flexible.filter((track) => track.max > track.min);
-    const totalWeight = stretchable.reduce((sum, track) => sum + track.weight, 0);
-    if (totalWeight > 0) {
-      for (const track of stretchable) {
-        track.width += remaining * track.weight / totalWeight;
-      }
-    }
-  }
-  const floatTrackTotal = tracks.reduce((sum, track) => sum + track.width, 0);
-  const maxTrackWidth = availableWidth - selectionWidth - contextMenuWidth;
-  const targetTrackWidth = Math.min(
-    floatTrackTotal <= maxTrackWidth ? Math.floor(floatTrackTotal) : Math.ceil(floatTrackTotal),
-    maxTrackWidth
-  );
-  const widths = toIntegerTrackWidths(tracks, targetTrackWidth);
-  const totalWidth = selectionWidth + contextMenuWidth + Object.values(widths).reduce((sum, width) => sum + width, 0);
-  return {
-    selectionWidth: hasSelection ? SELECTION_COLUMN_PX : void 0,
-    contextMenuWidth: hasContextMenu ? 0 : void 0,
-    widths,
-    totalWidth,
-    availableWidth,
-    shouldOverflow: totalWidth > availableWidth
-  };
 }
 
-export { buildColumnVisibilityFromVisibleIds, buildDistributedColumnWidths, getColumnId, getSortPropsFromSorting, mapDefsToColumnItems, sortingEqual };
+export { applyNeighborResize, buildColumnVisibilityFromVisibleIds, buildDistributedColumnWidths, getColumnId, getSortPropsFromSorting, mapDefsToColumnItems, sortingEqual };