react-redux-form-validation/dist/feedback-summary.js

Custom validation with redux-forms

'use strict';

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

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

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 _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.DefaultListCreator = DefaultListCreator;
exports.DefaultElementCreator = DefaultElementCreator;
exports.getErrors = getErrors;
exports.feedbackSummaryFactory = feedbackSummaryFactory;

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

var _propTypes2 = _interopRequireDefault(_propTypes);

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

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 _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

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 DefaultListCreator(_ref) {
    var header = _ref.header,
        errors = _ref.errors;

    return _get__('React').createElement(
        'div',
        {
            role: 'alert',
            'aria-live': 'assertive',
            'aria-atomic': 'true',
            className: 'feedbacksummary',
            tabIndex: '-1'
        },
        _get__('React').createElement(
            'h3',
            null,
            header
        ),
        _get__('React').createElement(
            'ul',
            null,
            errors
        )
    );
}

_get__('DefaultListCreator').propTypes = {
    header: _get__('PT').oneOfType([_get__('PT').string, _get__('PT').node]).isRequired,
    errors: _get__('PT').arrayOf(_get__('PT').node).isRequired
};

function DefaultElementCreator(_ref2) {
    var name = _ref2.name,
        error = _ref2.error;

    return _get__('React').createElement(
        'li',
        { key: name + '-' + error },
        _get__('React').createElement(
            'a',
            { href: '#' + name },
            error
        )
    );
}

_get__('DefaultElementCreator').propTypes = {
    name: _get__('PT').string.isRequired,
    error: _get__('PT').string.isRequired
};

function isUsingFieldArray(namedErrors) {
    return Array.isArray(namedErrors.errors) && namedErrors.errors.length > 0 && typeof namedErrors.errors[0] !== 'string' && _get__('React').isValidElement(namedErrors.errors[0]) === false;
}

function getErrors(props) {
    var names = props.names,
        submittoken = props.submittoken,
        fields = _objectWithoutProperties(props, ['names', 'submittoken']);

    if (submittoken === null) {
        return null;
    }

    var formErrors = names.map(function (name) {
        return { name: name, errors: fields[name].meta.error };
    }).filter(function (_ref3) {
        var errors = _ref3.errors;
        return errors && errors.length > 0;
    }).reduce(function (acc, namedErrors) {
        if (_get__('isUsingFieldArray')(namedErrors)) {
            var suberrorsConfig = namedErrors.errors.map(function (suberrors, idx) {
                if (!suberrors) {
                    return [];
                }
                return Object.entries(suberrors).map(function (_ref4) {
                    var _ref5 = _slicedToArray(_ref4, 2),
                        subkey = _ref5[0],
                        suberror = _ref5[1];

                    return {
                        name: namedErrors.name + '[' + idx + '].' + subkey,
                        error: suberror
                    };
                });
            }).filter(function (suberrors) {
                return suberrors.length > 0;
            }).reduce(function (list, suberrors) {
                return [].concat(_toConsumableArray(list), _toConsumableArray(suberrors));
            }, []);

            return [].concat(_toConsumableArray(acc), _toConsumableArray(suberrorsConfig));
        } else if (Array.isArray(namedErrors.errors)) {
            return [].concat(_toConsumableArray(acc), [namedErrors.errors.map(function (error) {
                return {
                    name: namedErrors.name,
                    error: error
                };
            })[0]]);
        }
        return [].concat(_toConsumableArray(acc), [{ name: namedErrors.name, error: namedErrors.errors }]);
    }, []);

    if (formErrors.length === 0) {
        return null;
    }

    return formErrors;
}

function feedbackSummaryFactory() {
    var listCreator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _get__('DefaultListCreator');
    var elementCreator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _get__('DefaultElementCreator');

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

        function FeedbackSummary() {
            _classCallCheck(this, FeedbackSummary);

            return _possibleConstructorReturn(this, (FeedbackSummary.__proto__ || Object.getPrototypeOf(FeedbackSummary)).apply(this, arguments));
        }

        _createClass(FeedbackSummary, [{
            key: 'render',
            value: function render() {
                var errors = _get__('getErrors')(this.props);
                if (!errors) {
                    return null;
                }

                var errorElements = errors.map(elementCreator);
                return listCreator({ header: this.props.header, errors: errorElements });
            }
        }]);

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

    FeedbackSummary.defaultProps = {
        header: 'Errors'
    };
    FeedbackSummary.propTypes = {
        header: _get__('PT').node.isRequired
    };

    return FeedbackSummary;
}

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 'DefaultListCreator':
            return DefaultListCreator;

        case 'PT':
            return _propTypes2.default;

        case 'DefaultElementCreator':
            return DefaultElementCreator;

        case 'React':
            return _react2.default;

        case 'isUsingFieldArray':
            return isUsingFieldArray;

        case 'getErrors':
            return getErrors;

        case 'Component':
            return _react.Component;
    }

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

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