dev/node_modules/uview-ui/libs/util/async-validator.js

function _extends() {
	_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;
	};

	return _extends.apply(this, arguments);
}

/* eslint no-console:0 */
var formatRegExp = /%[sdj%]/g;
var warning = function warning() {}; // don't print warning message when in production env or node runtime

if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production' && typeof window !==
	'undefined' && typeof document !== 'undefined') {
	warning = function warning(type, errors) {
		if (typeof console !== 'undefined' && console.warn) {
			if (errors.every(function(e) {
					return typeof e === 'string';
				})) {
				console.warn(type, errors);
			}
		}
	};
}

function convertFieldsError(errors) {
	if (!errors || !errors.length) return null;
	var fields = {};
	errors.forEach(function(error) {
		var field = error.field;
		fields[field] = fields[field] || [];
		fields[field].push(error);
	});
	return fields;
}

function format() {
	for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
	}

	var i = 1;
	var f = args[0];
	var len = args.length;

	if (typeof f === 'function') {
		return f.apply(null, args.slice(1));
	}

	if (typeof f === 'string') {
		var str = String(f).replace(formatRegExp, function(x) {
			if (x === '%%') {
				return '%';
			}

			if (i >= len) {
				return x;
			}

			switch (x) {
				case '%s':
					return String(args[i++]);

				case '%d':
					return Number(args[i++]);

				case '%j':
					try {
						return JSON.stringify(args[i++]);
					} catch (_) {
						return '[Circular]';
					}

					break;

				default:
					return x;
			}
		});

		for (var arg = args[i]; i < len; arg = args[++i]) {
			str += " " + arg;
		}

		return str;
	}

	return f;
}

function isNativeStringType(type) {
	return type === 'string' || type === 'url' || type === 'hex' || type === 'email' || type === 'pattern';
}

function isEmptyValue(value, type) {
	if (value === undefined || value === null) {
		return true;
	}

	if (type === 'array' && Array.isArray(value) && !value.length) {
		return true;
	}

	if (isNativeStringType(type) && typeof value === 'string' && !value) {
		return true;
	}

	return false;
}

function asyncParallelArray(arr, func, callback) {
	var results = [];
	var total = 0;
	var arrLength = arr.length;

	function count(errors) {
		results.push.apply(results, errors);
		total++;

		if (total === arrLength) {
			callback(results);
		}
	}

	arr.forEach(function(a) {
		func(a, count);
	});
}

function asyncSerialArray(arr, func, callback) {
	var index = 0;
	var arrLength = arr.length;

	function next(errors) {
		if (errors && errors.length) {
			callback(errors);
			return;
		}

		var original = index;
		index = index + 1;

		if (original < arrLength) {
			func(arr[original], next);
		} else {
			callback([]);
		}
	}

	next([]);
}

function flattenObjArr(objArr) {
	var ret = [];
	Object.keys(objArr).forEach(function(k) {
		ret.push.apply(ret, objArr[k]);
	});
	return ret;
}

function asyncMap(objArr, option, func, callback) {
	if (option.first) {
		var _pending = new Promise(function(resolve, reject) {
			var next = function next(errors) {
				callback(errors);
				return errors.length ? reject({
					errors: errors,
					fields: convertFieldsError(errors)
				}) : resolve();
			};

			var flattenArr = flattenObjArr(objArr);
			asyncSerialArray(flattenArr, func, next);
		});

		_pending["catch"](function(e) {
			return e;
		});

		return _pending;
	}

	var firstFields = option.firstFields || [];

	if (firstFields === true) {
		firstFields = Object.keys(objArr);
	}

	var objArrKeys = Object.keys(objArr);
	var objArrLength = objArrKeys.length;
	var total = 0;
	var results = [];
	var pending = new Promise(function(resolve, reject) {
		var next = function next(errors) {
			results.push.apply(results, errors);
			total++;

			if (total === objArrLength) {
				callback(results);
				return results.length ? reject({
					errors: results,
					fields: convertFieldsError(results)
				}) : resolve();
			}
		};

		if (!objArrKeys.length) {
			callback(results);
			resolve();
		}

		objArrKeys.forEach(function(key) {
			var arr = objArr[key];

			if (firstFields.indexOf(key) !== -1) {
				asyncSerialArray(arr, func, next);
			} else {
				asyncParallelArray(arr, func, next);
			}
		});
	});
	pending["catch"](function(e) {
		return e;
	});
	return pending;
}

function complementError(rule) {
	return function(oe) {
		if (oe && oe.message) {
			oe.field = oe.field || rule.fullField;
			return oe;
		}

		return {
			message: typeof oe === 'function' ? oe() : oe,
			field: oe.field || rule.fullField
		};
	};
}

function deepMerge(target, source) {
	if (source) {
		for (var s in source) {
			if (source.hasOwnProperty(s)) {
				var value = source[s];

				if (typeof value === 'object' && typeof target[s] === 'object') {
					target[s] = _extends({}, target[s], {}, value);
				} else {
					target[s] = value;
				}
			}
		}
	}

	return target;
}

/**
 *  Rule for validating required fields.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function required(rule, value, source, errors, options, type) {
	if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type || rule.type))) {
		errors.push(format(options.messages.required, rule.fullField));
	}
}

/**
 *  Rule for validating whitespace.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function whitespace(rule, value, source, errors, options) {
	if (/^\s+$/.test(value) || value === '') {
		errors.push(format(options.messages.whitespace, rule.fullField));
	}
}

/* eslint max-len:0 */

var pattern = {
	// http://emailregex.com/
	email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
	url: new RegExp(
		"^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$",
		'i'),
	hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
};
var types = {
	integer: function integer(value) {
		return types.number(value) && parseInt(value, 10) === value;
	},
	"float": function float(value) {
		return types.number(value) && !types.integer(value);
	},
	array: function array(value) {
		return Array.isArray(value);
	},
	regexp: function regexp(value) {
		if (value instanceof RegExp) {
			return true;
		}

		try {
			return !!new RegExp(value);
		} catch (e) {
			return false;
		}
	},
	date: function date(value) {
		return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear ===
			'function';
	},
	number: function number(value) {
		if (isNaN(value)) {
			return false;
		}

		// 修改源码，将字符串数值先转为数值
		return typeof +value === 'number';
	},
	object: function object(value) {
		return typeof value === 'object' && !types.array(value);
	},
	method: function method(value) {
		return typeof value === 'function';
	},
	email: function email(value) {
		return typeof value === 'string' && !!value.match(pattern.email) && value.length < 255;
	},
	url: function url(value) {
		return typeof value === 'string' && !!value.match(pattern.url);
	},
	hex: function hex(value) {
		return typeof value === 'string' && !!value.match(pattern.hex);
	}
};
/**
 *  Rule for validating the type of a value.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function type(rule, value, source, errors, options) {
	if (rule.required && value === undefined) {
		required(rule, value, source, errors, options);
		return;
	}

	var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'number', 'date', 'url', 'hex'];
	var ruleType = rule.type;

	if (custom.indexOf(ruleType) > -1) {
		if (!types[ruleType](value)) {
			errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
		} // straight typeof check

	} else if (ruleType && typeof value !== rule.type) {
		errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
	}
}

/**
 *  Rule for validating minimum and maximum allowed values.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function range(rule, value, source, errors, options) {
	var len = typeof rule.len === 'number';
	var min = typeof rule.min === 'number';
	var max = typeof rule.max === 'number'; // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）

	var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
	var val = value;
	var key = null;
	var num = typeof value === 'number';
	var str = typeof value === 'string';
	var arr = Array.isArray(value);

	if (num) {
		key = 'number';
	} else if (str) {
		key = 'string';
	} else if (arr) {
		key = 'array';
	} // if the value is not of a supported type for range validation
	// the validation rule rule should use the
	// type property to also test for a particular type


	if (!key) {
		return false;
	}

	if (arr) {
		val = value.length;
	}

	if (str) {
		// 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".lenght !== 3
		val = value.replace(spRegexp, '_').length;
	}

	if (len) {
		if (val !== rule.len) {
			errors.push(format(options.messages[key].len, rule.fullField, rule.len));
		}
	} else if (min && !max && val < rule.min) {
		errors.push(format(options.messages[key].min, rule.fullField, rule.min));
	} else if (max && !min && val > rule.max) {
		errors.push(format(options.messages[key].max, rule.fullField, rule.max));
	} else if (min && max && (val < rule.min || val > rule.max)) {
		errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
	}
}

var ENUM = 'enum';
/**
 *  Rule for validating a value exists in an enumerable list.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function enumerable(rule, value, source, errors, options) {
	rule[ENUM] = Array.isArray(rule[ENUM]) ? rule[ENUM] : [];

	if (rule[ENUM].indexOf(value) === -1) {
		errors.push(format(options.messages[ENUM], rule.fullField, rule[ENUM].join(', ')));
	}
}

/**
 *  Rule for validating a regular expression pattern.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param source The source object being validated.
 *  @param errors An array of errors that this rule may add
 *  validation errors to.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function pattern$1(rule, value, source, errors, options) {
	if (rule.pattern) {
		if (rule.pattern instanceof RegExp) {
			// if a RegExp instance is passed, reset `lastIndex` in case its `global`
			// flag is accidentally set to `true`, which in a validation scenario
			// is not necessary and the result might be misleading
			rule.pattern.lastIndex = 0;

			if (!rule.pattern.test(value)) {
				errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
			}
		} else if (typeof rule.pattern === 'string') {
			var _pattern = new RegExp(rule.pattern);

			if (!_pattern.test(value)) {
				errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
			}
		}
	}
}

var rules = {
	required: required,
	whitespace: whitespace,
	type: type,
	range: range,
	"enum": enumerable,
	pattern: pattern$1
};

/**
 *  Performs validation for string types.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function string(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value, 'string') && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options, 'string');

		if (!isEmptyValue(value, 'string')) {
			rules.type(rule, value, source, errors, options);
			rules.range(rule, value, source, errors, options);
			rules.pattern(rule, value, source, errors, options);

			if (rule.whitespace === true) {
				rules.whitespace(rule, value, source, errors, options);
			}
		}
	}

	callback(errors);
}

/**
 *  Validates a function.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function method(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (value !== undefined) {
			rules.type(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

/**
 *  Validates a number.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function number(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (value === '') {
			value = undefined;
		}

		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (value !== undefined) {
			rules.type(rule, value, source, errors, options);
			rules.range(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

/**
 *  Validates a boolean.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function _boolean(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (value !== undefined) {
			rules.type(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

/**
 *  Validates the regular expression type.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function regexp(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (!isEmptyValue(value)) {
			rules.type(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

/**
 *  Validates a number is an integer.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function integer(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (value !== undefined) {
			rules.type(rule, value, source, errors, options);
			rules.range(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

/**
 *  Validates a number is a floating point number.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function floatFn(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (value !== undefined) {
			rules.type(rule, value, source, errors, options);
			rules.range(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

/**
 *  Validates an array.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function array(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value, 'array') && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options, 'array');

		if (!isEmptyValue(value, 'array')) {
			rules.type(rule, value, source, errors, options);
			rules.range(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

/**
 *  Validates an object.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function object(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (value !== undefined) {
			rules.type(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

var ENUM$1 = 'enum';
/**
 *  Validates an enumerable list.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function enumerable$1(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (value !== undefined) {
			rules[ENUM$1](rule, value, source, errors, options);
		}
	}

	callback(errors);
}

/**
 *  Validates a regular expression pattern.
 *
 *  Performs validation when a rule only contains
 *  a pattern property but is not declared as a string type.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function pattern$2(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value, 'string') && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (!isEmptyValue(value, 'string')) {
			rules.pattern(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

function date(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field); 

	if (validate) {
		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);

		if (!isEmptyValue(value)) {
			var dateObject;

			if (typeof value === 'number') {
				dateObject = new Date(value);
			} else {
				dateObject = value;
			}

			rules.type(rule, dateObject, source, errors, options);

			if (dateObject) {
				rules.range(rule, dateObject.getTime(), source, errors, options);
			}
		}
	}

	callback(errors);
}

function required$1(rule, value, callback, source, options) {
	var errors = [];
	var type = Array.isArray(value) ? 'array' : typeof value;
	rules.required(rule, value, source, errors, options, type);
	callback(errors);
}

function type$1(rule, value, callback, source, options) {
	var ruleType = rule.type;
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value, ruleType) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options, ruleType);

		if (!isEmptyValue(value, ruleType)) {
			rules.type(rule, value, source, errors, options);
		}
	}

	callback(errors);
}

/**
 *  Performs validation for any type.
 *
 *  @param rule The validation rule.
 *  @param value The value of the field on the source object.
 *  @param callback The callback function.
 *  @param source The source object being validated.
 *  @param options The validation options.
 *  @param options.messages The validation messages.
 */

function any(rule, value, callback, source, options) {
	var errors = [];
	var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);

	if (validate) {
		if (isEmptyValue(value) && !rule.required) {
			return callback();
		}

		rules.required(rule, value, source, errors, options);
	}

	callback(errors);
}

var validators = {
	string: string,
	method: method,
	number: number,
	"boolean": _boolean,
	regexp: regexp,
	integer: integer,
	"float": floatFn,
	array: array,
	object: object,
	"enum": enumerable$1,
	pattern: pattern$2,
	date: date,
	url: type$1,
	hex: type$1,
	email: type$1,
	required: required$1,
	any: any
};

function newMessages() {
	return {
		"default": 'Validation error on field %s',
		required: '%s is required',
		"enum": '%s must be one of %s',
		whitespace: '%s cannot be empty',
		date: {
			format: '%s date %s is invalid for format %s',
			parse: '%s date could not be parsed, %s is invalid ',
			invalid: '%s date %s is invalid'
		},
		types: {
			string: '%s is not a %s',
			method: '%s is not a %s (function)',
			array: '%s is not an %s',
			object: '%s is not an %s',
			number: '%s is not a %s',
			date: '%s is not a %s',
			"boolean": '%s is not a %s',
			integer: '%s is not an %s',
			"float": '%s is not a %s',
			regexp: '%s is not a valid %s',
			email: '%s is not a valid %s',
			url: '%s is not a valid %s',
			hex: '%s is not a valid %s'
		},
		string: {
			len: '%s must be exactly %s characters',
			min: '%s must be at least %s characters',
			max: '%s cannot be longer than %s characters',
			range: '%s must be between %s and %s characters'
		},
		number: {
			len: '%s must equal %s',
			min: '%s cannot be less than %s',
			max: '%s cannot be greater than %s',
			range: '%s must be between %s and %s'
		},
		array: {
			len: '%s must be exactly %s in length',
			min: '%s cannot be less than %s in length',
			max: '%s cannot be greater than %s in length',
			range: '%s must be between %s and %s in length'
		},
		pattern: {
			mismatch: '%s value %s does not match pattern %s'
		},
		clone: function clone() {
			var cloned = JSON.parse(JSON.stringify(this));
			cloned.clone = this.clone;
			return cloned;
		}
	};
}
var messages = newMessages();

/**
 *  Encapsulates a validation schema.
 *
 *  @param descriptor An object declaring validation rules
 *  for this schema.
 */

function Schema(descriptor) {
	this.rules = null;
	this._messages = messages;
	this.define(descriptor);
}

Schema.prototype = {
	messages: function messages(_messages) {
		if (_messages) {
			this._messages = deepMerge(newMessages(), _messages);
		}

		return this._messages;
	},
	define: function define(rules) {
		if (!rules) {
			throw new Error('Cannot configure a schema with no rules');
		}

		if (typeof rules !== 'object' || Array.isArray(rules)) {
			throw new Error('Rules must be an object');
		}

		this.rules = {};
		var z;
		var item;

		for (z in rules) {
			if (rules.hasOwnProperty(z)) {
				item = rules[z];
				this.rules[z] = Array.isArray(item) ? item : [item];
			}
		}
	},
	validate: function validate(source_, o, oc) {
		var _this = this;

		if (o === void 0) {
			o = {};
		}

		if (oc === void 0) {
			oc = function oc() {};
		}

		var source = source_;
		var options = o;
		var callback = oc;

		if (typeof options === 'function') {
			callback = options;
			options = {};
		}

		if (!this.rules || Object.keys(this.rules).length === 0) {
			if (callback) {
				callback();
			}

			return Promise.resolve();
		}

		function complete(results) {
			var i;
			var errors = [];
			var fields = {};

			function add(e) {
				if (Array.isArray(e)) {
					var _errors;

					errors = (_errors = errors).concat.apply(_errors, e);
				} else {
					errors.push(e);
				}
			}

			for (i = 0; i < results.length; i++) {
				add(results[i]);
			}

			if (!errors.length) {
				errors = null;
				fields = null;
			} else {
				fields = convertFieldsError(errors);
			}

			callback(errors, fields);
		}

		if (options.messages) {
			var messages$1 = this.messages();

			if (messages$1 === messages) {
				messages$1 = newMessages();
			}

			deepMerge(messages$1, options.messages);
			options.messages = messages$1;
		} else {
			options.messages = this.messages();
		}

		var arr;
		var value;
		var series = {};
		var keys = options.keys || Object.keys(this.rules);
		keys.forEach(function(z) {
			arr = _this.rules[z];
			value = source[z];
			arr.forEach(function(r) {
				var rule = r;

				if (typeof rule.transform === 'function') {
					if (source === source_) {
						source = _extends({}, source);
					}

					value = source[z] = rule.transform(value);
				}

				if (typeof rule === 'function') {
					rule = {
						validator: rule
					};
				} else {
					rule = _extends({}, rule);
				}

				rule.validator = _this.getValidationMethod(rule);
				rule.field = z;
				rule.fullField = rule.fullField || z;
				rule.type = _this.getType(rule);

				if (!rule.validator) {
					return;
				}

				series[z] = series[z] || [];
				series[z].push({
					rule: rule,
					value: value,
					source: source,
					field: z
				});
			});
		});
		var errorFields = {};
		return asyncMap(series, options, function(data, doIt) {
			var rule = data.rule;
			var deep = (rule.type === 'object' || rule.type === 'array') && (typeof rule.fields === 'object' || typeof rule.defaultField ===
				'object');
			deep = deep && (rule.required || !rule.required && data.value);
			rule.field = data.field;

			function addFullfield(key, schema) {
				return _extends({}, schema, {
					fullField: rule.fullField + "." + key
				});
			}

			function cb(e) {
				if (e === void 0) {
					e = [];
				}

				var errors = e;

				if (!Array.isArray(errors)) {
					errors = [errors];
				}

				if (!options.suppressWarning && errors.length) {
					Schema.warning('async-validator:', errors);
				}

				if (errors.length && rule.message) {
					errors = [].concat(rule.message);
				}

				errors = errors.map(complementError(rule));

				if (options.first && errors.length) {
					errorFields[rule.field] = 1;
					return doIt(errors);
				}

				if (!deep) {
					doIt(errors);
				} else {
					// if rule is required but the target object
					// does not exist fail at the rule level and don't
					// go deeper
					if (rule.required && !data.value) {
						if (rule.message) {
							errors = [].concat(rule.message).map(complementError(rule));
						} else if (options.error) {
							errors = [options.error(rule, format(options.messages.required, rule.field))];
						} else {
							errors = [];
						}

						return doIt(errors);
					}

					var fieldsSchema = {};

					if (rule.defaultField) {
						for (var k in data.value) {
							if (data.value.hasOwnProperty(k)) {
								fieldsSchema[k] = rule.defaultField;
							}
						}
					}

					fieldsSchema = _extends({}, fieldsSchema, {}, data.rule.fields);

					for (var f in fieldsSchema) {
						if (fieldsSchema.hasOwnProperty(f)) {
							var fieldSchema = Array.isArray(fieldsSchema[f]) ? fieldsSchema[f] : [fieldsSchema[f]];
							fieldsSchema[f] = fieldSchema.map(addFullfield.bind(null, f));
						}
					}

					var schema = new Schema(fieldsSchema);
					schema.messages(options.messages);

					if (data.rule.options) {
						data.rule.options.messages = options.messages;
						data.rule.options.error = options.error;
					}

					schema.validate(data.value, data.rule.options || options, function(errs) {
						var finalErrors = [];

						if (errors && errors.length) {
							finalErrors.push.apply(finalErrors, errors);
						}

						if (errs && errs.length) {
							finalErrors.push.apply(finalErrors, errs);
						}

						doIt(finalErrors.length ? finalErrors : null);
					});
				}
			}

			var res;

			if (rule.asyncValidator) {
				res = rule.asyncValidator(rule, data.value, cb, data.source, options);
			} else if (rule.validator) {
				res = rule.validator(rule, data.value, cb, data.source, options);

				if (res === true) {
					cb();
				} else if (res === false) {
					cb(rule.message || rule.field + " fails");
				} else if (res instanceof Array) {
					cb(res);
				} else if (res instanceof Error) {
					cb(res.message);
				}
			}

			if (res && res.then) {
				res.then(function() {
					return cb();
				}, function(e) {
					return cb(e);
				});
			}
		}, function(results) {
			complete(results);
		});
	},
	getType: function getType(rule) {
		if (rule.type === undefined && rule.pattern instanceof RegExp) {
			rule.type = 'pattern';
		}

		if (typeof rule.validator !== 'function' && rule.type && !validators.hasOwnProperty(rule.type)) {
			throw new Error(format('Unknown rule type %s', rule.type));
		}

		return rule.type || 'string';
	},
	getValidationMethod: function getValidationMethod(rule) {
		if (typeof rule.validator === 'function') {
			return rule.validator;
		}

		var keys = Object.keys(rule);
		var messageIndex = keys.indexOf('message');

		if (messageIndex !== -1) {
			keys.splice(messageIndex, 1);
		}

		if (keys.length === 1 && keys[0] === 'required') {
			return validators.required;
		}

		return validators[this.getType(rule)] || false;
	}
};

Schema.register = function register(type, validator) {
	if (typeof validator !== 'function') {
		throw new Error('Cannot register a validator by type, validator is not a function');
	}

	validators[type] = validator;
};

Schema.warning = warning;
Schema.messages = messages;

export default Schema;
//# sourceMappingURL=index.js.map