@itwin/itwinui-react 1.37.3 → 1.39.0

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

@@ -25,6 +25,7 @@ var __rest = (this && this.__rest) || function (s, e) {
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 import React from 'react';
+import { mergeRefs } from '../hooks';
 import { useResizeObserver } from '../hooks/useResizeObserver';
 var getScrollableParent = function (element, ownerDocument) {
     if (ownerDocument === void 0) { ownerDocument = document; }
@@ -46,6 +47,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;
@@ -53,7 +62,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)));
@@ -79,21 +91,55 @@ var getVisibleNodeCount = function (childHeight, startIndex, childrenLength, scr
  * />
  * @private
  */
-export var VirtualScroll = React.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.useState(0), startNode = _c[0], setStartNode = _c[1];
-    var _d = React.useState(0), visibleNodeCount = _d[0], setVisibleNodeCount = _d[1];
+export var VirtualScroll = React.forwardRef(function (props, ref) {
+    var _a = useVirtualization(props), innerProps = _a.innerProps, outerProps = _a.outerProps, visibleChildren = _a.visibleChildren;
+    return (React.createElement("div", __assign({}, outerProps, { ref: ref }),
+        React.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
+ */
+export 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.useState(0), startNode = _b[0], setStartNode = _b[1];
+    var _c = React.useState(0), visibleNodeCount = _c[0], setVisibleNodeCount = _c[1];
     var scrollContainer = React.useRef();
     var parentRef = React.useRef(null);
-    var childHeight = React.useRef(0);
+    var childHeight = React.useRef({ first: 0, middle: 0, last: 0 });
     var onScrollRef = React.useRef();
     // Used only to recalculate on resize
-    var _e = React.useState(0), scrollContainerHeight = _e[0], setScrollContainerHeight = _e[1];
+    var _d = React.useState(0), scrollContainerHeight = _d[0], setScrollContainerHeight = _d[1];
+    var visibleIndex = React.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.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 resizeRef = useResizeObserver(onResize)[0];
+    var _f = useResizeObserver(onResize), resizeRef = _f[0], resizeObserver = _f[1];
     // Find scrollable parent
     // Needed only on init
     React.useLayoutEffect(function () {
@@ -102,6 +148,14 @@ export var VirtualScroll = React.forwardRef(function (_a, ref) {
         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;
+    };
     var visibleChildren = React.useMemo(function () {
         var arr = [];
         var endIndex = Math.min(itemsLength, startNode + visibleNodeCount + bufferSize * 2);
@@ -112,27 +166,42 @@ export var VirtualScroll = React.forwardRef(function (_a, ref) {
     }, [itemsLength, itemRenderer, bufferSize, startNode, visibleNodeCount]);
     // Get child height when children available
     React.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.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.useCallback(function () {
+        updateVirtualScroll();
+    }, [updateVirtualScroll]);
     var removeScrollListener = React.useCallback(function () {
         var _a, _b;
         if (!onScrollRef.current) {
@@ -147,22 +216,85 @@ export var VirtualScroll = React.forwardRef(function (_a, ref) {
     React.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.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.useLayoutEffect(function () {
+        if (!scrollContainerHeight) {
+            return;
+        }
         updateVirtualScroll();
-    }, [scrollContainerHeight, itemsLength, updateVirtualScroll]);
-    return (React.createElement("div", __assign({ style: __assign({ overflow: 'hidden', minHeight: itemsLength * childHeight.current, width: '100%' }, style), ref: ref }, rest),
-        React.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: mergeRefs(parentRef), // convert object ref to callback ref for better types
+        },
+        visibleChildren: visibleChildren,
+    };
+};
 export default VirtualScroll;

package/esm/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/esm/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/esm/core/utils/hooks/index.d.ts

@@ -6,3 +6,4 @@ export * from './useContainerWidth';
 export * from './useTheme';
 export * from './useIntersection';
 export * from './useMediaQuery';
+export * from './useSafeContext';

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

@@ -10,3 +10,4 @@ export * from './useContainerWidth';
 export * from './useTheme';
 export * from './useIntersection';
 export * from './useMediaQuery';
+export * from './useSafeContext';

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

@@ -72,8 +72,10 @@ export 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/esm/core/utils/hooks/useSafeContext.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+/**
+ * Wrapper hook around `useContext` that throws an error if the context is not provided.
+ * @param context Context to use. Must have a `displayName` for useful errors.
+ */
+export declare const useSafeContext: <T>(context: React.Context<T>) => NonNullable<T>;

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

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ * 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';
+/**
+ * Wrapper hook around `useContext` that throws an error if the context is not provided.
+ * @param context Context to use. Must have a `displayName` for useful errors.
+ */
+export var useSafeContext = function (context) {
+    var value = React.useContext(context);
+    if (!value) {
+        throw new Error("".concat(context.displayName, " is undefined"));
+    }
+    return value; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- we already checked for undefined
+};

package/esm/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itwin/itwinui-react",
-  "version": "1.37.3",
+  "version": "1.39.0",
   "author": "Bentley Systems",
   "license": "MIT",
   "main": "cjs/index.js",
@@ -38,104 +38,61 @@
     "createComponent": "node scripts/createComponent.js",
     "format": "prettier --config .prettierrc **/*.{tsx,ts,js} --ignore-path .gitignore --write",
     "lint": "eslint \"**/*.{js,ts,tsx}\" --max-warnings=0",
-    "lint:fix": "yarn lint --fix && yarn lint:copyright --fix */**/*.{js,ts,tsx}",
-    "lint:copyright": "node scripts/copyrightLinter.js",
-    "copy-files": "cpx \"../../{README,LICENSE}.md\" .",
-    "storybook": "start-storybook -p 6006",
-    "dev": "yarn storybook",
-    "build-storybook": "yarn copy-files && build-storybook"
+    "lint:fix": "yarn lint --fix && node ../configs/copyrightLinter.js --fix \"*/**/*.{js,ts,tsx}\"",
+    "copy-files": "cpy \"../../{README,LICENSE}.md\" .",
+    "dev": "yarn build:watch"
   },
   "dependencies": {
-    "@itwin/itwinui-css": "^0.55.0",
-    "@itwin/itwinui-icons-react": "^1.5.0",
-    "@itwin/itwinui-illustrations-react": "^1.0.1",
+    "@itwin/itwinui-css": "^0.59.1",
+    "@itwin/itwinui-icons-react": "^1.10.1",
+    "@itwin/itwinui-illustrations-react": "^1.3.1",
     "@tippyjs/react": "^4.2.5",
     "@types/react-table": "^7.0.18",
     "classnames": "^2.2.6",
     "react-table": "^7.1.0",
-    "react-transition-group": "^4.1.1"
+    "react-transition-group": "^4.4.2"
   },
   "devDependencies": {
     "@babel/core": "^7.12.10",
-    "@storybook/addon-a11y": "^6.4.19",
-    "@storybook/addon-essentials": "~6.4.19",
-    "@storybook/addon-storysource": "~6.4.19",
-    "@storybook/addons": "~6.4.19",
-    "@storybook/api": "~6.4.19",
-    "@storybook/builder-webpack5": "~6.4.19",
-    "@storybook/components": "~6.4.19",
-    "@storybook/core-events": "~6.4.19",
-    "@storybook/manager-webpack5": "~6.4.19",
-    "@storybook/preset-typescript": "^3.0.0",
-    "@storybook/react": "~6.4.19",
-    "@storybook/theming": "~6.4.19",
-    "@testing-library/jest-dom": "^5.14.1",
-    "@testing-library/react": "^12.0.0",
-    "@testing-library/react-hooks": "^7.0.1",
-    "@testing-library/user-event": "^13.5.0",
+    "@testing-library/jest-dom": "^5.16.4",
+    "@testing-library/react": "^13.2.0",
+    "@testing-library/user-event": "^14.1.1",
     "@types/classnames": "^2.2.7",
     "@types/jest": "^27.0.0",
     "@types/node": "^10.12.2",
-    "@types/react": "^17.0.3",
-    "@types/react-dom": "^17.0.3",
-    "@types/react-transition-group": "^2.9.2",
+    "@types/react": "^18.0.6",
+    "@types/react-dom": "^18.0.2",
+    "@types/react-transition-group": "^4.4.4",
     "@typescript-eslint/eslint-plugin": "^5.17.0",
     "@typescript-eslint/parser": "^5.17.0",
     "babel-loader": "^8.2.2",
     "concurrently": "^5.3.0",
     "configs": "*",
-    "cpx": "^1.5.0",
-    "creevey": "^0.8.0-beta.0",
-    "fast-glob": "^3.2.5",
-    "husky": "^4.0.0",
+    "eslint": "^8.12.0",
+    "eslint-config-prettier": "^8.5.0",
     "inquirer": "^6.2.2",
-    "jest": "^27.0.6",
-    "jest-cli": "^27.0.6",
-    "jest-junit": "^12.0.0",
-    "lint-staged": "^12.1.2",
+    "jest": "^28.1.0",
+    "jest-cli": "^28.1.0",
+    "jest-environment-jsdom": "^28.1.0",
+    "jest-junit": "^13.2.0",
     "markdown-to-jsx": "6.11.4",
-    "mkdirp": "^1.0.4",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
-    "rimraf": "^2.6.2",
-    "storybook-dark-mode": "^1.0.9",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
     "tippy.js": "^6.3.1",
-    "ts-jest": "^27.0.4",
+    "ts-jest": "^28.0.2",
     "ts-loader": "^9.2.8",
     "ts-node": "^8.0.2",
-    "typescript": "^4.4.3",
-    "webpack": "5"
+    "typescript": "^4.4.3"
   },
   "peerDependencies": {
-    "react": "^16.8.6 || ^17.0.0",
-    "react-dom": "^16.8.6 || ^17.0.0"
-  },
-  "resolutions": {
-    "braces": "^2.3.1",
-    "hosted-git-info": ">=3.0.8",
-    "trim": "^0.0.3",
-    "browserslist": "^4.16.6",
-    "glob-parent": "^5.1.2",
-    "css-what": "^5.0.1",
-    "immer": "^9.0.6",
-    "set-value": "^4.1.0",
-    "prismjs": "^1.25.0",
-    "nth-check": "^2.0.1",
-    "ansi-regex": "^5.0.1",
-    "@pmmmwh/react-refresh-webpack-plugin": "^0.5.1",
-    "postcss": "8",
-    "nanoid": "^3.1.31"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
+    "react": ">=16.8.6 < 19.0.0",
+    "react-dom": ">=16.8.6 < 19.0.0"
   },
   "lint-staged": {
     "*.{tsx,ts,jsx,js}": [
       "prettier --write",
       "eslint --max-warnings=0 --fix",
-      "yarn lint:copyright --fix"
+      "node ../configs/copyrightLinter.js --fix"
     ]
   },
   "prettier": "configs/prettier-config",