content: import _extends from "@babel/runtime/helpers/esm/extends";
  import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
  import React from 'react';
  import PropTypes from 'prop-types';
  import clsx from 'clsx';
  import { refType } from '@material-ui/utils';
  import useControlled from '../utils/useControlled';
  import useFormControl from '../FormControl/useFormControl';
  import withStyles from '../styles/withStyles';
  import IconButton from '../IconButton';
  export const styles = {
    root: {
      padding: 9
    },
    checked: {},
    disabled: {},
    input: {
      cursor: 'inherit',
      position: 'absolute',
      opacity: 0,
      width: '100%',
      height: '100%',
      top: 0,
      left: 0,
      margin: 0,
      padding: 0,
      zIndex: 1
    }
  };
  /**
   * @ignore - internal component.
   */
  
  const SwitchBase = React.forwardRef(function SwitchBase(props, ref) {
    const {
      autoFocus,
      checked: checkedProp,
      checkedIcon,
      classes,
      className,
      defaultChecked,
      disabled: disabledProp,
      icon,
      id,
      inputProps,
      inputRef,
      name,
      onBlur,
      onChange,
      onFocus,
      readOnly,
      required,
      tabIndex,
      type,
      value
    } = props,
          other = _objectWithoutPropertiesLoose(props, ["autoFocus", "checked", "checkedIcon", "classes", "className", "defaultChecked", "disabled", "icon", "id", "inputProps", "inputRef", "name", "onBlur", "onChange", "onFocus", "readOnly", "required", "tabIndex", "type", "value"]);
  
    const [checked, setCheckedState] = useControlled({
      controlled: checkedProp,
      default: Boolean(defaultChecked),
      name: 'SwitchBase'
    });
    const muiFormControl = useFormControl();
  
    const handleFocus = event => {
      if (onFocus) {
        onFocus(event);
      }
  
      if (muiFormControl && muiFormControl.onFocus) {
        muiFormControl.onFocus(event);
      }
    };
  
    const handleBlur = event => {
      if (onBlur) {
        onBlur(event);
      }
  
      if (muiFormControl && muiFormControl.onBlur) {
        muiFormControl.onBlur(event);
      }
    };
  
    const handleInputChange = event => {
      const newChecked = event.target.checked;
      setCheckedState(newChecked);
  
      if (onChange) {
        onChange(event, newChecked);
      }
    };
  
    let disabled = disabledProp;
  
    if (muiFormControl) {
      if (typeof disabled === 'undefined') {
        disabled = muiFormControl.disabled;
      }
    }
  
    const hasLabelFor = type === 'checkbox' || type === 'radio';
    return React.createElement(IconButton, _extends({
      component: "span",
      className: clsx(classes.root, className, checked && classes.checked, disabled && classes.disabled),
      disabled: disabled,
      tabIndex: null,
      role: undefined,
      onFocus: handleFocus,
      onBlur: handleBlur,
      ref: ref
    }, other), React.createElement("input", _extends({
      autoFocus: autoFocus,
      checked: checkedProp,
      defaultChecked: defaultChecked,
      className: classes.input,
      disabled: disabled,
      id: hasLabelFor && id,
      name: name,
      onChange: handleInputChange,
      readOnly: readOnly,
      ref: inputRef,
      required: required,
      tabIndex: tabIndex,
      type: type,
      value: value
    }, inputProps)), checked ? checkedIcon : icon);
  }); // NB: If changed, please update Checkbox, Switch and Radio
  // so that the API documentation is updated.
  
  process.env.NODE_ENV !== "production" ? SwitchBase.propTypes = {
    /**
     * If `true`, the `input` element will be focused during the first mount.
     */
    autoFocus: PropTypes.bool,
  
    /**
     * If `true`, the component is checked.
     */
    checked: PropTypes.bool,
  
    /**
     * The icon to display when the component is checked.
     */
    checkedIcon: PropTypes.node.isRequired,
  
    /**
     * 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,
  
    /**
     * @ignore
     */
    defaultChecked: PropTypes.bool,
  
    /**
     * If `true`, the switch will be disabled.
     */
    disabled: PropTypes.bool,
  
    /**
     * The icon to display when the component is unchecked.
     */
    icon: PropTypes.node.isRequired,
  
    /**
     * The id of the `input` element.
     */
    id: PropTypes.string,
  
    /**
     * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.
     */
    inputProps: PropTypes.object,
  
    /**
     * Pass a ref to the `input` element.
     */
    inputRef: refType,
  
    /*
     * @ignore
     */
    name: PropTypes.string,
  
    /**
     * @ignore
     */
    onBlur: PropTypes.func,
  
    /**
     * Callback fired when the state is changed.
     *
     * @param {object} event The event source of the callback.
     * You can pull out the new checked state by accessing `event.target.checked` (boolean).
     */
    onChange: PropTypes.func,
  
    /**
     * @ignore
     */
    onFocus: PropTypes.func,
  
    /**
     * It prevents the user from changing the value of the field
     * (not from interacting with the field).
     */
    readOnly: PropTypes.bool,
  
    /**
     * If `true`, the `input` element will be required.
     */
    required: PropTypes.bool,
  
    /**
     * @ignore
     */
    tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
  
    /**
     * The input component prop `type`.
     */
    type: PropTypes.string.isRequired,
  
    /**
     * The value of the component.
     */
    value: PropTypes.any
  } : void 0;
  export default withStyles(styles, {
    name: 'PrivateSwitchBase'
  })(SwitchBase);