1.18整合
This commit is contained in:
皮
@@ -585,6 +585,7 @@ exports.deepMerge = deepMerge;
|
||||
exports.error = error;
|
||||
exports.formValidate = formValidate;
|
||||
exports.genLightColor = genLightColor;
|
||||
exports.getProperty = getProperty;
|
||||
exports.getWindowInfo = getWindowInfo;
|
||||
exports.index = index;
|
||||
exports.os = os;
|
||||
@@ -592,6 +593,7 @@ exports.padZero = padZero;
|
||||
exports.page = page;
|
||||
exports.queryParams = queryParams;
|
||||
exports.range = range;
|
||||
exports.setProperty = setProperty;
|
||||
exports.shallowMerge = shallowMerge;
|
||||
exports.sleep = sleep;
|
||||
exports.toast = toast;
|
||||
|
||||
893
unpackage/dist/dev/mp-weixin/uni_modules/uview-plus/libs/util/async-validator.js
vendored
Normal file
893
unpackage/dist/dev/mp-weixin/uni_modules/uview-plus/libs/util/async-validator.js
vendored
Normal file
@@ -0,0 +1,893 @@
|
||||
"use strict";
|
||||
const formatRegExp = /%[sdj%]/g;
|
||||
let warning = function warning2() {
|
||||
};
|
||||
if (typeof process !== "undefined" && process.env && true && typeof window !== "undefined" && typeof document !== "undefined") {
|
||||
warning = function warning3(type2, errors) {
|
||||
if (typeof console !== "undefined" && console.warn) {
|
||||
if (errors.every((e) => typeof e === "string")) {
|
||||
console.warn(type2, errors);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
function convertFieldsError(errors) {
|
||||
if (!errors || !errors.length)
|
||||
return null;
|
||||
const fields = {};
|
||||
errors.forEach((error) => {
|
||||
const { field } = error;
|
||||
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];
|
||||
}
|
||||
let i = 1;
|
||||
const f = args[0];
|
||||
const len = args.length;
|
||||
if (typeof f === "function") {
|
||||
return f.apply(null, args.slice(1));
|
||||
}
|
||||
if (typeof f === "string") {
|
||||
let str = String(f).replace(formatRegExp, (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 (let arg = args[i]; i < len; arg = args[++i]) {
|
||||
str += ` ${arg}`;
|
||||
}
|
||||
return str;
|
||||
}
|
||||
return f;
|
||||
}
|
||||
function isNativeStringType(type2) {
|
||||
return type2 === "string" || type2 === "url" || type2 === "hex" || type2 === "email" || type2 === "pattern";
|
||||
}
|
||||
function isEmptyValue(value, type2) {
|
||||
if (value === void 0 || value === null) {
|
||||
return true;
|
||||
}
|
||||
if (type2 === "array" && Array.isArray(value) && !value.length) {
|
||||
return true;
|
||||
}
|
||||
if (isNativeStringType(type2) && typeof value === "string" && !value) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function asyncParallelArray(arr, func, callback) {
|
||||
const results = [];
|
||||
let total = 0;
|
||||
const arrLength = arr.length;
|
||||
function count(errors) {
|
||||
results.push.apply(results, errors);
|
||||
total++;
|
||||
if (total === arrLength) {
|
||||
callback(results);
|
||||
}
|
||||
}
|
||||
arr.forEach((a) => {
|
||||
func(a, count);
|
||||
});
|
||||
}
|
||||
function asyncSerialArray(arr, func, callback) {
|
||||
let index = 0;
|
||||
const arrLength = arr.length;
|
||||
function next(errors) {
|
||||
if (errors && errors.length) {
|
||||
callback(errors);
|
||||
return;
|
||||
}
|
||||
const original = index;
|
||||
index += 1;
|
||||
if (original < arrLength) {
|
||||
func(arr[original], next);
|
||||
} else {
|
||||
callback([]);
|
||||
}
|
||||
}
|
||||
next([]);
|
||||
}
|
||||
function flattenObjArr(objArr) {
|
||||
const ret = [];
|
||||
Object.keys(objArr).forEach((k) => {
|
||||
ret.push.apply(ret, objArr[k]);
|
||||
});
|
||||
return ret;
|
||||
}
|
||||
function asyncMap(objArr, option, func, callback) {
|
||||
if (option.first) {
|
||||
const _pending = new Promise((resolve, reject) => {
|
||||
const next = function next2(errors) {
|
||||
callback(errors);
|
||||
return errors.length ? reject({
|
||||
errors,
|
||||
fields: convertFieldsError(errors)
|
||||
}) : resolve();
|
||||
};
|
||||
const flattenArr = flattenObjArr(objArr);
|
||||
asyncSerialArray(flattenArr, func, next);
|
||||
});
|
||||
_pending.catch((e) => e);
|
||||
return _pending;
|
||||
}
|
||||
let firstFields = option.firstFields || [];
|
||||
if (firstFields === true) {
|
||||
firstFields = Object.keys(objArr);
|
||||
}
|
||||
const objArrKeys = Object.keys(objArr);
|
||||
const objArrLength = objArrKeys.length;
|
||||
let total = 0;
|
||||
const results = [];
|
||||
const pending = new Promise((resolve, reject) => {
|
||||
const next = function next2(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((key) => {
|
||||
const arr = objArr[key];
|
||||
if (firstFields.indexOf(key) !== -1) {
|
||||
asyncSerialArray(arr, func, next);
|
||||
} else {
|
||||
asyncParallelArray(arr, func, next);
|
||||
}
|
||||
});
|
||||
});
|
||||
pending.catch((e) => 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 (const s in source) {
|
||||
if (source.hasOwnProperty(s)) {
|
||||
const value = source[s];
|
||||
if (typeof value === "object" && typeof target[s] === "object") {
|
||||
target[s] = { ...target[s], ...value };
|
||||
} else {
|
||||
target[s] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return target;
|
||||
}
|
||||
function required(rule, value, source, errors, options, type2) {
|
||||
if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type2 || rule.type))) {
|
||||
errors.push(format(options.messages.required, rule.fullField));
|
||||
}
|
||||
}
|
||||
function whitespace(rule, value, source, errors, options) {
|
||||
if (/^\s+$/.test(value) || value === "") {
|
||||
errors.push(format(options.messages.whitespace, rule.fullField));
|
||||
}
|
||||
}
|
||||
const 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 /^(-)?\d+$/.test(value);
|
||||
},
|
||||
float: function float(value) {
|
||||
return /^(-)?\d+(\.\d+)?$/.test(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);
|
||||
}
|
||||
};
|
||||
function type(rule, value, source, errors, options) {
|
||||
if (rule.required && value === void 0) {
|
||||
required(rule, value, source, errors, options);
|
||||
return;
|
||||
}
|
||||
const custom = ["integer", "float", "array", "regexp", "object", "method", "email", "number", "date", "url", "hex"];
|
||||
const 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));
|
||||
}
|
||||
}
|
||||
function range(rule, value, source, errors, options) {
|
||||
const len = typeof rule.len === "number";
|
||||
const min = typeof rule.min === "number";
|
||||
const max = typeof rule.max === "number";
|
||||
const spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
|
||||
let val = value;
|
||||
let key = null;
|
||||
const num = typeof value === "number";
|
||||
const str = typeof value === "string";
|
||||
const 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));
|
||||
}
|
||||
}
|
||||
const ENUM = "enum";
|
||||
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(", ")));
|
||||
}
|
||||
}
|
||||
function pattern$1(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") {
|
||||
const _pattern = new RegExp(rule.pattern);
|
||||
if (!_pattern.test(value)) {
|
||||
errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
const rules = {
|
||||
required,
|
||||
whitespace,
|
||||
type,
|
||||
range,
|
||||
enum: enumerable,
|
||||
pattern: pattern$1
|
||||
};
|
||||
function string(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
function method2(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
function number2(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
function _boolean(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
function regexp2(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
function integer2(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
function floatFn(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
function array2(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
function object2(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
const ENUM$1 = "enum";
|
||||
function enumerable$1(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
if (isEmptyValue(value) && !rule.required) {
|
||||
return callback();
|
||||
}
|
||||
rules.required(rule, value, source, errors, options);
|
||||
if (value !== void 0) {
|
||||
rules[ENUM$1](rule, value, source, errors, options);
|
||||
}
|
||||
}
|
||||
callback(errors);
|
||||
}
|
||||
function pattern$2(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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 date2(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
if (isEmptyValue(value) && !rule.required) {
|
||||
return callback();
|
||||
}
|
||||
rules.required(rule, value, source, errors, options);
|
||||
if (!isEmptyValue(value)) {
|
||||
let 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) {
|
||||
const errors = [];
|
||||
const type2 = Array.isArray(value) ? "array" : typeof value;
|
||||
rules.required(rule, value, source, errors, options, type2);
|
||||
callback(errors);
|
||||
}
|
||||
function type$1(rule, value, callback, source, options) {
|
||||
const ruleType = rule.type;
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
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);
|
||||
}
|
||||
function any(rule, value, callback, source, options) {
|
||||
const errors = [];
|
||||
const validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
|
||||
if (validate2) {
|
||||
if (isEmptyValue(value) && !rule.required) {
|
||||
return callback();
|
||||
}
|
||||
rules.required(rule, value, source, errors, options);
|
||||
}
|
||||
callback(errors);
|
||||
}
|
||||
const validators = {
|
||||
string,
|
||||
method: method2,
|
||||
number: number2,
|
||||
boolean: _boolean,
|
||||
regexp: regexp2,
|
||||
integer: integer2,
|
||||
float: floatFn,
|
||||
array: array2,
|
||||
object: object2,
|
||||
enum: enumerable$1,
|
||||
pattern: pattern$2,
|
||||
date: date2,
|
||||
url: type$1,
|
||||
hex: type$1,
|
||||
email: type$1,
|
||||
required: required$1,
|
||||
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() {
|
||||
const cloned = JSON.parse(JSON.stringify(this));
|
||||
cloned.clone = this.clone;
|
||||
return cloned;
|
||||
}
|
||||
};
|
||||
}
|
||||
const messages = newMessages();
|
||||
function Schema(descriptor) {
|
||||
this.rules = null;
|
||||
this._messages = messages;
|
||||
this.define(descriptor);
|
||||
}
|
||||
Schema.prototype = {
|
||||
messages: function messages2(_messages) {
|
||||
if (_messages) {
|
||||
this._messages = deepMerge(newMessages(), _messages);
|
||||
}
|
||||
return this._messages;
|
||||
},
|
||||
define: function define(rules2) {
|
||||
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 = {};
|
||||
let z;
|
||||
let item;
|
||||
for (z in rules2) {
|
||||
if (rules2.hasOwnProperty(z)) {
|
||||
item = rules2[z];
|
||||
this.rules[z] = Array.isArray(item) ? item : [item];
|
||||
}
|
||||
}
|
||||
},
|
||||
validate: function validate(source_, o, oc) {
|
||||
const _this = this;
|
||||
if (o === void 0) {
|
||||
o = {};
|
||||
}
|
||||
if (oc === void 0) {
|
||||
oc = function oc2() {
|
||||
};
|
||||
}
|
||||
let source = source_;
|
||||
let options = o;
|
||||
let 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) {
|
||||
let i;
|
||||
let errors = [];
|
||||
let fields = {};
|
||||
function add(e) {
|
||||
if (Array.isArray(e)) {
|
||||
let _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) {
|
||||
let 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();
|
||||
}
|
||||
let arr;
|
||||
let value;
|
||||
const series = {};
|
||||
const keys = options.keys || Object.keys(this.rules);
|
||||
keys.forEach((z) => {
|
||||
arr = _this.rules[z];
|
||||
value = source[z];
|
||||
arr.forEach((r) => {
|
||||
let rule = r;
|
||||
if (typeof rule.transform === "function") {
|
||||
if (source === source_) {
|
||||
source = { ...source };
|
||||
}
|
||||
value = source[z] = rule.transform(value);
|
||||
}
|
||||
if (typeof rule === "function") {
|
||||
rule = {
|
||||
validator: rule
|
||||
};
|
||||
} else {
|
||||
rule = { ...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,
|
||||
value,
|
||||
source,
|
||||
field: z
|
||||
});
|
||||
});
|
||||
});
|
||||
const errorFields = {};
|
||||
return asyncMap(series, options, (data, doIt) => {
|
||||
const { rule } = data;
|
||||
let 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 { ...schema, fullField: `${rule.fullField}.${key}` };
|
||||
}
|
||||
function cb(e) {
|
||||
if (e === void 0) {
|
||||
e = [];
|
||||
}
|
||||
let 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.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);
|
||||
}
|
||||
let fieldsSchema = {};
|
||||
if (rule.defaultField) {
|
||||
for (const k in data.value) {
|
||||
if (data.value.hasOwnProperty(k)) {
|
||||
fieldsSchema[k] = rule.defaultField;
|
||||
}
|
||||
}
|
||||
}
|
||||
fieldsSchema = { ...fieldsSchema, ...data.rule.fields };
|
||||
for (const f in fieldsSchema) {
|
||||
if (fieldsSchema.hasOwnProperty(f)) {
|
||||
const fieldSchema = Array.isArray(fieldsSchema[f]) ? fieldsSchema[f] : [fieldsSchema[f]];
|
||||
fieldsSchema[f] = fieldSchema.map(addFullfield.bind(null, f));
|
||||
}
|
||||
}
|
||||
const 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, (errs) => {
|
||||
const finalErrors = [];
|
||||
if (errors && errors.length) {
|
||||
finalErrors.push.apply(finalErrors, errors);
|
||||
}
|
||||
if (errs && errs.length) {
|
||||
finalErrors.push.apply(finalErrors, errs);
|
||||
}
|
||||
doIt(finalErrors.length ? finalErrors : null);
|
||||
});
|
||||
}
|
||||
}
|
||||
let 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(() => cb(), (e) => cb(e));
|
||||
}
|
||||
}, (results) => {
|
||||
complete(results);
|
||||
});
|
||||
},
|
||||
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";
|
||||
},
|
||||
getValidationMethod: function getValidationMethod(rule) {
|
||||
if (typeof rule.validator === "function") {
|
||||
return rule.validator;
|
||||
}
|
||||
const keys = Object.keys(rule);
|
||||
const 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(type2, validator) {
|
||||
if (typeof validator !== "function") {
|
||||
throw new Error("Cannot register a validator by type, validator is not a function");
|
||||
}
|
||||
validators[type2] = validator;
|
||||
};
|
||||
Schema.warning = warning;
|
||||
Schema.messages = messages;
|
||||
exports.Schema = Schema;
|
||||
Reference in New Issue
Block a user