rsuite 5.17.1 → 5.18.0-beta.3

package/esm/TreePicker/TreePicker.js

@@ -7,7 +7,7 @@ import _omit from "lodash/omit";
 import _pick from "lodash/pick";
 import React, { useState, useRef, useEffect, useCallback, useContext } from 'react';
 import PropTypes from 'prop-types';
-import { List, AutoSizer } from '../Picker/VirtualizedList';
+import { List, AutoSizer } from '../Windowing';
 import TreeNode from './TreeNode';
 import { getTreeNodeIndent } from '../utils/treeUtils';
 import { createChainedFunction, useClassNames, useCustom, useControlled, TREE_NODE_DROP_POSITION, KEY_VALUES, mergeRefs, shallowEqual } from '../utils';
@@ -17,6 +17,11 @@ import TreeContext from '../Tree/TreeContext'; // default value for virtualized
 
 export var maxTreeHeight = 320;
 var emptyArray = [];
+
+var itemSize = function itemSize() {
+  return 36;
+};
+
 var TreePicker = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _props$as = props.as,
       Component = _props$as === void 0 ? 'div' : _props$as,
@@ -574,34 +579,31 @@ var TreePicker = /*#__PURE__*/React.forwardRef(function (props, ref) {
     }, nodeProps));
   };
 
-  var renderVirtualListNode = function renderVirtualListNode(nodes) {
-    return function (_ref3) {
-      var key = _ref3.key,
-          index = _ref3.index,
-          style = _ref3.style;
-      var node = nodes[index];
-      var layer = node.layer,
-          visible = node.visible;
-      var expand = getExpandWhenSearching(searchKeywordState, expandItemValues.includes(node[valueKey]));
-
-      if (!node.visible) {
-        return null;
-      }
+  var renderVirtualListNode = function renderVirtualListNode(_ref3) {
+    var index = _ref3.index,
+        style = _ref3.style,
+        data = _ref3.data;
+    var node = data[index];
+    var layer = node.layer,
+        visible = node.visible;
+    var expand = getExpandWhenSearching(searchKeywordState, expandItemValues.includes(node[valueKey]));
 
-      var nodeProps = _extends({}, getTreeNodeProps(_extends({}, node, {
-        expand: expand
-      }), layer), {
-        style: style,
-        hasChildren: node.hasChildren
-      });
+    if (!node.visible) {
+      return null;
+    }
 
-      return visible && /*#__PURE__*/React.createElement(TreeNode, _extends({
-        ref: function ref(_ref4) {
-          return saveTreeNodeRef(_ref4, node.refKey);
-        },
-        key: key
-      }, nodeProps));
-    };
+    var nodeProps = _extends({}, getTreeNodeProps(_extends({}, node, {
+      expand: expand
+    }), layer), {
+      style: style,
+      hasChildren: node.hasChildren
+    });
+
+    return visible && /*#__PURE__*/React.createElement(TreeNode, _extends({
+      ref: function ref(_ref4) {
+        return saveTreeNodeRef(_ref4, node.refKey);
+      }
+    }, nodeProps));
   };
 
   var renderTree = function renderTree() {
@@ -634,11 +636,10 @@ var TreePicker = /*#__PURE__*/React.forwardRef(function (props, ref) {
         ref: listRef,
         width: width,
         height: height,
-        rowHeight: 36,
-        rowCount: formattedNodes.length,
-        rowRenderer: renderVirtualListNode(formattedNodes),
-        scrollToAlignment: "center"
-      }, listProps));
+        itemSize: itemSize,
+        itemCount: formattedNodes.length,
+        itemData: formattedNodes
+      }, listProps), renderVirtualListNode);
     }) : formattedNodes));
   };
 

package/esm/TreePicker/test/TreePicker.test.js

@@ -7,4 +7,18 @@ React.createElement(TreePicker, {
     return /*#__PURE__*/React.createElement("div", null);
   },
   data: []
+});
+
+/*#__PURE__*/
+React.createElement(TreePicker, {
+  data: [],
+  listProps: {
+    itemSize: 30,
+    onItemsRendered: function onItemsRendered() {
+      console.log('onItemsRendered');
+    },
+    onScroll: function onScroll() {
+      console.log('onScroll');
+    }
+  }
 });

package/esm/Uploader/UploadTrigger.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { UploaderLocale } from '../locales';
-export interface UploadTriggerProps {
+import { ButtonProps } from '../Button';
+export interface UploadTriggerProps extends ButtonProps {
     as?: React.ElementType;
     name?: string;
     multiple?: boolean;

package/esm/Uploader/UploadTrigger.js

@@ -1,16 +1,9 @@
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import React, { useCallback, useRef, useState, useImperativeHandle } from 'react';
 import PropTypes from 'prop-types';
-import Ripple from '../Ripple';
 import { isIE11, useClassNames } from '../utils';
-
-var Button = function Button(props) {
-  return /*#__PURE__*/React.createElement("button", _extends({}, props, {
-    type: "button"
-  }));
-};
-
+import Button from '../Button';
 var UploadTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _props$as = props.as,
       Component = _props$as === void 0 ? Button : _props$as,
@@ -126,7 +119,7 @@ var UploadTrigger = /*#__PURE__*/React.forwardRef(function (props, ref) {
     buttonProps.onDrop = handleDrop;
   }
 
-  var trigger = children ? /*#__PURE__*/React.cloneElement(React.Children.only(children), buttonProps) : /*#__PURE__*/React.createElement(Component, buttonProps, locale === null || locale === void 0 ? void 0 : locale.upload, /*#__PURE__*/React.createElement(Ripple, null));
+  var trigger = children ? /*#__PURE__*/React.cloneElement(React.Children.only(children), buttonProps) : /*#__PURE__*/React.createElement(Component, buttonProps, locale === null || locale === void 0 ? void 0 : locale.upload);
   return /*#__PURE__*/React.createElement("div", {
     ref: rootRef,
     className: classes

package/esm/Uploader/Uploader.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { UploadTriggerProps } from './UploadTrigger';
 import { WithAsProps } from '../@types/common';
 import { UploaderLocale } from '../locales';
 export interface FileType {
@@ -19,7 +20,7 @@ export interface UploaderInstance {
     root: HTMLElement;
     start: (file?: FileType) => void;
 }
-export interface UploaderProps extends WithAsProps {
+export interface UploaderProps extends WithAsProps, Omit<UploadTriggerProps, 'onChange' | 'onError' | 'onProgress'> {
     /** Uploading URL */
     action: string;
     /** File types that can be accepted. See input accept Attribute */

package/esm/Uploader/test/Uploader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/Uploader/test/Uploader.test.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import Uploader from '../Uploader';
+
+/*#__PURE__*/
+React.createElement(Uploader, {
+  appearance: "primary",
+  action: "#"
+});
+
+/*#__PURE__*/
+React.createElement(Uploader, {
+  appearance: "primary",
+  color: "orange",
+  action: "#"
+});
+
+/*#__PURE__*/
+React.createElement(Uploader, {
+  size: "lg",
+  action: "#"
+});

package/esm/Whisper/Whisper.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
-import { OverlayTriggerInstance } from '../Overlay/OverlayTrigger';
+import { OverlayTriggerHandle } from '../Overlay/OverlayTrigger';
 import { OverlayTriggerProps } from '../Overlay/OverlayTrigger';
 export declare type WhisperProps = OverlayTriggerProps;
-export declare type WhisperInstance = OverlayTriggerInstance;
-declare const Whisper: React.ForwardRefExoticComponent<OverlayTriggerProps & React.RefAttributes<OverlayTriggerInstance>>;
+export declare type WhisperInstance = OverlayTriggerHandle;
+declare const Whisper: React.ForwardRefExoticComponent<OverlayTriggerProps & React.RefAttributes<OverlayTriggerHandle>>;
 export default Whisper;

package/esm/Windowing/AutoSizer.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export interface Size {
+    height: number;
+    width: number;
+}
+export interface AutoSizerProps {
+    /** Function responsible for rendering children. */
+    children: (size: Size) => React.ReactNode;
+    /** Optional custom CSS class name to attach to root AutoSizer element.    */
+    className?: string | undefined;
+    /** Default height to use for initial render; useful for SSR */
+    defaultHeight?: number | undefined;
+    /** Default width to use for initial render; useful for SSR */
+    defaultWidth?: number | undefined;
+    /** Disable dynamic :height property */
+    disableHeight?: boolean | undefined;
+    /** Disable dynamic :width property */
+    disableWidth?: boolean | undefined;
+    /** Optional inline style */
+    style?: React.CSSProperties | undefined;
+    /** Callback to be invoked on-resize */
+    onResize?: ((size: Size) => void) | undefined;
+}
+declare const AutoSizer: React.ForwardRefExoticComponent<AutoSizerProps & React.RefAttributes<HTMLDivElement>>;
+export default AutoSizer;

package/esm/Windowing/AutoSizer.js

@@ -0,0 +1,92 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React, { useState, useRef } from 'react';
+import { useCallback } from 'react';
+import getStyle from 'dom-lib/getStyle';
+import { mergeRefs, useElementResize, useMount } from '../utils';
+var AutoSizer = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var children = props.children,
+      className = props.className,
+      disableHeight = props.disableHeight,
+      disableWidth = props.disableWidth,
+      defaultHeight = props.defaultHeight,
+      defaultWidth = props.defaultWidth,
+      style = props.style,
+      onResize = props.onResize,
+      rest = _objectWithoutPropertiesLoose(props, ["children", "className", "disableHeight", "disableWidth", "defaultHeight", "defaultWidth", "style", "onResize"]);
+
+  var _useState = useState(defaultHeight || 0),
+      height = _useState[0],
+      setHeight = _useState[1];
+
+  var _useState2 = useState(defaultWidth || 0),
+      width = _useState2[0],
+      setWidth = _useState2[1];
+
+  var rootRef = useRef(null);
+  var getParentNode = useCallback(function () {
+    var _rootRef$current;
+
+    if ((_rootRef$current = rootRef.current) !== null && _rootRef$current !== void 0 && _rootRef$current.parentNode && rootRef.current.parentNode.ownerDocument && rootRef.current.parentNode.ownerDocument.defaultView && rootRef.current.parentNode instanceof rootRef.current.parentNode.ownerDocument.defaultView.HTMLElement) {
+      return rootRef.current.parentNode;
+    }
+
+    return null;
+  }, []);
+  var handleResize = useCallback(function () {
+    var parentNode = getParentNode();
+
+    if (parentNode) {
+      var offsetHeight = parentNode.offsetHeight || 0;
+      var offsetWidth = parentNode.offsetWidth || 0;
+
+      var _style = getStyle(parentNode);
+
+      var paddingLeft = parseInt(_style.paddingLeft, 10) || 0;
+      var paddingRight = parseInt(_style.paddingRight, 10) || 0;
+      var paddingTop = parseInt(_style.paddingTop, 10) || 0;
+      var paddingBottom = parseInt(_style.paddingBottom, 10) || 0;
+      var newHeight = offsetHeight - paddingTop - paddingBottom;
+      var newWidth = offsetWidth - paddingLeft - paddingRight;
+
+      if (!disableHeight && height !== newHeight || !disableWidth && width !== newWidth) {
+        setHeight(offsetHeight - paddingTop - paddingBottom);
+        setWidth(offsetWidth - paddingLeft - paddingRight);
+        onResize === null || onResize === void 0 ? void 0 : onResize({
+          height: offsetHeight,
+          width: offsetWidth
+        });
+      }
+    }
+  }, [disableHeight, disableWidth, getParentNode, height, onResize, width]);
+  useMount(function () {
+    if (getParentNode()) {
+      handleResize();
+    }
+  });
+  useElementResize(getParentNode, handleResize);
+  var outerStyle = {
+    overflow: 'visible'
+  };
+  var childParams = {
+    width: 0,
+    height: 0
+  };
+
+  if (!disableHeight) {
+    outerStyle.height = 0;
+    childParams.height = height;
+  }
+
+  if (!disableWidth) {
+    outerStyle.width = 0;
+    childParams.width = width;
+  }
+
+  return /*#__PURE__*/React.createElement("div", _extends({
+    className: className,
+    ref: mergeRefs(rootRef, ref),
+    style: _extends({}, outerStyle, style)
+  }, rest), children(childParams));
+});
+export default AutoSizer;

package/esm/Windowing/List.d.ts

@@ -0,0 +1,45 @@
+import { VariableSizeList, ListItemKeySelector, ListOnScrollProps, ListOnItemsRenderedProps } from 'react-window';
+import { WithAsProps, RsRefForwardingComponent } from '../@types/common';
+export interface ListProps<T = any> extends WithAsProps {
+    /**
+     * @deprecated use itemSize instead
+     * Either a fixed row height (number) or a function that returns the height of a row given its index: ({ index: number }): number
+     */
+    rowHeight?: number | (({ index: number }: {
+        index: any;
+    }) => number);
+    /**
+     * Size of a item in the direction being windowed.
+     */
+    itemSize: number | ((index: number) => number);
+    /**
+     * Scroll offset for initial render.
+     */
+    initialScrollOffset?: number;
+    /**
+     * By default, lists will use an item's index as its key. This is okay if:
+     *
+     * - Your collections of items is never sorted or modified
+     * - Your item renderer is not stateful and does not extend PureComponent
+     *
+     * If your list does not satisfy the above constraints, use the itemKey property to specify your own keys for items
+     */
+    itemKey?: ListItemKeySelector<T>;
+    /**
+     * Called when the items rendered by the list change.
+     */
+    onItemsRendered?: (props: ListOnItemsRenderedProps) => void;
+    /**
+     * Called when the list scroll positions changes, as a result of user scrolling or scroll-to method calls.
+     */
+    onScroll?: (props: ListOnScrollProps) => void;
+}
+export interface ListHandle extends Partial<VariableSizeList> {
+    /**
+     * @deprecated use scrollToItem instead
+     * Ensure row is visible. This method can be used to safely scroll back to a cell that a user has scrolled away from even if it was previously scrolled to.
+     */
+    scrollToRow?: (index: number) => void;
+}
+declare const List: RsRefForwardingComponent<'div', ListProps>;
+export default List;

package/esm/Windowing/List.js

@@ -0,0 +1,58 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React, { useRef, useImperativeHandle, useCallback } from 'react';
+import { VariableSizeList } from 'react-window';
+import { useCustom } from '../utils';
+var List = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var rowHeight = props.rowHeight,
+      _props$as = props.as,
+      Component = _props$as === void 0 ? VariableSizeList : _props$as,
+      rest = _objectWithoutPropertiesLoose(props, ["rowHeight", "as"]);
+
+  var listRef = useRef(null);
+
+  var _useCustom = useCustom(),
+      rtl = _useCustom.rtl;
+
+  useImperativeHandle(ref, function () {
+    return {
+      resetAfterIndex: function resetAfterIndex(index, shouldForceUpdate) {
+        var _listRef$current, _listRef$current$rese;
+
+        (_listRef$current = listRef.current) === null || _listRef$current === void 0 ? void 0 : (_listRef$current$rese = _listRef$current.resetAfterIndex) === null || _listRef$current$rese === void 0 ? void 0 : _listRef$current$rese.call(_listRef$current, index, shouldForceUpdate);
+      },
+      scrollTo: function scrollTo(scrollOffset) {
+        var _listRef$current2, _listRef$current2$scr;
+
+        (_listRef$current2 = listRef.current) === null || _listRef$current2 === void 0 ? void 0 : (_listRef$current2$scr = _listRef$current2.scrollTo) === null || _listRef$current2$scr === void 0 ? void 0 : _listRef$current2$scr.call(_listRef$current2, scrollOffset);
+      },
+      scrollToItem: function scrollToItem(index, align) {
+        var _listRef$current3, _listRef$current3$scr;
+
+        (_listRef$current3 = listRef.current) === null || _listRef$current3 === void 0 ? void 0 : (_listRef$current3$scr = _listRef$current3.scrollToItem) === null || _listRef$current3$scr === void 0 ? void 0 : _listRef$current3$scr.call(_listRef$current3, index, align);
+      },
+      scrollToRow: function scrollToRow(index) {
+        var _listRef$current4, _listRef$current4$scr;
+
+        (_listRef$current4 = listRef.current) === null || _listRef$current4 === void 0 ? void 0 : (_listRef$current4$scr = _listRef$current4.scrollToItem) === null || _listRef$current4$scr === void 0 ? void 0 : _listRef$current4$scr.call(_listRef$current4, index);
+      }
+    };
+  });
+  var setRowHeight = useCallback(function (index) {
+    return typeof rowHeight === 'function' ? rowHeight({
+      index: index
+    }) : rowHeight || 0;
+  }, [rowHeight]);
+
+  var compatibleProps = _extends({}, rest);
+
+  if (rowHeight) {
+    compatibleProps.itemSize = Component === VariableSizeList ? setRowHeight : rowHeight;
+  }
+
+  return /*#__PURE__*/React.createElement(Component, _extends({
+    ref: listRef,
+    direction: rtl ? 'rtl' : 'ltr'
+  }, compatibleProps));
+});
+export default List;

package/esm/Windowing/index.d.ts

@@ -0,0 +1,5 @@
+export { default as AutoSizer } from './AutoSizer';
+export { default as List } from './List';
+export { FixedSizeList, VariableSizeList } from 'react-window';
+export type { ListChildComponentProps } from 'react-window';
+export type { ListProps, ListHandle } from './List';

package/esm/Windowing/index.js

@@ -0,0 +1,3 @@
+export { default as AutoSizer } from './AutoSizer';
+export { default as List } from './List';
+export { FixedSizeList, VariableSizeList } from 'react-window';

package/esm/index.d.ts

@@ -155,3 +155,4 @@ export type { AffixProps } from './Affix';
 export { default as CustomProvider } from './CustomProvider';
 export type { CustomProviderProps } from './CustomProvider';
 export type { Locale, CalendarLocale, PlaintextLocale, PaginationLocale, TableLocale, DatePickerLocale, DateRangePickerLocale, PickerLocale, InputPickerLocale, UploaderLocale, BreadcrumbLocale, ToggleLocale } from './locales';
+export type { PickerHandle } from './Picker';

package/esm/toaster/ToastContainer.d.ts

@@ -7,6 +7,7 @@ export interface ToastContainerProps extends WithAsProps {
     placement?: PlacementType;
     /** Set the message to appear in the specified container */
     container?: HTMLElement | (() => HTMLElement);
+    callback?: (ref: React.RefObject<ToastContainerInstance>) => void;
 }
 export interface ToastContainerInstance {
     root: HTMLElement;
@@ -19,7 +20,7 @@ export interface NodeProps extends WithAsProps {
     onClose?: (event?: React.MouseEvent<HTMLDivElement>) => void;
 }
 interface ToastContainerComponent extends RsRefForwardingComponent<'div', ToastContainerProps> {
-    getInstance: (props: ToastContainerProps) => [React.RefObject<ToastContainerInstance>, () => void];
+    getInstance: (props: ToastContainerProps) => Promise<[React.RefObject<ToastContainerInstance>, () => void]>;
 }
 declare const ToastContainer: ToastContainerComponent;
 export default ToastContainer;

package/esm/toaster/ToastContainer.js

@@ -1,11 +1,10 @@
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _extends from "@babel/runtime/helpers/esm/extends";
 import React, { useState, useImperativeHandle, useRef, useCallback } from 'react';
-import { render, unmountComponentAtNode } from 'react-dom';
 import PropTypes from 'prop-types';
 import kebabCase from 'lodash/kebabCase';
 import Transition from '../Animation/Transition';
-import { useClassNames, guid, createChainedFunction } from '../utils';
+import { useClassNames, guid, createChainedFunction, render } from '../utils';
 export var toastPlacements = ['topCenter', 'bottomCenter', 'topStart', 'topEnd', 'bottomStart', 'bottomEnd'];
 
 var useMessages = function useMessages() {
@@ -22,13 +21,15 @@ var useMessages = function useMessages() {
   }, [messages]);
   var push = useCallback(function (message) {
     var key = guid();
-    setMessages([].concat(messages, [{
-      key: key,
-      visible: true,
-      node: message
-    }]));
+    setMessages(function (prevMessages) {
+      return [].concat(prevMessages, [{
+        key: key,
+        visible: true,
+        node: message
+      }]);
+    });
     return key;
-  }, [messages]);
+  }, []);
   var clear = useCallback(function () {
     // Set all existing messages to be invisible.
     setMessages(messages.map(function (msg) {
@@ -76,7 +77,8 @@ var ToastContainer = /*#__PURE__*/React.forwardRef(function (props, ref) {
       classPrefix = _props$classPrefix === void 0 ? 'toast-container' : _props$classPrefix,
       _props$placement = props.placement,
       placement = _props$placement === void 0 ? 'topCenter' : _props$placement,
-      rest = _objectWithoutPropertiesLoose(props, ["as", "className", "classPrefix", "placement"]);
+      callback = props.callback,
+      rest = _objectWithoutPropertiesLoose(props, ["as", "className", "classPrefix", "placement", "callback"]);
 
   var _useClassNames = useClassNames(classPrefix),
       withClassPrefix = _useClassNames.withClassPrefix,
@@ -125,7 +127,10 @@ var ToastContainer = /*#__PURE__*/React.forwardRef(function (props, ref) {
     });
   });
   return /*#__PURE__*/React.createElement(Component, _extends({}, rest, {
-    ref: rootRef,
+    ref: function ref(selfRef) {
+      rootRef.current = selfRef;
+      callback === null || callback === void 0 ? void 0 : callback(selfRef);
+    },
     className: classes
   }), elements);
 });
@@ -135,22 +140,18 @@ ToastContainer.getInstance = function (props) {
       rest = _objectWithoutPropertiesLoose(props, ["container"]);
 
   var containerRef = /*#__PURE__*/React.createRef();
-  var mountElement = document.createElement('div');
-  var containerElement = typeof container === 'function' ? container() : container; //  Parent is document.body or the existing dom element
-
-  var parentElement = containerElement || document.body; // Add the detached element to the parent
-
-  parentElement.appendChild(mountElement);
-
-  function destroy() {
-    unmountComponentAtNode(mountElement);
-    parentElement.removeChild(mountElement);
-  }
+  var containerElement = (typeof container === 'function' ? container() : container) || document.body;
+  return new Promise(function (resolve) {
+    var renderCallback = function renderCallback() {
+      resolve([containerRef, unmount]);
+    };
 
-  render( /*#__PURE__*/React.createElement(ToastContainer, _extends({}, rest, {
-    ref: containerRef
-  })), mountElement);
-  return [containerRef, destroy];
+    var _render = render( /*#__PURE__*/React.createElement(ToastContainer, _extends({}, rest, {
+      ref: containerRef,
+      callback: renderCallback
+    })), containerElement),
+        unmount = _render.unmount;
+  });
 };
 
 ToastContainer.displayName = 'ToastContainer';
@@ -158,6 +159,7 @@ ToastContainer.propTypes = {
   className: PropTypes.string,
   classPrefix: PropTypes.string,
   placement: PropTypes.elementType,
-  container: PropTypes.oneOfType([PropTypes.node, PropTypes.func])
+  container: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+  callback: PropTypes.func
 };
 export default ToastContainer;

package/esm/toaster/toaster.d.ts

@@ -7,7 +7,7 @@ export interface Toaster {
      * @param message
      * @param options
      */
-    push(message: React.ReactNode, options?: ToastContainerProps): string | undefined;
+    push(message: React.ReactNode, options?: ToastContainerProps): string | undefined | Promise<string | undefined>;
     /**
      * Remove a message by key
      * @param key