rsuite 5.75.0 → 6.0.0-canary-20241227

package/esm/internals/Overlay/Overlay.js

@@ -2,113 +2,95 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import React, { useState, useRef, useCallback, useContext } from 'react';
 import classNames from 'classnames';
-import PropTypes from 'prop-types';
 import Position from "./Position.js";
 import { useRootClose } from "../hooks/index.js";
 import { mergeRefs } from "../utils/index.js";
 import Fade from "../../Animation/Fade.js";
 import OverlayContext from "./OverlayContext.js";
-export var overlayPropTypes = {
-  container: PropTypes.any,
-  children: PropTypes.any,
-  childrenProps: PropTypes.object,
-  className: PropTypes.string,
-  containerPadding: PropTypes.number,
-  placement: PropTypes.any,
-  preventOverflow: PropTypes.bool,
-  open: PropTypes.bool,
-  rootClose: PropTypes.bool,
-  transition: PropTypes.any,
-  triggerTarget: PropTypes.any,
-  onClose: PropTypes.func,
-  onEnter: PropTypes.func,
-  onEntering: PropTypes.func,
-  onEntered: PropTypes.func,
-  onExit: PropTypes.func,
-  onExiting: PropTypes.func,
-  onExited: PropTypes.func
-};
-
 /**
  * Overlay is a powerful component that helps you create floating components.
  * @private
  */
-var Overlay = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var _useContext = useContext(OverlayContext),
-    overlayContainer = _useContext.overlayContainer;
-  var _props$container = props.container,
-    container = _props$container === void 0 ? overlayContainer : _props$container,
-    containerPadding = props.containerPadding,
-    placement = props.placement,
-    rootClose = props.rootClose,
-    children = props.children,
-    childrenProps = props.childrenProps,
-    _props$transition = props.transition,
-    Transition = _props$transition === void 0 ? Fade : _props$transition,
-    open = props.open,
-    preventOverflow = props.preventOverflow,
-    triggerTarget = props.triggerTarget,
-    onClose = props.onClose,
-    onExited = props.onExited,
-    onExit = props.onExit,
-    onExiting = props.onExiting,
-    onEnter = props.onEnter,
-    onEntering = props.onEntering,
-    onEntered = props.onEntered,
-    followCursor = props.followCursor,
-    cursorPosition = props.cursorPosition;
-  var _useState = useState(!open),
-    exited = _useState[0],
-    setExited = _useState[1];
-  var overlayTarget = useRef(null);
+const Overlay = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    overlayContainer
+  } = useContext(OverlayContext);
+  const {
+    container = overlayContainer,
+    containerPadding,
+    placement,
+    rootClose,
+    children,
+    childrenProps,
+    transition: Transition = Fade,
+    open,
+    preventOverflow,
+    triggerTarget,
+    onClose,
+    onExited,
+    onExit,
+    onExiting,
+    onEnter,
+    onEntering,
+    onEntered,
+    followCursor,
+    cursorPosition
+  } = props;
+  const [exited, setExited] = useState(!open);
+  const overlayTarget = useRef(null);
   if (open) {
     if (exited) setExited(false);
   } else if (!Transition && !exited) {
     setExited(true);
   }
-  var mountOverlay = open || Transition && !exited;
-  var handleExited = useCallback(function (args) {
+  const mountOverlay = open || Transition && !exited;
+  const handleExited = useCallback(args => {
     setExited(true);
     onExited === null || onExited === void 0 || onExited(args);
   }, [onExited]);
   useRootClose(onClose, {
-    triggerTarget: triggerTarget,
-    overlayTarget: overlayTarget,
+    triggerTarget,
+    overlayTarget,
     disabled: !rootClose || !mountOverlay
   });
   if (!mountOverlay) {
     return null;
   }
-  var positionProps = {
-    container: container,
-    containerPadding: containerPadding,
-    triggerTarget: triggerTarget,
-    placement: placement,
-    preventOverflow: preventOverflow,
-    followCursor: followCursor,
-    cursorPosition: cursorPosition
+  const positionProps = {
+    container,
+    containerPadding,
+    triggerTarget,
+    placement,
+    preventOverflow,
+    followCursor,
+    cursorPosition
   };
-  var renderChildWithPosition = function renderChildWithPosition(transitionProps, transitionRef) {
+  const renderChildWithPosition = (transitionProps, transitionRef) => {
     return /*#__PURE__*/React.createElement(Position, _extends({}, positionProps, transitionProps, {
       ref: mergeRefs(ref, transitionRef)
-    }), function (childProps, childRef) {
+    }), (childProps, childRef) => {
       // overlayTarget is the ref on the DOM of the Overlay.
       if (typeof children === 'function') {
         return children(Object.assign(childProps, childrenProps), mergeRefs(childRef, overlayTarget));
       }
 
       // Position will return coordinates and className
-      var left = childProps.left,
-        top = childProps.top,
-        className = childProps.className;
-      return /*#__PURE__*/React.cloneElement(children, _extends({}, childrenProps, children.props, {
+      const {
+        left,
+        top,
+        className
+      } = childProps;
+      return /*#__PURE__*/React.cloneElement(children, {
+        ...childrenProps,
+        ...children.props,
         className: classNames(className, children.props.className),
-        style: _extends({
-          left: left,
-          top: top
-        }, children.props.style),
+        style: {
+          left,
+          top,
+          ...children.props.style
+        },
         ref: mergeRefs(childRef, overlayTarget)
-      }));
+      });
     });
   };
   if (Transition) {
@@ -126,5 +108,4 @@ var Overlay = /*#__PURE__*/React.forwardRef(function (props, ref) {
   return renderChildWithPosition();
 });
 Overlay.displayName = 'Overlay';
-Overlay.propTypes = overlayPropTypes;
 export default Overlay;

package/esm/internals/Overlay/OverlayContext.js

@@ -1,5 +1,5 @@
 'use client';
 import React from 'react';
-var OverlayContext = /*#__PURE__*/React.createContext({});
+const OverlayContext = /*#__PURE__*/React.createContext({});
 OverlayContext.displayName = 'OverlayContext';
 export default OverlayContext;

package/esm/internals/Overlay/OverlayTrigger.js

@@ -1,7 +1,5 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-var _excluded = ["children", "container", "controlId", "defaultOpen", "trigger", "disabled", "followCursor", "readOnly", "plaintext", "open", "delay", "delayOpen", "delayClose", "enterable", "placement", "speaker", "rootClose", "onClick", "onMouseOver", "onMouseMove", "onMouseOut", "onContextMenu", "onFocus", "onBlur", "onOpen", "onClose", "onExited"];
 import React, { useRef, useEffect, useImperativeHandle, useCallback, useContext, useState, useMemo, isValidElement, cloneElement } from 'react';
 import get from 'lodash/get';
 import isNil from 'lodash/isNil';
@@ -19,8 +17,8 @@ function mergeEvents(events, props) {
   if (props === void 0) {
     props = {};
   }
-  var nextEvents = {};
-  Object.keys(events).forEach(function (eventName) {
+  const nextEvents = {};
+  Object.keys(events).forEach(eventName => {
     if (events[eventName]) {
       var _props;
       nextEvents[eventName] = createChainedFunction(events[eventName], (_props = props) === null || _props === void 0 ? void 0 : _props[eventName]);
@@ -33,7 +31,7 @@ function mergeEvents(events, props) {
  * - Clicking outside of the overlay
  * - Direct invocation of triggerRef.current.close()
  */
-export var OverlayCloseCause = /*#__PURE__*/function (OverlayCloseCause) {
+export let OverlayCloseCause = /*#__PURE__*/function (OverlayCloseCause) {
   OverlayCloseCause[OverlayCloseCause["ClickOutside"] = 0] = "ClickOutside";
   OverlayCloseCause[OverlayCloseCause["ImperativeHandle"] = 1] = "ImperativeHandle";
   return OverlayCloseCause;
@@ -46,83 +44,79 @@ export var OverlayCloseCause = /*#__PURE__*/function (OverlayCloseCause) {
  * @param handler
  * @param event
  */
-function onMouseEventHandler(handler, event, delay) {
-  var target = event.currentTarget;
-  var related = event.relatedTarget || get(event, ['nativeEvent', 'toElement']);
+function onMouseEventHandler(handler, event, relatedNative) {
+  const target = event.currentTarget;
+  const related = event.relatedTarget || get(event, ['nativeEvent', relatedNative]);
   if ((!related || related !== target) && !contains(target, related)) {
-    handler(event, delay);
+    handler(event);
   }
 }
-var defaultTrigger = ['hover', 'focus'];
+const defaultTrigger = ['hover', 'focus'];
 
 /**
  * OverlayTrigger is used to display floating elements on another component.
  * @private
  */
-var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var _useContext = useContext(OverlayContext),
-    overlayContainer = _useContext.overlayContainer;
-  var children = props.children,
-    _props$container = props.container,
-    container = _props$container === void 0 ? overlayContainer : _props$container,
-    controlId = props.controlId,
-    defaultOpen = props.defaultOpen,
-    _props$trigger = props.trigger,
-    trigger = _props$trigger === void 0 ? defaultTrigger : _props$trigger,
-    disabled = props.disabled,
-    followCursor = props.followCursor,
-    readOnly = props.readOnly,
-    plaintext = props.plaintext,
-    openProp = props.open,
-    delay = props.delay,
-    delayOpenProp = props.delayOpen,
-    delayCloseProp = props.delayClose,
-    enterable = props.enterable,
-    _props$placement = props.placement,
-    placement = _props$placement === void 0 ? 'bottomStart' : _props$placement,
-    speaker = props.speaker,
-    _props$rootClose = props.rootClose,
-    rootClose = _props$rootClose === void 0 ? true : _props$rootClose,
-    onClick = props.onClick,
-    onMouseOver = props.onMouseOver,
-    onMouseMove = props.onMouseMove,
-    onMouseOut = props.onMouseOut,
-    onContextMenu = props.onContextMenu,
-    onFocus = props.onFocus,
-    onBlur = props.onBlur,
-    onOpen = props.onOpen,
-    onClose = props.onClose,
-    onExited = props.onExited,
-    rest = _objectWithoutPropertiesLoose(props, _excluded);
-  var _usePortal = usePortal({
-      container: container
-    }),
-    Portal = _usePortal.Portal,
-    containerElement = _usePortal.target;
-  var triggerRef = useRef(null);
-  var overlayRef = useRef();
-  var _useControlled = useControlled(openProp, defaultOpen),
-    open = _useControlled[0],
-    setOpen = _useControlled[1];
-  var _useState = useState(null),
-    cursorPosition = _useState[0],
-    setCursorPosition = _useState[1];
+const OverlayTrigger = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    overlayContainer
+  } = useContext(OverlayContext);
+  const {
+    children,
+    container = overlayContainer,
+    controlId,
+    defaultOpen,
+    trigger = defaultTrigger,
+    disabled,
+    followCursor,
+    readOnly,
+    plaintext,
+    open: openProp,
+    delay,
+    delayOpen: delayOpenProp,
+    delayClose: delayCloseProp,
+    enterable,
+    placement = 'bottomStart',
+    speaker,
+    rootClose = true,
+    onClick,
+    onMouseOver,
+    onMouseMove,
+    onMouseOut,
+    onContextMenu,
+    onFocus,
+    onBlur,
+    onOpen,
+    onClose,
+    onExited,
+    ...rest
+  } = props;
+  const {
+    Portal,
+    target: containerElement
+  } = usePortal({
+    container
+  });
+  const triggerRef = useRef(null);
+  const overlayRef = useRef();
+  const [open, setOpen] = useControlled(openProp, defaultOpen);
+  const [cursorPosition, setCursorPosition] = useState(null);
 
   // Delay the timer to close/open the overlay
   // When the cursor moves from the trigger to the overlay, the overlay will be closed.
   // In order to keep the overlay open, a timer is used to delay the closing.
-  var delayOpenTimer = useRef(null);
-  var delayCloseTimer = useRef(null);
-  var delayOpen = isNil(delayOpenProp) ? delay : delayOpenProp;
-  var delayClose = isNil(delayCloseProp) ? delay : delayCloseProp;
+  const delayOpenTimer = useRef(null);
+  const delayCloseTimer = useRef(null);
+  const delayOpen = isNil(delayOpenProp) ? delay : delayOpenProp;
+  const delayClose = isNil(delayCloseProp) ? delay : delayCloseProp;
 
   // Whether the cursor is on the overlay
-  var isOnOverlay = useRef(false);
+  const isOnOverlay = useRef(false);
 
   // Whether the cursor is on the trigger
-  var isOnTrigger = useRef(false);
-  useEffect(function () {
-    return function () {
+  const isOnTrigger = useRef(false);
+  useEffect(() => {
+    return () => {
       if (!isNil(delayOpenTimer.current)) {
         clearTimeout(delayOpenTimer.current);
       }
@@ -133,8 +127,8 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
   }, []);
 
   // Whether the cursor is on the overlay
-  var mouseEnter = useRef(false);
-  var handleOpenChange = useCallback(function (nextOpen, closeCause) {
+  const mouseEnter = useRef(false);
+  const handleOpenChange = useCallback((nextOpen, closeCause) => {
     // if the overlay open state is not changed, do not fire the event
     if (nextOpen === open) return;
     if (nextOpen) {
@@ -144,10 +138,10 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
     }
     setOpen(nextOpen);
   }, [open, onOpen, onClose, setOpen]);
-  var handleOpen = useCallback(function (delay) {
-    var ms = isUndefined(delay) ? delayOpen : delay;
+  const handleOpen = useCallback(delay => {
+    const ms = isUndefined(delay) ? delayOpen : delay;
     if (ms && typeof ms === 'number') {
-      return delayOpenTimer.current = setTimeout(function () {
+      return delayOpenTimer.current = setTimeout(() => {
         delayOpenTimer.current = null;
         if (mouseEnter.current) {
           handleOpenChange(true);
@@ -156,54 +150,48 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
     }
     handleOpenChange(true);
   }, [delayOpen, handleOpenChange]);
-  var handleClose = useCallback(function (delay, closeCause) {
-    var ms = isUndefined(delay) ? delayClose : delay;
+  const handleClose = useCallback((delay, closeCause) => {
+    const ms = isUndefined(delay) ? delayClose : delay;
     if (ms && typeof ms === 'number') {
-      return delayCloseTimer.current = setTimeout(function () {
+      return delayCloseTimer.current = setTimeout(() => {
         delayCloseTimer.current = null;
         handleOpenChange(false, closeCause);
       }, ms);
     }
     handleOpenChange(false, closeCause);
   }, [delayClose, handleOpenChange]);
-  var handleExited = useCallback(function () {
+  const handleExited = useCallback(() => {
     setCursorPosition(null);
   }, []);
-  useImperativeHandle(ref, function () {
-    return {
-      get root() {
-        return triggerRef.current;
-      },
-      get overlay() {
-        var _overlayRef$current;
-        return (_overlayRef$current = overlayRef.current) === null || _overlayRef$current === void 0 ? void 0 : _overlayRef$current.child;
-      },
-      getState: function getState() {
-        return {
-          open: open
-        };
-      },
-      open: handleOpen,
-      close: function close(delay) {
-        return handleClose(delay, OverlayCloseCause.ImperativeHandle);
-      },
-      updatePosition: function updatePosition() {
-        var _overlayRef$current2, _overlayRef$current2$;
-        (_overlayRef$current2 = overlayRef.current) === null || _overlayRef$current2 === void 0 || (_overlayRef$current2$ = _overlayRef$current2.updatePosition) === null || _overlayRef$current2$ === void 0 || _overlayRef$current2$.call(_overlayRef$current2);
-      }
-    };
-  });
+  useImperativeHandle(ref, () => ({
+    get root() {
+      return triggerRef.current;
+    },
+    get overlay() {
+      var _overlayRef$current;
+      return (_overlayRef$current = overlayRef.current) === null || _overlayRef$current === void 0 ? void 0 : _overlayRef$current.child;
+    },
+    getState: () => ({
+      open
+    }),
+    open: handleOpen,
+    close: delay => handleClose(delay, OverlayCloseCause.ImperativeHandle),
+    updatePosition: () => {
+      var _overlayRef$current2, _overlayRef$current2$;
+      (_overlayRef$current2 = overlayRef.current) === null || _overlayRef$current2 === void 0 || (_overlayRef$current2$ = _overlayRef$current2.updatePosition) === null || _overlayRef$current2$ === void 0 || _overlayRef$current2$.call(_overlayRef$current2);
+    }
+  }));
 
   /**
    * Close after the cursor leaves.
    */
-  var handleCloseWhenLeave = useCallback(function () {
+  const handleCloseWhenLeave = useCallback(() => {
     // When the cursor is not on the overlay and not on the trigger, it is closed.
     if (!isOnOverlay.current && !isOnTrigger.current) {
       handleClose(undefined, OverlayCloseCause.ClickOutside);
     }
   }, [handleClose]);
-  var handleDelayedOpen = useCallback(function () {
+  const handleDelayedOpen = useCallback(() => {
     mouseEnter.current = true;
     if (!enterable) {
       return handleOpen();
@@ -223,14 +211,14 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
   /**
    * Toggle open and closed state.
    */
-  var handleOpenState = useCallback(function () {
+  const handleOpenState = useCallback(() => {
     if (open) {
       handleCloseWhenLeave();
     } else {
       handleDelayedOpen();
     }
   }, [open, handleCloseWhenLeave, handleDelayedOpen]);
-  var handleDelayedClose = useCallback(function () {
+  const handleDelayedClose = useCallback(() => {
     mouseEnter.current = false;
     if (!enterable) {
       return handleClose();
@@ -244,7 +232,7 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
     if (!open || !isNil(delayCloseTimer.current)) {
       return;
     }
-    delayCloseTimer.current = setTimeout(function () {
+    delayCloseTimer.current = setTimeout(() => {
       if (!isNil(delayCloseTimer.current)) {
         clearTimeout(delayCloseTimer.current);
         delayCloseTimer.current = null;
@@ -252,38 +240,42 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
       handleCloseWhenLeave();
     }, 200);
   }, [enterable, open, handleClose, handleCloseWhenLeave]);
-  var handleSpeakerMouseEnter = useCallback(function () {
+  const handleSpeakerMouseEnter = useCallback(() => {
     isOnOverlay.current = true;
   }, []);
-  var handleSpeakerMouseLeave = useCallback(function () {
+  const handleSpeakerMouseLeave = useCallback(() => {
     isOnOverlay.current = false;
     if (!isOneOf('click', trigger) && !isOneOf('contextMenu', trigger) && !isOneOf('active', trigger)) {
       handleCloseWhenLeave();
     }
   }, [handleCloseWhenLeave, trigger]);
-  var handledMoveOverlay = useCallback(function (event) {
-    setCursorPosition(function () {
-      return {
-        top: event.pageY,
-        left: event.pageX,
-        clientTop: event.clientX,
-        clientLeft: event.clientY
-      };
-    });
+  const handledMoveOverlay = useCallback(event => {
+    setCursorPosition(() => ({
+      top: event.pageY,
+      left: event.pageX,
+      clientTop: event.clientX,
+      clientLeft: event.clientY
+    }));
   }, []);
-  var preventDefault = useCallback(function (event) {
+  const handleMouseOver = useCallback(event => {
+    onMouseEventHandler(handleDelayedOpen, event, 'fromElement');
+  }, [handleDelayedOpen]);
+  const handleMouseOut = useCallback(event => {
+    onMouseEventHandler(handleDelayedClose, event, 'toElement');
+  }, [handleDelayedClose]);
+  const preventDefault = useCallback(event => {
     event.preventDefault();
   }, []);
-  var triggerEvents = useMemo(function () {
+  const triggerEvents = useMemo(() => {
     // Pass events by props
-    var events = {
-      onClick: onClick,
-      onContextMenu: onContextMenu,
-      onMouseOver: onMouseOver,
-      onMouseOut: onMouseOut,
-      onFocus: onFocus,
-      onBlur: onBlur,
-      onMouseMove: onMouseMove
+    const events = {
+      onClick,
+      onContextMenu,
+      onMouseOver,
+      onMouseOut,
+      onFocus,
+      onBlur,
+      onMouseMove
     };
 
     // When trigger is disabled, no predefined event listeners are added.
@@ -310,14 +302,8 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
       return events;
     }
     if (isOneOf('hover', trigger)) {
-      var onMouseOverListener = function onMouseOverListener(e) {
-        return onMouseEventHandler(handleDelayedOpen, e);
-      };
-      var onMouseOutListener = function onMouseOutListener(e) {
-        return onMouseEventHandler(handleDelayedClose, e);
-      };
-      events.onMouseOver = createChainedFunction(onMouseOverListener, events.onMouseOver);
-      events.onMouseOut = createChainedFunction(onMouseOutListener, events.onMouseOut);
+      events.onMouseOver = createChainedFunction(handleMouseOver, events.onMouseOver);
+      events.onMouseOut = createChainedFunction(handleMouseOut, events.onMouseOut);
     }
     if (isOneOf('focus', trigger)) {
       events.onFocus = createChainedFunction(handleDelayedOpen, events.onFocus);
@@ -327,20 +313,19 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
       events.onContextMenu = createChainedFunction(preventDefault, handleOpenState, events.onContextMenu);
     }
     return events;
-  }, [disabled, followCursor, handleDelayedClose, handleDelayedOpen, handleOpenState, handledMoveOverlay, onBlur, onClick, onContextMenu, onFocus, onMouseMove, onMouseOut, onMouseOver, plaintext, preventDefault, readOnly, trigger]);
-  var renderOverlay = function renderOverlay() {
-    var overlayProps = _extends({}, rest, {
-      rootClose: rootClose,
+  }, [disabled, followCursor, handleDelayedClose, handleDelayedOpen, handleMouseOut, handleMouseOver, handleOpenState, handledMoveOverlay, onBlur, onClick, onContextMenu, onFocus, onMouseMove, onMouseOut, onMouseOver, plaintext, preventDefault, readOnly, trigger]);
+  const renderOverlay = () => {
+    const overlayProps = {
+      ...rest,
+      rootClose,
       triggerTarget: triggerRef,
-      onClose: trigger !== 'none' ? function () {
-        return handleClose(undefined, OverlayCloseCause.ClickOutside);
-      } : undefined,
+      onClose: trigger !== 'none' ? () => handleClose(undefined, OverlayCloseCause.ClickOutside) : undefined,
       onExited: createChainedFunction(followCursor ? handleExited : undefined, onExited),
-      placement: placement,
+      placement,
       container: containerElement,
-      open: open
-    });
-    var speakerProps = {
+      open
+    };
+    const speakerProps = {
       id: controlId
     };
 
@@ -356,13 +341,14 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
       childrenProps: speakerProps,
       followCursor: followCursor,
       cursorPosition: cursorPosition
-    }), typeof speaker === 'function' ? function (props, ref) {
-      return speaker(_extends({}, props, {
+    }), typeof speaker === 'function' ? (props, ref) => {
+      return speaker({
+        ...props,
         onClose: handleClose
-      }), ref);
+      }, ref);
     } : speaker);
   };
-  var triggerElement = useMemo(function () {
+  const triggerElement = useMemo(() => {
     if (typeof children === 'function') {
       return children(triggerEvents, triggerRef);
     } else if (isFragment(children) || ! /*#__PURE__*/isValidElement(children)) {
@@ -371,10 +357,11 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
         "aria-describedby": controlId
       }, triggerEvents), children);
     }
-    return /*#__PURE__*/cloneElement(children, _extends({
+    return /*#__PURE__*/cloneElement(children, {
       ref: triggerRef,
-      'aria-describedby': controlId
-    }, mergeEvents(triggerEvents, children.props)));
+      'aria-describedby': controlId,
+      ...mergeEvents(triggerEvents, children.props)
+    });
   }, [children, controlId, triggerEvents]);
   return /*#__PURE__*/React.createElement(React.Fragment, null, triggerElement, /*#__PURE__*/React.createElement(Portal, null, renderOverlay()));
 });