calidation - npm Package Compare versions

Comparing version 1.13.1 to 1.14.0

dist/Form.js

@@ -1,300 +0,417 @@
-'use strict';
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(['exports', 'react', 'prop-types', 'invariant', './ValidatorsContext', './FormContext', './utilities'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(exports, require('react'), require('prop-types'), require('invariant'), require('./ValidatorsContext'), require('./FormContext'), require('./utilities'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod.exports, global.react, global.propTypes, global.invariant, global.ValidatorsContext, global.FormContext, global.utilities);
+        global.Form = mod.exports;
+    }
+})(this, function (exports, _react, _propTypes, _invariant, _ValidatorsContext, _FormContext, _utilities) {
+    'use strict';
 
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
 
-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"); } }; }();
+    var _react2 = _interopRequireDefault(_react);
 
-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 _invariant2 = _interopRequireDefault(_invariant);
 
-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 _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
 
-var _react = require('react');
+    function _objectWithoutProperties(obj, keys) {
+        var target = {};
 
-var _react2 = _interopRequireDefault(_react);
+        for (var i in obj) {
+            if (keys.indexOf(i) >= 0) continue;
+            if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
+            target[i] = obj[i];
+        }
 
-var _propTypes = require('prop-types');
+        return target;
+    }
 
-var _invariant = require('invariant');
+    var _slicedToArray = function () {
+        function sliceIterator(arr, i) {
+            var _arr = [];
+            var _n = true;
+            var _d = false;
+            var _e = undefined;
 
-var _invariant2 = _interopRequireDefault(_invariant);
+            try {
+                for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+                    _arr.push(_s.value);
 
-var _ValidatorsContext = require('./ValidatorsContext');
+                    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;
+                }
+            }
 
-var _FormContext = require('./FormContext');
+            return _arr;
+        }
 
-var _utilities = require('./utilities');
+        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");
+            }
+        };
+    }();
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+    var _extends = Object.assign || function (target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
 
-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; }
+            for (var key in source) {
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
 
-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; }
+        return target;
+    };
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+    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;
+        }
 
-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; }
+        return obj;
+    }
 
-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 _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+        }
+    }
 
-var propTypes = {
-    onChange: _propTypes.func,
-    onSubmit: _propTypes.func,
-    onReset: _propTypes.func
-};
+    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);
+            }
+        }
 
-var Form = function (_Component) {
-    _inherits(Form, _Component);
+        return function (Constructor, protoProps, staticProps) {
+            if (protoProps) defineProperties(Constructor.prototype, protoProps);
+            if (staticProps) defineProperties(Constructor, staticProps);
+            return Constructor;
+        };
+    }();
 
-    function Form() {
-        var _ref;
+    function _possibleConstructorReturn(self, call) {
+        if (!self) {
+            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        }
 
-        var _temp, _this, _ret;
+        return call && (typeof call === "object" || typeof call === "function") ? call : self;
+    }
 
-        _classCallCheck(this, Form);
-
-        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
+    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);
         }
 
-        return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Form.__proto__ || Object.getPrototypeOf(Form)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
-            config: {},
-            dirty: {},
-            errors: {},
-            fields: {},
-            submitted: false
-        }, _this.initialValues = {}, _this.transforms = {}, _this.onChange = function (e) {
-            _this.props.onChange(e);
+        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;
+    }
 
-            var _e$target = e.target,
-                checked = _e$target.checked,
-                name = _e$target.name,
-                type = _e$target.type,
-                value = _e$target.value;
+    var propTypes = {
+        onChange: _propTypes.func,
+        onSubmit: _propTypes.func,
+        onReset: _propTypes.func
+    };
 
+    var Form = function (_Component) {
+        _inherits(Form, _Component);
 
-            if (!_this.state.config[name]) {
-                return;
-            }
+        function Form() {
+            var _ref;
 
-            var val = type === 'checkbox' ? checked : value;
+            var _temp, _this, _ret;
 
-            if (typeof _this.transforms[name] === 'function') {
-                val = _this.transforms[name](val);
-            }
+            _classCallCheck(this, Form);
 
-            _this.setField(_defineProperty({}, name, val));
-        }, _this.onReset = function (e) {
-            if (e) {
-                e.preventDefault();
+            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
             }
 
-            var _this$state = _this.state,
-                dirty = _this$state.dirty,
-                errors = _this$state.errors,
-                fields = _this$state.fields;
+            return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Form.__proto__ || Object.getPrototypeOf(Form)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
+                config: {},
+                dirty: {},
+                errors: {},
+                fields: {},
+                submitted: false
+            }, _this.initialValues = {}, _this.transforms = {}, _this.onChange = function (e) {
+                _this.props.onChange(e);
 
+                var _e$target = e.target,
+                    checked = _e$target.checked,
+                    name = _e$target.name,
+                    type = _e$target.type,
+                    value = _e$target.value;
 
-            _this.setState({
-                dirty: Object.keys(dirty).reduce(function (allDirty, field) {
-                    return _extends({}, allDirty, _defineProperty({}, field, false));
-                }, {}),
-                errors: Object.keys(errors).reduce(function (allErrors, field) {
-                    return _extends({}, allErrors, _defineProperty({}, field, null));
-                }, {}),
-                fields: Object.keys(fields).reduce(function (allFields, field) {
-                    return _extends({}, allFields, _defineProperty({}, field, _this.initialValues[field]));
-                }, {}),
-                submitted: false
-            });
 
-            _this.props.onReset();
-        }, _this.onSubmit = function (e) {
-            if (e) {
-                e.preventDefault();
-            }
+                if (!_this.state.config[name]) {
+                    return;
+                }
 
-            var _this$state2 = _this.state,
-                dirty = _this$state2.dirty,
-                errors = _this$state2.errors,
-                fields = _this$state2.fields;
+                var val = type === 'checkbox' ? checked : value;
 
+                if (typeof _this.transforms[name] === 'function') {
+                    val = _this.transforms[name](val);
+                }
 
-            _this.setState({ submitted: true });
+                _this.setField(_defineProperty({}, name, val));
+            }, _this.onReset = function (e) {
+                if (e) {
+                    e.preventDefault();
+                }
 
-            _this.props.onSubmit({
-                dirty: dirty,
-                errors: errors,
-                fields: fields,
-                isValid: Object.values(errors).every(function (error) {
-                    return error === null;
-                }),
-                resetAll: _this.onReset,
-                setError: _this.setError
-            });
-        }, _this.setField = function (diff) {
-            var _this$state3 = _this.state,
-                config = _this$state3.config,
-                dirty = _this$state3.dirty,
-                fields = _this$state3.fields;
+                var _this$state = _this.state,
+                    dirty = _this$state.dirty,
+                    errors = _this$state.errors,
+                    fields = _this$state.fields;
 
-            var allFields = _extends({}, fields, diff);
-            var areDirty = _extends({}, dirty, Object.keys(diff).reduce(function (allDirty, field) {
-                return _extends({}, allDirty, _defineProperty({}, field, dirty[field] || diff[field] !== _this.initialValues[field]));
-            }, {}));
 
-            _this.setState({
-                dirty: areDirty,
-                errors: _this.validate(config, allFields, areDirty),
-                fields: allFields,
-                submitted: false
-            });
-        }, _this.setError = function (diff) {
-            _this.setState({
-                errors: _extends({}, _this.state.errors, diff),
-                submitted: false
-            });
-        }, _this.validate = function (allConfig, allFields, areDirty) {
-            return Object.entries(allConfig).reduce(function (allErrors, _ref2) {
-                var _ref3 = _slicedToArray(_ref2, 2),
-                    fieldName = _ref3[0],
-                    fieldValidators = _ref3[1];
+                _this.setState({
+                    dirty: Object.keys(dirty).reduce(function (allDirty, field) {
+                        return _extends({}, allDirty, _defineProperty({}, field, false));
+                    }, {}),
+                    errors: Object.keys(errors).reduce(function (allErrors, field) {
+                        return _extends({}, allErrors, _defineProperty({}, field, null));
+                    }, {}),
+                    fields: Object.keys(fields).reduce(function (allFields, field) {
+                        return _extends({}, allFields, _defineProperty({}, field, _this.initialValues[field]));
+                    }, {}),
+                    submitted: false
+                });
 
-                return _extends({}, allErrors, _defineProperty({}, fieldName, _this.validateField(fieldName, fieldValidators, allFields, allErrors, areDirty)));
-            }, {});
-        }, _this.validateField = function (fieldName, fieldValidators, allFields, allErrors, areDirty) {
-            return Object.entries(fieldValidators).reduce(function (error, _ref4) {
-                var _ref5 = _slicedToArray(_ref4, 2),
-                    validatorName = _ref5[0],
-                    validatorConfig = _ref5[1];
-
-                if (error) {
-                    return error;
+                _this.props.onReset();
+            }, _this.onSubmit = function (e) {
+                if (e) {
+                    e.preventDefault();
                 }
 
-                var validator = _this.props.validators[validatorName];
+                var _this$state2 = _this.state,
+                    dirty = _this$state2.dirty,
+                    errors = _this$state2.errors,
+                    fields = _this$state2.fields;
 
-                (0, _invariant2.default)(validator, "You specified a validator that doesn't exist. You " + ('specified ' + validatorName + '. Available validators: \n\n') + Object.keys(_this.props.validators).join(',\n'));
 
-                var context = {
+                _this.setState({ submitted: true });
+
+                _this.props.onSubmit({
+                    dirty: dirty,
+                    errors: errors,
+                    fields: fields,
+                    isValid: Object.values(errors).every(function (error) {
+                        return error === null;
+                    }),
+                    resetAll: _this.onReset,
+                    setError: _this.setError
+                });
+            }, _this.setField = function (diff) {
+                var _this$state3 = _this.state,
+                    config = _this$state3.config,
+                    dirty = _this$state3.dirty,
+                    fields = _this$state3.fields;
+
+                var allFields = _extends({}, fields, diff);
+                var areDirty = _extends({}, dirty, Object.keys(diff).reduce(function (allDirty, field) {
+                    return _extends({}, allDirty, _defineProperty({}, field, dirty[field] || diff[field] !== _this.initialValues[field]));
+                }, {}));
+
+                _this.setState({
+                    dirty: areDirty,
+                    errors: _this.validate(config, allFields, areDirty),
                     fields: allFields,
-                    errors: _extends({}, _this.state.errors, allErrors),
-                    isDirty: areDirty[fieldName]
-                };
+                    submitted: false
+                });
+            }, _this.setError = function (diff) {
+                _this.setState({
+                    errors: _extends({}, _this.state.errors, diff),
+                    submitted: false
+                });
+            }, _this.validate = function (allConfig, allFields, areDirty) {
+                return Object.entries(allConfig).reduce(function (allErrors, _ref2) {
+                    var _ref3 = _slicedToArray(_ref2, 2),
+                        fieldName = _ref3[0],
+                        fieldValidators = _ref3[1];
 
-                if (typeof validatorConfig === 'function') {
-                    validatorConfig = validatorConfig(context);
-                }
+                    return _extends({}, allErrors, _defineProperty({}, fieldName, _this.validateField(fieldName, fieldValidators, allFields, allErrors, areDirty)));
+                }, {});
+            }, _this.validateField = function (fieldName, fieldValidators, allFields, allErrors, areDirty) {
+                return Object.entries(fieldValidators).reduce(function (error, _ref4) {
+                    var _ref5 = _slicedToArray(_ref4, 2),
+                        validatorName = _ref5[0],
+                        validatorConfig = _ref5[1];
 
-                if (typeof validatorConfig === 'string') {
-                    validatorConfig = { message: validatorConfig };
-                }
+                    if (error) {
+                        return error;
+                    }
 
-                if (typeof validatorConfig.validateIf === 'function' && !validatorConfig.validateIf(context) || typeof validatorConfig.validateIf === 'boolean' && !validatorConfig.validateIf) {
-                    return null;
-                }
+                    var validator = _this.props.validators[validatorName];
 
-                return validator(validatorConfig, context)(allFields[fieldName]);
-            }, null);
-        }, _this.registerSubComponent = function (subComponentConfig, transforms, initialValues) {
-            _this.initialValues = _extends({}, _this.initialValues, initialValues);
-            _this.transforms = _extends({}, _this.transforms, transforms);
+                    (0, _invariant2.default)(validator, "You specified a validator that doesn't exist. You " + ('specified ' + validatorName + '. Available validators: \n\n') + Object.keys(_this.props.validators).join(',\n'));
 
-            _this.setState(function (prevState) {
-                var config = _extends({}, prevState.config, subComponentConfig);
-                var dirty = _extends({}, prevState.dirty, Object.keys(subComponentConfig).reduce(function (allDirty, field) {
-                    return _extends({}, allDirty, _defineProperty({}, field, false));
-                }, {}));
-                var fields = _extends({}, prevState.fields, initialValues);
+                    var context = {
+                        fields: allFields,
+                        errors: _extends({}, _this.state.errors, allErrors),
+                        isDirty: areDirty[fieldName]
+                    };
 
-                return {
-                    config: config,
-                    dirty: dirty,
-                    errors: _this.validate(config, fields, dirty),
-                    fields: fields
-                };
-            });
-        }, _this.unregisterSubComponent = function (subComponentConfig) {
-            var keys = Object.keys(subComponentConfig);
+                    if (typeof validatorConfig === 'function') {
+                        validatorConfig = validatorConfig(context);
+                    }
 
-            _this.initialValues = (0, _utilities.removeFrom)(_this.initialValues)(keys);
-            _this.transforms = (0, _utilities.removeFrom)(_this.transforms)(keys);
+                    if (typeof validatorConfig === 'string') {
+                        validatorConfig = { message: validatorConfig };
+                    }
 
-            _this.setState(function (prevState) {
-                var config = (0, _utilities.removeFrom)(prevState.config)(keys);
-                var dirty = (0, _utilities.removeFrom)(prevState.dirty)(keys);
-                var fields = (0, _utilities.removeFrom)(prevState.fields)(keys);
+                    if (typeof validatorConfig.validateIf === 'function' && !validatorConfig.validateIf(context) || typeof validatorConfig.validateIf === 'boolean' && !validatorConfig.validateIf) {
+                        return null;
+                    }
 
-                return {
-                    config: config,
-                    dirty: dirty,
-                    errors: _this.validate(config, fields, dirty),
-                    fields: fields
-                };
-            });
-        }, _temp), _possibleConstructorReturn(_this, _ret);
-    }
+                    return validator(validatorConfig, context)(allFields[fieldName]);
+                }, null);
+            }, _this.registerSubComponent = function (subComponentConfig, transforms, initialValues) {
+                _this.initialValues = _extends({}, _this.initialValues, initialValues);
+                _this.transforms = _extends({}, _this.transforms, transforms);
 
-    _createClass(Form, [{
-        key: 'render',
-        value: function render() {
-            var _props = this.props,
-                children = _props.children,
-                onSubmit = _props.onSubmit,
-                rest = _objectWithoutProperties(_props, ['children', 'onSubmit']);
+                _this.setState(function (prevState) {
+                    var config = _extends({}, prevState.config, subComponentConfig);
+                    var dirty = _extends({}, prevState.dirty, Object.keys(subComponentConfig).reduce(function (allDirty, field) {
+                        return _extends({}, allDirty, _defineProperty({}, field, false));
+                    }, {}));
+                    var fields = _extends({}, prevState.fields, initialValues);
 
-            var _state = this.state,
-                dirty = _state.dirty,
-                errors = _state.errors,
-                fields = _state.fields,
-                submitted = _state.submitted;
+                    return {
+                        config: config,
+                        dirty: dirty,
+                        errors: _this.validate(config, fields, dirty),
+                        fields: fields
+                    };
+                });
+            }, _this.unregisterSubComponent = function (subComponentConfig) {
+                var keys = Object.keys(subComponentConfig);
 
-            var formContext = {
-                dirty: dirty,
-                errors: errors,
-                fields: fields,
-                register: this.registerSubComponent,
-                resetAll: this.onReset,
-                setError: this.setError,
-                setField: this.setField,
-                submit: this.onSubmit,
-                submitted: submitted,
-                unregister: this.unregisterSubComponent
-            };
+                _this.initialValues = (0, _utilities.removeFrom)(_this.initialValues)(keys);
+                _this.transforms = (0, _utilities.removeFrom)(_this.transforms)(keys);
 
-            return _react2.default.createElement(
-                'form',
-                _extends({}, rest, {
-                    onChange: this.onChange,
-                    onSubmit: this.onSubmit,
-                    onReset: this.onReset
-                }),
-                _react2.default.createElement(
-                    _FormContext.FormProvider,
-                    { value: formContext },
-                    children
-                )
-            );
+                _this.setState(function (prevState) {
+                    var config = (0, _utilities.removeFrom)(prevState.config)(keys);
+                    var dirty = (0, _utilities.removeFrom)(prevState.dirty)(keys);
+                    var fields = (0, _utilities.removeFrom)(prevState.fields)(keys);
+
+                    return {
+                        config: config,
+                        dirty: dirty,
+                        errors: _this.validate(config, fields, dirty),
+                        fields: fields
+                    };
+                });
+            }, _temp), _possibleConstructorReturn(_this, _ret);
         }
-    }]);
 
-    return Form;
-}(_react.Component);
+        _createClass(Form, [{
+            key: 'render',
+            value: function render() {
+                var _props = this.props,
+                    children = _props.children,
+                    onSubmit = _props.onSubmit,
+                    rest = _objectWithoutProperties(_props, ['children', 'onSubmit']);
 
-Form.defaultProps = {
-    onChange: function onChange(e) {},
-    onSubmit: function onSubmit(c) {},
-    onReset: function onReset() {}
-};
-Form.propTypes = _extends({}, propTypes, {
-    // ValidatorsContext
-    validators: (0, _propTypes.shape)({}).isRequired
-});
+                var _state = this.state,
+                    dirty = _state.dirty,
+                    errors = _state.errors,
+                    fields = _state.fields,
+                    submitted = _state.submitted;
 
+                var formContext = {
+                    dirty: dirty,
+                    errors: errors,
+                    fields: fields,
+                    register: this.registerSubComponent,
+                    resetAll: this.onReset,
+                    setError: this.setError,
+                    setField: this.setField,
+                    submit: this.onSubmit,
+                    submitted: submitted,
+                    unregister: this.unregisterSubComponent
+                };
 
-var FormWithValidatorsContext = (0, _ValidatorsContext.withValidators)(Form);
+                return _react2.default.createElement(
+                    'form',
+                    _extends({}, rest, {
+                        onChange: this.onChange,
+                        onSubmit: this.onSubmit,
+                        onReset: this.onReset
+                    }),
+                    _react2.default.createElement(
+                        _FormContext.FormProvider,
+                        { value: formContext },
+                        children
+                    )
+                );
+            }
+        }]);
 
-FormWithValidatorsContext.propTypes = propTypes;
+        return Form;
+    }(_react.Component);
 
-exports.default = FormWithValidatorsContext;
+    Form.defaultProps = {
+        onChange: function onChange(e) {},
+        onSubmit: function onSubmit(c) {},
+        onReset: function onReset() {}
+    };
+    Form.propTypes = _extends({}, propTypes, {
+        // ValidatorsContext
+        validators: (0, _propTypes.shape)({}).isRequired
+    });
+
+
+    var FormWithValidatorsContext = (0, _ValidatorsContext.withValidators)(Form);
+
+    FormWithValidatorsContext.propTypes = propTypes;
+
+    exports.default = FormWithValidatorsContext;
+});

dist/FormContext.js

@@ -1,38 +0,66 @@
-'use strict';
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(['exports', 'react'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(exports, require('react'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod.exports, global.react);
+        global.FormContext = mod.exports;
+    }
+})(this, function (exports, _react) {
+    'use strict';
 
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.withFormContext = exports.FormConsumer = exports.FormProvider = undefined;
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    exports.withFormContext = exports.FormConsumer = exports.FormProvider = undefined;
 
-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 _react2 = _interopRequireDefault(_react);
 
-var _react = require('react');
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
 
-var _react2 = _interopRequireDefault(_react);
+    var _extends = Object.assign || function (target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+            for (var key in source) {
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
 
-var _createContext = (0, _react.createContext)({}),
-    Consumer = _createContext.Consumer,
-    Provider = _createContext.Provider;
+        return target;
+    };
 
-var FormProvider = exports.FormProvider = Provider;
-var FormConsumer = exports.FormConsumer = Consumer;
+    var _createContext = (0, _react.createContext)({}),
+        Consumer = _createContext.Consumer,
+        Provider = _createContext.Provider;
 
-var withFormContext = exports.withFormContext = function withFormContext(TargetComponent) {
-    var WithFormContext = function WithFormContext(props) {
-        return _react2.default.createElement(
-            Consumer,
-            null,
-            function (formContext) {
-                return _react2.default.createElement(TargetComponent, _extends({}, props, formContext));
-            }
-        );
-    };
-    var targetName = TargetComponent.displayName || TargetComponent.name;
+    var FormProvider = exports.FormProvider = Provider;
+    var FormConsumer = exports.FormConsumer = Consumer;
 
-    WithFormContext.displayName = 'withFormContext(' + targetName + ')';
+    var withFormContext = exports.withFormContext = function withFormContext(TargetComponent) {
+        var WithFormContext = function WithFormContext(props) {
+            return _react2.default.createElement(
+                Consumer,
+                null,
+                function (formContext) {
+                    return _react2.default.createElement(TargetComponent, _extends({}, props, formContext));
+                }
+            );
+        };
+        var targetName = TargetComponent.displayName || TargetComponent.name;
 
-    return WithFormContext;
-};
+        WithFormContext.displayName = 'withFormContext(' + targetName + ')';
+
+        return WithFormContext;
+    };
+});

dist/FormValidation.js

@@ -1,49 +0,83 @@
-'use strict';
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(['exports', 'react', './Form', './Validation'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(exports, require('react'), require('./Form'), require('./Validation'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod.exports, global.react, global.Form, global.Validation);
+        global.FormValidation = mod.exports;
+    }
+})(this, function (exports, _react, _Form, _Validation) {
+    'use strict';
 
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
+    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 _react2 = _interopRequireDefault(_react);
 
-var _react = require('react');
+    var _Form2 = _interopRequireDefault(_Form);
 
-var _react2 = _interopRequireDefault(_react);
+    var _Validation2 = _interopRequireDefault(_Validation);
 
-var _Form = require('./Form');
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
 
-var _Form2 = _interopRequireDefault(_Form);
+    var _extends = Object.assign || function (target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
 
-var _Validation = require('./Validation');
+            for (var key in source) {
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
 
-var _Validation2 = _interopRequireDefault(_Validation);
+        return target;
+    };
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+    function _objectWithoutProperties(obj, keys) {
+        var target = {};
 
-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; }
+        for (var i in obj) {
+            if (keys.indexOf(i) >= 0) continue;
+            if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
+            target[i] = obj[i];
+        }
 
-var FormValidation = function FormValidation(props) {
-    var children = props.children,
-        config = props.config,
-        initialValues = props.initialValues,
-        transforms = props.transforms,
-        rest = _objectWithoutProperties(props, ['children', 'config', 'initialValues', 'transforms']);
+        return target;
+    }
 
-    return _react2.default.createElement(
-        _Form2.default,
-        rest,
-        _react2.default.createElement(
-            _Validation2.default,
-            {
-                config: config,
-                initialValues: initialValues,
-                transforms: transforms
-            },
-            children
-        )
-    );
-};
+    var FormValidation = function FormValidation(props) {
+        var children = props.children,
+            config = props.config,
+            initialValues = props.initialValues,
+            transforms = props.transforms,
+            rest = _objectWithoutProperties(props, ['children', 'config', 'initialValues', 'transforms']);
 
-FormValidation.propTypes = _extends({}, _Form2.default.propTypes, _Validation2.default.propTypes);
+        return _react2.default.createElement(
+            _Form2.default,
+            rest,
+            _react2.default.createElement(
+                _Validation2.default,
+                {
+                    config: config,
+                    initialValues: initialValues,
+                    transforms: transforms
+                },
+                children
+            )
+        );
+    };
 
-exports.default = FormValidation;
+    FormValidation.propTypes = _extends({}, _Form2.default.propTypes, _Validation2.default.propTypes);
+
+    exports.default = FormValidation;
+});

dist/index.js

@@ -1,27 +0,37 @@
-'use strict';
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(['exports', './Form', './Validation', './FormValidation', './ValidatorsContext'], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require('./Form'), require('./Validation'), require('./FormValidation'), require('./ValidatorsContext'));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.Form, global.Validation, global.FormValidation, global.ValidatorsContext);
+    global.index = mod.exports;
+  }
+})(this, function (exports, _Form, _Validation, _FormValidation, _ValidatorsContext) {
+  'use strict';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ValidatorsProvider = exports.FormValidation = exports.Validation = exports.Form = undefined;
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.ValidatorsProvider = exports.FormValidation = exports.Validation = exports.Form = undefined;
 
-var _Form = require('./Form');
+  var _Form2 = _interopRequireDefault(_Form);
 
-var _Form2 = _interopRequireDefault(_Form);
+  var _Validation2 = _interopRequireDefault(_Validation);
 
-var _Validation = require('./Validation');
+  var _FormValidation2 = _interopRequireDefault(_FormValidation);
 
-var _Validation2 = _interopRequireDefault(_Validation);
+  function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+      default: obj
+    };
+  }
 
-var _FormValidation = require('./FormValidation');
-
-var _FormValidation2 = _interopRequireDefault(_FormValidation);
-
-var _ValidatorsContext = require('./ValidatorsContext');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-exports.Form = _Form2.default;
-exports.Validation = _Validation2.default;
-exports.FormValidation = _FormValidation2.default;
-exports.ValidatorsProvider = _ValidatorsContext.ValidatorsProvider;
+  exports.Form = _Form2.default;
+  exports.Validation = _Validation2.default;
+  exports.FormValidation = _FormValidation2.default;
+  exports.ValidatorsProvider = _ValidatorsContext.ValidatorsProvider;
+});

dist/utilities.js

@@ -1,33 +0,108 @@
-"use strict";
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(["exports"], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(exports);
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod.exports);
+        global.utilities = mod.exports;
+    }
+})(this, function (exports) {
+    "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
+    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; };
+    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;
+        }
 
-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"); } }; }();
+        return obj;
+    }
 
-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; }
+    var _extends = Object.assign || function (target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
 
-var getFirstDefinedValue = exports.getFirstDefinedValue = function getFirstDefinedValue() {
-    for (var _len = arguments.length, values = Array(_len), _key = 0; _key < _len; _key++) {
-        values[_key] = arguments[_key];
-    }
+            for (var key in source) {
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
 
-    return values.find(function (value) {
-        return value !== undefined;
-    });
-};
+        return target;
+    };
 
-var removeFrom = exports.removeFrom = function removeFrom(original) {
-    return function (keysToRemove) {
-        return Object.entries(original).reduce(function (obj, _ref) {
-            var _ref2 = _slicedToArray(_ref, 2),
-                key = _ref2[0],
-                value = _ref2[1];
+    var _slicedToArray = function () {
+        function sliceIterator(arr, i) {
+            var _arr = [];
+            var _n = true;
+            var _d = false;
+            var _e = undefined;
 
-            return _extends({}, obj, !keysToRemove.includes(key) ? _defineProperty({}, key, value) : {});
-        }, {});
+            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");
+            }
+        };
+    }();
+
+    var getFirstDefinedValue = exports.getFirstDefinedValue = function getFirstDefinedValue() {
+        for (var _len = arguments.length, values = Array(_len), _key = 0; _key < _len; _key++) {
+            values[_key] = arguments[_key];
+        }
+
+        return values.find(function (value) {
+            return value !== undefined;
+        });
     };
-};
+
+    var removeFrom = exports.removeFrom = function removeFrom(original) {
+        return function (keysToRemove) {
+            return Object.entries(original).reduce(function (obj, _ref) {
+                var _ref2 = _slicedToArray(_ref, 2),
+                    key = _ref2[0],
+                    value = _ref2[1];
+
+                return _extends({}, obj, !keysToRemove.includes(key) ? _defineProperty({}, key, value) : {});
+            }, {});
+        };
+    };
+});

dist/Validation.js

@@ -1,143 +0,218 @@
-'use strict';
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(['exports', 'react', 'prop-types', './FormContext', './utilities'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(exports, require('react'), require('prop-types'), require('./FormContext'), require('./utilities'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod.exports, global.react, global.propTypes, global.FormContext, global.utilities);
+        global.Validation = mod.exports;
+    }
+})(this, function (exports, _react, _propTypes, _FormContext, _utilities) {
+    'use strict';
 
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
+    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 _react2 = _interopRequireDefault(_react);
 
-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 _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
 
-var _react = require('react');
+    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;
+        }
 
-var _react2 = _interopRequireDefault(_react);
+        return obj;
+    }
 
-var _propTypes = require('prop-types');
+    var _extends = Object.assign || function (target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
 
-var _FormContext = require('./FormContext');
+            for (var key in source) {
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
 
-var _utilities = require('./utilities');
+        return target;
+    };
 
-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 _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; }
+    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);
+            }
+        }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+        return function (Constructor, protoProps, staticProps) {
+            if (protoProps) defineProperties(Constructor.prototype, protoProps);
+            if (staticProps) defineProperties(Constructor, staticProps);
+            return Constructor;
+        };
+    }();
 
-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 _possibleConstructorReturn(self, call) {
+        if (!self) {
+            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        }
 
-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; }
+        return call && (typeof call === "object" || typeof call === "function") ? call : self;
+    }
 
-var propTypes = {
-    children: _propTypes.func.isRequired,
-    config: (0, _propTypes.shape)({}).isRequired,
-    initialValues: (0, _propTypes.shape)({}),
-    transforms: (0, _propTypes.shape)({})
-};
+    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);
+        }
 
-var Validation = function (_Component) {
-    _inherits(Validation, _Component);
+        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 Validation() {
-        var _ref;
+    var propTypes = {
+        children: _propTypes.func.isRequired,
+        config: (0, _propTypes.shape)({}).isRequired,
+        initialValues: (0, _propTypes.shape)({}),
+        transforms: (0, _propTypes.shape)({})
+    };
 
-        var _temp, _this, _ret;
+    var Validation = function (_Component) {
+        _inherits(Validation, _Component);
 
-        _classCallCheck(this, Validation);
+        function Validation() {
+            var _ref;
 
-        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
+            var _temp, _this, _ret;
+
+            _classCallCheck(this, Validation);
+
+            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+            }
+
+            return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Validation.__proto__ || Object.getPrototypeOf(Validation)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
+                isRegistered: false
+            }, _temp), _possibleConstructorReturn(_this, _ret);
         }
 
-        return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Validation.__proto__ || Object.getPrototypeOf(Validation)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
-            isRegistered: false
-        }, _temp), _possibleConstructorReturn(_this, _ret);
-    }
+        _createClass(Validation, [{
+            key: 'componentDidMount',
+            value: function componentDidMount() {
+                var _props = this.props,
+                    config = _props.config,
+                    initialValues = _props.initialValues,
+                    register = _props.register,
+                    transforms = _props.transforms;
 
-    _createClass(Validation, [{
-        key: 'componentDidMount',
-        value: function componentDidMount() {
-            var _props = this.props,
-                config = _props.config,
-                initialValues = _props.initialValues,
-                register = _props.register,
-                transforms = _props.transforms;
 
+                register(config, transforms, Object.keys(config).reduce(function (allFields, field) {
+                    var value = (0, _utilities.getFirstDefinedValue)(initialValues[field], '');
 
-            register(config, transforms, Object.keys(config).reduce(function (allFields, field) {
-                var value = (0, _utilities.getFirstDefinedValue)(initialValues[field], '');
+                    if (typeof transforms[field] === 'function') {
+                        value = transforms[field](value);
+                    }
 
-                if (typeof transforms[field] === 'function') {
-                    value = transforms[field](value);
-                }
+                    return _extends({}, allFields, _defineProperty({}, field, value));
+                }, {}));
 
-                return _extends({}, allFields, _defineProperty({}, field, value));
-            }, {}));
+                this.setState({ isRegistered: true });
+            }
+        }, {
+            key: 'componentWillUnmount',
+            value: function componentWillUnmount() {
+                this.props.unregister(this.props.config);
 
-            this.setState({ isRegistered: true });
-        }
-    }, {
-        key: 'componentWillUnmount',
-        value: function componentWillUnmount() {
-            this.props.unregister(this.props.config);
+                this.setState({ isRegistered: false });
+            }
+        }, {
+            key: 'render',
+            value: function render() {
+                var _props2 = this.props,
+                    children = _props2.children,
+                    dirty = _props2.dirty,
+                    errors = _props2.errors,
+                    fields = _props2.fields,
+                    resetAll = _props2.resetAll,
+                    setError = _props2.setError,
+                    setField = _props2.setField,
+                    submit = _props2.submit,
+                    submitted = _props2.submitted;
 
-            this.setState({ isRegistered: false });
-        }
-    }, {
-        key: 'render',
-        value: function render() {
-            var _props2 = this.props,
-                children = _props2.children,
-                dirty = _props2.dirty,
-                errors = _props2.errors,
-                fields = _props2.fields,
-                resetAll = _props2.resetAll,
-                setError = _props2.setError,
-                setField = _props2.setField,
-                submit = _props2.submit,
-                submitted = _props2.submitted;
+                var validationContext = {
+                    dirty: dirty,
+                    errors: errors,
+                    fields: fields,
+                    resetAll: resetAll,
+                    setError: setError,
+                    setField: setField,
+                    submit: submit,
+                    submitted: submitted
+                };
 
-            var validationContext = {
-                dirty: dirty,
-                errors: errors,
-                fields: fields,
-                resetAll: resetAll,
-                setError: setError,
-                setField: setField,
-                submit: submit,
-                submitted: submitted
-            };
+                return this.state.isRegistered ? children(validationContext) : null;
+            }
+        }]);
 
-            return this.state.isRegistered ? children(validationContext) : null;
-        }
-    }]);
+        return Validation;
+    }(_react.Component);
 
-    return Validation;
-}(_react.Component);
+    Validation.defaultProps = {
+        errors: {},
+        fields: {},
+        initialValues: {},
+        transforms: {}
+    };
+    Validation.propTypes = _extends({}, propTypes, {
+        // FormContext
+        dirty: (0, _propTypes.shape)({}),
+        errors: (0, _propTypes.shape)({}),
+        fields: (0, _propTypes.shape)({}),
+        register: _propTypes.func.isRequired,
+        resetAll: _propTypes.func.isRequired,
+        setError: _propTypes.func.isRequired,
+        setField: _propTypes.func.isRequired,
+        submit: _propTypes.func.isRequired,
+        submitted: _propTypes.bool,
+        unregister: _propTypes.func.isRequired
+    });
 
-Validation.defaultProps = {
-    errors: {},
-    fields: {},
-    initialValues: {},
-    transforms: {}
-};
-Validation.propTypes = _extends({}, propTypes, {
-    // FormContext
-    dirty: (0, _propTypes.shape)({}),
-    errors: (0, _propTypes.shape)({}),
-    fields: (0, _propTypes.shape)({}),
-    register: _propTypes.func.isRequired,
-    resetAll: _propTypes.func.isRequired,
-    setError: _propTypes.func.isRequired,
-    setField: _propTypes.func.isRequired,
-    submit: _propTypes.func.isRequired,
-    submitted: _propTypes.bool,
-    unregister: _propTypes.func.isRequired
-});
 
+    var ValidationWithFormContext = (0, _FormContext.withFormContext)(Validation);
 
-var ValidationWithFormContext = (0, _FormContext.withFormContext)(Validation);
+    ValidationWithFormContext.propTypes = propTypes;
 
-ValidationWithFormContext.propTypes = propTypes;
-
-exports.default = ValidationWithFormContext;
+    exports.default = ValidationWithFormContext;
+});

dist/ValidatorsContext.js

@@ -1,108 +0,172 @@
-'use strict';
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(['exports', 'react', 'prop-types', 'calidators'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(exports, require('react'), require('prop-types'), require('calidators'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod.exports, global.react, global.propTypes, global.calidators);
+        global.ValidatorsContext = mod.exports;
+    }
+})(this, function (exports, _react, _propTypes, _calidators) {
+    'use strict';
 
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.withValidators = exports.ValidatorsConsumer = exports.ValidatorsProvider = undefined;
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    exports.withValidators = exports.ValidatorsConsumer = exports.ValidatorsProvider = undefined;
 
-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 _react2 = _interopRequireDefault(_react);
 
-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 _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
 
-var _react = require('react');
+    var _extends = Object.assign || function (target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
 
-var _react2 = _interopRequireDefault(_react);
+            for (var key in source) {
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
 
-var _propTypes = require('prop-types');
+        return target;
+    };
 
-var _calidators = require('calidators');
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+        }
+    }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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);
+            }
+        }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+        return function (Constructor, protoProps, staticProps) {
+            if (protoProps) defineProperties(Constructor.prototype, protoProps);
+            if (staticProps) defineProperties(Constructor, staticProps);
+            return Constructor;
+        };
+    }();
 
-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 _possibleConstructorReturn(self, call) {
+        if (!self) {
+            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        }
 
-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; }
+        return call && (typeof call === "object" || typeof call === "function") ? call : self;
+    }
 
-var defaultValidators = {
-    isBlacklisted: _calidators.isBlacklisted,
-    isEmail: _calidators.isEmail,
-    isEqual: _calidators.isEqual,
-    isGreaterThan: _calidators.isGreaterThan,
-    isLessThan: _calidators.isLessThan,
-    isRequired: _calidators.isRequired,
-    isNumber: _calidators.isNumber,
-    isRegexMatch: _calidators.isRegexMatch,
-    isWhitelisted: _calidators.isWhitelisted,
-    isMinLength: _calidators.isMinLength,
-    isMaxLength: _calidators.isMaxLength,
-    isExactLength: _calidators.isExactLength
-};
+    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);
+        }
 
-var _createContext = (0, _react.createContext)({}),
-    Provider = _createContext.Provider,
-    Consumer = _createContext.Consumer;
+        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;
+    }
 
-var ValidatorsProvider = exports.ValidatorsProvider = function (_Component) {
-    _inherits(ValidatorsProvider, _Component);
+    var defaultValidators = {
+        isBlacklisted: _calidators.isBlacklisted,
+        isEmail: _calidators.isEmail,
+        isEqual: _calidators.isEqual,
+        isGreaterThan: _calidators.isGreaterThan,
+        isLessThan: _calidators.isLessThan,
+        isRequired: _calidators.isRequired,
+        isNumber: _calidators.isNumber,
+        isRegexMatch: _calidators.isRegexMatch,
+        isWhitelisted: _calidators.isWhitelisted,
+        isMinLength: _calidators.isMinLength,
+        isMaxLength: _calidators.isMaxLength,
+        isExactLength: _calidators.isExactLength
+    };
 
-    function ValidatorsProvider() {
-        var _ref;
+    var _createContext = (0, _react.createContext)({}),
+        Provider = _createContext.Provider,
+        Consumer = _createContext.Consumer;
 
-        var _temp, _this, _ret;
+    var ValidatorsProvider = exports.ValidatorsProvider = function (_Component) {
+        _inherits(ValidatorsProvider, _Component);
 
-        _classCallCheck(this, ValidatorsProvider);
+        function ValidatorsProvider() {
+            var _ref;
 
-        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-        }
+            var _temp, _this, _ret;
 
-        return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = ValidatorsProvider.__proto__ || Object.getPrototypeOf(ValidatorsProvider)).call.apply(_ref, [this].concat(args))), _this), _this.state = _extends({}, _this.props.validators), _temp), _possibleConstructorReturn(_this, _ret);
-    }
+            _classCallCheck(this, ValidatorsProvider);
 
-    _createClass(ValidatorsProvider, [{
-        key: 'render',
-        value: function render() {
-            return _react2.default.createElement(
-                Provider,
-                { value: this.state },
-                this.props.children
-            );
+            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+            }
+
+            return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = ValidatorsProvider.__proto__ || Object.getPrototypeOf(ValidatorsProvider)).call.apply(_ref, [this].concat(args))), _this), _this.state = _extends({}, _this.props.validators), _temp), _possibleConstructorReturn(_this, _ret);
         }
-    }], [{
-        key: 'getDerivedStateFromProps',
-        value: function getDerivedStateFromProps(nextProps) {
-            return nextProps.validators || null;
-        }
-    }]);
 
-    return ValidatorsProvider;
-}(_react.Component);
+        _createClass(ValidatorsProvider, [{
+            key: 'render',
+            value: function render() {
+                return _react2.default.createElement(
+                    Provider,
+                    { value: this.state },
+                    this.props.children
+                );
+            }
+        }], [{
+            key: 'getDerivedStateFromProps',
+            value: function getDerivedStateFromProps(nextProps) {
+                return nextProps.validators || null;
+            }
+        }]);
 
-ValidatorsProvider.defaultProps = {
-    validators: {}
-};
-ValidatorsProvider.propTypes = {
-    validators: (0, _propTypes.shape)({})
-};
-var ValidatorsConsumer = exports.ValidatorsConsumer = Consumer;
+        return ValidatorsProvider;
+    }(_react.Component);
 
-var withValidators = exports.withValidators = function withValidators(TargetComponent) {
-    var WithValidators = function WithValidators(props) {
-        return _react2.default.createElement(
-            Consumer,
-            null,
-            function (validators) {
-                return _react2.default.createElement(TargetComponent, _extends({}, props, {
-                    validators: _extends({}, defaultValidators, validators)
-                }));
-            }
-        );
+    ValidatorsProvider.defaultProps = {
+        validators: {}
     };
-    var targetName = TargetComponent.displayName || TargetComponent.name;
+    ValidatorsProvider.propTypes = {
+        validators: (0, _propTypes.shape)({})
+    };
+    var ValidatorsConsumer = exports.ValidatorsConsumer = Consumer;
 
-    WithValidators.displayName = 'withValidators(' + targetName + ')';
+    var withValidators = exports.withValidators = function withValidators(TargetComponent) {
+        var WithValidators = function WithValidators(props) {
+            return _react2.default.createElement(
+                Consumer,
+                null,
+                function (validators) {
+                    return _react2.default.createElement(TargetComponent, _extends({}, props, {
+                        validators: _extends({}, defaultValidators, validators)
+                    }));
+                }
+            );
+        };
+        var targetName = TargetComponent.displayName || TargetComponent.name;
 
-    return WithValidators;
-};
+        WithValidators.displayName = 'withValidators(' + targetName + ')';
+
+        return WithValidators;
+    };
+});

package.json

 {
   "name": "calidation",
-  "version": "1.13.1",
+  "version": "1.14.0",
   "description": "A red hot validation library for React",
@@ -30,2 +30,3 @@ "main": "dist/index.js",
     "babel-plugin-transform-class-properties": "^6.24.1",
+    "babel-plugin-transform-es2015-modules-umd": "^6.24.1",
     "babel-plugin-transform-object-rest-spread": "^6.26.0",
@@ -32,0 +33,0 @@ "babel-preset-env": "^1.6.1",

README.md

@@ -479,2 +479,4 @@ # calidation
 
+##### `transforms: object`
+
 The `transforms` object lets you apply transforms to the value before it
@@ -502,3 +504,3 @@ is stored and validated against. Each key should map to a field name and be a function
 
-##### `validators`
+##### `validators: object`
 
@@ -505,0 +507,0 @@ An object with functions according to the

No alert changes

Improved metrics

Total package byte prevSize

55412

increased by18.75%

Lines of code

913

increased by70.65%

Number of lines in readme file

534

increased by0.38%

Worsened metrics

Dev dependency count

19

increased by5.56%

No dependency changes