@carbon/react 1.27.0 → 1.28.0

package/es/components/OverflowMenu/OverflowMenu.js

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { defineProperty as _defineProperty, inherits as _inherits, createSuper as _createSuper, classCallCheck as _classCallCheck, assertThisInitialized as _assertThisInitialized, createClass as _createClass, objectWithoutProperties as _objectWithoutProperties, extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { defineProperty as _defineProperty, extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js';
 import invariant from 'invariant';
 import PropTypes from 'prop-types';
 import React__default, { Component } from 'react';
@@ -20,21 +20,18 @@ import { IconButton } from '../IconButton/index.js';
 import { matches } from '../../internal/keyboard/match.js';
 import { ArrowUp, ArrowRight, ArrowDown, ArrowLeft, Escape } from '../../internal/keyboard/keys.js';
 
-var _excluded = ["id", "aria-label", "ariaLabel", "children", "iconDescription", "direction", "flipped", "focusTrap", "menuOffset", "menuOffsetFlip", "iconClass", "onClick", "onOpen", "selectorPrimaryFocus", "renderIcon", "innerRef", "menuOptionsClass", "light", "size"];
-
-var _triggerButtonPositio, _triggerButtonPositio2, _defineProperty2, _defineProperty3;
-
-var on = function on(element) {
+const on = function (element) {
   for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
     args[_key - 1] = arguments[_key];
   }
 
-  element.addEventListener.apply(element, args);
+  element.addEventListener(...args);
   return {
-    release: function release() {
-      element.removeEventListener.apply(element, args);
+    release() {
+      element.removeEventListener(...args);
       return null;
     }
+
   };
 };
 /**
@@ -43,13 +40,19 @@ var on = function on(element) {
  */
 
 
-var triggerButtonPositionProps = (_triggerButtonPositio = {}, _defineProperty(_triggerButtonPositio, DIRECTION_TOP, 'bottom'), _defineProperty(_triggerButtonPositio, DIRECTION_BOTTOM, 'top'), _triggerButtonPositio);
+const triggerButtonPositionProps = {
+  [DIRECTION_TOP]: 'bottom',
+  [DIRECTION_BOTTOM]: 'top'
+};
 /**
  * Determines how the position of arrow should affect the floating menu position.
  * @type {Object<string, number>}
  */
 
-var triggerButtonPositionFactors = (_triggerButtonPositio2 = {}, _defineProperty(_triggerButtonPositio2, DIRECTION_TOP, -2), _defineProperty(_triggerButtonPositio2, DIRECTION_BOTTOM, -1), _triggerButtonPositio2);
+const triggerButtonPositionFactors = {
+  [DIRECTION_TOP]: -2,
+  [DIRECTION_BOTTOM]: -1
+};
 /**
  * @param {Element} menuBody The menu body with the menu arrow.
  * @param {string} direction The floating menu direction.
@@ -57,23 +60,25 @@ var triggerButtonPositionFactors = (_triggerButtonPositio2 = {}, _defineProperty
  * @private
  */
 
-var getMenuOffset = function getMenuOffset(menuBody, direction, trigger, flip) {
-  var triggerButtonPositionProp = triggerButtonPositionProps[direction];
-  var triggerButtonPositionFactor = triggerButtonPositionFactors[direction];
+const getMenuOffset = (menuBody, direction, trigger, flip) => {
+  const triggerButtonPositionProp = triggerButtonPositionProps[direction];
+  const triggerButtonPositionFactor = triggerButtonPositionFactors[direction];
 
   if (process.env.NODE_ENV !== "production") {
     !(triggerButtonPositionProp && triggerButtonPositionFactor) ? process.env.NODE_ENV !== "production" ? invariant(false, '[OverflowMenu] wrong floating menu direction: `%s`', direction) : invariant(false) : void 0;
   }
 
-  var menuWidth = menuBody.offsetWidth,
-      menuHeight = menuBody.offsetHeight;
+  const {
+    offsetWidth: menuWidth,
+    offsetHeight: menuHeight
+  } = menuBody;
 
   switch (triggerButtonPositionProp) {
     case 'top':
     case 'bottom':
       {
         // TODO: Ensure `trigger` is there for `<OverflowMenu open>`
-        var triggerWidth = !trigger ? 0 : trigger.offsetWidth;
+        const triggerWidth = !trigger ? 0 : trigger.offsetWidth;
         return {
           left: (!flip ? 1 : -1) * (menuWidth / 2 - triggerWidth / 2),
           top: 0
@@ -84,7 +89,7 @@ var getMenuOffset = function getMenuOffset(menuBody, direction, trigger, flip) {
     case 'right':
       {
         // TODO: Ensure `trigger` is there for `<OverflowMenu open>`
-        var triggerHeight = !trigger ? 0 : trigger.offsetHeight;
+        const triggerHeight = !trigger ? 0 : trigger.offsetHeight;
         return {
           left: 0,
           top: (!flip ? 1 : -1) * (menuHeight / 2 - triggerHeight / 2)
@@ -93,97 +98,86 @@ var getMenuOffset = function getMenuOffset(menuBody, direction, trigger, flip) {
   }
 };
 
-var OverflowMenu = /*#__PURE__*/function (_Component) {
-  _inherits(OverflowMenu, _Component);
-
-  var _super = _createSuper(OverflowMenu);
-
-  function OverflowMenu() {
-    var _this;
-
-    _classCallCheck(this, OverflowMenu);
-
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
-    }
-
-    _this = _super.call.apply(_super, [this].concat(args));
+class OverflowMenu extends Component {
+  constructor() {
+    super(...arguments);
 
-    _defineProperty(_assertThisInitialized(_this), "state", {});
+    _defineProperty(this, "state", {});
 
-    _defineProperty(_assertThisInitialized(_this), "_hFocusIn", null);
+    _defineProperty(this, "_hFocusIn", null);
 
-    _defineProperty(_assertThisInitialized(_this), "_hBlurTimeout", void 0);
+    _defineProperty(this, "_hBlurTimeout", void 0);
 
-    _defineProperty(_assertThisInitialized(_this), "_triggerRef", /*#__PURE__*/React__default.createRef());
+    _defineProperty(this, "_triggerRef", /*#__PURE__*/React__default.createRef());
 
-    _defineProperty(_assertThisInitialized(_this), "handleClick", function (evt) {
+    _defineProperty(this, "handleClick", evt => {
       evt.stopPropagation();
 
-      if (!_this._menuBody || !_this._menuBody.contains(evt.target)) {
-        _this.setState({
-          open: !_this.state.open
+      if (!this._menuBody || !this._menuBody.contains(evt.target)) {
+        this.setState({
+          open: !this.state.open
         });
-
-        _this.props.onClick(evt);
+        this.props.onClick(evt);
       }
     });
 
-    _defineProperty(_assertThisInitialized(_this), "closeMenuAndFocus", function () {
-      var wasOpen = _this.state.open;
-
-      _this.closeMenu(function () {
+    _defineProperty(this, "closeMenuAndFocus", () => {
+      let wasOpen = this.state.open;
+      this.closeMenu(() => {
         if (wasOpen) {
-          _this.focusMenuEl();
+          this.focusMenuEl();
         }
       });
     });
 
-    _defineProperty(_assertThisInitialized(_this), "handleKeyPress", function (evt) {
-      if (_this.state.open && matches(evt, [ArrowUp, ArrowRight, ArrowDown, ArrowLeft])) {
+    _defineProperty(this, "handleKeyPress", evt => {
+      if (this.state.open && matches(evt, [ArrowUp, ArrowRight, ArrowDown, ArrowLeft])) {
         evt.preventDefault();
       } // Close the overflow menu on escape
 
 
       if (matches(evt, [Escape])) {
-        _this.closeMenuAndFocus(); // Stop the esc keypress from bubbling out and closing something it shouldn't
-
+        this.closeMenuAndFocus(); // Stop the esc keypress from bubbling out and closing something it shouldn't
 
         evt.stopPropagation();
       }
     });
 
-    _defineProperty(_assertThisInitialized(_this), "handleClickOutside", function (evt) {
-      if (_this.state.open && (!_this._menuBody || !_this._menuBody.contains(evt.target))) {
-        _this.closeMenu();
+    _defineProperty(this, "handleClickOutside", evt => {
+      if (this.state.open && (!this._menuBody || !this._menuBody.contains(evt.target))) {
+        this.closeMenu();
       }
     });
 
-    _defineProperty(_assertThisInitialized(_this), "closeMenu", function (onCloseMenu) {
-      _this.setState({
+    _defineProperty(this, "closeMenu", onCloseMenu => {
+      this.setState({
         open: false
-      }, function () {
+      }, () => {
         // Optional callback to be executed after the state as been set to close
         if (onCloseMenu) {
           onCloseMenu();
         }
 
-        _this.props.onClose();
+        this.props.onClose();
       });
     });
 
-    _defineProperty(_assertThisInitialized(_this), "focusMenuEl", function () {
-      var triggerEl = _this._triggerRef.current;
+    _defineProperty(this, "focusMenuEl", () => {
+      const {
+        current: triggerEl
+      } = this._triggerRef;
 
       if (triggerEl) {
         triggerEl.focus();
       }
     });
 
-    _defineProperty(_assertThisInitialized(_this), "handleOverflowMenuItemFocus", function (_ref) {
-      var currentIndex = _ref.currentIndex,
-          direction = _ref.direction;
-      var enabledIndices = React__default.Children.toArray(_this.props.children).reduce(function (acc, curr, i) {
+    _defineProperty(this, "handleOverflowMenuItemFocus", _ref => {
+      let {
+        currentIndex,
+        direction
+      } = _ref;
+      const enabledIndices = React__default.Children.toArray(this.props.children).reduce((acc, curr, i) => {
         if (!curr.props.disabled) {
           acc.push(i);
         }
@@ -191,8 +185,8 @@ var OverflowMenu = /*#__PURE__*/function (_Component) {
         return acc;
       }, []);
 
-      var nextValidIndex = function () {
-        var nextIndex = enabledIndices.indexOf(currentIndex) + direction;
+      const nextValidIndex = (() => {
+        const nextIndex = enabledIndices.indexOf(currentIndex) + direction;
 
         switch (nextIndex) {
           case -1:
@@ -204,201 +198,340 @@ var OverflowMenu = /*#__PURE__*/function (_Component) {
           default:
             return nextIndex;
         }
-      }();
-
-      var overflowMenuItem = _this["overflowMenuItem".concat(enabledIndices[nextValidIndex])];
+      })();
 
+      const overflowMenuItem = this[`overflowMenuItem${enabledIndices[nextValidIndex]}`];
       overflowMenuItem === null || overflowMenuItem === void 0 ? void 0 : overflowMenuItem.focus();
     });
 
-    _defineProperty(_assertThisInitialized(_this), "_bindMenuBody", function (menuBody) {
+    _defineProperty(this, "_bindMenuBody", menuBody => {
       if (!menuBody) {
-        _this._menuBody = menuBody;
+        this._menuBody = menuBody;
       }
 
-      if (!menuBody && _this._hFocusIn) {
-        _this._hFocusIn = _this._hFocusIn.release();
+      if (!menuBody && this._hFocusIn) {
+        this._hFocusIn = this._hFocusIn.release();
       }
     });
 
-    _defineProperty(_assertThisInitialized(_this), "_handlePlace", function (menuBody) {
+    _defineProperty(this, "_handlePlace", menuBody => {
       if (menuBody) {
-        _this._menuBody = menuBody;
-        var hasFocusin = ('onfocusin' in window);
-        var focusinEventName = hasFocusin ? 'focusin' : 'focus';
-        _this._hFocusIn = on(menuBody.ownerDocument, focusinEventName, function (event) {
-          var target = ClickListener.getEventTarget(event);
-          var triggerEl = _this._triggerRef.current;
+        this._menuBody = menuBody;
+        const hasFocusin = ('onfocusin' in window);
+        const focusinEventName = hasFocusin ? 'focusin' : 'focus';
+        this._hFocusIn = on(menuBody.ownerDocument, focusinEventName, event => {
+          const target = ClickListener.getEventTarget(event);
+          const {
+            current: triggerEl
+          } = this._triggerRef;
 
           if (typeof target.matches === 'function') {
-            if (!menuBody.contains(target) && triggerEl && !target.matches(".".concat(_this.context, "--overflow-menu,.").concat(_this.context, "--overflow-menu-options"))) {
-              _this.closeMenuAndFocus();
+            if (!menuBody.contains(target) && triggerEl && !target.matches(`.${this.context}--overflow-menu,.${this.context}--overflow-menu-options`)) {
+              this.closeMenuAndFocus();
             }
           }
         }, !hasFocusin);
-
-        _this.props.onOpen();
+        this.props.onOpen();
       }
     });
 
-    _defineProperty(_assertThisInitialized(_this), "_getTarget", function () {
-      var triggerEl = _this._triggerRef.current;
+    _defineProperty(this, "_getTarget", () => {
+      const {
+        current: triggerEl
+      } = this._triggerRef;
       return triggerEl && triggerEl.closest('[data-floating-menu-container]') || document.body;
     });
-
-    return _this;
   }
 
-  _createClass(OverflowMenu, [{
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(_, prevState) {
-      var onClose = this.props.onClose;
+  componentDidUpdate(_, prevState) {
+    const {
+      onClose
+    } = this.props;
 
-      if (!this.state.open && prevState.open) {
-        onClose();
-      }
+    if (!this.state.open && prevState.open) {
+      onClose();
     }
-  }, {
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      // ensure that if open=true on first render, we wait
-      // to render the floating menu until the trigger ref is not null
-      if (this._triggerRef.current) {
-        this.setState({
-          hasMountedTrigger: true
-        });
-      }
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      if (typeof this._hBlurTimeout === 'number') {
-        clearTimeout(this._hBlurTimeout);
-        this._hBlurTimeout = undefined;
-      }
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _classNames,
-          _classNames2,
-          _this2 = this;
-
-      var prefix = this.context;
-
-      var _this$props = this.props,
-          id = _this$props.id,
-          ariaLabel = _this$props['aria-label'],
-          deprecatedAriaLabel = _this$props.ariaLabel,
-          children = _this$props.children,
-          iconDescription = _this$props.iconDescription,
-          direction = _this$props.direction,
-          flipped = _this$props.flipped,
-          focusTrap = _this$props.focusTrap,
-          menuOffset = _this$props.menuOffset,
-          menuOffsetFlip = _this$props.menuOffsetFlip,
-          iconClass = _this$props.iconClass;
-          _this$props.onClick;
-          _this$props.onOpen;
-          _this$props.selectorPrimaryFocus;
-          var IconElement = _this$props.renderIcon,
-          ref = _this$props.innerRef,
-          menuOptionsClass = _this$props.menuOptionsClass,
-          light = _this$props.light,
-          _this$props$size = _this$props.size,
-          size = _this$props$size === void 0 ? 'md' : _this$props$size,
-          other = _objectWithoutProperties(_this$props, _excluded);
-
-      var open = this.state.open;
-      var overflowMenuClasses = cx(this.props.className, "".concat(prefix, "--overflow-menu"), (_classNames = {}, _defineProperty(_classNames, "".concat(prefix, "--overflow-menu--open"), open), _defineProperty(_classNames, "".concat(prefix, "--overflow-menu--light"), light), _defineProperty(_classNames, "".concat(prefix, "--overflow-menu--").concat(size), size), _classNames));
-      var overflowMenuOptionsClasses = cx(menuOptionsClass, "".concat(prefix, "--overflow-menu-options"), (_classNames2 = {}, _defineProperty(_classNames2, "".concat(prefix, "--overflow-menu--flip"), this.props.flipped), _defineProperty(_classNames2, "".concat(prefix, "--overflow-menu-options--open"), open), _defineProperty(_classNames2, "".concat(prefix, "--overflow-menu-options--light"), light), _defineProperty(_classNames2, "".concat(prefix, "--overflow-menu-options--").concat(size), size), _classNames2));
-      var overflowMenuIconClasses = cx("".concat(prefix, "--overflow-menu__icon"), iconClass);
-      var childrenWithProps = React__default.Children.toArray(children).map(function (child, index) {
-        var _child$props;
-
-        return /*#__PURE__*/React__default.cloneElement(child, {
-          closeMenu: (child === null || child === void 0 ? void 0 : (_child$props = child.props) === null || _child$props === void 0 ? void 0 : _child$props.closeMenu) || _this2.closeMenuAndFocus,
-          handleOverflowMenuItemFocus: _this2.handleOverflowMenuItemFocus,
-          ref: function ref(e) {
-            _this2["overflowMenuItem".concat(index)] = e;
-          },
-          index: index
-        });
+  }
+
+  componentDidMount() {
+    // ensure that if open=true on first render, we wait
+    // to render the floating menu until the trigger ref is not null
+    if (this._triggerRef.current) {
+      this.setState({
+        hasMountedTrigger: true
       });
-      var menuBody = /*#__PURE__*/React__default.createElement("ul", {
-        className: overflowMenuOptionsClasses,
-        tabIndex: "-1",
-        role: "menu",
-        "aria-label": ariaLabel || deprecatedAriaLabel,
-        onKeyDown: this.handleKeyPress
-      }, childrenWithProps);
-      var wrappedMenuBody = /*#__PURE__*/React__default.createElement(FloatingMenu, {
-        focusTrap: focusTrap,
-        triggerRef: this._triggerRef,
-        menuDirection: direction,
-        menuOffset: flipped ? menuOffsetFlip : menuOffset,
-        menuRef: this._bindMenuBody,
-        flipped: this.props.flipped,
-        target: this._getTarget,
-        onPlace: this._handlePlace,
-        selectorPrimaryFocus: this.props.selectorPrimaryFocus
-      }, /*#__PURE__*/React__default.cloneElement(menuBody, {
-        'data-floating-menu-direction': direction
-      }));
-      var iconProps = {
-        className: overflowMenuIconClasses,
-        'aria-label': iconDescription
-      };
-      return /*#__PURE__*/React__default.createElement(ClickListener, {
-        onClickOutside: this.handleClickOutside
-      }, /*#__PURE__*/React__default.createElement("span", {
-        className: "".concat(prefix, "--overflow-menu__wrapper")
-      }, /*#__PURE__*/React__default.createElement(IconButton, _extends({}, other, {
-        type: "button",
-        "aria-haspopup": true,
-        "aria-expanded": this.state.open,
-        className: overflowMenuClasses,
-        onClick: this.handleClick,
-        id: id,
-        ref: mergeRefs(this._triggerRef, ref),
-        label: iconDescription
-      }), /*#__PURE__*/React__default.createElement(IconElement, iconProps)), open && this.state.hasMountedTrigger && wrappedMenuBody));
     }
-  }], [{
-    key: "getDerivedStateFromProps",
-    value: function getDerivedStateFromProps(_ref2, state) {
-      var open = _ref2.open;
-      var prevOpen = state.prevOpen;
-      return prevOpen === open ? null : {
-        open: open,
-        prevOpen: open
-      };
+  }
+
+  static getDerivedStateFromProps(_ref2, state) {
+    let {
+      open
+    } = _ref2;
+    const {
+      prevOpen
+    } = state;
+    return prevOpen === open ? null : {
+      open,
+      prevOpen: open
+    };
+  }
+
+  componentWillUnmount() {
+    if (typeof this._hBlurTimeout === 'number') {
+      clearTimeout(this._hBlurTimeout);
+      this._hBlurTimeout = undefined;
     }
-  }]);
+  }
 
-  return OverflowMenu;
-}(Component);
+  render() {
+    const prefix = this.context;
+    const {
+      id,
+      ['aria-label']: ariaLabel,
+      ariaLabel: deprecatedAriaLabel,
+      children,
+      iconDescription,
+      direction,
+      flipped,
+      focusTrap,
+      menuOffset,
+      menuOffsetFlip,
+      iconClass,
+      onClick,
+      // eslint-disable-line
+      onOpen,
+      // eslint-disable-line
+      selectorPrimaryFocus = '[data-floating-menu-primary-focus]',
+      // eslint-disable-line
+      renderIcon: IconElement,
+      // eslint-disable-next-line react/prop-types
+      innerRef: ref,
+      menuOptionsClass,
+      light,
+      size = 'md',
+      ...other
+    } = this.props;
+    const {
+      open
+    } = this.state;
+    const overflowMenuClasses = cx(this.props.className, `${prefix}--overflow-menu`, {
+      [`${prefix}--overflow-menu--open`]: open,
+      [`${prefix}--overflow-menu--light`]: light,
+      [`${prefix}--overflow-menu--${size}`]: size
+    });
+    const overflowMenuOptionsClasses = cx(menuOptionsClass, `${prefix}--overflow-menu-options`, {
+      [`${prefix}--overflow-menu--flip`]: this.props.flipped,
+      [`${prefix}--overflow-menu-options--open`]: open,
+      [`${prefix}--overflow-menu-options--light`]: light,
+      [`${prefix}--overflow-menu-options--${size}`]: size
+    });
+    const overflowMenuIconClasses = cx(`${prefix}--overflow-menu__icon`, iconClass);
+    const childrenWithProps = React__default.Children.toArray(children).map((child, index) => {
+      var _child$props;
+
+      return /*#__PURE__*/React__default.cloneElement(child, {
+        closeMenu: (child === null || child === void 0 ? void 0 : (_child$props = child.props) === null || _child$props === void 0 ? void 0 : _child$props.closeMenu) || this.closeMenuAndFocus,
+        handleOverflowMenuItemFocus: this.handleOverflowMenuItemFocus,
+        ref: e => {
+          this[`overflowMenuItem${index}`] = e;
+        },
+        index
+      });
+    });
+    const menuBody = /*#__PURE__*/React__default.createElement("ul", {
+      className: overflowMenuOptionsClasses,
+      tabIndex: "-1",
+      role: "menu",
+      "aria-label": ariaLabel || deprecatedAriaLabel,
+      onKeyDown: this.handleKeyPress
+    }, childrenWithProps);
+    const wrappedMenuBody = /*#__PURE__*/React__default.createElement(FloatingMenu, {
+      focusTrap: focusTrap,
+      triggerRef: this._triggerRef,
+      menuDirection: direction,
+      menuOffset: flipped ? menuOffsetFlip : menuOffset,
+      menuRef: this._bindMenuBody,
+      flipped: this.props.flipped,
+      target: this._getTarget,
+      onPlace: this._handlePlace,
+      selectorPrimaryFocus: this.props.selectorPrimaryFocus
+    }, /*#__PURE__*/React__default.cloneElement(menuBody, {
+      'data-floating-menu-direction': direction
+    }));
+    const iconProps = {
+      className: overflowMenuIconClasses,
+      'aria-label': iconDescription
+    };
+    return /*#__PURE__*/React__default.createElement(ClickListener, {
+      onClickOutside: this.handleClickOutside
+    }, /*#__PURE__*/React__default.createElement("span", {
+      className: `${prefix}--overflow-menu__wrapper`
+    }, /*#__PURE__*/React__default.createElement(IconButton, _extends({}, other, {
+      type: "button",
+      "aria-haspopup": true,
+      "aria-expanded": this.state.open,
+      className: overflowMenuClasses,
+      onClick: this.handleClick,
+      id: id,
+      ref: mergeRefs(this._triggerRef, ref),
+      size: size,
+      label: iconDescription
+    }), /*#__PURE__*/React__default.createElement(IconElement, iconProps)), open && this.state.hasMountedTrigger && wrappedMenuBody));
+  }
 
-_defineProperty(OverflowMenu, "propTypes", (_defineProperty2 = {}, _defineProperty(_defineProperty2, 'aria-label', PropTypes.string), _defineProperty(_defineProperty2, "ariaLabel", deprecate(PropTypes.string, 'This prop syntax has been deprecated. Please use the new `aria-label`.')), _defineProperty(_defineProperty2, "children", PropTypes.node), _defineProperty(_defineProperty2, "className", PropTypes.string), _defineProperty(_defineProperty2, "direction", PropTypes.oneOf([DIRECTION_TOP, DIRECTION_BOTTOM])), _defineProperty(_defineProperty2, "flipped", PropTypes.bool), _defineProperty(_defineProperty2, "focusTrap", PropTypes.bool), _defineProperty(_defineProperty2, "iconClass", PropTypes.string), _defineProperty(_defineProperty2, "iconDescription", PropTypes.string.isRequired), _defineProperty(_defineProperty2, "id", PropTypes.string), _defineProperty(_defineProperty2, "light", deprecate(PropTypes.bool, 'The `light` prop for `OverflowMenu` is no longer needed and has been deprecated. It will be removed in the next major release. Use the Layer component instead.')), _defineProperty(_defineProperty2, "menuOffset", PropTypes.oneOfType([PropTypes.shape({
-  top: PropTypes.number,
-  left: PropTypes.number
-}), PropTypes.func])), _defineProperty(_defineProperty2, "menuOffsetFlip", PropTypes.oneOfType([PropTypes.shape({
-  top: PropTypes.number,
-  left: PropTypes.number
-}), PropTypes.func])), _defineProperty(_defineProperty2, "menuOptionsClass", PropTypes.string), _defineProperty(_defineProperty2, "onClick", PropTypes.func), _defineProperty(_defineProperty2, "onClose", PropTypes.func), _defineProperty(_defineProperty2, "onFocus", PropTypes.func), _defineProperty(_defineProperty2, "onKeyDown", PropTypes.func), _defineProperty(_defineProperty2, "onOpen", PropTypes.func), _defineProperty(_defineProperty2, "open", PropTypes.bool), _defineProperty(_defineProperty2, "renderIcon", PropTypes.oneOfType([PropTypes.func, PropTypes.object])), _defineProperty(_defineProperty2, "selectorPrimaryFocus", PropTypes.string), _defineProperty(_defineProperty2, "size", PropTypes.oneOf(['sm', 'md', 'lg'])), _defineProperty2));
+}
+
+_defineProperty(OverflowMenu, "propTypes", {
+  /**
+   * Specify a label to be read by screen readers on the container node
+   */
+  ['aria-label']: PropTypes.string,
+
+  /**
+   * Deprecated, please use `aria-label` instead.
+   * Specify a label to be read by screen readers on the container note.
+   */
+  ariaLabel: deprecate(PropTypes.string, 'This prop syntax has been deprecated. Please use the new `aria-label`.'),
+
+  /**
+   * The child nodes.
+   */
+  children: PropTypes.node,
+
+  /**
+   * The CSS class names.
+   */
+  className: PropTypes.string,
+
+  /**
+   * The menu direction.
+   */
+  direction: PropTypes.oneOf([DIRECTION_TOP, DIRECTION_BOTTOM]),
+
+  /**
+   * `true` if the menu alignment should be flipped.
+   */
+  flipped: PropTypes.bool,
+
+  /**
+   * Enable or disable focus trap behavior
+   */
+  focusTrap: PropTypes.bool,
+
+  /**
+   * The CSS class for the icon.
+   */
+  iconClass: PropTypes.string,
+
+  /**
+   * The icon description.
+   */
+  iconDescription: PropTypes.string.isRequired,
+
+  /**
+   * The element ID.
+   */
+  id: PropTypes.string,
+
+  /**
+   * `true` to use the light version. For use on $ui-01 backgrounds only.
+   * Don't use this to make OverflowMenu background color same as container background color.
+   */
+  light: deprecate(PropTypes.bool, 'The `light` prop for `OverflowMenu` is no longer needed and has been deprecated. It will be removed in the next major release. Use the Layer component instead.'),
+
+  /**
+   * The adjustment in position applied to the floating menu.
+   */
+  menuOffset: PropTypes.oneOfType([PropTypes.shape({
+    top: PropTypes.number,
+    left: PropTypes.number
+  }), PropTypes.func]),
+
+  /**
+   * The adjustment in position applied to the floating menu.
+   */
+  menuOffsetFlip: PropTypes.oneOfType([PropTypes.shape({
+    top: PropTypes.number,
+    left: PropTypes.number
+  }), PropTypes.func]),
+
+  /**
+   * The class to apply to the menu options
+   */
+  menuOptionsClass: PropTypes.string,
+
+  /**
+   * The event handler for the `click` event.
+   */
+  onClick: PropTypes.func,
+
+  /**
+   * Function called when menu is closed
+   */
+  onClose: PropTypes.func,
+
+  /**
+   * The event handler for the `focus` event.
+   */
+  onFocus: PropTypes.func,
+
+  /**
+   * The event handler for the `keydown` event.
+   */
+  onKeyDown: PropTypes.func,
+
+  /**
+   * Function called when menu is opened
+   */
+  onOpen: PropTypes.func,
+
+  /**
+   * `true` if the menu should be open.
+   */
+  open: PropTypes.bool,
+
+  /**
+   * Function called to override icon rendering.
+   */
+  renderIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
+
+  /**
+   * Specify a CSS selector that matches the DOM element that should
+   * be focused when the OverflowMenu opens
+   */
+  selectorPrimaryFocus: PropTypes.string,
+
+  /**
+   * Specify the size of the OverflowMenu. Currently supports either `sm`, 'md' (default) or 'lg` as an option.
+   */
+  size: PropTypes.oneOf(['sm', 'md', 'lg'])
+});
 
 _defineProperty(OverflowMenu, "contextType", PrefixContext);
 
-_defineProperty(OverflowMenu, "defaultProps", (_defineProperty3 = {}, _defineProperty(_defineProperty3, 'aria-label', null), _defineProperty(_defineProperty3, "iconDescription", 'Options'), _defineProperty(_defineProperty3, "open", false), _defineProperty(_defineProperty3, "direction", DIRECTION_BOTTOM), _defineProperty(_defineProperty3, "flipped", false), _defineProperty(_defineProperty3, "focusTrap", true), _defineProperty(_defineProperty3, "renderIcon", OverflowMenuVertical), _defineProperty(_defineProperty3, "onClick", function onClick() {}), _defineProperty(_defineProperty3, "onKeyDown", function onKeyDown() {}), _defineProperty(_defineProperty3, "onClose", function onClose() {}), _defineProperty(_defineProperty3, "onOpen", function onOpen() {}), _defineProperty(_defineProperty3, "menuOffset", getMenuOffset), _defineProperty(_defineProperty3, "menuOffsetFlip", getMenuOffset), _defineProperty(_defineProperty3, "selectorPrimaryFocus", '[data-overflow-menu-primary-focus]'), _defineProperty3));
-((function () {
-  var forwardRef = function forwardRef(props, ref) {
-    return /*#__PURE__*/React__default.createElement(OverflowMenu, _extends({}, props, {
-      innerRef: ref
-    }));
-  };
+_defineProperty(OverflowMenu, "defaultProps", {
+  ['aria-label']: null,
+  iconDescription: 'Options',
+  open: false,
+  direction: DIRECTION_BOTTOM,
+  flipped: false,
+  focusTrap: true,
+  renderIcon: OverflowMenuVertical,
+  onClick: () => {},
+  onKeyDown: () => {},
+  onClose: () => {},
+  onOpen: () => {},
+  menuOffset: getMenuOffset,
+  menuOffsetFlip: getMenuOffset,
+  selectorPrimaryFocus: '[data-overflow-menu-primary-focus]'
+});
+(() => {
+  const forwardRef = (props, ref) => /*#__PURE__*/React__default.createElement(OverflowMenu, _extends({}, props, {
+    innerRef: ref
+  }));
 
   forwardRef.displayName = 'OverflowMenu';
   return /*#__PURE__*/React__default.forwardRef(forwardRef);
-}))();
+})();
 
 export { OverflowMenu, getMenuOffset };