@itwin/itwinui-react 3.11.3 → 3.12.0

package/cjs/core/Table/TableRowMemoized.js

@@ -1,116 +1,168 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+'use strict';
+Object.defineProperty(exports, '__esModule', {
+  value: true,
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableRowMemoized = exports.TableRow = void 0;
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
- * See LICENSE.md in the project root for license terms and full copyright notice.
- *--------------------------------------------------------------------------------------------*/
-const React = __importStar(require("react"));
-const classnames_1 = __importDefault(require("classnames"));
-const index_js_1 = require("../../utils/index.js");
-const TableCell_js_1 = require("./TableCell.js");
-/**
- * Memoization is needed to avoid unnecessary re-renders of all rows when additional data is added when lazy-loading.
- * Using `isLast` here instead of passing data length to avoid re-renders of all rows when more data is added. Now only the last row re-renders.
- * Although state is not used it is needed for `React.memo` to check state that changes row state e.g. selection.
- * When adding new features check whether it changes state that affects row. If it does then add equality check to `React.memo`.
- */
-const TableRow = (props) => {
-    const { row, rowProps, isLast, onRowInViewport, onBottomReached, intersectionMargin, onClick, subComponent, isDisabled, tableHasSubRows, tableInstance, expanderCell, scrollContainerRef, tableRowRef, density, } = props;
-    const onIntersect = React.useCallback(() => {
-        onRowInViewport.current?.(row.original);
-        isLast && onBottomReached.current?.();
-    }, [isLast, onBottomReached, onRowInViewport, row.original]);
-    const intersectionRoot = React.useMemo(() => {
-        const isTableScrollable = (scrollContainerRef?.scrollHeight ?? 0) >
-            (scrollContainerRef?.offsetHeight ?? 0);
-        // If table body is scrollable, make it the intersection root
-        if (isTableScrollable) {
-            return scrollContainerRef;
-        }
-        // Otherwise, make the viewport the intersection root
-        return undefined;
-    }, [scrollContainerRef]);
-    const intersectionRef = (0, index_js_1.useIntersection)(onIntersect, {
-        rootMargin: `${intersectionMargin}px`,
-        root: intersectionRoot,
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name],
     });
-    const userRowProps = rowProps?.(row) ?? {};
-    const { status, isLoading, ...restUserRowProps } = userRowProps;
-    const mergedProps = {
-        ...row.getRowProps({ style: { flex: `0 0 auto`, minWidth: '100%' } }),
-        ...restUserRowProps,
-        ...{
-            className: (0, classnames_1.default)('iui-table-row', {
-                'iui-table-row-expanded': row.isExpanded && subComponent,
-                'iui-loading': isLoading,
-            }, userRowProps?.className),
-            'aria-selected': row.isSelected || undefined,
-            'aria-disabled': isDisabled || undefined,
-            'data-iui-status': status,
+}
+_export(exports, {
+  TableRow: function () {
+    return TableRow;
+  },
+  TableRowMemoized: function () {
+    return TableRowMemoized;
+  },
+});
+const _interop_require_default = require('@swc/helpers/_/_interop_require_default');
+const _interop_require_wildcard = require('@swc/helpers/_/_interop_require_wildcard');
+const _jsxruntime = require('react/jsx-runtime');
+const _react = _interop_require_wildcard._(require('react'));
+const _classnames = _interop_require_default._(require('classnames'));
+const _index = require('../../utils/index.js');
+const _TableCell = require('./TableCell.js');
+const TableRow = (props) => {
+  const {
+    row,
+    rowProps,
+    isLast,
+    onRowInViewport,
+    onBottomReached,
+    intersectionMargin,
+    onClick,
+    subComponent,
+    isDisabled,
+    tableHasSubRows,
+    tableInstance,
+    expanderCell,
+    scrollContainerRef,
+    tableRowRef,
+    density,
+  } = props;
+  const onIntersect = _react.useCallback(() => {
+    onRowInViewport.current?.(row.original);
+    isLast && onBottomReached.current?.();
+  }, [isLast, onBottomReached, onRowInViewport, row.original]);
+  const intersectionRoot = _react.useMemo(() => {
+    const isTableScrollable =
+      (scrollContainerRef?.scrollHeight ?? 0) >
+      (scrollContainerRef?.offsetHeight ?? 0);
+    if (isTableScrollable) {
+      return scrollContainerRef;
+    }
+    return undefined;
+  }, [scrollContainerRef]);
+  const intersectionRef = (0, _index.useIntersection)(onIntersect, {
+    rootMargin: `${intersectionMargin}px`,
+    root: intersectionRoot,
+  });
+  const userRowProps = rowProps?.(row) ?? {};
+  const { status, isLoading, ...restUserRowProps } = userRowProps;
+  const mergedProps = {
+    ...row.getRowProps({
+      style: {
+        flex: `0 0 auto`,
+        minWidth: '100%',
+      },
+    }),
+    ...restUserRowProps,
+    ...{
+      className: (0, _classnames.default)(
+        'iui-table-row',
+        {
+          'iui-table-row-expanded': row.isExpanded && subComponent,
+          'iui-loading': isLoading,
         },
-    };
-    const refs = (0, index_js_1.useMergedRefs)(intersectionRef, mergedProps.ref, tableRowRef);
-    return (React.createElement(React.Fragment, null,
-        React.createElement(index_js_1.Box, { ...mergedProps, ref: refs, onClick: (event) => {
-                mergedProps?.onClick?.(event);
-                onClick?.(event, row);
-            } }, row.cells.map((cell, index) => {
-            return (React.createElement(TableCell_js_1.TableCell, { key: cell.getCellProps().key, cell: cell, cellIndex: index, isDisabled: isDisabled, tableHasSubRows: tableHasSubRows, tableInstance: tableInstance, expanderCell: expanderCell, density: density }));
-        })),
-        subComponent && (React.createElement(index_js_1.WithCSSTransition, { in: row.isExpanded },
-            React.createElement(index_js_1.Box, { className: (0, classnames_1.default)('iui-table-row', 'iui-table-expanded-content'), "aria-disabled": isDisabled }, subComponent(row))))));
+        userRowProps?.className,
+      ),
+      'aria-selected': row.isSelected || undefined,
+      'aria-disabled': isDisabled || undefined,
+      'data-iui-status': status,
+    },
+  };
+  const refs = (0, _index.useMergedRefs)(
+    intersectionRef,
+    mergedProps.ref,
+    tableRowRef,
+  );
+  return (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+    children: [
+      (0, _jsxruntime.jsx)(_index.Box, {
+        ...mergedProps,
+        ref: refs,
+        onClick: (event) => {
+          mergedProps?.onClick?.(event);
+          onClick?.(event, row);
+        },
+        children: row.cells.map((cell, index) => {
+          return (0, _jsxruntime.jsx)(
+            _TableCell.TableCell,
+            {
+              cell: cell,
+              cellIndex: index,
+              isDisabled: isDisabled,
+              tableHasSubRows: tableHasSubRows,
+              tableInstance: tableInstance,
+              expanderCell: expanderCell,
+              density: density,
+            },
+            cell.getCellProps().key,
+          );
+        }),
+      }),
+      subComponent &&
+        (0, _jsxruntime.jsx)(_index.WithCSSTransition, {
+          in: row.isExpanded,
+          children: (0, _jsxruntime.jsx)(_index.Box, {
+            className: (0, _classnames.default)(
+              'iui-table-row',
+              'iui-table-expanded-content',
+            ),
+            'aria-disabled': isDisabled,
+            children: subComponent(row),
+          }),
+        }),
+    ],
+  });
 };
-exports.TableRow = TableRow;
 const hasAnySelectedSubRow = (row, selectedRowIds) => {
-    if (selectedRowIds?.[row.id]) {
-        return true;
-    }
-    return row.subRows.some((subRow) => hasAnySelectedSubRow(subRow, selectedRowIds));
+  if (selectedRowIds?.[row.id]) {
+    return true;
+  }
+  return row.subRows.some((subRow) =>
+    hasAnySelectedSubRow(subRow, selectedRowIds),
+  );
 };
-exports.TableRowMemoized = React.memo(exports.TableRow, (prevProp, nextProp) => prevProp.isLast === nextProp.isLast &&
+const TableRowMemoized = _react.memo(
+  TableRow,
+  (prevProp, nextProp) =>
+    prevProp.isLast === nextProp.isLast &&
     prevProp.state.hiddenColumns?.length ===
-        nextProp.state.hiddenColumns?.length &&
-    !!prevProp.state.hiddenColumns?.every((column, index) => nextProp.state.hiddenColumns?.[index] === column) &&
+      nextProp.state.hiddenColumns?.length &&
+    !!prevProp.state.hiddenColumns?.every(
+      (column, index) => nextProp.state.hiddenColumns?.[index] === column,
+    ) &&
     prevProp.onRowInViewport === nextProp.onRowInViewport &&
     prevProp.onBottomReached === nextProp.onBottomReached &&
     prevProp.onClick === nextProp.onClick &&
     prevProp.row.original === nextProp.row.original &&
     prevProp.state.selectedRowIds?.[prevProp.row.id] ===
-        nextProp.state.selectedRowIds?.[nextProp.row.id] &&
-    // Check if sub-rows selection has changed and whether to show indeterminate state or not
-    prevProp.row.subRows.some((subRow) => hasAnySelectedSubRow(subRow, prevProp.state.selectedRowIds)) ===
-        nextProp.row.subRows.some((subRow) => hasAnySelectedSubRow(subRow, nextProp.state.selectedRowIds)) &&
+      nextProp.state.selectedRowIds?.[nextProp.row.id] &&
+    prevProp.row.subRows.some((subRow) =>
+      hasAnySelectedSubRow(subRow, prevProp.state.selectedRowIds),
+    ) ===
+      nextProp.row.subRows.some((subRow) =>
+        hasAnySelectedSubRow(subRow, nextProp.state.selectedRowIds),
+      ) &&
     prevProp.state.expanded?.[prevProp.row.id] ===
-        nextProp.state.expanded?.[nextProp.row.id] &&
+      nextProp.state.expanded?.[nextProp.row.id] &&
     prevProp.subComponent === nextProp.subComponent &&
-    prevProp.row.cells.every((cell, index) => nextProp.row.cells[index].column === cell.column) &&
+    prevProp.row.cells.every(
+      (cell, index) => nextProp.row.cells[index].column === cell.column,
+    ) &&
     prevProp.isDisabled === nextProp.isDisabled &&
     prevProp.rowProps === nextProp.rowProps &&
     prevProp.expanderCell === nextProp.expanderCell &&
@@ -120,7 +172,8 @@ exports.TableRowMemoized = React.memo(exports.TableRow, (prevProp, nextProp) =>
     !nextProp.state.columnResizing.isResizingColumn &&
     prevProp.state.isTableResizing === nextProp.state.isTableResizing &&
     prevProp.state.sticky.isScrolledToLeft ===
-        nextProp.state.sticky.isScrolledToLeft &&
+      nextProp.state.sticky.isScrolledToLeft &&
     prevProp.state.sticky.isScrolledToRight ===
-        nextProp.state.sticky.isScrolledToRight &&
-    prevProp.density === nextProp.density);
+      nextProp.state.sticky.isScrolledToRight &&
+    prevProp.density === nextProp.density,
+);

package/cjs/core/Table/actionHandlers/expandHandler.d.ts

@@ -1,2 +1,2 @@
 import type { TableInstance, TableState } from '../../../react-table/react-table.js';
-export declare const onExpandHandler: <T extends Record<string, unknown>>(newState: TableState<T>, instance?: TableInstance<T> | undefined, onExpand?: ((expandedData: T[] | undefined, tableState?: TableState<T> | undefined) => void) | undefined) => void;
+export declare const onExpandHandler: <T extends Record<string, unknown>>(newState: TableState<T>, instance?: TableInstance<T>, onExpand?: (expandedData: T[] | undefined, tableState?: TableState<T>) => void) => void;

package/cjs/core/Table/actionHandlers/expandHandler.js

@@ -1,17 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.onExpandHandler = void 0;
+'use strict';
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+Object.defineProperty(exports, 'onExpandHandler', {
+  enumerable: true,
+  get: function () {
+    return onExpandHandler;
+  },
+});
 const onExpandHandler = (newState, instance, onExpand) => {
-    if (!instance?.preFilteredFlatRows.length) {
-        onExpand?.([], newState);
-        return;
+  if (!instance?.preFilteredFlatRows.length) {
+    onExpand?.([], newState);
+    return;
+  }
+  const expandedData = [];
+  instance.preFilteredFlatRows.forEach((row) => {
+    if (newState.expanded[row.id]) {
+      expandedData.push(row.original);
     }
-    const expandedData = [];
-    instance.preFilteredFlatRows.forEach((row) => {
-        if (newState.expanded[row.id]) {
-            expandedData.push(row.original);
-        }
-    });
-    onExpand?.(expandedData, newState);
+  });
+  onExpand?.(expandedData, newState);
 };
-exports.onExpandHandler = onExpandHandler;

package/cjs/core/Table/actionHandlers/filterHandler.d.ts

@@ -1,3 +1,3 @@
 import type { ActionType, TableInstance, TableState } from '../../../react-table/react-table.js';
 import type { TableFilterValue } from '../filters/index.js';
-export declare const onFilterHandler: <T extends Record<string, unknown>>(newState: TableState<T>, action: ActionType, previousState: TableState<T>, currentFilter: TableFilterValue<T>[], instance?: TableInstance<T> | undefined) => TableFilterValue<T>[];
+export declare const onFilterHandler: <T extends Record<string, unknown>>(newState: TableState<T>, action: ActionType, previousState: TableState<T>, currentFilter: TableFilterValue<T>[], instance?: TableInstance<T>) => TableFilterValue<T>[];

package/cjs/core/Table/actionHandlers/filterHandler.js

@@ -1,20 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.onFilterHandler = void 0;
-const onFilterHandler = (newState, action, previousState, currentFilter, instance) => {
-    const previousFilter = previousState.filters.find((f) => f.id === action.columnId);
-    if (previousFilter?.value != action.filterValue) {
-        const filters = newState.filters.map((f) => {
-            const column = instance?.allColumns.find((c) => c.id === f.id);
-            return {
-                id: f.id,
-                value: f.value,
-                fieldType: column?.fieldType ?? 'text',
-                filterType: column?.filter ?? 'text',
-            };
-        });
-        return filters;
-    }
-    return currentFilter;
+'use strict';
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+Object.defineProperty(exports, 'onFilterHandler', {
+  enumerable: true,
+  get: function () {
+    return onFilterHandler;
+  },
+});
+const onFilterHandler = (
+  newState,
+  action,
+  previousState,
+  currentFilter,
+  instance,
+) => {
+  const previousFilter = previousState.filters.find(
+    (f) => f.id === action.columnId,
+  );
+  if (previousFilter?.value != action.filterValue) {
+    const filters = newState.filters.map((f) => {
+      const column = instance?.allColumns.find((c) => c.id === f.id);
+      return {
+        id: f.id,
+        value: f.value,
+        fieldType: column?.fieldType ?? 'text',
+        filterType: column?.filter ?? 'text',
+      };
+    });
+    return filters;
+  }
+  return currentFilter;
 };
-exports.onFilterHandler = onFilterHandler;

package/cjs/core/Table/actionHandlers/index.js

@@ -1,18 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.onTableResizeEnd = exports.onTableResizeStart = exports.onShiftSelectHandler = exports.onSingleSelectHandler = exports.onToggleHandler = exports.onFilterHandler = exports.onExpandHandler = void 0;
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
- * See LICENSE.md in the project root for license terms and full copyright notice.
- *--------------------------------------------------------------------------------------------*/
-var expandHandler_js_1 = require("./expandHandler.js");
-Object.defineProperty(exports, "onExpandHandler", { enumerable: true, get: function () { return expandHandler_js_1.onExpandHandler; } });
-var filterHandler_js_1 = require("./filterHandler.js");
-Object.defineProperty(exports, "onFilterHandler", { enumerable: true, get: function () { return filterHandler_js_1.onFilterHandler; } });
-var selectHandler_js_1 = require("./selectHandler.js");
-Object.defineProperty(exports, "onToggleHandler", { enumerable: true, get: function () { return selectHandler_js_1.onToggleHandler; } });
-Object.defineProperty(exports, "onSingleSelectHandler", { enumerable: true, get: function () { return selectHandler_js_1.onSingleSelectHandler; } });
-Object.defineProperty(exports, "onShiftSelectHandler", { enumerable: true, get: function () { return selectHandler_js_1.onShiftSelectHandler; } });
-var resizeHandler_js_1 = require("./resizeHandler.js");
-Object.defineProperty(exports, "onTableResizeStart", { enumerable: true, get: function () { return resizeHandler_js_1.onTableResizeStart; } });
-Object.defineProperty(exports, "onTableResizeEnd", { enumerable: true, get: function () { return resizeHandler_js_1.onTableResizeEnd; } });
+'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, {
+  onExpandHandler: function () {
+    return _expandHandler.onExpandHandler;
+  },
+  onFilterHandler: function () {
+    return _filterHandler.onFilterHandler;
+  },
+  onShiftSelectHandler: function () {
+    return _selectHandler.onShiftSelectHandler;
+  },
+  onSingleSelectHandler: function () {
+    return _selectHandler.onSingleSelectHandler;
+  },
+  onTableResizeEnd: function () {
+    return _resizeHandler.onTableResizeEnd;
+  },
+  onTableResizeStart: function () {
+    return _resizeHandler.onTableResizeStart;
+  },
+  onToggleHandler: function () {
+    return _selectHandler.onToggleHandler;
+  },
+});
+const _expandHandler = require('./expandHandler.js');
+const _filterHandler = require('./filterHandler.js');
+const _selectHandler = require('./selectHandler.js');
+const _resizeHandler = require('./resizeHandler.js');

package/cjs/core/Table/actionHandlers/resizeHandler.d.ts

@@ -3,20 +3,20 @@ export declare const onTableResizeStart: <T extends Record<string, unknown>>(sta
     isTableResizing: boolean;
     hiddenColumns?: import("../../../react-table/react-table.js").IdType<T>[] | undefined;
     columnResizing: {
-        startX?: number | undefined;
-        columnWidth?: number | undefined;
-        nextColumnWidth?: number | undefined;
-        headerIdWidths?: [string, number][] | undefined;
-        nextHeaderIdWidths?: [string, number][] | undefined;
+        startX?: number;
+        columnWidth?: number;
+        nextColumnWidth?: number;
+        headerIdWidths?: Array<[string, number]>;
+        nextHeaderIdWidths?: Array<[string, number]>;
         columnWidths: Record<string, number>;
-        isResizingColumn?: string | undefined;
+        isResizingColumn?: string;
     };
     columnReorderStartIndex: number;
     sticky: {
-        isScrolledToRight?: boolean | undefined;
-        isScrolledToLeft?: boolean | undefined;
+        isScrolledToRight?: boolean;
+        isScrolledToLeft?: boolean;
     };
-    lastSelectedRowId?: string | undefined;
+    lastSelectedRowId?: string;
     columnOrder: import("../../../react-table/react-table.js").IdType<T>[];
     expanded: Record<import("../../../react-table/react-table.js").IdType<T>, boolean>;
     filters: import("../../../react-table/react-table.js").Filters<T>;
@@ -34,20 +34,20 @@ export declare const onTableResizeEnd: <T extends Record<string, unknown>>(state
     isTableResizing: boolean;
     columnResizing: {
         columnWidths: any;
-        startX?: number | undefined;
-        columnWidth?: number | undefined;
-        nextColumnWidth?: number | undefined;
-        headerIdWidths?: [string, number][] | undefined;
-        nextHeaderIdWidths?: [string, number][] | undefined;
-        isResizingColumn?: string | undefined;
+        startX?: number;
+        columnWidth?: number;
+        nextColumnWidth?: number;
+        headerIdWidths?: Array<[string, number]>;
+        nextHeaderIdWidths?: Array<[string, number]>;
+        isResizingColumn?: string;
     };
     hiddenColumns?: import("../../../react-table/react-table.js").IdType<T>[] | undefined;
     columnReorderStartIndex: number;
     sticky: {
-        isScrolledToRight?: boolean | undefined;
-        isScrolledToLeft?: boolean | undefined;
+        isScrolledToRight?: boolean;
+        isScrolledToLeft?: boolean;
     };
-    lastSelectedRowId?: string | undefined;
+    lastSelectedRowId?: string;
     columnOrder: import("../../../react-table/react-table.js").IdType<T>[];
     expanded: Record<import("../../../react-table/react-table.js").IdType<T>, boolean>;
     filters: import("../../../react-table/react-table.js").Filters<T>;

package/cjs/core/Table/actionHandlers/resizeHandler.js

@@ -1,20 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.onTableResizeEnd = exports.onTableResizeStart = void 0;
+'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, {
+  onTableResizeEnd: function () {
+    return onTableResizeEnd;
+  },
+  onTableResizeStart: function () {
+    return onTableResizeStart;
+  },
+});
 const onTableResizeStart = (state) => {
-    return { ...state, isTableResizing: true };
+  return {
+    ...state,
+    isTableResizing: true,
+  };
 };
-exports.onTableResizeStart = onTableResizeStart;
 const onTableResizeEnd = (state, action) => {
-    return {
-        ...state,
-        isTableResizing: false,
-        columnResizing: {
-            ...state.columnResizing,
-            columnWidths: {
-                ...action.columnWidths,
-            },
-        },
-    };
+  return {
+    ...state,
+    isTableResizing: false,
+    columnResizing: {
+      ...state.columnResizing,
+      columnWidths: {
+        ...action.columnWidths,
+      },
+    },
+  };
 };
-exports.onTableResizeEnd = onTableResizeEnd;

package/cjs/core/Table/actionHandlers/selectHandler.d.ts

@@ -2,28 +2,28 @@ import type { ActionType, TableInstance, TableState, IdType } from '../../../rea
 /**
  * Handles selection when toggling a row (Ctrl click or checkbox click)
  */
-export declare const onToggleHandler: <T extends Record<string, unknown>>(newState: TableState<T>, action: ActionType, instance?: TableInstance<T> | undefined, onSelect?: ((selectedData: T[] | undefined, tableState?: TableState<T> | undefined) => void) | undefined, isRowDisabled?: ((rowData: T) => boolean) | undefined) => void;
+export declare const onToggleHandler: <T extends Record<string, unknown>>(newState: TableState<T>, action: ActionType, instance?: TableInstance<T>, onSelect?: (selectedData: T[] | undefined, tableState?: TableState<T>) => void, isRowDisabled?: (rowData: T) => boolean) => void;
 /**
  * Handles selection when clicked on a row.
  */
-export declare const onSingleSelectHandler: <T extends Record<string, unknown>>(state: TableState<T>, action: ActionType, instance?: TableInstance<T> | undefined, onSelect?: ((selectedData: T[] | undefined, tableState?: TableState<T> | undefined) => void) | undefined, isRowDisabled?: ((rowData: T) => boolean) | undefined) => {
+export declare const onSingleSelectHandler: <T extends Record<string, unknown>>(state: TableState<T>, action: ActionType, instance?: TableInstance<T>, onSelect?: (selectedData: T[] | undefined, tableState?: TableState<T>) => void, isRowDisabled?: (rowData: T) => boolean) => {
     lastSelectedRowId: any;
     selectedRowIds: Record<string, boolean>;
     hiddenColumns?: IdType<T>[] | undefined;
     columnResizing: {
-        startX?: number | undefined;
-        columnWidth?: number | undefined;
-        nextColumnWidth?: number | undefined;
-        headerIdWidths?: [string, number][] | undefined;
-        nextHeaderIdWidths?: [string, number][] | undefined;
+        startX?: number;
+        columnWidth?: number;
+        nextColumnWidth?: number;
+        headerIdWidths?: Array<[string, number]>;
+        nextHeaderIdWidths?: Array<[string, number]>;
         columnWidths: Record<string, number>;
-        isResizingColumn?: string | undefined;
+        isResizingColumn?: string;
     };
-    isTableResizing?: boolean | undefined;
+    isTableResizing?: boolean;
     columnReorderStartIndex: number;
     sticky: {
-        isScrolledToRight?: boolean | undefined;
-        isScrolledToLeft?: boolean | undefined;
+        isScrolledToRight?: boolean;
+        isScrolledToLeft?: boolean;
     };
     columnOrder: IdType<T>[];
     expanded: Record<IdType<T>, boolean>;
@@ -40,4 +40,4 @@ export declare const onSingleSelectHandler: <T extends Record<string, unknown>>(
 /**
  * Handles selection when clicked on a row while shift key is pressed.
  */
-export declare const onShiftSelectHandler: <T extends Record<string, unknown>>(state: TableState<T>, action: ActionType, instance?: TableInstance<T> | undefined, onSelect?: ((selectedData: T[] | undefined, tableState?: TableState<T> | undefined) => void) | undefined, isRowDisabled?: ((rowData: T) => boolean) | undefined) => TableState<T>;
+export declare const onShiftSelectHandler: <T extends Record<string, unknown>>(state: TableState<T>, action: ActionType, instance?: TableInstance<T>, onSelect?: (selectedData: T[] | undefined, tableState?: TableState<T>) => void, isRowDisabled?: (rowData: T) => boolean) => TableState<T>;