@carbon/react 1.78.2 → 1.79.0

package/es/components/OverflowMenu/OverflowMenu.js

@@ -5,32 +5,32 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { defineProperty as _defineProperty, extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js';
-import { FloatingMenu, DIRECTION_TOP, DIRECTION_BOTTOM } from '../../internal/FloatingMenu.js';
-import React__default from 'react';
-import ClickListener from '../../internal/ClickListener.js';
-import { IconButton } from '../IconButton/index.js';
+import { extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import React__default, { forwardRef, useContext, useState, useRef, useEffect, useCallback, Children, isValidElement, cloneElement } from 'react';
 import { OverflowMenuVertical } from '@carbon/icons-react';
-import { PrefixContext } from '../../internal/usePrefix.js';
-import PropTypes from 'prop-types';
 import cx from 'classnames';
-import deprecate from '../../prop-types/deprecate.js';
 import invariant from 'invariant';
-import mergeRefs from '../../tools/mergeRefs.js';
+import PropTypes from 'prop-types';
+import ClickListener from '../../internal/ClickListener.js';
+import { DIRECTION_TOP, DIRECTION_BOTTOM, FloatingMenu } from '../../internal/FloatingMenu.js';
+import { ArrowUp, ArrowRight, ArrowDown, ArrowLeft, Escape } from '../../internal/keyboard/keys.js';
+import { matches } from '../../internal/keyboard/match.js';
 import { noopFn } from '../../internal/noopFn.js';
+import { PrefixContext } from '../../internal/usePrefix.js';
+import deprecate from '../../prop-types/deprecate.js';
+import mergeRefs from '../../tools/mergeRefs.js';
 import setupGetInstanceId from '../../tools/setupGetInstanceId.js';
-import { matches } from '../../internal/keyboard/match.js';
-import { ArrowUp, ArrowRight, ArrowDown, ArrowLeft, Escape } from '../../internal/keyboard/keys.js';
+import { IconButton } from '../IconButton/index.js';
 
 const getInstanceId = setupGetInstanceId();
-const on = function (element) {
+const on = function (target) {
   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(...args);
+  target.addEventListener(...args);
   return {
     release() {
-      element.removeEventListener(...args);
+      target.removeEventListener(...args);
       return null;
     }
   };
@@ -38,7 +38,6 @@ const on = function (element) {
 
 /**
  * The CSS property names of the arrow keyed by the floating menu direction.
- * @type {[key: string]: string}
  */
 const triggerButtonPositionProps = {
   [DIRECTION_TOP]: 'bottom',
@@ -46,13 +45,22 @@ const triggerButtonPositionProps = {
 };
 
 /**
- * Determines how the position of arrow should affect the floating menu position.
- * @type {[key: string]: number}
+ * Determines how the position of the arrow should affect the floating menu
+ * position.
  */
 const triggerButtonPositionFactors = {
   [DIRECTION_TOP]: -2,
   [DIRECTION_BOTTOM]: -1
 };
+
+/**
+ * Calculates the offset for the floating menu.
+ *
+ * @param menuBody - The menu body with the menu arrow.
+ * @param direction - The floating menu direction.
+ * @returns The adjustment of the floating menu position, upon the position of
+ *          the menu arrow.
+ */
 const getMenuOffset = (menuBody, direction, trigger, flip) => {
   const triggerButtonPositionProp = triggerButtonPositionProps[direction];
   const triggerButtonPositionFactor = triggerButtonPositionFactors[direction];
@@ -81,324 +89,254 @@ const getMenuOffset = (menuBody, direction, trigger, flip) => {
       };
   }
 };
-class OverflowMenu extends React__default.Component {
-  constructor() {
-    super(...arguments);
-    _defineProperty(this, "state", {
-      open: false,
-      // Set a default value for 'open'
-      hasMountedTrigger: false,
-      // Set a default value for 'hasMountedTrigger'
-      click: false // Set a default value for 'click'
-    });
-    _defineProperty(this, "instanceId", getInstanceId());
-    /**
-     * The handle of `onfocusin` or `focus` event handler.
-     * @private
-     */
-    _defineProperty(this, "_hFocusIn", null);
-    /**
-     * The timeout handle for handling `blur` event.
-     * @private
-     */
-    _defineProperty(this, "_hBlurTimeout", void 0);
-    /**
-     * The element ref of the tooltip's trigger button.
-     * @type {React.RefObject<HTMLElement>}
-     * @private
-     */
-    _defineProperty(this, "_triggerRef", /*#__PURE__*/React__default.createRef());
-    _defineProperty(this, "handleClick", evt => {
-      const {
-        onClick = noopFn
-      } = this.props;
-      this.setState({
-        click: true
-      });
-      if (!this._menuBody || !this._menuBody.contains(evt.target)) {
-        this.setState({
-          open: !this.state.open
-        });
-        onClick(evt);
-      }
-    });
-    _defineProperty(this, "closeMenuAndFocus", () => {
-      const wasClicked = this.state.click;
-      const wasOpen = this.state.open;
-      this.closeMenu(() => {
-        if (wasOpen && !wasClicked) {
-          this.focusMenuEl();
-        }
-      });
-    });
-    _defineProperty(this, "closeMenuOnEscape", () => {
-      const wasOpen = this.state.open;
-      this.closeMenu(() => {
-        if (wasOpen) {
-          this.focusMenuEl();
-        }
-      });
-    });
-    _defineProperty(this, "handleKeyPress", evt => {
-      if (this.state.open && matches(evt, [ArrowUp, ArrowRight, ArrowDown, ArrowLeft])) {
-        evt.preventDefault();
-      }
+const OverflowMenu = /*#__PURE__*/forwardRef((_ref, ref) => {
+  let {
+    ['aria-label']: ariaLabel = null,
+    ariaLabel: deprecatedAriaLabel,
+    children,
+    className,
+    direction = DIRECTION_BOTTOM,
+    flipped = false,
+    focusTrap = true,
+    iconClass,
+    iconDescription = 'Options',
+    id,
+    light,
+    menuOffset = getMenuOffset,
+    menuOffsetFlip = getMenuOffset,
+    menuOptionsClass,
+    onClick = noopFn,
+    onClose = noopFn,
+    onOpen = noopFn,
+    open: openProp,
+    renderIcon: IconElement = OverflowMenuVertical,
+    selectorPrimaryFocus = '[data-floating-menu-primary-focus]',
+    size = 'md',
+    ...other
+  } = _ref;
+  const prefix = useContext(PrefixContext);
+  const [open, setOpen] = useState(openProp ?? false);
+  const [click, setClick] = useState(false);
+  const [hasMountedTrigger, setHasMountedTrigger] = useState(false);
+  /**  The handle of `onfocusin` or `focus` event handler. */
+  const hFocusIn = useRef(null);
+  const instanceId = useRef(getInstanceId());
+  const menuBodyRef = useRef(null);
+  const menuItemRefs = useRef({});
+  const prevOpenProp = useRef(openProp);
+  const prevOpenState = useRef(open);
+  /** The element ref of the tooltip's trigger button. */
+  const triggerRef = useRef(null);
 
-      // Close the overflow menu on escape
-      if (matches(evt, [Escape])) {
-        this.closeMenuOnEscape();
+  // Sync open prop changes.
+  useEffect(() => {
+    if (prevOpenProp.current !== openProp) {
+      setOpen(!!openProp);
+      prevOpenProp.current = openProp;
+    }
+  }, [openProp]);
 
-        // Stop the esc keypress from bubbling out and closing something it shouldn't
-        evt.stopPropagation();
-      }
-    });
-    _defineProperty(this, "handleClickOutside", evt => {
-      if (this.state.open && (!this._menuBody || !this._menuBody.contains(evt.target))) {
-        this.closeMenu();
+  // Mark trigger as mounted.
+  useEffect(() => {
+    if (triggerRef.current) {
+      setHasMountedTrigger(true);
+    }
+  }, []);
+
+  // Call `onClose` when menu closes.
+  useEffect(() => {
+    if (!open && prevOpenState.current) {
+      onClose();
+    }
+    prevOpenState.current = open;
+  }, [open, onClose]);
+  const focusMenuEl = useCallback(() => {
+    if (triggerRef.current) {
+      triggerRef.current.focus();
+    }
+  }, []);
+  const closeMenu = useCallback(onCloseMenu => {
+    setOpen(false);
+    // Optional callback to be executed after the state as been set to close
+    if (onCloseMenu) {
+      onCloseMenu();
+    }
+    onClose();
+  }, [onClose]);
+  const closeMenuAndFocus = useCallback(() => {
+    const wasClicked = click;
+    const wasOpen = open;
+    closeMenu(() => {
+      if (wasOpen && !wasClicked) {
+        focusMenuEl();
       }
     });
-    _defineProperty(this, "closeMenu", onCloseMenu => {
-      const {
-        onClose = noopFn
-      } = this.props;
-      this.setState({
-        open: false
-      }, () => {
-        // Optional callback to be executed after the state as been set to close
-        if (onCloseMenu) {
-          onCloseMenu();
-        }
-        onClose();
-      });
-    });
-    _defineProperty(this, "focusMenuEl", () => {
-      const {
-        current: triggerEl
-      } = this._triggerRef;
-      if (triggerEl) {
-        triggerEl.focus();
+  }, [click, open, closeMenu, focusMenuEl]);
+  const closeMenuOnEscape = useCallback(() => {
+    const wasOpen = open;
+    closeMenu(() => {
+      if (wasOpen) {
+        focusMenuEl();
       }
     });
-    /**
-     * Focuses the next enabled overflow menu item given the currently focused
-     * item index and direction to move
-     * @param {object} params
-     * @param {number} params.currentIndex - the index of the currently focused
-     * overflow menu item in the list of overflow menu items
-     * @param {number} params.direction - number denoting the direction to move
-     * focus (1 for forwards, -1 for backwards)
-     */
-    _defineProperty(this, "handleOverflowMenuItemFocus", _ref => {
-      let {
-        currentIndex,
-        direction
-      } = _ref;
-      const enabledIndices = React__default.Children.toArray(this.props.children).reduce((acc, curr, i) => {
-        if (/*#__PURE__*/React__default.isValidElement(curr) && !curr.props.disabled) {
-          acc.push(i);
-        }
-        return acc;
-      }, []);
-      const nextValidIndex = (() => {
-        const nextIndex = enabledIndices.indexOf(currentIndex) + direction;
-        switch (nextIndex) {
-          case -1:
-            return enabledIndices.length - 1;
-          case enabledIndices.length:
-            return 0;
-          default:
-            return nextIndex;
-        }
-      })();
-      const overflowMenuItem = this[`overflowMenuItem${enabledIndices[nextValidIndex]}`];
-      overflowMenuItem?.focus();
-    });
-    /**
-     * Handles the floating menu being unmounted or non-floating menu being
-     * mounted or unmounted.
-     * @param {Element} menuBody The DOM element of the menu body.
-     * @private
-     */
-    _defineProperty(this, "_menuBody", null);
-    _defineProperty(this, "_bindMenuBody", menuBody => {
-      if (!menuBody) {
-        this._menuBody = menuBody;
+  }, [open, closeMenu, focusMenuEl]);
+  const handleClick = evt => {
+    setClick(true);
+    if (!menuBodyRef.current || !menuBodyRef.current.contains(evt.target)) {
+      setOpen(prev => !prev);
+      onClick(evt);
+    }
+  };
+  const handleKeyPress = evt => {
+    if (open && matches(evt, [ArrowUp, ArrowRight, ArrowDown, ArrowLeft])) {
+      evt.preventDefault();
+    }
+
+    // Close the overflow menu on escape
+    if (matches(evt, [Escape])) {
+      closeMenuOnEscape();
+
+      // Stop the esc keypress from bubbling out and closing something it shouldn't
+      evt.stopPropagation();
+    }
+  };
+  const handleClickOutside = evt => {
+    if (open && (!menuBodyRef.current || !menuBodyRef.current.contains(evt.target))) {
+      closeMenu();
+    }
+  };
+
+  /**
+   * Focuses the next enabled overflow menu item given the currently focused
+   * item index and direction to move.
+   */
+  const handleOverflowMenuItemFocus = _ref2 => {
+    let {
+      currentIndex,
+      direction
+    } = _ref2;
+    const enabledIndices = Children.toArray(children).reduce((acc, curr, i) => {
+      if (/*#__PURE__*/isValidElement(curr) && !curr.props.disabled) {
+        acc.push(i);
       }
-      if (!menuBody && this._hFocusIn) {
-        this._hFocusIn = this._hFocusIn.release();
+      return acc;
+    }, []);
+    const nextValidIndex = (() => {
+      const nextIndex = enabledIndices.indexOf(currentIndex) + direction;
+      switch (nextIndex) {
+        case -1:
+          return enabledIndices.length - 1;
+        case enabledIndices.length:
+          return 0;
+        default:
+          return nextIndex;
       }
-    });
-    /**
-     * Handles the floating menu being placed.
-     * @param {Element} menuBody The DOM element of the menu body.
-     * @private
-     */
-    _defineProperty(this, "_handlePlace", menuBody => {
-      const {
-        onOpen = noopFn
-      } = this.props;
-      if (menuBody) {
-        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(`.${this.context}--overflow-menu:first-child,.${this.context}--overflow-menu-options:first-child`)) {
-              this.closeMenuAndFocus();
-            }
-          }
-        }, !hasFocusin);
-        onOpen();
+    })();
+    const overflowMenuItem = menuItemRefs.current[enabledIndices[nextValidIndex]];
+    overflowMenuItem?.focus();
+  };
+  const bindMenuBody = menuBody => {
+    if (!menuBody) {
+      menuBodyRef.current = menuBody;
+    }
+    if (!menuBody && hFocusIn.current) {
+      hFocusIn.current = hFocusIn.current.release();
+    }
+  };
+  const handlePlace = menuBody => {
+    if (!menuBody) return;
+    menuBodyRef.current = menuBody;
+    const hasFocusin = 'onfocusin' in window;
+    const focusinEventName = hasFocusin ? 'focusin' : 'focus';
+    hFocusIn.current = on(menuBody.ownerDocument, focusinEventName, event => {
+      const target = event.target;
+      const triggerEl = triggerRef.current;
+      if (typeof target.matches === 'function') {
+        if (!menuBody.contains(target) && triggerEl && !target.matches(`.${prefix}--overflow-menu:first-child, .${prefix}--overflow-menu-options:first-child`)) {
+          closeMenuAndFocus();
+        }
       }
-    });
-    /**
-     * @returns {Element} The DOM element where the floating menu is placed in.
-     */
-    _defineProperty(this, "_getTarget", () => {
-      const {
-        current: triggerEl
-      } = this._triggerRef;
-      return triggerEl instanceof Element && triggerEl.closest('[data-floating-menu-container]') || document.body;
-    });
-  }
-  componentDidUpdate(_, prevState) {
-    const {
-      onClose = noopFn
-    } = this.props;
-    if (!this.state.open && prevState.open) {
-      onClose();
+    }, !hasFocusin);
+    onOpen();
+  };
+  const getTarget = () => {
+    const triggerEl = triggerRef.current;
+    if (triggerEl instanceof Element) {
+      return triggerEl.closest('[data-floating-menu-container]') || document.body;
     }
-  }
-  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
+    return document.body;
+  };
+  const menuBodyId = `overflow-menu-${instanceId.current}__menu-body`;
+  const overflowMenuClasses = cx(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`]: 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 = Children.toArray(children).map((child, index) => {
+    if (/*#__PURE__*/isValidElement(child)) {
+      const childElement = child;
+      return /*#__PURE__*/cloneElement(childElement, {
+        closeMenu: childElement.props.closeMenu || closeMenuAndFocus,
+        handleOverflowMenuItemFocus,
+        ref: el => {
+          menuItemRefs.current[index] = el;
+        },
+        index
       });
     }
-  }
-  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;
-    }
-  }
-  render() {
-    const prefix = this.context;
-    const {
-      id,
-      ['aria-label']: ariaLabel = null,
-      ariaLabel: deprecatedAriaLabel,
-      children,
-      iconDescription = 'Options',
-      direction = DIRECTION_BOTTOM,
-      flipped = false,
-      focusTrap = true,
-      menuOffset = getMenuOffset,
-      menuOffsetFlip = getMenuOffset,
-      iconClass,
-      onClick = noopFn,
-      // eslint-disable-line
-      onOpen = noopFn,
-      // eslint-disable-line
-      selectorPrimaryFocus = '[data-floating-menu-primary-focus]',
-      // eslint-disable-line
-      renderIcon: IconElement = OverflowMenuVertical,
-      // eslint-disable-next-line react/prop-types
-      innerRef: ref,
-      menuOptionsClass,
-      light,
-      size = 'md',
-      ...other
-    } = this.props;
-    const {
-      open = false
-    } = 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) => /*#__PURE__*/React__default.isValidElement(child) ? /*#__PURE__*/React__default.cloneElement(child, {
-      // @ts-expect-error: PropTypes are not expressive enough to cover this case
-      closeMenu: child.props.closeMenu || this.closeMenuAndFocus,
-      handleOverflowMenuItemFocus: this.handleOverflowMenuItemFocus,
-      ref: e => {
-        this[`overflowMenuItem${index}`] = e;
-      },
-      index
-    }) : null);
-    const menuBodyId = `overflow-menu-${this.instanceId}__menu-body`;
-    const menuBody = /*#__PURE__*/React__default.createElement("ul", {
-      className: overflowMenuOptionsClasses,
-      tabIndex: -1,
-      role: "menu",
-      "aria-label": ariaLabel || deprecatedAriaLabel,
-      onKeyDown: this.handleKeyPress,
-      id: menuBodyId
-    }, 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`,
-      "aria-owns": open ? menuBodyId : undefined
-    }, /*#__PURE__*/React__default.createElement(IconButton, _extends({}, other, {
-      type: "button",
-      "aria-haspopup": true,
-      "aria-expanded": open,
-      "aria-controls": open ? menuBodyId : undefined,
-      className: overflowMenuClasses,
-      onClick: this.handleClick,
-      id: id,
-      ref: mergeRefs(this._triggerRef, ref),
-      size: size,
-      label: iconDescription,
-      kind: "ghost"
-    }), /*#__PURE__*/React__default.createElement(IconElement, iconProps)), open && this.state.hasMountedTrigger && wrappedMenuBody));
-  }
-}
-_defineProperty(OverflowMenu, "propTypes", {
+    return null;
+  });
+  const menuBody = /*#__PURE__*/React__default.createElement("ul", {
+    className: overflowMenuOptionsClasses,
+    tabIndex: -1,
+    role: "menu",
+    "aria-label": ariaLabel || deprecatedAriaLabel,
+    onKeyDown: handleKeyPress,
+    id: menuBodyId
+  }, childrenWithProps);
+  const wrappedMenuBody = /*#__PURE__*/React__default.createElement(FloatingMenu, {
+    focusTrap: focusTrap,
+    triggerRef: triggerRef,
+    menuDirection: direction,
+    menuOffset: flipped ? menuOffsetFlip : menuOffset,
+    menuRef: bindMenuBody,
+    flipped: flipped,
+    target: getTarget,
+    onPlace: handlePlace,
+    selectorPrimaryFocus: selectorPrimaryFocus
+  }, /*#__PURE__*/cloneElement(menuBody, {
+    'data-floating-menu-direction': direction
+  }));
+  return /*#__PURE__*/React__default.createElement(ClickListener, {
+    onClickOutside: handleClickOutside
+  }, /*#__PURE__*/React__default.createElement("span", {
+    className: `${prefix}--overflow-menu__wrapper`,
+    "aria-owns": open ? menuBodyId : undefined
+  }, /*#__PURE__*/React__default.createElement(IconButton, _extends({}, other, {
+    type: "button",
+    "aria-haspopup": true,
+    "aria-expanded": open,
+    "aria-controls": open ? menuBodyId : undefined,
+    className: overflowMenuClasses,
+    onClick: handleClick,
+    id: id,
+    ref: mergeRefs(triggerRef, ref),
+    size: size,
+    label: iconDescription,
+    kind: "ghost"
+  }), /*#__PURE__*/React__default.createElement(IconElement, {
+    className: overflowMenuIconClasses,
+    "aria-label": iconDescription
+  })), open && hasMountedTrigger && wrappedMenuBody));
+});
+OverflowMenu.propTypes = {
   /**
    * Specify a label to be read by screen readers on the container node
    */
@@ -449,15 +387,15 @@ _defineProperty(OverflowMenu, "propTypes", {
    * The adjustment in position applied to the floating menu.
    */
   menuOffset: PropTypes.oneOfType([PropTypes.shape({
-    top: PropTypes.number,
-    left: PropTypes.number
+    top: PropTypes.number.isRequired,
+    left: PropTypes.number.isRequired
   }), PropTypes.func]),
   /**
    * The adjustment in position applied to the floating menu.
    */
   menuOffsetFlip: PropTypes.oneOfType([PropTypes.shape({
-    top: PropTypes.number,
-    left: PropTypes.number
+    top: PropTypes.number.isRequired,
+    left: PropTypes.number.isRequired
   }), PropTypes.func]),
   /**
    * The class to apply to the menu options
@@ -488,8 +426,9 @@ _defineProperty(OverflowMenu, "propTypes", {
    */
   open: PropTypes.bool,
   /**
-   * Function called to override icon rendering.
+   * A component used to render an icon.
    */
+  // @ts-expect-error: PropTypes are not expressive enough to cover this case
   renderIcon: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
   /**
    * Specify a CSS selector that matches the DOM element that should
@@ -500,14 +439,6 @@ _defineProperty(OverflowMenu, "propTypes", {
    * 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);
-(() => {
-  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 };
+export { OverflowMenu, OverflowMenu as default, getMenuOffset };