react-redux-form-validation/dist/validate.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
});

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 _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.arrayOf = arrayOf;
exports.minLength = minLength;
exports.maxLength = maxLength;
exports.contains = contains;
exports.default = validate;

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function arrayOf(val) {
    return Array.isArray(val) ? val : [val];
}
function minLength(min) {
    var error = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'min-length';

    return function (value) {
        return value && value.length >= min ? undefined : error;
    };
}
function maxLength(max) {
    var error = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'max-length';

    return function (value) {
        return value && value.length > max ? error : undefined;
    };
}
function contains(needle) {
    var error = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'contains';

    return function (value) {
        return value && value.includes(needle) ? undefined : error;
    };
}

var required = exports.required = _get__('minLength')(0, 'required');

var array = exports.array = function array(name, config) {
    var arrayValidator = function arrayValidator(values, props) {
        var arrayErrors = values.map(function (value) {
            return Object.entries(config).reduce(function (errors, _ref) {
                var _ref2 = _slicedToArray(_ref, 2),
                    field = _ref2[0],
                    allrules = _ref2[1];

                var fielderrors = _get__('arrayOf')(allrules).map(function (rule) {
                    return rule(value[field], props);
                }).filter(function (rule) {
                    return rule;
                });
                if (fielderrors.length === 0) {
                    return errors;
                }
                return _extends({}, errors, _defineProperty({}, field, fielderrors));
            }, {});
        }).map(function (element) {
            return Object.keys(element).length > 0 ? element : undefined;
        });

        return arrayErrors.every(function (element) {
            return element === undefined;
        }) ? undefined : arrayErrors;
    };

    arrayValidator.isArrayValidator = true;

    return arrayValidator;
};

var rules = exports.rules = {
    minLength: _get__('minLength'),
    maxLength: _get__('maxLength'),
    contains: _get__('contains'),
    required: _get__('required'),
    array: _get__('array')
};

function validate(config) {
    return function (values, props) {
        return Object.entries(config).map(function (_ref3) {
            var _ref4 = _slicedToArray(_ref3, 2),
                field = _ref4[0],
                allrules = _ref4[1];

            return {
                field: field,
                errors: allrules.isArrayValidator ? allrules(values[field], props) : _get__('arrayOf')(allrules).map(function (rule) {
                    return rule(values[field], props);
                }).filter(function (rule) {
                    return rule;
                })
            };
        }).filter(function (_ref5) {
            var errors = _ref5.errors;
            return errors && errors.length > 0;
        }).reduce(function (acc, _ref6) {
            var field = _ref6.field,
                errors = _ref6.errors;
            return _extends({}, acc, _defineProperty({}, field, errors));
        }, {});
    };
}

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

        case 'arrayOf':
            return arrayOf;

        case 'maxLength':
            return maxLength;

        case 'contains':
            return contains;

        case 'required':
            return required;

        case 'array':
            return array;
    }

    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 validate === 'undefined' ? 'undefined' : _typeof(validate);

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

if ((_typeOfOriginalExport === 'object' || _typeOfOriginalExport === 'function') && Object.isExtensible(validate)) {
    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__;