@carbon/react 1.16.0 → 1.17.0-rc.1

package/es/components/Tabs/Tabs.js

@@ -5,614 +5,688 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { inherits as _inherits, createSuper as _createSuper, classCallCheck as _classCallCheck, defineProperty as _defineProperty, assertThisInitialized as _assertThisInitialized, createClass as _createClass, objectWithoutProperties as _objectWithoutProperties, extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js';
-import PropTypes from 'prop-types';
-import React__default from 'react';
-import cx from 'classnames';
+import { slicedToArray as _slicedToArray, objectWithoutProperties as _objectWithoutProperties, defineProperty as _defineProperty, extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js';
 import { ChevronLeft, ChevronRight } from '@carbon/icons-react';
+import cx from 'classnames';
 import debounce from 'lodash.debounce';
-import TabContent from '../TabContent/TabContent.js';
-import { PrefixContext } from '../../internal/usePrefix.js';
-import { match, matches } from '../../internal/keyboard/match.js';
-import { ArrowLeft, ArrowRight, Enter, Space, Home, End } from '../../internal/keyboard/keys.js';
+import PropTypes from 'prop-types';
+import React__default, { useState, useRef, useCallback, useEffect } from 'react';
+import { Tooltip } from '../Tooltip/next/Tooltip.js';
+import { useControllableState } from '../../internal/useControllableState.js';
+import { useEffectOnce } from '../../internal/useEffectOnce.js';
+import { useId } from '../../internal/useId.js';
+import useIsomorphicEffect from '../../internal/useIsomorphicEffect.js';
+import { useMergedRefs } from '../../internal/useMergedRefs.js';
+import { getInteractiveContent } from '../../internal/useNoInteractiveChildren.js';
+import { usePrefix } from '../../internal/usePrefix.js';
+import { usePressable } from './usePressable.js';
+import { matches, match } from '../../internal/keyboard/match.js';
+import { ArrowRight, ArrowLeft, Home, End } from '../../internal/keyboard/keys.js';
 
 var _ChevronLeft, _ChevronRight;
 
-var _excluded = ["className", "type", "light", "onSelectionChange", "scrollDebounceWait", "scrollIntoView", "selectionMode", "tabContentClassName", "leftOverflowButtonProps", "rightOverflowButtonProps"];
-
-var Tabs = /*#__PURE__*/function (_React$Component) {
-  _inherits(Tabs, _React$Component);
-
-  var _super = _createSuper(Tabs);
+var _excluded = ["activation", "aria-label", "children", "className", "contained", "iconSize", "leftOverflowButtonProps", "light", "rightOverflowButtonProps", "scrollDebounceWait", "scrollIntoView"],
+    _excluded2 = ["as", "children", "className", "disabled", "onClick", "onKeyDown"],
+    _excluded3 = ["children", "className", "defaultOpen", "enterDelayMs", "leaveDelayMs", "label"],
+    _excluded4 = ["children", "className"];
 
-  function Tabs() {
-    var _this;
-
-    _classCallCheck(this, Tabs);
-
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
-    _this = _super.call.apply(_super, [this].concat(args));
-
-    _defineProperty(_assertThisInitialized(_this), "state", {
-      horizontalOverflow: false
-    });
+var TabsContext = /*#__PURE__*/React__default.createContext(); // Used to keep track of position in a tablist
 
-    _defineProperty(_assertThisInitialized(_this), "tablist", /*#__PURE__*/React__default.createRef());
+var TabContext = /*#__PURE__*/React__default.createContext(); // Used to keep track of position in a list of tab panels
 
-    _defineProperty(_assertThisInitialized(_this), "leftOverflowNavButton", /*#__PURE__*/React__default.createRef());
+var TabPanelContext = /*#__PURE__*/React__default.createContext();
 
-    _defineProperty(_assertThisInitialized(_this), "rightOverflowNavButton", /*#__PURE__*/React__default.createRef());
+function Tabs(_ref) {
+  var children = _ref.children,
+      _ref$defaultSelectedI = _ref.defaultSelectedIndex,
+      defaultSelectedIndex = _ref$defaultSelectedI === void 0 ? 0 : _ref$defaultSelectedI,
+      _onChange = _ref.onChange,
+      controlledSelectedIndex = _ref.selectedIndex;
+  var baseId = useId('ccs'); // The active index is used to track the element which has focus in our tablist
 
-    _defineProperty(_assertThisInitialized(_this), "OVERFLOW_BUTTON_OFFSET", 40);
+  var _useState = useState(defaultSelectedIndex),
+      _useState2 = _slicedToArray(_useState, 2),
+      activeIndex = _useState2[0],
+      setActiveIndex = _useState2[1]; // The selected index is used for the tab/panel pairing which is "visible"
 
-    _defineProperty(_assertThisInitialized(_this), "handleScroll", function () {
-      var _this$tablist;
 
-      if (!((_this$tablist = _this.tablist) !== null && _this$tablist !== void 0 && _this$tablist.current)) {
-        return;
+  var _useControllableState = useControllableState({
+    value: controlledSelectedIndex,
+    defaultValue: defaultSelectedIndex,
+    onChange: function onChange(value) {
+      if (_onChange) {
+        _onChange({
+          selectedIndex: value
+        });
       }
+    }
+  }),
+      _useControllableState2 = _slicedToArray(_useControllableState, 2),
+      selectedIndex = _useControllableState2[0],
+      setSelectedIndex = _useControllableState2[1];
+
+  var value = {
+    baseId: baseId,
+    activeIndex: activeIndex,
+    defaultSelectedIndex: defaultSelectedIndex,
+    setActiveIndex: setActiveIndex,
+    selectedIndex: selectedIndex,
+    setSelectedIndex: setSelectedIndex
+  };
+  return /*#__PURE__*/React__default.createElement(TabsContext.Provider, {
+    value: value
+  }, children);
+}
+
+Tabs.propTypes = {
+  /**
+   * Provide child elements to be rendered inside of the `Tabs`.
+   * These elements should render either `TabsList` or `TabsPanels`
+   */
+  children: PropTypes.node,
 
-      var _this$tablist$current = _this.tablist.current,
-          tablistClientWidth = _this$tablist$current.clientWidth,
-          tablistScrollLeft = _this$tablist$current.scrollLeft,
-          tablistScrollWidth = _this$tablist$current.scrollWidth;
-
-      _this.setState({
-        tablistClientWidth: tablistClientWidth,
-        horizontalOverflow: tablistScrollWidth > tablistClientWidth,
-        tablistScrollWidth: tablistScrollWidth,
-        tablistScrollLeft: tablistScrollLeft
-      });
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "_debouncedHandleWindowResize", null);
-
-    _defineProperty(_assertThisInitialized(_this), "_handleWindowResize", _this.handleScroll);
-
-    _defineProperty(_assertThisInitialized(_this), "_debouncedHandleScroll", null);
-
-    _defineProperty(_assertThisInitialized(_this), "_handleScroll", _this.handleScroll);
-
-    _defineProperty(_assertThisInitialized(_this), "getEnabledTabs", function () {
-      return React__default.Children.toArray(_this.props.children).reduce(function (enabledTabs, tab, index) {
-        return !tab.props.disabled ? enabledTabs.concat(index) : enabledTabs;
-      }, []);
-    });
+  /**
+   * Specify which content tab should be initially selected when the component
+   * is first rendered
+   */
+  defaultSelectedIndex: PropTypes.number,
 
-    _defineProperty(_assertThisInitialized(_this), "getNextIndex", function (index, direction) {
-      var enabledTabs = _this.getEnabledTabs();
+  /**
+   * Provide an optional function which is called whenever the state of the
+   * `Tabs` changes
+   */
+  onChange: PropTypes.func,
 
-      var nextIndex = Math.max(enabledTabs.indexOf(index) + direction, // For `tab` not found in `enabledTabs`
-      -1);
-      var nextIndexLooped = nextIndex >= 0 && nextIndex < enabledTabs.length ? nextIndex : nextIndex - Math.sign(nextIndex) * enabledTabs.length;
-      return enabledTabs[nextIndexLooped];
-    });
+  /**
+   * Control which content panel is currently selected. This puts the component
+   * in a controlled mode and should be used along with `onChange`
+   */
+  selectedIndex: PropTypes.number
+};
+/**
+ * Get the next index for a given keyboard event given a count of the total
+ * items and the current index
+ * @param {Event} event
+ * @param {number} total
+ * @param {number} index
+ * @returns {number}
+ */
 
-    _defineProperty(_assertThisInitialized(_this), "getDirection", function (evt) {
-      if (match(evt, ArrowLeft)) {
-        return -1;
-      }
+function getNextIndex(event, total, index) {
+  if (match(event, ArrowRight)) {
+    return (index + 1) % total;
+  } else if (match(event, ArrowLeft)) {
+    return (total + index - 1) % total;
+  } else if (match(event, Home)) {
+    return 0;
+  } else if (match(event, End)) {
+    return total - 1;
+  }
+}
+
+function TabList(_ref2) {
+  var _cx;
+
+  var _ref2$activation = _ref2.activation,
+      activation = _ref2$activation === void 0 ? 'automatic' : _ref2$activation,
+      label = _ref2['aria-label'],
+      children = _ref2.children,
+      customClassName = _ref2.className,
+      _ref2$contained = _ref2.contained,
+      contained = _ref2$contained === void 0 ? false : _ref2$contained,
+      iconSize = _ref2.iconSize,
+      leftOverflowButtonProps = _ref2.leftOverflowButtonProps,
+      light = _ref2.light,
+      rightOverflowButtonProps = _ref2.rightOverflowButtonProps,
+      _ref2$scrollDebounceW = _ref2.scrollDebounceWait,
+      scrollDebounceWait = _ref2$scrollDebounceW === void 0 ? 200 : _ref2$scrollDebounceW,
+      scrollIntoView = _ref2.scrollIntoView,
+      rest = _objectWithoutProperties(_ref2, _excluded);
+
+  var _React$useContext = React__default.useContext(TabsContext),
+      activeIndex = _React$useContext.activeIndex,
+      selectedIndex = _React$useContext.selectedIndex,
+      setSelectedIndex = _React$useContext.setSelectedIndex,
+      setActiveIndex = _React$useContext.setActiveIndex;
+
+  var prefix = usePrefix();
+  var ref = useRef(null);
+  var previousButton = useRef(null);
+  var nextButton = useRef(null);
+
+  var _useState3 = useState(false),
+      _useState4 = _slicedToArray(_useState3, 2),
+      isScrollable = _useState4[0],
+      setIsScrollable = _useState4[1];
+
+  var _useState5 = useState(null),
+      _useState6 = _slicedToArray(_useState5, 2),
+      scrollLeft = _useState6[0],
+      setScrollLeft = _useState6[1];
+
+  var className = cx("".concat(prefix, "--tabs"), customClassName, (_cx = {}, _defineProperty(_cx, "".concat(prefix, "--tabs--contained"), contained), _defineProperty(_cx, "".concat(prefix, "--tabs--light"), light), _defineProperty(_cx, "".concat(prefix, "--tabs__icon--default"), iconSize === 'default'), _defineProperty(_cx, "".concat(prefix, "--tabs__icon--lg"), iconSize === 'lg'), _cx)); // Previous Button
+  // VISIBLE IF:
+  //   SCROLLABLE
+  //   AND SCROLL_LEFT > 0
+
+  var buttonWidth = 44;
+  var isPreviousButtonVisible = ref.current ? isScrollable && scrollLeft > 0 : false; // Next Button
+  // VISIBLE IF:
+  //   SCROLLABLE
+  //   AND SCROLL_LEFT + CLIENT_WIDTH < SCROLL_WIDTH
+
+  var isNextButtonVisible = ref.current ? scrollLeft + buttonWidth + ref.current.clientWidth < ref.current.scrollWidth : false;
+  var previousButtonClasses = cx("".concat(prefix, "--tab--overflow-nav-button"), "".concat(prefix, "--tab--overflow-nav-button--previous"), _defineProperty({}, "".concat(prefix, "--tab--overflow-nav-button--hidden"), !isPreviousButtonVisible));
+  var nextButtonClasses = cx("".concat(prefix, "--tab--overflow-nav-button"), "".concat(prefix, "--tab--overflow-nav-button--next"), _defineProperty({}, "".concat(prefix, "--tab--overflow-nav-button--hidden"), !isNextButtonVisible));
+  var tabs = useRef([]);
+  var debouncedOnScroll = useCallback(function () {
+    return debounce(function (event) {
+      setScrollLeft(event.target.scrollLeft);
+    }, scrollDebounceWait);
+  }, [scrollDebounceWait]);
+
+  function onKeyDown(event) {
+    if (matches(event, [ArrowRight, ArrowLeft, Home, End])) {
+      event.preventDefault();
+      var activeTabs = tabs.current.filter(function (tab) {
+        return !tab.disabled;
+      });
+      var currentIndex = activeTabs.indexOf(tabs.current[activation === 'automatic' ? selectedIndex : activeIndex]);
+      var nextIndex = tabs.current.indexOf(activeTabs[getNextIndex(event, activeTabs.length, currentIndex)]);
 
-      if (match(evt, ArrowRight)) {
-        return 1;
+      if (activation === 'automatic') {
+        setSelectedIndex(nextIndex);
+      } else if (activation === 'manual') {
+        setActiveIndex(nextIndex);
       }
 
-      return 0;
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "getTabAt", function (index, useFresh) {
-      return !useFresh && _this["tab".concat(index)] || React__default.Children.toArray(_this.props.children)[index];
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "scrollTabIntoView", function (event, _ref) {
-      var index = _ref.index;
-
-      var tab = _this.getTabAt(index);
-
-      if (matches(event, [ArrowLeft, ArrowRight]) || event.type === 'click') {
-        var _tab$tabAnchor, _tab$tabAnchor2;
-
-        var currentScrollLeft = _this.state.tablistScrollLeft;
-        tab === null || tab === void 0 ? void 0 : (_tab$tabAnchor = tab.tabAnchor) === null || _tab$tabAnchor === void 0 ? void 0 : _tab$tabAnchor.scrollIntoView({
-          block: 'nearest',
-          inline: 'nearest'
-        });
-        tab === null || tab === void 0 ? void 0 : (_tab$tabAnchor2 = tab.tabAnchor) === null || _tab$tabAnchor2 === void 0 ? void 0 : _tab$tabAnchor2.focus();
-        var newScrollLeft = _this.tablist.current.scrollLeft;
-
-        if (newScrollLeft > currentScrollLeft) {
-          _this.tablist.current.scrollLeft += _this.OVERFLOW_BUTTON_OFFSET;
-        }
-      }
-    });
+      tabs.current[nextIndex].focus();
+    }
+  }
 
-    _defineProperty(_assertThisInitialized(_this), "selectTabAt", function (event, _ref2) {
-      var index = _ref2.index,
-          onSelectionChange = _ref2.onSelectionChange;
+  useEffectOnce(function () {
+    var tab = tabs.current[selectedIndex];
 
-      _this.scrollTabIntoView(event, {
-        index: index
+    if (scrollIntoView && tab) {
+      tab.scrollIntoView({
+        block: 'nearest',
+        inline: 'nearest'
+      });
+    }
+  });
+  useEffectOnce(function () {
+    if (tabs.current[selectedIndex].disabled) {
+      var activeTabs = tabs.current.filter(function (tab) {
+        return !tab.disabled;
       });
 
-      if (_this.state.selected !== index) {
-        _this.setState({
-          selected: index
-        });
-
-        if (typeof onSelectionChange === 'function') {
-          onSelectionChange(index);
-        }
+      if (activeTabs.length > 0) {
+        var tab = activeTabs[0];
+        setSelectedIndex(tabs.current.indexOf(tab));
       }
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "handleTabKeyDown", function (onSelectionChange) {
-      return function (index, evt) {
-        if (matches(evt, [Enter, Space])) {
-          _this.selectTabAt(evt, {
-            index: index,
-            onSelectionChange: onSelectionChange
-          });
-        }
-
-        var nextIndex = function () {
-          if (matches(evt, [ArrowLeft, ArrowRight])) {
-            return _this.getNextIndex(index, _this.getDirection(evt));
-          }
-
-          if (match(evt, Home)) {
-            return 0;
-          }
-
-          if (match(evt, End)) {
-            return _this.getEnabledTabs().pop();
-          }
-        }();
-
-        var tab = _this.getTabAt(nextIndex);
-
-        if (matches(evt, [ArrowLeft, ArrowRight, Home, End])) {
-          var _tab$tabAnchor3;
-
-          evt.preventDefault();
-
-          if (_this.props.selectionMode !== 'manual') {
-            _this.selectTabAt(evt, {
-              index: nextIndex,
-              onSelectionChange: onSelectionChange
-            });
-          } else {
-            _this.scrollTabIntoView(evt, {
-              index: nextIndex
-            });
-          }
-
-          tab === null || tab === void 0 ? void 0 : (_tab$tabAnchor3 = tab.tabAnchor) === null || _tab$tabAnchor3 === void 0 ? void 0 : _tab$tabAnchor3.focus();
-        }
-      };
-    });
+    }
+  });
+  useIsomorphicEffect(function () {
+    if (ref.current) {
+      setIsScrollable(ref.current.scrollWidth > ref.current.clientWidth);
+    }
 
-    _defineProperty(_assertThisInitialized(_this), "getTabs", function () {
-      return React__default.Children.map(_this.props.children, function (tab) {
-        return tab;
-      });
-    });
+    function handler() {
+      if (ref.current) {
+        setIsScrollable(ref.current.scrollWidth > ref.current.clientWidth);
+      }
+    }
 
-    _defineProperty(_assertThisInitialized(_this), "handleTabClick", function (onSelectionChange) {
-      return function (index, evt) {
-        evt.preventDefault();
+    var debouncedHandler = debounce(handler, 200);
+    window.addEventListener('resize', debouncedHandler);
+    return function () {
+      debouncedHandler.cancel();
+      window.removeEventListener('resize', debouncedHandler);
+    };
+  }, []); // updates scroll location for all scroll behavior.
+
+  useIsomorphicEffect(function () {
+    if (scrollLeft !== null) {
+      ref.current.scrollLeft = scrollLeft;
+    }
+  }, [scrollLeft]);
+  useIsomorphicEffect(function () {
+    if (!isScrollable) {
+      return;
+    }
 
-        _this.selectTabAt(evt, {
-          index: index,
-          onSelectionChange: onSelectionChange
-        });
-      };
-    });
+    var tab = activation === 'manual' ? tabs.current[activeIndex] : tabs.current[selectedIndex];
 
-    _defineProperty(_assertThisInitialized(_this), "setTabAt", function (index, tabRef) {
-      _this["tab".concat(index)] = tabRef;
-    });
+    if (tab) {
+      // The width of the "scroll buttons"
+      // The start and end position of the selected tab
+      var _tab$getBoundingClien = tab.getBoundingClientRect(),
+          tabWidth = _tab$getBoundingClien.width;
 
-    _defineProperty(_assertThisInitialized(_this), "overflowNavInterval", null);
+      var start = tab.offsetLeft;
+      var end = tab.offsetLeft + tabWidth; // The start and end of the visible area for the tabs
 
-    _defineProperty(_assertThisInitialized(_this), "handleOverflowNavClick", function (_, _ref3) {
-      var _this$tablist2;
+      var visibleStart = ref.current.scrollLeft + buttonWidth;
+      var visibleEnd = ref.current.scrollLeft + ref.current.clientWidth - buttonWidth; // The beginning of the tab is clipped and not visible
 
-      var direction = _ref3.direction,
-          _ref3$multiplier = _ref3.multiplier,
-          multiplier = _ref3$multiplier === void 0 ? 10 : _ref3$multiplier;
+      if (start < visibleStart) {
+        setScrollLeft(start - buttonWidth);
+      } // The end of teh tab is clipped and not visible
 
-      // account for overflow button appearing and causing tablist width change
-      var _this$tablist$current2 = (_this$tablist2 = _this.tablist) === null || _this$tablist2 === void 0 ? void 0 : _this$tablist2.current,
-          clientWidth = _this$tablist$current2.clientWidth,
-          scrollLeft = _this$tablist$current2.scrollLeft,
-          scrollWidth = _this$tablist$current2.scrollWidth;
 
-      if (direction === 1 && !scrollLeft) {
-        _this.tablist.current.scrollLeft += _this.OVERFLOW_BUTTON_OFFSET;
+      if (end > visibleEnd) {
+        setScrollLeft(end + buttonWidth - ref.current.clientWidth);
       }
+    }
+  }, [activation, activeIndex, selectedIndex, isScrollable]);
+  usePressable(previousButton, {
+    onPress: function onPress(_ref3) {
+      var longPress = _ref3.longPress;
 
-      _this.tablist.current.scrollLeft += direction * multiplier;
-      var leftEdgeReached = direction === -1 && scrollLeft < _this.OVERFLOW_BUTTON_OFFSET;
-      var rightEdgeReached = direction === 1 && scrollLeft + clientWidth >= scrollWidth - _this.OVERFLOW_BUTTON_OFFSET;
-
-      if (leftEdgeReached || rightEdgeReached) {
-        if (leftEdgeReached) {
-          var _this$rightOverflowNa, _this$rightOverflowNa2;
-
-          (_this$rightOverflowNa = _this.rightOverflowNavButton) === null || _this$rightOverflowNa === void 0 ? void 0 : (_this$rightOverflowNa2 = _this$rightOverflowNa.current) === null || _this$rightOverflowNa2 === void 0 ? void 0 : _this$rightOverflowNa2.focus();
-        }
-
-        if (rightEdgeReached) {
-          var _this$leftOverflowNav, _this$leftOverflowNav2;
-
-          (_this$leftOverflowNav = _this.leftOverflowNavButton) === null || _this$leftOverflowNav === void 0 ? void 0 : (_this$leftOverflowNav2 = _this$leftOverflowNav.current) === null || _this$leftOverflowNav2 === void 0 ? void 0 : _this$leftOverflowNav2.focus();
-        }
+      if (!longPress) {
+        setScrollLeft(Math.max(scrollLeft - ref.current.scrollWidth / tabs.current.length * 1.5, 0));
       }
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "handleOverflowNavMouseDown", function (event, _ref4) {
-      var direction = _ref4.direction;
+    },
+    onLongPress: function onLongPress() {
+      return createLongPressBehavior(ref, 'backward', setScrollLeft);
+    }
+  });
+  usePressable(nextButton, {
+    onPress: function onPress(_ref4) {
+      var longPress = _ref4.longPress;
 
-      // disregard mouse buttons aside from left mouse button
-      if (event.buttons !== 1) {
-        return;
+      if (!longPress) {
+        setScrollLeft(Math.min(scrollLeft + ref.current.scrollWidth / tabs.current.length * 1.5, ref.current.scrollWidth - ref.current.clientWidth));
       }
+    },
+    onLongPress: function onLongPress() {
+      return createLongPressBehavior(ref, 'forward', setScrollLeft);
+    }
+  });
+  return /*#__PURE__*/React__default.createElement("div", {
+    className: className
+  }, /*#__PURE__*/React__default.createElement("button", _extends({
+    "aria-hidden": "true",
+    "aria-label": "Scroll left",
+    ref: previousButton,
+    className: previousButtonClasses,
+    type: "button"
+  }, leftOverflowButtonProps), _ChevronLeft || (_ChevronLeft = /*#__PURE__*/React__default.createElement(ChevronLeft, null))), /*#__PURE__*/React__default.createElement("div", _extends({}, rest, {
+    "aria-label": label,
+    ref: ref,
+    role: "tablist",
+    className: "".concat(prefix, "--tab--list"),
+    onScroll: debouncedOnScroll,
+    onKeyDown: onKeyDown
+  }), React__default.Children.map(children, function (child, index) {
+    return /*#__PURE__*/React__default.createElement(TabContext.Provider, {
+      value: index
+    }, /*#__PURE__*/React__default.cloneElement(child, {
+      ref: function ref(node) {
+        tabs.current[index] = node;
+      }
+    }));
+  })), /*#__PURE__*/React__default.createElement("button", _extends({
+    "aria-hidden": "true",
+    "aria-label": "Scroll right",
+    ref: nextButton,
+    className: nextButtonClasses,
+    type: "button"
+  }, rightOverflowButtonProps), _ChevronRight || (_ChevronRight = /*#__PURE__*/React__default.createElement(ChevronRight, null))));
+}
+
+TabList.propTypes = {
+  /**
+   * Specify whether the content tab should be activated automatically or
+   * manually
+   */
+  activation: PropTypes.oneOf(['automatic', 'manual']),
 
-      _this.overflowNavInterval = setInterval(function () {
-        var _this$tablist3;
-
-        var _this$tablist$current3 = (_this$tablist3 = _this.tablist) === null || _this$tablist3 === void 0 ? void 0 : _this$tablist3.current,
-            clientWidth = _this$tablist$current3.clientWidth,
-            scrollLeft = _this$tablist$current3.scrollLeft,
-            scrollWidth = _this$tablist$current3.scrollWidth; // clear interval if scroll reaches left or right edge
-
-
-        var leftEdgeReached = direction === -1 && scrollLeft < _this.OVERFLOW_BUTTON_OFFSET;
-        var rightEdgeReached = direction === 1 && scrollLeft + clientWidth >= scrollWidth - _this.OVERFLOW_BUTTON_OFFSET;
-
-        if (leftEdgeReached || rightEdgeReached) {
-          clearInterval(_this.overflowNavInterval);
-        } // account for overflow button appearing and causing tablist width change
-
-
-        _this.handleOverflowNavClick(event, {
-          direction: direction
-        });
-      });
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "handleOverflowNavMouseUp", function () {
-      clearInterval(_this.overflowNavInterval);
-    });
+  /**
+   * Provide an accessible label to be read when a user interacts with this
+   * component
+   */
+  'aria-label': PropTypes.string.isRequired,
 
-    return _this;
-  }
+  /**
+   * Provide child elements to be rendered inside of `ContentTabs`.
+   * These elements should render a `ContentTab`
+   */
+  children: PropTypes.node,
 
-  _createClass(Tabs, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      var _this$tablist4;
+  /**
+   * Specify an optional className to be added to the container node
+   */
+  className: PropTypes.string,
 
-      if (!this._debouncedHandleWindowResize) {
-        this._debouncedHandleWindowResize = debounce(this._handleWindowResize, 200);
-      }
+  /**
+   * Specify whether component is contained type
+   */
+  contained: PropTypes.bool,
 
-      this._handleWindowResize();
+  /**
+   * If using `IconTab`, specify the size of the icon being used.
+   */
+  iconSize: PropTypes.oneOf(['default', 'lg']),
 
-      window.addEventListener('resize', this._debouncedHandleWindowResize);
+  /**
+   * Provide the props that describe the left overflow button
+   */
+  leftOverflowButtonProps: PropTypes.object,
 
-      if (!this._debouncedHandleScroll) {
-        this._debouncedHandleScroll = debounce(this._handleScroll, this.props.scrollDebounceWait);
-      } // scroll selected tab into view on mount
+  /**
+   * Specify whether or not to use the light component variant
+   */
+  light: PropTypes.bool,
 
+  /**
+   * Provide the props that describe the right overflow button
+   */
+  rightOverflowButtonProps: PropTypes.object,
 
-      var _ref5 = ((_this$tablist4 = this.tablist) === null || _this$tablist4 === void 0 ? void 0 : _this$tablist4.current) || {},
-          tablistClientWidth = _ref5.clientWidth,
-          tablistScrollLeft = _ref5.scrollLeft,
-          tablistScrollWidth = _ref5.scrollWidth;
+  /**
+   * Optionally provide a delay (in milliseconds) passed to the lodash
+   * debounce of the onScroll handler. This will impact the responsiveness
+   * of scroll arrow buttons rendering when scrolling to the first or last tab.
+   */
+  scrollDebounceWait: PropTypes.number,
 
-      var tab = this.getTabAt(this.state.selected);
-      var horizontalOverflow = tablistScrollWidth > tablistClientWidth;
+  /**
+   * Choose whether or not to automatically scroll to newly selected tabs
+   * on component rerender
+   */
+  scrollIntoView: PropTypes.bool
+};
+/**
+ * Helper function to setup the behavior when a button is "long pressed". This
+ * function will take a ref to the tablist, a direction, and a setter for
+ * scrollLeft and will update the scroll position within a
+ * requestAnimationFrame.
+ *
+ * It returns a cleanup function to be run when the long press is
+ * deactivated
+ *
+ * @param {RefObject} ref
+ * @param {'forward' | 'backward'} direction
+ * @param {Function} setScrollLeft
+ * @returns {Function}
+ */
 
-      if (horizontalOverflow) {
-        var _tab$tabAnchor4, _tab$tabAnchor5, _tab$tabAnchor6;
+function createLongPressBehavior(ref, direction, setScrollLeft) {
+  // We manually override the scroll behavior to be "auto". If it is set as
+  // smooth, this animation does not update correctly
+  var defaultScrollBehavior = ref.current.style['scroll-behavior'];
+  ref.current.style['scroll-behavior'] = 'auto';
+  var scrollDelta = direction === 'forward' ? 5 : -5;
+  var frameId = null;
+
+  function tick() {
+    ref.current.scrollLeft = ref.current.scrollLeft + scrollDelta;
+    frameId = requestAnimationFrame(tick);
+  }
 
-        var leftOverflowNavButtonHidden = (tab === null || tab === void 0 ? void 0 : (_tab$tabAnchor4 = tab.tabAnchor) === null || _tab$tabAnchor4 === void 0 ? void 0 : _tab$tabAnchor4.getBoundingClientRect().right) < (tab === null || tab === void 0 ? void 0 : (_tab$tabAnchor5 = tab.tabAnchor) === null || _tab$tabAnchor5 === void 0 ? void 0 : _tab$tabAnchor5.offsetParent.getBoundingClientRect().right);
-        var rightOverflowNavButtonHidden = tablistScrollLeft + tablistClientWidth === tablistScrollWidth;
-        this.props.scrollIntoView && (tab === null || tab === void 0 ? void 0 : (_tab$tabAnchor6 = tab.tabAnchor) === null || _tab$tabAnchor6 === void 0 ? void 0 : _tab$tabAnchor6.scrollIntoView({
-          block: 'nearest',
-          inline: 'nearest'
-        })); // account for overflow buttons in scroll position on mount
+  frameId = requestAnimationFrame(tick);
+  return function () {
+    // Restore the previous scroll behavior
+    ref.current.style['scroll-behavior'] = defaultScrollBehavior; // Make sure that our `scrollLeft` value is in sync with the existing
+    // `ref` after our requestAnimationFrame loop above
 
-        if (!leftOverflowNavButtonHidden && !rightOverflowNavButtonHidden) {
-          this.tablist.current.scrollLeft += this.OVERFLOW_BUTTON_OFFSET * 2;
-        }
-      }
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      if (this._debouncedHandleWindowResize) {
-        this._debouncedHandleWindowResize.cancel();
-      }
+    setScrollLeft(ref.current.scrollLeft);
 
-      window.removeEventListener('resize', this._debouncedHandleWindowResize);
+    if (frameId) {
+      cancelAnimationFrame(frameId);
     }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(_, prevState) {
-      // compare current tablist properties to current state
-      var _this$tablist$current4 = this.tablist.current,
-          tablistClientWidth = _this$tablist$current4.clientWidth,
-          tablistScrollLeft = _this$tablist$current4.scrollLeft,
-          tablistScrollWidth = _this$tablist$current4.scrollWidth;
-      var _this$state = this.state,
-          currentStateClientWidth = _this$state.tablistClientWidth,
-          currentStateScrollLeft = _this$state.tablistScrollLeft,
-          currentStateScrollWidth = _this$state.tablistScrollWidth,
-          selected = _this$state.selected;
-
-      if (tablistClientWidth !== currentStateClientWidth || tablistScrollLeft !== currentStateScrollLeft || tablistScrollWidth !== currentStateScrollWidth) {
-        this.setState({
-          horizontalOverflow: tablistScrollWidth > tablistClientWidth,
-          tablistClientWidth: tablistClientWidth,
-          tablistScrollLeft: tablistScrollLeft,
-          tablistScrollWidth: tablistScrollWidth
-        });
+  };
+}
+
+var Tab = /*#__PURE__*/React__default.forwardRef(function Tab(_ref5, ref) {
+  var _cx4;
+
+  var _ref5$as = _ref5.as,
+      BaseComponent = _ref5$as === void 0 ? 'button' : _ref5$as,
+      children = _ref5.children,
+      customClassName = _ref5.className,
+      disabled = _ref5.disabled,
+      _onClick = _ref5.onClick,
+      onKeyDown = _ref5.onKeyDown,
+      rest = _objectWithoutProperties(_ref5, _excluded2);
+
+  var prefix = usePrefix();
+
+  var _React$useContext2 = React__default.useContext(TabsContext),
+      selectedIndex = _React$useContext2.selectedIndex,
+      setSelectedIndex = _React$useContext2.setSelectedIndex,
+      baseId = _React$useContext2.baseId;
+
+  var index = React__default.useContext(TabContext);
+  var id = "".concat(baseId, "-tab-").concat(index);
+  var panelId = "".concat(baseId, "-tabpanel-").concat(index);
+  var className = cx("".concat(prefix, "--tabs__nav-item"), "".concat(prefix, "--tabs__nav-link"), customClassName, (_cx4 = {}, _defineProperty(_cx4, "".concat(prefix, "--tabs__nav-item--selected"), selectedIndex === index), _defineProperty(_cx4, "".concat(prefix, "--tabs__nav-item--disabled"), disabled), _cx4));
+  return /*#__PURE__*/React__default.createElement(BaseComponent, _extends({}, rest, {
+    "aria-controls": panelId,
+    "aria-disabled": disabled,
+    "aria-selected": selectedIndex === index,
+    ref: ref,
+    id: id,
+    role: "tab",
+    className: className,
+    disabled: disabled,
+    onClick: function onClick(evt) {
+      if (disabled) {
+        return;
       }
 
-      if (this.props.scrollIntoView && prevState.selected !== selected) {
-        var _this$getTabAt, _this$getTabAt$tabAnc;
+      setSelectedIndex(index);
 
-        (_this$getTabAt = this.getTabAt(selected)) === null || _this$getTabAt === void 0 ? void 0 : (_this$getTabAt$tabAnc = _this$getTabAt.tabAnchor) === null || _this$getTabAt$tabAnc === void 0 ? void 0 : _this$getTabAt$tabAnc.scrollIntoView({
-          block: 'nearest',
-          inline: 'nearest'
-        });
+      if (_onClick) {
+        _onClick(evt);
       }
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this2 = this,
-          _classNames,
-          _classNames2,
-          _classNames3;
-
-      var _this$props = this.props,
-          className = _this$props.className,
-          type = _this$props.type,
-          light = _this$props.light,
-          onSelectionChange = _this$props.onSelectionChange;
-          _this$props.scrollDebounceWait;
-          _this$props.scrollIntoView;
-          _this$props.selectionMode;
-          var tabContentClassName = _this$props.tabContentClassName,
-          leftOverflowButtonProps = _this$props.leftOverflowButtonProps,
-          rightOverflowButtonProps = _this$props.rightOverflowButtonProps,
-          other = _objectWithoutProperties(_this$props, _excluded);
-
-      var prefix = this.context;
-      /**
-       * The tab panel acts like a tab panel when the screen is wider, but acts
-       * like a select list when the screen is narrow.  In the wide case we want
-       * to allow the user to use the tab key to set the focus in the tab panel
-       * and then use the left and right arrow keys to navigate the tabs.  In the
-       * narrow case we want to use the tab key to select different options in
-       * the list.
-       *
-       * We set the tab index based on the different states so the browser will treat
-       * the whole tab panel as a single focus component when it looks like a tab
-       * panel and separate components when it looks like a select list.
-       */
-
-      var tabsWithProps = this.getTabs().map(function (tab, index) {
-        var tabIndex = index === _this2.state.selected ? 0 : -1;
-        var newTab = /*#__PURE__*/React__default.cloneElement(tab, {
-          index: index,
-          selected: index === _this2.state.selected,
-          handleTabClick: _this2.handleTabClick(onSelectionChange),
-          tabIndex: tabIndex,
-          ref: function ref(e) {
-            _this2.setTabAt(index, e);
-          },
-          handleTabKeyDown: _this2.handleTabKeyDown(onSelectionChange)
-        });
-        return newTab;
-      });
-      var tabContentWithProps = React__default.Children.map(tabsWithProps, function (tab) {
-        var _tab$props = tab.props,
-            tabId = _tab$props.id,
-            children = _tab$props.children,
-            selected = _tab$props.selected,
-            _tab$props$renderCont = _tab$props.renderContent,
-            Content = _tab$props$renderCont === void 0 ? TabContent : _tab$props$renderCont;
-        return /*#__PURE__*/React__default.createElement(Content, {
-          id: tabId && "".concat(tabId, "__panel"),
-          className: tabContentClassName,
-          hidden: !selected,
-          selected: selected,
-          "aria-labelledby": tabId
-        }, children);
-      });
-      var leftOverflowNavButtonHidden = !this.state.horizontalOverflow || !this.state.tablistScrollLeft;
-      var rightOverflowNavButtonHidden = !this.state.horizontalOverflow || this.state.tablistScrollLeft + this.state.tablistClientWidth === this.state.tablistScrollWidth;
-      var classes = {
-        // TODO: remove scrollable from classnames in next major release and uncomment classnames that don't contain scrollable
-        tabs: cx(className, // `${prefix}--tabs`,
-        "".concat(prefix, "--tabs--scrollable"), (_classNames = {}, _defineProperty(_classNames, "".concat(prefix, "--tabs--scrollable--container"), type === 'container'), _defineProperty(_classNames, "".concat(prefix, "--tabs--scrollable--light"), light), _classNames)),
-        // TODO: remove scrollable from classnames in next major release and uncomment classnames that don't contain scrollable
-        tablist: cx( // `${prefix}--tabs__nav`,
-        "".concat(prefix, "--tabs--scrollable__nav")),
-        leftOverflowButtonClasses: cx((_classNames2 = {}, _defineProperty(_classNames2, "".concat(prefix, "--tab--overflow-nav-button"), this.state.horizontalOverflow), _defineProperty(_classNames2, "".concat(prefix, "--tab--overflow-nav-button--hidden"), leftOverflowNavButtonHidden), _classNames2)),
-        rightOverflowButtonClasses: cx((_classNames3 = {}, _defineProperty(_classNames3, "".concat(prefix, "--tab--overflow-nav-button"), this.state.horizontalOverflow), _defineProperty(_classNames3, "".concat(prefix, "--tab--overflow-nav-button--hidden"), rightOverflowNavButtonHidden), _classNames3))
-      };
-      return /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement("div", _extends({}, other, {
-        className: classes.tabs
-      }), /*#__PURE__*/React__default.createElement("button", _extends({
-        "aria-hidden": "true",
-        "aria-label": "Scroll left",
-        className: classes.leftOverflowButtonClasses,
-        onClick: function onClick(_) {
-          return _this2.handleOverflowNavClick(_, {
-            direction: -1
-          });
-        },
-        onMouseDown: function onMouseDown(event) {
-          return _this2.handleOverflowNavMouseDown(event, {
-            direction: -1
-          });
-        },
-        onMouseUp: this.handleOverflowNavMouseUp,
-        ref: this.leftOverflowNavButton,
-        tabIndex: "-1",
-        type: "button"
-      }, leftOverflowButtonProps), _ChevronLeft || (_ChevronLeft = /*#__PURE__*/React__default.createElement(ChevronLeft, null))), !leftOverflowNavButtonHidden && /*#__PURE__*/React__default.createElement("div", {
-        className: "".concat(prefix, "--tabs__overflow-indicator--left")
-      }), /*#__PURE__*/React__default.createElement("ul", {
-        role: "tablist",
-        tabIndex: -1,
-        className: classes.tablist,
-        ref: this.tablist,
-        onScroll: this._debouncedHandleScroll
-      }, tabsWithProps), !rightOverflowNavButtonHidden && /*#__PURE__*/React__default.createElement("div", {
-        className: "".concat(prefix, "--tabs__overflow-indicator--right")
-      }), /*#__PURE__*/React__default.createElement("button", _extends({
-        "aria-hidden": "true",
-        "aria-label": "Scroll right",
-        className: classes.rightOverflowButtonClasses,
-        onClick: function onClick(_) {
-          return _this2.handleOverflowNavClick(_, {
-            direction: 1
-          });
-        },
-        onMouseDown: function onMouseDown(event) {
-          return _this2.handleOverflowNavMouseDown(event, {
-            direction: 1
-          });
-        },
-        onMouseUp: this.handleOverflowNavMouseUp,
-        ref: this.rightOverflowNavButton,
-        tabIndex: "-1",
-        type: "button"
-      }, rightOverflowButtonProps), _ChevronRight || (_ChevronRight = /*#__PURE__*/React__default.createElement(ChevronRight, null)))), tabContentWithProps);
-    }
-  }], [{
-    key: "getDerivedStateFromProps",
-    value: function getDerivedStateFromProps(_ref6, state) {
-      var selected = _ref6.selected;
-      var prevSelected = state.prevSelected;
-      return prevSelected === selected ? null : {
-        selected: selected,
-        prevSelected: selected
-      };
-    }
-    /**
-     * `scroll` event handler to save tablist clientWidth, scrollWidth, and
-     * scrollLeft
-     */
-
-  }]);
-
-  return Tabs;
-}(React__default.Component);
+    },
+    onKeyDown: onKeyDown,
+    tabIndex: selectedIndex === index ? '0' : '-1',
+    type: "button"
+  }), children);
+});
+Tab.propTypes = {
+  /**
+   * Provide a custom element to render instead of the default button
+   */
+  as: PropTypes.oneOfType([PropTypes.string, PropTypes.elementType]),
 
-_defineProperty(Tabs, "propTypes", {
   /**
-   * Pass in a collection of <Tab> children to be rendered depending on the
-   * currently selected tab
+   * Provide child elements to be rendered inside of `Tab`.
    */
   children: PropTypes.node,
 
   /**
-   * Provide a className that is applied to the root <div> component for the
-   * <Tabs>
+   * Specify an optional className to be added to your Tab
    */
   className: PropTypes.string,
 
   /**
-   * Specify whether the Tab content is hidden
+   * Whether your Tab is disabled.
    */
-  hidden: PropTypes.bool,
+  disabled: PropTypes.bool,
 
   /**
-   * Provide the props that describe the left overflow button
+   * Provide a handler that is invoked when a user clicks on the control
    */
-  leftOverflowButtonProps: PropTypes.object,
+  onClick: PropTypes.func,
 
   /**
-   * Specify whether or not to use the light component variant
+   * Provide a handler that is invoked on the key down event for the control
    */
-  light: PropTypes.bool,
+  onKeyDown: PropTypes.func,
 
+  /*
+   * An optional parameter to allow overriding the anchor rendering.
+   * Useful for using Tab along with react-router or other client
+   * side router libraries.
+   **/
+  renderButton: PropTypes.func
+};
+var IconTab = /*#__PURE__*/React__default.forwardRef(function IconTab(_ref6, ref) {
+  var children = _ref6.children,
+      customClassName = _ref6.className,
+      _ref6$defaultOpen = _ref6.defaultOpen,
+      defaultOpen = _ref6$defaultOpen === void 0 ? false : _ref6$defaultOpen,
+      enterDelayMs = _ref6.enterDelayMs,
+      leaveDelayMs = _ref6.leaveDelayMs,
+      label = _ref6.label,
+      rest = _objectWithoutProperties(_ref6, _excluded3);
+
+  var prefix = usePrefix();
+  var classNames = cx("".concat(prefix, "--tabs__nav-item--icon"), customClassName);
+  return /*#__PURE__*/React__default.createElement(Tooltip, {
+    align: "bottom",
+    defaultOpen: defaultOpen,
+    className: "".concat(prefix, "--icon-tooltip"),
+    enterDelayMs: enterDelayMs,
+    label: label,
+    leaveDelayMs: leaveDelayMs
+  }, /*#__PURE__*/React__default.createElement(Tab, _extends({
+    className: classNames,
+    ref: ref
+  }, rest), children));
+});
+IconTab.propTypes = {
   /**
-   * Optionally provide an `onClick` handler that is invoked when a <Tab> is
-   * clicked
+   * Provide an icon to be rendered inside of `IconTab` as the visual label for Tab.
    */
-  onClick: PropTypes.func,
+  children: PropTypes.node,
 
   /**
-   * Optionally provide an `onKeyDown` handler that is invoked when keyed
-   * navigation is triggered
+   * Specify an optional className to be added to your Tab
    */
-  onKeyDown: PropTypes.func,
+  className: PropTypes.string,
 
   /**
-   * Provide an optional handler that is called whenever the selection
-   * changes. This method is called with the index of the tab that was
-   * selected
+   * Specify whether the tooltip for the icon should be open when it first renders
    */
-  onSelectionChange: PropTypes.func,
+  defaultOpen: PropTypes.bool,
 
   /**
-   * Provide the props that describe the right overflow button
+   * Specify the duration in milliseconds to delay before displaying the tooltip for the icon.
    */
-  rightOverflowButtonProps: PropTypes.object,
+  enterDelayMs: PropTypes.number,
 
   /**
-   * Optionally provide a delay (in milliseconds) passed to the lodash
-   * debounce of the onScroll handler. This will impact the responsiveness
-   * of scroll arrow buttons rendering when scrolling to the first or last tab.
+   * Provide the label to be rendered inside of the Tooltip. The label will use
+   * `aria-labelledby` and will fully describe the child node that is provided.
+   * This means that if you have text in the child node it will not be
+   * announced to the screen reader.
    */
-  scrollDebounceWait: PropTypes.number,
+  label: PropTypes.node.isRequired,
 
   /**
-   * Choose whether or not to automatically scroll to newly selected tabs
-   * on component rerender
+   * Specify the duration in milliseconds to delay before hiding the tooltip
    */
-  scrollIntoView: PropTypes.bool,
+  leaveDelayMs: PropTypes.number
+};
+var TabPanel = /*#__PURE__*/React__default.forwardRef(function TabPanel(_ref7, forwardRef) {
+  var children = _ref7.children,
+      customClassName = _ref7.className,
+      rest = _objectWithoutProperties(_ref7, _excluded4);
+
+  var prefix = usePrefix();
+  var panel = useRef(null);
+  var ref = useMergedRefs([forwardRef, panel]);
+
+  var _useState7 = useState('0'),
+      _useState8 = _slicedToArray(_useState7, 2),
+      tabIndex = _useState8[0],
+      setTabIndex = _useState8[1];
+
+  var _useState9 = useState(false),
+      _useState10 = _slicedToArray(_useState9, 2),
+      interactiveContent = _useState10[0],
+      setInteractiveContent = _useState10[1];
+
+  var _React$useContext3 = React__default.useContext(TabsContext),
+      selectedIndex = _React$useContext3.selectedIndex,
+      baseId = _React$useContext3.baseId;
+
+  var index = React__default.useContext(TabPanelContext);
+  var id = "".concat(baseId, "-tabpanel-").concat(index);
+  var tabId = "".concat(baseId, "-tab-").concat(index);
+  var className = cx("".concat(prefix, "--tab-content"), customClassName, _defineProperty({}, "".concat(prefix, "--tab-content--interactive"), interactiveContent));
+  useEffectOnce(function () {
+    if (!panel.current) {
+      return;
+    }
 
-  /**
-   * Optionally provide an index for the currently selected <Tab>
-   */
-  selected: PropTypes.number,
+    var content = getInteractiveContent(panel.current);
+
+    if (content) {
+      setInteractiveContent(true);
+      setTabIndex('-1');
+    }
+  }); // tabindex should only be 0 if no interactive content in children
+
+  useEffect(function () {
+    if (!panel.current) {
+      return;
+    }
+
+    var node = panel.current;
+
+    function callback() {
+      var content = getInteractiveContent(node);
 
+      if (content) {
+        setInteractiveContent(true);
+        setTabIndex('-1');
+      } else {
+        setInteractiveContent(false);
+        setTabIndex('0');
+      }
+    }
+
+    var observer = new MutationObserver(callback);
+    observer.observe(node, {
+      childList: true,
+      subtree: true
+    });
+    return function () {
+      observer.disconnect(node);
+    };
+  }, []);
+  return /*#__PURE__*/React__default.createElement("div", _extends({}, rest, {
+    "aria-labelledby": tabId,
+    id: id,
+    className: className,
+    ref: ref,
+    role: "tabpanel",
+    tabIndex: tabIndex,
+    hidden: selectedIndex !== index
+  }), children);
+});
+TabPanel.propTypes = {
   /**
-   * Choose whether or not to automatically change selection on focus
+   * Provide child elements to be rendered inside of `TabPanel`.
    */
-  selectionMode: PropTypes.oneOf(['automatic', 'manual']),
+  children: PropTypes.node,
 
   /**
-   * Provide a className that is applied to the <TabContent> components
+   * Specify an optional className to be added to TabPanel.
    */
-  tabContentClassName: PropTypes.string,
-
+  className: PropTypes.string
+};
+
+function TabPanels(_ref8) {
+  var children = _ref8.children;
+  return React__default.Children.map(children, function (child, index) {
+    return /*#__PURE__*/React__default.createElement(TabPanelContext.Provider, {
+      value: index
+    }, child);
+  });
+}
+
+TabPanels.propTypes = {
   /**
-   * Provide the type of Tab
+   * Provide child elements to be rendered inside of `TabPanels`.
    */
-  type: PropTypes.oneOf(['default', 'container'])
-});
-
-_defineProperty(Tabs, "defaultProps", {
-  type: 'default',
-  scrollIntoView: true,
-  selected: 0,
-  selectionMode: 'automatic',
-  scrollDebounceWait: 150
-});
-
-_defineProperty(Tabs, "contextType", PrefixContext);
+  children: PropTypes.node
+};
 
-export { Tabs as default };
+export { IconTab, Tab, TabList, TabPanel, TabPanels, Tabs };