content: import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
  import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
  import _extends from "@babel/runtime/helpers/esm/extends";
  import React from 'react';
  import PropTypes from 'prop-types';
  import clsx from 'clsx';
  import withStyles from '../styles/withStyles';
  import { duration } from '../styles/transitions';
  import ClickAwayListener from '../ClickAwayListener';
  import useEventCallback from '../utils/useEventCallback';
  import capitalize from '../utils/capitalize';
  import createChainedFunction from '../utils/createChainedFunction';
  import Grow from '../Grow';
  import SnackbarContent from '../SnackbarContent';
  export var styles = function styles(theme) {
    var top1 = {
      top: 8
    };
    var bottom1 = {
      bottom: 8
    };
    var right = {
      justifyContent: 'flex-end'
    };
    var left = {
      justifyContent: 'flex-start'
    };
    var top3 = {
      top: 24
    };
    var bottom3 = {
      bottom: 24
    };
    var right3 = {
      right: 24
    };
    var left3 = {
      left: 24
    };
    var center = {
      left: '50%',
      right: 'auto',
      transform: 'translateX(-50%)'
    };
    return {
      /* Styles applied to the root element. */
      root: {
        zIndex: theme.zIndex.snackbar,
        position: 'fixed',
        display: 'flex',
        left: 8,
        right: 8,
        justifyContent: 'center',
        alignItems: 'center'
      },
  
      /* Styles applied to the root element if `anchorOrigin={{ 'top', 'center' }}`. */
      anchorOriginTopCenter: _extends({}, top1, _defineProperty({}, theme.breakpoints.up('sm'), _extends({}, top3, {}, center))),
  
      /* Styles applied to the root element if `anchorOrigin={{ 'bottom', 'center' }}`. */
      anchorOriginBottomCenter: _extends({}, bottom1, _defineProperty({}, theme.breakpoints.up('sm'), _extends({}, bottom3, {}, center))),
  
      /* Styles applied to the root element if `anchorOrigin={{ 'top', 'right' }}`. */
      anchorOriginTopRight: _extends({}, top1, {}, right, _defineProperty({}, theme.breakpoints.up('sm'), _extends({
        left: 'auto'
      }, top3, {}, right3))),
  
      /* Styles applied to the root element if `anchorOrigin={{ 'bottom', 'right' }}`. */
      anchorOriginBottomRight: _extends({}, bottom1, {}, right, _defineProperty({}, theme.breakpoints.up('sm'), _extends({
        left: 'auto'
      }, bottom3, {}, right3))),
  
      /* Styles applied to the root element if `anchorOrigin={{ 'top', 'left' }}`. */
      anchorOriginTopLeft: _extends({}, top1, {}, left, _defineProperty({}, theme.breakpoints.up('sm'), _extends({
        right: 'auto'
      }, top3, {}, left3))),
  
      /* Styles applied to the root element if `anchorOrigin={{ 'bottom', 'left' }}`. */
      anchorOriginBottomLeft: _extends({}, bottom1, {}, left, _defineProperty({}, theme.breakpoints.up('sm'), _extends({
        right: 'auto'
      }, bottom3, {}, left3)))
    };
  };
  var Snackbar = React.forwardRef(function Snackbar(props, ref) {
    var action = props.action,
        _props$anchorOrigin = props.anchorOrigin;
    _props$anchorOrigin = _props$anchorOrigin === void 0 ? {
      vertical: 'bottom',
      horizontal: 'center'
    } : _props$anchorOrigin;
  
    var vertical = _props$anchorOrigin.vertical,
        horizontal = _props$anchorOrigin.horizontal,
        _props$autoHideDurati = props.autoHideDuration,
        autoHideDuration = _props$autoHideDurati === void 0 ? null : _props$autoHideDurati,
        children = props.children,
        classes = props.classes,
        className = props.className,
        ClickAwayListenerProps = props.ClickAwayListenerProps,
        ContentProps = props.ContentProps,
        _props$disableWindowB = props.disableWindowBlurListener,
        disableWindowBlurListener = _props$disableWindowB === void 0 ? false : _props$disableWindowB,
        message = props.message,
        onClose = props.onClose,
        onEnter = props.onEnter,
        onEntered = props.onEntered,
        onEntering = props.onEntering,
        onExit = props.onExit,
        onExited = props.onExited,
        onExiting = props.onExiting,
        onMouseEnter = props.onMouseEnter,
        onMouseLeave = props.onMouseLeave,
        open = props.open,
        resumeHideDuration = props.resumeHideDuration,
        _props$TransitionComp = props.TransitionComponent,
        TransitionComponent = _props$TransitionComp === void 0 ? Grow : _props$TransitionComp,
        _props$transitionDura = props.transitionDuration,
        transitionDuration = _props$transitionDura === void 0 ? {
      enter: duration.enteringScreen,
      exit: duration.leavingScreen
    } : _props$transitionDura,
        TransitionProps = props.TransitionProps,
        other = _objectWithoutProperties(props, ["action", "anchorOrigin", "autoHideDuration", "children", "classes", "className", "ClickAwayListenerProps", "ContentProps", "disableWindowBlurListener", "message", "onClose", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "onMouseEnter", "onMouseLeave", "open", "resumeHideDuration", "TransitionComponent", "transitionDuration", "TransitionProps"]);
  
    var timerAutoHide = React.useRef();
  
    var _React$useState = React.useState(true),
        exited = _React$useState[0],
        setExited = _React$useState[1];
  
    var handleClose = useEventCallback(function () {
      if (onClose) {
        onClose.apply(void 0, arguments);
      }
    });
    var setAutoHideTimer = useEventCallback(function (autoHideDurationParam) {
      if (!onClose || autoHideDurationParam == null) {
        return;
      }
  
      clearTimeout(timerAutoHide.current);
      timerAutoHide.current = setTimeout(function () {
        handleClose(null, 'timeout');
      }, autoHideDurationParam);
    });
    React.useEffect(function () {
      if (open) {
        setAutoHideTimer(autoHideDuration);
      }
  
      return function () {
        clearTimeout(timerAutoHide.current);
      };
    }, [open, autoHideDuration, setAutoHideTimer]); // Pause the timer when the user is interacting with the Snackbar
    // or when the user hide the window.
  
    var handlePause = function handlePause() {
      clearTimeout(timerAutoHide.current);
    }; // Restart the timer when the user is no longer interacting with the Snackbar
    // or when the window is shown back.
  
  
    var handleResume = React.useCallback(function () {
      if (autoHideDuration != null) {
        setAutoHideTimer(resumeHideDuration != null ? resumeHideDuration : autoHideDuration * 0.5);
      }
    }, [autoHideDuration, resumeHideDuration, setAutoHideTimer]);
  
    var handleMouseEnter = function handleMouseEnter(event) {
      if (onMouseEnter) {
        onMouseEnter(event);
      }
  
      handlePause();
    };
  
    var handleMouseLeave = function handleMouseLeave(event) {
      if (onMouseLeave) {
        onMouseLeave(event);
      }
  
      handleResume();
    };
  
    var handleClickAway = function handleClickAway(event) {
      if (onClose) {
        onClose(event, 'clickaway');
      }
    };
  
    var handleExited = function handleExited() {
      setExited(true);
    };
  
    var handleEnter = function handleEnter() {
      setExited(false);
    };
  
    React.useEffect(function () {
      if (!disableWindowBlurListener && open) {
        window.addEventListener('focus', handleResume);
        window.addEventListener('blur', handlePause);
        return function () {
          window.removeEventListener('focus', handleResume);
          window.removeEventListener('blur', handlePause);
        };
      }
  
      return undefined;
    }, [disableWindowBlurListener, handleResume, open]); // So we only render active snackbars.
  
    if (!open && exited) {
      return null;
    }
  
    return React.createElement(ClickAwayListener, _extends({
      onClickAway: handleClickAway
    }, ClickAwayListenerProps), React.createElement("div", _extends({
      className: clsx(classes.root, classes["anchorOrigin".concat(capitalize(vertical)).concat(capitalize(horizontal))], className),
      onMouseEnter: handleMouseEnter,
      onMouseLeave: handleMouseLeave,
      ref: ref
    }, other), React.createElement(TransitionComponent, _extends({
      appear: true,
      in: open,
      onEnter: createChainedFunction(handleEnter, onEnter),
      onEntered: onEntered,
      onEntering: onEntering,
      onExit: onExit,
      onExited: createChainedFunction(handleExited, onExited),
      onExiting: onExiting,
      timeout: transitionDuration,
      direction: vertical === 'top' ? 'down' : 'up'
    }, TransitionProps), children || React.createElement(SnackbarContent, _extends({
      message: message,
      action: action
    }, ContentProps)))));
  });
  process.env.NODE_ENV !== "production" ? Snackbar.propTypes = {
    /**
     * The action to display. It renders after the message, at the end of the snackbar.
     */
    action: PropTypes.node,
  
    /**
     * The anchor of the `Snackbar`.
     */
    anchorOrigin: PropTypes.shape({
      horizontal: PropTypes.oneOf(['left', 'center', 'right']).isRequired,
      vertical: PropTypes.oneOf(['top', 'bottom']).isRequired
    }),
  
    /**
     * The number of milliseconds to wait before automatically calling the
     * `onClose` function. `onClose` should then set the state of the `open`
     * prop to hide the Snackbar. This behavior is disabled by default with
     * the `null` value.
     */
    autoHideDuration: PropTypes.number,
  
    /**
     * Replace the `SnackbarContent` component.
     */
    children: PropTypes.element,
  
    /**
     * Override or extend the styles applied to the component.
     * See [CSS API](#css) below for more details.
     */
    classes: PropTypes.object.isRequired,
  
    /**
     * @ignore
     */
    className: PropTypes.string,
  
    /**
     * Props applied to the `ClickAwayListener` element.
     */
    ClickAwayListenerProps: PropTypes.object,
  
    /**
     * Props applied to the [`SnackbarContent`](/api/snackbar-content/) element.
     */
    ContentProps: PropTypes.object,
  
    /**
     * If `true`, the `autoHideDuration` timer will expire even if the window is not focused.
     */
    disableWindowBlurListener: PropTypes.bool,
  
    /**
     * When displaying multiple consecutive Snackbars from a parent rendering a single
     * <Snackbar/>, add the key prop to ensure independent treatment of each message.
     * e.g. <Snackbar key={message} />, otherwise, the message may update-in-place and
     * features such as autoHideDuration may be canceled.
     */
    key: PropTypes.any,
  
    /**
     * The message to display.
     */
    message: PropTypes.node,
  
    /**
     * Callback fired when the component requests to be closed.
     * Typically `onClose` is used to set state in the parent component,
     * which is used to control the `Snackbar` `open` prop.
     * The `reason` parameter can optionally be used to control the response to `onClose`,
     * for example ignoring `clickaway`.
     *
     * @param {object} event The event source of the callback.
     * @param {string} reason Can be: `"timeout"` (`autoHideDuration` expired), `"clickaway"`.
     */
    onClose: PropTypes.func,
  
    /**
     * Callback fired before the transition is entering.
     */
    onEnter: PropTypes.func,
  
    /**
     * Callback fired when the transition has entered.
     */
    onEntered: PropTypes.func,
  
    /**
     * Callback fired when the transition is entering.
     */
    onEntering: PropTypes.func,
  
    /**
     * Callback fired before the transition is exiting.
     */
    onExit: PropTypes.func,
  
    /**
     * Callback fired when the transition has exited.
     */
    onExited: PropTypes.func,
  
    /**
     * Callback fired when the transition is exiting.
     */
    onExiting: PropTypes.func,
  
    /**
     * @ignore
     */
    onMouseEnter: PropTypes.func,
  
    /**
     * @ignore
     */
    onMouseLeave: PropTypes.func,
  
    /**
     * If `true`, `Snackbar` is open.
     */
    open: PropTypes.bool,
  
    /**
     * The number of milliseconds to wait before dismissing after user interaction.
     * If `autoHideDuration` prop isn't specified, it does nothing.
     * If `autoHideDuration` prop is specified but `resumeHideDuration` isn't,
     * we default to `autoHideDuration / 2` ms.
     */
    resumeHideDuration: PropTypes.number,
  
    /**
     * The component used for the transition.
     * [Follow this guide](/components/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
     */
    TransitionComponent: PropTypes.elementType,
  
    /**
     * The duration for the transition, in milliseconds.
     * You may specify a single timeout for all transitions, or individually with an object.
     */
    transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
      enter: PropTypes.number,
      exit: PropTypes.number
    })]),
  
    /**
     * Props applied to the [`Transition`](http://reactcommunity.org/react-transition-group/transition#Transition-props) element.
     */
    TransitionProps: PropTypes.object
  } : void 0;
  export default withStyles(styles, {
    flip: false,
    name: 'MuiSnackbar'
  })(Snackbar);