@carbon/ibm-products 2.17.1 → 2.18.0

package/es/components/Carousel/Carousel.js

@@ -0,0 +1,322 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["children", "className", "disableArrowScroll", "fadedEdgeColor", "onChangeIsScrollable", "onScroll"];
+/**
+ * Copyright IBM Corp. 2023, 2023
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import React, { useCallback, useEffect, useImperativeHandle, useRef } from 'react';
+import PropTypes from 'prop-types';
+import { CarouselItem } from './CarouselItem';
+import cx from 'classnames';
+import { getDevtoolsProps } from '../../global/js/utils/devtools';
+import { pkg } from '../../settings';
+
+// The block part of our conventional BEM class names (blockClass__E--M).
+var blockClass = "".concat(pkg.prefix, "--carousel");
+var componentName = 'Carousel';
+
+// Default values for props
+var defaults = {
+  disableArrowScroll: false,
+  onScroll: function onScroll() {},
+  onChangeIsScrollable: function onChangeIsScrollable() {}
+};
+
+/**
+ * The Carousel acts as a scaffold for other Novice to Pro content.
+ *
+ * This component is not intended for general use.
+ *
+ * Expected scrolling behavior.
+ * 1. Scroll the maximum number of visible items at a time.
+ * 2. The left-most item should always be left-aligned in the viewport.
+ *
+ * Exception.
+ * 1. After scrolling to the last (right-most) item,
+ *      if some of its content remains hidden,
+ *      then nudge it to the right until it is right-aligned.
+ * 2. From the right-aligned position, when scrolling left,
+ *      the left-most item should again be left-aligned.
+ */
+var Carousel = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
+  var children = _ref.children,
+    className = _ref.className,
+    _ref$disableArrowScro = _ref.disableArrowScroll,
+    disableArrowScroll = _ref$disableArrowScro === void 0 ? defaults.disableArrowScroll : _ref$disableArrowScro,
+    fadedEdgeColor = _ref.fadedEdgeColor,
+    _ref$onChangeIsScroll = _ref.onChangeIsScrollable,
+    onChangeIsScrollable = _ref$onChangeIsScroll === void 0 ? defaults.onChangeIsScrollable : _ref$onChangeIsScroll,
+    _ref$onScroll = _ref.onScroll,
+    onScroll = _ref$onScroll === void 0 ? defaults.onScroll : _ref$onScroll,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  var carouselRef = useRef();
+  var scrollRef = useRef();
+  // Array of refs used to reference this component's children DOM elements
+  var childElementsRef = useRef(Array(React.Children.count(children)).fill(useRef(null)));
+  var leftFadedEdgeColor = (fadedEdgeColor === null || fadedEdgeColor === void 0 ? void 0 : fadedEdgeColor.left) || fadedEdgeColor;
+  var rightFadedEdgeColor = (fadedEdgeColor === null || fadedEdgeColor === void 0 ? void 0 : fadedEdgeColor.right) || fadedEdgeColor;
+
+  // Trigger callbacks to report state of the carousel
+  var handleOnScroll = useCallback(function () {
+    // viewport's width
+    var clientWidth = scrollRef.current.clientWidth;
+    // scroll position
+    var scrollLeft = parseInt(scrollRef.current.scrollLeft, 10);
+    // scrollable width
+    var scrollWidth = scrollRef.current.scrollWidth;
+
+    // The maximum scrollLeft achievable is the scrollable width - the viewport width.
+    var scrollLeftMax = scrollWidth - clientWidth;
+    // if isNaN(scrollLeft / scrollLeftMax), then set to zero
+    var scrollPercent = parseFloat((scrollLeft / scrollLeftMax).toFixed(2)) || 0;
+    if (!scrollRef.current) {
+      return;
+    }
+
+    // Callback 1: Does the carousel have enough content to enable scrolling?
+    onChangeIsScrollable(scrollWidth > clientWidth);
+
+    // Callback 2: Return the percentage of current scroll, between 0 and 1.
+    onScroll(scrollPercent);
+  }, [onChangeIsScrollable, onScroll]);
+
+  // Check if an individual child element is visible in the container
+  var getElementInView = useCallback(function (containerRect, elementRect) {
+    // Is the element's left greater than or equal to the containers left
+    var elementLeftIsRightOfContainerLeft = elementRect.left >= containerRect.left;
+    // Is the element's right less than or equal to the containers right
+    var elementRightIsLeftOfContainerRight = elementRect.right <= containerRect.right;
+    return elementLeftIsRightOfContainerLeft && elementRightIsLeftOfContainerRight;
+  }, []);
+
+  // Get all elements that are visible in the container.
+  var getElementsInView = useCallback(function () {
+    var containerRect = scrollRef.current.getBoundingClientRect();
+    var inViewElements = childElementsRef.current.filter(function (el) {
+      return getElementInView(containerRect, el.getBoundingClientRect());
+    });
+    return inViewElements;
+  }, [getElementInView]);
+
+  // Return container's and children's rect data
+  var getContainerAndChildRectData = useCallback(function () {
+    // Get the rect of the container
+    var containerRect = scrollRef.current.getBoundingClientRect();
+    // Get all child elements that are in view of the container, and return their bounding rects.
+    var elementRectsInView = getElementsInView().map(function (el) {
+      return el.getBoundingClientRect();
+    });
+
+    // What is the overall width of the visible elements in the container
+    // Note: may end up being 0 if the container's width is less than the child's width
+    var visibleWidth = elementRectsInView.reduce(function (accumulator, currentValue) {
+      return accumulator + currentValue.width;
+    }, 0);
+    return {
+      containerRect: containerRect,
+      elementRectsInView: elementRectsInView,
+      visibleWidth: visibleWidth
+    };
+  }, [getElementsInView]);
+  var handleScrollNext = useCallback(function () {
+    var _getContainerAndChild = getContainerAndChildRectData(),
+      containerRect = _getContainerAndChild.containerRect,
+      visibleWidth = _getContainerAndChild.visibleWidth;
+    // Set the scrollValue to the visibleWidth, but if the visibleWidth value is 0, set it to the container's width
+    var scrollValue = visibleWidth > 0 ? visibleWidth : containerRect.width;
+    // Increment the scrollLeft of the container
+    scrollRef.current.scrollLeft += scrollValue;
+  }, [getContainerAndChildRectData]);
+  var handleScrollPrev = useCallback(function () {
+    var _getContainerAndChild2 = getContainerAndChildRectData(),
+      containerRect = _getContainerAndChild2.containerRect,
+      elementRectsInView = _getContainerAndChild2.elementRectsInView,
+      visibleWidth = _getContainerAndChild2.visibleWidth;
+    // Set the scrollValue to the visibleWidth minus the first child's left value,
+    // but if the visibleWidth value is 0, set it to the container's width plus the container's left value
+    var scrollValue = visibleWidth > 0 ? visibleWidth - elementRectsInView[0].left : containerRect.width + containerRect.left;
+
+    // Decrement the scrollLeft of the container
+    scrollRef.current.scrollLeft -= scrollValue;
+  }, [getContainerAndChildRectData]);
+  var handleScrollReset = useCallback(function () {
+    // This doesn't trigger "scrollend"...
+    scrollRef.current.scrollLeft = 0;
+    // ...so trigger a callback manually.
+    handleOnScroll();
+  }, [handleOnScroll]);
+  var handleScrollToView = useCallback(function (itemNumber) {
+    childElementsRef.current[itemNumber].scrollIntoView();
+  }, []);
+
+  // Trigger a callback after first render (and applied CSS).
+  useEffect(function () {
+    // Normally, we can trigger a callback "immediately after first
+    // render", because we will be doing more "logical" work (update
+    // a state, show / hide a feature, etc.), and the final, applied
+    // CSS can "catch up" asynchronously without breaking anything.
+    setTimeout(function () {
+      // But, because we are making calculations based on the final,
+      // applied CSS, we must wait for one more "tick".
+      handleOnScroll();
+    }, 0);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // On window.resize, reset carousel to zero.
+  useEffect(function () {
+    var handleWindowResize = function handleWindowResize() {
+      scrollRef.current.scrollLeft = 0;
+      handleOnScroll();
+    };
+    window.addEventListener('resize', handleWindowResize);
+    return function () {
+      return window.removeEventListener('resize', handleWindowResize);
+    };
+  }, [handleOnScroll]);
+
+  // On scrollRef.scrollend, trigger a callback.
+  useEffect(function () {
+    var handleScrollend = function handleScrollend() {
+      handleOnScroll();
+    };
+    var scrollDiv = scrollRef.current;
+    scrollDiv.addEventListener('scrollend', handleScrollend);
+    return function () {
+      return scrollDiv.removeEventListener('scrollend', handleScrollend);
+    };
+  }, [handleOnScroll]);
+
+  // Disable wheel scrolling
+  useEffect(function () {
+    function handleWheel(event) {
+      // update the scroll position
+      event.stopPropagation();
+      event.preventDefault();
+      event.cancelBubble = false;
+    }
+    var scrollDiv = scrollRef.current;
+    if (scrollDiv) {
+      scrollDiv.addEventListener('wheel', handleWheel, {
+        passive: false
+      });
+      return function () {
+        scrollDiv.removeEventListener('wheel', handleWheel, {
+          passive: false
+        });
+      };
+    }
+  }, []);
+
+  // Enable arrow scrolling from within the carousel
+  useEffect(function () {
+    function handleKeydown(event) {
+      var key = event.key;
+      if ((key === 'ArrowLeft' || key === 'ArrowRight') && disableArrowScroll) {
+        event.stopPropagation();
+        event.preventDefault();
+        event.cancelBubble = false;
+      }
+    }
+    var carouselDiv = carouselRef.current;
+    if (carouselDiv) {
+      carouselDiv.addEventListener('keydown', handleKeydown);
+      return function () {
+        return carouselDiv.removeEventListener('keydown', handleKeydown);
+      };
+    }
+  }, [disableArrowScroll]);
+
+  // Enable external function calls
+  useImperativeHandle(ref, function () {
+    return {
+      scrollNext: function scrollNext() {
+        handleScrollNext();
+      },
+      scrollPrev: function scrollPrev() {
+        handleScrollPrev();
+      },
+      scrollReset: function scrollReset() {
+        handleScrollReset();
+      },
+      scrollToView: function scrollToView(itemNumber) {
+        handleScrollToView(itemNumber);
+      }
+    };
+  }, [handleScrollNext, handleScrollPrev, handleScrollReset, handleScrollToView]);
+  return /*#__PURE__*/React.createElement("div", _extends({}, rest, {
+    tabIndex: -1,
+    className: cx(blockClass, className),
+    ref: carouselRef,
+    role: "main"
+  }, getDevtoolsProps(componentName)), /*#__PURE__*/React.createElement("div", {
+    className: cx("".concat(blockClass, "__elements-container"))
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(blockClass, "__elements"),
+    ref: scrollRef
+  }, React.Children.map(children, function (child, index) {
+    return /*#__PURE__*/React.createElement(CarouselItem, {
+      key: index,
+      ref: function ref(element) {
+        return childElementsRef.current[index] = element;
+      }
+    }, child);
+  })), leftFadedEdgeColor && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(blockClass, "__elements-container--scrolled"),
+    style: {
+      background: "linear-gradient(90deg, ".concat(leftFadedEdgeColor, ", transparent)")
+    }
+  }), rightFadedEdgeColor && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(blockClass, "__elements-container--scroll-max"),
+    style: {
+      background: "linear-gradient(270deg, ".concat(rightFadedEdgeColor, ", transparent)")
+    }
+  })));
+});
+Carousel.displayName = componentName;
+
+// The types and DocGen commentary for the component props,
+// in alphabetical order (for consistency).
+// See https://www.npmjs.com/package/prop-types#usage.
+Carousel.propTypes = {
+  /**
+   * Provide the contents of the Carousel.
+   */
+  children: PropTypes.node.isRequired,
+  /**
+   * Provide an optional class to be applied to the containing node.
+   */
+  className: PropTypes.string,
+  /**
+   * Disables the ability of the Carousel to scroll
+   * use a keyboard's left and right arrow keys.
+   */
+  disableArrowScroll: PropTypes.bool,
+  /**
+   * Enables the edges of the component to have faded styling.
+   *
+   * Pass a single string (`$color`) to specify the same color for left and right.
+   *
+   * Or pass an object (`{ left: $color1, right: $color2 }`) to specify different colors.
+   */
+  fadedEdgeColor: PropTypes.oneOfType([PropTypes.string, PropTypes.shape({
+    left: PropTypes.string,
+    right: PropTypes.string
+  })]),
+  /**
+   * An optional callback function that returns `true`
+   * when the carousel has enough content to be scrollable,
+   * and `false` when there is not enough content.
+   */
+  onChangeIsScrollable: PropTypes.func,
+  /**
+   * An optional callback function that returns the scroll position as
+   * a value between 0 and 1.
+   */
+  onScroll: PropTypes.func
+};
+export { Carousel };

package/es/components/Carousel/CarouselItem.js

@@ -0,0 +1,53 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["children", "className"];
+/**
+ * Copyright IBM Corp. 2023, 2023
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import React from 'react';
+
+// Other standard imports.
+import PropTypes from 'prop-types';
+import cx from 'classnames';
+import { getDevtoolsProps } from '../../global/js/utils/devtools';
+import { pkg } from '../../settings';
+
+// Carbon and package components we use.
+/* TODO: @import(s) of carbon components and other package components. */
+
+// The block part of our conventional BEM class names (blockClass__E--M).
+var blockClass = "".concat(pkg.prefix, "--carousel__item");
+var componentName = 'CarouselItem';
+
+/**
+ * TODO: A description of the component.
+ */
+var CarouselItem = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
+  var children = _ref.children,
+    className = _ref.className,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/React.createElement("div", _extends({}, rest, {
+    className: cx(blockClass, className)
+  }, getDevtoolsProps(componentName), {
+    ref: ref
+  }), children);
+});
+CarouselItem.displayName = componentName;
+// The types and DocGen commentary for the component props,
+// in alphabetical order (for consistency).
+// See https://www.npmjs.com/package/prop-types#usage.
+CarouselItem.propTypes = {
+  /**
+   * Provide the contents of the CarouselItem.
+   */
+  children: PropTypes.node.isRequired,
+  /**
+   * Provide an optional class to be applied to the containing node.
+   */
+  className: PropTypes.string
+};
+export { CarouselItem };

package/es/components/Carousel/index.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright IBM Corp. 2023, 2023
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export { Carousel } from './Carousel';
+export { CarouselItem } from './CarouselItem';

package/es/components/Carousel/utils.js

@@ -0,0 +1,98 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+/**
+ * Copyright IBM Corp. 2023, 2023
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+export var useIntersection = function useIntersection(element, threshold) {
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isVisible = _useState2[0],
+    setState = _useState2[1];
+  useEffect(function () {
+    var el = element.current;
+    var observer = new IntersectionObserver(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 1),
+        entry = _ref2[0];
+      setState(entry.isIntersecting);
+    }, {
+      threshold: threshold
+    });
+    el && observer.observe(el);
+    return function () {
+      return observer.unobserve(el);
+    };
+  }, [element, threshold]);
+  return isVisible;
+};
+export var useIsOverflow = function useIsOverflow(ref) {
+  var _useState3 = useState(),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isScrollable = _useState4[0],
+    setIsScrollable = _useState4[1];
+  var _useState5 = useState(),
+    _useState6 = _slicedToArray(_useState5, 2),
+    mutationObserver = _useState6[0],
+    setMutationObserver = _useState6[1];
+  var _useState7 = useState(),
+    _useState8 = _slicedToArray(_useState7, 2),
+    resizeObserver = _useState8[0],
+    setResizeObserver = _useState8[1];
+  var checkOverflow = useCallback(function () {
+    if (!ref.current) {
+      return;
+    }
+    var hasOverflow = ref.current.scrollWidth > ref.current.clientWidth;
+    setIsScrollable(hasOverflow);
+  }, [ref]);
+  useEffect(function () {
+    if (!mutationObserver) {
+      return;
+    }
+    return function () {
+      if (mutationObserver) {
+        mutationObserver.disconnect();
+      }
+      if (resizeObserver) {
+        resizeObserver.disconnect();
+      }
+    };
+  });
+  useLayoutEffect(function () {
+    var current = ref.current;
+    if (current) {
+      if ('ResizeObserver' in window && !resizeObserver) {
+        setResizeObserver(new ResizeObserver(checkOverflow).observe(current));
+      }
+      if ('MutationObserver' in window && !mutationObserver) {
+        setMutationObserver(new MutationObserver(checkOverflow).observe(current, {
+          attributes: false,
+          childList: true,
+          subtree: false
+        }));
+      }
+      checkOverflow();
+    }
+  }, [ref, checkOverflow, mutationObserver, resizeObserver]);
+  return isScrollable;
+};
+export var useWindowEvent = function useWindowEvent(eventName, callback) {
+  var savedCallback = useRef(null);
+  useEffect(function () {
+    savedCallback.current = callback;
+  });
+  useEffect(function () {
+    function handler(event) {
+      if (savedCallback.current) {
+        savedCallback.current(event);
+      }
+    }
+    window.addEventListener(eventName, handler);
+    return function () {
+      window.removeEventListener(eventName, handler);
+    };
+  }, [eventName]);
+};

package/es/components/CreateSidePanel/CreateSidePanel.js

@@ -1,7 +1,7 @@
 import _extends from "@babel/runtime/helpers/extends";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-var _excluded = ["className", "children", "disableSubmit", "formTitle", "formDescription", "onRequestClose", "onRequestSubmit", "open", "primaryButtonText", "secondaryButtonText", "selectorPageContent", "selectorPrimaryFocus", "subtitle", "title"];
+var _excluded = ["className", "children", "disableSubmit", "formTitle", "formDescription", "id", "onRequestClose", "onRequestSubmit", "open", "primaryButtonText", "secondaryButtonText", "selectorPageContent", "selectorPrimaryFocus", "subtitle", "title"];
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /**
@@ -40,6 +40,7 @@ export var CreateSidePanel = /*#__PURE__*/React.forwardRef(function (_ref, ref)
     disableSubmit = _ref.disableSubmit,
     formTitle = _ref.formTitle,
     formDescription = _ref.formDescription,
+    id = _ref.id,
     onRequestClose = _ref.onRequestClose,
     onRequestSubmit = _ref.onRequestSubmit,
     open = _ref.open,
@@ -66,6 +67,7 @@ export var CreateSidePanel = /*#__PURE__*/React.forwardRef(function (_ref, ref)
   }];
   var formTitleId = uuidv4();
   return selectorPageContent && /*#__PURE__*/React.createElement(SidePanel, _extends({}, rest, _objectSpread({
+    id: id,
     open: open,
     ref: ref,
     selectorPageContent: selectorPageContent,
@@ -118,6 +120,10 @@ CreateSidePanel.propTypes = {
    * Specifies a required field that provides a title for a form
    */
   formTitle: PropTypes.node.isRequired,
+  /**
+   * Unique identifier
+   */
+  id: PropTypes.string,
   /**
    * Specifies an optional handler which is called when the CreateSidePanel
    * is closed.

package/es/components/Datagrid/Datagrid/DatagridExpandedRow.js

@@ -34,12 +34,14 @@ var DatagridExpandedRow = function DatagridExpandedRow(ExpandedRowContentCompone
       onMouseLeave: function onMouseLeave(event) {
         return toggleParentHoverClass(event);
       }
+    }, /*#__PURE__*/React.createElement("td", {
+      className: "".concat(blockClass, "__expanded-row-cell-wrapper")
     }, /*#__PURE__*/React.createElement("div", {
       className: "".concat(blockClass, "__expanded-row-content"),
       style: {
         height: expandedContentHeight && expandedContentHeight
       }
-    }, /*#__PURE__*/React.createElement(ExpandedRowContentComponent, datagridState)));
+    }, /*#__PURE__*/React.createElement(ExpandedRowContentComponent, datagridState))));
   };
 };
 export default DatagridExpandedRow;

package/es/components/Datagrid/Datagrid/DatagridRow.js

@@ -33,7 +33,9 @@ var DatagridRow = function DatagridRow(datagridState) {
     rowSize = datagridState.rowSize,
     withNestedRows = datagridState.withNestedRows,
     prepareRow = datagridState.prepareRow,
-    key = datagridState.key;
+    key = datagridState.key,
+    tableId = datagridState.tableId,
+    withExpandedRows = datagridState.withExpandedRows;
   var getVisibleNestedRowCount = function getVisibleNestedRowCount(_ref) {
     var isExpanded = _ref.isExpanded,
       subRows = _ref.subRows;
@@ -62,7 +64,7 @@ var DatagridRow = function DatagridRow(datagridState) {
     hoverRow === null || hoverRow === void 0 || (_hoverRow$style3 = hoverRow.style) === null || _hoverRow$style3 === void 0 || _hoverRow$style3.setProperty("--".concat(blockClass, "--indicator-offset-amount"), px((rowExpanderButton === null || rowExpanderButton === void 0 ? void 0 : rowExpanderButton.offsetLeft) || 0));
   };
   var focusRemover = function focusRemover() {
-    var elements = document.querySelectorAll(".".concat(blockClass, "__carbon-row-expanded"));
+    var elements = document.querySelectorAll("#".concat(tableId, " .").concat(blockClass, "__carbon-row-expanded"));
     elements.forEach(function (el) {
       el.classList.remove("".concat(blockClass, "__carbon-row-expanded-hover-active"));
     });
@@ -91,6 +93,14 @@ var DatagridRow = function DatagridRow(datagridState) {
     }
   };
   var rowClassNames = cx("".concat(blockClass, "__carbon-row"), (_cx = {}, _defineProperty(_cx, "".concat(blockClass, "__carbon-row-expanded"), row.isExpanded), _defineProperty(_cx, "".concat(blockClass, "__carbon-row-expandable"), row.canExpand), _defineProperty(_cx, "".concat(carbon.prefix, "--data-table--selected"), row.isSelected), _cx));
+  var setAdditionalRowProps = function setAdditionalRowProps() {
+    if (withNestedRows || withExpandedRows) {
+      return {
+        'data-nested-row-id': row.id
+      };
+    }
+    return {};
+  };
   return /*#__PURE__*/React.createElement(React.Fragment, {
     key: key
   }, /*#__PURE__*/React.createElement(TableRow, _extends({
@@ -102,7 +112,7 @@ var DatagridRow = function DatagridRow(datagridState) {
     onFocus: hoverHandler,
     onBlur: focusRemover,
     onKeyUp: handleOnKeyUp
-  }), row.cells.map(function (cell, index) {
+  }, setAdditionalRowProps()), row.cells.map(function (cell, index) {
     var _cell$column;
     var cellProps = cell.getCellProps();
     var children = cellProps.children,

package/es/components/Datagrid/Datagrid/addons/Filtering/hooks/useFilters.js

@@ -78,7 +78,7 @@ var useFilters = function useFilters(_ref2) {
   /** Methods */
   // If the user decides to cancel or click outside the flyout, it reverts back to the filters that were
   // there when they opened the flyout
-  var revertToPreviousFilters = function revertToPreviousFilters() {
+  var revertToPreviousFilters = useCallback(function () {
     setFiltersState(JSON.parse(prevFiltersRef.current));
     setFiltersObjectArray(JSON.parse(prevFiltersObjectArrayRef.current));
     setAllFilters(JSON.parse(lastAppliedFilters.current));
@@ -88,7 +88,7 @@ var useFilters = function useFilters(_ref2) {
     holdingPrevFiltersRef.current = JSON.parse(prevFiltersRef.current);
     holdingLastAppliedFiltersRef.current = JSON.parse(prevFiltersObjectArrayRef.current);
     holdingPrevFiltersObjectArrayRef.current = JSON.parse(lastAppliedFilters.current);
-  };
+  }, [setAllFilters]);
   var reset = useCallback(function () {
     // When we reset we want the "initialFilters" to be an empty array
     var resetFiltersArray = [];
@@ -352,6 +352,7 @@ var useFilters = function useFilters(_ref2) {
    */
   useEffect(function () {
     if (!panelOpen && previousState !== null && previousState !== void 0 && previousState.panelOpen) {
+      revertToPreviousFilters();
       setAllFilters(holdingLastAppliedFiltersRef.current);
     }
     if (panelOpen && !(previousState !== null && previousState !== void 0 && previousState.panelOpen)) {
@@ -361,7 +362,7 @@ var useFilters = function useFilters(_ref2) {
         setAllFilters(JSON.parse(prevFiltersObjectArrayRef.current));
       }
     }
-  }, [panelOpen, previousState, previousState === null || previousState === void 0 ? void 0 : previousState.panelOpen, reset, setAllFilters]);
+  }, [panelOpen, previousState, previousState === null || previousState === void 0 ? void 0 : previousState.panelOpen, reset, setAllFilters, revertToPreviousFilters]);
   var cancel = function cancel() {
     // Reverting to previous filters only applies when using batch actions
     if (updateMethod === BATCH) {

package/es/components/Datagrid/Extensions/Filtering/Filtering.docs-page.js

@@ -41,6 +41,12 @@ export var DocsPage = function DocsPage() {
     }, {
       subTitle: 'Create your filters for panel variant',
       description: 'Filter panel coming soon.'
+    }, {
+      subTitle: 'Customizing the filter tag labels',
+      description: 'You can customize the rendering of the filter tag labels by supplying the `renderLabel` property to your `filterProps` as seen below. Otherwise it will default to `key: value`.',
+      source: {
+        code: "\nfilterProps: {\n  ...otherFilterProps,\n  renderLabel: (key, value) => myCustomTagLabelFormatter(key, value),\n},\n          "
+      }
     }, {
       subTitle: 'Putting it all together',
       source: {
@@ -50,7 +56,7 @@ export var DocsPage = function DocsPage() {
       subTitle: "`filterProps` types",
       source: {
         language: 'json',
-        code: "\nfilterProps: {\n  /** The variation of filtering */\n  variation: 'flyout'|'panel',\n  /** The update method in which to filter, instant automatically\n      applies the filters, batch the user has to click apply */\n  updateMethod: 'batch'|'instant',\n  /** Text for primary action button, default is 'Apply' */\n  primaryActionLabel: string,\n  /** Text for secondary action button, default is 'Cancel' */\n  secondaryActionLabel: string,\n  /** Text for flyout icon description */\n  flyoutIconDescription: string,\n  /** Array of objects to render filters in flyout */\n  filters: object[]\n}\n          "
+        code: "\nfilterProps: {\n  /** The variation of filtering */\n  variation: 'flyout'|'panel',\n  /** The update method in which to filter, instant automatically\n      applies the filters, batch the user has to click apply */\n  updateMethod: 'batch'|'instant',\n  /** Text for primary action button, default is 'Apply' */\n  primaryActionLabel: string,\n  /** Text for secondary action button, default is 'Cancel' */\n  secondaryActionLabel: string,\n  /** Text for flyout icon description */\n  flyoutIconDescription: string,\n  /** Array of objects to render filters in flyout */\n  filters: object[]\n  /** Applies custom formatting to filter tags */\n  renderLabel: Function\n}\n          "
       }
     }]
   });

package/es/components/Datagrid/useExpandedRow.js

@@ -9,14 +9,10 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
  * LICENSE file in the root directory of this source tree.
  */
 
-import { useEffect, useState } from 'react';
-import { pkg } from '../../settings';
+import { useState } from 'react';
 import DatagridExpandedRow from './Datagrid/DatagridExpandedRow';
 import useRowExpander from './useRowExpander';
 var useExpandedRow = function useExpandedRow(hooks) {
-  useEffect(function () {
-    pkg.checkReportFeatureEnabled('Datagrid.useExpandedRow');
-  }, []);
   useRowExpander(hooks);
   var useInstance = function useInstance(instance) {
     var rows = instance.rows,
@@ -38,7 +34,8 @@ var useExpandedRow = function useExpandedRow(hooks) {
     });
     Object.assign(instance, {
       rows: rowsWithExpand,
-      setExpandedRowHeight: setExpandedRowHeight
+      setExpandedRowHeight: setExpandedRowHeight,
+      withExpandedRows: true
     });
   };
   hooks.useInstance.push(useInstance);