@itwin/itwinui-react 1.45.0 → 1.47.0

package/esm/core/index.d.ts

@@ -20,6 +20,8 @@ export { ComboBox } from './ComboBox';
 export type { ComboBoxProps } from './ComboBox';
 export { DatePicker, generateLocalizedStrings } from './DatePicker';
 export type { DatePickerProps } from './DatePicker';
+export { Dialog } from './Dialog';
+export type { DialogProps, DialogButtonBarProps, DialogContentProps, DialogMainProps, DialogTitleBarProps, } from './Dialog';
 export { DropdownMenu } from './DropdownMenu';
 export type { DropdownMenuProps } from './DropdownMenu';
 export { ErrorPage } from './ErrorPage';
@@ -72,7 +74,7 @@ export { StatusMessage } from './StatusMessage';
 export type { StatusMessageProps } from './StatusMessage';
 export { Surface } from './Surface';
 export type { SurfaceProps } from './Surface';
-export { Table, tableFilters, FilterButtonBar, DefaultCell, EditableCell, TablePaginator, ActionColumn, ExpanderColumn, SelectionColumn, } from './Table';
+export { Table, tableFilters, BaseFilter, FilterButtonBar, DefaultCell, EditableCell, TablePaginator, ActionColumn, ExpanderColumn, SelectionColumn, } from './Table';
 export type { TableProps, TableFilterProps, TableFilterValue, DateRangeFilterOptions, FilterButtonBarProps, DefaultCellProps, EditableCellProps, TablePaginatorProps, TablePaginatorRendererProps, } from './Table';
 export { Tag, TagContainer } from './Tag';
 export type { TagProps, TagContainerProps } from './Tag';

package/esm/core/index.js

@@ -13,6 +13,7 @@ export { Checkbox } from './Checkbox';
 export { ColorPicker, ColorSwatch, ColorBuilder, ColorInputPanel, ColorPalette, } from './ColorPicker';
 export { ComboBox } from './ComboBox';
 export { DatePicker, generateLocalizedStrings } from './DatePicker';
+export { Dialog } from './Dialog';
 export { DropdownMenu } from './DropdownMenu';
 export { ErrorPage } from './ErrorPage';
 export { ExpandableBlock } from './ExpandableBlock';
@@ -39,7 +40,7 @@ export { SkipToContentLink } from './SkipToContentLink';
 export { Slider } from './Slider';
 export { StatusMessage } from './StatusMessage';
 export { Surface } from './Surface';
-export { Table, tableFilters, FilterButtonBar, DefaultCell, EditableCell, TablePaginator, ActionColumn, ExpanderColumn, SelectionColumn, } from './Table';
+export { Table, tableFilters, BaseFilter, FilterButtonBar, DefaultCell, EditableCell, TablePaginator, ActionColumn, ExpanderColumn, SelectionColumn, } from './Table';
 export { Tag, TagContainer } from './Tag';
 export { Textarea } from './Textarea';
 export { Tile } from './Tile';

package/esm/core/utils/components/Resizer.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+export declare type ResizerProps = {
+    /**
+     * Ref of the element that is being resized.
+     */
+    elementRef: React.RefObject<HTMLElement>;
+    /**
+     * Ref of the container element in order to avoid resizing past container boundaries.
+     * If not passed, viewport will be used.
+     */
+    containerRef?: React.RefObject<HTMLElement>;
+    /**
+     * Callback that is being called on resize end.
+     * Useful to preserve state if element is being closed.
+     */
+    onResizeEnd?: (style: React.CSSProperties) => void;
+};
+/**
+ * Component that allows to resize parent element.
+ * Parent must have `position: relative`.
+ * @private
+ * @example
+ * const ref = React.useRef<HTMLDivElement>(null);
+ * return (
+ *   <div ref={ref} style={{ position: 'relative' }}>
+ *     <Resizer elementRef={ref} />
+ *   </div>
+ * );
+ */
+export declare const Resizer: (props: ResizerProps) => JSX.Element;
+export default Resizer;

package/esm/core/utils/components/Resizer.js

@@ -0,0 +1,199 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import React from 'react';
+import { getBoundedValue, getTranslateValues } from '../functions';
+/**
+ * Component that allows to resize parent element.
+ * Parent must have `position: relative`.
+ * @private
+ * @example
+ * const ref = React.useRef<HTMLDivElement>(null);
+ * return (
+ *   <div ref={ref} style={{ position: 'relative' }}>
+ *     <Resizer elementRef={ref} />
+ *   </div>
+ * );
+ */
+export var Resizer = function (props) {
+    var elementRef = props.elementRef, containerRef = props.containerRef, onResizeEnd = props.onResizeEnd;
+    var onResizePointerDown = function (event) {
+        if (!elementRef.current || event.button !== 0) {
+            return;
+        }
+        var initialPointerX = event.clientX;
+        var initialPointerY = event.clientY;
+        var _a = getTranslateValues(elementRef.current), initialTranslateX = _a[0], initialTranslateY = _a[1];
+        var _b = elementRef.current.getBoundingClientRect(), initialWidth = _b.width, initialHeight = _b.height;
+        var width = "".concat(initialWidth, "px");
+        var height = "".concat(initialHeight, "px");
+        var translateX = initialTranslateX;
+        var translateY = initialTranslateY;
+        var minWidth = parseFloat(getComputedStyle(elementRef.current).minWidth);
+        var minHeight = parseFloat(getComputedStyle(elementRef.current).minHeight);
+        var resizer = event.currentTarget.dataset.iuiResizer;
+        var originalUserSelect = elementRef.current.ownerDocument.body.style.userSelect;
+        elementRef.current.ownerDocument.body.style.userSelect = 'none';
+        var onResizePointerMove = function (event) {
+            var _a, _b, _c, _d, _e, _f, _g;
+            if (!elementRef.current) {
+                return;
+            }
+            var containerRect = (_a = containerRef === null || containerRef === void 0 ? void 0 : containerRef.current) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
+            var clientX = getBoundedValue(event.clientX, (_b = containerRect === null || containerRect === void 0 ? void 0 : containerRect.left) !== null && _b !== void 0 ? _b : 0, (_d = (_c = containerRect === null || containerRect === void 0 ? void 0 : containerRect.right) !== null && _c !== void 0 ? _c : elementRef.current.ownerDocument.documentElement.clientWidth) !== null && _d !== void 0 ? _d : 0);
+            var clientY = getBoundedValue(event.clientY, (_e = containerRect === null || containerRect === void 0 ? void 0 : containerRect.top) !== null && _e !== void 0 ? _e : 0, (_g = (_f = containerRect === null || containerRect === void 0 ? void 0 : containerRect.bottom) !== null && _f !== void 0 ? _f : elementRef.current.ownerDocument.documentElement.clientHeight) !== null && _g !== void 0 ? _g : 0);
+            var diffX = initialPointerX - clientX;
+            var diffY = initialPointerY - clientY;
+            switch (resizer) {
+                case 'top-left': {
+                    var newHeight = initialHeight + diffY;
+                    if (newHeight >= minHeight) {
+                        height = elementRef.current.style.height = "".concat(newHeight, "px");
+                        translateY = initialTranslateY - diffY;
+                    }
+                    var newWidth = initialWidth + diffX;
+                    if (newWidth >= minWidth) {
+                        width = elementRef.current.style.width = "".concat(newWidth, "px");
+                        translateX = initialTranslateX - diffX;
+                    }
+                    elementRef.current.style.transform = "translate(".concat(translateX, "px, ").concat(translateY, "px)");
+                    break;
+                }
+                case 'top': {
+                    var newHeight = initialHeight + diffY;
+                    if (newHeight < minHeight) {
+                        break;
+                    }
+                    height = elementRef.current.style.height = "".concat(newHeight, "px");
+                    translateY = initialTranslateY - diffY;
+                    elementRef.current.style.transform = "translate(".concat(translateX, "px, ").concat(translateY, "px)");
+                    break;
+                }
+                case 'top-right': {
+                    var newHeight = initialHeight + diffY;
+                    if (newHeight >= minHeight) {
+                        height = elementRef.current.style.height = "".concat(newHeight, "px");
+                        translateY = initialTranslateY - diffY;
+                    }
+                    width = elementRef.current.style.width = "".concat(initialWidth - diffX, "px");
+                    elementRef.current.style.transform = "translate(".concat(translateX, "px, ").concat(translateY, "px)");
+                    break;
+                }
+                case 'right': {
+                    width = elementRef.current.style.width = "".concat(initialWidth - diffX, "px");
+                    break;
+                }
+                case 'bottom-right': {
+                    width = elementRef.current.style.width = "".concat(initialWidth - diffX, "px");
+                    height = elementRef.current.style.height = "".concat(initialHeight - diffY, "px");
+                    break;
+                }
+                case 'bottom': {
+                    height = elementRef.current.style.height = "".concat(initialHeight - diffY, "px");
+                    break;
+                }
+                case 'bottom-left': {
+                    var newWidth = initialWidth + diffX;
+                    if (newWidth >= minWidth) {
+                        width = elementRef.current.style.width = "".concat(newWidth, "px");
+                        translateX = initialTranslateX - diffX;
+                    }
+                    height = elementRef.current.style.height = "".concat(initialHeight - diffY, "px");
+                    elementRef.current.style.transform = "translate(".concat(translateX, "px, ").concat(translateY, "px)");
+                    break;
+                }
+                case 'left': {
+                    var newWidth = initialWidth + diffX;
+                    if (newWidth < minWidth) {
+                        break;
+                    }
+                    width = elementRef.current.style.width = "".concat(newWidth, "px");
+                    translateX = initialTranslateX - diffX;
+                    elementRef.current.style.transform = "translate(".concat(translateX, "px, ").concat(translateY, "px)");
+                    break;
+                }
+                default:
+                    break;
+            }
+        };
+        elementRef.current.ownerDocument.addEventListener('pointermove', onResizePointerMove);
+        elementRef.current.ownerDocument.addEventListener('pointerup', function () {
+            document.removeEventListener('pointermove', onResizePointerMove);
+            if (elementRef.current) {
+                elementRef.current.ownerDocument.body.style.userSelect = originalUserSelect;
+                onResizeEnd === null || onResizeEnd === void 0 ? void 0 : onResizeEnd({
+                    width: width,
+                    height: height,
+                    transform: "translate(".concat(translateX, "px, ").concat(translateY, "px)"),
+                });
+            }
+        }, { once: true });
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", { "data-iui-resizer": 'top-left', onPointerDown: onResizePointerDown, style: {
+                position: 'absolute',
+                top: -4,
+                left: -4,
+                width: 12,
+                height: 12,
+                cursor: 'nw-resize',
+            } }),
+        React.createElement("div", { "data-iui-resizer": 'top', onPointerDown: onResizePointerDown, style: {
+                position: 'absolute',
+                top: -4,
+                left: 8,
+                right: 8,
+                height: 8,
+                cursor: 'n-resize',
+            } }),
+        React.createElement("div", { "data-iui-resizer": 'top-right', onPointerDown: onResizePointerDown, style: {
+                position: 'absolute',
+                top: -4,
+                right: -4,
+                width: 12,
+                height: 12,
+                cursor: 'ne-resize',
+            } }),
+        React.createElement("div", { "data-iui-resizer": 'right', onPointerDown: onResizePointerDown, style: {
+                position: 'absolute',
+                top: 8,
+                right: -4,
+                bottom: 8,
+                width: 8,
+                cursor: 'e-resize',
+            } }),
+        React.createElement("div", { "data-iui-resizer": 'bottom-right', onPointerDown: onResizePointerDown, style: {
+                position: 'absolute',
+                bottom: -4,
+                right: -4,
+                width: 12,
+                height: 12,
+                cursor: 'se-resize',
+            } }),
+        React.createElement("div", { "data-iui-resizer": 'bottom', onPointerDown: onResizePointerDown, style: {
+                position: 'absolute',
+                bottom: -4,
+                left: 8,
+                right: 8,
+                height: 8,
+                cursor: 's-resize',
+            } }),
+        React.createElement("div", { "data-iui-resizer": 'bottom-left', onPointerDown: onResizePointerDown, style: {
+                position: 'absolute',
+                bottom: -4,
+                left: -4,
+                width: 12,
+                height: 12,
+                cursor: 'sw-resize',
+            } }),
+        React.createElement("div", { "data-iui-resizer": 'left', onPointerDown: onResizePointerDown, style: {
+                position: 'absolute',
+                top: 8,
+                left: -4,
+                bottom: 8,
+                width: 8,
+                cursor: 'w-resize',
+            } })));
+};
+export default Resizer;

package/esm/core/utils/components/VirtualScroll.js

@@ -130,28 +130,6 @@ export var useVirtualization = function (props) {
     // Used to mark when scroll container has height (updated by resize observer)
     // because before that calculations are not right
     var _e = React.useState(false), isMounted = _e[0], setIsMounted = _e[1];
-    var onResize = React.useCallback(function (_a) {
-        var height = _a.height;
-        // Initial value returned by resize observer is 0
-        // So wait for the next one
-        if (height > 0) {
-            setIsMounted(true);
-        }
-        setScrollContainerHeight(height);
-    }, []);
-    var _f = useResizeObserver(onResize), resizeRef = _f[0], resizeObserver = _f[1];
-    // Find scrollable parent
-    // Needed only on init
-    React.useLayoutEffect(function () {
-        var _a;
-        var scrollableParent = getScrollableParent(parentRef.current, (_a = parentRef.current) === null || _a === void 0 ? void 0 : _a.ownerDocument);
-        scrollContainer.current = scrollableParent;
-        resizeRef(scrollableParent);
-    }, [resizeRef]);
-    // Stop watching resize, when virtual scroll is unmounted
-    React.useLayoutEffect(function () {
-        return function () { return resizeObserver === null || resizeObserver === void 0 ? void 0 : resizeObserver.disconnect(); };
-    }, [resizeObserver]);
     var getScrollableContainer = function () {
         var _a, _b;
         return (_a = scrollContainer.current) !== null && _a !== void 0 ? _a : (_b = parentRef.current) === null || _b === void 0 ? void 0 : _b.ownerDocument.scrollingElement;
@@ -164,8 +142,7 @@ export var useVirtualization = function (props) {
         }
         return arr;
     }, [itemsLength, itemRenderer, bufferSize, startNode, visibleNodeCount]);
-    // Get child height when children available
-    React.useLayoutEffect(function () {
+    var updateChildHeight = React.useCallback(function () {
         var _a, _b, _c, _d, _e, _f;
         if (!parentRef.current || !visibleChildren.length) {
             return;
@@ -180,6 +157,31 @@ export var useVirtualization = function (props) {
             last: Number((_f = (_e = getElementHeightWithMargins(lastChild)) === null || _e === void 0 ? void 0 : _e.toFixed(2)) !== null && _f !== void 0 ? _f : firstChildHeight),
         };
     }, [visibleChildren.length]);
+    var onResize = React.useCallback(function (_a) {
+        var height = _a.height;
+        // Initial value returned by resize observer is 0
+        // So wait for the next one
+        if (height > 0) {
+            setIsMounted(true);
+        }
+        setScrollContainerHeight(height);
+        updateChildHeight();
+    }, [updateChildHeight]);
+    var _f = useResizeObserver(onResize), resizeRef = _f[0], resizeObserver = _f[1];
+    // Find scrollable parent
+    // Needed only on init
+    React.useLayoutEffect(function () {
+        var _a;
+        var scrollableParent = getScrollableParent(parentRef.current, (_a = parentRef.current) === null || _a === void 0 ? void 0 : _a.ownerDocument);
+        scrollContainer.current = scrollableParent;
+        resizeRef(scrollableParent);
+    }, [resizeRef]);
+    // Stop watching resize, when virtual scroll is unmounted
+    React.useLayoutEffect(function () {
+        return function () { return resizeObserver === null || resizeObserver === void 0 ? void 0 : resizeObserver.disconnect(); };
+    }, [resizeObserver]);
+    // Get child height when children available
+    React.useLayoutEffect(function () { return updateChildHeight(); }, [updateChildHeight]);
     var updateVirtualScroll = React.useCallback(function () {
         var scrollableContainer = getScrollableContainer();
         if (!scrollableContainer) {

package/esm/core/utils/components/index.d.ts

@@ -1,4 +1,5 @@
 export * from './Popover';
+export * from './Resizer';
 export * from './FocusTrap';
 export * from './InputContainer';
 export * from './icons';

package/esm/core/utils/components/index.js

@@ -3,6 +3,7 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 export * from './Popover';
+export * from './Resizer';
 export * from './FocusTrap';
 export * from './InputContainer';
 export * from './icons';

package/esm/core/utils/functions/index.d.ts

@@ -2,3 +2,4 @@ export * from './dom';
 export * from './colors';
 export * from './numbers';
 export * from './focusable';
+export * from './styles';

package/esm/core/utils/functions/index.js

@@ -6,3 +6,4 @@ export * from './dom';
 export * from './colors';
 export * from './numbers';
 export * from './focusable';
+export * from './styles';

package/esm/core/utils/functions/styles.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns translate values as an array of a given element.
+ * @param element HTML element you want to get translate value of
+ * @returns Translate values in pixels in a array `[translateX, translateY]`
+ */
+export declare const getTranslateValues: (element: HTMLElement | null | undefined) => number[];

package/esm/core/utils/functions/styles.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Returns translate values as an array of a given element.
+ * @param element HTML element you want to get translate value of
+ * @returns Translate values in pixels in a array `[translateX, translateY]`
+ */
+export var getTranslateValues = function (element) {
+    if (!element) {
+        return [];
+    }
+    var transformValue = getComputedStyle(element).getPropertyValue('transform');
+    var matrix = new DOMMatrix(transformValue);
+    return [matrix.m41, matrix.m42];
+};

package/esm/core/utils/hooks/useContainerWidth.d.ts

@@ -13,5 +13,5 @@
  * ... // do something with width
  * return <div ref={ref}>...</div>;
  */
-export declare const useContainerWidth: <T extends HTMLElement>(watchResizes?: boolean) => readonly [(instance: HTMLElement | null) => void, number];
+export declare const useContainerWidth: <T extends HTMLElement>(watchResizes?: boolean) => readonly [(instance: HTMLElement | null | undefined) => void, number];
 export default useContainerWidth;

package/esm/core/utils/hooks/useDragAndDrop.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+/**
+ * Helper hook that handles elements drag logic.
+ * @param elementRef Element ref that is draggable.
+ * @param containerRect Bounding rectangle of container element that element can't go outside. If not passed window is used as a container.
+ * @returns
+ * `onPointerDown` - handler that is called when pointer is down and handles all the dragging logic.
+ * `transform` - current transform of the element, it is used to preserve drag position when element visibility is being toggled.
+ */
+export declare const useDragAndDrop: (elementRef: React.RefObject<HTMLElement>, containerRef?: React.RefObject<HTMLElement>, enabled?: boolean) => {
+    onPointerDown: (e: React.PointerEvent<HTMLElement>) => void;
+    transform: string;
+};
+export default useDragAndDrop;

package/esm/core/utils/hooks/useDragAndDrop.js

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import React from 'react';
+import { getTranslateValues, getWindow } from '../functions';
+import { useEventListener } from './useEventListener';
+import { useResizeObserver } from './useResizeObserver';
+var getContainerRect = function (containerRef) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var containerRect = (_a = containerRef === null || containerRef === void 0 ? void 0 : containerRef.current) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
+    return {
+        top: (_b = containerRect === null || containerRect === void 0 ? void 0 : containerRect.top) !== null && _b !== void 0 ? _b : 0,
+        right: (_e = (_c = containerRect === null || containerRect === void 0 ? void 0 : containerRect.right) !== null && _c !== void 0 ? _c : (_d = getWindow()) === null || _d === void 0 ? void 0 : _d.innerWidth) !== null && _e !== void 0 ? _e : 0,
+        bottom: (_h = (_f = containerRect === null || containerRect === void 0 ? void 0 : containerRect.bottom) !== null && _f !== void 0 ? _f : (_g = getWindow()) === null || _g === void 0 ? void 0 : _g.innerHeight) !== null && _h !== void 0 ? _h : 0,
+        left: (_j = containerRect === null || containerRect === void 0 ? void 0 : containerRect.left) !== null && _j !== void 0 ? _j : 0,
+    };
+};
+/**
+ * Helper hook that handles elements drag logic.
+ * @param elementRef Element ref that is draggable.
+ * @param containerRect Bounding rectangle of container element that element can't go outside. If not passed window is used as a container.
+ * @returns
+ * `onPointerDown` - handler that is called when pointer is down and handles all the dragging logic.
+ * `transform` - current transform of the element, it is used to preserve drag position when element visibility is being toggled.
+ */
+export var useDragAndDrop = function (elementRef, containerRef, enabled) {
+    if (enabled === void 0) { enabled = true; }
+    var grabOffsetX = React.useRef(0);
+    var grabOffsetY = React.useRef(0);
+    var translateX = React.useRef();
+    var translateY = React.useRef();
+    var containerRectRef = React.useRef(getContainerRect(containerRef));
+    var adjustTransform = React.useCallback(function () {
+        var _a;
+        if (!elementRef.current || !enabled) {
+            return;
+        }
+        var _b = (_a = elementRef.current) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect(), top = _b.top, right = _b.right, bottom = _b.bottom, left = _b.left;
+        var _c = getTranslateValues(elementRef.current), newTranslateX = _c[0], newTranslateY = _c[1];
+        containerRectRef.current = getContainerRect(containerRef);
+        if (bottom > containerRectRef.current.bottom) {
+            newTranslateY -= bottom - containerRectRef.current.bottom;
+        }
+        if (top < containerRectRef.current.top) {
+            newTranslateY += containerRectRef.current.top - top;
+        }
+        if (right > containerRectRef.current.right) {
+            newTranslateX -= right - containerRectRef.current.right;
+        }
+        if (left < containerRectRef.current.left) {
+            newTranslateX += containerRectRef.current.left - left;
+        }
+        translateX.current = newTranslateX;
+        translateY.current = newTranslateY;
+        elementRef.current.style.transform = "translate(".concat(newTranslateX, "px, ").concat(newTranslateY, "px)");
+    }, [containerRef, elementRef, enabled]);
+    var _a = useResizeObserver(adjustTransform), resizeRef = _a[0], resizeObserver = _a[1];
+    resizeRef(containerRef === null || containerRef === void 0 ? void 0 : containerRef.current);
+    React.useEffect(function () {
+        return function () {
+            resizeObserver === null || resizeObserver === void 0 ? void 0 : resizeObserver.disconnect();
+        };
+    }, [resizeObserver]);
+    useEventListener('resize', function () {
+        adjustTransform();
+        if (translateX.current != null && translateY.current != null) {
+            setTransform("translate(".concat(translateX.current, "px, ").concat(translateY.current, "px)"));
+        }
+    }, getWindow());
+    var _b = React.useState(''), transform = _b[0], setTransform = _b[1];
+    var onPointerMove = React.useRef(function (event) {
+        if (!elementRef.current) {
+            return;
+        }
+        var newTranslateX = event.clientX - grabOffsetX.current;
+        var newTranslateY = event.clientY - grabOffsetY.current;
+        elementRef.current.style.transform = "translate(".concat(newTranslateX, "px, ").concat(newTranslateY, "px)");
+        adjustTransform();
+    });
+    var originalUserSelect = React.useRef('');
+    var onPointerDown = React.useCallback(function (e) {
+        if (!elementRef.current || e.button !== 0 || !enabled) {
+            return;
+        }
+        var _a = getTranslateValues(elementRef.current), x = _a[0], y = _a[1];
+        grabOffsetX.current = e.clientX - x;
+        grabOffsetY.current = e.clientY - y;
+        originalUserSelect.current = elementRef.current.style.userSelect;
+        // Prevents from selecting inner content when dragging.
+        elementRef.current.style.userSelect = 'none';
+        elementRef.current.ownerDocument.addEventListener('pointermove', onPointerMove.current);
+        elementRef.current.ownerDocument.addEventListener('pointerup', function () {
+            setTransform("translate(".concat(translateX.current, "px, ").concat(translateY.current, "px)"));
+            document.removeEventListener('pointermove', onPointerMove.current);
+            if (elementRef.current) {
+                elementRef.current.style.userSelect = originalUserSelect.current;
+            }
+        }, { once: true });
+    }, [elementRef, enabled]);
+    return { onPointerDown: onPointerDown, transform: transform };
+};
+export default useDragAndDrop;

package/esm/core/utils/hooks/useEventListener.d.ts

@@ -7,4 +7,4 @@
  *     containerRef.current?.ownerDocument,
  *  );
  */
-export declare const useEventListener: (eventName: string, handler: (event: Event) => void, element: HTMLElement | Document | undefined) => void;
+export declare const useEventListener: (eventName: string, handler: (event: Event) => void, element: HTMLElement | Document | Window | undefined) => void;

package/esm/core/utils/hooks/useOverflow.d.ts

@@ -21,4 +21,4 @@ import React from 'react';
  *   </div>
  * );
  */
-export declare const useOverflow: <T extends HTMLElement>(items: React.ReactNode[] | string, disabled?: boolean, orientation?: 'horizontal' | 'vertical') => readonly [(instance: T | null) => void, number];
+export declare const useOverflow: <T extends HTMLElement>(items: React.ReactNode[] | string, disabled?: boolean, orientation?: 'horizontal' | 'vertical') => readonly [(instance: T | null | undefined) => void, number];

package/esm/core/utils/hooks/useResizeObserver.d.ts

@@ -10,4 +10,4 @@
  * ...
  * return <div ref={ref}>...</div>;
  */
-export declare const useResizeObserver: <T extends HTMLElement>(onResize: (size: DOMRectReadOnly) => void) => readonly [(element: T | null) => void, ResizeObserver | undefined];
+export declare const useResizeObserver: <T extends HTMLElement>(onResize: (size: DOMRectReadOnly) => void) => readonly [(element: T | null | undefined) => void, ResizeObserver | undefined];

package/esm/types/react-table-config.d.ts

@@ -19,7 +19,7 @@ declare module 'react-table' {
          */
         isDisabled?: (rowData: D) => boolean;
     };
-    interface TableOptions<D extends object = {}> extends Omit<UseTableOptions<D>, 'data'>, UseRowSelectOptions<D>, UseExpandedOptions<D>, UseFiltersOptions<D>, UsePaginationOptions<D>, Omit<UseResizeColumnsOptions<D>, 'disableResizing'>, UseSortByOptions<D> {
+    interface TableOptions<D extends object = {}> extends Omit<UseTableOptions<D>, 'data'>, UseRowSelectOptions<D>, UseExpandedOptions<D>, UseFiltersOptions<D>, UsePaginationOptions<D>, UseGlobalFiltersOptions<D>, UseGlobalFiltersColumnOptions<D>, Omit<UseResizeColumnsOptions<D>, 'disableResizing'>, UseSortByOptions<D> {
         /**
          * Table data list.
          * Must be memoized.
@@ -28,11 +28,22 @@ declare module 'react-table' {
          * If some rows don't have sub-data, it is recommended to pass an empty array to `subRows` for consistent spacing.
          */
         data: D[];
+        /**
+         * Column's resize mode.
+         *  - `fit` - when resizing it affects current and the next column,
+         *   e.g. when increasing width of current column, next column's width will decrease.
+         *  - `expand` - when resizing it affects only the current column,
+         *   e.g. when increasing width of the current column, next column's width remains the same.
+         * @default 'fit'
+         */
+        columnResizeMode?: 'fit' | 'expand';
     }
     interface Hooks<D extends object = {}> extends UseExpandedHooks<D>, UseGroupByHooks<D>, UseRowSelectHooks<D>, UseSortByHooks<D> {
     }
     interface TableInstance<D extends object = {}> extends UseColumnOrderInstanceProps<D>, UseExpandedInstanceProps<D>, UseFiltersInstanceProps<D>, UseGlobalFiltersInstanceProps<D>, UseGroupByInstanceProps<D>, UsePaginationInstanceProps<D>, UseRowSelectInstanceProps<D>, UseRowStateInstanceProps<D>, UseSortByInstanceProps<D> {
         initialRows: Row<D>[];
+        columnResizeMode: TableOptions['columnResizeMode'];
+        tableWidth: number;
     }
     interface TableState<D extends object = {}> extends UseColumnOrderState<D>, UseExpandedState<D>, UseFiltersState<D>, UseGlobalFiltersState<D>, UseGroupByState<D>, UsePaginationState<D>, UseRowSelectState<D>, UseRowStateState<D>, UseSortByState<D> {
         columnResizing: {
@@ -50,6 +61,7 @@ declare module 'react-table' {
             isScrolledToRight?: boolean;
             isScrolledToLeft?: boolean;
         };
+        lastSelectedRowId?: string;
     }
     interface ColumnInterface<D extends object = {}> extends UseSortByColumnOptions<D>, UseFiltersColumnOptions<D>, UseResizeColumnsColumnOptions<D> {
         /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itwin/itwinui-react",
-  "version": "1.45.0",
+  "version": "1.47.0",
   "author": "Bentley Systems",
   "license": "MIT",
   "main": "cjs/index.js",