@khanacademy/wonder-blocks-modal 2.2.3 → 2.3.2

package/dist/es/index.js

@@ -6,20 +6,11 @@ import Spacing from '@khanacademy/wonder-blocks-spacing';
 import Color from '@khanacademy/wonder-blocks-color';
 import { HeadingMedium, LabelSmall } from '@khanacademy/wonder-blocks-typography';
 import * as ReactDOM from 'react-dom';
+import { withActionScheduler } from '@khanacademy/wonder-blocks-timing';
 import _extends from '@babel/runtime/helpers/extends';
 import { icons } from '@khanacademy/wonder-blocks-icon';
 import IconButton from '@khanacademy/wonder-blocks-icon-button';
 
-/**
- * `ModalDialog` is a component that contains these elements:
- * - The visual dialog element itself (`<div role="dialog"/>`)
- * - The custom contents below and/or above the Dialog itself (e.g. decorative graphics).
- *
- * **Accessibility notes:**
- * - By default (e.g. using `OnePaneDialog`), `aria-labelledby` is populated automatically using the dialog title `id`.
- * - If there is a custom Dialog implementation (e.g. `TwoPaneDialog`), the dialog element doesn’t have to have
- * the `aria-labelledby` attribute however this is recommended. It should match the `id` of the dialog title.
- */
 class ModalDialog extends React.Component {
   render() {
     const {
@@ -35,23 +26,23 @@ class ModalDialog extends React.Component {
       ssrSize: "large",
       mediaSpec: MEDIA_MODAL_SPEC
     };
-    return /*#__PURE__*/React.createElement(MediaLayoutContext.Provider, {
+    return React.createElement(MediaLayoutContext.Provider, {
       value: contextValue
-    }, /*#__PURE__*/React.createElement(MediaLayout, {
+    }, React.createElement(MediaLayout, {
       styleSheets: styleSheets$3
     }, ({
       styles
-    }) => /*#__PURE__*/React.createElement(View, {
+    }) => React.createElement(View, {
       style: [styles.wrapper, style]
-    }, below && /*#__PURE__*/React.createElement(View, {
+    }, below && React.createElement(View, {
       style: styles.below
-    }, below), /*#__PURE__*/React.createElement(View, {
+    }, below), React.createElement(View, {
       role: role,
       "aria-modal": "true",
       "aria-labelledby": ariaLabelledBy,
       style: styles.dialog,
       testId: testId
-    }, children), above && /*#__PURE__*/React.createElement(View, {
+    }, children), above && React.createElement(View, {
       style: styles.above
     }, above))));
   }
@@ -70,10 +61,6 @@ const styleSheets$3 = {
       height: "100%",
       position: "relative"
     },
-
-    /**
-     * Ensures the dialog container uses the container size
-     */
     dialog: {
       width: "100%",
       height: "100%",
@@ -107,15 +94,6 @@ const styleSheets$3 = {
   })
 };
 
-/**
- * Modal footer included after the content.
- *
- * **Implementation notes**:
- *
- * If you are creating a custom Dialog, make sure to follow these guidelines:
- * - Make sure to include it as part of [ModalPanel](/#modalpanel) by using the `footer` prop.
- * - The footer is completely flexible. Meaning the developer needs to add its own custom layout to match design specs.
- */
 class ModalFooter extends React.Component {
   static isClassOf(instance) {
     return instance && instance.type && instance.type.__IS_MODAL_FOOTER__;
@@ -125,7 +103,7 @@ class ModalFooter extends React.Component {
     const {
       children
     } = this.props;
-    return /*#__PURE__*/React.createElement(View, {
+    return React.createElement(View, {
       style: styles$3.footer
     }, children);
   }
@@ -149,49 +127,6 @@ const styles$3 = StyleSheet.create({
   }
 });
 
-/**
- * This is a helper component that is never rendered by itself. It is always
- * pinned to the top of the dialog, is responsive using the same behavior as its
- * parent dialog, and has the following properties:
- * - title
- * - breadcrumb OR subtitle, but not both.
- *
- * **Accessibility notes:**
- *
- * - By default (e.g. using [OnePaneDialog](/#onepanedialog)), `titleId` is
- *   populated automatically by the parent container.
- * - If there is a custom Dialog implementation (e.g. `TwoPaneDialog`), the
- *   ModalHeader doesn’t have to have the `titleId` prop however this is
- *   recommended. It should match the `aria-labelledby` prop of the
- *   [ModalDialog](/#modaldialog) component. If you want to see an example of
- *   how to generate this ID, check [IDProvider](/#idprovider).
- *
- * **Implementation notes:**
- *
- * If you are creating a custom Dialog, make sure to follow these guidelines:
- * - Make sure to include it as part of [ModalPanel](/#modalpanel) by using the
- *   `header` prop.
- * - Add a title (required).
- * - Optionally add a subtitle or breadcrumbs.
- * - We encourage you to add `titleId` (see Accessibility notes).
- * - If the `ModalPanel` has a dark background, make sure to set `light` to
- *   `false`.
- * - If you need to create e2e tests, make sure to pass a `testId` prop and
- *   add a sufix to scope the testId to this component: e.g.
- *   `some-random-id-ModalHeader`. This scope will also be passed to the title
- *   and subtitle elements: e.g. `some-random-id-ModalHeader-title`.
- *
- * Example:
- *
- * ```js
- * <ModalHeader
- *      title="Sidebar using ModalHeader"
- *      subtitle="subtitle"
- *      titleId="uniqueTitleId"
- *      light={false}
- *  />
- * ```
- */
 class ModalHeader extends React.Component {
   render() {
     const {
@@ -207,20 +142,20 @@ class ModalHeader extends React.Component {
       throw new Error("'subtitle' and 'breadcrumbs' can't be used together");
     }
 
-    return /*#__PURE__*/React.createElement(MediaLayout, {
+    return React.createElement(MediaLayout, {
       styleSheets: styleSheets$2
     }, ({
       styles
-    }) => /*#__PURE__*/React.createElement(View, {
+    }) => React.createElement(View, {
       style: [styles.header, !light && styles.dark],
       testId: testId
-    }, breadcrumbs && /*#__PURE__*/React.createElement(View, {
+    }, breadcrumbs && React.createElement(View, {
       style: styles.breadcrumbs
-    }, breadcrumbs), /*#__PURE__*/React.createElement(HeadingMedium, {
+    }, breadcrumbs), React.createElement(HeadingMedium, {
       style: styles.title,
       id: titleId,
       testId: testId && `${testId}-title`
-    }, title), subtitle && /*#__PURE__*/React.createElement(LabelSmall, {
+    }, title), subtitle && React.createElement(LabelSmall, {
       style: light && styles.subtitle,
       testId: testId && `${testId}-subtitle`
     }, subtitle)));
@@ -250,7 +185,6 @@ const styleSheets$2 = {
       marginBottom: Spacing.xSmall_8
     },
     title: {
-      // Prevent title from overlapping the close button
       paddingRight: Spacing.medium_16
     },
     subtitle: {
@@ -270,22 +204,11 @@ const styleSheets$2 = {
 };
 
 class FocusTrap extends React.Component {
-  /** The most recent node _inside this component_ to receive focus. */
-
-  /**
-   * Whether we're currently applying programmatic focus, and should therefore
-   * ignore focus change events.
-   */
-
-  /**
-   * Tabbing is restricted to descendents of this element.
-   */
   constructor(props) {
     super(props);
 
     this.getModalRoot = node => {
       if (!node) {
-        // The component is being umounted
         return;
       }
 
@@ -299,8 +222,6 @@ class FocusTrap extends React.Component {
     };
 
     this.handleGlobalFocus = e => {
-      // If we're busy applying our own programmatic focus, we ignore focus
-      // changes, to avoid an infinite loop.
       if (this.ignoreFocusChanges) {
         return;
       }
@@ -308,7 +229,6 @@ class FocusTrap extends React.Component {
       const target = e.target;
 
       if (!(target instanceof Node)) {
-        // Sometimes focus events trigger on the document itself. Ignore!
         return;
       }
 
@@ -319,25 +239,13 @@ class FocusTrap extends React.Component {
       }
 
       if (modalRoot.contains(target)) {
-        // If the newly focused node is inside the modal, we just keep track
-        // of that.
         this.lastNodeFocusedInModal = target;
       } else {
-        // If the newly focused node is outside the modal, we try refocusing
-        // the first focusable node of the modal. (This could be the user
-        // pressing Tab on the last node of the modal, or focus escaping in
-        // some other way.)
-        this.focusFirstElementIn(modalRoot); // But, if it turns out that the first focusable node of the modal
-        // was what we were previously focusing, then this is probably the
-        // user pressing Shift-Tab on the first node, wanting to go to the
-        // end. So, we instead try focusing the last focusable node of the
-        // modal.
+        this.focusFirstElementIn(modalRoot);
 
         if (document.activeElement === this.lastNodeFocusedInModal) {
           this.focusLastElementIn(modalRoot);
-        } // Focus should now be inside the modal, so record the newly-focused
-        // node as the last node focused in the modal.
-
+        }
 
         this.lastNodeFocusedInModal = document.activeElement;
       }
@@ -355,27 +263,18 @@ class FocusTrap extends React.Component {
     window.removeEventListener("focus", this.handleGlobalFocus, true);
   }
 
-  /** Try to focus the given node. Return true iff successful. */
   tryToFocus(node) {
     if (node instanceof HTMLElement) {
       this.ignoreFocusChanges = true;
 
       try {
         node.focus();
-      } catch (e) {// ignore error
-      }
+      } catch (e) {}
 
       this.ignoreFocusChanges = false;
       return document.activeElement === node;
     }
   }
-  /**
-   * Focus the first focusable descendant of the given node.
-   *
-   * Return true if we succeed. Or, if the given node has no focusable
-   * descendants, return false.
-   */
-
 
   focusFirstElementIn(currentParent) {
     const children = currentParent.childNodes;
@@ -390,13 +289,6 @@ class FocusTrap extends React.Component {
 
     return false;
   }
-  /**
-   * Focus the last focusable descendant of the given node.
-   *
-   * Return true if we succeed. Or, if the given node has no focusable
-   * descendants, return false.
-   */
-
 
   focusLastElementIn(currentParent) {
     const children = currentParent.childNodes;
@@ -411,22 +303,20 @@ class FocusTrap extends React.Component {
 
     return false;
   }
-  /** This method is called when any node on the page is focused. */
-
 
   render() {
     const {
       style
     } = this.props;
-    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+    return React.createElement(React.Fragment, null, React.createElement("div", {
       tabIndex: "0",
       style: {
         position: "fixed"
       }
-    }), /*#__PURE__*/React.createElement(View, {
+    }), React.createElement(View, {
       style: style,
       ref: this.getModalRoot
-    }, this.props.children), /*#__PURE__*/React.createElement("div", {
+    }, this.props.children), React.createElement("div", {
       tabIndex: "0",
       style: {
         position: "fixed"
@@ -436,43 +326,23 @@ class FocusTrap extends React.Component {
 
 }
 
-/**
- * The attribute used to identify a modal launcher portal.
- */
 const ModalLauncherPortalAttributeName = "data-modal-launcher-portal";
 
-/**
- * List of elements that can be focused
- * @see https://www.w3.org/TR/html5/editing.html#can-be-focused
- */
 const FOCUSABLE_ELEMENTS = 'a[href], details, input, textarea, select, button:not([aria-label^="Close"])';
 function findFocusableNodes(root) {
   return Array.from(root.querySelectorAll(FOCUSABLE_ELEMENTS));
 }
 
-/**
- * A private component used by ModalLauncher. This is the fixed-position
- * container element that gets mounted outside the DOM. It overlays the modal
- * content (provided as `children`) over the content, with a gray backdrop
- * behind it.
- *
- * This component is also responsible for cloning the provided modal `children`,
- * and adding an `onClose` prop that will call `onCloseModal`. If an
- * `onClose` prop is already provided, the two are merged.
- */
 class ModalBackdrop extends React.Component {
   constructor(...args) {
     super(...args);
     this._mousePressedOutside = false;
 
     this.handleMouseDown = e => {
-      // Confirm that it is the backdrop that is being clicked, not the child
       this._mousePressedOutside = e.target === e.currentTarget;
     };
 
     this.handleMouseUp = e => {
-      // Confirm that it is the backdrop that is being clicked, not the child
-      // and that the mouse was pressed in the backdrop first.
       if (e.target === e.currentTarget && this._mousePressedOutside) {
         this.props.onCloseModal();
       }
@@ -488,20 +358,13 @@ class ModalBackdrop extends React.Component {
       return;
     }
 
-    const firstFocusableElement = // 1. try to get element specified by the user
-    this._getInitialFocusElement(node) || // 2. get first occurence from list of focusable elements
-    this._getFirstFocusableElement(node) || // 3. get the dialog itself
-    this._getDialogElement(node); // wait for styles to applied
-
+    const firstFocusableElement = this._getInitialFocusElement(node) || this._getFirstFocusableElement(node) || this._getDialogElement(node);
 
     setTimeout(() => {
       firstFocusableElement.focus();
     }, 0);
   }
 
-  /**
-   * Returns an element specified by the user
-   */
   _getInitialFocusElement(node) {
     const {
       initialFocusId
@@ -513,41 +376,22 @@ class ModalBackdrop extends React.Component {
 
     return ReactDOM.findDOMNode(node.querySelector(`#${initialFocusId}`));
   }
-  /**
-   * Returns the first focusable element found inside the Dialog
-   */
-
 
   _getFirstFocusableElement(node) {
-    // get a collection of elements that can be focused
     const focusableElements = findFocusableNodes(node);
 
     if (!focusableElements) {
       return null;
-    } // if found, return the first focusable element
-
+    }
 
     return focusableElements[0];
   }
-  /**
-   * Returns the dialog element
-   */
-
 
   _getDialogElement(node) {
-    // If no focusable elements are found,
-    // the dialog content element itself will receive focus.
-    const dialogElement = ReactDOM.findDOMNode(node.querySelector('[role="dialog"]')); // add tabIndex to make the Dialog focusable
-
+    const dialogElement = ReactDOM.findDOMNode(node.querySelector('[role="dialog"]'));
     dialogElement.tabIndex = -1;
     return dialogElement;
   }
-  /**
-   * When the user clicks on the gray backdrop area (i.e., the click came
-   * _directly_ from the positioner, not bubbled up from its children), close
-   * the modal.
-   */
-
 
   render() {
     const {
@@ -557,7 +401,7 @@ class ModalBackdrop extends React.Component {
     const backdropProps = {
       [ModalLauncherPortalAttributeName]: true
     };
-    return /*#__PURE__*/React.createElement(View, _extends({
+    return React.createElement(View, _extends({
       style: styles$2.modalPositioner,
       onMouseDown: this.handleMouseDown,
       onMouseUp: this.handleMouseUp,
@@ -575,30 +419,11 @@ const styles$2 = StyleSheet.create({
     height: "100%",
     alignItems: "center",
     justifyContent: "center",
-    // If the modal ends up being too big for the viewport (e.g., the min
-    // height is triggered), add another scrollbar specifically for
-    // scrolling modal content.
-    //
-    // TODO(mdr): The specified behavior is that the modal should scroll
-    //     with the rest of the page, rather than separately, if overflow
-    //     turns out to be necessary. That sounds hard to do; punting for
-    //     now!
     overflow: "auto",
     background: Color.offBlack64
   }
 });
 
-/**
- * A UI-less component that lets `ModalLauncher` disable page scroll.
- *
- * The positioning of the modal requires some global page state changed
- * unfortunately, and this handles that in an encapsulated way.
- *
- * NOTE(mdr): This component was copied from webapp. Be wary of sync issues. It
- *     also doesn't have unit tests, and we haven't added any, since it's a
- *     relatively stable component that has now been stress-tested lots in prod.
- */
-
 const needsHackyMobileSafariScrollDisabler = (() => {
   if (typeof window === "undefined") {
     return false;
@@ -615,13 +440,10 @@ class ScrollDisabler extends React.Component {
 
       if (!body) {
         throw new Error("couldn't find document.body");
-      } // Prevent scrolling of the background, the first time a modal is
-      // opened.
-
+      }
 
       ScrollDisabler.oldOverflow = body.style.overflow;
-      ScrollDisabler.oldScrollY = window.scrollY; // We need to grab all of the original style properties before we
-      // modified any of them.
+      ScrollDisabler.oldScrollY = window.scrollY;
 
       if (needsHackyMobileSafariScrollDisabler) {
         ScrollDisabler.oldPosition = body.style.position;
@@ -629,9 +451,7 @@ class ScrollDisabler extends React.Component {
         ScrollDisabler.oldTop = body.style.top;
       }
 
-      body.style.overflow = "hidden"; // On mobile Safari, overflow: hidden is not enough, position:
-      // fixed is also required.  Setting style.top = -scollTop maintains
-      // the scroll position (without which we'd scroll to the top).
+      body.style.overflow = "hidden";
 
       if (needsHackyMobileSafariScrollDisabler) {
         body.style.position = "fixed";
@@ -651,8 +471,7 @@ class ScrollDisabler extends React.Component {
 
       if (!body) {
         throw new Error("couldn't find document.body");
-      } // Reset all values on the closing of the final modal.
-
+      }
 
       body.style.overflow = ScrollDisabler.oldOverflow;
 
@@ -679,24 +498,8 @@ ScrollDisabler.numModalsOpened = 0;
 const defaultContext = {
   closeModal: undefined
 };
-var ModalContext = /*#__PURE__*/React.createContext(defaultContext);
-
-/**
- * This component enables you to launch a modal, covering the screen.
- *
- * Children have access to `openModal` function via the function-as-children
- * pattern, so one common use case is for this component to wrap a button:
- *
- * ```js
- * <ModalLauncher modal={<TwoColumnModal ... />}>
- *     {({openModal}) => <button onClick={openModal}>Learn more</button>}
- * </ModalLauncher>
- * ```
- *
- * The actual modal itself is constructed separately, using a layout component
- * like OnePaneDialog and is provided via
- * the `modal` prop.
- */
+var ModalContext = React.createContext(defaultContext);
+
 class ModalLauncher extends React.Component {
   constructor(...args) {
     super(...args);
@@ -705,7 +508,6 @@ class ModalLauncher extends React.Component {
     };
 
     this._saveLastElementFocused = () => {
-      // keep a reference of the element that triggers the modal
       this.lastElementFocusedOutsideModal = document.activeElement;
     };
 
@@ -717,33 +519,55 @@ class ModalLauncher extends React.Component {
       });
     };
 
+    this._returnFocus = () => {
+      const {
+        closedFocusId,
+        schedule
+      } = this.props;
+      const lastElement = this.lastElementFocusedOutsideModal;
+
+      if (closedFocusId) {
+        const focusElement = ReactDOM.findDOMNode(document.getElementById(closedFocusId));
+
+        if (focusElement) {
+          schedule.animationFrame(() => {
+            focusElement.focus();
+          });
+          return;
+        }
+      }
+
+      if (lastElement != null) {
+        schedule.animationFrame(() => {
+          lastElement.focus();
+        });
+      }
+    };
+
     this.handleCloseModal = () => {
       this.setState({
         opened: false
       }, () => {
-        this.props.onClose && this.props.onClose();
+        const {
+          onClose
+        } = this.props;
+        onClose && onClose();
 
-        if (this.lastElementFocusedOutsideModal != null) {
-          // return focus to the element that triggered the modal
-          this.lastElementFocusedOutsideModal.focus();
-        }
+        this._returnFocus();
       });
     };
   }
 
   static getDerivedStateFromProps(props, state) {
     if (typeof props.opened === "boolean" && props.children) {
-      // eslint-disable-next-line no-console
       console.warn("'children' and 'opened' can't be used together");
     }
 
     if (typeof props.opened === "boolean" && !props.onClose) {
-      // eslint-disable-next-line no-console
       console.warn("'onClose' should be used with 'opened'");
     }
 
     if (typeof props.opened !== "boolean" && !props.children) {
-      // eslint-disable-next-line no-console
       console.warn("either 'children' or 'opened' must be set");
     }
 
@@ -753,7 +577,6 @@ class ModalLauncher extends React.Component {
   }
 
   componentDidUpdate(prevProps) {
-    // ensures the element is stored only when the modal is opened
     if (!prevProps.opened && this.props.opened) {
       this._saveLastElementFocused();
     }
@@ -781,34 +604,22 @@ class ModalLauncher extends React.Component {
       return null;
     }
 
-    return (
-      /*#__PURE__*/
-      // This flow check is valid, it's the babel plugin which is broken,
-      // see modal-context.js for details.
-      // $FlowFixMe
-      React.createElement(ModalContext.Provider, {
-        value: {
-          closeModal: this.handleCloseModal
-        }
-      }, renderedChildren, this.state.opened && /*#__PURE__*/ReactDOM.createPortal(
-      /*#__PURE__*/
-
-      /* We need the container View that FocusTrap creates to be at the
-         correct z-index so that it'll be above the global nav in webapp. */
-      React.createElement(FocusTrap, {
-        style: styles$1.container
-      }, /*#__PURE__*/React.createElement(ModalBackdrop, {
-        initialFocusId: this.props.initialFocusId,
-        testId: this.props.testId,
-        onCloseModal: this.props.backdropDismissEnabled ? this.handleCloseModal : () => {}
-      }, this._renderModal())), body), this.state.opened && /*#__PURE__*/React.createElement(ModalLauncherKeypressListener, {
-        onClose: this.handleCloseModal
-      }), this.state.opened && /*#__PURE__*/React.createElement(ScrollDisabler, null))
-    );
+    return React.createElement(ModalContext.Provider, {
+      value: {
+        closeModal: this.handleCloseModal
+      }
+    }, renderedChildren, this.state.opened && ReactDOM.createPortal(React.createElement(FocusTrap, {
+      style: styles$1.container
+    }, React.createElement(ModalBackdrop, {
+      initialFocusId: this.props.initialFocusId,
+      testId: this.props.testId,
+      onCloseModal: this.props.backdropDismissEnabled ? this.handleCloseModal : () => {}
+    }, this._renderModal())), body), this.state.opened && React.createElement(ModalLauncherKeypressListener, {
+      onClose: this.handleCloseModal
+    }), this.state.opened && React.createElement(ScrollDisabler, null));
   }
 
 }
-/** A component that, when mounted, calls `onClose` when Escape is pressed. */
 
 ModalLauncher.defaultProps = {
   backdropDismissEnabled: true
@@ -819,16 +630,7 @@ class ModalLauncherKeypressListener extends React.Component {
     super(...args);
 
     this._handleKeyup = e => {
-      // We check the key as that's keyboard layout agnostic and also avoids
-      // the minefield of deprecated number type properties like keyCode and
-      // which, with the replacement code, which uses a string instead.
       if (e.key === "Escape") {
-        // Stop the event going any further.
-        // For cancellation events, like the Escape key, we generally should
-        // air on the side of caution and only allow it to cancel one thing.
-        // So, it's polite for us to stop propagation of the event.
-        // Otherwise, we end up with UX where one Escape key press
-        // unexpectedly cancels multiple things.
         e.preventDefault();
         e.stopPropagation();
         this.props.onClose();
@@ -852,18 +654,11 @@ class ModalLauncherKeypressListener extends React.Component {
 
 const styles$1 = StyleSheet.create({
   container: {
-    // This z-index is copied from the Khan Academy webapp.
-    //
-    // TODO(mdr): Should we keep this in a constants file somewhere? Or
-    //     not hardcode it at all, and provide it to Wonder Blocks via
-    //     configuration?
     zIndex: 1080
   }
 });
+var modalLauncher = withActionScheduler(ModalLauncher);
 
-/**
- * The Modal content included after the header
- */
 class ModalContent extends React.Component {
   static isClassOf(instance) {
     return instance && instance.type && instance.type.__IS_MODAL_CONTENT__;
@@ -875,13 +670,13 @@ class ModalContent extends React.Component {
       style,
       children
     } = this.props;
-    return /*#__PURE__*/React.createElement(MediaLayout, {
+    return React.createElement(MediaLayout, {
       styleSheets: styleSheets$1
     }, ({
       styles
-    }) => /*#__PURE__*/React.createElement(View, {
+    }) => React.createElement(View, {
       style: [styles.wrapper, scrollOverflow && styles.scrollOverflow]
-    }, /*#__PURE__*/React.createElement(View, {
+    }, React.createElement(View, {
       style: [styles.content, style]
     }, children)));
   }
@@ -895,8 +690,6 @@ const styleSheets$1 = {
   all: StyleSheet.create({
     wrapper: {
       flex: 1,
-      // This helps to ensure that the paddingBottom is preserved when
-      // the contents start to overflow, this goes away on display: flex
       display: "block"
     },
     scrollOverflow: {
@@ -924,17 +717,15 @@ class CloseButton extends React.Component {
       style,
       testId
     } = this.props;
-    return /*#__PURE__*/React.createElement(ModalContext.Consumer, null, ({
+    return React.createElement(ModalContext.Consumer, null, ({
       closeModal
     }) => {
       if (closeModal && onClick) {
         throw new Error("You've specified 'onClose' on a modal when using ModalLauncher.  Please specify 'onClose' on the ModalLauncher instead");
       }
 
-      return /*#__PURE__*/React.createElement(IconButton, {
-        icon: icons.dismiss // TODO(mdr): Translate this string for i18n.
-        // TODO(kevinb): provide a way to set this label
-        ,
+      return React.createElement(IconButton, {
+        icon: icons.dismiss,
         "aria-label": "Close modal",
         onClick: onClick || closeModal,
         kind: light ? "primary" : "tertiary",
@@ -947,26 +738,6 @@ class CloseButton extends React.Component {
 
 }
 
-/**
- * ModalPanel is  the content container.
- *
- * **Implementation notes:**
- *
- * If you are creating a custom Dialog, make sure to follow these guidelines:
- * - Make sure to add this component inside the [ModalDialog](/#modaldialog).
- * - If needed, you can also add a [ModalHeader](/#modalheader) using the
- *   `header` prop. Same goes for [ModalFooter](/#modalfooter).
- * - If you need to create e2e tests, make sure to pass a `testId` prop. This
- *   will be passed down to this component using a sufix: e.g.
- *   `some-random-id-ModalPanel`. This scope will be propagated to the
- *   CloseButton element as well: e.g. `some-random-id-CloseButton`.
- *
- * ```js
- * <ModalDialog>
- *      <ModalPanel content={"custom content goes here"} />
- * </ModalDialog>
- * ```
- */
 class ModalPanel extends React.Component {
   renderMainContent() {
     const {
@@ -974,19 +745,14 @@ class ModalPanel extends React.Component {
       footer,
       scrollOverflow
     } = this.props;
-    const mainContent = ModalContent.isClassOf(content) ? content : /*#__PURE__*/React.createElement(ModalContent, null, content);
+    const mainContent = ModalContent.isClassOf(content) ? content : React.createElement(ModalContent, null, content);
 
     if (!mainContent) {
       return mainContent;
     }
 
-    return /*#__PURE__*/React.cloneElement(mainContent, {
-      // Pass the scrollOverflow and header in to the main content
+    return React.cloneElement(mainContent, {
       scrollOverflow,
-      // We override the styling of the main content to help position
-      // it if there is a footer or close button being
-      // shown. We have to do this here as the ModalContent doesn't
-      // know about things being positioned around it.
       style: [!!footer && styles.hasFooter, mainContent.props.style]
     });
   }
@@ -1002,15 +768,15 @@ class ModalPanel extends React.Component {
       testId
     } = this.props;
     const mainContent = this.renderMainContent();
-    return /*#__PURE__*/React.createElement(View, {
+    return React.createElement(View, {
       style: [styles.wrapper, !light && styles.dark, style],
       testId: testId && `${testId}-panel`
-    }, closeButtonVisible && /*#__PURE__*/React.createElement(CloseButton, {
+    }, closeButtonVisible && React.createElement(CloseButton, {
       light: !light,
       onClick: onClose,
       style: styles.closeButton,
       testId: testId && `${testId}-close`
-    }), header, mainContent, !footer || ModalFooter.isClassOf(footer) ? footer : /*#__PURE__*/React.createElement(ModalFooter, null, footer));
+    }), header, mainContent, !footer || ModalFooter.isClassOf(footer) ? footer : React.createElement(ModalFooter, null, footer));
   }
 
 }
@@ -1035,8 +801,6 @@ const styles = StyleSheet.create({
     position: "absolute",
     right: Spacing.medium_16,
     top: Spacing.medium_16,
-    // This is to allow the button to be tab-ordered before the modal
-    // content but still be above the header and content.
     zIndex: 1
   },
   dark: {
@@ -1048,12 +812,6 @@ const styles = StyleSheet.create({
   }
 });
 
-/**
- * This is the standard layout for most straightforward modal experiences.
- *
- * The ModalHeader is required, but the ModalFooter is optional.
- * The content of the dialog itself is fully customizable, but the left/right/top/bottom padding is fixed.
- */
 class OnePaneDialog extends React.Component {
   renderHeader(uniqueId) {
     const {
@@ -1064,21 +822,21 @@ class OnePaneDialog extends React.Component {
     } = this.props;
 
     if (breadcrumbs) {
-      return /*#__PURE__*/React.createElement(ModalHeader, {
+      return React.createElement(ModalHeader, {
         title: title,
         breadcrumbs: breadcrumbs,
         titleId: uniqueId,
         testId: testId && `${testId}-header`
       });
     } else if (subtitle) {
-      return /*#__PURE__*/React.createElement(ModalHeader, {
+      return React.createElement(ModalHeader, {
         title: title,
         subtitle: subtitle,
         titleId: uniqueId,
         testId: testId && `${testId}-header`
       });
     } else {
-      return /*#__PURE__*/React.createElement(ModalHeader, {
+      return React.createElement(ModalHeader, {
         title: title,
         titleId: uniqueId,
         testId: testId && `${testId}-header`
@@ -1099,21 +857,21 @@ class OnePaneDialog extends React.Component {
       titleId,
       role
     } = this.props;
-    return /*#__PURE__*/React.createElement(MediaLayout, {
+    return React.createElement(MediaLayout, {
       styleSheets: styleSheets
     }, ({
       styles
-    }) => /*#__PURE__*/React.createElement(IDProvider, {
+    }) => React.createElement(IDProvider, {
       id: titleId,
       scope: "modal"
-    }, uniqueId => /*#__PURE__*/React.createElement(ModalDialog, {
+    }, uniqueId => React.createElement(ModalDialog, {
       style: [styles.dialog, style],
       above: above,
       below: below,
       testId: testId,
       "aria-labelledby": uniqueId,
       role: role
-    }, /*#__PURE__*/React.createElement(ModalPanel, {
+    }, React.createElement(ModalPanel, {
       onClose: onClose,
       header: this.renderHeader(uniqueId),
       content: content,
@@ -1145,14 +903,6 @@ const styleSheets = {
   })
 };
 
-/**
- * From a given element, finds its next ancestor that is a modal launcher portal
- * element.
- * @param {?(Element | Text)} element The element whose ancestors are to be
- * walked.
- * @returns {?Element} The nearest parent modal launcher portal.
- */
-
 function maybeGetNextAncestorModalLauncherPortal(element) {
   let candidateElement = element && element.parentElement;
 
@@ -1162,18 +912,9 @@ function maybeGetNextAncestorModalLauncherPortal(element) {
 
   return candidateElement;
 }
-/**
- * From a given element, finds the next modal host that has been mounted in
- * a modal portal.
- * @param {?(Element | Text)} element The element whose ancestors are to be
- * walked.
- * @returns {?Element} The next portal-mounted modal host element.
- * TODO(kevinb): look into getting rid of this
- */
-
 
 function maybeGetPortalMountedModalHostElement(element) {
   return maybeGetNextAncestorModalLauncherPortal(element);
 }
 
-export { ModalDialog, ModalFooter, ModalHeader, ModalLauncher, ModalPanel, OnePaneDialog, maybeGetPortalMountedModalHostElement };
+export { ModalDialog, ModalFooter, ModalHeader, modalLauncher as ModalLauncher, ModalPanel, OnePaneDialog, maybeGetPortalMountedModalHostElement };