@human-kit/svelte-components 1.0.0-alpha.16 → 1.0.0-alpha.17

package/dist/table/root/context.js

@@ -1,10 +1,12 @@
-import { getContext, setContext } from 'svelte';
+import { flushSync, getContext, setContext } from 'svelte';
 import { writable } from 'svelte/store';
 const TABLE_KEY = Symbol('table');
 const TABLE_SECTION_KEY = Symbol('table-section');
 const TABLE_ROW_KEY = Symbol('table-row');
 const TABLE_COLUMN_KEY = Symbol('table-column');
 const TABLE_CELL_KEY = Symbol('table-cell');
+const IS_BROWSER = typeof window !== 'undefined';
+export const DEFAULT_TABLE_COLUMN_MIN_WIDTH = 60;
 export function createTableContext(options = {}) {
     let selectionMode = options.selectionMode ?? 'none';
     let selectionBehavior = options.selectionBehavior ?? 'toggle';
@@ -20,15 +22,18 @@ export function createTableContext(options = {}) {
     const disabledKeys = new Set(options.disabledKeys ?? []);
     const hiddenColumnIds = new Set(options.initialHiddenColumns ?? []);
     let resizingColumnId = null;
+    let resizeSession = null;
     let suppressNextHeaderClick = false;
     const columns = new Map();
     const columnIds = new Map();
     const columnOrder = [];
     const columnsWithResizers = new Set();
+    let resizerLayoutReady = false;
     const columnWidths = new Map(options.initialColumnWidths ?? []);
     const rows = new Map();
     const headerRowOrder = [];
     const bodyRowOrder = [];
+    let bodyRowsInitialized = false;
     const cells = new Map();
     const cellOrder = [];
     let orderedRowTokensCache = {
@@ -39,6 +44,7 @@ export function createTableContext(options = {}) {
     let visibleOrderedColumnTokensCache = null;
     let columnWidthsCache = null;
     let visibleColumnWidthsCache = null;
+    let resolvedVisibleColumnWidthsCache = null;
     let navigableCellsCache = null;
     let rowsWithCellsCache = null;
     const layoutVersion = writable(0);
@@ -60,11 +66,20 @@ export function createTableContext(options = {}) {
         visibleOrderedColumnTokensCache = null;
         columnWidthsCache = null;
         visibleColumnWidthsCache = null;
+        resolvedVisibleColumnWidthsCache = null;
         navigableCellsCache = null;
         rowsWithCellsCache = null;
     }
     let layoutNotifyScheduled = false;
     let widthNotifyScheduled = false;
+    function syncResizerLayoutReady(nextReady) {
+        if (resizerLayoutReady === nextReady)
+            return;
+        resizerLayoutReady = nextReady;
+        invalidateLayoutCaches();
+        layoutVersion.update((value) => value + 1);
+        notifyWidth();
+    }
     function notifyLayout() {
         invalidateLayoutCaches();
         if (!layoutNotifyScheduled) {
@@ -88,6 +103,7 @@ export function createTableContext(options = {}) {
     function notifyWidth() {
         columnWidthsCache = null;
         visibleColumnWidthsCache = null;
+        resolvedVisibleColumnWidthsCache = null;
         if (!widthNotifyScheduled) {
             widthNotifyScheduled = true;
             queueMicrotask(() => {
@@ -96,22 +112,49 @@ export function createTableContext(options = {}) {
             });
         }
     }
+    function notifyWidthImmediately() {
+        columnWidthsCache = null;
+        visibleColumnWidthsCache = null;
+        resolvedVisibleColumnWidthsCache = null;
+        flushSync(() => {
+            widthVersion.update((value) => value + 1);
+        });
+    }
     function notifyResize() {
         resizeVersion.update((value) => value + 1);
     }
-    function normalizeColumnWidth(width) {
+    function parseColumnWidth(width) {
         if (typeof width === 'number') {
-            return Number.isFinite(width) ? width : undefined;
+            return Number.isFinite(width) ? { unit: 'px', value: width } : undefined;
         }
         if (typeof width === 'string') {
-            const match = width.trim().match(/^(\d+(?:\.\d+)?)px$/i);
+            const match = width.trim().match(/^(\d+(?:\.\d+)?)(px|%|fr)$/i);
             if (!match)
                 return undefined;
             const next = Number(match[1]);
-            return Number.isFinite(next) ? next : undefined;
+            if (!Number.isFinite(next))
+                return undefined;
+            const unit = match[2].toLowerCase();
+            return { unit, value: next };
         }
         return undefined;
     }
+    function normalizeColumnWidth(width) {
+        const parsed = parseColumnWidth(width);
+        if (!parsed)
+            return undefined;
+        if (parsed.unit === 'px') {
+            return typeof width === 'number' ? width : `${parsed.value}px`;
+        }
+        if (parsed.unit === '%') {
+            return `${parsed.value}%`;
+        }
+        return `${parsed.value}fr`;
+    }
+    function isRelativeColumnWidth(width) {
+        const parsed = parseColumnWidth(width);
+        return parsed ? parsed.unit !== 'px' : false;
+    }
     function getColumnRegistrationById(columnId) {
         const token = columnIds.get(columnId);
         return token ? columns.get(token) : undefined;
@@ -125,9 +168,61 @@ export function createTableContext(options = {}) {
     function getColumnMaxWidth(columnId) {
         return getColumnRegistrationById(columnId)?.maxWidth;
     }
+    function getFixedColumnWidthSpec(columnId) {
+        return normalizeColumnWidth(getColumnRegistrationById(columnId)?.width);
+    }
+    function getManagedColumnWidthSpec(columnId) {
+        return normalizeColumnWidth(columnWidths.get(columnId));
+    }
+    function getDefaultColumnWidthSpec(columnId) {
+        return normalizeColumnWidth(getColumnRegistrationById(columnId)?.defaultWidth);
+    }
+    function hasAuthoredColumnWidthSpec(columnId) {
+        return (getFixedColumnWidthSpec(columnId) !== undefined ||
+            getManagedColumnWidthSpec(columnId) !== undefined ||
+            getDefaultColumnWidthSpec(columnId) !== undefined);
+    }
+    function getEffectiveColumnWidthSpec(columnId) {
+        const fixedWidth = getFixedColumnWidthSpec(columnId);
+        if (fixedWidth !== undefined) {
+            return fixedWidth;
+        }
+        const managedWidth = getManagedColumnWidthSpec(columnId);
+        if (managedWidth !== undefined) {
+            return managedWidth;
+        }
+        const defaultWidth = getDefaultColumnWidthSpec(columnId);
+        if (defaultWidth !== undefined) {
+            return defaultWidth;
+        }
+        return resizerLayoutReady && columnsWithResizers.size > 0 ? '1fr' : undefined;
+    }
+    function getMeasuredTableWidth() {
+        const tableCell = Array.from(cells.values()).find((cell) => cell.element)?.element;
+        const tableElement = tableCell?.closest('table');
+        const tableWidth = tableElement?.getBoundingClientRect().width;
+        const containerElement = tableElement?.parentElement;
+        const containerClientWidth = containerElement?.clientWidth;
+        const containerStyle = containerElement ? getComputedStyle(containerElement) : undefined;
+        const containerPaddingLeft = Number.parseFloat(containerStyle?.paddingLeft ?? '0');
+        const containerPaddingRight = Number.parseFloat(containerStyle?.paddingRight ?? '0');
+        const containerWidth = containerClientWidth !== undefined && Number.isFinite(containerClientWidth)
+            ? containerClientWidth - containerPaddingLeft - containerPaddingRight
+            : undefined;
+        // Use the container width as the stable reference for fr/% resolution.
+        // Using Math.max(table, container) causes a feedback loop during resize:
+        // the table grows → measurement returns more → fr columns get more space →
+        // the table grows further. The container width is stable and represents
+        // the actual available space the table should fill.
+        const width = containerWidth ?? tableWidth;
+        if (width === undefined || width <= 0 || !Number.isFinite(width)) {
+            return undefined;
+        }
+        return Math.round(width);
+    }
     function clampColumnWidth(columnId, width) {
         const registration = getColumnRegistrationById(columnId);
-        const minWidth = registration?.minWidth ?? 75;
+        const minWidth = registration?.minWidth ?? DEFAULT_TABLE_COLUMN_MIN_WIDTH;
         const maxWidth = registration?.maxWidth;
         let next = Math.round(width);
         if (Number.isNaN(next) || !Number.isFinite(next)) {
@@ -141,9 +236,7 @@ export function createTableContext(options = {}) {
     }
     function hasResizableColumns() {
         for (const column of columns.values()) {
-            if (isColumnHidden(column.id))
-                continue;
-            if (columnsWithResizers.has(column.token))
+            if (isColumnResizable(column.id))
                 return true;
         }
         return false;
@@ -152,12 +245,26 @@ export function createTableContext(options = {}) {
         if (columnsWithResizers.has(columnToken))
             return;
         columnsWithResizers.add(columnToken);
-        notifyLayout();
+        if (IS_BROWSER) {
+            syncResizerLayoutReady(true);
+            return;
+        }
+        resizerLayoutReady = false;
+        invalidateLayoutCaches();
+        layoutVersion.update((value) => value + 1);
+        notifyWidth();
     }
     function unregisterColumnResizer(columnToken) {
         if (!columnsWithResizers.delete(columnToken))
             return;
-        notifyLayout();
+        if (IS_BROWSER) {
+            syncResizerLayoutReady(columnsWithResizers.size > 0);
+            return;
+        }
+        resizerLayoutReady = false;
+        invalidateLayoutCaches();
+        layoutVersion.update((value) => value + 1);
+        notifyWidth();
     }
     function sameColumnMetadata(left, right) {
         return (left.token === right.token &&
@@ -271,15 +378,72 @@ export function createTableContext(options = {}) {
         return getColumnRegistrationById(columnId)?.textValue;
     }
     function getColumnWidth(columnId) {
-        const managedWidth = columnWidths.get(columnId);
-        if (managedWidth !== undefined) {
-            return clampColumnWidth(columnId, managedWidth);
+        const parsed = parseColumnWidth(getEffectiveColumnWidthSpec(columnId));
+        if (!parsed)
+            return undefined;
+        if (!isColumnHidden(columnId)) {
+            if (parsed.unit !== 'px') {
+                return undefined;
+            }
+            return getResolvedVisibleColumnWidths().get(columnId);
         }
-        const registration = getColumnRegistrationById(columnId);
-        if (!registration)
+        return parsed?.unit === 'px' ? clampColumnWidth(columnId, parsed.value) : undefined;
+    }
+    function formatCssLength(length) {
+        const rounded = Math.round(length * 1000) / 1000;
+        return Number.isInteger(rounded) ? `${rounded}` : `${rounded}`;
+    }
+    function getColumnWidthStyle(columnId) {
+        const resolvedWidth = getColumnWidth(columnId);
+        if (resolvedWidth !== undefined) {
+            return `${resolvedWidth}px`;
+        }
+        const parsed = parseColumnWidth(getEffectiveColumnWidthSpec(columnId));
+        if (!parsed)
+            return undefined;
+        if (parsed.unit === 'px') {
+            return `${clampColumnWidth(columnId, parsed.value)}px`;
+        }
+        if (parsed.unit === '%') {
+            return `${parsed.value}%`;
+        }
+        let fixedPxTotal = 0;
+        let percentTotal = 0;
+        let totalFr = 0;
+        for (const token of getVisibleOrderedColumnTokens()) {
+            const column = columns.get(token);
+            if (!column)
+                continue;
+            const spec = parseColumnWidth(getEffectiveColumnWidthSpec(column.id));
+            if (!spec)
+                continue;
+            if (spec.unit === 'px') {
+                fixedPxTotal += clampColumnWidth(column.id, spec.value);
+                continue;
+            }
+            if (spec.unit === '%') {
+                percentTotal += spec.value;
+                continue;
+            }
+            totalFr += spec.value;
+        }
+        if (totalFr <= 0)
             return undefined;
-        const nextWidth = normalizeColumnWidth(registration.width) ?? normalizeColumnWidth(registration.defaultWidth);
-        return nextWidth !== undefined ? clampColumnWidth(columnId, nextWidth) : undefined;
+        const frShare = parsed.value / totalFr;
+        const availableWidthTerms = ['100%'];
+        if (fixedPxTotal > 0) {
+            availableWidthTerms.push(`${formatCssLength(fixedPxTotal)}px`);
+        }
+        if (percentTotal > 0) {
+            availableWidthTerms.push(`${formatCssLength(percentTotal)}%`);
+        }
+        const availableWidthExpression = availableWidthTerms.length === 1
+            ? availableWidthTerms[0]
+            : `(${availableWidthTerms.join(' - ')})`;
+        if (frShare === 1) {
+            return `calc(${availableWidthExpression})`;
+        }
+        return `calc(${availableWidthExpression} * ${formatCssLength(frShare)})`;
     }
     function isColumnResizable(columnId) {
         const column = getColumnRegistrationById(columnId);
@@ -297,7 +461,7 @@ export function createTableContext(options = {}) {
             const column = columns.get(token);
             if (!column)
                 continue;
-            const width = getColumnWidth(column.id);
+            const width = getManagedColumnWidthSpec(column.id);
             if (width !== undefined) {
                 widths.set(column.id, width);
             }
@@ -317,6 +481,63 @@ export function createTableContext(options = {}) {
         visibleColumnWidthsCache = widths;
         return widths;
     }
+    function hasRelativeVisibleColumnWidths() {
+        for (const token of getVisibleOrderedColumnTokens()) {
+            const column = columns.get(token);
+            if (!column)
+                continue;
+            if (isRelativeColumnWidth(getEffectiveColumnWidthSpec(column.id))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function getResolvedVisibleColumnWidths() {
+        if (resolvedVisibleColumnWidthsCache)
+            return resolvedVisibleColumnWidthsCache;
+        const widths = new Map();
+        const flexibleColumns = [];
+        const tableWidth = getMeasuredTableWidth();
+        let remainingWidth = tableWidth;
+        let totalFr = 0;
+        for (const token of getVisibleOrderedColumnTokens()) {
+            const column = columns.get(token);
+            if (!column)
+                continue;
+            const parsed = parseColumnWidth(getEffectiveColumnWidthSpec(column.id));
+            if (!parsed)
+                continue;
+            if (parsed.unit === 'px') {
+                const nextWidth = clampColumnWidth(column.id, parsed.value);
+                widths.set(column.id, nextWidth);
+                if (remainingWidth !== undefined) {
+                    remainingWidth -= nextWidth;
+                }
+                continue;
+            }
+            if (parsed.unit === '%') {
+                if (tableWidth === undefined)
+                    continue;
+                const nextWidth = clampColumnWidth(column.id, (tableWidth * parsed.value) / 100);
+                widths.set(column.id, nextWidth);
+                if (remainingWidth !== undefined) {
+                    remainingWidth -= nextWidth;
+                }
+                continue;
+            }
+            flexibleColumns.push({ columnId: column.id, fr: parsed.value });
+            totalFr += parsed.value;
+        }
+        if (tableWidth !== undefined && flexibleColumns.length > 0 && totalFr > 0) {
+            const distributableWidth = Math.max(remainingWidth ?? tableWidth, 0);
+            for (const entry of flexibleColumns) {
+                const nextWidth = clampColumnWidth(entry.columnId, (distributableWidth * entry.fr) / totalFr);
+                widths.set(entry.columnId, nextWidth);
+            }
+        }
+        resolvedVisibleColumnWidthsCache = widths;
+        return widths;
+    }
     function getMeasuredHeaderWidth(columnToken) {
         const headerCell = Array.from(cells.values()).find((cell) => cell.section === 'header' && cell.columnToken === columnToken && cell.element);
         const width = headerCell?.element?.getBoundingClientRect().width;
@@ -325,42 +546,91 @@ export function createTableContext(options = {}) {
         }
         return Math.round(width);
     }
-    function freezeColumnWidthsFromLayout() {
-        const next = new Map();
-        let changed = false;
-        for (const token of columnOrder) {
+    function getResizableRelativeTailColumnId(activeColumnId) {
+        return getVisibleOrderedColumnTokens()
+            .map((token) => columns.get(token))
+            .filter((column) => !!column)
+            .filter((column) => {
+            if (column.id === activeColumnId)
+                return false;
+            if (getFixedColumnWidthSpec(column.id) !== undefined)
+                return false;
+            return isRelativeColumnWidth(getEffectiveColumnWidthSpec(column.id));
+        })
+            .at(-1)?.id;
+    }
+    function prepareColumnWidthsForResize(activeColumnId) {
+        const next = new Map(columnWidths);
+        const baselineWidths = new Map();
+        const preservedFlexibleColumnId = getResizableRelativeTailColumnId(activeColumnId);
+        const preservedFlexibleEffectiveWidth = preservedFlexibleColumnId
+            ? normalizeColumnWidth(getEffectiveColumnWidthSpec(preservedFlexibleColumnId))
+            : undefined;
+        const measuredTableWidth = getMeasuredTableWidth();
+        for (const token of getVisibleOrderedColumnTokens()) {
             const column = columns.get(token);
             if (!column)
                 continue;
+            if (getFixedColumnWidthSpec(column.id) !== undefined)
+                continue;
             const measuredWidth = getMeasuredHeaderWidth(token);
-            const resolvedWidth = measuredWidth ?? getColumnWidth(column.id);
+            const resolvedWidth = getColumnWidth(column.id) ?? measuredWidth;
             if (resolvedWidth === undefined)
                 continue;
-            const clampedWidth = clampColumnWidth(column.id, resolvedWidth);
-            next.set(column.id, clampedWidth);
-            if (columnWidths.get(column.id) !== clampedWidth) {
-                changed = true;
+            const frozenWidth = clampColumnWidth(column.id, resolvedWidth);
+            next.set(column.id, frozenWidth);
+            baselineWidths.set(column.id, frozenWidth);
+        }
+        let changed = next.size !== columnWidths.size;
+        if (!changed) {
+            for (const [columnId, width] of next) {
+                if (columnWidths.get(columnId) !== width) {
+                    changed = true;
+                    break;
+                }
             }
         }
-        if (!changed || next.size === 0)
+        if (!changed)
             return;
         columnWidths.clear();
         for (const [columnId, width] of next) {
             columnWidths.set(columnId, width);
         }
         columnWidthsCache = null;
+        visibleColumnWidthsCache = null;
+        const baselineTotalWidth = Array.from(baselineWidths.values()).reduce((total, current) => total + current, 0);
+        resizeSession = {
+            activeColumnId: activeColumnId,
+            flexibleTailColumnId: preservedFlexibleColumnId,
+            flexibleTailRestoreWidth: preservedFlexibleColumnId && isRelativeColumnWidth(preservedFlexibleEffectiveWidth)
+                ? preservedFlexibleEffectiveWidth
+                : undefined,
+            baselineWidths,
+            baselineTableWidth: measuredTableWidth ?? baselineTotalWidth,
+            baselineTotalWidth
+        };
         options.onColumnWidthsChange?.(getColumnWidths());
         notifyWidth();
     }
+    function shouldPrepareColumnWidthsForResize(columnId) {
+        if (getFixedColumnWidthSpec(columnId) !== undefined)
+            return false;
+        if (!hasRelativeVisibleColumnWidths())
+            return false;
+        return resizeSession?.activeColumnId !== columnId;
+    }
     function setColumnWidths(widths) {
         const next = new Map();
+        const incomingWidths = widths ? new Map(widths) : undefined;
         for (const token of columnOrder) {
             const column = columns.get(token);
             if (!column)
                 continue;
-            const incomingWidth = widths ? new Map(widths).get(column.id) : undefined;
+            if (getFixedColumnWidthSpec(column.id) !== undefined)
+                continue;
+            const incomingWidth = normalizeColumnWidth(incomingWidths?.get(column.id));
             if (incomingWidth !== undefined) {
-                next.set(column.id, clampColumnWidth(column.id, incomingWidth));
+                next.set(column.id, incomingWidth);
             }
         }
         columnWidths.clear();
@@ -370,13 +640,36 @@ export function createTableContext(options = {}) {
         notifyWidth();
     }
     function setColumnWidth(columnId, width) {
+        if (getFixedColumnWidthSpec(columnId) !== undefined)
+            return;
         if (!isColumnResizable(columnId))
             return;
+        if (shouldPrepareColumnWidthsForResize(columnId)) {
+            prepareColumnWidthsForResize(columnId);
+        }
         const nextWidth = clampColumnWidth(columnId, width);
-        if (columnWidths.get(columnId) === nextWidth)
+        const currentWidth = columnWidths.get(columnId);
+        if (resizeSession?.activeColumnId === columnId &&
+            resizeSession.flexibleTailColumnId !== undefined) {
+            const baselineActiveWidth = resizeSession.baselineWidths.get(columnId);
+            const baselineTailWidth = resizeSession.baselineWidths.get(resizeSession.flexibleTailColumnId);
+            if (baselineActiveWidth !== undefined && baselineTailWidth !== undefined) {
+                const widthDelta = nextWidth - baselineActiveWidth;
+                const overflowWidth = Math.max(resizeSession.baselineTotalWidth - resizeSession.baselineTableWidth, 0);
+                const tailTargetWidth = widthDelta >= 0
+                    ? baselineTailWidth - widthDelta
+                    : baselineTailWidth + Math.max(-widthDelta - overflowWidth, 0);
+                const tailWidth = clampColumnWidth(resizeSession.flexibleTailColumnId, tailTargetWidth);
+                if (columnWidths.get(resizeSession.flexibleTailColumnId) !== tailWidth) {
+                    columnWidths.set(resizeSession.flexibleTailColumnId, tailWidth);
+                }
+            }
+        }
+        if (currentWidth === nextWidth)
             return;
         columnWidths.set(columnId, nextWidth);
         columnWidthsCache = null;
+        visibleColumnWidthsCache = null;
         options.onColumnWidthsChange?.(getColumnWidths());
         notifyWidth();
     }
@@ -502,9 +795,7 @@ export function createTableContext(options = {}) {
         notifyWidth();
     }
     function measureIntrinsicElementWidth(cell) {
-        const target = cell.querySelector('[data-table-header-content]') ??
-            cell.firstElementChild ??
-            cell;
+        const target = cell;
         const clone = target.cloneNode(true);
         for (const separator of clone.querySelectorAll('[role="separator"]')) {
             separator.remove();
@@ -563,9 +854,7 @@ export function createTableContext(options = {}) {
     function startColumnResize(columnId) {
         if (!isColumnResizable(columnId) || resizingColumnId === columnId)
             return;
-        if (getVisibleColumnWidths().size < getVisibleColumnCount()) {
-            freezeColumnWidthsFromLayout();
-        }
+        resizeSession = null;
         resizingColumnId = columnId;
         options.onColumnResizeStart?.(columnId);
         notifyResize();
@@ -573,8 +862,24 @@ export function createTableContext(options = {}) {
     function endColumnResize() {
         if (!resizingColumnId)
             return;
+        let restoredFlexibleTail = false;
+        if (resizeSession?.flexibleTailColumnId !== undefined &&
+            resizeSession.activeColumnId !== resizeSession.flexibleTailColumnId &&
+            resizeSession.flexibleTailRestoreWidth !== undefined) {
+            const tailColumnId = resizeSession.flexibleTailColumnId;
+            columnWidths.set(tailColumnId, resizeSession.flexibleTailRestoreWidth);
+            columnWidthsCache = null;
+            visibleColumnWidthsCache = null;
+            resolvedVisibleColumnWidthsCache = null;
+            restoredFlexibleTail = true;
+        }
         resizingColumnId = null;
+        if (restoredFlexibleTail) {
+            options.onColumnWidthsChange?.(getColumnWidths());
+        }
+        resizeSession = null;
         options.onColumnResizeEnd?.(getColumnWidths());
+        notifyWidthImmediately();
         notifyResize();
     }
     function suppressHeaderClickOnce() {
@@ -606,6 +911,7 @@ export function createTableContext(options = {}) {
         if (targetOrder && !targetOrder.includes(row.token)) {
             targetOrder.push(row.token);
         }
+        notifySelection();
         notifyLayout();
     }
     function unregisterRow(token) {
@@ -633,8 +939,19 @@ export function createTableContext(options = {}) {
                 notifyFocus();
             }
         }
+        notifySelection();
         notifyLayout();
     }
+    function markBodyRowsInitialized() {
+        if (bodyRowsInitialized)
+            return;
+        const optimisticHasSelectableRows = selectionMode === 'multiple' || selectedKeys.size > 0;
+        bodyRowsInitialized = true;
+        const actualHasSelectableRows = getOrderedSelectableRowIds().length > 0 || selectedKeys.size > 0;
+        if (optimisticHasSelectableRows !== actualHasSelectableRows) {
+            notifySelection();
+        }
+    }
     function getBodyRowCount() {
         return getOrderedRowTokens('body').length;
     }
@@ -719,6 +1036,9 @@ export function createTableContext(options = {}) {
         return 'some';
     }
     function hasSelectableRows() {
+        if (!bodyRowsInitialized) {
+            return selectionMode === 'multiple' || selectedKeys.size > 0;
+        }
         return getOrderedSelectableRowIds().length > 0 || selectedKeys.size > 0;
     }
     function isRowFocused(token) {
@@ -1465,12 +1785,16 @@ export function createTableContext(options = {}) {
         getVisibleColumnIndexByToken,
         getColumnTextValue,
         getColumnWidth,
+        getColumnWidthStyle,
+        hasAuthoredColumnWidthSpec,
         getColumnMinWidth,
         getColumnMaxWidth,
         isColumnHidden,
         isColumnResizable,
         getColumnWidths,
         getVisibleColumnWidths,
+        getResolvedVisibleColumnWidths,
+        hasRelativeVisibleColumnWidths,
         setColumnWidths,
         setColumnWidth,
         setHiddenColumns,
@@ -1482,6 +1806,7 @@ export function createTableContext(options = {}) {
         hasResizableColumns,
         registerRow,
         unregisterRow,
+        markBodyRowsInitialized,
         getHeaderRowCount,
         getBodyRowCount,
         isRowSelected,