From f26f29d84e0a68831a6af14dab3eec5500496d2e Mon Sep 17 00:00:00 2001
From: spring <2396852758@qq.com>
Date: 星期三, 28 五月 2025 16:48:52 +0800
Subject: [PATCH] 初始化项目
---
uview-ui/libs/util/async-validator.js | 1356 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1,356 insertions(+), 0 deletions(-)
diff --git a/uview-ui/libs/util/async-validator.js b/uview-ui/libs/util/async-validator.js
new file mode 100644
index 0000000..d7215b9
--- /dev/null
+++ b/uview-ui/libs/util/async-validator.js
@@ -0,0 +1,1356 @@
+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'; // 姝ｅ垯鍖归厤鐮佺偣鑼冨洿浠嶶+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鐨勬枃瀛條ength灞炴�т笉鍑嗙‘鐨刡ug锛屽"馉馉馉".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
--
Gitblit v1.9.3