You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1356 lines
33 KiB
1356 lines
33 KiB
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
|
|
|