@itwin/itwinui-react 2.0.0-dev.2 → 2.0.0-dev.4

package/esm/core/Table/hooks/useResizeColumns.js

@@ -1,232 +1,229 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { actions, makePropGetter, useGetLatest, } from 'react-table';
-export var useResizeColumns = function (ownerDocument) {
-    return function (hooks) {
-        hooks.getResizerProps = [defaultGetResizerProps(ownerDocument)];
-        hooks.stateReducers.push(reducer);
-        hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions);
-    };
+export const useResizeColumns = (ownerDocument) => (hooks) => {
+    hooks.getResizerProps = [defaultGetResizerProps(ownerDocument)];
+    hooks.stateReducers.push(reducer);
+    hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions);
 };
-var isTouchEvent = function (event) {
+const isTouchEvent = (event) => {
     return event.type === 'touchstart';
 };
-var defaultGetResizerProps = function (ownerDocument) {
-    return function (props, _a) {
-        var instance = _a.instance, header = _a.header, nextHeader = _a.nextHeader;
-        var dispatch = instance.dispatch;
-        var onResizeStart = function (e, header) {
-            var _a, _b, _c;
-            // lets not respond to multiple touches (e.g. 2 or 3 fingers)
-            if (isTouchEvent(e) && e.touches && e.touches.length > 1) {
-                return;
-            }
-            var headerIdWidths = getLeafHeaders(header).map(function (d) { return [
-                d.id,
-                getHeaderWidth(d),
-            ]; });
-            var nextHeaderIdWidths = nextHeader
-                ? getLeafHeaders(nextHeader).map(function (d) { return [d.id, getHeaderWidth(d)]; })
-                : [];
-            var clientX = isTouchEvent(e)
-                ? Math.round(e.touches[0].clientX)
-                : e.clientX;
-            var dispatchMove = function (clientXPos) {
-                return dispatch({ type: actions.columnResizing, clientX: clientXPos });
-            };
-            var dispatchEnd = function () {
-                return dispatch({
-                    type: actions.columnDoneResizing,
-                });
-            };
-            var handlersAndEvents = {
-                mouse: {
-                    moveEvent: 'mousemove',
-                    moveHandler: function (e) { return dispatchMove(e.clientX); },
-                    upEvent: 'mouseup',
-                    upHandler: function () {
-                        var _a, _b, _c;
-                        (_a = ownerDocument.current) === null || _a === void 0 ? void 0 : _a.removeEventListener('mousemove', handlersAndEvents.mouse.moveHandler);
-                        (_b = ownerDocument.current) === null || _b === void 0 ? void 0 : _b.removeEventListener('mouseup', handlersAndEvents.mouse.upHandler);
-                        (_c = ownerDocument.current) === null || _c === void 0 ? void 0 : _c.removeEventListener('mouseleave', handlersAndEvents.mouse.upHandler);
-                        dispatchEnd();
-                    },
-                },
-                touch: {
-                    moveEvent: 'touchmove',
-                    moveHandler: function (e) {
-                        if (e.cancelable) {
-                            e.preventDefault();
-                            e.stopPropagation();
-                        }
-                        dispatchMove(e.touches[0].clientX);
-                    },
-                    upEvent: 'touchend',
-                    upHandler: function () {
-                        var _a, _b;
-                        (_a = ownerDocument.current) === null || _a === void 0 ? void 0 : _a.removeEventListener(handlersAndEvents.touch.moveEvent, handlersAndEvents.touch.moveHandler);
-                        (_b = ownerDocument.current) === null || _b === void 0 ? void 0 : _b.removeEventListener(handlersAndEvents.touch.upEvent, handlersAndEvents.touch.moveHandler);
-                        dispatchEnd();
-                    },
-                },
-            };
-            var events = isTouchEvent(e)
-                ? handlersAndEvents.touch
-                : handlersAndEvents.mouse;
-            var passiveIfSupported = passiveEventSupported()
-                ? { passive: false }
-                : false;
-            (_a = ownerDocument.current) === null || _a === void 0 ? void 0 : _a.addEventListener(events.moveEvent, events.moveHandler, passiveIfSupported);
-            (_b = ownerDocument.current) === null || _b === void 0 ? void 0 : _b.addEventListener(events.upEvent, events.upHandler, passiveIfSupported);
-            if (!isTouchEvent(e)) {
-                (_c = ownerDocument.current) === null || _c === void 0 ? void 0 : _c.addEventListener('mouseleave', handlersAndEvents.mouse.upHandler, passiveIfSupported);
-            }
-            dispatch({
-                type: actions.columnStartResizing,
-                columnId: header.id,
-                columnWidth: getHeaderWidth(header),
-                nextColumnWidth: getHeaderWidth(nextHeader),
-                headerIdWidths: headerIdWidths,
-                nextHeaderIdWidths: nextHeaderIdWidths,
-                clientX: clientX,
-            });
-        };
-        return [
-            props,
-            {
-                onClick: function (e) {
-                    // Prevents from triggering sort
-                    e.stopPropagation();
-                },
-                onMouseDown: function (e) {
-                    e.persist();
-                    // Prevents from triggering drag'n'drop
-                    e.preventDefault();
-                    // Prevents from triggering sort
-                    e.stopPropagation();
-                    onResizeStart(e, header);
+const defaultGetResizerProps = (ownerDocument) => (props, { instance, header, nextHeader, }) => {
+    const { dispatch } = instance;
+    const onResizeStart = (e, header) => {
+        var _a, _b, _c;
+        // lets not respond to multiple touches (e.g. 2 or 3 fingers)
+        if (isTouchEvent(e) && e.touches && e.touches.length > 1) {
+            return;
+        }
+        const headerIdWidths = getLeafHeaders(header).map((d) => [
+            d.id,
+            getHeaderWidth(d),
+        ]);
+        const nextHeaderIdWidths = nextHeader
+            ? getLeafHeaders(nextHeader).map((d) => [d.id, getHeaderWidth(d)])
+            : [];
+        const clientX = isTouchEvent(e)
+            ? Math.round(e.touches[0].clientX)
+            : e.clientX;
+        const dispatchMove = (clientXPos) => dispatch({ type: actions.columnResizing, clientX: clientXPos });
+        const dispatchEnd = () => dispatch({
+            type: actions.columnDoneResizing,
+        });
+        const handlersAndEvents = {
+            mouse: {
+                moveEvent: 'mousemove',
+                moveHandler: (e) => dispatchMove(e.clientX),
+                upEvent: 'mouseup',
+                upHandler: () => {
+                    var _a, _b, _c;
+                    (_a = ownerDocument.current) === null || _a === void 0 ? void 0 : _a.removeEventListener('mousemove', handlersAndEvents.mouse.moveHandler);
+                    (_b = ownerDocument.current) === null || _b === void 0 ? void 0 : _b.removeEventListener('mouseup', handlersAndEvents.mouse.upHandler);
+                    (_c = ownerDocument.current) === null || _c === void 0 ? void 0 : _c.removeEventListener('mouseleave', handlersAndEvents.mouse.upHandler);
+                    dispatchEnd();
                 },
-                onTouchStart: function (e) {
-                    e.persist();
-                    // Prevents from triggering drag'n'drop
-                    e.preventDefault();
-                    onResizeStart(e, header);
+            },
+            touch: {
+                moveEvent: 'touchmove',
+                moveHandler: (e) => {
+                    if (e.cancelable) {
+                        e.preventDefault();
+                        e.stopPropagation();
+                    }
+                    dispatchMove(e.touches[0].clientX);
                 },
-                style: {
-                    cursor: 'col-resize',
+                upEvent: 'touchend',
+                upHandler: () => {
+                    var _a, _b;
+                    (_a = ownerDocument.current) === null || _a === void 0 ? void 0 : _a.removeEventListener(handlersAndEvents.touch.moveEvent, handlersAndEvents.touch.moveHandler);
+                    (_b = ownerDocument.current) === null || _b === void 0 ? void 0 : _b.removeEventListener(handlersAndEvents.touch.upEvent, handlersAndEvents.touch.moveHandler);
+                    dispatchEnd();
                 },
-                draggable: false,
-                role: 'separator',
             },
-        ];
+        };
+        const events = isTouchEvent(e)
+            ? handlersAndEvents.touch
+            : handlersAndEvents.mouse;
+        const passiveIfSupported = passiveEventSupported()
+            ? { passive: false }
+            : false;
+        (_a = ownerDocument.current) === null || _a === void 0 ? void 0 : _a.addEventListener(events.moveEvent, events.moveHandler, passiveIfSupported);
+        (_b = ownerDocument.current) === null || _b === void 0 ? void 0 : _b.addEventListener(events.upEvent, events.upHandler, passiveIfSupported);
+        if (!isTouchEvent(e)) {
+            (_c = ownerDocument.current) === null || _c === void 0 ? void 0 : _c.addEventListener('mouseleave', handlersAndEvents.mouse.upHandler, passiveIfSupported);
+        }
+        dispatch({
+            type: actions.columnStartResizing,
+            columnId: header.id,
+            columnWidth: getHeaderWidth(header),
+            nextColumnWidth: getHeaderWidth(nextHeader),
+            headerIdWidths,
+            nextHeaderIdWidths,
+            clientX,
+        });
     };
+    return [
+        props,
+        {
+            onClick: (e) => {
+                // Prevents from triggering sort
+                e.stopPropagation();
+            },
+            onMouseDown: (e) => {
+                e.persist();
+                // Prevents from triggering drag'n'drop
+                e.preventDefault();
+                // Prevents from triggering sort
+                e.stopPropagation();
+                onResizeStart(e, header);
+            },
+            onTouchStart: (e) => {
+                e.persist();
+                // Prevents from triggering drag'n'drop
+                e.preventDefault();
+                onResizeStart(e, header);
+            },
+            style: {
+                cursor: 'col-resize',
+            },
+            draggable: false,
+            role: 'separator',
+        },
+    ];
 };
 useResizeColumns.pluginName = 'useResizeColumns';
-var reducer = function (newState, action, previousState, instance) {
+const reducer = (newState, action, previousState, instance) => {
     if (action.type === actions.init) {
-        return __assign(__assign({}, newState), { columnResizing: {
+        return {
+            ...newState,
+            columnResizing: {
                 columnWidths: {},
-            } });
+            },
+        };
     }
     if (action.type === actions.resetResize) {
-        return __assign(__assign({}, newState), { columnResizing: {
+        return {
+            ...newState,
+            columnResizing: {
                 columnWidths: {},
-            } });
+            },
+        };
     }
     if (action.type === actions.columnStartResizing) {
-        var clientX = action.clientX, columnId = action.columnId, columnWidth = action.columnWidth, nextColumnWidth = action.nextColumnWidth, headerIdWidths = action.headerIdWidths, nextHeaderIdWidths = action.nextHeaderIdWidths;
-        return __assign(__assign({}, newState), { columnResizing: __assign(__assign({}, newState.columnResizing), { startX: clientX, columnWidth: columnWidth, nextColumnWidth: nextColumnWidth, headerIdWidths: headerIdWidths, nextHeaderIdWidths: nextHeaderIdWidths, isResizingColumn: columnId }) });
+        const { clientX, columnId, columnWidth, nextColumnWidth, headerIdWidths, nextHeaderIdWidths, } = action;
+        return {
+            ...newState,
+            columnResizing: {
+                ...newState.columnResizing,
+                startX: clientX,
+                columnWidth,
+                nextColumnWidth,
+                headerIdWidths,
+                nextHeaderIdWidths,
+                isResizingColumn: columnId,
+            },
+        };
     }
     if (action.type === actions.columnResizing) {
-        var clientX = action.clientX;
-        var _a = newState.columnResizing, _b = _a.startX, startX = _b === void 0 ? 0 : _b, _c = _a.columnWidth, columnWidth = _c === void 0 ? 1 : _c, _d = _a.nextColumnWidth, nextColumnWidth = _d === void 0 ? 1 : _d, _e = _a.headerIdWidths, headerIdWidths = _e === void 0 ? [] : _e, _f = _a.nextHeaderIdWidths, nextHeaderIdWidths = _f === void 0 ? [] : _f;
+        const { clientX } = action;
+        const { startX = 0, columnWidth = 1, nextColumnWidth = 1, headerIdWidths = [], nextHeaderIdWidths = [], } = newState.columnResizing;
         if (!instance) {
             return newState;
         }
-        var deltaX = clientX - startX;
-        var newColumnWidths = getColumnWidths(headerIdWidths, deltaX / columnWidth);
-        var isTableWidthDecreasing = calculateTableWidth(newColumnWidths, instance.flatHeaders) <
+        const deltaX = clientX - startX;
+        const newColumnWidths = getColumnWidths(headerIdWidths, deltaX / columnWidth);
+        const isTableWidthDecreasing = calculateTableWidth(newColumnWidths, instance.flatHeaders) <
             instance.tableWidth;
-        var newNextColumnWidths = (instance === null || instance === void 0 ? void 0 : instance.columnResizeMode) === 'fit' ||
+        const newNextColumnWidths = (instance === null || instance === void 0 ? void 0 : instance.columnResizeMode) === 'fit' ||
             ((instance === null || instance === void 0 ? void 0 : instance.columnResizeMode) === 'expand' && isTableWidthDecreasing)
             ? getColumnWidths(nextHeaderIdWidths, -deltaX / nextColumnWidth)
             : {};
         if (!isNewColumnWidthsValid(newColumnWidths, instance.flatHeaders) ||
             !isNewColumnWidthsValid(newNextColumnWidths, instance.flatHeaders) ||
-            !isNewTableWidthValid(__assign(__assign({}, newColumnWidths), newNextColumnWidths), instance)) {
+            !isNewTableWidthValid({ ...newColumnWidths, ...newNextColumnWidths }, instance)) {
             return newState;
         }
         // Setting `width` here because it might take several rerenders until actual column width is set.
         // Also setting after the actual resize happened.
-        instance === null || instance === void 0 ? void 0 : instance.flatHeaders.forEach(function (h) {
+        instance === null || instance === void 0 ? void 0 : instance.flatHeaders.forEach((h) => {
             if (!h.width) {
                 h.width = h.resizeWidth;
             }
         });
-        return __assign(__assign({}, newState), { columnResizing: __assign(__assign({}, newState.columnResizing), { columnWidths: __assign(__assign(__assign({}, newState.columnResizing.columnWidths), newColumnWidths), newNextColumnWidths) }) });
+        return {
+            ...newState,
+            columnResizing: {
+                ...newState.columnResizing,
+                columnWidths: {
+                    ...newState.columnResizing.columnWidths,
+                    ...newColumnWidths,
+                    ...newNextColumnWidths,
+                },
+            },
+        };
     }
     if (action.type === actions.columnDoneResizing) {
-        return __assign(__assign({}, newState), { columnResizing: __assign(__assign({}, newState.columnResizing), { startX: undefined, isResizingColumn: undefined }) });
+        return {
+            ...newState,
+            columnResizing: {
+                ...newState.columnResizing,
+                startX: undefined,
+                isResizingColumn: undefined,
+            },
+        };
     }
     return newState;
 };
-var getColumnWidths = function (headerIdWidths, deltaPercentage) {
-    var columnWidths = {};
-    headerIdWidths.forEach(function (_a) {
-        var headerId = _a[0], headerWidth = _a[1];
+const getColumnWidths = (headerIdWidths, deltaPercentage) => {
+    const columnWidths = {};
+    headerIdWidths.forEach(([headerId, headerWidth]) => {
         columnWidths[headerId] = Math.max(headerWidth + headerWidth * deltaPercentage, 0);
     });
     return columnWidths;
 };
-var isNewColumnWidthsValid = function (columnWidths, headers) {
+const isNewColumnWidthsValid = (columnWidths, headers) => {
     // Prevents from going outside the column bounds
-    if (Object.values(columnWidths).some(function (width) { return width <= 1; })) {
+    if (Object.values(columnWidths).some((width) => width <= 1)) {
         return false;
     }
-    var _loop_1 = function (headerId, width) {
-        var header = headers === null || headers === void 0 ? void 0 : headers.find(function (h) { return h.id === headerId; });
+    for (const [headerId, width] of Object.entries(columnWidths)) {
+        const header = headers === null || headers === void 0 ? void 0 : headers.find((h) => h.id === headerId);
         if (!header) {
-            return "continue";
+            continue;
         }
-        var minWidth = header.minWidth || 0;
-        var maxWidth = header.maxWidth || Infinity;
+        const minWidth = header.minWidth || 0;
+        const maxWidth = header.maxWidth || Infinity;
         if (width < minWidth || width > maxWidth) {
-            return { value: false };
+            return false;
         }
-    };
-    for (var _i = 0, _a = Object.entries(columnWidths); _i < _a.length; _i++) {
-        var _b = _a[_i], headerId = _b[0], width = _b[1];
-        var state_1 = _loop_1(headerId, width);
-        if (typeof state_1 === "object")
-            return state_1.value;
     }
     return true;
 };
-var isNewTableWidthValid = function (columnWidths, instance) {
+const isNewTableWidthValid = (columnWidths, instance) => {
     if (instance.columnResizeMode === 'fit') {
         return true;
     }
-    var newTableWidth = 0;
-    for (var _i = 0, _a = instance.flatHeaders; _i < _a.length; _i++) {
-        var header = _a[_i];
+    let newTableWidth = 0;
+    for (const header of instance.flatHeaders) {
         newTableWidth += columnWidths[header.id]
             ? columnWidths[header.id]
             : getHeaderWidth(header);
@@ -237,21 +234,21 @@ var isNewTableWidthValid = function (columnWidths, instance) {
     }
     return true;
 };
-var useInstanceBeforeDimensions = function (instance) {
-    var flatHeaders = instance.flatHeaders, getHooks = instance.getHooks, columnResizing = instance.state.columnResizing, columnResizeMode = instance.columnResizeMode;
-    var getInstance = useGetLatest(instance);
-    flatHeaders.forEach(function (header, index) {
+const useInstanceBeforeDimensions = (instance) => {
+    const { flatHeaders, getHooks, state: { columnResizing }, columnResizeMode, } = instance;
+    const getInstance = useGetLatest(instance);
+    flatHeaders.forEach((header, index) => {
         var _a;
-        var resizeWidth = columnResizing.columnWidths[header.id];
+        const resizeWidth = columnResizing.columnWidths[header.id];
         header.width = resizeWidth || header.width || header.originalWidth;
         header.isResizing = columnResizing.isResizingColumn === header.id;
-        var headerToResize = header.disableResizing && columnResizeMode === 'fit'
+        const headerToResize = header.disableResizing && columnResizeMode === 'fit'
             ? getPreviousResizableHeader(header, instance)
             : header;
         // When `columnResizeMode` is `expand` and it is a last column,
         // then try to find some column on the left side to resize
         // when table width is decreasing.
-        var nextResizableHeader = columnResizeMode === 'expand' && index === flatHeaders.length - 1
+        const nextResizableHeader = columnResizeMode === 'expand' && index === flatHeaders.length - 1
             ? getPreviousResizableHeader(header, instance)
             : getNextResizableHeader(header, instance);
         header.canResize =
@@ -274,30 +271,26 @@ var useInstanceBeforeDimensions = function (instance) {
         });
     });
 };
-var getPreviousResizableHeader = function (headerColumn, instance) {
+const getPreviousResizableHeader = (headerColumn, instance) => {
     var _a;
-    var headersList = (((_a = headerColumn.parent) === null || _a === void 0 ? void 0 : _a.columns) || instance.flatHeaders).filter(function (_a) {
-        var isVisible = _a.isVisible;
-        return isVisible;
-    });
-    var headerIndex = headersList.findIndex(function (h) { return h.id === headerColumn.id; });
-    return __spreadArray([], headersList, true).slice(0, headerIndex)
+    const headersList = (((_a = headerColumn.parent) === null || _a === void 0 ? void 0 : _a.columns) || instance.flatHeaders).filter(({ isVisible }) => isVisible);
+    const headerIndex = headersList.findIndex((h) => h.id === headerColumn.id);
+    return [...headersList]
+        .slice(0, headerIndex)
         .reverse()
-        .find(function (h) { return !h.disableResizing; });
+        .find((h) => !h.disableResizing);
 };
-var getNextResizableHeader = function (headerColumn, instance) {
+const getNextResizableHeader = (headerColumn, instance) => {
     var _a;
-    var headersList = (((_a = headerColumn.parent) === null || _a === void 0 ? void 0 : _a.columns) || instance.flatHeaders).filter(function (_a) {
-        var isVisible = _a.isVisible;
-        return isVisible;
-    });
-    var headerIndex = headersList.findIndex(function (h) { return h.id === headerColumn.id; });
-    return __spreadArray([], headersList, true).slice(headerIndex + 1)
-        .find(function (h) { return !h.disableResizing; });
+    const headersList = (((_a = headerColumn.parent) === null || _a === void 0 ? void 0 : _a.columns) || instance.flatHeaders).filter(({ isVisible }) => isVisible);
+    const headerIndex = headersList.findIndex((h) => h.id === headerColumn.id);
+    return [...headersList]
+        .slice(headerIndex + 1)
+        .find((h) => !h.disableResizing);
 };
 function getLeafHeaders(header) {
-    var leafHeaders = [];
-    var recurseHeader = function (header) {
+    const leafHeaders = [];
+    const recurseHeader = (header) => {
         if (header.columns && header.columns.length) {
             header.columns.map(recurseHeader);
         }
@@ -306,13 +299,12 @@ function getLeafHeaders(header) {
     recurseHeader(header);
     return leafHeaders;
 }
-var getHeaderWidth = function (header) {
+const getHeaderWidth = (header) => {
     return Number(header.width || header.resizeWidth || 0);
 };
-var calculateTableWidth = function (columnWidths, headers) {
-    var newTableWidth = 0;
-    for (var _i = 0, headers_1 = headers; _i < headers_1.length; _i++) {
-        var header = headers_1[_i];
+const calculateTableWidth = (columnWidths, headers) => {
+    let newTableWidth = 0;
+    for (const header of headers) {
         newTableWidth += columnWidths[header.id]
             ? columnWidths[header.id]
             : getHeaderWidth(header);
@@ -320,21 +312,21 @@ var calculateTableWidth = function (columnWidths, headers) {
     return newTableWidth;
 };
 // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#safely_detecting_option_support
-var passiveSupported = null;
-var passiveEventSupported = function () {
+let passiveSupported = null;
+const passiveEventSupported = () => {
     // memoize support to avoid adding multiple test events
     if (passiveSupported != null) {
         return passiveSupported;
     }
     try {
-        var options = {
+        const options = {
             once: true,
             get passive() {
                 passiveSupported = true;
                 return false;
             },
         };
-        window.addEventListener('test', function () { }, options);
+        window.addEventListener('test', () => { }, options);
     }
     catch (_a) {
         passiveSupported = false;

package/esm/core/Table/hooks/useScrollToRow.js

@@ -3,27 +3,26 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 import React from 'react';
-export function useScrollToRow(_a) {
-    var data = _a.data, enableVirtualization = _a.enableVirtualization, page = _a.page, paginatorRenderer = _a.paginatorRenderer, scrollToRow = _a.scrollToRow;
-    var rowRefs = React.useRef({});
+export function useScrollToRow({ data, enableVirtualization, page, paginatorRenderer, scrollToRow, }) {
+    const rowRefs = React.useRef({});
     // Refs prevents from having `page` and `data` as dependencies
     // therefore we avoid unnecessary scroll to row.
-    var pageRef = React.useRef(page);
+    const pageRef = React.useRef(page);
     pageRef.current = page;
-    var dataRef = React.useRef(data);
+    const dataRef = React.useRef(data);
     dataRef.current = data;
     // For virtualized tables, all we need to do is pass the index of the item
     // to the VirtualScroll component
-    var scrollToIndex = React.useMemo(function () {
+    const scrollToIndex = React.useMemo(() => {
         if (!scrollToRow || paginatorRenderer) {
             return undefined;
         }
-        var index = scrollToRow(pageRef.current, dataRef.current);
+        const index = scrollToRow(pageRef.current, dataRef.current);
         return index < 0 ? undefined : index;
     }, [paginatorRenderer, scrollToRow]);
     // For non-virtualized tables, we need to add a ref to each row
     // and scroll to the element
-    React.useEffect(function () {
+    React.useEffect(() => {
         var _a;
         if (enableVirtualization ||
             scrollToIndex === undefined ||
@@ -33,10 +32,10 @@ export function useScrollToRow(_a) {
         }
         (_a = rowRefs.current[pageRef.current[scrollToIndex].id]) === null || _a === void 0 ? void 0 : _a.scrollIntoView();
     }, [enableVirtualization, scrollToIndex]);
-    var tableRowRef = React.useCallback(function (row) {
-        return function (element) {
+    const tableRowRef = React.useCallback((row) => {
+        return (element) => {
             rowRefs.current[row.id] = element;
         };
     }, []);
-    return { scrollToIndex: scrollToIndex, tableRowRef: tableRowRef };
+    return { scrollToIndex, tableRowRef };
 }

package/esm/core/Table/hooks/useSelectionCell.js

@@ -1,21 +1,10 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { SelectionColumn, SELECTION_CELL_ID } from '../columns';
-export var useSelectionCell = function (isSelectable, selectionMode, isRowDisabled) { return function (hooks) {
+export const useSelectionCell = (isSelectable, selectionMode, isRowDisabled) => (hooks) => {
     if (!isSelectable) {
         return;
     }
-    hooks.allColumns.push(function (columns) {
-        return selectionMode === 'single' ||
-            columns.find(function (c) { return c.id === SELECTION_CELL_ID; })
-            ? columns
-            : __spreadArray([SelectionColumn({ isDisabled: isRowDisabled })], columns, true);
-    });
-}; };
+    hooks.allColumns.push((columns) => selectionMode === 'single' ||
+        columns.find((c) => c.id === SELECTION_CELL_ID)
+        ? columns
+        : [SelectionColumn({ isDisabled: isRowDisabled }), ...columns]);
+};