@human-kit/svelte-components 1.0.0-alpha.4 → 1.0.0-alpha.6

package/dist/table/root/context.js

@@ -0,0 +1,1426 @@
+import { 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');
+export function createTableContext(options = {}) {
+    let selectionMode = options.selectionMode ?? 'none';
+    let selectionBehavior = options.selectionBehavior ?? 'toggle';
+    let sortDescriptor = options.initialSortDescriptor;
+    let focusedCellKey = null;
+    let focusedRowTarget = null;
+    let focusVisible = false;
+    let selectedKeys = new Set(options.initialSelectedKeys ?? []);
+    let selectionAnchorKey = selectedKeys.values().next().value ?? null;
+    const disabledKeys = new Set(options.disabledKeys ?? []);
+    const hiddenColumnIds = new Set(options.initialHiddenColumns ?? []);
+    let resizingColumnId = null;
+    let suppressNextHeaderClick = false;
+    const columns = new Map();
+    const columnIds = new Map();
+    const columnOrder = [];
+    const columnsWithResizers = new Set();
+    const columnWidths = new Map(options.initialColumnWidths ?? []);
+    const rows = new Map();
+    const headerRowOrder = [];
+    const bodyRowOrder = [];
+    const cells = new Map();
+    const cellOrder = [];
+    let orderedRowTokensCache = {
+        header: null,
+        body: null
+    };
+    let orderedColumnTokensCache = null;
+    let visibleOrderedColumnTokensCache = null;
+    let columnWidthsCache = null;
+    let navigableCellsCache = null;
+    let rowsWithCellsCache = null;
+    const layoutVersion = writable(0);
+    const selectionVersion = writable(0);
+    const focusVersion = writable(0);
+    const sortVersion = writable(0);
+    const widthVersion = writable(0);
+    const resizeVersion = writable(0);
+    const instanceCounters = new Map();
+    function createInstanceToken(prefix) {
+        const nextCount = (instanceCounters.get(prefix) ?? 0) + 1;
+        instanceCounters.set(prefix, nextCount);
+        return `table-${prefix}-${nextCount}`;
+    }
+    function invalidateLayoutCaches() {
+        orderedRowTokensCache = { header: null, body: null };
+        orderedColumnTokensCache = null;
+        visibleOrderedColumnTokensCache = null;
+        columnWidthsCache = null;
+        navigableCellsCache = null;
+        rowsWithCellsCache = null;
+    }
+    let layoutNotifyScheduled = false;
+    let widthNotifyScheduled = false;
+    function notifyLayout() {
+        invalidateLayoutCaches();
+        if (!layoutNotifyScheduled) {
+            layoutNotifyScheduled = true;
+            queueMicrotask(() => {
+                layoutNotifyScheduled = false;
+                layoutVersion.update((value) => value + 1);
+            });
+        }
+    }
+    function notifySelection() {
+        selectionVersion.update((value) => value + 1);
+    }
+    function notifyFocus() {
+        focusVersion.update((value) => value + 1);
+    }
+    function notifySort() {
+        invalidateLayoutCaches();
+        sortVersion.update((value) => value + 1);
+    }
+    function notifyWidth() {
+        columnWidthsCache = null;
+        if (!widthNotifyScheduled) {
+            widthNotifyScheduled = true;
+            queueMicrotask(() => {
+                widthNotifyScheduled = false;
+                widthVersion.update((value) => value + 1);
+            });
+        }
+    }
+    function notifyResize() {
+        resizeVersion.update((value) => value + 1);
+    }
+    function normalizeColumnWidth(width) {
+        if (typeof width === 'number') {
+            return Number.isFinite(width) ? width : undefined;
+        }
+        if (typeof width === 'string') {
+            const match = width.trim().match(/^(\d+(?:\.\d+)?)px$/i);
+            if (!match)
+                return undefined;
+            const next = Number(match[1]);
+            return Number.isFinite(next) ? next : undefined;
+        }
+        return undefined;
+    }
+    function getColumnRegistrationById(columnId) {
+        const token = columnIds.get(columnId);
+        return token ? columns.get(token) : undefined;
+    }
+    function isColumnHidden(columnId) {
+        return hiddenColumnIds.has(columnId);
+    }
+    function getColumnMinWidth(columnId) {
+        return getColumnRegistrationById(columnId)?.minWidth;
+    }
+    function getColumnMaxWidth(columnId) {
+        return getColumnRegistrationById(columnId)?.maxWidth;
+    }
+    function clampColumnWidth(columnId, width) {
+        const registration = getColumnRegistrationById(columnId);
+        const minWidth = registration?.minWidth ?? 75;
+        const maxWidth = registration?.maxWidth;
+        let next = Math.round(width);
+        if (Number.isNaN(next) || !Number.isFinite(next)) {
+            next = minWidth;
+        }
+        next = Math.max(minWidth, next);
+        if (maxWidth !== undefined) {
+            next = Math.min(maxWidth, next);
+        }
+        return next;
+    }
+    function hasResizableColumns() {
+        for (const column of columns.values()) {
+            if (isColumnHidden(column.id))
+                continue;
+            if (column.allowsResizing || columnsWithResizers.has(column.token))
+                return true;
+        }
+        return false;
+    }
+    function registerColumnResizer(columnToken) {
+        if (columnsWithResizers.has(columnToken))
+            return;
+        columnsWithResizers.add(columnToken);
+        notifyLayout();
+    }
+    function unregisterColumnResizer(columnToken) {
+        if (!columnsWithResizers.delete(columnToken))
+            return;
+        notifyLayout();
+    }
+    function sameColumnRegistration(left, right) {
+        return (left.token === right.token &&
+            left.id === right.id &&
+            left.allowsSorting === right.allowsSorting &&
+            left.allowsResizing === right.allowsResizing &&
+            left.isRowHeader === right.isRowHeader &&
+            left.textValue === right.textValue &&
+            left.width === right.width &&
+            left.defaultWidth === right.defaultWidth &&
+            left.minWidth === right.minWidth &&
+            left.maxWidth === right.maxWidth);
+    }
+    function sameRowRegistration(left, right) {
+        return (left.token === right.token &&
+            left.section === right.section &&
+            left.id === right.id &&
+            left.disabled === right.disabled &&
+            left.element === right.element);
+    }
+    function sameCellRegistration(left, right) {
+        return (left.key === right.key &&
+            left.rowToken === right.rowToken &&
+            left.section === right.section &&
+            left.columnIndex === right.columnIndex &&
+            left.columnToken === right.columnToken &&
+            left.element === right.element &&
+            left.focusDelegate === right.focusDelegate);
+    }
+    function registerColumn(column) {
+        const existing = columns.get(column.token);
+        const alreadyOrdered = columnOrder.includes(column.token);
+        if (existing && sameColumnRegistration(existing, column) && alreadyOrdered)
+            return;
+        if (existing && existing.id !== column.id && columnIds.get(existing.id) === column.token) {
+            columnIds.delete(existing.id);
+        }
+        columns.set(column.token, column);
+        columnIds.set(column.id, column.token);
+        if (!alreadyOrdered) {
+            columnOrder.push(column.token);
+        }
+        notifyLayout();
+    }
+    function unregisterColumn(token) {
+        const column = columns.get(token);
+        if (column && columnIds.get(column.id) === token) {
+            columnIds.delete(column.id);
+        }
+        columns.delete(token);
+        columnsWithResizers.delete(token);
+        const index = columnOrder.indexOf(token);
+        if (index >= 0) {
+            columnOrder.splice(index, 1);
+        }
+        notifyLayout();
+    }
+    function getOrderedColumnTokens() {
+        if (orderedColumnTokensCache)
+            return orderedColumnTokensCache;
+        // Pre-build a lookup from columnToken → header cell element to avoid
+        // O(columns × cells) scanning inside the comparator.
+        const headerElementByToken = new Map();
+        for (const cell of cells.values()) {
+            if (cell.section === 'header' && cell.columnToken && cell.element) {
+                headerElementByToken.set(cell.columnToken, cell.element);
+            }
+        }
+        orderedColumnTokensCache = [...columnOrder].sort((leftToken, rightToken) => {
+            const leftCell = headerElementByToken.get(leftToken);
+            const rightCell = headerElementByToken.get(rightToken);
+            if (!leftCell || !rightCell) {
+                return columnOrder.indexOf(leftToken) - columnOrder.indexOf(rightToken);
+            }
+            if (leftCell === rightCell)
+                return 0;
+            const position = leftCell.compareDocumentPosition(rightCell);
+            if (position & Node.DOCUMENT_POSITION_FOLLOWING)
+                return -1;
+            if (position & Node.DOCUMENT_POSITION_PRECEDING)
+                return 1;
+            return columnOrder.indexOf(leftToken) - columnOrder.indexOf(rightToken);
+        });
+        return orderedColumnTokensCache;
+    }
+    function getColumnCount() {
+        return getOrderedColumnTokens().length;
+    }
+    function getVisibleOrderedColumnTokens() {
+        if (visibleOrderedColumnTokensCache)
+            return visibleOrderedColumnTokensCache;
+        visibleOrderedColumnTokensCache = getOrderedColumnTokens().filter((token) => {
+            const column = columns.get(token);
+            return column ? !isColumnHidden(column.id) : false;
+        });
+        return visibleOrderedColumnTokensCache;
+    }
+    function getVisibleColumnCount() {
+        return getVisibleOrderedColumnTokens().length;
+    }
+    function getColumnAt(index) {
+        const token = getOrderedColumnTokens()[index];
+        return token ? columns.get(token) : undefined;
+    }
+    function getColumnIndexByToken(token) {
+        return getOrderedColumnTokens().indexOf(token);
+    }
+    function getVisibleColumnIndexByToken(token) {
+        return getVisibleOrderedColumnTokens().indexOf(token);
+    }
+    function getColumnTextValue(columnId) {
+        return getColumnRegistrationById(columnId)?.textValue;
+    }
+    function getColumnWidth(columnId) {
+        const managedWidth = columnWidths.get(columnId);
+        if (managedWidth !== undefined) {
+            return clampColumnWidth(columnId, managedWidth);
+        }
+        const registration = getColumnRegistrationById(columnId);
+        if (!registration)
+            return undefined;
+        const nextWidth = normalizeColumnWidth(registration.width) ?? normalizeColumnWidth(registration.defaultWidth);
+        return nextWidth !== undefined ? clampColumnWidth(columnId, nextWidth) : undefined;
+    }
+    function isColumnResizable(columnId) {
+        const column = getColumnRegistrationById(columnId);
+        if (!column)
+            return false;
+        if (isColumnHidden(columnId))
+            return false;
+        return column.allowsResizing || columnsWithResizers.has(column.token);
+    }
+    function getColumnWidths() {
+        if (columnWidthsCache)
+            return columnWidthsCache;
+        const widths = new Map();
+        for (const token of getOrderedColumnTokens()) {
+            const column = columns.get(token);
+            if (!column)
+                continue;
+            const width = getColumnWidth(column.id);
+            if (width !== undefined) {
+                widths.set(column.id, width);
+            }
+        }
+        columnWidthsCache = widths;
+        return widths;
+    }
+    function getVisibleColumnWidths() {
+        const widths = new Map();
+        for (const [columnId, width] of getColumnWidths()) {
+            if (isColumnHidden(columnId))
+                continue;
+            widths.set(columnId, width);
+        }
+        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;
+        if (width === undefined || width <= 0 || !Number.isFinite(width)) {
+            return undefined;
+        }
+        return Math.round(width);
+    }
+    function freezeColumnWidthsFromLayout() {
+        const next = new Map();
+        let changed = false;
+        for (const token of columnOrder) {
+            const column = columns.get(token);
+            if (!column)
+                continue;
+            const measuredWidth = getMeasuredHeaderWidth(token);
+            const resolvedWidth = measuredWidth ?? getColumnWidth(column.id);
+            if (resolvedWidth === undefined)
+                continue;
+            const clampedWidth = clampColumnWidth(column.id, resolvedWidth);
+            next.set(column.id, clampedWidth);
+            if (columnWidths.get(column.id) !== clampedWidth) {
+                changed = true;
+            }
+        }
+        if (!changed || next.size === 0)
+            return;
+        columnWidths.clear();
+        for (const [columnId, width] of next) {
+            columnWidths.set(columnId, width);
+        }
+        columnWidthsCache = null;
+        options.onColumnWidthsChange?.(getColumnWidths());
+        notifyWidth();
+    }
+    function setColumnWidths(widths) {
+        const next = new Map();
+        for (const token of columnOrder) {
+            const column = columns.get(token);
+            if (!column)
+                continue;
+            const incomingWidth = widths ? new Map(widths).get(column.id) : undefined;
+            if (incomingWidth !== undefined) {
+                next.set(column.id, clampColumnWidth(column.id, incomingWidth));
+            }
+        }
+        columnWidths.clear();
+        for (const [columnId, width] of next) {
+            columnWidths.set(columnId, width);
+        }
+        notifyWidth();
+    }
+    function setColumnWidth(columnId, width) {
+        if (!isColumnResizable(columnId))
+            return;
+        const nextWidth = clampColumnWidth(columnId, width);
+        if (columnWidths.get(columnId) === nextWidth)
+            return;
+        columnWidths.set(columnId, nextWidth);
+        columnWidthsCache = null;
+        options.onColumnWidthsChange?.(getColumnWidths());
+        notifyWidth();
+    }
+    function getCellColumn(cell) {
+        if (cell.section === 'header' && cell.columnToken) {
+            return columns.get(cell.columnToken);
+        }
+        return cell.columnIndex !== undefined ? getColumnAt(cell.columnIndex) : undefined;
+    }
+    function isCellColumnHidden(cell) {
+        const column = getCellColumn(cell);
+        return column ? isColumnHidden(column.id) : false;
+    }
+    function getNearestVisibleCellKey(targetCell) {
+        const targetPhysicalIndex = targetCell.section === 'header'
+            ? targetCell.columnToken
+                ? getColumnIndexByToken(targetCell.columnToken)
+                : -1
+            : (targetCell.columnIndex ?? -1);
+        const siblingCells = Array.from(cells.values())
+            .filter((candidate) => {
+            if (candidate.key === targetCell.key)
+                return false;
+            if (candidate.rowToken !== targetCell.rowToken)
+                return false;
+            if (candidate.section !== targetCell.section)
+                return false;
+            if (!candidate.element)
+                return false;
+            if (isCellColumnHidden(candidate))
+                return false;
+            if (candidate.section === 'body' &&
+                isRowDisabled(rows.get(candidate.rowToken)?.id, rows.get(candidate.rowToken)?.disabled)) {
+                return false;
+            }
+            return true;
+        })
+            .map((candidate) => {
+            const physicalIndex = candidate.section === 'header'
+                ? candidate.columnToken
+                    ? getColumnIndexByToken(candidate.columnToken)
+                    : -1
+                : (candidate.columnIndex ?? -1);
+            const candidateColumn = getCellColumn(candidate);
+            return { candidate, physicalIndex, candidateColumn };
+        })
+            .filter((entry) => entry.physicalIndex >= 0 && entry.candidateColumn);
+        if (siblingCells.length === 0)
+            return null;
+        siblingCells.sort((left, right) => {
+            const leftDistance = Math.abs(left.physicalIndex - targetPhysicalIndex);
+            const rightDistance = Math.abs(right.physicalIndex - targetPhysicalIndex);
+            if (leftDistance !== rightDistance)
+                return leftDistance - rightDistance;
+            return left.physicalIndex - right.physicalIndex;
+        });
+        return siblingCells[0]?.candidate.key ?? null;
+    }
+    function reconcileFocusAfterHiddenColumnsChange() {
+        if (resizingColumnId && isColumnHidden(resizingColumnId)) {
+            endColumnResize();
+        }
+        if (!focusedCellKey)
+            return;
+        const focusedCell = cells.get(focusedCellKey);
+        if (!focusedCell || !isCellColumnHidden(focusedCell))
+            return;
+        const replacementKey = getNearestVisibleCellKey(focusedCell);
+        if (replacementKey) {
+            focusCellByKey(replacementKey);
+            return;
+        }
+        focusedCellKey = null;
+        focusedRowTarget = null;
+        notifyFocus();
+    }
+    function setHiddenColumns(columnIds) {
+        const next = new Set(columnIds ?? []);
+        let changed = next.size !== hiddenColumnIds.size;
+        if (!changed) {
+            for (const columnId of hiddenColumnIds) {
+                if (!next.has(columnId)) {
+                    changed = true;
+                    break;
+                }
+            }
+        }
+        if (!changed)
+            return;
+        hiddenColumnIds.clear();
+        for (const columnId of next) {
+            hiddenColumnIds.add(columnId);
+        }
+        reconcileFocusAfterHiddenColumnsChange();
+        notifyLayout();
+        notifyWidth();
+    }
+    function measureIntrinsicElementWidth(cell) {
+        const target = cell.querySelector('[data-table-header-content]') ??
+            cell.firstElementChild ??
+            cell;
+        const clone = target.cloneNode(true);
+        for (const separator of clone.querySelectorAll('[role="separator"]')) {
+            separator.remove();
+        }
+        // Copy the cell's computed font so the clone inherits correct text metrics
+        // (the clone is appended to document.body which may have different font styles)
+        const cellFont = getComputedStyle(cell);
+        clone.style.font = cellFont.font;
+        clone.style.letterSpacing = cellFont.letterSpacing;
+        clone.style.wordSpacing = cellFont.wordSpacing;
+        clone.style.position = 'absolute';
+        clone.style.visibility = 'hidden';
+        clone.style.pointerEvents = 'none';
+        clone.style.left = '-99999px';
+        clone.style.top = '0';
+        clone.style.width = 'max-content';
+        clone.style.maxWidth = 'none';
+        clone.style.minWidth = '0';
+        clone.style.overflow = 'visible';
+        clone.style.whiteSpace = 'nowrap';
+        document.body.appendChild(clone);
+        const width = Math.ceil(clone.getBoundingClientRect().width);
+        clone.remove();
+        return width;
+    }
+    function measureColumnContentWidth(columnId) {
+        const registration = getColumnRegistrationById(columnId);
+        if (!registration)
+            return undefined;
+        const columnIndex = getColumnIndexByToken(registration.token);
+        if (columnIndex < 0)
+            return undefined;
+        const measuredWidths = [];
+        for (const cell of cells.values()) {
+            const matchesHeader = cell.section === 'header' && cell.columnToken === registration.token && cell.element;
+            const matchesBody = cell.section === 'body' && cell.columnIndex === columnIndex && cell.element;
+            if (!matchesHeader && !matchesBody)
+                continue;
+            const element = cell.element;
+            if (!element)
+                continue;
+            const computedStyle = getComputedStyle(element);
+            const paddingX = parseFloat(computedStyle.paddingLeft || '0') +
+                parseFloat(computedStyle.paddingRight || '0');
+            const borderX = parseFloat(computedStyle.borderLeftWidth || '0') +
+                parseFloat(computedStyle.borderRightWidth || '0');
+            const contentWidth = measureIntrinsicElementWidth(element);
+            if (contentWidth <= 0)
+                continue;
+            measuredWidths.push(Math.ceil(contentWidth + paddingX + borderX));
+        }
+        if (measuredWidths.length === 0)
+            return undefined;
+        return clampColumnWidth(columnId, Math.max(...measuredWidths));
+    }
+    function startColumnResize(columnId) {
+        if (!isColumnResizable(columnId) || resizingColumnId === columnId)
+            return;
+        if (getVisibleColumnWidths().size < getVisibleColumnCount()) {
+            freezeColumnWidthsFromLayout();
+        }
+        resizingColumnId = columnId;
+        options.onColumnResizeStart?.(columnId);
+        notifyResize();
+    }
+    function endColumnResize() {
+        if (!resizingColumnId)
+            return;
+        resizingColumnId = null;
+        options.onColumnResizeEnd?.(getColumnWidths());
+        notifyResize();
+    }
+    function suppressHeaderClickOnce() {
+        suppressNextHeaderClick = true;
+    }
+    function consumeHeaderClickSuppression() {
+        const shouldSuppress = suppressNextHeaderClick;
+        suppressNextHeaderClick = false;
+        return shouldSuppress;
+    }
+    function registerRow(row) {
+        const existing = rows.get(row.token);
+        const targetOrder = row.section === 'header' ? headerRowOrder : row.section === 'body' ? bodyRowOrder : null;
+        const alreadyOrdered = targetOrder ? targetOrder.includes(row.token) : false;
+        const wasInHeader = headerRowOrder.includes(row.token);
+        const wasInBody = bodyRowOrder.includes(row.token);
+        if (existing &&
+            sameRowRegistration(existing, row) &&
+            (targetOrder ? alreadyOrdered : !wasInHeader && !wasInBody)) {
+            return;
+        }
+        if (wasInHeader) {
+            headerRowOrder.splice(headerRowOrder.indexOf(row.token), 1);
+        }
+        if (wasInBody) {
+            bodyRowOrder.splice(bodyRowOrder.indexOf(row.token), 1);
+        }
+        rows.set(row.token, row);
+        if (targetOrder && !targetOrder.includes(row.token)) {
+            targetOrder.push(row.token);
+        }
+        notifyLayout();
+    }
+    function unregisterRow(token) {
+        const row = rows.get(token);
+        rows.delete(token);
+        if (focusedRowTarget?.rowToken === token) {
+            focusedRowTarget = null;
+            notifyFocus();
+        }
+        for (const order of [headerRowOrder, bodyRowOrder]) {
+            const index = order.indexOf(token);
+            if (index >= 0) {
+                order.splice(index, 1);
+            }
+        }
+        for (const [key, cell] of cells.entries()) {
+            if (cell.rowToken === token) {
+                cells.delete(key);
+            }
+        }
+        if (row && focusedCellKey) {
+            const focusedCell = cells.get(focusedCellKey);
+            if (!focusedCell || focusedCell.rowToken === token) {
+                focusedCellKey = null;
+                notifyFocus();
+            }
+        }
+        notifyLayout();
+    }
+    function getBodyRowCount() {
+        return getOrderedRowTokens('body').length;
+    }
+    function getHeaderRowCount() {
+        return getOrderedRowTokens('header').length;
+    }
+    function compareRowsByDocumentOrder(leftToken, rightToken, fallback) {
+        const leftIndex = fallback.indexOf(leftToken);
+        const rightIndex = fallback.indexOf(rightToken);
+        const leftRow = rows.get(leftToken)?.element;
+        const rightRow = rows.get(rightToken)?.element;
+        if (!leftRow || !rightRow || leftRow === rightRow) {
+            return leftIndex - rightIndex;
+        }
+        const position = leftRow.compareDocumentPosition(rightRow);
+        if (position & Node.DOCUMENT_POSITION_FOLLOWING)
+            return -1;
+        if (position & Node.DOCUMENT_POSITION_PRECEDING)
+            return 1;
+        return leftIndex - rightIndex;
+    }
+    function getOrderedRowTokens(section) {
+        const cached = orderedRowTokensCache[section];
+        if (cached)
+            return cached;
+        const fallback = section === 'header' ? headerRowOrder : bodyRowOrder;
+        const sorted = [...fallback].sort((leftToken, rightToken) => compareRowsByDocumentOrder(leftToken, rightToken, fallback));
+        orderedRowTokensCache[section] = sorted;
+        return sorted;
+    }
+    function getOrderedSelectableRowIds() {
+        const rowIds = [];
+        for (const token of getOrderedRowTokens('body')) {
+            const row = rows.get(token);
+            if (!row?.id)
+                continue;
+            if (disabledKeys.has(row.id) || row.disabled)
+                continue;
+            rowIds.push(row.id);
+        }
+        return rowIds;
+    }
+    function isRowDisabled(id, localDisabled = false) {
+        if (localDisabled)
+            return true;
+        if (id === undefined)
+            return false;
+        return disabledKeys.has(id);
+    }
+    function isRowSelected(id) {
+        if (id === undefined)
+            return false;
+        return selectedKeys.has(id);
+    }
+    function getSelectionCheckboxState() {
+        const orderedIds = getOrderedSelectableRowIds();
+        if (orderedIds.length === 0) {
+            return selectedKeys.size > 0 ? 'some' : 'none';
+        }
+        if (selectedKeys.size === 0) {
+            return 'none';
+        }
+        let selectedCount = 0;
+        for (const id of orderedIds) {
+            if (selectedKeys.has(id)) {
+                selectedCount += 1;
+            }
+        }
+        if (selectedCount === 0)
+            return 'none';
+        if (selectedCount === orderedIds.length)
+            return 'all';
+        return 'some';
+    }
+    function hasSelectableRows() {
+        return getOrderedSelectableRowIds().length > 0 || selectedKeys.size > 0;
+    }
+    function isRowFocused(token) {
+        if (focusedRowTarget?.rowToken === token)
+            return true;
+        if (!focusedCellKey)
+            return false;
+        return cells.get(focusedCellKey)?.rowToken === token;
+    }
+    function isRowFocusTarget(token) {
+        return focusedRowTarget?.rowToken === token;
+    }
+    function getRowFocusEdge(token) {
+        return focusedRowTarget?.rowToken === token ? focusedRowTarget.edge : null;
+    }
+    function registerCell(cell) {
+        const existing = cells.get(cell.key);
+        const alreadyOrdered = cellOrder.includes(cell.key);
+        if (existing && sameCellRegistration(existing, cell) && alreadyOrdered)
+            return;
+        cells.set(cell.key, cell);
+        if (!alreadyOrdered) {
+            cellOrder.push(cell.key);
+        }
+        notifyLayout();
+    }
+    function unregisterCell(key) {
+        cells.delete(key);
+        const index = cellOrder.indexOf(key);
+        if (index >= 0) {
+            cellOrder.splice(index, 1);
+        }
+        if (focusedCellKey === key) {
+            focusedCellKey = null;
+            notifyFocus();
+        }
+        notifyLayout();
+    }
+    function isCellFocused(key) {
+        return focusedCellKey === key;
+    }
+    function getDefaultFocusKey() {
+        for (const rowToken of getOrderedRowTokens('header')) {
+            const headerCells = Array.from(cells.values())
+                .filter((cell) => cell.section === 'header' && cell.rowToken === rowToken)
+                .sort((left, right) => getColumnIndex(left) - getColumnIndex(right));
+            const firstHeaderCell = headerCells[0]?.key;
+            if (firstHeaderCell)
+                return firstHeaderCell;
+        }
+        for (const rowToken of getOrderedRowTokens('body')) {
+            const row = rows.get(rowToken);
+            if (isRowDisabled(row?.id, row?.disabled))
+                continue;
+            const bodyCells = Array.from(cells.values())
+                .filter((cell) => cell.section === 'body' && cell.rowToken === rowToken)
+                .sort((left, right) => (left.columnIndex ?? -1) - (right.columnIndex ?? -1));
+            const firstBodyCell = bodyCells[0]?.key;
+            if (firstBodyCell)
+                return firstBodyCell;
+        }
+        return null;
+    }
+    function isCellTabStop(key) {
+        if (focusedCellKey) {
+            return focusedCellKey === key;
+        }
+        if (focusedRowTarget) {
+            return false;
+        }
+        return getDefaultFocusKey() === key;
+    }
+    function isRowTabStop(token) {
+        return focusedRowTarget?.rowToken === token;
+    }
+    function getGlobalRowIndex(rowToken) {
+        const orderedHeaderRows = getOrderedRowTokens('header');
+        const orderedBodyRows = getOrderedRowTokens('body');
+        const headerIndex = orderedHeaderRows.indexOf(rowToken);
+        if (headerIndex >= 0)
+            return headerIndex;
+        const bodyIndex = orderedBodyRows.indexOf(rowToken);
+        if (bodyIndex >= 0)
+            return orderedHeaderRows.length + bodyIndex;
+        return -1;
+    }
+    function getColumnIndex(cell) {
+        if (cell.section === 'header' && cell.columnToken) {
+            return getVisibleColumnIndexByToken(cell.columnToken);
+        }
+        const column = cell.columnIndex !== undefined ? getColumnAt(cell.columnIndex) : undefined;
+        if (!column || isColumnHidden(column.id))
+            return -1;
+        return getVisibleColumnIndexByToken(column.token);
+    }
+    function getCellCoord(cell) {
+        const row = getGlobalRowIndex(cell.rowToken);
+        const col = getColumnIndex(cell);
+        if (row < 0 || col < 0)
+            return null;
+        return { row, col };
+    }
+    function getNavigableCells() {
+        if (navigableCellsCache)
+            return navigableCellsCache;
+        navigableCellsCache = Array.from(cells.values())
+            .map((cell) => ({ cell, coord: getCellCoord(cell) }))
+            .filter((entry) => Boolean(entry.coord &&
+            !isCellColumnHidden(entry.cell) &&
+            entry.cell.element &&
+            (entry.cell.section !== 'body' ||
+                !isRowDisabled(rows.get(entry.cell.rowToken)?.id, rows.get(entry.cell.rowToken)?.disabled))))
+            .sort((left, right) => left.coord.row === right.coord.row
+            ? left.coord.col - right.coord.col
+            : left.coord.row - right.coord.row);
+        return navigableCellsCache;
+    }
+    function getRowsWithCells() {
+        if (rowsWithCellsCache)
+            return rowsWithCellsCache;
+        const rowsByIndex = new Map();
+        for (const { cell, coord } of getNavigableCells()) {
+            const rowCells = rowsByIndex.get(coord.row) ?? [];
+            rowCells.push({ col: coord.col, key: cell.key, element: cell.element });
+            rowsByIndex.set(coord.row, rowCells);
+        }
+        for (const rowCells of rowsByIndex.values()) {
+            rowCells.sort((a, b) => a.col - b.col);
+        }
+        rowsWithCellsCache = rowsByIndex;
+        return rowsWithCellsCache;
+    }
+    function getClosestCellKey(rowIndex, preferredCol) {
+        const rowCells = getRowsWithCells().get(rowIndex);
+        if (!rowCells || rowCells.length === 0)
+            return null;
+        const exact = rowCells.find((rowCell) => rowCell.col === preferredCol);
+        if (exact)
+            return exact.key;
+        const before = [...rowCells].reverse().find((rowCell) => rowCell.col <= preferredCol);
+        if (before)
+            return before.key;
+        return rowCells[0]?.key ?? null;
+    }
+    function focusCellByKey(key) {
+        if (!key)
+            return;
+        const cell = cells.get(key);
+        if (!cell?.element)
+            return;
+        if (cell.section === 'body' &&
+            isRowDisabled(rows.get(cell.rowToken)?.id, rows.get(cell.rowToken)?.disabled)) {
+            return;
+        }
+        focusedRowTarget = null;
+        focusedCellKey = key;
+        notifyFocus();
+        const focusTarget = cell.focusDelegate?.() ?? cell.element;
+        focusTarget.focus();
+        focusTarget.scrollIntoView?.({ block: 'nearest', inline: 'nearest' });
+    }
+    function focusRowByToken(token, edge) {
+        const row = rows.get(token);
+        if (!row?.element || row.section !== 'body')
+            return;
+        if (isRowDisabled(row.id, row.disabled))
+            return;
+        focusedCellKey = null;
+        focusedRowTarget = { rowToken: token, edge };
+        notifyFocus();
+        row.element.focus();
+        row.element.scrollIntoView?.({ block: 'nearest', inline: 'nearest' });
+    }
+    function setFocusedCell(key) {
+        if (focusedCellKey === key && focusedRowTarget === null)
+            return;
+        focusedCellKey = key;
+        focusedRowTarget = null;
+        notifyFocus();
+    }
+    function setFocusedRow(token, edge = 'start') {
+        if (token === null) {
+            if (focusedCellKey === null && focusedRowTarget === null)
+                return;
+            focusedCellKey = null;
+            focusedRowTarget = null;
+            notifyFocus();
+            return;
+        }
+        if (focusedCellKey === null &&
+            focusedRowTarget?.rowToken === token &&
+            focusedRowTarget.edge === edge) {
+            return;
+        }
+        focusedCellKey = null;
+        focusedRowTarget = { rowToken: token, edge };
+        notifyFocus();
+    }
+    function setFocusVisible(visible) {
+        if (focusVisible === visible)
+            return;
+        focusVisible = visible;
+        notifyFocus();
+    }
+    function getFocusedCoord() {
+        if (!focusedCellKey)
+            return null;
+        const cell = cells.get(focusedCellKey);
+        return cell ? getCellCoord(cell) : null;
+    }
+    function getFocusedRowId() {
+        const rowToken = focusedRowTarget?.rowToken ?? cells.get(focusedCellKey ?? '')?.rowToken;
+        if (!rowToken)
+            return null;
+        const row = rows.get(rowToken);
+        return row?.section === 'body' ? (row.id ?? null) : null;
+    }
+    function getRowTokenByGlobalIndex(index) {
+        const headerRows = getOrderedRowTokens('header');
+        if (index < headerRows.length) {
+            return headerRows[index] ?? null;
+        }
+        return getOrderedRowTokens('body')[index - headerRows.length] ?? null;
+    }
+    function getFocusableBodyRowToken(direction) {
+        const orderedBodyTokens = getOrderedRowTokens('body');
+        const tokens = direction === 'start' ? orderedBodyTokens : [...orderedBodyTokens].reverse();
+        for (const token of tokens) {
+            const row = rows.get(token);
+            if (!row || isRowDisabled(row.id, row.disabled))
+                continue;
+            return token;
+        }
+        return null;
+    }
+    function hasSameSelection(left, right) {
+        if (left.size !== right.size)
+            return false;
+        for (const key of left) {
+            if (!right.has(key))
+                return false;
+        }
+        return true;
+    }
+    function setSelectedKeys(next, anchor) {
+        selectedKeys =
+            selectionMode === 'none'
+                ? new Set()
+                : selectionMode === 'single' && next.size > 1
+                    ? new Set([next.values().next().value])
+                    : next;
+        const fallbackAnchor = selectedKeys.values().next().value ?? null;
+        if (anchor === undefined) {
+            selectionAnchorKey = fallbackAnchor;
+            return;
+        }
+        selectionAnchorKey = anchor === null || selectedKeys.has(anchor) ? anchor : fallbackAnchor;
+    }
+    function replaceSelectionWithRow(id) {
+        if (id === undefined || disabledKeys.has(id))
+            return;
+        setSelectedKeys(new Set([id]), id);
+        emitSelectionChange();
+    }
+    function toggleSelectionForRow(id) {
+        if (id === undefined || disabledKeys.has(id))
+            return;
+        if (selectionMode === 'single') {
+            const wasSelected = selectedKeys.has(id);
+            setSelectedKeys(selectionBehavior === 'toggle' && wasSelected ? new Set() : new Set([id]), selectionBehavior === 'toggle' && wasSelected ? null : id);
+            emitSelectionChange();
+            return;
+        }
+        const next = new Set(selectedKeys);
+        if (next.has(id)) {
+            next.delete(id);
+        }
+        else {
+            next.add(id);
+        }
+        setSelectedKeys(next, id);
+        emitSelectionChange();
+    }
+    function extendSelectionToRow(id, anchorOverride) {
+        if (id === undefined || disabledKeys.has(id))
+            return;
+        if (selectionMode !== 'multiple') {
+            replaceSelectionWithRow(id);
+            return;
+        }
+        const orderedIds = getOrderedSelectableRowIds();
+        const targetIndex = orderedIds.indexOf(id);
+        if (targetIndex < 0)
+            return;
+        const anchor = anchorOverride ??
+            (selectionAnchorKey && orderedIds.includes(selectionAnchorKey) ? selectionAnchorKey : null) ??
+            getFocusedRowId() ??
+            id;
+        const anchorIndex = orderedIds.indexOf(anchor);
+        if (anchorIndex < 0) {
+            replaceSelectionWithRow(id);
+            return;
+        }
+        const start = Math.min(anchorIndex, targetIndex);
+        const end = Math.max(anchorIndex, targetIndex);
+        setSelectedKeys(new Set(orderedIds.slice(start, end + 1)), anchor);
+        emitSelectionChange();
+    }
+    function pressRow(id, interaction = {}) {
+        if (selectionMode === 'none' || id === undefined || disabledKeys.has(id))
+            return;
+        if (selectionBehavior === 'replace' && selectionMode === 'multiple') {
+            if (interaction.shiftKey) {
+                extendSelectionToRow(id);
+                return;
+            }
+            if (interaction.ctrlKey || interaction.metaKey) {
+                toggleSelectionForRow(id);
+                return;
+            }
+            replaceSelectionWithRow(id);
+            return;
+        }
+        toggleSelectionForRow(id);
+    }
+    function moveFocus(direction, interaction = {}) {
+        const rowMap = getRowsWithCells();
+        const currentCoord = getFocusedCoord();
+        const rowIndexes = Array.from(rowMap.keys()).sort((a, b) => a - b);
+        if (rowIndexes.length === 0)
+            return;
+        const previousFocusedRowId = getFocusedRowId();
+        function maybeSyncSelectionAfterFocus() {
+            if (direction !== 'up' && direction !== 'down')
+                return;
+            if (selectionMode === 'none')
+                return;
+            if (interaction.ctrlKey || interaction.metaKey || interaction.altKey)
+                return;
+            const targetRowId = getFocusedRowId();
+            if (targetRowId === null)
+                return;
+            if (interaction.shiftKey) {
+                extendSelectionToRow(targetRowId, selectionAnchorKey ?? previousFocusedRowId);
+                return;
+            }
+            if (selectionBehavior !== 'replace')
+                return;
+            replaceSelectionWithRow(targetRowId);
+        }
+        if (!currentCoord) {
+            if (focusedRowTarget) {
+                const currentRowIndex = getGlobalRowIndex(focusedRowTarget.rowToken);
+                if (currentRowIndex < 0)
+                    return;
+                if (direction === 'left' || direction === 'right') {
+                    const rowCells = rowMap.get(currentRowIndex) ?? [];
+                    if (focusedRowTarget.edge === 'start') {
+                        if (direction === 'right') {
+                            focusCellByKey(getClosestCellKey(currentRowIndex, -1));
+                            return;
+                        }
+                        focusCellByKey(rowCells[rowCells.length - 1]?.key ?? null);
+                        return;
+                    }
+                    if (direction === 'left') {
+                        focusCellByKey(rowCells[rowCells.length - 1]?.key ?? null);
+                        return;
+                    }
+                    focusCellByKey(getClosestCellKey(currentRowIndex, -1));
+                    return;
+                }
+                const rowPosition = rowIndexes.indexOf(currentRowIndex);
+                const targetRowIndex = direction === 'up' ? rowIndexes[rowPosition - 1] : rowIndexes[rowPosition + 1];
+                if (targetRowIndex === undefined)
+                    return;
+                const targetRowToken = getRowTokenByGlobalIndex(targetRowIndex);
+                const targetRow = targetRowToken ? rows.get(targetRowToken) : null;
+                if (targetRow?.section === 'body' && !isRowDisabled(targetRow.id, targetRow.disabled)) {
+                    focusRowByToken(targetRowToken, focusedRowTarget.edge);
+                }
+                else if (focusedRowTarget.edge === 'start') {
+                    focusCellByKey(getClosestCellKey(targetRowIndex, -1));
+                }
+                else {
+                    const targetRowCells = rowMap.get(targetRowIndex) ?? [];
+                    focusCellByKey(targetRowCells[targetRowCells.length - 1]?.key ?? null);
+                }
+                maybeSyncSelectionAfterFocus();
+                return;
+            }
+            const firstKey = getClosestCellKey(rowIndexes[0], 0);
+            focusCellByKey(firstKey);
+            maybeSyncSelectionAfterFocus();
+            return;
+        }
+        if (direction === 'left' || direction === 'right') {
+            const rowCells = rowMap.get(currentCoord.row) ?? [];
+            const currentIndex = rowCells.findIndex((rowCell) => rowCell.key === focusedCellKey);
+            if (currentIndex < 0)
+                return;
+            const nextIndex = direction === 'left' ? currentIndex - 1 : currentIndex + 1;
+            const nextKey = rowCells[nextIndex]?.key;
+            if (nextKey) {
+                focusCellByKey(nextKey);
+                return;
+            }
+            const currentCell = cells.get(focusedCellKey ?? '');
+            if (currentCell?.section === 'body') {
+                focusRowByToken(currentCell.rowToken, direction === 'left' ? 'start' : 'end');
+            }
+            return;
+        }
+        const rowPosition = rowIndexes.indexOf(currentCoord.row);
+        const targetRowIndex = direction === 'up' ? rowIndexes[rowPosition - 1] : rowIndexes[rowPosition + 1];
+        if (targetRowIndex === undefined)
+            return;
+        const targetKey = getClosestCellKey(targetRowIndex, currentCoord.col);
+        focusCellByKey(targetKey);
+        maybeSyncSelectionAfterFocus();
+    }
+    function moveToRowStart() {
+        if (focusedRowTarget) {
+            const rowIndex = getGlobalRowIndex(focusedRowTarget.rowToken);
+            if (rowIndex < 0)
+                return;
+            focusCellByKey(getClosestCellKey(rowIndex, -1));
+            return;
+        }
+        const currentCoord = getFocusedCoord();
+        if (!currentCoord) {
+            moveToGridStart();
+            return;
+        }
+        focusCellByKey(getClosestCellKey(currentCoord.row, -1));
+    }
+    function moveToRowEnd() {
+        const rowMap = getRowsWithCells();
+        if (focusedRowTarget) {
+            const rowIndex = getGlobalRowIndex(focusedRowTarget.rowToken);
+            if (rowIndex < 0)
+                return;
+            const rowCells = rowMap.get(rowIndex) ?? [];
+            focusCellByKey(rowCells[rowCells.length - 1]?.key ?? null);
+            return;
+        }
+        const currentCoord = getFocusedCoord();
+        if (!currentCoord) {
+            moveToGridEnd();
+            return;
+        }
+        const rowCells = rowMap.get(currentCoord.row) ?? [];
+        focusCellByKey(rowCells[rowCells.length - 1]?.key ?? null);
+    }
+    function moveToGridStart() {
+        const rowIndexes = Array.from(getRowsWithCells().keys()).sort((a, b) => a - b);
+        if (rowIndexes.length === 0)
+            return;
+        focusCellByKey(getClosestCellKey(rowIndexes[0], -1));
+    }
+    function moveToBodyRowStart() {
+        const targetToken = getFocusableBodyRowToken('start');
+        if (!targetToken)
+            return;
+        focusRowByToken(targetToken, focusedRowTarget?.edge ?? 'start');
+    }
+    function moveToBodyRowEnd() {
+        const targetToken = getFocusableBodyRowToken('end');
+        if (!targetToken)
+            return;
+        focusRowByToken(targetToken, focusedRowTarget?.edge ?? 'end');
+    }
+    function moveToGridEnd() {
+        const rowMap = getRowsWithCells();
+        const bodyGlobalRows = getOrderedRowTokens('body')
+            .map((token) => getGlobalRowIndex(token))
+            .filter((index) => index >= 0)
+            .sort((a, b) => a - b);
+        const targetRow = bodyGlobalRows.at(-1) ??
+            Array.from(rowMap.keys())
+                .sort((a, b) => a - b)
+                .at(-1);
+        if (targetRow === undefined)
+            return;
+        const rowCells = rowMap.get(targetRow) ?? [];
+        focusCellByKey(rowCells[rowCells.length - 1]?.key ?? null);
+    }
+    function emitSelectionChange() {
+        options.onSelectionChange?.(new Set(selectedKeys));
+        notifySelection();
+    }
+    function toggleRowSelection(id) {
+        if (selectionMode === 'none' || id === undefined || disabledKeys.has(id))
+            return;
+        if (selectionMode === 'single') {
+            const wasSelected = selectedKeys.has(id);
+            setSelectedKeys(wasSelected ? new Set() : new Set([id]), wasSelected ? null : id);
+            emitSelectionChange();
+            return;
+        }
+        const next = new Set(selectedKeys);
+        if (next.has(id)) {
+            next.delete(id);
+        }
+        else {
+            next.add(id);
+        }
+        setSelectedKeys(next, id);
+        emitSelectionChange();
+    }
+    function selectAllRows() {
+        if (selectionMode !== 'multiple')
+            return;
+        const next = new Set();
+        for (const token of getOrderedRowTokens('body')) {
+            const row = rows.get(token);
+            if (!row?.id || disabledKeys.has(row.id) || row.disabled)
+                continue;
+            next.add(row.id);
+        }
+        setSelectedKeys(next, next.values().next().value ?? null);
+        emitSelectionChange();
+    }
+    function deselectAllRows() {
+        if (selectedKeys.size === 0)
+            return;
+        setSelectedKeys(new Set(), null);
+        emitSelectionChange();
+    }
+    function setSelection(keys) {
+        const next = new Set(keys);
+        const preservedAnchor = selectionAnchorKey !== null && next.has(selectionAnchorKey) ? selectionAnchorKey : undefined;
+        setSelectedKeys(next, preservedAnchor);
+        notifySelection();
+    }
+    function setSelectionMode(mode) {
+        const previousSelectedKeys = new Set(selectedKeys);
+        const previousAnchor = selectionAnchorKey;
+        selectionMode = mode;
+        setSelectedKeys(new Set(selectedKeys), selectionAnchorKey);
+        if (!hasSameSelection(previousSelectedKeys, selectedKeys) ||
+            previousAnchor !== selectionAnchorKey) {
+            emitSelectionChange();
+            return;
+        }
+        notifySelection();
+    }
+    function setSelectionBehavior(behavior) {
+        selectionBehavior = behavior;
+        notifySelection();
+    }
+    function setDisabledKeys(keys) {
+        disabledKeys.clear();
+        if (keys) {
+            for (const key of keys) {
+                disabledKeys.add(key);
+            }
+        }
+        notifySelection();
+    }
+    function setSortDescriptor(descriptor) {
+        sortDescriptor = descriptor;
+        options.onSortChange?.(descriptor);
+        notifySort();
+    }
+    function isColumnSortable(columnId) {
+        return Array.from(columns.values()).some((column) => column.id === columnId && column.allowsSorting);
+    }
+    function toggleSort(columnId) {
+        if (!isColumnSortable(columnId))
+            return;
+        if (!sortDescriptor || sortDescriptor.column !== columnId) {
+            setSortDescriptor({ column: columnId, direction: 'ascending' });
+            return;
+        }
+        setSortDescriptor({
+            column: columnId,
+            direction: sortDescriptor.direction === 'ascending' ? 'descending' : 'ascending'
+        });
+    }
+    function getSortDirection(columnId) {
+        if (sortDescriptor?.column !== columnId)
+            return undefined;
+        return sortDescriptor.direction;
+    }
+    return {
+        layoutVersion,
+        selectionVersion,
+        focusVersion,
+        sortVersion,
+        widthVersion,
+        resizeVersion,
+        createInstanceToken,
+        get selectionMode() {
+            return selectionMode;
+        },
+        get selectionBehavior() {
+            return selectionBehavior;
+        },
+        disabledKeys,
+        get focusedCellKey() {
+            return focusedCellKey;
+        },
+        get focusVisible() {
+            return focusVisible;
+        },
+        get sortDescriptor() {
+            return sortDescriptor;
+        },
+        get resizingColumnId() {
+            return resizingColumnId;
+        },
+        registerColumn,
+        unregisterColumn,
+        registerColumnResizer,
+        unregisterColumnResizer,
+        getColumnCount,
+        getVisibleColumnCount,
+        getColumnAt,
+        getColumnIndexByToken,
+        getVisibleColumnIndexByToken,
+        getColumnTextValue,
+        getColumnWidth,
+        getColumnMinWidth,
+        getColumnMaxWidth,
+        isColumnHidden,
+        isColumnResizable,
+        getColumnWidths,
+        getVisibleColumnWidths,
+        setColumnWidths,
+        setColumnWidth,
+        setHiddenColumns,
+        measureColumnContentWidth,
+        startColumnResize,
+        endColumnResize,
+        suppressHeaderClickOnce,
+        consumeHeaderClickSuppression,
+        hasResizableColumns,
+        registerRow,
+        unregisterRow,
+        getHeaderRowCount,
+        getBodyRowCount,
+        isRowSelected,
+        isRowFocused,
+        isRowFocusTarget,
+        getRowFocusEdge,
+        isRowDisabled,
+        hasSelectableRows,
+        getSelectionCheckboxState,
+        registerCell,
+        unregisterCell,
+        isCellFocused,
+        isCellTabStop,
+        isRowTabStop,
+        focusCellByKey,
+        focusRowByToken,
+        pressRow,
+        setFocusedCell,
+        setFocusedRow,
+        setFocusVisible,
+        moveFocus,
+        moveToRowStart,
+        moveToRowEnd,
+        moveToBodyRowStart,
+        moveToBodyRowEnd,
+        moveToGridStart,
+        moveToGridEnd,
+        toggleRowSelection,
+        selectAllRows,
+        deselectAllRows,
+        setSelection,
+        setSelectionMode,
+        setSelectionBehavior,
+        setDisabledKeys,
+        setSortDescriptor,
+        toggleSort,
+        isColumnSortable,
+        getSortDirection
+    };
+}
+export function setTableContext(context) {
+    setContext(TABLE_KEY, context);
+    return context;
+}
+export function getTableContext() {
+    return getContext(TABLE_KEY);
+}
+export function useTableContext() {
+    const context = getTableContext();
+    if (!context) {
+        throw new Error('Table parts must be used inside `Table.Root`.');
+    }
+    return context;
+}
+export function setTableSectionContext(context) {
+    setContext(TABLE_SECTION_KEY, context);
+    return context;
+}
+export function getTableSectionContext() {
+    return getContext(TABLE_SECTION_KEY);
+}
+export function useTableSectionContext() {
+    const context = getTableSectionContext();
+    if (!context) {
+        throw new Error('Table section parts must be used inside `Table.Root`.');
+    }
+    return context;
+}
+export function setTableRowContext(context) {
+    setContext(TABLE_ROW_KEY, context);
+    return context;
+}
+export function getTableRowContext() {
+    return getContext(TABLE_ROW_KEY);
+}
+export function useTableRowContext() {
+    const context = getTableRowContext();
+    if (!context) {
+        throw new Error('Table cells must be used inside `Table.Row`.');
+    }
+    return context;
+}
+export function setTableCellContext(context) {
+    setContext(TABLE_CELL_KEY, context);
+    return context;
+}
+export function getTableCellContext() {
+    return getContext(TABLE_CELL_KEY);
+}
+export function useTableCellContext() {
+    const context = getTableCellContext();
+    if (!context) {
+        throw new Error('Table interactive cell parts must be used inside `Table.Cell` or `Table.ColumnHeaderCell`.');
+    }
+    return context;
+}
+export function setTableColumnContext(context) {
+    setContext(TABLE_COLUMN_KEY, context);
+    return context;
+}
+export function getTableColumnContext() {
+    return getContext(TABLE_COLUMN_KEY);
+}
+export function useTableColumnContext() {
+    const context = getTableColumnContext();
+    if (!context) {
+        throw new Error('`Table.ColumnHeaderCell` must be used inside `Table.Column`.');
+    }
+    return context;
+}