react-redux-form-validation/dist/validForm.js

Custom validation with redux-forms

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.__RewireAPI__ = exports.__ResetDependency__ = exports.__set__ = exports.__Rewire__ = exports.__GetDependency__ = exports.__get__ = undefined;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

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; }; }();

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; };

exports.default = validForm;

var _propTypes = require('prop-types');

var _propTypes2 = _interopRequireDefault(_propTypes);

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _reactDom = require('react-dom');

var _reduxForm = require('redux-form');

var _reactRedux = require('react-redux');

var _feedbackSummary = require('./feedback-summary');

var _validate = require('./validate');

var _validate2 = _interopRequireDefault(_validate);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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; }

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 getSubmittokenFromStore(form) {
    return function (state, ownProps) {
        var formname = ownProps.form || form;

        return {
            submittoken: state.form[formname].submittoken
        };
    };
}

function validForm(config) {
    var form = config.form,
        errorSummaryTitle = config.errorSummaryTitle,
        validate = config.validate,
        listCreator = config.listCreator,
        elementCreator = config.elementCreator,
        rest = _objectWithoutProperties(config, ['form', 'errorSummaryTitle', 'validate', 'listCreator', 'elementCreator']);

    var defaultSummary = _get__('feedbackSummaryFactory')(listCreator, elementCreator);

    var fields = Object.keys(validate || {});

    return function (WrappedComponent) {
        var mappedConfig = _extends({
            form: form,
            validate: _get__('validation')(validate)
        }, rest);

        var Wrapper = function (_get__2) {
            _inherits(Wrapper, _get__2);

            function Wrapper(props) {
                _classCallCheck(this, Wrapper);

                var _this = _possibleConstructorReturn(this, (Wrapper.__proto__ || Object.getPrototypeOf(Wrapper)).call(this, props));

                _this.handleSubmitProxy = _this.handleSubmitProxy.bind(_this);
                return _this;
            }

            _createClass(Wrapper, [{
                key: 'handleSubmitProxy',
                value: function handleSubmitProxy() {
                    var _props,
                        _this2 = this;

                    return Promise.resolve((_props = this.props).handleSubmit.apply(_props, arguments)).then(function (result) {
                        if ((typeof result === 'undefined' ? 'undefined' : _typeof(result)) !== 'object') {
                            // Resolved ok from onSubmit promise
                            return result;
                        }
                        // Rejected from onSubmit promise
                        // Result contains keys from fields, then it had a validation error
                        var hasField = Object.keys(result).find(function (errorField) {
                            return fields.includes(errorField);
                        });

                        if (hasField) {
                            var summary = _this2.summaryPanel.getRenderedComponent();
                            _get__('findDOMNode')(summary).focus(); // eslint-disable-line react/no-find-dom-node
                        }

                        return result;
                    });
                }
            }, {
                key: 'render',
                value: function render() {
                    var _this3 = this;

                    var _props2 = this.props,
                        submittoken = _props2.submittoken,
                        props = _objectWithoutProperties(_props2, ['submittoken']);

                    var errorSummary = _get__('React').createElement(_get__('Fields'), {
                        names: fields,
                        header: errorSummaryTitle,
                        component: defaultSummary,
                        submittoken: submittoken,
                        withRef: true,
                        ref: function ref(panel) {
                            _this3.summaryPanel = panel;
                        }
                    });
                    var useProps = _extends({}, props, {
                        errorSummary: errorSummary,
                        handleSubmit: this.handleSubmitProxy
                    });

                    return _get__('createElement')(WrappedComponent, useProps);
                }
            }]);

            return Wrapper;
        }(_get__('Component'));

        Wrapper.propTypes = {
            handleSubmit: _get__('PT').func.isRequired,
            submittoken: _get__('PT').string
        };

        return _get__('reduxForm')(mappedConfig)(_get__('connect')(_get__('getSubmittokenFromStore')(form))(Wrapper));
    };
}

function _getGlobalObject() {
    try {
        if (!!global) {
            return global;
        }
    } catch (e) {
        try {
            if (!!window) {
                return window;
            }
        } catch (e) {
            return this;
        }
    }
}

;
var _RewireModuleId__ = null;

function _getRewireModuleId__() {
    if (_RewireModuleId__ === null) {
        var globalVariable = _getGlobalObject();

        if (!globalVariable.__$$GLOBAL_REWIRE_NEXT_MODULE_ID__) {
            globalVariable.__$$GLOBAL_REWIRE_NEXT_MODULE_ID__ = 0;
        }

        _RewireModuleId__ = __$$GLOBAL_REWIRE_NEXT_MODULE_ID__++;
    }

    return _RewireModuleId__;
}

function _getRewireRegistry__() {
    var theGlobalVariable = _getGlobalObject();

    if (!theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__) {
        theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__ = Object.create(null);
    }

    return theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__;
}

function _getRewiredData__() {
    var moduleId = _getRewireModuleId__();

    var registry = _getRewireRegistry__();

    var rewireData = registry[moduleId];

    if (!rewireData) {
        registry[moduleId] = Object.create(null);
        rewireData = registry[moduleId];
    }

    return rewireData;
}

(function registerResetAll() {
    var theGlobalVariable = _getGlobalObject();

    if (!theGlobalVariable['__rewire_reset_all__']) {
        theGlobalVariable['__rewire_reset_all__'] = function () {
            theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__ = Object.create(null);
        };
    }
})();

var INTENTIONAL_UNDEFINED = '__INTENTIONAL_UNDEFINED__';
var _RewireAPI__ = {};

(function () {
    function addPropertyToAPIObject(name, value) {
        Object.defineProperty(_RewireAPI__, name, {
            value: value,
            enumerable: false,
            configurable: true
        });
    }

    addPropertyToAPIObject('__get__', _get__);
    addPropertyToAPIObject('__GetDependency__', _get__);
    addPropertyToAPIObject('__Rewire__', _set__);
    addPropertyToAPIObject('__set__', _set__);
    addPropertyToAPIObject('__reset__', _reset__);
    addPropertyToAPIObject('__ResetDependency__', _reset__);
    addPropertyToAPIObject('__with__', _with__);
})();

function _get__(variableName) {
    var rewireData = _getRewiredData__();

    if (rewireData[variableName] === undefined) {
        return _get_original__(variableName);
    } else {
        var value = rewireData[variableName];

        if (value === INTENTIONAL_UNDEFINED) {
            return undefined;
        } else {
            return value;
        }
    }
}

function _get_original__(variableName) {
    switch (variableName) {
        case 'feedbackSummaryFactory':
            return _feedbackSummary.feedbackSummaryFactory;

        case 'validation':
            return _validate2.default;

        case 'findDOMNode':
            return _reactDom.findDOMNode;

        case 'createElement':
            return _react.createElement;

        case 'Component':
            return _react.Component;

        case 'PT':
            return _propTypes2.default;

        case 'reduxForm':
            return _reduxForm.reduxForm;

        case 'connect':
            return _reactRedux.connect;

        case 'getSubmittokenFromStore':
            return getSubmittokenFromStore;

        case 'React':
            return _react2.default;

        case 'Fields':
            return _reduxForm.Fields;
    }

    return undefined;
}

function _assign__(variableName, value) {
    var rewireData = _getRewiredData__();

    if (rewireData[variableName] === undefined) {
        return _set_original__(variableName, value);
    } else {
        return rewireData[variableName] = value;
    }
}

function _set_original__(variableName, _value) {
    switch (variableName) {}

    return undefined;
}

function _update_operation__(operation, variableName, prefix) {
    var oldValue = _get__(variableName);

    var newValue = operation === '++' ? oldValue + 1 : oldValue - 1;

    _assign__(variableName, newValue);

    return prefix ? newValue : oldValue;
}

function _set__(variableName, value) {
    var rewireData = _getRewiredData__();

    if ((typeof variableName === 'undefined' ? 'undefined' : _typeof(variableName)) === 'object') {
        Object.keys(variableName).forEach(function (name) {
            rewireData[name] = variableName[name];
        });
        return function () {
            Object.keys(variableName).forEach(function (name) {
                _reset__(variableName);
            });
        };
    } else {
        if (value === undefined) {
            rewireData[variableName] = INTENTIONAL_UNDEFINED;
        } else {
            rewireData[variableName] = value;
        }

        return function () {
            _reset__(variableName);
        };
    }
}

function _reset__(variableName) {
    var rewireData = _getRewiredData__();

    delete rewireData[variableName];

    if (Object.keys(rewireData).length == 0) {
        delete _getRewireRegistry__()[_getRewireModuleId__];
    }

    ;
}

function _with__(object) {
    var rewireData = _getRewiredData__();

    var rewiredVariableNames = Object.keys(object);
    var previousValues = {};

    function reset() {
        rewiredVariableNames.forEach(function (variableName) {
            rewireData[variableName] = previousValues[variableName];
        });
    }

    return function (callback) {
        rewiredVariableNames.forEach(function (variableName) {
            previousValues[variableName] = rewireData[variableName];
            rewireData[variableName] = object[variableName];
        });
        var result = callback();

        if (!!result && typeof result.then == 'function') {
            result.then(reset).catch(reset);
        } else {
            reset();
        }

        return result;
    };
}

var _typeOfOriginalExport = typeof Wrapper === 'undefined' ? 'undefined' : _typeof(Wrapper);

function addNonEnumerableProperty(name, value) {
    Object.defineProperty(Wrapper, name, {
        value: value,
        enumerable: false,
        configurable: true
    });
}

if ((_typeOfOriginalExport === 'object' || _typeOfOriginalExport === 'function') && Object.isExtensible(Wrapper)) {
    addNonEnumerableProperty('__get__', _get__);
    addNonEnumerableProperty('__GetDependency__', _get__);
    addNonEnumerableProperty('__Rewire__', _set__);
    addNonEnumerableProperty('__set__', _set__);
    addNonEnumerableProperty('__reset__', _reset__);
    addNonEnumerableProperty('__ResetDependency__', _reset__);
    addNonEnumerableProperty('__with__', _with__);
    addNonEnumerableProperty('__RewireAPI__', _RewireAPI__);
}

exports.__get__ = _get__;
exports.__GetDependency__ = _get__;
exports.__Rewire__ = _set__;
exports.__set__ = _set__;
exports.__ResetDependency__ = _reset__;
exports.__RewireAPI__ = _RewireAPI__;