rsuite 5.2.4 → 5.4.2

package/esm/Overlay/Modal.js

@@ -1,16 +1,16 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import React, { useRef, useEffect, useState, useCallback } from 'react';
+import React, { useRef, useEffect, useState, useCallback, useMemo } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
-import canUseDOM from 'dom-lib/canUseDOM';
 import contains from 'dom-lib/contains';
 import getContainer from 'dom-lib/getContainer';
 import on from 'dom-lib/on';
 import ModalManager from './ModalManager';
 import Fade from '../Animation/Fade';
 import { animationPropTypes } from '../Animation/utils';
-import { mergeRefs, getDOMNode, usePortal, createChainedFunction, useWillUnmount } from '../utils';
+import { mergeRefs, usePortal, createChainedFunction, useWillUnmount, useEventCallback, KEY_VALUES } from '../utils';
+import OverlayContext from './OverlayContext';
 var manager;
 
 function getManager() {
@@ -25,6 +25,12 @@ var useModalManager = function useModalManager() {
     backdrop: null
   });
   return {
+    get dialog() {
+      var _modal$current;
+
+      return (_modal$current = modal.current) === null || _modal$current === void 0 ? void 0 : _modal$current.dialog;
+    },
+
     add: function add(containerElement, containerClassName) {
       return modalManager.add(modal.current, containerElement, containerClassName);
     },
@@ -66,8 +72,7 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
       open = props.open,
       _props$autoFocus = props.autoFocus,
       autoFocus = _props$autoFocus === void 0 ? true : _props$autoFocus,
-      onBackdropClick = props.onBackdropClick,
-      onEscapeKeyUp = props.onEscapeKeyUp,
+      onEsc = props.onEsc,
       onExit = props.onExit,
       onExiting = props.onExiting,
       onExited = props.onExited,
@@ -76,7 +81,7 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
       onEntered = props.onEntered,
       onClose = props.onClose,
       onOpen = props.onOpen,
-      rest = _objectWithoutPropertiesLoose(props, ["as", "children", "transition", "dialogTransitionTimeout", "style", "className", "container", "animationProps", "containerClassName", "keyboard", "enforceFocus", "backdrop", "backdropTransitionTimeout", "backdropStyle", "backdropClassName", "open", "autoFocus", "onBackdropClick", "onEscapeKeyUp", "onExit", "onExiting", "onExited", "onEnter", "onEntering", "onEntered", "onClose", "onOpen"]);
+      rest = _objectWithoutPropertiesLoose(props, ["as", "children", "transition", "dialogTransitionTimeout", "style", "className", "container", "animationProps", "containerClassName", "keyboard", "enforceFocus", "backdrop", "backdropTransitionTimeout", "backdropStyle", "backdropClassName", "open", "autoFocus", "onEsc", "onExit", "onExiting", "onExited", "onEnter", "onEntering", "onEntered", "onClose", "onOpen"]);
 
   var _useState = useState(!open),
       exited = _useState[0],
@@ -96,19 +101,13 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
   }
 
   var mountModal = open || Transition && !exited;
-  var rootRef = useRef();
-  var lastFocus = useRef();
-  var handleDocumentKeyUp = useCallback(function (event) {
-    if (keyboard && event.keyCode === 27 && modal.isTopModal()) {
-      onEscapeKeyUp === null || onEscapeKeyUp === void 0 ? void 0 : onEscapeKeyUp(event);
+  var lastFocus = useRef(null);
+  var handleDocumentKeyDown = useEventCallback(function (event) {
+    if (keyboard && event.key === KEY_VALUES.ESC && modal.isTopModal()) {
+      onEsc === null || onEsc === void 0 ? void 0 : onEsc(event);
       onClose === null || onClose === void 0 ? void 0 : onClose(event);
     }
-  }, [keyboard, modal, onEscapeKeyUp, onClose]);
-  var checkForFocus = useCallback(function () {
-    if (canUseDOM) {
-      lastFocus.current = document.activeElement;
-    }
-  }, []);
+  });
   var restoreLastFocus = useCallback(function () {
     if (lastFocus.current) {
       var _lastFocus$current$fo, _lastFocus$current;
@@ -117,55 +116,60 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
       lastFocus.current = null;
     }
   }, []);
-  var getDialogElement = useCallback(function () {
-    return getDOMNode(rootRef.current);
-  }, []);
-  var handleEnforceFocus = useCallback(function () {
-    if (!enforceFocus || !modal.isTopModal()) {
-      return;
-    }
+  /**
+   * Determines if the currently focused element is inside the dialog,
+   * and if not, returns the focus to the dialog.
+   *
+   */
 
+  var handleFocusDialog = useEventCallback(function (onBeforeFocusCallback) {
     var currentActiveElement = document.activeElement;
-    var dialog = getDialogElement();
+    var dialog = modal.dialog;
 
-    if (dialog && dialog !== currentActiveElement && !contains(dialog, currentActiveElement)) {
+    if (dialog && currentActiveElement && !contains(dialog, currentActiveElement)) {
+      onBeforeFocusCallback === null || onBeforeFocusCallback === void 0 ? void 0 : onBeforeFocusCallback();
       dialog.focus();
     }
-  }, [enforceFocus, getDialogElement, modal]);
-  var handleBackdropClick = useCallback(function (event) {
-    if (event.target !== event.currentTarget) {
+  });
+  var handleEnforceFocus = useEventCallback(function () {
+    if (!enforceFocus || !modal.isTopModal()) {
       return;
     }
 
-    onBackdropClick === null || onBackdropClick === void 0 ? void 0 : onBackdropClick(event);
-
-    if (backdrop === true) {
-      onClose === null || onClose === void 0 ? void 0 : onClose(event);
-    }
-  }, [backdrop, onBackdropClick, onClose]);
-  var documentKeyupListener = useRef();
-  var docusinListener = useRef();
-  var handleOpen = useCallback(function () {
-    var dialog = getDialogElement();
+    handleFocusDialog();
+  });
+  var documentKeyDownListener = useRef();
+  var documentFocusListener = useRef();
+  var handleOpen = useEventCallback(function () {
     var containerElement = getContainer(container, document.body);
     modal.add(containerElement, containerClassName);
-    documentKeyupListener.current = on(document, 'keydown', handleDocumentKeyUp);
-    docusinListener.current = on(document, 'focus', handleEnforceFocus, true);
-    onOpen === null || onOpen === void 0 ? void 0 : onOpen();
-    checkForFocus();
+
+    if (!documentKeyDownListener.current) {
+      documentKeyDownListener.current = on(document, 'keydown', handleDocumentKeyDown);
+    }
+
+    if (!documentFocusListener.current) {
+      documentFocusListener.current = on(document, 'focus', handleEnforceFocus, true);
+    }
 
     if (autoFocus) {
-      dialog === null || dialog === void 0 ? void 0 : dialog.focus();
+      handleFocusDialog(function () {
+        lastFocus.current = document.activeElement;
+      });
     }
-  }, [autoFocus, checkForFocus, container, containerClassName, getDialogElement, handleDocumentKeyUp, handleEnforceFocus, modal, onOpen]);
-  var handleClose = useCallback(function () {
-    var _documentKeyupListene, _docusinListener$curr;
+
+    onOpen === null || onOpen === void 0 ? void 0 : onOpen();
+  });
+  var handleClose = useEventCallback(function () {
+    var _documentKeyDownListe, _documentFocusListene;
 
     modal.remove();
-    (_documentKeyupListene = documentKeyupListener.current) === null || _documentKeyupListene === void 0 ? void 0 : _documentKeyupListene.off();
-    (_docusinListener$curr = docusinListener.current) === null || _docusinListener$curr === void 0 ? void 0 : _docusinListener$curr.off();
+    (_documentKeyDownListe = documentKeyDownListener.current) === null || _documentKeyDownListe === void 0 ? void 0 : _documentKeyDownListe.off();
+    documentKeyDownListener.current = null;
+    (_documentFocusListene = documentFocusListener.current) === null || _documentFocusListene === void 0 ? void 0 : _documentFocusListene.off();
+    documentFocusListener.current = null;
     restoreLastFocus();
-  }, [modal, restoreLastFocus]);
+  });
   useEffect(function () {
     if (!open) {
       return;
@@ -186,17 +190,19 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var handleExited = useCallback(function () {
     setExited(true);
   }, []);
+  var contextValue = useMemo(function () {
+    return {
+      overlayContainer: function overlayContainer() {
+        return modal.dialog;
+      }
+    };
+  }, [modal.dialog]);
 
   if (!mountModal) {
     return null;
   }
 
   var renderBackdrop = function renderBackdrop() {
-    var backdropPorps = {
-      style: backdropStyle,
-      onClick: handleBackdropClick
-    };
-
     if (Transition) {
       return /*#__PURE__*/React.createElement(Fade, {
         transitionAppear: true,
@@ -208,18 +214,19 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
 
         return /*#__PURE__*/React.createElement("div", _extends({
           "aria-hidden": true
-        }, rest, backdropPorps, {
+        }, rest, {
+          style: backdropStyle,
           ref: mergeRefs(modal.setBackdropRef, ref),
           className: classNames(backdropClassName, className)
         }));
       });
     }
 
-    return /*#__PURE__*/React.createElement("div", _extends({
-      "aria-hidden": true
-    }, backdropPorps, {
+    return /*#__PURE__*/React.createElement("div", {
+      "aria-hidden": true,
+      style: backdropStyle,
       className: backdropClassName
-    }));
+    });
   };
 
   var dialogElement = Transition ? /*#__PURE__*/React.createElement(Transition, _extends({}, animationProps, {
@@ -234,12 +241,14 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
     onEntering: onEntering,
     onEntered: onEntered
   }), children) : children;
-  return /*#__PURE__*/React.createElement(Portal, null, /*#__PURE__*/React.createElement(Component, _extends({}, rest, {
+  return /*#__PURE__*/React.createElement(OverlayContext.Provider, {
+    value: contextValue
+  }, /*#__PURE__*/React.createElement(Portal, null, backdrop && renderBackdrop(), /*#__PURE__*/React.createElement(Component, _extends({}, rest, {
     ref: mergeRefs(modal.setDialogRef, ref),
     style: style,
     className: className,
     tabIndex: -1
-  }), backdrop && renderBackdrop(), dialogElement));
+  }), dialogElement)));
 });
 export var modalPropTypes = {
   as: PropTypes.elementType,
@@ -264,7 +273,6 @@ Modal.propTypes = _extends({}, animationPropTypes, modalPropTypes, {
   dialogTransitionTimeout: PropTypes.number,
   backdropTransitionTimeout: PropTypes.number,
   transition: PropTypes.any,
-  onEscapeKeyUp: PropTypes.func,
-  onBackdropClick: PropTypes.func
+  onEsc: PropTypes.func
 });
 export default Modal;

package/esm/Overlay/ModalManager.d.ts

@@ -1,11 +1,20 @@
+import React from 'react';
+export interface ModalInstance {
+    dialog: HTMLElement | null;
+    backdrop: HTMLElement | null;
+}
+export interface ContainerState {
+    classes: string[];
+    modals: ModalInstance[];
+    style: React.CSSProperties;
+    overflowing: boolean;
+}
 declare class ModalManager {
-    constructor(hideSiblingNodes?: boolean);
-    hideSiblingNodes: any;
-    modals: any[];
-    containers: any[];
-    data: any[];
-    add(modal: any, container: any, className?: string): number;
-    remove(modal: any): void;
-    isTopModal(modal: any): boolean;
+    modals: ModalInstance[];
+    containers: HTMLElement[];
+    data: ContainerState[];
+    add(modal: ModalInstance, container: HTMLElement, className?: string): number;
+    remove(modal: ModalInstance): void;
+    isTopModal(modal: ModalInstance): boolean;
 }
 export default ModalManager;

package/esm/Overlay/ModalManager.js

@@ -25,16 +25,7 @@ function findContainer(data, modal) {
 }
 
 var ModalManager = /*#__PURE__*/function () {
-  function ModalManager(hideSiblingNodes) {
-    if (hideSiblingNodes === void 0) {
-      hideSiblingNodes = true;
-    }
-
-    this.hideSiblingNodes = null;
-    this.modals = [];
-    this.containers = [];
-    this.data = [];
-    this.hideSiblingNodes = hideSiblingNodes;
+  function ModalManager() {
     this.modals = [];
     this.containers = [];
     this.data = [];
@@ -58,7 +49,7 @@ var ModalManager = /*#__PURE__*/function () {
       return modalIndex;
     }
 
-    var data = {
+    var containerState = {
       modals: [modal],
       classes: className ? className.split(/\s+/) : [],
       style: {
@@ -68,7 +59,7 @@ var ModalManager = /*#__PURE__*/function () {
       overflowing: isOverflowing(container)
     };
 
-    if (data.overflowing) {
+    if (containerState.overflowing) {
       var paddingRight = parseInt(getStyle(container, 'paddingRight') || 0, 10);
       var barSize = getScrollbarSize();
       addStyle(container, {
@@ -76,9 +67,9 @@ var ModalManager = /*#__PURE__*/function () {
       });
     }
 
-    data.classes.forEach(addClass.bind(null, container));
+    containerState.classes.forEach(addClass.bind(null, container));
     this.containers.push(container);
-    this.data.push(data);
+    this.data.push(containerState);
     return modalIndex;
   };
 
@@ -90,16 +81,16 @@ var ModalManager = /*#__PURE__*/function () {
     }
 
     var containerIndex = findContainer(this.data, modal);
-    var data = this.data[containerIndex];
+    var containerState = this.data[containerIndex];
     var container = this.containers[containerIndex];
-    data.modals.splice(data.modals.indexOf(modal), 1);
+    containerState.modals.splice(containerState.modals.indexOf(modal), 1);
     this.modals.splice(modalIndex, 1);
 
-    if (data.modals.length === 0) {
-      Object.keys(data.style).forEach(function (key) {
-        return container.style[key] = data.style[key];
+    if (containerState.modals.length === 0) {
+      Object.keys(containerState.style).forEach(function (key) {
+        return container.style[key] = containerState.style[key];
       });
-      data.classes.forEach(removeClass.bind(null, container));
+      containerState.classes.forEach(removeClass.bind(null, container));
       this.containers.splice(containerIndex, 1);
       this.data.splice(containerIndex, 1);
     }

package/esm/Overlay/Overlay.d.ts

@@ -2,8 +2,8 @@ import React from 'react';
 import PropTypes from 'prop-types';
 import { TypeAttributes, AnimationEventProps } from '../@types/common';
 export interface OverlayProps extends AnimationEventProps {
-    container?: HTMLElement | (() => HTMLElement);
-    children?: React.ReactElement | ((props: any, ref: any) => React.ReactElement);
+    container?: HTMLElement | (() => HTMLElement | null) | null;
+    children: React.ReactElement | ((props: any, ref: any) => React.ReactElement);
     childrenProps?: React.HTMLAttributes<HTMLElement>;
     className?: string;
     containerPadding?: number;
@@ -13,7 +13,7 @@ export interface OverlayProps extends AnimationEventProps {
     rootClose?: boolean;
     transition?: React.ElementType;
     triggerTarget?: React.RefObject<any>;
-    onClose?: () => void;
+    onClose?: React.ReactEventHandler;
 }
 export declare const overlayPropTypes: {
     container: PropTypes.Requireable<any>;

package/esm/Overlay/Overlay.js

@@ -1,10 +1,11 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
-import React, { useState, useRef, useCallback } from 'react';
+import React, { useState, useRef, useCallback, useContext } from 'react';
 import classNames from 'classnames';
 import PropTypes from 'prop-types';
 import Position from './Position';
 import { mergeRefs, useRootClose } from '../utils';
 import Fade from '../Animation/Fade';
+import OverlayContext from './OverlayContext';
 export var overlayPropTypes = {
   container: PropTypes.any,
   children: PropTypes.any,
@@ -26,7 +27,11 @@ export var overlayPropTypes = {
   onExited: PropTypes.func
 };
 var Overlay = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var container = props.container,
+  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,
@@ -49,7 +54,7 @@ var Overlay = /*#__PURE__*/React.forwardRef(function (props, ref) {
       exited = _useState[0],
       setExited = _useState[1];
 
-  var overlayTarget = useRef();
+  var overlayTarget = useRef(null);
 
   if (open) {
     if (exited) setExited(false);

package/esm/Overlay/OverlayContext.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface OverlayContextProps {
+    overlayContainer?: () => HTMLElement | null;
+}
+declare const OverlayContext: React.Context<OverlayContextProps>;
+export default OverlayContext;

package/esm/Overlay/OverlayContext.js

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

package/esm/Overlay/OverlayTrigger.d.ts

@@ -17,7 +17,7 @@ export interface OverlayTriggerProps extends StandardProps, AnimationEventProps
     /** Container padding */
     containerPadding?: number;
     /** display element */
-    speaker?: React.ReactElement | ((props: any, ref: React.RefObject<any>) => React.ReactElement);
+    speaker: React.ReactElement | ((props: any, ref: React.RefObject<any>) => React.ReactElement);
     /** Prevent floating element overflow */
     preventOverflow?: boolean;
     /** Opern  overlay */
@@ -27,7 +27,7 @@ export interface OverlayTriggerProps extends StandardProps, AnimationEventProps
     /** Whether mouse is allowed to enter the floating layer of popover, whose default value is false. */
     enterable?: boolean;
     /** For the monitored component, the event will be bound to this component. */
-    children?: React.ReactElement | ((props: any, ref: any) => React.ReactElement);
+    children: React.ReactElement | ((props: any, ref: any) => React.ReactElement);
     /** Whether to allow clicking document to close the overlay */
     rootClose?: boolean;
     /** Once disabled, the event cannot be triggered. */
@@ -39,27 +39,27 @@ export interface OverlayTriggerProps extends StandardProps, AnimationEventProps
     /**  Set the `id` on `<Overlay>` and `aria-describedby` on `<OverlayTrigger>` */
     controlId?: string;
     /** Lose Focus callback function */
-    onBlur?: () => void;
+    onBlur?: React.FocusEventHandler;
     /** Click on the callback function */
-    onClick?: () => void;
+    onClick?: React.MouseEventHandler;
     /** RightClick on the callback function */
     onContextMenu?: React.MouseEventHandler;
     /** Callback function to get focus */
-    onFocus?: () => void;
+    onFocus?: React.FocusEventHandler;
     /** Mouse leave callback function */
-    onMouseOut?: () => void;
+    onMouseOut?: React.MouseEventHandler;
     /** Mouse over callback function */
-    onMouseOver?: () => void;
+    onMouseOver?: React.MouseEventHandler;
     /** Callback fired when open component */
     onOpen?: () => void;
     /** Callback fired when close component */
     onClose?: () => void;
 }
 export interface OverlayTriggerInstance {
-    root: Element;
-    updatePosition?: () => void;
-    open?: () => void;
-    close?: () => void;
+    root: HTMLElement;
+    updatePosition: () => void;
+    open: () => void;
+    close: () => void;
 }
 declare const OverlayTrigger: React.ForwardRefExoticComponent<OverlayTriggerProps & React.RefAttributes<unknown>>;
 export default OverlayTrigger;

package/esm/Overlay/OverlayTrigger.js

@@ -1,13 +1,14 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _isUndefined from "lodash/isUndefined";
-import React, { useRef, useEffect, useImperativeHandle, useCallback } from 'react';
+import React, { useRef, useEffect, useImperativeHandle, useCallback, useContext } from 'react';
 import get from 'lodash/get';
 import isNil from 'lodash/isNil';
 import contains from 'dom-lib/contains';
 import Overlay from './Overlay';
 import { createChainedFunction, usePortal, useControlled } from '../utils';
 import isOneOf from '../utils/isOneOf';
+import OverlayContext from './OverlayContext';
 
 function mergeEvents(events, props) {
   if (events === void 0) {
@@ -47,8 +48,12 @@ function onMouseEventHandler(handler, event, delay) {
 
 var defaultTrigger = ['hover', 'focus'];
 var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var _useContext = useContext(OverlayContext),
+      overlayContainer = _useContext.overlayContainer;
+
   var children = props.children,
-      container = props.container,
+      _props$container = props.container,
+      container = _props$container === void 0 ? overlayContainer : _props$container,
       controlId = props.controlId,
       defaultOpen = props.defaultOpen,
       _props$trigger = props.trigger,
@@ -90,8 +95,8 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
   // In order to keep the overlay open, a timer is used to delay the closing.
 
 
-  var delayOpenTimer = useRef();
-  var delayCloseTimer = useRef();
+  var delayOpenTimer = useRef(null);
+  var delayCloseTimer = useRef(null);
   var delayOpen = isNil(delayOpenProp) ? delay : delayOpenProp;
   var delayClose = isNil(delayCloseProp) ? delay : delayCloseProp; // Whether the cursor is on the overlay
 
@@ -100,8 +105,13 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var isOnTrigger = useRef(false);
   useEffect(function () {
     return function () {
-      clearTimeout(delayOpenTimer.current);
-      clearTimeout(delayCloseTimer.current);
+      if (!isNil(delayOpenTimer.current)) {
+        clearTimeout(delayOpenTimer.current);
+      }
+
+      if (!isNil(delayCloseTimer.current)) {
+        clearTimeout(delayCloseTimer.current);
+      }
     };
   }, []);
   var handleOpen = useCallback(function (delay) {
@@ -207,8 +217,11 @@ var OverlayTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
     }
 
     delayCloseTimer.current = setTimeout(function () {
-      clearTimeout(delayCloseTimer.current);
-      delayCloseTimer.current = null;
+      if (!isNil(delayCloseTimer.current)) {
+        clearTimeout(delayCloseTimer.current);
+        delayCloseTimer.current = null;
+      }
+
       handleCloseWhenLeave();
     }, 200);
   }, [enterable, open, handleClose, handleCloseWhenLeave]);

package/esm/Overlay/Position.d.ts

@@ -2,13 +2,13 @@ import React from 'react';
 import { TypeAttributes } from '../@types/common';
 export interface PositionChildProps {
     className: string;
-    left: number;
-    top: number;
+    left?: number;
+    top?: number;
 }
 export interface PositionProps {
-    children?: (props: PositionChildProps, ref: any) => React.ReactElement;
+    children: (props: PositionChildProps, ref: any) => React.ReactElement;
     className?: string;
-    container?: HTMLElement | (() => HTMLElement);
+    container?: HTMLElement | (() => HTMLElement | null) | null;
     containerPadding?: number;
     placement?: TypeAttributes.Placement;
     preventOverflow?: boolean;

package/esm/Overlay/Position.js

@@ -16,13 +16,14 @@ import { useUpdateEffect } from '../utils';
 var usePosition = function usePosition(props, ref) {
   var _props$placement = props.placement,
       placement = _props$placement === void 0 ? 'right' : _props$placement,
-      preventOverflow = props.preventOverflow,
+      _props$preventOverflo = props.preventOverflow,
+      preventOverflow = _props$preventOverflo === void 0 ? false : _props$preventOverflo,
       _props$containerPaddi = props.containerPadding,
       containerPadding = _props$containerPaddi === void 0 ? 0 : _props$containerPaddi,
       container = props.container,
       triggerTarget = props.triggerTarget;
-  var containerRef = useRef();
-  var lastTargetRef = useRef();
+  var containerRef = useRef(null);
+  var lastTargetRef = useRef(null);
   var overlayResizeObserver = useRef();
   var defaultPosition = {
     positionLeft: 0,
@@ -68,8 +69,9 @@ var usePosition = function usePosition(props, ref) {
       return;
     }
 
-    var overlay = getDOMNode(ref.current);
-    var containerElement = getContainer(typeof container === 'function' ? container() : container, ownerDocument(ref.current).body);
+    var overlay = getDOMNode(ref.current); // fixme dom-lib getContainer incorrect type
+
+    var containerElement = getContainer(typeof container === 'function' ? container() : container !== null && container !== void 0 ? container : null, ownerDocument(ref.current).body);
     var posi = utils.calcOverlayPosition(overlay, targetElement, containerElement);
 
     if (forceUpdateDOM && overlay) {
@@ -77,7 +79,11 @@ var usePosition = function usePosition(props, ref) {
 
       var preClassName = overlay === null || overlay === void 0 ? void 0 : (_overlay$className = overlay.className) === null || _overlay$className === void 0 ? void 0 : (_overlay$className$ma = _overlay$className.match(/(placement-\S+)/)) === null || _overlay$className$ma === void 0 ? void 0 : _overlay$className$ma[0];
       removeClass(overlay, preClassName);
-      addClass(overlay, posi.positionClassName);
+
+      if (posi.positionClassName) {
+        addClass(overlay, posi.positionClassName);
+      }
+
       addStyle(overlay, {
         left: posi.positionLeft + "px",
         top: posi.positionTop + "px"
@@ -134,7 +140,7 @@ var usePosition = function usePosition(props, ref) {
 var Position = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var children = props.children,
       className = props.className;
-  var childRef = React.useRef();
+  var childRef = React.useRef(null);
 
   var _usePosition = usePosition(props, childRef),
       position = _usePosition[0],
@@ -171,7 +177,7 @@ var Position = /*#__PURE__*/React.forwardRef(function (props, ref) {
 Position.displayName = 'Position';
 Position.propTypes = {
   className: PropTypes.string,
-  children: PropTypes.func,
+  children: PropTypes.func.isRequired,
   container: PropTypes.oneOfType([PropTypes.func, PropTypes.any]),
   containerPadding: PropTypes.number,
   placement: PropTypes.any,

package/esm/Overlay/positionUtils.d.ts

@@ -29,7 +29,7 @@ declare const _default: (props: UtilProps) => {
         left: number;
         height: number;
         width: number;
-    };
+    } | null;
     calcAutoPlacement(targetOffset: any, container: any, overlay: any): any;
     calcOverlayPosition(overlayNode: any, target: any, container: any): PositionType;
 };

package/esm/Overlay/positionUtils.js

@@ -29,10 +29,10 @@ function getContainerDimensions(containerNode) {
     scrollY = scrollTop(ownerDocument(containerNode).documentElement) || scrollTop(containerNode);
     scrollX = scrollLeft(ownerDocument(containerNode).documentElement) || scrollLeft(containerNode);
   } else {
-    var _getOffset = getOffset(containerNode);
+    var _ref = getOffset(containerNode);
 
-    width = _getOffset.width;
-    height = _getOffset.height;
+    width = _ref.width;
+    height = _ref.height;
     scrollY = scrollTop(containerNode);
     scrollX = scrollLeft(containerNode);
   }
@@ -197,9 +197,9 @@ export default (function (props) {
     calcOverlayPosition: function calcOverlayPosition(overlayNode, target, container) {
       var childOffset = this.getPosition(target, container);
 
-      var _getOffset2 = getOffset(overlayNode),
-          overlayHeight = _getOffset2.height,
-          overlayWidth = _getOffset2.width;
+      var _ref2 = getOffset(overlayNode),
+          overlayHeight = _ref2.height,
+          overlayWidth = _ref2.width;
 
       var top = childOffset.top,
           left = childOffset.left;