1012 lines
31 KiB
JavaScript
1012 lines
31 KiB
JavaScript
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);
|
|
}
|
|
function _inheritsLoose(subClass, superClass) {
|
|
subClass.prototype = Object.create(superClass.prototype);
|
|
subClass.prototype.constructor = subClass;
|
|
_setPrototypeOf(subClass, superClass);
|
|
}
|
|
function _getPrototypeOf(o) {
|
|
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
|
|
return o2.__proto__ || Object.getPrototypeOf(o2);
|
|
};
|
|
return _getPrototypeOf(o);
|
|
}
|
|
function _setPrototypeOf(o, p) {
|
|
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
|
|
o2.__proto__ = p2;
|
|
return o2;
|
|
};
|
|
return _setPrototypeOf(o, p);
|
|
}
|
|
function _isNativeReflectConstruct() {
|
|
if (typeof Reflect === "undefined" || !Reflect.construct)
|
|
return false;
|
|
if (Reflect.construct.sham)
|
|
return false;
|
|
if (typeof Proxy === "function")
|
|
return true;
|
|
try {
|
|
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
|
|
}));
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
function _construct(Parent, args, Class) {
|
|
if (_isNativeReflectConstruct()) {
|
|
_construct = Reflect.construct;
|
|
} else {
|
|
_construct = function _construct2(Parent2, args2, Class2) {
|
|
var a = [null];
|
|
a.push.apply(a, args2);
|
|
var Constructor = Function.bind.apply(Parent2, a);
|
|
var instance = new Constructor();
|
|
if (Class2)
|
|
_setPrototypeOf(instance, Class2.prototype);
|
|
return instance;
|
|
};
|
|
}
|
|
return _construct.apply(null, arguments);
|
|
}
|
|
function _isNativeFunction(fn) {
|
|
return Function.toString.call(fn).indexOf("[native code]") !== -1;
|
|
}
|
|
function _wrapNativeSuper(Class) {
|
|
var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
|
|
_wrapNativeSuper = function _wrapNativeSuper2(Class2) {
|
|
if (Class2 === null || !_isNativeFunction(Class2))
|
|
return Class2;
|
|
if (typeof Class2 !== "function") {
|
|
throw new TypeError("Super expression must either be null or a function");
|
|
}
|
|
if (typeof _cache !== "undefined") {
|
|
if (_cache.has(Class2))
|
|
return _cache.get(Class2);
|
|
_cache.set(Class2, Wrapper);
|
|
}
|
|
function Wrapper() {
|
|
return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
|
|
}
|
|
Wrapper.prototype = Object.create(Class2.prototype, {
|
|
constructor: {
|
|
value: Wrapper,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
return _setPrototypeOf(Wrapper, Class2);
|
|
};
|
|
return _wrapNativeSuper(Class);
|
|
}
|
|
var formatRegExp = /%[sdj%]/g;
|
|
var warning = function warning2() {
|
|
};
|
|
if (typeof process !== "undefined" && process.env && false) {
|
|
warning = function warning3(type4, errors) {
|
|
if (typeof console !== "undefined" && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === "undefined") {
|
|
if (errors.every(function(e) {
|
|
return typeof e === "string";
|
|
})) {
|
|
console.warn(type4, 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(template) {
|
|
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
args[_key - 1] = arguments[_key];
|
|
}
|
|
var i = 0;
|
|
var len = args.length;
|
|
if (typeof template === "function") {
|
|
return template.apply(null, args);
|
|
}
|
|
if (typeof template === "string") {
|
|
var str = template.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;
|
|
}
|
|
});
|
|
return str;
|
|
}
|
|
return template;
|
|
}
|
|
function isNativeStringType(type4) {
|
|
return type4 === "string" || type4 === "url" || type4 === "hex" || type4 === "email" || type4 === "date" || type4 === "pattern";
|
|
}
|
|
function isEmptyValue(value, type4) {
|
|
if (value === void 0 || value === null) {
|
|
return true;
|
|
}
|
|
if (type4 === "array" && Array.isArray(value) && !value.length) {
|
|
return true;
|
|
}
|
|
if (isNativeStringType(type4) && 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;
|
|
}
|
|
var AsyncValidationError = /* @__PURE__ */ function(_Error) {
|
|
_inheritsLoose(AsyncValidationError2, _Error);
|
|
function AsyncValidationError2(errors, fields) {
|
|
var _this;
|
|
_this = _Error.call(this, "Async Validation Error") || this;
|
|
_this.errors = errors;
|
|
_this.fields = fields;
|
|
return _this;
|
|
}
|
|
return AsyncValidationError2;
|
|
}(/* @__PURE__ */ _wrapNativeSuper(Error));
|
|
function asyncMap(objArr, option, func, callback, source) {
|
|
if (option.first) {
|
|
var _pending = new Promise(function(resolve, reject) {
|
|
var next = function next2(errors) {
|
|
callback(errors);
|
|
return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
|
|
};
|
|
var flattenArr = flattenObjArr(objArr);
|
|
asyncSerialArray(flattenArr, func, next);
|
|
});
|
|
_pending["catch"](function(e) {
|
|
return e;
|
|
});
|
|
return _pending;
|
|
}
|
|
var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
|
|
var objArrKeys = Object.keys(objArr);
|
|
var objArrLength = objArrKeys.length;
|
|
var total = 0;
|
|
var results = [];
|
|
var pending = new Promise(function(resolve, reject) {
|
|
var next = function next2(errors) {
|
|
results.push.apply(results, errors);
|
|
total++;
|
|
if (total === objArrLength) {
|
|
callback(results);
|
|
return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
|
|
}
|
|
};
|
|
if (!objArrKeys.length) {
|
|
callback(results);
|
|
resolve(source);
|
|
}
|
|
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 isErrorObj(obj) {
|
|
return !!(obj && obj.message !== void 0);
|
|
}
|
|
function getValue(value, path) {
|
|
var v = value;
|
|
for (var i = 0; i < path.length; i++) {
|
|
if (v == void 0) {
|
|
return v;
|
|
}
|
|
v = v[path[i]];
|
|
}
|
|
return v;
|
|
}
|
|
function complementError(rule, source) {
|
|
return function(oe) {
|
|
var fieldValue;
|
|
if (rule.fullFields) {
|
|
fieldValue = getValue(source, rule.fullFields);
|
|
} else {
|
|
fieldValue = source[oe.field || rule.fullField];
|
|
}
|
|
if (isErrorObj(oe)) {
|
|
oe.field = oe.field || rule.fullField;
|
|
oe.fieldValue = fieldValue;
|
|
return oe;
|
|
}
|
|
return {
|
|
message: typeof oe === "function" ? oe() : oe,
|
|
fieldValue,
|
|
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;
|
|
}
|
|
var required$1 = function required(rule, value, source, errors, options, type4) {
|
|
if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type4 || rule.type))) {
|
|
errors.push(format(options.messages.required, rule.fullField));
|
|
}
|
|
};
|
|
var whitespace = function whitespace2(rule, value, source, errors, options) {
|
|
if (/^\s+$/.test(value) || value === "") {
|
|
errors.push(format(options.messages.whitespace, rule.fullField));
|
|
}
|
|
};
|
|
var pattern$2 = {
|
|
email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{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" && !isNaN(value.getTime());
|
|
},
|
|
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.length <= 320 && !!value.match(pattern$2.email);
|
|
},
|
|
url: function url(value) {
|
|
return typeof value === "string" && value.length <= 2048 && !!value.match(pattern$2.url);
|
|
},
|
|
hex: function hex(value) {
|
|
return typeof value === "string" && !!value.match(pattern$2.hex);
|
|
}
|
|
};
|
|
var type$1 = function type(rule, value, source, errors, options) {
|
|
if (rule.required && value === void 0) {
|
|
required$1(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));
|
|
}
|
|
} else if (ruleType && typeof value !== rule.type) {
|
|
errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
|
|
}
|
|
};
|
|
var range = function range2(rule, value, source, errors, options) {
|
|
var len = typeof rule.len === "number";
|
|
var min = typeof rule.min === "number";
|
|
var max = typeof rule.max === "number";
|
|
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 (!key) {
|
|
return false;
|
|
}
|
|
if (arr) {
|
|
val = value.length;
|
|
}
|
|
if (str) {
|
|
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$1 = "enum";
|
|
var enumerable$1 = function enumerable(rule, value, source, errors, options) {
|
|
rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
|
|
if (rule[ENUM$1].indexOf(value) === -1) {
|
|
errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(", ")));
|
|
}
|
|
};
|
|
var pattern$1 = function pattern(rule, value, source, errors, options) {
|
|
if (rule.pattern) {
|
|
if (rule.pattern instanceof RegExp) {
|
|
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$1,
|
|
whitespace,
|
|
type: type$1,
|
|
range,
|
|
"enum": enumerable$1,
|
|
pattern: pattern$1
|
|
};
|
|
var string = function string2(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);
|
|
};
|
|
var method2 = function method3(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 !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var number2 = function number3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (value === "") {
|
|
value = void 0;
|
|
}
|
|
if (isEmptyValue(value) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (value !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
rules.range(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var _boolean = function _boolean2(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 !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var regexp2 = function regexp3(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);
|
|
};
|
|
var integer2 = function integer3(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 !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
rules.range(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var floatFn = function floatFn2(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 !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
rules.range(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var array2 = function array3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if ((value === void 0 || value === null) && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options, "array");
|
|
if (value !== void 0 && value !== null) {
|
|
rules.type(rule, value, source, errors, options);
|
|
rules.range(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var object2 = function object3(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 !== void 0) {
|
|
rules.type(rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var ENUM = "enum";
|
|
var enumerable2 = function enumerable3(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 !== void 0) {
|
|
rules[ENUM](rule, value, source, errors, options);
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var pattern2 = function pattern3(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);
|
|
};
|
|
var date2 = function date3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
|
if (validate) {
|
|
if (isEmptyValue(value, "date") && !rule.required) {
|
|
return callback();
|
|
}
|
|
rules.required(rule, value, source, errors, options);
|
|
if (!isEmptyValue(value, "date")) {
|
|
var dateObject;
|
|
if (value instanceof Date) {
|
|
dateObject = value;
|
|
} else {
|
|
dateObject = new Date(value);
|
|
}
|
|
rules.type(rule, dateObject, source, errors, options);
|
|
if (dateObject) {
|
|
rules.range(rule, dateObject.getTime(), source, errors, options);
|
|
}
|
|
}
|
|
}
|
|
callback(errors);
|
|
};
|
|
var required2 = function required3(rule, value, callback, source, options) {
|
|
var errors = [];
|
|
var type4 = Array.isArray(value) ? "array" : typeof value;
|
|
rules.required(rule, value, source, errors, options, type4);
|
|
callback(errors);
|
|
};
|
|
var type2 = function type3(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);
|
|
};
|
|
var any = function any2(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,
|
|
method: method2,
|
|
number: number2,
|
|
"boolean": _boolean,
|
|
regexp: regexp2,
|
|
integer: integer2,
|
|
"float": floatFn,
|
|
array: array2,
|
|
object: object2,
|
|
"enum": enumerable2,
|
|
pattern: pattern2,
|
|
date: date2,
|
|
url: type2,
|
|
hex: type2,
|
|
email: type2,
|
|
required: required2,
|
|
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();
|
|
var Schema = /* @__PURE__ */ function() {
|
|
function Schema2(descriptor) {
|
|
this.rules = null;
|
|
this._messages = messages;
|
|
this.define(descriptor);
|
|
}
|
|
var _proto = Schema2.prototype;
|
|
_proto.define = function define(rules2) {
|
|
var _this = this;
|
|
if (!rules2) {
|
|
throw new Error("Cannot configure a schema with no rules");
|
|
}
|
|
if (typeof rules2 !== "object" || Array.isArray(rules2)) {
|
|
throw new Error("Rules must be an object");
|
|
}
|
|
this.rules = {};
|
|
Object.keys(rules2).forEach(function(name) {
|
|
var item = rules2[name];
|
|
_this.rules[name] = Array.isArray(item) ? item : [item];
|
|
});
|
|
};
|
|
_proto.messages = function messages2(_messages) {
|
|
if (_messages) {
|
|
this._messages = deepMerge(newMessages(), _messages);
|
|
}
|
|
return this._messages;
|
|
};
|
|
_proto.validate = function validate(source_, o, oc) {
|
|
var _this2 = this;
|
|
if (o === void 0) {
|
|
o = {};
|
|
}
|
|
if (oc === void 0) {
|
|
oc = function oc2() {
|
|
};
|
|
}
|
|
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(null, source);
|
|
}
|
|
return Promise.resolve(source);
|
|
}
|
|
function complete(results) {
|
|
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 (var i = 0; i < results.length; i++) {
|
|
add(results[i]);
|
|
}
|
|
if (!errors.length) {
|
|
callback(null, source);
|
|
} 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 series = {};
|
|
var keys = options.keys || Object.keys(this.rules);
|
|
keys.forEach(function(z) {
|
|
var arr = _this2.rules[z];
|
|
var 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 = _this2.getValidationMethod(rule);
|
|
if (!rule.validator) {
|
|
return;
|
|
}
|
|
rule.field = z;
|
|
rule.fullField = rule.fullField || z;
|
|
rule.type = _this2.getType(rule);
|
|
series[z] = series[z] || [];
|
|
series[z].push({
|
|
rule,
|
|
value,
|
|
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,
|
|
fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
|
|
});
|
|
}
|
|
function cb(e) {
|
|
if (e === void 0) {
|
|
e = [];
|
|
}
|
|
var errorList = Array.isArray(e) ? e : [e];
|
|
if (!options.suppressWarning && errorList.length) {
|
|
Schema2.warning("async-validator:", errorList);
|
|
}
|
|
if (errorList.length && rule.message !== void 0) {
|
|
errorList = [].concat(rule.message);
|
|
}
|
|
var filledErrors = errorList.map(complementError(rule, source));
|
|
if (options.first && filledErrors.length) {
|
|
errorFields[rule.field] = 1;
|
|
return doIt(filledErrors);
|
|
}
|
|
if (!deep) {
|
|
doIt(filledErrors);
|
|
} else {
|
|
if (rule.required && !data.value) {
|
|
if (rule.message !== void 0) {
|
|
filledErrors = [].concat(rule.message).map(complementError(rule, source));
|
|
} else if (options.error) {
|
|
filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
|
|
}
|
|
return doIt(filledErrors);
|
|
}
|
|
var fieldsSchema = {};
|
|
if (rule.defaultField) {
|
|
Object.keys(data.value).map(function(key) {
|
|
fieldsSchema[key] = rule.defaultField;
|
|
});
|
|
}
|
|
fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
|
|
var paredFieldsSchema = {};
|
|
Object.keys(fieldsSchema).forEach(function(field) {
|
|
var fieldSchema = fieldsSchema[field];
|
|
var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
|
|
paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
|
|
});
|
|
var schema = new Schema2(paredFieldsSchema);
|
|
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 (filledErrors && filledErrors.length) {
|
|
finalErrors.push.apply(finalErrors, filledErrors);
|
|
}
|
|
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) {
|
|
try {
|
|
res = rule.validator(rule, data.value, cb, data.source, options);
|
|
} catch (error) {
|
|
console.error == null ? void 0 : console.error(error);
|
|
setTimeout(function() {
|
|
throw error;
|
|
}, 0);
|
|
cb(error.message);
|
|
}
|
|
if (res === true) {
|
|
cb();
|
|
} else if (res === false) {
|
|
cb(typeof rule.message === "function" ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || 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);
|
|
}, source);
|
|
};
|
|
_proto.getType = function getType(rule) {
|
|
if (rule.type === void 0 && 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";
|
|
};
|
|
_proto.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)] || void 0;
|
|
};
|
|
return Schema2;
|
|
}();
|
|
Schema.register = function register(type4, validator) {
|
|
if (typeof validator !== "function") {
|
|
throw new Error("Cannot register a validator by type, validator is not a function");
|
|
}
|
|
validators[type4] = validator;
|
|
};
|
|
Schema.warning = warning;
|
|
Schema.messages = messages;
|
|
Schema.validators = validators;
|
|
export { Schema as S };
|