rsuite 5.0.0 → 5.1.0

package/esm/MaskedInput/createTextMaskInputElement.js

@@ -0,0 +1,212 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import isString from 'lodash/isString';
+import isNumber from 'lodash/isNumber';
+import adjustCaretPosition from './adjustCaretPosition';
+import conformToMask from './conformToMask';
+import { convertMaskToPlaceholder, processCaretTraps, defaultPlaceholderChar } from './utilities';
+var emptyString = '';
+var strNone = 'none';
+var strObject = 'object';
+var isAndroid = typeof navigator !== 'undefined' && /Android/i.test(navigator.userAgent);
+var defer = typeof requestAnimationFrame !== 'undefined' ? requestAnimationFrame : setTimeout;
+export default function createTextMaskInputElement(config) {
+  // Anything that we will need to keep between `update` calls, we will store in this `state` object.
+  var state = {
+    previousConformedValue: undefined,
+    previousPlaceholder: undefined
+  };
+  return {
+    state: state,
+    // `update` is called by framework components whenever they want to update the `value` of the input element.
+    // The caller can send a `rawValue` to be conformed and set on the input element. However, the default use-case
+    // is for this to be read from the `inputElement` directly.
+    update: function update(rawValue, _temp) {
+      var _pipeResults, _pipeResults2;
+
+      var _ref = _temp === void 0 ? config : _temp,
+          inputElement = _ref.inputElement,
+          providedMask = _ref.mask,
+          guide = _ref.guide,
+          pipe = _ref.pipe,
+          _ref$placeholderChar = _ref.placeholderChar,
+          placeholderChar = _ref$placeholderChar === void 0 ? defaultPlaceholderChar : _ref$placeholderChar,
+          _ref$keepCharPosition = _ref.keepCharPositions,
+          keepCharPositions = _ref$keepCharPosition === void 0 ? false : _ref$keepCharPosition,
+          _ref$showMask = _ref.showMask,
+          showMask = _ref$showMask === void 0 ? false : _ref$showMask;
+
+      // if `rawValue` is `undefined`, read from the `inputElement`
+      if (typeof rawValue === 'undefined') {
+        rawValue = inputElement.value;
+      } // If `rawValue` equals `state.previousConformedValue`, we don't need to change anything. So, we return.
+      // This check is here to handle controlled framework components that repeat the `update` call on every render.
+
+
+      if (rawValue === state.previousConformedValue) {
+        return;
+      } // Text Mask accepts masks that are a combination of a `mask` and a `pipe` that work together. If such a `mask` is
+      // passed, we destructure it below, so the rest of the code can work normally as if a separate `mask` and a `pipe`
+      // were passed.
+
+
+      if (typeof providedMask === strObject && providedMask.pipe !== undefined && providedMask.mask !== undefined) {
+        pipe = providedMask.pipe;
+        providedMask = providedMask.mask;
+      } // The `placeholder` is an essential piece of how Text Mask works. For a mask like `(111)`, the placeholder would
+      // be `(___)` if the `placeholderChar` is set to `_`.
+
+
+      var placeholder; // We don't know what the mask would be yet. If it is an array, we take it as is, but if it's a function, we will
+      // have to call that function to get the mask array.
+
+      var mask; // If the provided mask is an array, we can call `convertMaskToPlaceholder` here once and we'll always have the
+      // correct `placeholder`.
+
+      if (providedMask instanceof Array) {
+        placeholder = convertMaskToPlaceholder(providedMask, placeholderChar);
+      } // In framework components that support reactivity, it's possible to turn off masking by passing
+      // `false` for `mask` after initialization. See https://github.com/text-mask/text-mask/pull/359
+
+
+      if (providedMask === false) {
+        return;
+      } // We check the provided `rawValue` before moving further.
+      // If it's something we can't work with `getSafeRawValue` will throw.
+
+
+      var safeRawValue = getSafeRawValue(rawValue); // `selectionEnd` indicates to us where the caret position is after the user has typed into the input
+
+      var currentCaretPosition = inputElement.selectionEnd; // We need to know what the `previousConformedValue` and `previousPlaceholder` is from the previous `update` call
+
+      var previousConformedValue = state.previousConformedValue,
+          previousPlaceholder = state.previousPlaceholder;
+      var caretTrapIndexes; // If the `providedMask` is a function. We need to call it at every `update` to get the `mask` array.
+      // Then we also need to get the `placeholder`
+
+      if (typeof providedMask === 'function') {
+        mask = providedMask(safeRawValue, {
+          currentCaretPosition: currentCaretPosition,
+          previousConformedValue: previousConformedValue,
+          placeholderChar: placeholderChar
+        }); // disable masking if `mask` is `false`
+
+        if (mask === false) {
+          return;
+        } // mask functions can setup caret traps to have some control over how the caret moves. We need to process
+        // the mask for any caret traps. `processCaretTraps` will remove the caret traps from the mask and return
+        // the indexes of the caret traps.
+
+
+        var _processCaretTraps = processCaretTraps(mask),
+            maskWithoutCaretTraps = _processCaretTraps.maskWithoutCaretTraps,
+            indexes = _processCaretTraps.indexes;
+
+        mask = maskWithoutCaretTraps; // The processed mask is what we're interested in
+
+        caretTrapIndexes = indexes; // And we need to store these indexes because they're needed by `adjustCaretPosition`
+
+        placeholder = convertMaskToPlaceholder(mask, placeholderChar); // If the `providedMask` is not a function, we just use it as-is.
+      } else {
+        mask = providedMask;
+      } // The following object will be passed to `conformToMask` to determine how the `rawValue` will be conformed
+
+
+      var conformToMaskConfig = {
+        previousConformedValue: previousConformedValue,
+        guide: guide,
+        placeholderChar: placeholderChar,
+        pipe: pipe,
+        placeholder: placeholder,
+        currentCaretPosition: currentCaretPosition,
+        keepCharPositions: keepCharPositions
+      }; // `conformToMask` returns `conformedValue` as part of an object for future API flexibility
+
+      var _conformToMask = conformToMask(safeRawValue, mask, conformToMaskConfig),
+          conformedValue = _conformToMask.conformedValue; // The following few lines are to support the `pipe` feature.
+
+
+      var piped = typeof pipe === 'function';
+      var pipeResults = {}; // If `pipe` is a function, we call it.
+
+      if (piped) {
+        // `pipe` receives the `conformedValue` and the configurations with which `conformToMask` was called.
+        pipeResults = pipe(conformedValue, _extends({
+          rawValue: safeRawValue
+        }, conformToMaskConfig)); // `pipeResults` should be an object. But as a convenience, we allow the pipe author to just return `false` to
+        // indicate rejection. Or return just a string when there are no piped characters.
+        // If the `pipe` returns `false` or a string, the block below turns it into an object that the rest
+        // of the code can work with.
+
+        if (pipeResults === false) {
+          // If the `pipe` rejects `conformedValue`, we use the `previousConformedValue`, and set `rejected` to `true`.
+          pipeResults = {
+            value: previousConformedValue,
+            rejected: true
+          };
+        } else if (isString(pipeResults)) {
+          pipeResults = {
+            value: pipeResults
+          };
+        }
+      } // Before we proceed, we need to know which conformed value to use, the one returned by the pipe or the one
+      // returned by `conformToMask`.
+
+
+      var finalConformedValue = piped ? (_pipeResults = pipeResults) === null || _pipeResults === void 0 ? void 0 : _pipeResults.value : conformedValue; // After determining the conformed value, we will need to know where to set
+      // the caret position. `adjustCaretPosition` will tell us.
+
+      var adjustedCaretPosition = adjustCaretPosition({
+        previousConformedValue: previousConformedValue,
+        previousPlaceholder: previousPlaceholder,
+        conformedValue: finalConformedValue,
+        placeholder: placeholder,
+        rawValue: safeRawValue,
+        currentCaretPosition: currentCaretPosition,
+        placeholderChar: placeholderChar,
+        indexesOfPipedChars: (_pipeResults2 = pipeResults) === null || _pipeResults2 === void 0 ? void 0 : _pipeResults2.indexesOfPipedChars,
+        caretTrapIndexes: caretTrapIndexes
+      }); // Text Mask sets the input value to an empty string when the condition below is set. It provides a better UX.
+
+      var inputValueShouldBeEmpty = finalConformedValue === placeholder && adjustedCaretPosition === 0;
+      var emptyValue = showMask ? placeholder : emptyString;
+      var inputElementValue = inputValueShouldBeEmpty ? emptyValue : finalConformedValue;
+      state.previousConformedValue = inputElementValue; // store value for access for next time
+
+      state.previousPlaceholder = placeholder; // In some cases, this `update` method will be repeatedly called with a raw value that has already been conformed
+      // and set to `inputElement.value`. The below check guards against needlessly readjusting the input state.
+      // See https://github.com/text-mask/text-mask/issues/231
+
+      if (inputElement.value === inputElementValue) {
+        return;
+      }
+
+      inputElement.value = inputElementValue; // set the input value
+
+      safeSetSelection(inputElement, adjustedCaretPosition); // adjust caret position
+    }
+  };
+}
+
+function safeSetSelection(element, selectionPosition) {
+  if (document.activeElement === element) {
+    if (isAndroid) {
+      defer(function () {
+        return element.setSelectionRange(selectionPosition, selectionPosition, strNone);
+      }, 0);
+    } else {
+      element.setSelectionRange(selectionPosition, selectionPosition, strNone);
+    }
+  }
+}
+
+function getSafeRawValue(inputValue) {
+  if (isString(inputValue)) {
+    return inputValue;
+  } else if (isNumber(inputValue)) {
+    return String(inputValue);
+  } else if (inputValue === undefined || inputValue === null) {
+    return emptyString;
+  } else {
+    throw new Error("The 'value' provided to Text Mask needs to be a string or a number. The value received was:\n\n " + JSON.stringify(inputValue));
+  }
+}

package/esm/MaskedInput/index.d.ts

@@ -0,0 +1,3 @@
+import MaskedInput from './MaskedInput';
+export type { MaskedInputProps } from './MaskedInput';
+export default MaskedInput;

package/esm/MaskedInput/index.js

@@ -0,0 +1,2 @@
+import MaskedInput from './MaskedInput';
+export default MaskedInput;

package/esm/MaskedInput/types.d.ts

@@ -0,0 +1,10 @@
+export interface ConfigType {
+    guide?: boolean;
+    previousConformedValue?: string;
+    placeholderChar?: string;
+    placeholder?: string;
+    currentCaretPosition?: number;
+    keepCharPositions?: boolean;
+}
+export declare type MaskType = string | (string | RegExp)[];
+export declare type MaskFunctionType = (rawValue: string, config: ConfigType) => MaskType;

package/esm/MaskedInput/utilities.d.ts

@@ -0,0 +1,7 @@
+import { MaskType, MaskFunctionType } from './types';
+export declare const defaultPlaceholderChar = "_";
+export declare function convertMaskToPlaceholder(mask?: MaskType | MaskFunctionType, placeholderChar?: string): string;
+export declare function processCaretTraps(mask: any): {
+    maskWithoutCaretTraps: any;
+    indexes: any[];
+};

package/esm/MaskedInput/utilities.js

@@ -0,0 +1,38 @@
+var emptyArray = [];
+var strCaretTrap = '[]';
+export var defaultPlaceholderChar = '_';
+export function convertMaskToPlaceholder(mask, placeholderChar) {
+  if (mask === void 0) {
+    mask = emptyArray;
+  }
+
+  if (placeholderChar === void 0) {
+    placeholderChar = defaultPlaceholderChar;
+  }
+
+  if (!Array.isArray(mask)) {
+    throw new Error('Text-mask:convertMaskToPlaceholder; The mask property must be an array.');
+  }
+
+  if (mask.indexOf(placeholderChar) !== -1) {
+    throw new Error('Placeholder character must not be used as part of the mask. Please specify a character ' + 'that is not present in your mask as your placeholder character.\n\n' + ("The placeholder character that was received is: " + JSON.stringify(placeholderChar) + "\n\n") + ("The mask that was received is: " + JSON.stringify(mask)));
+  }
+
+  return mask.map(function (char) {
+    return char instanceof RegExp ? placeholderChar : char;
+  }).join('');
+}
+export function processCaretTraps(mask) {
+  var indexes = [];
+  var indexOfCaretTrap;
+
+  while (indexOfCaretTrap = mask.indexOf(strCaretTrap), indexOfCaretTrap !== -1) {
+    indexes.push(indexOfCaretTrap);
+    mask.splice(indexOfCaretTrap, 1);
+  }
+
+  return {
+    maskWithoutCaretTraps: mask,
+    indexes: indexes
+  };
+}

package/esm/Menu/Menu.d.ts

@@ -29,7 +29,6 @@ export interface MenuHandle {
 declare function Menu(props: MenuProps & React.HTMLAttributes<HTMLUListElement>): React.ReactElement<React.HTMLAttributes<HTMLDivElement>, string | React.JSXElementConstructor<any>>;
 declare namespace Menu {
     var displayName: string;
-    var defaultProps: Partial<MenuProps>;
     var propTypes: {
         children: PropTypes.Validator<(...args: any[]) => any>;
     };

package/esm/Menu/Menu.js

@@ -9,9 +9,7 @@ import useFocus from '../utils/useFocus';
 import useClickOutside from '../utils/useClickOutside';
 import { isFocusLeaving } from '../utils/events';
 import { isFocusableElement } from '../utils/dom';
-var defaultProps = {
-  openMenuOn: ['click']
-};
+var defaultOpenMenuOn = ['click'];
 /**
  * Headless ARIA `menu`
  */
@@ -21,7 +19,8 @@ function Menu(props) {
 
   var disabled = props.disabled,
       children = props.children,
-      openMenuOn = props.openMenuOn,
+      _props$openMenuOn = props.openMenuOn,
+      openMenuOn = _props$openMenuOn === void 0 ? defaultOpenMenuOn : _props$openMenuOn,
       menuButtonText = props.menuButtonText,
       renderMenuButton = props.renderMenuButton,
       renderMenuPopup = props.renderMenuPopup,
@@ -368,7 +367,6 @@ function Menu(props) {
 }
 
 Menu.displayName = 'Menu';
-Menu.defaultProps = defaultProps;
 Menu.propTypes = {
   children: PropTypes.func.isRequired
 };

package/esm/Message/Message.js

@@ -8,24 +8,22 @@ import React, { useState } from 'react';
 import PropTypes from 'prop-types';
 import { useClassNames, useTimeout, MESSAGE_STATUS_ICONS, STATUS } from '../utils';
 import CloseButton from '../CloseButton';
-var defaultProps = {
-  as: 'div',
-  classPrefix: 'message',
-  type: 'info',
-  duration: 2000
-};
 var Message = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _withClassPrefix;
 
-  var Component = props.as,
+  var _props$as = props.as,
+      Component = _props$as === void 0 ? 'div' : _props$as,
       className = props.className,
-      classPrefix = props.classPrefix,
+      _props$classPrefix = props.classPrefix,
+      classPrefix = _props$classPrefix === void 0 ? 'message' : _props$classPrefix,
       children = props.children,
       closable = props.closable,
-      duration = props.duration,
+      _props$duration = props.duration,
+      duration = _props$duration === void 0 ? 2000 : _props$duration,
       full = props.full,
       header = props.header,
-      type = props.type,
+      _props$type = props.type,
+      type = _props$type === void 0 ? 'info' : _props$type,
       showIcon = props.showIcon,
       onClose = props.onClose,
       rest = _objectWithoutPropertiesLoose(props, ["as", "className", "classPrefix", "children", "closable", "duration", "full", "header", "type", "showIcon", "onClose"]);
@@ -80,7 +78,6 @@ var Message = /*#__PURE__*/React.forwardRef(function (props, ref) {
   }, children))));
 });
 Message.displayName = 'Message';
-Message.defaultProps = defaultProps;
 Message.propTypes = {
   type: PropTypes.oneOf(STATUS),
   className: PropTypes.string,

package/esm/Modal/Modal.d.ts

@@ -6,7 +6,7 @@ import ModalHeader from './ModalHeader';
 import ModalTitle from './ModalTitle';
 import ModalFooter from './ModalFooter';
 import { TypeAttributes, RsRefForwardingComponent } from '../@types/common';
-export interface ModalProps extends BaseModalProps {
+export interface ModalProps extends BaseModalProps, Pick<React.HTMLAttributes<HTMLElement>, 'role' | 'id' | 'aria-labelledby' | 'aria-describedby'> {
     /** A modal can have different sizes */
     size?: TypeAttributes.Size;
     /** Set the duration of the animation */
@@ -26,15 +26,6 @@ export interface ModalProps extends BaseModalProps {
     /** Render Modal as Drawer */
     drawer?: boolean;
 }
-export interface ModalContextProps {
-    /** Pass the close event callback to the header close button. */
-    onModalClose: (event: React.MouseEvent<Element, MouseEvent>) => void;
-    /** Pass the latest style to body. */
-    getBodyStyles?: () => React.CSSProperties;
-    /** Whether this Modal is a Drawer */
-    isDrawer: boolean;
-}
-export declare const ModalContext: React.Context<ModalContextProps>;
 interface ModalComponent extends RsRefForwardingComponent<'div', ModalProps> {
     Body: typeof ModalBody;
     Header: typeof ModalHeader;

package/esm/Modal/Modal.js

@@ -11,44 +11,48 @@ import BaseModal, { modalPropTypes } from '../Overlay/Modal';
 import Bounce from '../Animation/Bounce';
 import { useClassNames, mergeRefs, SIZE } from '../utils';
 import ModalDialog, { modalDialogPropTypes } from './ModalDialog';
+import { ModalContext } from './ModalContext';
 import ModalBody from './ModalBody';
 import ModalHeader from './ModalHeader';
 import ModalTitle from './ModalTitle';
 import ModalFooter from './ModalFooter';
 import helper from '../DOMHelper';
 import { useBodyStyles } from './utils';
-var defaultProps = {
-  classPrefix: 'modal',
-  size: 'sm',
-  animation: Bounce,
-  animationTimeout: 300,
-  dialogAs: ModalDialog,
-  backdrop: true,
-  overflow: true
-};
-export var ModalContext = /*#__PURE__*/React.createContext(null);
+import useUniqueId from '../utils/useUniqueId';
 var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var className = props.className,
       children = props.children,
-      classPrefix = props.classPrefix,
+      _props$classPrefix = props.classPrefix,
+      classPrefix = _props$classPrefix === void 0 ? 'modal' : _props$classPrefix,
       dialogClassName = props.dialogClassName,
       backdropClassName = props.backdropClassName,
-      backdrop = props.backdrop,
+      _props$backdrop = props.backdrop,
+      backdrop = _props$backdrop === void 0 ? true : _props$backdrop,
       dialogStyle = props.dialogStyle,
-      animation = props.animation,
+      _props$animation = props.animation,
+      animation = _props$animation === void 0 ? Bounce : _props$animation,
       open = props.open,
-      size = props.size,
+      _props$size = props.size,
+      size = _props$size === void 0 ? 'sm' : _props$size,
       full = props.full,
-      Dialog = props.dialogAs,
+      _props$dialogAs = props.dialogAs,
+      Dialog = _props$dialogAs === void 0 ? ModalDialog : _props$dialogAs,
       animationProps = props.animationProps,
-      animationTimeout = props.animationTimeout,
-      overflow = props.overflow,
+      _props$animationTimeo = props.animationTimeout,
+      animationTimeout = _props$animationTimeo === void 0 ? 300 : _props$animationTimeo,
+      _props$overflow = props.overflow,
+      overflow = _props$overflow === void 0 ? true : _props$overflow,
       drawer = props.drawer,
       onClose = props.onClose,
       onEntered = props.onEntered,
       onEntering = props.onEntering,
       onExited = props.onExited,
-      rest = _objectWithoutPropertiesLoose(props, ["className", "children", "classPrefix", "dialogClassName", "backdropClassName", "backdrop", "dialogStyle", "animation", "open", "size", "full", "dialogAs", "animationProps", "animationTimeout", "overflow", "drawer", "onClose", "onEntered", "onEntering", "onExited"]);
+      _props$role = props.role,
+      role = _props$role === void 0 ? 'dialog' : _props$role,
+      idProp = props.id,
+      ariaLabelledby = props['aria-labelledby'],
+      ariaDescribedby = props['aria-describedby'],
+      rest = _objectWithoutPropertiesLoose(props, ["className", "children", "classPrefix", "dialogClassName", "backdropClassName", "backdrop", "dialogStyle", "animation", "open", "size", "full", "dialogAs", "animationProps", "animationTimeout", "overflow", "drawer", "onClose", "onEntered", "onEntering", "onExited", "role", "id", "aria-labelledby", "aria-describedby"]);
 
   var inClass = {
     in: open && !animation
@@ -73,15 +77,17 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
       onChangeBodyStyles = _useBodyStyles[1],
       onDestroyEvents = _useBodyStyles[2];
 
+  var dialogId = useUniqueId('dialog-', idProp);
   var modalContextValue = useMemo(function () {
     return {
+      dialogId: dialogId,
       onModalClose: onClose,
       getBodyStyles: function getBodyStyles() {
         return bodyStyles;
       },
       isDrawer: drawer
     };
-  }, [onClose, bodyStyles, drawer]);
+  }, [dialogId, onClose, bodyStyles, drawer]);
 
   var _useState = useState(false),
       shake = _useState[0],
@@ -141,7 +147,12 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
     var transitionClassName = transitionProps.className,
         transitionRest = _objectWithoutPropertiesLoose(transitionProps, ["className"]);
 
-    return /*#__PURE__*/React.createElement(Dialog, _extends({}, transitionRest, pick(rest, Object.keys(modalDialogPropTypes)), {
+    return /*#__PURE__*/React.createElement(Dialog, _extends({
+      role: role,
+      id: dialogId,
+      "aria-labelledby": ariaLabelledby !== null && ariaLabelledby !== void 0 ? ariaLabelledby : dialogId + "-title",
+      "aria-describedby": ariaDescribedby
+    }, transitionRest, pick(rest, Object.keys(modalDialogPropTypes)), {
       ref: mergeRefs(dialogRef, transitionRef),
       classPrefix: classPrefix,
       className: merge(classes, transitionClassName, prefix({
@@ -158,7 +169,6 @@ Modal.Title = ModalTitle;
 Modal.Footer = ModalFooter;
 Modal.Dialog = ModalDialog;
 Modal.displayName = 'Modal';
-Modal.defaultProps = defaultProps;
 Modal.propTypes = _extends({}, modalPropTypes, {
   animation: PropTypes.any,
   animationTimeout: PropTypes.number,

package/esm/Modal/ModalBody.js

@@ -3,16 +3,14 @@ import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWith
 import React from 'react';
 import PropTypes from 'prop-types';
 import { useClassNames } from '../utils';
-import { ModalContext } from './Modal';
+import { ModalContext } from './ModalContext';
 import IconButton from '../IconButton';
 import Close from '@rsuite/icons/Close';
-var defaultProps = {
-  as: 'div',
-  classPrefix: 'modal-body'
-};
 var ModalBody = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var Component = props.as,
-      classPrefix = props.classPrefix,
+  var _props$as = props.as,
+      Component = _props$as === void 0 ? 'div' : _props$as,
+      _props$classPrefix = props.classPrefix,
+      classPrefix = _props$classPrefix === void 0 ? 'modal-body' : _props$classPrefix,
       className = props.className,
       style = props.style,
       children = props.children,
@@ -42,7 +40,6 @@ var ModalBody = /*#__PURE__*/React.forwardRef(function (props, ref) {
   });
 });
 ModalBody.displayName = 'ModalBody';
-ModalBody.defaultProps = defaultProps;
 ModalBody.propTypes = {
   as: PropTypes.elementType,
   classPrefix: PropTypes.string,

package/esm/Modal/ModalContext.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface ModalContextProps {
+    /** ID of the dialog element */
+    dialogId: string;
+    /** Pass the close event callback to the header close button. */
+    onModalClose: (event: React.MouseEvent<Element, MouseEvent>) => void;
+    /** Pass the latest style to body. */
+    getBodyStyles?: () => React.CSSProperties;
+    /** Whether this Modal is a Drawer */
+    isDrawer: boolean;
+}
+export declare const ModalContext: React.Context<ModalContextProps>;

package/esm/Modal/ModalContext.js

@@ -0,0 +1,2 @@
+import React from 'react';
+export var ModalContext = /*#__PURE__*/React.createContext(null);

package/esm/Modal/ModalDialog.js

@@ -16,17 +16,15 @@ export var modalDialogPropTypes = {
   dialogStyle: PropTypes.object,
   children: PropTypes.node
 };
-var defaultProps = {
-  as: 'div',
-  classPrefix: 'modal'
-};
 var ModalDialog = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var Component = props.as,
+  var _props$as = props.as,
+      Component = _props$as === void 0 ? 'div' : _props$as,
       style = props.style,
       children = props.children,
       dialogClassName = props.dialogClassName,
       dialogStyle = props.dialogStyle,
-      classPrefix = props.classPrefix,
+      _props$classPrefix = props.classPrefix,
+      classPrefix = _props$classPrefix === void 0 ? 'modal' : _props$classPrefix,
       className = props.className,
       size = props.size,
       rest = _objectWithoutPropertiesLoose(props, ["as", "style", "children", "dialogClassName", "dialogStyle", "classPrefix", "className", "size"]);
@@ -42,7 +40,10 @@ var ModalDialog = /*#__PURE__*/React.forwardRef(function (props, ref) {
 
   var classes = merge(className, withClassPrefix(size));
   var dialogClasses = merge(dialogClassName, prefix('dialog'));
-  return /*#__PURE__*/React.createElement(Component, _extends({}, rest, {
+  return /*#__PURE__*/React.createElement(Component, _extends({
+    role: "dialog",
+    "aria-modal": true
+  }, rest, {
     ref: ref,
     className: classes,
     style: modalStyle
@@ -55,6 +56,5 @@ var ModalDialog = /*#__PURE__*/React.forwardRef(function (props, ref) {
   }, children)));
 });
 ModalDialog.displayName = 'ModalDialog';
-ModalDialog.defaultProps = defaultProps;
 ModalDialog.propTypes = modalDialogPropTypes;
 export default ModalDialog;

package/esm/Modal/ModalHeader.js

@@ -3,20 +3,18 @@ import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWith
 import React, { useContext } from 'react';
 import PropTypes from 'prop-types';
 import { createChainedFunction, useClassNames } from '../utils';
-import { ModalContext } from './Modal';
+import { ModalContext } from './ModalContext';
 import CloseButton from '../CloseButton';
 import Close from '@rsuite/icons/Close';
 import IconButton from '../IconButton';
-var defaultProps = {
-  as: 'div',
-  closeButton: true,
-  classPrefix: 'modal-header'
-};
 var ModalHeader = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var Component = props.as,
-      classPrefix = props.classPrefix,
+  var _props$as = props.as,
+      Component = _props$as === void 0 ? 'div' : _props$as,
+      _props$classPrefix = props.classPrefix,
+      classPrefix = _props$classPrefix === void 0 ? 'modal-header' : _props$classPrefix,
       className = props.className,
-      closeButton = props.closeButton,
+      _props$closeButton = props.closeButton,
+      closeButton = _props$closeButton === void 0 ? true : _props$closeButton,
       children = props.children,
       onClose = props.onClose,
       rest = _objectWithoutPropertiesLoose(props, ["as", "classPrefix", "className", "closeButton", "children", "onClose"]);
@@ -44,7 +42,6 @@ var ModalHeader = /*#__PURE__*/React.forwardRef(function (props, ref) {
   }), closeButton && buttonElement, children);
 });
 ModalHeader.displayName = 'ModalHeader';
-ModalHeader.defaultProps = defaultProps;
 ModalHeader.propTypes = {
   as: PropTypes.elementType,
   classPrefix: PropTypes.string,

package/esm/Modal/ModalTitle.d.ts

@@ -1,4 +1,5 @@
-import { ComponentProps } from '../utils/createComponent';
+import type { ComponentProps } from '../utils/createComponent';
+import type { RsRefForwardingComponent } from '../@types/common';
 export declare type ModalTitleProps = ComponentProps;
-declare const ModalTitle: import("../@types/common").RsRefForwardingComponent<"div", ComponentProps>;
+declare const ModalTitle: RsRefForwardingComponent<'h4', ComponentProps>;
 export default ModalTitle;