@itwin/itwinui-react 3.12.2 → 3.13.0

package/DEV-cjs/core/Table/filters/customFilterFunctions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "customFilterFunctions", {
+    enumerable: true,
+    get: function() {
+        return customFilterFunctions;
+    }
+});
+const isValidDate = (date)=>!!date && !isNaN(date.valueOf());
+const betweenDate = (rows, ids, filterValue)=>{
+    let [min, max] = filterValue || [];
+    let MAX_DATE_VALUE = 8640000000000000;
+    let minValue = isValidDate(min) ? min : new Date(-MAX_DATE_VALUE);
+    let maxValue = isValidDate(max) ? max : new Date(MAX_DATE_VALUE);
+    return rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return rowValue.valueOf() >= minValue.valueOf() && rowValue.valueOf() <= maxValue.valueOf();
+        }));
+};
+betweenDate.autoRemove = (val)=>!val || !isValidDate(val[0]) && !isValidDate(val[1]);
+const customFilterFunctions = {
+    betweenDate
+};

package/DEV-cjs/core/Table/filters/defaultFilterFunctions.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "defaultFilterFunctions", {
+    enumerable: true,
+    get: function() {
+        return defaultFilterFunctions;
+    }
+});
+const text = (rows, ids, filterValue)=>{
+    rows = rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return String(rowValue).toLowerCase().includes(String(filterValue).toLowerCase());
+        }));
+    return rows;
+};
+text.autoRemove = (val)=>!val;
+const exactText = (rows, ids, filterValue)=>rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return void 0 === rowValue || String(rowValue).toLowerCase() === String(filterValue).toLowerCase();
+        }));
+exactText.autoRemove = (val)=>!val;
+const exactTextCase = (rows, ids, filterValue)=>rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return void 0 === rowValue || String(rowValue) === String(filterValue);
+        }));
+exactTextCase.autoRemove = (val)=>!val;
+const includes = (rows, ids, filterValue)=>rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return rowValue.includes(filterValue);
+        }));
+includes.autoRemove = (val)=>!val || !val.length;
+const includesAll = (rows, ids, filterValue)=>rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return rowValue && rowValue.length && filterValue.every((val)=>rowValue.includes(val));
+        }));
+includesAll.autoRemove = (val)=>!val || !val.length;
+const includesSome = (rows, ids, filterValue)=>rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return rowValue && rowValue.length && filterValue.some((val)=>rowValue.includes(val));
+        }));
+includesSome.autoRemove = (val)=>!val || !val.length;
+const includesValue = (rows, ids, filterValue)=>rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return filterValue.includes(rowValue);
+        }));
+includesValue.autoRemove = (val)=>!val || !val.length;
+const exact = (rows, ids, filterValue)=>rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return rowValue === filterValue;
+        }));
+exact.autoRemove = (val)=>void 0 === val;
+const equals = (rows, ids, filterValue)=>rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return rowValue == filterValue;
+        }));
+equals.autoRemove = (val)=>null == val;
+const between = (rows, ids, filterValue)=>{
+    let [min, max] = filterValue || [];
+    min = 'number' == typeof min ? min : -1 / 0;
+    max = 'number' == typeof max ? max : 1 / 0;
+    if (min > max) {
+        let temp = min;
+        min = max;
+        max = temp;
+    }
+    return rows.filter((row)=>ids.some((id)=>{
+            let rowValue = row.values[id];
+            return rowValue >= min && rowValue <= max;
+        }));
+};
+between.autoRemove = (val)=>!val || 'number' != typeof val[0] && 'number' != typeof val[1];
+const defaultFilterFunctions = {
+    text,
+    exactText,
+    exactTextCase,
+    includes,
+    includesAll,
+    includesSome,
+    includesValue,
+    between
+};

package/DEV-cjs/core/Table/filters/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    BaseFilter: function() {
+        return _BaseFilter.BaseFilter;
+    },
+    FilterButtonBar: function() {
+        return _FilterButtonBar.FilterButtonBar;
+    },
+    FilterToggle: function() {
+        return _FilterToggle.FilterToggle;
+    },
+    tableFilters: function() {
+        return _tableFilters.tableFilters;
+    }
+});
+const _BaseFilter = require("./BaseFilter.js");
+const _tableFilters = require("./tableFilters.js");
+const _FilterButtonBar = require("./FilterButtonBar.js");
+const _FilterToggle = require("./FilterToggle.js");

package/DEV-cjs/core/Table/filters/tableFilters.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "tableFilters", {
+    enumerable: true,
+    get: function() {
+        return tableFilters;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = _interop_require_wildcard._(require("react"));
+const _DateRangeFilter = require("./DateRangeFilter/DateRangeFilter.js");
+const _NumberRangeFilter = require("./NumberRangeFilter/NumberRangeFilter.js");
+const _TextFilter = require("./TextFilter/TextFilter.js");
+const tableFilters = {
+    TextFilter: (translatedLabels)=>(props)=>_react.createElement(_TextFilter.TextFilter, {
+                ...props,
+                translatedLabels: translatedLabels
+            }),
+    DateRangeFilter: (options)=>(props)=>_react.createElement(_DateRangeFilter.DateRangeFilter, {
+                ...props,
+                ...options
+            }),
+    NumberRangeFilter: (translatedLabels)=>(props)=>_react.createElement(_NumberRangeFilter.NumberRangeFilter, {
+                ...props,
+                translatedLabels: translatedLabels
+            })
+};

package/DEV-cjs/core/Table/filters/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/DEV-cjs/core/Table/hooks/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useColumnDragAndDrop: function() {
+        return _useColumnDragAndDrop.useColumnDragAndDrop;
+    },
+    useExpanderCell: function() {
+        return _useExpanderCell.useExpanderCell;
+    },
+    useResizeColumns: function() {
+        return _useResizeColumns.useResizeColumns;
+    },
+    useScrollToRow: function() {
+        return _useScrollToRow.useScrollToRow;
+    },
+    useSelectionCell: function() {
+        return _useSelectionCell.useSelectionCell;
+    },
+    useStickyColumns: function() {
+        return _useStickyColumns.useStickyColumns;
+    },
+    useSubRowFiltering: function() {
+        return _useSubRowFiltering.useSubRowFiltering;
+    },
+    useSubRowSelection: function() {
+        return _useSubRowSelection.useSubRowSelection;
+    }
+});
+const _useExpanderCell = require("./useExpanderCell.js");
+const _useSelectionCell = require("./useSelectionCell.js");
+const _useSubRowFiltering = require("./useSubRowFiltering.js");
+const _useSubRowSelection = require("./useSubRowSelection.js");
+const _useResizeColumns = require("./useResizeColumns.js");
+const _useColumnDragAndDrop = require("./useColumnDragAndDrop.js");
+const _useScrollToRow = require("./useScrollToRow.js");
+const _useStickyColumns = require("./useStickyColumns.js");

package/DEV-cjs/core/Table/hooks/useColumnDragAndDrop.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useColumnDragAndDrop", {
+    enumerable: true,
+    get: function() {
+        return useColumnDragAndDrop;
+    }
+});
+const _reacttable = require("react-table");
+const _styles = require("../../../styles.js");
+const REORDER_ACTIONS = {
+    columnDragStart: 'columnDragStart',
+    columnDragEnd: 'columnDragEnd'
+};
+const useColumnDragAndDrop = (isEnabled)=>(hooks)=>{
+        hooks.getDragAndDropProps = [
+            defaultGetDragAndDropProps(isEnabled)
+        ];
+        hooks.stateReducers.push(reducer);
+        hooks.useInstance.push(useInstance);
+    };
+const defaultGetDragAndDropProps = (isEnabled)=>(props, { instance, header })=>{
+        if (!isEnabled || header.disableReordering) return props;
+        let onDragStart = ()=>{
+            instance.dispatch({
+                type: REORDER_ACTIONS.columnDragStart,
+                columnIndex: instance.flatHeaders.indexOf(header)
+            });
+        };
+        let setOnDragColumnStyle = (event, position)=>{
+            let columnElement = event.currentTarget;
+            columnElement.classList.remove(_styles.styles['iui-table-reorder-column-right']);
+            columnElement.classList.remove(_styles.styles['iui-table-reorder-column-left']);
+            if ('left' === position) columnElement.classList.add(_styles.styles['iui-table-reorder-column-left']);
+            else if ('right' === position) columnElement.classList.add(_styles.styles['iui-table-reorder-column-right']);
+        };
+        let reorderColumns = (tableColumns, srcIndex, dstIndex)=>{
+            let newTableColumns = [
+                ...tableColumns
+            ];
+            let [removed] = newTableColumns.splice(srcIndex, 1);
+            newTableColumns.splice(dstIndex, 0, removed);
+            return newTableColumns;
+        };
+        let onDragOver = (event)=>{
+            event.preventDefault();
+            let headerIndex = instance.flatHeaders.indexOf(header);
+            if (instance.state.columnReorderStartIndex !== headerIndex) setOnDragColumnStyle(event, instance.state.columnReorderStartIndex > headerIndex ? 'left' : 'right');
+        };
+        let onDragLeave = (event)=>{
+            setOnDragColumnStyle(event);
+        };
+        let onDrop = (event)=>{
+            event.preventDefault();
+            setOnDragColumnStyle(event);
+            let columnIds = instance.allColumns.map((x)=>x.id);
+            let srcIndex = instance.state.columnReorderStartIndex;
+            let dstIndex = columnIds.findIndex((x)=>x === header.id);
+            if (srcIndex === dstIndex || -1 === srcIndex || -1 === dstIndex) return;
+            instance.setColumnOrder(reorderColumns(columnIds, srcIndex, dstIndex));
+            instance.dispatch({
+                type: REORDER_ACTIONS.columnDragEnd,
+                columnIndex: -1
+            });
+        };
+        return [
+            props,
+            {
+                draggable: true,
+                onDragStart,
+                onDragOver,
+                onDragLeave,
+                onDrop
+            }
+        ];
+    };
+const reducer = (newState, action)=>{
+    switch(action.type){
+        case _reacttable.actions.init:
+            return {
+                ...newState,
+                columnReorderStartIndex: -1
+            };
+        case REORDER_ACTIONS.columnDragStart:
+            return {
+                ...newState,
+                columnReorderStartIndex: action.columnIndex
+            };
+        case REORDER_ACTIONS.columnDragEnd:
+            return {
+                ...newState,
+                columnReorderStartIndex: -1
+            };
+        default:
+            return newState;
+    }
+};
+const useInstance = (instance)=>{
+    let { flatHeaders, getHooks } = instance;
+    let getInstance = (0, _reacttable.useGetLatest)(instance);
+    flatHeaders.forEach((header)=>{
+        header.getDragAndDropProps = (0, _reacttable.makePropGetter)(getHooks().getDragAndDropProps, {
+            instance: getInstance(),
+            header
+        });
+    });
+};

package/DEV-cjs/core/Table/hooks/useExpanderCell.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useExpanderCell", {
+    enumerable: true,
+    get: function() {
+        return useExpanderCell;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = _interop_require_wildcard._(require("react"));
+const _index = require("../columns/index.js");
+const useExpanderCell = (subComponent, expanderCell, isRowDisabled)=>(hooks)=>{
+        if (!subComponent) return;
+        hooks.allColumns.push((columns)=>{
+            let hasExpanderColumn = columns.find((c)=>c.id === _index.EXPANDER_CELL_ID);
+            if (hasExpanderColumn) return columns;
+            let expanderColumn = (0, _index.ExpanderColumn)({
+                subComponent,
+                isDisabled: isRowDisabled
+            });
+            return [
+                {
+                    ...expanderColumn,
+                    Cell: expanderCell ? (cellProps)=>_react.createElement(_react.Fragment, null, expanderCell(cellProps)) : expanderColumn.Cell
+                },
+                ...columns
+            ];
+        });
+    };

package/DEV-cjs/core/Table/hooks/useResizeColumns.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useResizeColumns", {
+    enumerable: true,
+    get: function() {
+        return useResizeColumns;
+    }
+});
+const _reacttable = require("react-table");
+const useResizeColumns = (ownerDocument)=>(hooks)=>{
+        hooks.getResizerProps = [
+            defaultGetResizerProps(ownerDocument)
+        ];
+        hooks.stateReducers.push(reducer);
+        hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions);
+    };
+const isTouchEvent = (event)=>'touchstart' === event.type;
+const defaultGetResizerProps = (ownerDocument)=>(props, { instance, header, nextHeader })=>{
+        let { dispatch } = instance;
+        let onResizeStart = (e, header)=>{
+            if (isTouchEvent(e) && e.touches && e.touches.length > 1) return;
+            let headerIdWidths = getLeafHeaders(header).map((d)=>[
+                    d.id,
+                    getHeaderWidth(d)
+                ]);
+            let nextHeaderIdWidths = nextHeader ? getLeafHeaders(nextHeader).map((d)=>[
+                    d.id,
+                    getHeaderWidth(d)
+                ]) : [];
+            let clientX = isTouchEvent(e) ? Math.round(e.touches[0].clientX) : e.clientX;
+            let dispatchMove = (clientXPos)=>dispatch({
+                    type: _reacttable.actions.columnResizing,
+                    clientX: clientXPos
+                });
+            let dispatchEnd = ()=>dispatch({
+                    type: _reacttable.actions.columnDoneResizing
+                });
+            let handlersAndEvents = {
+                mouse: {
+                    moveEvent: 'mousemove',
+                    moveHandler: (e)=>dispatchMove(e.clientX),
+                    upEvent: 'mouseup',
+                    upHandler: ()=>{
+                        ownerDocument.current?.removeEventListener('mousemove', handlersAndEvents.mouse.moveHandler);
+                        ownerDocument.current?.removeEventListener('mouseup', handlersAndEvents.mouse.upHandler);
+                        ownerDocument.current?.removeEventListener('mouseleave', handlersAndEvents.mouse.upHandler);
+                        dispatchEnd();
+                    }
+                },
+                touch: {
+                    moveEvent: 'touchmove',
+                    moveHandler: (e)=>{
+                        if (e.cancelable) {
+                            e.preventDefault();
+                            e.stopPropagation();
+                        }
+                        dispatchMove(e.touches[0].clientX);
+                    },
+                    upEvent: 'touchend',
+                    upHandler: ()=>{
+                        ownerDocument.current?.removeEventListener(handlersAndEvents.touch.moveEvent, handlersAndEvents.touch.moveHandler);
+                        ownerDocument.current?.removeEventListener(handlersAndEvents.touch.upEvent, handlersAndEvents.touch.moveHandler);
+                        dispatchEnd();
+                    }
+                }
+            };
+            let events = isTouchEvent(e) ? handlersAndEvents.touch : handlersAndEvents.mouse;
+            let passiveIfSupported = !!passiveEventSupported() && {
+                passive: false
+            };
+            ownerDocument.current?.addEventListener(events.moveEvent, events.moveHandler, passiveIfSupported);
+            ownerDocument.current?.addEventListener(events.upEvent, events.upHandler, passiveIfSupported);
+            if (!isTouchEvent(e)) ownerDocument.current?.addEventListener('mouseleave', handlersAndEvents.mouse.upHandler, passiveIfSupported);
+            dispatch({
+                type: _reacttable.actions.columnStartResizing,
+                columnId: header.id,
+                columnWidth: getHeaderWidth(header),
+                nextColumnWidth: getHeaderWidth(nextHeader),
+                headerIdWidths,
+                nextHeaderIdWidths,
+                clientX
+            });
+        };
+        return [
+            props,
+            {
+                onClick: (e)=>{
+                    e.stopPropagation();
+                },
+                onMouseDown: (e)=>{
+                    e.persist();
+                    e.preventDefault();
+                    e.stopPropagation();
+                    onResizeStart(e, header);
+                },
+                onTouchStart: (e)=>{
+                    e.persist();
+                    e.preventDefault();
+                    onResizeStart(e, header);
+                },
+                style: {
+                    cursor: 'col-resize'
+                },
+                draggable: false,
+                role: 'separator'
+            }
+        ];
+    };
+useResizeColumns.pluginName = 'useResizeColumns';
+const reducer = (newState, action, previousState, instance)=>{
+    if (action.type === _reacttable.actions.init) return {
+        ...newState,
+        columnResizing: {
+            columnWidths: {}
+        }
+    };
+    if (action.type === _reacttable.actions.resetResize) return {
+        ...newState,
+        columnResizing: {
+            columnWidths: {}
+        }
+    };
+    if (action.type === _reacttable.actions.columnStartResizing) {
+        let { clientX, columnId, columnWidth, nextColumnWidth, headerIdWidths, nextHeaderIdWidths } = action;
+        return {
+            ...newState,
+            columnResizing: {
+                ...newState.columnResizing,
+                startX: clientX,
+                columnWidth,
+                nextColumnWidth,
+                headerIdWidths,
+                nextHeaderIdWidths,
+                isResizingColumn: columnId
+            }
+        };
+    }
+    if (action.type === _reacttable.actions.columnResizing) {
+        let { clientX } = action;
+        let { startX = 0, columnWidth = 1, nextColumnWidth = 1, headerIdWidths = [], nextHeaderIdWidths = [] } = newState.columnResizing;
+        if (!instance) return newState;
+        let deltaX = clientX - startX;
+        let newColumnWidths = getColumnWidths(headerIdWidths, deltaX / columnWidth);
+        let isTableWidthDecreasing = calculateTableWidth(newColumnWidths, instance.flatHeaders) < instance.tableWidth;
+        let newNextColumnWidths = instance?.columnResizeMode === 'fit' || instance?.columnResizeMode === 'expand' && isTableWidthDecreasing ? getColumnWidths(nextHeaderIdWidths, -deltaX / nextColumnWidth) : {};
+        if (!isNewColumnWidthsValid(newColumnWidths, instance.flatHeaders) || !isNewColumnWidthsValid(newNextColumnWidths, instance.flatHeaders) || !isNewTableWidthValid({
+            ...newColumnWidths,
+            ...newNextColumnWidths
+        }, instance)) return newState;
+        instance?.flatHeaders.forEach((h)=>{
+            if (!h.width) h.width = h.resizeWidth;
+        });
+        return {
+            ...newState,
+            columnResizing: {
+                ...newState.columnResizing,
+                columnWidths: {
+                    ...newState.columnResizing.columnWidths,
+                    ...newColumnWidths,
+                    ...newNextColumnWidths
+                }
+            }
+        };
+    }
+    if (action.type === _reacttable.actions.columnDoneResizing) return {
+        ...newState,
+        columnResizing: {
+            ...newState.columnResizing,
+            startX: void 0,
+            isResizingColumn: void 0
+        }
+    };
+    return newState;
+};
+const getColumnWidths = (headerIdWidths, deltaPercentage)=>{
+    let columnWidths = {};
+    headerIdWidths.forEach(([headerId, headerWidth])=>{
+        columnWidths[headerId] = Math.max(headerWidth + headerWidth * deltaPercentage, 0);
+    });
+    return columnWidths;
+};
+const isNewColumnWidthsValid = (columnWidths, headers)=>{
+    if (Object.values(columnWidths).some((width)=>width <= 1)) return false;
+    for (let [headerId, width] of Object.entries(columnWidths)){
+        let header = headers?.find((h)=>h.id === headerId);
+        if (!header) continue;
+        let minWidth = header.minWidth || 0;
+        let maxWidth = header.maxWidth || 1 / 0;
+        if (width < minWidth || width > maxWidth) return false;
+    }
+    return true;
+};
+const isNewTableWidthValid = (columnWidths, instance)=>{
+    if ('fit' === instance.columnResizeMode) return true;
+    let newTableWidth = 0;
+    for (let header of instance.flatHeaders)newTableWidth += columnWidths[header.id] ? columnWidths[header.id] : getHeaderWidth(header);
+    if (Math.round(newTableWidth) < instance.tableWidth) return false;
+    return true;
+};
+const useInstanceBeforeDimensions = (instance)=>{
+    let { flatHeaders, getHooks, state: { columnResizing }, columnResizeMode } = instance;
+    let getInstance = (0, _reacttable.useGetLatest)(instance);
+    flatHeaders.forEach((header, index)=>{
+        let resizeWidth = columnResizing.columnWidths[header.id];
+        header.width = resizeWidth || header.width || header.originalWidth;
+        header.isResizing = columnResizing.isResizingColumn === header.id;
+        let headerToResize = header.disableResizing && 'fit' === columnResizeMode ? getPreviousResizableHeader(header, instance) : header;
+        let nextResizableHeader = 'expand' === columnResizeMode && index === flatHeaders.length - 1 ? getPreviousResizableHeader(header, instance) : getNextResizableHeader(header, instance);
+        header.canResize = null == header.disableResizing || !header.disableResizing;
+        if ('fit' === columnResizeMode) header.isResizerVisible = header.canResize && !!nextResizableHeader || headerToResize && !!instance.flatHeaders[index + 1]?.canResize;
+        else header.isResizerVisible = header.canResize && !!headerToResize;
+        header.getResizerProps = (0, _reacttable.makePropGetter)(getHooks().getResizerProps, {
+            instance: getInstance(),
+            header: headerToResize,
+            nextHeader: nextResizableHeader
+        });
+    });
+};
+const getPreviousResizableHeader = (headerColumn, instance)=>{
+    let headersList = (headerColumn.parent?.columns || instance.flatHeaders).filter(({ isVisible })=>isVisible);
+    let headerIndex = headersList.findIndex((h)=>h.id === headerColumn.id);
+    return [
+        ...headersList
+    ].slice(0, headerIndex).reverse().find((h)=>!h.disableResizing);
+};
+const getNextResizableHeader = (headerColumn, instance)=>{
+    let headersList = (headerColumn.parent?.columns || instance.flatHeaders).filter(({ isVisible })=>isVisible);
+    let headerIndex = headersList.findIndex((h)=>h.id === headerColumn.id);
+    return [
+        ...headersList
+    ].slice(headerIndex + 1).find((h)=>!h.disableResizing);
+};
+function getLeafHeaders(header) {
+    let leafHeaders = [];
+    let recurseHeader = (header)=>{
+        if (header.columns && header.columns.length) header.columns.map(recurseHeader);
+        leafHeaders.push(header);
+    };
+    recurseHeader(header);
+    return leafHeaders;
+}
+const getHeaderWidth = (header)=>{
+    if (!header) return 0;
+    return 'string' == typeof header.width && Number.isNaN(Number(header.width)) ? Number(header.resizeWidth || 0) : Number(header.width || header.resizeWidth || 0);
+};
+const calculateTableWidth = (columnWidths, headers)=>{
+    let newTableWidth = 0;
+    for (let header of headers)newTableWidth += columnWidths[header.id] ? columnWidths[header.id] : getHeaderWidth(header);
+    return newTableWidth;
+};
+let passiveSupported = null;
+const passiveEventSupported = ()=>{
+    if (null != passiveSupported) return passiveSupported;
+    try {
+        let options = {
+            once: true,
+            get passive () {
+                passiveSupported = true;
+                return false;
+            }
+        };
+        window.addEventListener('test', ()=>{}, options);
+    } catch  {
+        passiveSupported = false;
+    }
+    return passiveSupported;
+};

package/DEV-cjs/core/Table/hooks/useScrollToRow.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useScrollToRow", {
+    enumerable: true,
+    get: function() {
+        return useScrollToRow;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = _interop_require_wildcard._(require("react"));
+function useScrollToRow({ data, enableVirtualization, page, paginatorRenderer, scrollToRow }) {
+    let rowRefs = _react.useRef({});
+    let pageRef = _react.useRef(page);
+    pageRef.current = page;
+    let dataRef = _react.useRef(data);
+    dataRef.current = data;
+    let scrollToIndex = _react.useMemo(()=>{
+        if (!scrollToRow || paginatorRenderer) return;
+        let index = scrollToRow(pageRef.current, dataRef.current);
+        return index < 0 ? void 0 : index;
+    }, [
+        paginatorRenderer,
+        scrollToRow
+    ]);
+    _react.useEffect(()=>{
+        if (enableVirtualization || null == scrollToIndex || scrollToIndex < 0) return;
+        rowRefs.current[pageRef.current[scrollToIndex]?.id]?.scrollIntoView();
+    }, [
+        enableVirtualization,
+        scrollToIndex
+    ]);
+    let tableRowRef = _react.useCallback((row)=>(element)=>{
+            rowRefs.current[row.id] = element;
+        }, []);
+    return {
+        scrollToIndex,
+        tableRowRef
+    };
+}