text: var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  
  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  import { Component, createElement } from 'react';
  import PropTypes from 'prop-types';
  import { connect } from 'react-redux';
  import createFieldProps from './createFieldProps';
  import plain from './structure/plain';
  import onChangeValue from './events/onChangeValue';
  
  
  var propsToNotUpdateFor = ['_reduxForm'];
  
  var createConnectedFields = function createConnectedFields(structure) {
    var deepEqual = structure.deepEqual,
        getIn = structure.getIn,
        size = structure.size;
  
  
    var getSyncError = function getSyncError(syncErrors, name) {
      // Because the error for this field might not be at a level in the error structure where
      // it can be set directly, it might need to be unwrapped from the _error property
      return plain.getIn(syncErrors, name + '._error') || plain.getIn(syncErrors, name);
    };
  
    var getSyncWarning = function getSyncWarning(syncWarnings, name) {
      var warning = getIn(syncWarnings, name);
      // Because the warning for this field might not be at a level in the warning structure where
      // it can be set directly, it might need to be unwrapped from the _warning property
      return warning && warning._warning ? warning._warning : warning;
    };
  
    var ConnectedFields = function (_Component) {
      _inherits(ConnectedFields, _Component);
  
      function ConnectedFields(props) {
        _classCallCheck(this, ConnectedFields);
  
        var _this = _possibleConstructorReturn(this, (ConnectedFields.__proto__ || Object.getPrototypeOf(ConnectedFields)).call(this, props));
  
        _this.onChangeFns = {};
        _this.onFocusFns = {};
        _this.onBlurFns = {};
  
        _this.prepareEventHandlers = function (_ref) {
          var names = _ref.names;
          return names.forEach(function (name) {
            _this.onChangeFns[name] = function (event) {
              return _this.handleChange(name, event);
            };
            _this.onFocusFns[name] = function () {
              return _this.handleFocus(name);
            };
            _this.onBlurFns[name] = function (event) {
              return _this.handleBlur(name, event);
            };
          });
        };
  
        _this.handleChange = function (name, event) {
          var _this$props = _this.props,
              dispatch = _this$props.dispatch,
              parse = _this$props.parse,
              _reduxForm = _this$props._reduxForm;
  
          var value = onChangeValue(event, { name: name, parse: parse });
  
          dispatch(_reduxForm.change(name, value));
        };
  
        _this.handleFocus = function (name) {
          var _this$props2 = _this.props,
              dispatch = _this$props2.dispatch,
              _reduxForm = _this$props2._reduxForm;
  
          dispatch(_reduxForm.focus(name));
        };
  
        _this.handleBlur = function (name, event) {
          var _this$props3 = _this.props,
              dispatch = _this$props3.dispatch,
              parse = _this$props3.parse,
              _reduxForm = _this$props3._reduxForm;
  
          var value = onChangeValue(event, { name: name, parse: parse });
  
          // dispatch blur action
          dispatch(_reduxForm.blur(name, value));
  
          // call post-blur callback
          if (_reduxForm.asyncValidate) {
            _reduxForm.asyncValidate(name, value);
          }
        };
  
        _this.prepareEventHandlers(props);
        return _this;
      }
  
      _createClass(ConnectedFields, [{
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
          var _this2 = this;
  
          if (this.props.names !== nextProps.names && (size(this.props.names) !== size(nextProps.names) || nextProps.names.some(function (nextName) {
            return !_this2.props._fields[nextName];
          }))) {
            // names has changed. The cached event handlers need to be updated
            this.prepareEventHandlers(nextProps);
          }
        }
      }, {
        key: 'shouldComponentUpdate',
        value: function shouldComponentUpdate(nextProps) {
          var _this3 = this;
  
          var nextPropsKeys = Object.keys(nextProps);
          var thisPropsKeys = Object.keys(this.props);
          return nextPropsKeys.length !== thisPropsKeys.length || nextPropsKeys.some(function (prop) {
            if (prop === 'children') {
              return _this3.props[prop] === nextProps[prop];
            }
  
            return !~propsToNotUpdateFor.indexOf(prop) && !deepEqual(_this3.props[prop], nextProps[prop]);
          });
        }
      }, {
        key: 'isDirty',
        value: function isDirty() {
          var _fields = this.props._fields;
  
          return Object.keys(_fields).some(function (name) {
            return _fields[name].dirty;
          });
        }
      }, {
        key: 'getValues',
        value: function getValues() {
          var _fields = this.props._fields;
  
          return Object.keys(_fields).reduce(function (accumulator, name) {
            return plain.setIn(accumulator, name, _fields[name].value);
          }, {});
        }
      }, {
        key: 'getRenderedComponent',
        value: function getRenderedComponent() {
          return this.refs.renderedComponent;
        }
      }, {
        key: 'render',
        value: function render() {
          var _this4 = this;
  
          var _props = this.props,
              component = _props.component,
              withRef = _props.withRef,
              _fields = _props._fields,
              _reduxForm = _props._reduxForm,
              rest = _objectWithoutProperties(_props, ['component', 'withRef', '_fields', '_reduxForm']);
  
          var sectionPrefix = _reduxForm.sectionPrefix,
              form = _reduxForm.form;
  
          var _Object$keys$reduce = Object.keys(_fields).reduce(function (accumulator, name) {
            var connectedProps = _fields[name];
  
            var _createFieldProps = createFieldProps(structure, name, _extends({}, connectedProps, rest, {
              form: form,
              onBlur: _this4.onBlurFns[name],
              onChange: _this4.onChangeFns[name],
              onFocus: _this4.onFocusFns[name]
            })),
                custom = _createFieldProps.custom,
                fieldProps = _objectWithoutProperties(_createFieldProps, ['custom']);
  
            accumulator.custom = custom;
            var fieldName = sectionPrefix ? name.replace(sectionPrefix + '.', '') : name;
            return plain.setIn(accumulator, fieldName, fieldProps);
          }, {}),
              custom = _Object$keys$reduce.custom,
              props = _objectWithoutProperties(_Object$keys$reduce, ['custom']);
  
          if (withRef) {
            props.ref = 'renderedComponent';
          }
  
          return createElement(component, _extends({}, props, custom));
        }
      }]);
  
      return ConnectedFields;
    }(Component);
  
    ConnectedFields.propTypes = {
      component: PropTypes.oneOfType([PropTypes.func, PropTypes.string]).isRequired,
      _fields: PropTypes.object.isRequired,
      props: PropTypes.object
    };
  
    var connector = connect(function (state, ownProps) {
      var names = ownProps.names,
          _ownProps$_reduxForm = ownProps._reduxForm,
          initialValues = _ownProps$_reduxForm.initialValues,
          getFormState = _ownProps$_reduxForm.getFormState;
  
      var formState = getFormState(state);
      return {
        _fields: names.reduce(function (accumulator, name) {
          var initialState = getIn(formState, 'initial.' + name);
          var initial = initialState !== undefined ? initialState : initialValues && getIn(initialValues, name);
          var value = getIn(formState, 'values.' + name);
          var syncError = getSyncError(getIn(formState, 'syncErrors'), name);
          var syncWarning = getSyncWarning(getIn(formState, 'syncWarnings'), name);
          var submitting = getIn(formState, 'submitting');
          var pristine = value === initial;
          accumulator[name] = {
            asyncError: getIn(formState, 'asyncErrors.' + name),
            asyncValidating: getIn(formState, 'asyncValidating') === name,
            dirty: !pristine,
            initial: initial,
            pristine: pristine,
            state: getIn(formState, 'fields.' + name),
            submitError: getIn(formState, 'submitErrors.' + name),
            submitFailed: getIn(formState, 'submitFailed'),
            submitting: submitting,
            syncError: syncError,
            syncWarning: syncWarning,
            value: value,
            _value: ownProps.value // save value passed in (for checkboxes)
          };
          return accumulator;
        }, {})
      };
    }, undefined, undefined, { withRef: true });
    return connector(ConnectedFields);
  };
  
  export default createConnectedFields;