@itwin/itwinui-react 1.38.0 → 1.40.0

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

@@ -25,12 +25,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VirtualScroll = void 0;
+exports.useVirtualization = exports.VirtualScroll = 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 react_1 = __importDefault(require("react"));
+var hooks_1 = require("../hooks");
 var useResizeObserver_1 = require("../hooks/useResizeObserver");
 var getScrollableParent = function (element, ownerDocument) {
     if (ownerDocument === void 0) { ownerDocument = document; }
@@ -52,6 +53,14 @@ var getElementHeight = function (element) {
     var _a;
     return (_a = element === null || element === void 0 ? void 0 : element.getBoundingClientRect().height) !== null && _a !== void 0 ? _a : 0;
 };
+var getElementHeightWithMargins = function (element) {
+    if (!element) {
+        return undefined;
+    }
+    var margin = parseFloat(getElementStyle(element, 'margin-top')) +
+        parseFloat(getElementStyle(element, 'margin-bottom'));
+    return getElementHeight(element) + (isNaN(margin) ? 0 : margin);
+};
 var getNumberOfNodesInHeight = function (childHeight, totalHeight) {
     if (!childHeight) {
         return 0;
@@ -59,7 +68,10 @@ var getNumberOfNodesInHeight = function (childHeight, totalHeight) {
     return Math.floor(totalHeight / childHeight);
 };
 var getTranslateValue = function (childHeight, startIndex) {
-    return childHeight * startIndex;
+    if (startIndex > 0) {
+        return childHeight * startIndex;
+    }
+    return 0;
 };
 var getVisibleNodeCount = function (childHeight, startIndex, childrenLength, scrollContainer) {
     return Math.min(childrenLength - startIndex, getNumberOfNodesInHeight(childHeight, getElementHeight(scrollContainer)));
@@ -85,21 +97,55 @@ var getVisibleNodeCount = function (childHeight, startIndex, childrenLength, scr
  * />
  * @private
  */
-exports.VirtualScroll = react_1.default.forwardRef(function (_a, ref) {
-    var itemsLength = _a.itemsLength, itemRenderer = _a.itemRenderer, _b = _a.bufferSize, bufferSize = _b === void 0 ? 10 : _b, style = _a.style, rest = __rest(_a, ["itemsLength", "itemRenderer", "bufferSize", "style"]);
-    var _c = react_1.default.useState(0), startNode = _c[0], setStartNode = _c[1];
-    var _d = react_1.default.useState(0), visibleNodeCount = _d[0], setVisibleNodeCount = _d[1];
+exports.VirtualScroll = react_1.default.forwardRef(function (props, ref) {
+    var _a = (0, exports.useVirtualization)(props), innerProps = _a.innerProps, outerProps = _a.outerProps, visibleChildren = _a.visibleChildren;
+    return (react_1.default.createElement("div", __assign({}, outerProps, { ref: ref }),
+        react_1.default.createElement("div", __assign({}, innerProps), visibleChildren)));
+});
+/**
+ * `useVirtualization` is used for efficiently rendering only the visible rows from a large list.
+ * It returns `outerProps` and `innerProps`, which need to be applied on 2 container elements and `visibleChildren` which is a list of virtualized items.
+ * @example
+ * const itemRenderer = React.useCallback((index: number) => (
+ *  <li key={index}>
+ *    This is my item #{index}
+ *  </li>
+ * ), [])
+ *
+ * const { outerProps, innerProps, visibleChildren } = useVirtualization({itemsLength: 1000, itemRenderer: itemRenderer});
+ * return (
+ *  <div {...outerProps}>
+ *   <ul {...innerProps}>
+ *    {visibleChildren}
+ *   </ul>
+ *  </div>
+ * );
+ * @private
+ */
+var useVirtualization = function (props) {
+    var itemsLength = props.itemsLength, itemRenderer = props.itemRenderer, _a = props.bufferSize, bufferSize = _a === void 0 ? 10 : _a, scrollToIndex = props.scrollToIndex, style = props.style, rest = __rest(props, ["itemsLength", "itemRenderer", "bufferSize", "scrollToIndex", "style"]);
+    var _b = react_1.default.useState(0), startNode = _b[0], setStartNode = _b[1];
+    var _c = react_1.default.useState(0), visibleNodeCount = _c[0], setVisibleNodeCount = _c[1];
     var scrollContainer = react_1.default.useRef();
     var parentRef = react_1.default.useRef(null);
-    var childHeight = react_1.default.useRef(0);
+    var childHeight = react_1.default.useRef({ first: 0, middle: 0, last: 0 });
     var onScrollRef = react_1.default.useRef();
     // Used only to recalculate on resize
-    var _e = react_1.default.useState(0), scrollContainerHeight = _e[0], setScrollContainerHeight = _e[1];
+    var _d = react_1.default.useState(0), scrollContainerHeight = _d[0], setScrollContainerHeight = _d[1];
+    var visibleIndex = react_1.default.useRef({ start: 0, end: 0 });
+    // Used to mark when scroll container has height (updated by resize observer)
+    // because before that calculations are not right
+    var _e = react_1.default.useState(false), isMounted = _e[0], setIsMounted = _e[1];
     var onResize = react_1.default.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 resizeRef = (0, useResizeObserver_1.useResizeObserver)(onResize)[0];
+    var _f = (0, useResizeObserver_1.useResizeObserver)(onResize), resizeRef = _f[0], resizeObserver = _f[1];
     // Find scrollable parent
     // Needed only on init
     react_1.default.useLayoutEffect(function () {
@@ -108,6 +154,14 @@ exports.VirtualScroll = react_1.default.forwardRef(function (_a, ref) {
         scrollContainer.current = scrollableParent;
         resizeRef(scrollableParent);
     }, [resizeRef]);
+    // Stop watching resize, when virtual scroll is unmounted
+    react_1.default.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;
+    };
     var visibleChildren = react_1.default.useMemo(function () {
         var arr = [];
         var endIndex = Math.min(itemsLength, startNode + visibleNodeCount + bufferSize * 2);
@@ -118,27 +172,42 @@ exports.VirtualScroll = react_1.default.forwardRef(function (_a, ref) {
     }, [itemsLength, itemRenderer, bufferSize, startNode, visibleNodeCount]);
     // Get child height when children available
     react_1.default.useLayoutEffect(function () {
+        var _a, _b, _c, _d, _e, _f;
         if (!parentRef.current || !visibleChildren.length) {
             return;
         }
         var firstChild = parentRef.current.children.item(0);
-        childHeight.current = Number(getElementHeight(firstChild).toFixed(2));
+        var secondChild = parentRef.current.children.item(1);
+        var lastChild = parentRef.current.children.item(parentRef.current.children.length - 1);
+        var firstChildHeight = Number((_b = (_a = getElementHeightWithMargins(firstChild)) === null || _a === void 0 ? void 0 : _a.toFixed(2)) !== null && _b !== void 0 ? _b : 0);
+        childHeight.current = {
+            first: firstChildHeight,
+            middle: Number((_d = (_c = getElementHeightWithMargins(secondChild)) === null || _c === void 0 ? void 0 : _c.toFixed(2)) !== null && _d !== void 0 ? _d : firstChildHeight),
+            last: Number((_f = (_e = getElementHeightWithMargins(lastChild)) === null || _e === void 0 ? void 0 : _e.toFixed(2)) !== null && _f !== void 0 ? _f : firstChildHeight),
+        };
     }, [visibleChildren.length]);
     var updateVirtualScroll = react_1.default.useCallback(function () {
-        var _a, _b;
-        var scrollableContainer = (_a = scrollContainer.current) !== null && _a !== void 0 ? _a : (_b = parentRef.current) === null || _b === void 0 ? void 0 : _b.ownerDocument.scrollingElement;
+        var scrollableContainer = getScrollableContainer();
         if (!scrollableContainer) {
             return;
         }
-        var start = getNumberOfNodesInHeight(childHeight.current, scrollableContainer.scrollTop);
-        var startIndex = Math.max(0, start - bufferSize);
+        var start = getNumberOfNodesInHeight(childHeight.current.middle, Math.round(scrollableContainer.scrollTop));
+        var visibleNodes = getVisibleNodeCount(childHeight.current.middle, start, itemsLength, scrollableContainer);
+        // If there are less items at the end than buffer size
+        // show more items at the start.
+        // Have boundaries for edge cases, e.g. 1 item length
+        var startIndex = Math.min(Math.max(0, start - bufferSize), Math.max(0, itemsLength - bufferSize * 2 - visibleNodes));
+        visibleIndex.current = { start: start, end: start + visibleNodes };
         setStartNode(startIndex);
-        setVisibleNodeCount(getVisibleNodeCount(childHeight.current, start, itemsLength, scrollableContainer));
+        setVisibleNodeCount(visibleNodes);
         if (!parentRef.current) {
             return;
         }
-        parentRef.current.style.transform = "translateY(".concat(getTranslateValue(childHeight.current, startIndex), "px)");
+        parentRef.current.style.transform = "translateY(".concat(getTranslateValue(childHeight.current.middle, startIndex), "px)");
     }, [bufferSize, itemsLength]);
+    var onScroll = react_1.default.useCallback(function () {
+        updateVirtualScroll();
+    }, [updateVirtualScroll]);
     var removeScrollListener = react_1.default.useCallback(function () {
         var _a, _b;
         if (!onScrollRef.current) {
@@ -153,22 +222,86 @@ exports.VirtualScroll = react_1.default.forwardRef(function (_a, ref) {
     react_1.default.useLayoutEffect(function () {
         var _a, _b;
         removeScrollListener();
-        onScrollRef.current = updateVirtualScroll;
+        onScrollRef.current = onScroll;
         if (!scrollContainer.current ||
             scrollContainer.current === ((_a = parentRef.current) === null || _a === void 0 ? void 0 : _a.ownerDocument.body)) {
-            (_b = parentRef.current) === null || _b === void 0 ? void 0 : _b.ownerDocument.addEventListener('scroll', updateVirtualScroll);
+            (_b = parentRef.current) === null || _b === void 0 ? void 0 : _b.ownerDocument.addEventListener('scroll', onScroll);
         }
         else {
-            scrollContainer.current.addEventListener('scroll', updateVirtualScroll);
+            scrollContainer.current.addEventListener('scroll', onScroll);
         }
         return removeScrollListener;
-    }, [updateVirtualScroll, removeScrollListener]);
+    }, [onScroll, removeScrollListener]);
+    react_1.default.useLayoutEffect(function () {
+        if (!isMounted) {
+            return;
+        }
+        var scrollableContainer = getScrollableContainer();
+        if (!scrollableContainer || scrollToIndex == null) {
+            return;
+        }
+        // if `scrollToIndex` is not visible, scroll to it
+        if (scrollToIndex > visibleIndex.current.end ||
+            scrollToIndex < visibleIndex.current.start) {
+            var indexDiff = scrollToIndex > visibleIndex.current.end
+                ? scrollToIndex - visibleIndex.current.end
+                : scrollToIndex - visibleIndex.current.start;
+            if (scrollToIndex === 0) {
+                scrollableContainer.scrollTo({ top: 0 });
+                return;
+            }
+            // If go down: add to the existing scrollTop needed height
+            // If go up: calculate the exact scroll top
+            scrollableContainer.scrollTo({
+                top: indexDiff > 0
+                    ? Math.ceil(scrollableContainer.scrollTop) +
+                        indexDiff * childHeight.current.middle
+                    : scrollToIndex * childHeight.current.middle,
+            });
+        }
+        // if `scrollToIndex` is the first visible node
+        // ensure it is fully visible
+        if (scrollToIndex === visibleIndex.current.start) {
+            var roundedScrollTop = Math.round(scrollableContainer.scrollTop);
+            var diff = roundedScrollTop % childHeight.current.middle;
+            diff > 0 &&
+                scrollableContainer.scrollTo({
+                    top: roundedScrollTop - diff,
+                });
+            return;
+        }
+        // if `scrollToIndex` is the last visible node
+        // ensure it is fully visible
+        if (scrollToIndex === visibleIndex.current.end) {
+            var diff = (scrollableContainer.offsetHeight - childHeight.current.first) %
+                childHeight.current.middle;
+            var roundedScrollTop = Math.ceil(scrollableContainer.scrollTop);
+            var scrollTopMod = roundedScrollTop % childHeight.current.middle;
+            if (diff > 0 && scrollTopMod === 0) {
+                scrollableContainer.scrollTo({
+                    top: roundedScrollTop + childHeight.current.middle - diff,
+                });
+            }
+        }
+    }, [scrollToIndex, isMounted]);
     react_1.default.useLayoutEffect(function () {
+        if (!scrollContainerHeight) {
+            return;
+        }
         updateVirtualScroll();
-    }, [scrollContainerHeight, itemsLength, updateVirtualScroll]);
-    return (react_1.default.createElement("div", __assign({ style: __assign({ overflow: 'hidden', minHeight: itemsLength * childHeight.current, width: '100%' }, style), ref: ref }, rest),
-        react_1.default.createElement("div", { style: {
-                willChange: 'transform',
-            }, ref: parentRef }, visibleChildren)));
-});
+    }, [scrollContainerHeight, updateVirtualScroll]);
+    return {
+        outerProps: __assign({ style: __assign({ overflow: 'hidden', minHeight: itemsLength > 1
+                    ? Math.max(itemsLength - 2, 0) * childHeight.current.middle +
+                        childHeight.current.first +
+                        childHeight.current.last
+                    : childHeight.current.middle, width: '100%' }, style) }, rest),
+        innerProps: {
+            style: { willChange: 'transform' },
+            ref: (0, hooks_1.mergeRefs)(parentRef), // convert object ref to callback ref for better types
+        },
+        visibleChildren: visibleChildren,
+    };
+};
+exports.useVirtualization = useVirtualization;
 exports.default = exports.VirtualScroll;

package/cjs/core/utils/components/VisuallyHidden.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export declare type VisuallyHiddenProps = React.ComponentPropsWithRef<'div'>;
+/**
+ * Hides content visually but is still accessible to screen readers.
+ */
+export declare const VisuallyHidden: React.ForwardRefExoticComponent<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | React.RefObject<HTMLDivElement> | null | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>>;
+export default VisuallyHidden;

package/cjs/core/utils/components/VisuallyHidden.js

@@ -0,0 +1,44 @@
+"use strict";
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisuallyHidden = 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 react_1 = __importDefault(require("react"));
+var classnames_1 = __importDefault(require("classnames"));
+var hooks_1 = require("../hooks");
+/**
+ * Hides content visually but is still accessible to screen readers.
+ */
+exports.VisuallyHidden = react_1.default.forwardRef(function (props, ref) {
+    var className = props.className, rest = __rest(props, ["className"]);
+    (0, hooks_1.useTheme)();
+    return (react_1.default.createElement("div", __assign({ className: (0, classnames_1.default)('iui-visually-hidden', className), ref: ref }, rest)));
+});
+exports.default = exports.VisuallyHidden;

package/cjs/core/utils/components/WithCSSTransition.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="react" />
-import { CSSTransition } from 'react-transition-group';
 import { CSSTransitionProps } from 'react-transition-group/CSSTransition';
-export declare const WithCSSTransition: (props: Partial<CSSTransition.CSSTransitionProps> & {
+export declare const WithCSSTransition: (props: Partial<CSSTransitionProps<undefined>> & {
     children: JSX.Element;
     dimension?: "width" | "height" | undefined;
 }) => JSX.Element;

package/cjs/core/utils/components/icons.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="react" />
 import { CommonProps } from '../props';
 export declare const StatusIconMap: {
-    negative: (args?: CommonProps | undefined) => JSX.Element;
-    positive: (args?: CommonProps | undefined) => JSX.Element;
-    warning: (args?: CommonProps | undefined) => JSX.Element;
-    informational: (args?: CommonProps | undefined) => JSX.Element;
+    negative: (args?: CommonProps) => JSX.Element;
+    positive: (args?: CommonProps) => JSX.Element;
+    warning: (args?: CommonProps) => JSX.Element;
+    informational: (args?: CommonProps) => JSX.Element;
 };

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

@@ -5,3 +5,4 @@ export * from './icons';
 export * from './WithCSSTransition';
 export * from './MiddleTextTruncation';
 export * from './VirtualScroll';
+export * from './VisuallyHidden';

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

@@ -25,3 +25,4 @@ __exportStar(require("./icons"), exports);
 __exportStar(require("./WithCSSTransition"), exports);
 __exportStar(require("./MiddleTextTruncation"), exports);
 __exportStar(require("./VirtualScroll"), exports);
+__exportStar(require("./VisuallyHidden"), exports);

package/cjs/core/utils/hooks/useOverflow.js

@@ -78,8 +78,10 @@ var useOverflow = function (items, disabled, orientation) {
             var childrenSize = Array.from(containerRef.current.children).reduce(function (sum, child) { return sum + child["offset".concat(dimension)]; }, 0);
             var avgItemSize = childrenSize / visibleCount;
             var visibleItems = Math.floor(availableSize / avgItemSize);
-            // Doubling the visible items to overflow the container. Just to be safe.
-            setVisibleCount(Math.min(items.length, visibleItems * 2));
+            if (!isNaN(visibleItems)) {
+                // Doubling the visible items to overflow the container. Just to be safe.
+                setVisibleCount(Math.min(items.length, visibleItems * 2));
+            }
         }
         needsFullRerender.current = false;
     }, [containerSize, visibleCount, disabled, items.length, orientation]);

package/cjs/core/utils/hooks/useTheme.d.ts

@@ -19,4 +19,4 @@ export declare type ThemeType = 'light' | 'dark' | 'os';
  * @param theme Light, dark, or based on OS setting.
  * @param themeOptions Options that override default theming behavior.
  */
-export declare const useTheme: (theme?: ThemeType | undefined, themeOptions?: ThemeOptions | undefined) => void;
+export declare const useTheme: (theme?: ThemeType, themeOptions?: ThemeOptions) => void;

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

@@ -46,6 +46,10 @@ declare module 'react-table' {
         };
         isTableResizing?: boolean;
         columnReorderStartIndex: number;
+        sticky: {
+            isScrolledToRight?: boolean;
+            isScrolledToLeft?: boolean;
+        };
     }
     interface ColumnInterface<D extends object = {}> extends UseSortByColumnOptions<D>, UseFiltersColumnOptions<D>, UseResizeColumnsColumnOptions<D> {
         /**
@@ -91,12 +95,17 @@ declare module 'react-table' {
          * @default false
          */
         disableToggleVisibility?: boolean;
+        /**
+         * Side on which column should be sticked to.
+         */
+        sticky?: 'left' | 'right';
     }
     interface ColumnInstance<D extends object = {}> extends UseFiltersColumnProps<D>, UseGroupByColumnProps<D>, UseResizeColumnsColumnProps<D>, UseSortByColumnProps<D> {
         originalWidth: number;
         resizeWidth?: number;
         isResizerVisible?: boolean;
         getDragAndDropProps: () => TableKeyedProps;
+        originalSticky?: 'left' | 'right' | 'none';
     }
     interface Cell<D extends object = {}> extends UseGroupByCellProps<D>, UseRowStateCellProps<D> {
     }

package/esm/core/Carousel/Carousel.js

@@ -58,19 +58,24 @@ export var Carousel = Object.assign(React.forwardRef(function (props, ref) {
     var id = React.useState(function () { var _a; return (_a = props.id) !== null && _a !== void 0 ? _a : "iui-carousel-".concat(getRandomValue(10)); })[0];
     useTheme();
     var isManuallyUpdating = React.useRef(false);
-    var scrollInstantly = React.useRef(false);
     var carouselRef = React.useRef(null);
     var refs = useMergedRefs(carouselRef, ref);
-    var _b = React.useState(userActiveIndex), currentIndex = _b[0], _setCurrentIndex = _b[1];
+    var _b = React.useState(userActiveIndex), currentIndex = _b[0], setCurrentIndex = _b[1];
+    var scrollToSlide = React.useRef(function () { }); // stub function populated in CarouselSlider
+    var justMounted = React.useRef(true);
     React.useEffect(function () {
-        _setCurrentIndex(userActiveIndex);
-    }, [userActiveIndex]);
-    var setCurrentIndex = React.useCallback(function (index) {
         var _a;
-        _setCurrentIndex(index);
-        isManuallyUpdating.current = true;
-        (_a = carouselRef.current) === null || _a === void 0 ? void 0 : _a.focus();
-    }, []);
+        setCurrentIndex(userActiveIndex);
+        scrollToSlide.current(userActiveIndex, {
+            instant: justMounted.current,
+        });
+        // re-focus the carousel for keyboard nav, but not on first mount
+        // because it shows outline and might interfere with other components
+        if (!justMounted.current) {
+            (_a = carouselRef.current) === null || _a === void 0 ? void 0 : _a.focus({ preventScroll: true });
+        }
+        justMounted.current = false;
+    }, [userActiveIndex]);
     var _c = React.useState(0), slideCount = _c[0], setSlideCount = _c[1];
     var _d = React.useState({}), keysPressed = _d[0], setKeysPressed = _d[1];
     var handleKeyDown = function (event) {
@@ -88,12 +93,16 @@ export var Carousel = Object.assign(React.forwardRef(function (props, ref) {
         switch (event.key) {
             case 'ArrowLeft': {
                 setKeysPressed(function (old) { return (__assign(__assign({}, old), { ArrowLeft: false })); });
-                setCurrentIndex(function (old) { return (slideCount + old - 1) % slideCount; });
+                var prevIndex = (slideCount + currentIndex - 1) % slideCount;
+                scrollToSlide.current(prevIndex);
+                setCurrentIndex(prevIndex);
                 break;
             }
             case 'ArrowRight': {
                 setKeysPressed(function (old) { return (__assign(__assign({}, old), { ArrowRight: false })); });
-                setCurrentIndex(function (old) { return (slideCount + old + 1) % slideCount; });
+                var nextIndex = (slideCount + currentIndex + 1) % slideCount;
+                scrollToSlide.current(nextIndex);
+                setCurrentIndex(nextIndex);
                 break;
             }
         }
@@ -112,7 +121,7 @@ export var Carousel = Object.assign(React.forwardRef(function (props, ref) {
                 keysPressed: keysPressed,
                 idPrefix: id,
                 isManuallyUpdating: isManuallyUpdating,
-                scrollInstantly: scrollInstantly,
+                scrollToSlide: scrollToSlide,
             } }, children)));
 }), {
     Slider: CarouselSlider,

package/esm/core/Carousel/CarouselContext.d.ts

@@ -31,7 +31,9 @@ export declare const CarouselContext: React.Context<{
      */
     isManuallyUpdating: React.MutableRefObject<boolean>;
     /**
-     * Ref object used to skip smooth scrolling when button is clicked too many times.
+     * Function that scrolls to the current slide. Should be called on all managed events (clicks and keydowns).
      */
-    scrollInstantly: React.MutableRefObject<boolean>;
+    scrollToSlide: React.MutableRefObject<(slideIndex: number, options?: {
+        instant?: boolean;
+    }) => void>;
 } | undefined>;

package/esm/core/Carousel/CarouselDotsList.js

@@ -63,6 +63,7 @@ export var CarouselDotsList = React.forwardRef(function (props, ref) {
     var handleSlideChange = React.useCallback(function (index) {
         if (context) {
             context.setCurrentIndex(index);
+            context.scrollToSlide.current(index);
         }
         onSlideChange === null || onSlideChange === void 0 ? void 0 : onSlideChange(index);
     }, [context, onSlideChange]);

package/esm/core/Carousel/CarouselNavigation.js

@@ -37,13 +37,12 @@ var PreviousButton = React.forwardRef(function (props, ref) {
     if (!context) {
         throw new Error('CarouselNavigation should be used inside Carousel');
     }
-    var slideCount = context.slideCount, setCurrentIndex = context.setCurrentIndex, keysPressed = context.keysPressed, scrollInstantly = context.scrollInstantly;
+    var slideCount = context.slideCount, currentIndex = context.currentIndex, setCurrentIndex = context.setCurrentIndex, keysPressed = context.keysPressed, scrollToSlide = context.scrollToSlide;
     return (React.createElement(IconButton, __assign({ styleType: 'borderless', size: 'small', tabIndex: -1, "data-pressed": keysPressed['ArrowLeft'] || undefined, ref: ref }, props, { onClick: function (e) {
             var _a;
-            if (e.detail > 3) {
-                scrollInstantly.current = true;
-            }
-            setCurrentIndex(function (old) { return (slideCount + old - 1) % slideCount; });
+            var prevIndex = (slideCount + currentIndex - 1) % slideCount;
+            setCurrentIndex(prevIndex);
+            scrollToSlide.current(prevIndex, { instant: e.detail > 3 });
             (_a = props === null || props === void 0 ? void 0 : props.onClick) === null || _a === void 0 ? void 0 : _a.call(props, e);
         } }),
         React.createElement(SvgChevronLeft, null)));
@@ -54,13 +53,12 @@ var NextButton = React.forwardRef(function (props, ref) {
     if (!context) {
         throw new Error('CarouselNavigation should be used inside Carousel');
     }
-    var slideCount = context.slideCount, setCurrentIndex = context.setCurrentIndex, keysPressed = context.keysPressed, scrollInstantly = context.scrollInstantly;
+    var slideCount = context.slideCount, currentIndex = context.currentIndex, setCurrentIndex = context.setCurrentIndex, keysPressed = context.keysPressed, scrollToSlide = context.scrollToSlide;
     return (React.createElement(IconButton, __assign({ styleType: 'borderless', size: 'small', tabIndex: -1, "data-pressed": keysPressed['ArrowRight'] || undefined, ref: ref }, props, { onClick: function (e) {
             var _a;
-            if (e.detail > 3) {
-                scrollInstantly.current = true;
-            }
-            setCurrentIndex(function (old) { return (slideCount + old + 1) % slideCount; });
+            var nextIndex = (slideCount + currentIndex + 1) % slideCount;
+            setCurrentIndex(nextIndex);
+            scrollToSlide.current(nextIndex, { instant: e.detail > 3 });
             (_a = props === null || props === void 0 ? void 0 : props.onClick) === null || _a === void 0 ? void 0 : _a.call(props, e);
         } }),
         React.createElement(SvgChevronRight, null)));

package/esm/core/Carousel/CarouselSlide.js

@@ -40,17 +40,13 @@ export var CarouselSlide = React.forwardRef(function (props, ref) {
     if (!context || index == null) {
         throw new Error('CarouselSlide must be used within Carousel');
     }
-    var currentIndex = context.currentIndex, isManuallyUpdating = context.isManuallyUpdating, setCurrentIndex = context.setCurrentIndex;
+    var isManuallyUpdating = context.isManuallyUpdating, setCurrentIndex = context.setCurrentIndex;
     var updateActiveIndexOnScroll = React.useCallback(function () {
         // only update index if scroll was triggered by browser
-        if (!isManuallyUpdating.current && currentIndex !== index) {
+        if (!isManuallyUpdating.current) {
             setCurrentIndex(index);
         }
-        // when manual scroll completes, reset the state of `isManuallyUpdating` so that it's ready for future actions
-        if (currentIndex === index) {
-            isManuallyUpdating.current = false;
-        }
-    }, [currentIndex, index, isManuallyUpdating, setCurrentIndex]);
+    }, [index, isManuallyUpdating, setCurrentIndex]);
     var intersectionRef = useIntersection(updateActiveIndexOnScroll, { threshold: 0.5 }, false);
     var refs = useMergedRefs(intersectionRef, ref);
     return (React.createElement("li", __assign({ className: cx('iui-carousel-slider-item', className), role: 'tabpanel', "aria-roledescription": 'slide', ref: refs }, rest), children));

package/esm/core/Carousel/CarouselSlider.js

@@ -27,7 +27,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 import React from 'react';
 import cx from 'classnames';
 import { CarouselContext } from './CarouselContext';
-import { getWindow, useMergedRefs, useResizeObserver } from '../utils';
+import { getWindow, useMergedRefs } from '../utils';
 /**
  * `CarouselSlider` is the scrollable list that should consist of `CarouselSlide` components.
  */
@@ -37,7 +37,7 @@ export var CarouselSlider = React.forwardRef(function (props, ref) {
     if (!context) {
         throw new Error('CarouselSlider must be used within Carousel');
     }
-    var currentIndex = context.currentIndex, setSlideCount = context.setSlideCount, idPrefix = context.idPrefix, isManuallyUpdating = context.isManuallyUpdating, scrollInstantly = context.scrollInstantly;
+    var setSlideCount = context.setSlideCount, idPrefix = context.idPrefix, scrollToSlide = context.scrollToSlide, isManuallyUpdating = context.isManuallyUpdating;
     var items = React.useMemo(function () {
         var _a;
         return (_a = React.Children.map(children, function (child, index) {
@@ -52,37 +52,32 @@ export var CarouselSlider = React.forwardRef(function (props, ref) {
     React.useLayoutEffect(function () {
         setSlideCount(items.length);
     }, [items.length, setSlideCount]);
-    var _a = React.useState(), width = _a[0], setWidth = _a[1];
-    var resizeRef = useResizeObserver(function (_a) {
-        var width = _a.width;
-        return setWidth(width);
-    })[0];
     var sliderRef = React.useRef(null);
-    var refs = useMergedRefs(sliderRef, resizeRef, ref);
-    var justMounted = React.useRef(true);
-    var previousWidth = React.useRef();
-    React.useLayoutEffect(function () {
-        var _a, _b, _c;
-        var slideToShow = (_a = sliderRef.current) === null || _a === void 0 ? void 0 : _a.children.item(currentIndex);
-        if (!sliderRef.current ||
-            !slideToShow ||
-            (!isManuallyUpdating.current && previousWidth.current === width)) {
+    var refs = useMergedRefs(sliderRef, ref);
+    scrollToSlide.current = function (slideIndex, _a) {
+        var _b, _c, _d;
+        var _e = _a === void 0 ? {} : _a, instant = _e.instant;
+        isManuallyUpdating.current = true; // start manual update
+        var slideToShow = (_b = sliderRef.current) === null || _b === void 0 ? void 0 : _b.children.item(slideIndex);
+        if (!sliderRef.current || !slideToShow) {
             return;
         }
-        // instant scroll on first mount
-        if (justMounted.current) {
-            scrollInstantly.current = true;
-            justMounted.current = false;
-        }
-        var motionOk = (_c = (_b = getWindow()) === null || _b === void 0 ? void 0 : _b.matchMedia('(prefers-reduced-motion: no-preference)')) === null || _c === void 0 ? void 0 : _c.matches;
+        var motionOk = (_d = (_c = getWindow()) === null || _c === void 0 ? void 0 : _c.matchMedia('(prefers-reduced-motion: no-preference)')) === null || _d === void 0 ? void 0 : _d.matches;
         sliderRef.current.scrollTo({
             left: slideToShow.offsetLeft - sliderRef.current.offsetLeft,
-            behavior: (scrollInstantly.current || !motionOk
-                ? 'instant'
-                : 'smooth'), // scrollTo accepts 'instant' but ScrollBehavior type is wrong
+            behavior: (instant || !motionOk ? 'instant' : 'smooth'), // scrollTo accepts 'instant' but ScrollBehavior type is wrong
         });
-        scrollInstantly.current = false;
-        previousWidth.current = width;
-    }, [currentIndex, isManuallyUpdating, scrollInstantly, width]);
-    return (React.createElement("ol", __assign({ "aria-live": 'polite', className: cx('iui-carousel-slider', className), ref: refs }, rest), items));
+    };
+    var scrollTimeout = React.useRef();
+    // reset isManuallyUpdating.current to false after the last scroll event
+    var handleOnScroll = React.useCallback(function () {
+        var _a, _b;
+        if (scrollTimeout.current) {
+            (_a = getWindow()) === null || _a === void 0 ? void 0 : _a.clearTimeout(scrollTimeout.current);
+        }
+        scrollTimeout.current = (_b = getWindow()) === null || _b === void 0 ? void 0 : _b.setTimeout(function () {
+            isManuallyUpdating.current = false;
+        }, 100);
+    }, [isManuallyUpdating]);
+    return (React.createElement("ol", __assign({ "aria-live": 'polite', className: cx('iui-carousel-slider', className), ref: refs, onScroll: handleOnScroll }, rest), items));
 });