@mezzanine-ui/react 1.0.0-alpha.0 → 1.0.0-beta.0

package/Table/hooks/useTableFixedOffsets.js

@@ -0,0 +1,241 @@
+'use client';
+import { useState, useEffect, useCallback, useMemo } from 'react';
+import { DRAG_HANDLE_KEY, DRAG_HANDLE_COLUMN_WIDTH, EXPANSION_KEY, EXPANSION_COLUMN_WIDTH, SELECTION_KEY, SELECTION_COLUMN_WIDTH } from '@mezzanine-ui/core/table';
+import { useTableSuperContext } from '../TableContext.js';
+
+const parseFixed = (fixed) => {
+    if (fixed === true || fixed === 'start')
+        return 'start';
+    if (fixed === 'end')
+        return 'end';
+    return null;
+};
+function useTableFixedOffsets(options) {
+    const { expansionLeftPadding = 0 } = useTableSuperContext();
+    const { actionConfig, columns, getResizedColumnWidth } = options;
+    // Store measured widths
+    const [measuredWidths, setMeasuredWidths] = useState(new Map());
+    const { hasDragHandle, hasExpansion, hasSelection } = actionConfig;
+    useEffect(() => {
+        const innerMap = new Map();
+        if (hasDragHandle) {
+            innerMap.set(DRAG_HANDLE_KEY, DRAG_HANDLE_COLUMN_WIDTH);
+        }
+        if (hasExpansion) {
+            innerMap.set(EXPANSION_KEY, EXPANSION_COLUMN_WIDTH);
+        }
+        if (hasSelection) {
+            innerMap.set(SELECTION_KEY, SELECTION_COLUMN_WIDTH);
+        }
+        setMeasuredWidths(innerMap);
+    }, [hasDragHandle, hasExpansion, hasSelection]);
+    // Get width for a column (prioritize measured, then computed, then defined, then fallback)
+    const getWidth = useCallback((key, fallback = 0) => {
+        // Get static widths first
+        const measured = measuredWidths.get(key);
+        if (measured !== undefined && measured > 0) {
+            return measured;
+        }
+        // get resized column width
+        const computed = getResizedColumnWidth === null || getResizedColumnWidth === void 0 ? void 0 : getResizedColumnWidth(key);
+        if (computed !== undefined) {
+            return computed;
+        }
+        // Then try to find column definition width
+        const column = columns.find((col) => col.key === key);
+        if ((column === null || column === void 0 ? void 0 : column.width) !== undefined) {
+            return column.width;
+        }
+        return fallback;
+    }, [columns, getResizedColumnWidth, measuredWidths]);
+    // Build ordered list of all fixed columns
+    const { fixedEndKeys, fixedStartKeys } = useMemo(() => {
+        const startKeys = [];
+        const endKeys = [];
+        // Action columns first (in order: drag handle, expansion, selection)
+        if (actionConfig.hasDragHandle && actionConfig.dragHandleFixed) {
+            startKeys.push(DRAG_HANDLE_KEY);
+        }
+        if (actionConfig.hasExpansion && actionConfig.expansionFixed) {
+            startKeys.push(EXPANSION_KEY);
+        }
+        if (actionConfig.hasSelection && actionConfig.selectionFixed) {
+            startKeys.push(SELECTION_KEY);
+        }
+        // Then data columns
+        columns.forEach((column) => {
+            const side = parseFixed(column.fixed);
+            if (side === 'start') {
+                startKeys.push(column.key);
+            }
+            else if (side === 'end') {
+                endKeys.push(column.key);
+            }
+        });
+        return { fixedEndKeys: endKeys, fixedStartKeys: startKeys };
+    }, [actionConfig, columns]);
+    // Calculate all fixed offsets
+    const fixedOffsets = useMemo(() => {
+        const startOffsets = new Map();
+        const endOffsets = new Map();
+        // Calculate start offsets
+        let currentStartOffset = 0;
+        fixedStartKeys.forEach((key) => {
+            startOffsets.set(key, {
+                offset: currentStartOffset,
+                side: 'start',
+            });
+            currentStartOffset += getWidth(key);
+        });
+        // Calculate end offsets (from right to left)
+        let currentEndOffset = 0;
+        for (let i = fixedEndKeys.length - 1; i >= 0; i--) {
+            const key = fixedEndKeys[i];
+            endOffsets.set(key, {
+                offset: currentEndOffset,
+                side: 'end',
+            });
+            currentEndOffset += getWidth(key);
+        }
+        return { endOffsets, startOffsets };
+    }, [fixedEndKeys, fixedStartKeys, getWidth]);
+    // Build ordered list of all columns (for position calculation)
+    const allColumnKeys = useMemo(() => {
+        const keys = [];
+        // Action columns first
+        if (hasDragHandle) {
+            keys.push(DRAG_HANDLE_KEY);
+        }
+        if (hasExpansion) {
+            keys.push(EXPANSION_KEY);
+        }
+        if (hasSelection) {
+            keys.push(SELECTION_KEY);
+        }
+        // Then data columns
+        columns.forEach((column) => {
+            keys.push(column.key);
+        });
+        return keys;
+    }, [hasDragHandle, hasSelection, hasExpansion, columns]);
+    // Calculate original positions (left edge) for all columns
+    const originalPositions = useMemo(() => {
+        const positions = new Map();
+        let currentPosition = 0;
+        allColumnKeys.forEach((key) => {
+            positions.set(key, currentPosition);
+            currentPosition += getWidth(key);
+        });
+        return positions;
+    }, [allColumnKeys, getWidth]);
+    /**
+     * Determine if a column should show shadow.
+     */
+    const shouldShowShadow = useCallback((key, scrollLeft, containerWidth) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const offsetInfo = (_a = fixedOffsets.startOffsets.get(key)) !== null && _a !== void 0 ? _a : fixedOffsets.endOffsets.get(key);
+        if (!offsetInfo)
+            return false;
+        if (offsetInfo.side === 'start') {
+            // For start-fixed columns
+            const keyIndex = fixedStartKeys.indexOf(key);
+            if (keyIndex === -1)
+                return false;
+            const originalPos = (_b = originalPositions.get(key)) !== null && _b !== void 0 ? _b : 0;
+            const isSticky = scrollLeft - expansionLeftPadding > originalPos - offsetInfo.offset;
+            if (!isSticky)
+                return false;
+            // Now check if there's a gap to the right (shadow should show)
+            // Find the next fixed-start column
+            const nextIndex = keyIndex + 1;
+            if (nextIndex < fixedStartKeys.length) {
+                const nextKey = fixedStartKeys[nextIndex];
+                const nextOriginalPos = (_c = originalPositions.get(nextKey)) !== null && _c !== void 0 ? _c : 0;
+                const nextOffset = (_e = (_d = fixedOffsets.startOffsets.get(nextKey)) === null || _d === void 0 ? void 0 : _d.offset) !== null && _e !== void 0 ? _e : 0;
+                // Gap closes when scroll reaches the point where next column becomes sticky
+                const isNextSticky = scrollLeft - expansionLeftPadding >= nextOriginalPos - nextOffset;
+                return !isNextSticky;
+            }
+            return true;
+        }
+        else {
+            // For end-fixed columns
+            const keyIndex = fixedEndKeys.indexOf(key);
+            if (keyIndex === -1)
+                return false;
+            // Get this column's original position from left
+            const originalPos = (_f = originalPositions.get(key)) !== null && _f !== void 0 ? _f : 0;
+            const columnWidth = getWidth(key);
+            const isSticky = scrollLeft + containerWidth <
+                originalPos + columnWidth + offsetInfo.offset + expansionLeftPadding;
+            if (!isSticky)
+                return false;
+            // Check if there's a gap to the left (shadow should show)
+            const prevIndex = keyIndex - 1;
+            if (~prevIndex) {
+                const prevKey = fixedEndKeys[prevIndex];
+                const prevOriginalPos = (_g = originalPositions.get(prevKey)) !== null && _g !== void 0 ? _g : 0;
+                const prevOffset = (_j = (_h = fixedOffsets.endOffsets.get(prevKey)) === null || _h === void 0 ? void 0 : _h.offset) !== null && _j !== void 0 ? _j : 0;
+                const prevColumnWidth = getWidth(prevKey);
+                const isPrevSticky = scrollLeft + containerWidth <
+                    prevOriginalPos +
+                        prevColumnWidth +
+                        prevOffset +
+                        expansionLeftPadding;
+                // If both are sticky, the gap is closed if this column's
+                // left visual edge touches the prev column's right visual edge
+                return !isPrevSticky;
+            }
+            // This is the leftmost fixed-end column
+            return true;
+        }
+    }, [
+        fixedEndKeys,
+        fixedOffsets,
+        fixedStartKeys,
+        getWidth,
+        originalPositions,
+        expansionLeftPadding,
+    ]);
+    const getColumnOffset = useCallback((key) => {
+        var _a, _b;
+        return ((_b = (_a = fixedOffsets.startOffsets.get(key)) !== null && _a !== void 0 ? _a : fixedOffsets.endOffsets.get(key)) !== null && _b !== void 0 ? _b : null);
+    }, [fixedOffsets]);
+    const getDragHandleOffset = useCallback(() => {
+        var _a;
+        if (!actionConfig.hasDragHandle || !actionConfig.dragHandleFixed) {
+            return null;
+        }
+        return (_a = fixedOffsets.startOffsets.get(DRAG_HANDLE_KEY)) !== null && _a !== void 0 ? _a : null;
+    }, [actionConfig, fixedOffsets]);
+    const getSelectionOffset = useCallback(() => {
+        var _a;
+        if (!actionConfig.hasSelection || !actionConfig.selectionFixed) {
+            return null;
+        }
+        return (_a = fixedOffsets.startOffsets.get(SELECTION_KEY)) !== null && _a !== void 0 ? _a : null;
+    }, [actionConfig, fixedOffsets]);
+    const getExpansionOffset = useCallback(() => {
+        var _a;
+        if (!actionConfig.hasExpansion || !actionConfig.expansionFixed) {
+            return null;
+        }
+        return (_a = fixedOffsets.startOffsets.get(EXPANSION_KEY)) !== null && _a !== void 0 ? _a : null;
+    }, [actionConfig, fixedOffsets]);
+    // Memoize return object to prevent unnecessary re-renders
+    return useMemo(() => ({
+        getColumnOffset,
+        getDragHandleOffset,
+        getExpansionOffset,
+        getSelectionOffset,
+        shouldShowShadow,
+    }), [
+        getColumnOffset,
+        getDragHandleOffset,
+        getExpansionOffset,
+        getSelectionOffset,
+        shouldShowShadow,
+    ]);
+}
+
+export { useTableFixedOffsets };

package/Table/hooks/useTableScroll.d.ts

@@ -0,0 +1,12 @@
+export interface UseTableScrollReturn {
+    /** Container width (viewport width) */
+    containerWidth: number;
+    handleScroll: (event: React.UIEvent<HTMLDivElement>) => void;
+    isScrollingHorizontally: boolean;
+    scrollLeft: number;
+    /** Set refs for measuring container width */
+    setContainerRef: (element: HTMLDivElement | null) => void;
+}
+export declare function useTableScroll({ enabled, }: {
+    enabled: boolean;
+}): UseTableScrollReturn;

package/Table/hooks/useTableScroll.js

@@ -0,0 +1,58 @@
+'use client';
+import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
+
+function useTableScroll({ enabled, }) {
+    const [isScrollingHorizontally, setIsScrollingHorizontally] = useState(false);
+    const [scrollLeft, setScrollLeft] = useState(0);
+    const [containerWidth, setContainerWidth] = useState(0);
+    const containerRef = useRef(null);
+    const setContainerRef = useCallback((element) => {
+        containerRef.current = element;
+    }, []);
+    const measureDimensions = useCallback(() => {
+        if (containerRef.current) {
+            const newContainerWidth = containerRef.current.clientWidth;
+            setContainerWidth((prev) => prev !== newContainerWidth ? newContainerWidth : prev);
+        }
+    }, []);
+    const handleScroll = useCallback((event) => {
+        const target = event.currentTarget;
+        const newScrollLeft = target.scrollLeft;
+        setScrollLeft(newScrollLeft);
+        setIsScrollingHorizontally(newScrollLeft > 0);
+    }, []);
+    // Set up ResizeObserver to track dimension changes
+    useEffect(() => {
+        const { current: container } = containerRef;
+        if (!container || !enabled)
+            return;
+        const resizeObserver = new ResizeObserver(() => {
+            measureDimensions();
+        });
+        resizeObserver.observe(container);
+        return () => {
+            resizeObserver.disconnect();
+        };
+    }, [measureDimensions, enabled]);
+    // Initial measurement after mount
+    useEffect(() => {
+        if (enabled) {
+            measureDimensions();
+        }
+    }, [measureDimensions, enabled]);
+    return useMemo(() => ({
+        containerWidth,
+        handleScroll,
+        isScrollingHorizontally,
+        scrollLeft,
+        setContainerRef,
+    }), [
+        containerWidth,
+        handleScroll,
+        isScrollingHorizontally,
+        scrollLeft,
+        setContainerRef,
+    ]);
+}
+
+export { useTableScroll };

package/Table/hooks/useTableSelection.d.ts

@@ -0,0 +1,7 @@
+import { type TableDataSource, type TableRowSelection } from '@mezzanine-ui/core/table';
+import type { TableSelectionState } from '../TableContext';
+export interface UseTableSelectionOptions<T extends TableDataSource> {
+    dataSource: T[];
+    rowSelection?: TableRowSelection<T>;
+}
+export declare function useTableSelection<T extends TableDataSource>({ dataSource, rowSelection, }: UseTableSelectionOptions<T>): TableSelectionState<T> | undefined;

package/Table/hooks/useTableSelection.js

@@ -0,0 +1,94 @@
+'use client';
+import { useMemo, useCallback } from 'react';
+import { getRowKey } from '@mezzanine-ui/core/table';
+
+function useTableSelection({ dataSource, rowSelection, }) {
+    const { selectedRowKeys = [], isCheckboxDisabled, onChange, onSelectAll, preserveSelectedRowKeys = false, } = rowSelection || {};
+    const selectableKeys = useMemo(() => {
+        if (!rowSelection)
+            return [];
+        return dataSource
+            .filter((record) => {
+            if (!isCheckboxDisabled)
+                return true;
+            const disabled = isCheckboxDisabled(record);
+            return !disabled;
+        })
+            .map((record) => getRowKey(record));
+    }, [dataSource, isCheckboxDisabled, rowSelection]);
+    const isRowSelected = useCallback((key) => {
+        return selectedRowKeys.includes(key);
+    }, [selectedRowKeys]);
+    const isRowDisabled = useCallback((record) => {
+        if (!isCheckboxDisabled)
+            return false;
+        const disabled = isCheckboxDisabled(record);
+        return disabled;
+    }, [isCheckboxDisabled]);
+    const isAllSelected = useMemo(() => {
+        if (!selectableKeys.length)
+            return false;
+        return selectableKeys.every((key) => selectedRowKeys.includes(key));
+    }, [selectableKeys, selectedRowKeys]);
+    const isIndeterminate = useMemo(() => {
+        if (!selectableKeys.length)
+            return false;
+        const selectedCount = selectableKeys.filter((key) => selectedRowKeys.includes(key)).length;
+        return selectedCount > 0 && selectedCount < selectableKeys.length;
+    }, [selectableKeys, selectedRowKeys]);
+    const toggleRow = useCallback((key) => {
+        const newKeys = selectedRowKeys.includes(key)
+            ? selectedRowKeys.filter((k) => k !== key)
+            : [...selectedRowKeys, key];
+        const selectedRow = dataSource.find((r) => getRowKey(r) === key) || null;
+        const selectedRows = dataSource.filter((r) => newKeys.includes(getRowKey(r)));
+        onChange === null || onChange === void 0 ? void 0 : onChange(newKeys, selectedRow, selectedRows);
+    }, [selectedRowKeys, dataSource, onChange]);
+    const toggleAll = useCallback(() => {
+        let newKeys;
+        let type;
+        if (isAllSelected) {
+            if (preserveSelectedRowKeys) {
+                const currentDataKeys = dataSource.map(getRowKey);
+                newKeys = selectedRowKeys.filter((key) => !currentDataKeys.includes(String(key)));
+            }
+            else {
+                newKeys = selectedRowKeys.filter((key) => !selectableKeys.includes(String(key)));
+            }
+            type = 'none';
+        }
+        else {
+            const existingNonDataKeys = preserveSelectedRowKeys
+                ? selectedRowKeys.filter((key) => !dataSource.some((r) => getRowKey(r) === String(key)))
+                : [];
+            newKeys = [...existingNonDataKeys, ...selectableKeys];
+            type = 'all';
+        }
+        const selectedRows = dataSource.filter((r) => newKeys.includes(getRowKey(r)));
+        onChange === null || onChange === void 0 ? void 0 : onChange(newKeys, null, selectedRows);
+        onSelectAll === null || onSelectAll === void 0 ? void 0 : onSelectAll(type);
+    }, [
+        dataSource,
+        isAllSelected,
+        onSelectAll,
+        onChange,
+        preserveSelectedRowKeys,
+        selectableKeys,
+        selectedRowKeys,
+    ]);
+    if (!rowSelection) {
+        return undefined;
+    }
+    return {
+        config: rowSelection,
+        isAllSelected,
+        isIndeterminate,
+        isRowDisabled,
+        isRowSelected,
+        selectedRowKeys,
+        toggleAll,
+        toggleRow,
+    };
+}
+
+export { useTableSelection };

package/Table/hooks/useTableSorting.d.ts

@@ -0,0 +1,6 @@
+import type { TableColumn, TableDataSource } from '@mezzanine-ui/core/table';
+import type { TableSortingState } from '../TableContext';
+export interface UseTableSortingOptions<T extends TableDataSource> {
+    columns: TableColumn<T>[];
+}
+export declare function useTableSorting<T extends TableDataSource>({ columns, }: UseTableSortingOptions<T>): TableSortingState;

package/Table/hooks/useTableSorting.js

@@ -0,0 +1,32 @@
+'use client';
+import { useCallback } from 'react';
+
+function useTableSorting({ columns, }) {
+    const onSort = useCallback((key) => {
+        var _a;
+        const column = columns.find((col) => col.key === key);
+        if (!column || !column.onSort)
+            return;
+        const sortedKey = column.key;
+        const sortedDirection = column.sortOrder;
+        let nextDirection;
+        if (sortedKey !== key) {
+            nextDirection = 'ascend';
+        }
+        else if (!sortedDirection) {
+            nextDirection = 'ascend';
+        }
+        else if (sortedDirection === 'ascend') {
+            nextDirection = 'descend';
+        }
+        else {
+            nextDirection = null;
+        }
+        (_a = column.onSort) === null || _a === void 0 ? void 0 : _a.call(column, key, nextDirection);
+    }, [columns]);
+    return {
+        onSort,
+    };
+}
+
+export { useTableSorting };

package/Table/hooks/useTableVirtualization.d.ts

@@ -0,0 +1,22 @@
+import { VirtualItem } from '@tanstack/react-virtual';
+import { type TableDataSource } from '@mezzanine-ui/core/table';
+export interface UseTableVirtualizationOptions<T extends TableDataSource> {
+    dataSource: T[];
+    enabled?: boolean;
+    isRowExpanded?: (key: string | number) => boolean;
+    overscan?: number;
+    scrollContainerRef: React.RefObject<HTMLDivElement | null>;
+}
+export interface UseTableVirtualizationReturn {
+    /** Bottom padding for the tbody to maintain scroll height */
+    paddingBottom: number;
+    /** Top padding for the tbody to offset visible rows */
+    paddingTop: number;
+    measureElement: (node: HTMLElement | null) => void;
+    scrollToIndex: (index: number, options?: {
+        align?: 'start' | 'center' | 'end';
+    }) => void;
+    totalSize: number;
+    virtualItems: VirtualItem[];
+}
+export declare function useTableVirtualization<T extends TableDataSource>({ dataSource, enabled, isRowExpanded, overscan, scrollContainerRef, }: UseTableVirtualizationOptions<T>): UseTableVirtualizationReturn | null;

package/Table/hooks/useTableVirtualization.js

@@ -0,0 +1,115 @@
+'use client';
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import { useVirtualizer } from '@tanstack/react-virtual';
+import { getRowKey } from '@mezzanine-ui/core/table';
+import { useTableContext } from '../TableContext.js';
+
+function useTableVirtualization({ dataSource, enabled = true, isRowExpanded, overscan = 5, scrollContainerRef, }) {
+    var _a, _b, _c, _d;
+    const { rowHeight } = useTableContext();
+    const [isContainerReady, setIsContainerReady] = useState(false);
+    const expandedRowHeightsRef = useRef(new Map());
+    useEffect(() => {
+        if (scrollContainerRef.current && enabled) {
+            setIsContainerReady(true);
+        }
+    }, [scrollContainerRef, enabled]);
+    // Estimate size callback that accounts for expanded rows
+    const estimateSize = useCallback((index) => {
+        const record = dataSource[index];
+        const key = getRowKey(record);
+        const measuredHeight = expandedRowHeightsRef.current.get(key);
+        if (measuredHeight !== undefined) {
+            return measuredHeight;
+        }
+        return rowHeight;
+    }, [dataSource, rowHeight]);
+    const getItemKey = useCallback((index) => {
+        const record = dataSource[index];
+        return getRowKey(record);
+    }, [dataSource]);
+    /* eslint-disable-next-line react-hooks/incompatible-library */
+    const virtualizer = useVirtualizer({
+        count: enabled && isContainerReady ? dataSource.length : 0,
+        enabled: enabled && isContainerReady,
+        estimateSize,
+        getItemKey,
+        getScrollElement: () => scrollContainerRef.current,
+        overscan,
+    });
+    // Force re-measure when container becomes ready
+    useEffect(() => {
+        if (isContainerReady && enabled) {
+            virtualizer.measure();
+        }
+    }, [isContainerReady, enabled, virtualizer]);
+    const virtualItems = virtualizer.getVirtualItems();
+    const totalSize = virtualizer.getTotalSize();
+    // Custom measure function that measures both the main row and its expanded row
+    const measureElement = useCallback((node) => {
+        var _a;
+        if (!node)
+            return;
+        const index = node.dataset.index;
+        if (index === undefined)
+            return;
+        const rowIndex = parseInt(index, 10);
+        const record = dataSource[rowIndex];
+        if (!record)
+            return;
+        const key = getRowKey(record);
+        const expanded = (_a = isRowExpanded === null || isRowExpanded === void 0 ? void 0 : isRowExpanded(key)) !== null && _a !== void 0 ? _a : false;
+        // Get the main row height
+        let totalHeight = node.getBoundingClientRect().height;
+        // If expanded, find and measure the expanded row (next sibling)
+        if (expanded && node.nextElementSibling) {
+            const expandedRow = node.nextElementSibling;
+            const expandedRowKey = expandedRow.dataset.rowKey;
+            if (expandedRowKey === `${key}-expanded`) {
+                totalHeight += expandedRow.getBoundingClientRect().height;
+            }
+        }
+        // Store the combined height
+        expandedRowHeightsRef.current.set(key, totalHeight);
+        // Use the virtualizer's measure with the combined height
+        virtualizer.measureElement(node);
+    }, [dataSource, isRowExpanded, virtualizer]);
+    const scrollToIndex = useCallback((index, options) => {
+        virtualizer.scrollToIndex(index, options);
+    }, [virtualizer]);
+    // Re-measure when expansion state changes
+    useEffect(() => {
+        if (!enabled || !isContainerReady)
+            return;
+        expandedRowHeightsRef.current.clear();
+        virtualizer.measure();
+    }, [isRowExpanded, enabled, isContainerReady, virtualizer]);
+    const paddingTop = virtualItems.length > 0 ? ((_b = (_a = virtualItems[0]) === null || _a === void 0 ? void 0 : _a.start) !== null && _b !== void 0 ? _b : 0) : 0;
+    const paddingBottom = virtualItems.length > 0
+        ? totalSize - ((_d = (_c = virtualItems[virtualItems.length - 1]) === null || _c === void 0 ? void 0 : _c.end) !== null && _d !== void 0 ? _d : totalSize)
+        : 0;
+    const result = useMemo(() => {
+        if (!enabled) {
+            return null;
+        }
+        return {
+            measureElement,
+            paddingBottom,
+            paddingTop,
+            scrollToIndex,
+            totalSize,
+            virtualItems,
+        };
+    }, [
+        enabled,
+        measureElement,
+        paddingBottom,
+        paddingTop,
+        scrollToIndex,
+        totalSize,
+        virtualItems,
+    ]);
+    return result;
+}
+
+export { useTableVirtualization };

package/Table/index.d.ts

@@ -1,10 +1,7 @@
-export type { TableProps } from './Table';
-export { default } from './Table';
-export { default as TableRefresh } from './refresh/TableRefresh';
-export type { TableRefreshProps } from './refresh/TableRefresh';
-export type { TableCellProps } from './TableCell';
-export { default as TableCell } from './TableCell';
-export type { EditableBodyCellProps } from './editable/TableEditRenderWrapper';
-export { useTableDraggable } from './draggable/useTableDraggable';
-export { useTableRowSelection, SELECTED_ALL_KEY, } from './rowSelection/useTableRowSelection';
-export { default as useTableScroll } from './useTableScroll';
+export { tableClasses as classes, getCellAlignClass, getColumnStyle, getRowKey, type FixedType, type SortOrder, type TableColumn, type TableDataSource, type TableDraggable, type TableExpandable, type TableRowSelection, type TableScroll, type TableSize, } from '@mezzanine-ui/core/table';
+export { default, type TableBaseProps, type TableNonVirtualizedProps, type TableProps, type TableVirtualizedProps, } from './Table';
+export { TableContext, TableDataContext, useTableContext, useTableDataContext, type TableColumnState, type TableContextValue, type TableDataContextValue, type TableDraggableState, type TableExpansionState, type TableSelectionState, type TableSortingState, type TableTransitionState, } from './TableContext';
+export { type UpdateDataSourceOptions } from './hooks';
+export * from './hooks';
+export * from './components';
+export * from './utils';

package/Table/index.js

@@ -1,6 +1,22 @@
-export { default } from './Table.js';
-export { default as TableRefresh } from './refresh/TableRefresh.js';
-export { default as TableCell } from './TableCell.js';
-export { useTableDraggable } from './draggable/useTableDraggable.js';
-export { SELECTED_ALL_KEY, useTableRowSelection } from './rowSelection/useTableRowSelection.js';
-export { default as useTableScroll } from './useTableScroll.js';
+export { tableClasses as classes, getCellAlignClass, getColumnStyle, getRowKey } from '@mezzanine-ui/core/table';
+export { Table as default } from './Table.js';
+export { TableContext, TableDataContext, useTableContext, useTableDataContext } from './TableContext.js';
+export { useTableSorting } from './hooks/useTableSorting.js';
+export { useTableSelection } from './hooks/useTableSelection.js';
+export { useTableColumns } from './hooks/useTableColumns.js';
+export { useTableExpansion } from './hooks/useTableExpansion.js';
+export { useTableFixedOffsets } from './hooks/useTableFixedOffsets.js';
+export { useTableScroll } from './hooks/useTableScroll.js';
+export { useTableVirtualization } from './hooks/useTableVirtualization.js';
+export { useTableDataSource } from './hooks/useTableDataSource.js';
+export { TableBody } from './components/TableBody.js';
+export { TableCell } from './components/TableCell.js';
+export { TableColGroup } from './components/TableColGroup.js';
+export { TableExpandCell } from './components/TableExpandCell.js';
+export { TableExpandedRow } from './components/TableExpandedRow.js';
+export { TableHeader } from './components/TableHeader.js';
+export { TablePagination } from './components/TablePagination.js';
+export { TableResizeHandle } from './components/TableResizeHandle.js';
+export { TableRow } from './components/TableRow.js';
+export { TableSelectionCell } from './components/TableSelectionCell.js';
+export { useTableRowSelection } from './utils/useTableRowSelection.js';

package/Table/utils/index.d.ts

@@ -0,0 +1,2 @@
+export type { UseTableRowSelectionProps } from './useTableRowSelection';
+export { useTableRowSelection } from './useTableRowSelection';

package/Table/utils/index.js

@@ -0,0 +1 @@
+export { useTableRowSelection } from './useTableRowSelection.js';

package/Table/utils/useTableRowSelection.d.ts

@@ -0,0 +1,18 @@
+import { TableDataSource, TableRowSelection } from '@mezzanine-ui/core/table';
+export interface UseTableRowSelectionProps<T extends TableDataSource> {
+    getSubData: (record: T) => T[] | undefined;
+}
+/**
+ * Custom hook for users to manage row selection state in a table with expandable rows.
+ */
+export declare function useTableRowSelection<T extends TableDataSource = TableDataSource>(props: UseTableRowSelectionProps<T>): {
+    parentSelectedKeys: (string | number)[];
+    parentOnChange: (selectedRowKeys: (string | number)[], selectedRow: T | null, selectedRows: T[]) => void;
+    parentGetCheckboxProps: (record: T) => {
+        indeterminate?: boolean;
+        selected?: boolean;
+    };
+    getChildOnChange: (record: T) => TableRowSelection<T>["onChange"];
+    getChildSelectedRowKeys: (record: T) => (string | number)[];
+    totalSelectionCount: number;
+};