🚀 Socket Launch Week Day 5:Introducing Repository Access Permissions and Custom Roles.Learn more →
Sign In

@rc-component/async-validator

Package Overview
Dependencies
Maintainers
5
Versions
9
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@rc-component/async-validator - npm Package Compare versions

Comparing version
5.1.1
 to
5.1.2
+250
-232
es/index.js

@@ -0,1 +1,7 @@

import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
import _typeof from "@babel/runtime/helpers/esm/typeof";
import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
import _createClass from "@babel/runtime/helpers/esm/createClass";
import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
import { messages as defaultMessages, newMessages } from "./messages";

@@ -12,264 +18,276 @@ import { asyncMap, complementError, convertFieldsError, deepMerge, format, warning } from "./util";

*/
class Schema {
// ========================= Static =========================
static 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;
};
static warning = warning;
static messages = defaultMessages;
static validators = validators;
// ======================== Instance ========================
rules = null;
_messages = defaultMessages;
constructor(descriptor) {
var Schema = /*#__PURE__*/function () {
function Schema(descriptor) {
_classCallCheck(this, Schema);
// ======================== Instance ========================
_defineProperty(this, "rules", null);
_defineProperty(this, "_messages", defaultMessages);
this.define(descriptor);
}
define(rules) {
if (!rules) {
throw new Error('Cannot configure a schema with no rules');
_createClass(Schema, [{
key: "define",
value: function define(rules) {
var _this = this;
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 = {};
Object.keys(rules).forEach(function (name) {
var item = rules[name];
_this.rules[name] = Array.isArray(item) ? item : [item];
});
}
if (typeof rules !== 'object' || Array.isArray(rules)) {
throw new Error('Rules must be an object');
}, {
key: "messages",
value: function messages(_messages) {
if (_messages) {
this._messages = deepMerge(newMessages(), _messages);
}
return this._messages;
}
this.rules = {};
Object.keys(rules).forEach(name => {
const item = rules[name];
this.rules[name] = Array.isArray(item) ? item : [item];
});
}
messages(messages) {
if (messages) {
this._messages = deepMerge(newMessages(), messages);
}
return this._messages;
}
// eslint-disable-next-line @typescript-eslint/unified-signatures
validate(source_, o = {}, oc = () => {}) {
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(null, source);
}, {
key: "validate",
value: function validate(source_) {
var _this2 = this;
var o = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var oc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
var source = source_;
var options = o;
var callback = oc;
if (typeof options === 'function') {
callback = options;
options = {};
}
return Promise.resolve(source);
}
function complete(results) {
let errors = [];
let fields = {};
function add(e) {
if (Array.isArray(e)) {
errors = errors.concat(...e);
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, _toConsumableArray(e));
} else {
errors.push(e);
}
}
for (var i = 0; i < results.length; i++) {
add(results[i]);
}
if (!errors.length) {
callback(null, source);
} else {
errors.push(e);
fields = convertFieldsError(errors);
callback(errors, fields);
}
}
for (let i = 0; i < results.length; i++) {
add(results[i]);
}
if (!errors.length) {
callback(null, source);
if (options.messages) {
var messages = this.messages();
if (messages === defaultMessages) {
messages = newMessages();
}
deepMerge(messages, options.messages);
options.messages = messages;
} else {
fields = convertFieldsError(errors);
callback(errors, fields);
options.messages = this.messages();
}
}
if (options.messages) {
let messages = this.messages();
if (messages === defaultMessages) {
messages = newMessages();
}
deepMerge(messages, options.messages);
options.messages = messages;
} else {
options.messages = this.messages();
}
const series = {};
const keys = options.keys || Object.keys(this.rules);
keys.forEach(z => {
const arr = this.rules[z];
let value = source[z];
arr.forEach(r => {
let rule = r;
if (typeof rule.transform === 'function') {
if (source === source_) {
source = {
...source
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 = _objectSpread({}, source);
}
value = source[z] = rule.transform(value);
if (value !== undefined && value !== null) {
rule.type = rule.type || (Array.isArray(value) ? 'array' : _typeof(value));
}
}
if (typeof rule === 'function') {
rule = {
validator: rule
};
} else {
rule = _objectSpread({}, rule);
}
value = source[z] = rule.transform(value);
if (value !== undefined && value !== null) {
rule.type = rule.type || (Array.isArray(value) ? 'array' : typeof value);
// Fill validator. Skip if nothing need to validate
rule.validator = _this2.getValidationMethod(rule);
if (!rule.validator) {
return;
}
}
if (typeof rule === 'function') {
rule = {
validator: rule
};
} else {
rule = {
...rule
};
}
// Fill validator. Skip if nothing need to validate
rule.validator = this.getValidationMethod(rule);
if (!rule.validator) {
return;
}
rule.field = z;
rule.fullField = rule.fullField || z;
rule.type = this.getType(rule);
series[z] = series[z] || [];
series[z].push({
rule,
value,
source,
field: z
rule.field = z;
rule.fullField = rule.fullField || z;
rule.type = _this2.getType(rule);
series[z] = series[z] || [];
series[z].push({
rule: rule,
value: value,
source: source,
field: z
});
});
});
});
const errorFields = {};
return asyncMap(series, options, (data, doIt) => {
const rule = data.rule;
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}`,
fullFields: rule.fullFields ? [...rule.fullFields, key] : [key]
};
}
function cb(e = []) {
let errorList = Array.isArray(e) ? e : [e];
if (!options.suppressWarning && errorList.length) {
Schema.warning('async-validator:', errorList);
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 _objectSpread(_objectSpread({}, schema), {}, {
fullField: "".concat(rule.fullField, ".").concat(key),
fullFields: rule.fullFields ? [].concat(_toConsumableArray(rule.fullFields), [key]) : [key]
});
}
if (errorList.length && rule.message !== undefined && rule.message !== null) {
errorList = [].concat(rule.message);
}
function cb() {
var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
var errorList = Array.isArray(e) ? e : [e];
if (!options.suppressWarning && errorList.length) {
Schema.warning('async-validator:', errorList);
}
if (errorList.length && rule.message !== undefined && rule.message !== null) {
errorList = [].concat(rule.message);
}
// Fill error info
let 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 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 !== undefined) {
filledErrors = [].concat(rule.message).map(complementError(rule, source));
} else if (options.error) {
filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
}
// Fill error info
var filledErrors = errorList.map(complementError(rule, source));
if (options.first && filledErrors.length) {
errorFields[rule.field] = 1;
return doIt(filledErrors);
}
let fieldsSchema = {};
if (rule.defaultField) {
Object.keys(data.value).map(key => {
fieldsSchema[key] = rule.defaultField;
if (!deep) {
doIt(filledErrors);
} 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 !== undefined) {
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 = _objectSpread(_objectSpread({}, 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 Schema(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, _toConsumableArray(filledErrors));
}
if (errs && errs.length) {
finalErrors.push.apply(finalErrors, _toConsumableArray(errs));
}
doIt(finalErrors.length ? finalErrors : null);
});
}
fieldsSchema = {
...fieldsSchema,
...data.rule.fields
};
const paredFieldsSchema = {};
Object.keys(fieldsSchema).forEach(field => {
const fieldSchema = fieldsSchema[field];
const fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
});
const schema = new Schema(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, errs => {
const finalErrors = [];
if (filledErrors && filledErrors.length) {
finalErrors.push(...filledErrors);
}
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) {
var _console$error, _console;
(_console$error = (_console = console).error) === null || _console$error === void 0 || _console$error.call(_console, error);
// rethrow to report error
if (!options.suppressValidatorError) {
setTimeout(function () {
throw error;
}, 0);
}
if (errs && errs.length) {
finalErrors.push(...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) {
try {
res = rule.validator(rule, data.value, cb, data.source, options);
} catch (error) {
console.error?.(error);
// rethrow to report error
if (!options.suppressValidatorError) {
setTimeout(() => {
throw error;
}, 0);
cb(error.message);
}
cb(error.message);
if (res === true) {
cb();
} else if (res === false) {
cb(typeof rule.message === 'function' ? rule.message(rule.fullField || rule.field) : rule.message || "".concat(rule.fullField || rule.field, " fails"));
} else if (res instanceof Array) {
cb(res);
} else if (res instanceof Error) {
cb(res.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);
}
}, {
key: "getType",
value: function getType(rule) {
if (rule.type === undefined && rule.pattern instanceof RegExp) {
rule.type = 'pattern';
}
if (res && res.then) {
res.then(() => cb(), e => cb(e));
if (typeof rule.validator !== 'function' && rule.type && !validators.hasOwnProperty(rule.type)) {
throw new Error(format('Unknown rule type %s', rule.type));
}
}, results => {
complete(results);
}, source);
}
getType(rule) {
if (rule.type === undefined && rule.pattern instanceof RegExp) {
rule.type = 'pattern';
return rule.type || 'string';
}
if (typeof rule.validator !== 'function' && rule.type && !validators.hasOwnProperty(rule.type)) {
throw new Error(format('Unknown rule type %s', rule.type));
}, {
key: "getValidationMethod",
value: 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)] || undefined;
}
return rule.type || 'string';
}]);
return Schema;
}();
// ========================= Static =========================
_defineProperty(Schema, "register", function register(type, validator) {
if (typeof validator !== 'function') {
throw new Error('Cannot register a validator by type, validator is not a 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)] || undefined;
}
}
validators[type] = validator;
});
_defineProperty(Schema, "warning", warning);
_defineProperty(Schema, "messages", defaultMessages);
_defineProperty(Schema, "validators", validators);
export default Schema;
+3
-3
es/messages.js

@@ -49,4 +49,4 @@ export function newMessages() {

},
clone() {
const cloned = JSON.parse(JSON.stringify(this));
clone: function clone() {
var cloned = JSON.parse(JSON.stringify(this));
cloned.clone = this.clone;

@@ -57,2 +57,2 @@ return cloned;

}
export const messages = newMessages();
export var messages = newMessages();
+2
-2
es/rule/enum.js
import { format } from "../util";
const ENUM = 'enum';
const enumerable = (rule, value, source, errors, options) => {
var ENUM = 'enum';
var enumerable = function enumerable(rule, value, source, errors, options) {
rule[ENUM] = Array.isArray(rule[ENUM]) ? rule[ENUM] : [];

@@ -5,0 +5,0 @@ if (rule[ENUM].indexOf(value) === -1) {

+5
-5
es/rule/index.js

@@ -8,8 +8,8 @@ import enumRule from "./enum";

export default {
required,
whitespace,
type,
range,
required: required,
whitespace: whitespace,
type: type,
range: range,
enum: enumRule,
pattern
pattern: pattern
};
+2
-2
es/rule/pattern.js
import { format } from "../util";
const pattern = (rule, value, source, errors, options) => {
var pattern = function pattern(rule, value, source, errors, options) {
if (rule.pattern) {

@@ -13,3 +13,3 @@ if (rule.pattern instanceof RegExp) {

} else if (typeof rule.pattern === 'string') {
const _pattern = new RegExp(rule.pattern);
var _pattern = new RegExp(rule.pattern);
if (!_pattern.test(value)) {

@@ -16,0 +16,0 @@ errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));

+10
-10
es/rule/range.js
import { format } from "../util";
const range = (rule, value, source, errors, options) => {
const len = typeof rule.len === 'number';
const min = typeof rule.min === 'number';
const max = typeof rule.max === 'number';
var range = function range(rule, value, source, errors, options) {
var len = typeof rule.len === 'number';
var min = typeof rule.min === 'number';
var max = typeof rule.max === 'number';
// 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）
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);
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) {

@@ -14,0 +14,0 @@ key = 'number';

+1
-1
es/rule/required.js
import { format, isEmptyValue } from "../util";
const required = (rule, value, source, errors, options, type) => {
var required = function required(rule, value, source, errors, options, type) {
if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type || rule.type))) {

@@ -4,0 +4,0 @@ errors.push(format(options.messages.required, rule.fullField));

+20
-19
es/rule/type.js

@@ -0,1 +1,2 @@

import _typeof from "@babel/runtime/helpers/esm/typeof";
import { format } from "../util";

@@ -6,3 +7,3 @@ import required from "./required";

const pattern = {
var pattern = {
// http://emailregex.com/

@@ -23,13 +24,13 @@ 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,}))$/,

};
const types = {
integer(value) {
var types = {
integer: function integer(value) {
return types.number(value) && parseInt(value, 10) === value;
},
float(value) {
float: function float(value) {
return types.number(value) && !types.integer(value);
},
array(value) {
array: function array(value) {
return Array.isArray(value);
},
regexp(value) {
regexp: function regexp(value) {
if (value instanceof RegExp) {

@@ -44,6 +45,6 @@ return true;

},
date(value) {
date: function date(value) {
return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear === 'function' && !isNaN(value.getTime());
},
number(value) {
number: function number(value) {
if (isNaN(value)) {

@@ -54,22 +55,22 @@ return false;

},
object(value) {
return typeof value === 'object' && !types.array(value);
object: function object(value) {
return _typeof(value) === 'object' && !types.array(value);
},
method(value) {
method: function method(value) {
return typeof value === 'function';
},
email(value) {
email: function email(value) {
return typeof value === 'string' && value.length <= 320 && !!value.match(pattern.email);
},
tel(value) {
tel: function tel(value) {
return typeof value === 'string' && value.length <= 32 && !!value.match(pattern.tel);
},
url(value) {
url: function url(value) {
return typeof value === 'string' && value.length <= 2048 && !!value.match(getUrlRegex());
},
hex(value) {
hex: function hex(value) {
return typeof value === 'string' && !!value.match(pattern.hex);
}
};
const type = (rule, value, source, errors, options) => {
var type = function type(rule, value, source, errors, options) {
if (rule.required && value === undefined) {

@@ -79,4 +80,4 @@ required(rule, value, source, errors, options);

}
const custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'tel', 'number', 'date', 'url', 'hex'];
const ruleType = rule.type;
var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'tel', 'number', 'date', 'url', 'hex'];
var ruleType = rule.type;
if (custom.indexOf(ruleType) > -1) {

@@ -87,3 +88,3 @@ if (!types[ruleType](value)) {

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

@@ -90,0 +91,0 @@ }

+41
-40
es/rule/url.js
// https://github.com/kevva/url-regex/blob/master/index.js
let urlReg;
export default (() => {
var urlReg;
export default (function () {
if (urlReg) {
return urlReg;
}
const word = '[a-fA-F\\d:]';
const b = options => options && options.includeBoundaries ? `(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))` : '';
const v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
const v6seg = '[a-fA-F\\d]{1,4}';
const v6List = [`(?:${v6seg}:){7}(?:${v6seg}|:)`,
// 1:2:3:4:5:6:7:: 1:2:3:4:5:6:7:8
`(?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)`,
// 1:2:3:4:5:6:: 1:2:3:4:5:6::8 1:2:3:4:5:6::8 1:2:3:4:5:6::
`(?:${v6seg}:){5}(?::${v4}|(?::${v6seg}){1,2}|:)`,
// 1:2:3:4:5:: 1:2:3:4:5::7:8 1:2:3:4:5::8 1:2:3:4:5::
`(?:${v6seg}:){4}(?:(?::${v6seg}){0,1}:${v4}|(?::${v6seg}){1,3}|:)`,
// 1:2:3:4:: 1:2:3:4::6:7:8 1:2:3:4::8 1:2:3:4::
`(?:${v6seg}:){3}(?:(?::${v6seg}){0,2}:${v4}|(?::${v6seg}){1,4}|:)`,
// 1:2:3:: 1:2:3::5:6:7:8 1:2:3::8 1:2:3::
`(?:${v6seg}:){2}(?:(?::${v6seg}){0,3}:${v4}|(?::${v6seg}){1,5}|:)`,
// 1:2:: 1:2::4:5:6:7:8 1:2::8 1:2::
`(?:${v6seg}:){1}(?:(?::${v6seg}){0,4}:${v4}|(?::${v6seg}){1,6}|:)`,
// 1:: 1::3:4:5:6:7:8 1::8 1::
`(?::(?:(?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))` // ::2:3:4:5:6:7:8 ::2:3:4:5:6:7:8 ::8 ::
var word = '[a-fA-F\\d:]';
var b = function b(options) {
return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=".concat(word, ")|(?<=").concat(word, ")(?=\\s|$))") : '';
};
var v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
var v6seg = '[a-fA-F\\d]{1,4}';
var v6List = ["(?:".concat(v6seg, ":){7}(?:").concat(v6seg, "|:)"), // 1:2:3:4:5:6:7:: 1:2:3:4:5:6:7:8
"(?:".concat(v6seg, ":){6}(?:").concat(v4, "|:").concat(v6seg, "|:)"), // 1:2:3:4:5:6:: 1:2:3:4:5:6::8 1:2:3:4:5:6::8 1:2:3:4:5:6::
"(?:".concat(v6seg, ":){5}(?::").concat(v4, "|(?::").concat(v6seg, "){1,2}|:)"), // 1:2:3:4:5:: 1:2:3:4:5::7:8 1:2:3:4:5::8 1:2:3:4:5::
"(?:".concat(v6seg, ":){4}(?:(?::").concat(v6seg, "){0,1}:").concat(v4, "|(?::").concat(v6seg, "){1,3}|:)"), // 1:2:3:4:: 1:2:3:4::6:7:8 1:2:3:4::8 1:2:3:4::
"(?:".concat(v6seg, ":){3}(?:(?::").concat(v6seg, "){0,2}:").concat(v4, "|(?::").concat(v6seg, "){1,4}|:)"), // 1:2:3:: 1:2:3::5:6:7:8 1:2:3::8 1:2:3::
"(?:".concat(v6seg, ":){2}(?:(?::").concat(v6seg, "){0,3}:").concat(v4, "|(?::").concat(v6seg, "){1,5}|:)"), // 1:2:: 1:2::4:5:6:7:8 1:2::8 1:2::
"(?:".concat(v6seg, ":){1}(?:(?::").concat(v6seg, "){0,4}:").concat(v4, "|(?::").concat(v6seg, "){1,6}|:)"), // 1:: 1::3:4:5:6:7:8 1::8 1::
"(?::(?:(?::".concat(v6seg, "){0,5}:").concat(v4, "|(?::").concat(v6seg, "){1,7}|:))") // ::2:3:4:5:6:7:8 ::2:3:4:5:6:7:8 ::8 ::
];
const v6Eth0 = `(?:%[0-9a-zA-Z]{1,})?`; // %eth0 %1
var v6Eth0 = "(?:%[0-9a-zA-Z]{1,})?"; // %eth0 %1
const v6 = `(?:${v6List.join('|')})${v6Eth0}`;
var v6 = "(?:".concat(v6List.join('|'), ")").concat(v6Eth0);
// Pre-compile only the exact regexes because adding a global flag make regexes stateful
const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
const v4exact = new RegExp(`^${v4}$`);
const v6exact = new RegExp(`^${v6}$`);
const ip = options => options && options.exact ? v46Exact : new RegExp(`(?:${b(options)}${v4}${b(options)})|(?:${b(options)}${v6}${b(options)})`, 'g');
ip.v4 = options => options && options.exact ? v4exact : new RegExp(`${b(options)}${v4}${b(options)}`, 'g');
ip.v6 = options => options && options.exact ? v6exact : new RegExp(`${b(options)}${v6}${b(options)}`, 'g');
const protocol = `(?:(?:[a-z]+:)?//)`;
const auth = '(?:\\S+(?::\\S*)?@)?';
const ipv4 = ip.v4().source;
const ipv6 = ip.v6().source;
const host = '(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)';
const domain = '(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*';
const tld = `(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))`;
const port = '(?::\\d{2,5})?';
const path = '(?:[/?#][^\\s"]*)?';
const regex = `(?:${protocol}|www\\.)${auth}(?:localhost|${ipv4}|${ipv6}|${host}${domain}${tld})${port}${path}`;
urlReg = new RegExp(`(?:^${regex}$)`, 'i');
var v46Exact = new RegExp("(?:^".concat(v4, "$)|(?:^").concat(v6, "$)"));
var v4exact = new RegExp("^".concat(v4, "$"));
var v6exact = new RegExp("^".concat(v6, "$"));
var ip = function ip(options) {
return options && options.exact ? v46Exact : new RegExp("(?:".concat(b(options)).concat(v4).concat(b(options), ")|(?:").concat(b(options)).concat(v6).concat(b(options), ")"), 'g');
};
ip.v4 = function (options) {
return options && options.exact ? v4exact : new RegExp("".concat(b(options)).concat(v4).concat(b(options)), 'g');
};
ip.v6 = function (options) {
return options && options.exact ? v6exact : new RegExp("".concat(b(options)).concat(v6).concat(b(options)), 'g');
};
var protocol = "(?:(?:[a-z]+:)?//)";
var auth = '(?:\\S+(?::\\S*)?@)?';
var ipv4 = ip.v4().source;
var ipv6 = ip.v6().source;
var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
var port = '(?::\\d{2,5})?';
var path = '(?:[/?#][^\\s"]*)?';
var regex = "(?:".concat(protocol, "|www\\.)").concat(auth, "(?:localhost|").concat(ipv4, "|").concat(ipv6, "|").concat(host).concat(domain).concat(tld, ")").concat(port).concat(path);
urlReg = new RegExp("(?:^".concat(regex, "$)"), 'i');
return urlReg;
});
+1
-1
es/rule/whitespace.js

@@ -14,3 +14,3 @@ import { format } from "../util";

*/
const whitespace = (rule, value, source, errors, options) => {
var whitespace = function whitespace(rule, value, source, errors, options) {
if (/^\s+$/.test(value) || value === '') {

@@ -17,0 +17,0 @@ errors.push(format(options.messages.whitespace, rule.fullField));

+79
-57
es/util.js

@@ -0,11 +1,23 @@

import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
import _typeof from "@babel/runtime/helpers/esm/typeof";
import _createClass from "@babel/runtime/helpers/esm/createClass";
import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
import _inherits from "@babel/runtime/helpers/esm/inherits";
import _createSuper from "@babel/runtime/helpers/esm/createSuper";
import _wrapNativeSuper from "@babel/runtime/helpers/esm/wrapNativeSuper";
import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
/* eslint no-console:0 */
const formatRegExp = /%[sdj%]/g;
export let warning = () => {};
var formatRegExp = /%[sdj%]/g;
export 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 = (type, errors) => {
warning = function warning(type, errors) {
if (typeof console !== 'undefined' && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === 'undefined') {
if (errors.every(e => typeof e === 'string')) {
if (errors.every(function (e) {
return typeof e === 'string';
})) {
console.warn(type, errors);

@@ -18,5 +30,5 @@ }

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

@@ -27,5 +39,8 @@ fields[field].push(error);

}
export function format(template, ...args) {
let i = 0;
const len = args.length;
export 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') {

@@ -36,3 +51,3 @@ // eslint-disable-next-line prefer-spread

if (typeof template === 'string') {
const str = template.replace(formatRegExp, x => {
var str = template.replace(formatRegExp, function (x) {
if (x === '%%') {

@@ -83,7 +98,7 @@ return '%';

function asyncParallelArray(arr, func, callback) {
const results = [];
let total = 0;
const arrLength = arr.length;
var results = [];
var total = 0;
var arrLength = arr.length;
function count(errors) {
results.push(...(errors || []));
results.push.apply(results, _toConsumableArray(errors || []));
total++;

@@ -94,3 +109,3 @@ if (total === arrLength) {

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

@@ -100,4 +115,4 @@ });

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

@@ -108,3 +123,3 @@ if (errors && errors.length) {

}
const original = index;
var original = index;
index = index + 1;

@@ -120,37 +135,45 @@ if (original < arrLength) {

function flattenObjArr(objArr) {
const ret = [];
Object.keys(objArr).forEach(k => {
ret.push(...(objArr[k] || []));
var ret = [];
Object.keys(objArr).forEach(function (k) {
ret.push.apply(ret, _toConsumableArray(objArr[k] || []));
});
return ret;
}
export class AsyncValidationError extends Error {
errors;
fields;
constructor(errors, fields) {
super('Async Validation Error');
this.errors = errors;
this.fields = fields;
export var AsyncValidationError = /*#__PURE__*/function (_Error) {
_inherits(AsyncValidationError, _Error);
var _super = _createSuper(AsyncValidationError);
function AsyncValidationError(errors, fields) {
var _this;
_classCallCheck(this, AsyncValidationError);
_this = _super.call(this, 'Async Validation Error');
_defineProperty(_assertThisInitialized(_this), "errors", void 0);
_defineProperty(_assertThisInitialized(_this), "fields", void 0);
_this.errors = errors;
_this.fields = fields;
return _this;
}
}
return _createClass(AsyncValidationError);
}( /*#__PURE__*/_wrapNativeSuper(Error));
export function asyncMap(objArr, option, func, callback, source) {
if (option.first) {
const pending = new Promise((resolve, reject) => {
const next = errors => {
var _pending = new Promise(function (resolve, reject) {
var next = function next(errors) {
callback(errors);
return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
};
const flattenArr = flattenObjArr(objArr);
var flattenArr = flattenObjArr(objArr);
asyncSerialArray(flattenArr, func, next);
});
pending.catch(e => e);
return pending;
_pending.catch(function (e) {
return e;
});
return _pending;
}
const firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
const objArrKeys = Object.keys(objArr);
const objArrLength = objArrKeys.length;
let total = 0;
const results = [];
const pending = new Promise((resolve, reject) => {
const next = errors => {
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 next(errors) {
// eslint-disable-next-line prefer-spread

@@ -168,4 +191,4 @@ results.push.apply(results, errors);

}
objArrKeys.forEach(key => {
const arr = objArr[key];
objArrKeys.forEach(function (key) {
var arr = objArr[key];
if (firstFields.indexOf(key) !== -1) {

@@ -178,3 +201,5 @@ asyncSerialArray(arr, func, next);

});
pending.catch(e => e);
pending.catch(function (e) {
return e;
});
return pending;

@@ -186,4 +211,4 @@ }

function getValue(value, path) {
let v = value;
for (let i = 0; i < path.length; i++) {
var v = value;
for (var i = 0; i < path.length; i++) {
if (v == undefined) {

@@ -197,4 +222,4 @@ return v;

export function complementError(rule, source) {
return oe => {
let fieldValue;
return function (oe) {
var fieldValue;
if (rule.fullFields) {

@@ -212,3 +237,3 @@ fieldValue = getValue(source, rule.fullFields);

message: typeof oe === 'function' ? oe() : oe,
fieldValue,
fieldValue: fieldValue,
field: oe.field || rule.fullField

@@ -220,10 +245,7 @@ };

if (source) {
for (const s in source) {
for (var s in source) {
if (source.hasOwnProperty(s)) {
const value = source[s];
if (typeof value === 'object' && typeof target[s] === 'object') {
target[s] = {
...target[s],
...value
};
var value = source[s];
if (_typeof(value) === 'object' && _typeof(target[s]) === 'object') {
target[s] = _objectSpread(_objectSpread({}, target[s]), value);
} else {

@@ -230,0 +252,0 @@ target[s] = value;

+3
-3
es/validator/any.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const any = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var any = function any(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (isEmptyValue(value) && !rule.required) {

+3
-3
es/validator/array.js
import rules from "../rule/index";
const array = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var array = function array(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -6,0 +6,0 @@ if ((value === undefined || value === null) && !rule.required) {

+3
-3
es/validator/boolean.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const boolean = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var boolean = function boolean(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (isEmptyValue(value) && !rule.required) {

+4
-4
es/validator/date.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const date = (rule, value, callback, source, options) => {
var date = function date(rule, value, callback, source, options) {
// console.log('integer rule called %j', rule);
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
// console.log('validate on %s value', value);

@@ -14,3 +14,3 @@ if (validate) {

if (!isEmptyValue(value, 'date')) {
let dateObject;
var dateObject;
if (value instanceof Date) {

@@ -17,0 +17,0 @@ dateObject = value;

+4
-4
es/validator/enum.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const ENUM = 'enum';
const enumerable = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var ENUM = 'enum';
var enumerable = function enumerable(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -8,0 +8,0 @@ if (isEmptyValue(value) && !rule.required) {

+3
-3
es/validator/float.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const floatFn = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var floatFn = function floatFn(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (isEmptyValue(value) && !rule.required) {

+13
-13
es/validator/index.js

@@ -17,14 +17,14 @@ import any from "./any";

export default {
string,
method,
number,
boolean,
regexp,
integer,
float,
array,
object,
string: string,
method: method,
number: number,
boolean: boolean,
regexp: regexp,
integer: integer,
float: float,
array: array,
object: object,
enum: enumValidator,
pattern,
date,
pattern: pattern,
date: date,
url: type,

@@ -34,4 +34,4 @@ hex: type,

tel: type,
required,
any
required: required,
any: any
};
+3
-3
es/validator/integer.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const integer = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var integer = function integer(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (isEmptyValue(value) && !rule.required) {

+3
-3
es/validator/method.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const method = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var method = function method(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (isEmptyValue(value) && !rule.required) {

+3
-3
es/validator/number.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const number = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var number = function number(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (value === '') {

+3
-3
es/validator/object.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const object = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var object = function object(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (isEmptyValue(value) && !rule.required) {

+3
-3
es/validator/pattern.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const pattern = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var pattern = function pattern(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (isEmptyValue(value, 'string') && !rule.required) {

+3
-3
es/validator/regexp.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const regexp = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var regexp = function regexp(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (isEmptyValue(value) && !rule.required) {

+4
-3
es/validator/required.js

@@ -0,5 +1,6 @@

import _typeof from "@babel/runtime/helpers/esm/typeof";
import rules from "../rule";
const required = (rule, value, callback, source, options) => {
const errors = [];
const type = Array.isArray(value) ? 'array' : typeof value;
var required = function required(rule, value, callback, source, options) {
var errors = [];
var type = Array.isArray(value) ? 'array' : _typeof(value);
rules.required(rule, value, source, errors, options, type);

@@ -6,0 +7,0 @@ callback(errors);

+3
-3
es/validator/string.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const string = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var string = function string(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -7,0 +7,0 @@ if (isEmptyValue(value, 'string') && !rule.required) {

+4
-4
es/validator/type.js
import rules from "../rule";
import { isEmptyValue } from "../util";
const type = (rule, value, callback, source, options) => {
const ruleType = rule.type;
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var type = function type(rule, value, callback, source, options) {
var ruleType = rule.type;
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -8,0 +8,0 @@ if (isEmptyValue(value, ruleType) && !rule.required) {

+252
-234
lib/index.js

@@ -9,3 +9,9 @@ "use strict";

exports.default = void 0;
var _messages = require("./messages");
var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _messages2 = require("./messages");
var _util = require("./util");

@@ -20,3 +26,3 @@ var _index = _interopRequireDefault(require("./validator/index"));

enumerable: true,
get: function () {
get: function get() {
return _interface[key];

@@ -32,264 +38,276 @@ }

*/
class Schema {
// ========================= Static =========================
static register = function register(type, validator) {
if (typeof validator !== 'function') {
throw new Error('Cannot register a validator by type, validator is not a function');
}
_index.default[type] = validator;
};
static warning = _util.warning;
static messages = _messages.messages;
static validators = _index.default;
// ======================== Instance ========================
rules = null;
_messages = _messages.messages;
constructor(descriptor) {
var Schema = /*#__PURE__*/function () {
function Schema(descriptor) {
(0, _classCallCheck2.default)(this, Schema);
// ======================== Instance ========================
(0, _defineProperty2.default)(this, "rules", null);
(0, _defineProperty2.default)(this, "_messages", _messages2.messages);
this.define(descriptor);
}
define(rules) {
if (!rules) {
throw new Error('Cannot configure a schema with no rules');
(0, _createClass2.default)(Schema, [{
key: "define",
value: function define(rules) {
var _this = this;
if (!rules) {
throw new Error('Cannot configure a schema with no rules');
}
if ((0, _typeof2.default)(rules) !== 'object' || Array.isArray(rules)) {
throw new Error('Rules must be an object');
}
this.rules = {};
Object.keys(rules).forEach(function (name) {
var item = rules[name];
_this.rules[name] = Array.isArray(item) ? item : [item];
});
}
if (typeof rules !== 'object' || Array.isArray(rules)) {
throw new Error('Rules must be an object');
}, {
key: "messages",
value: function messages(_messages) {
if (_messages) {
this._messages = (0, _util.deepMerge)((0, _messages2.newMessages)(), _messages);
}
return this._messages;
}
this.rules = {};
Object.keys(rules).forEach(name => {
const item = rules[name];
this.rules[name] = Array.isArray(item) ? item : [item];
});
}
messages(messages) {
if (messages) {
this._messages = (0, _util.deepMerge)((0, _messages.newMessages)(), messages);
}
return this._messages;
}
// eslint-disable-next-line @typescript-eslint/unified-signatures
validate(source_, o = {}, oc = () => {}) {
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(null, source);
}, {
key: "validate",
value: function validate(source_) {
var _this2 = this;
var o = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var oc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
var source = source_;
var options = o;
var callback = oc;
if (typeof options === 'function') {
callback = options;
options = {};
}
return Promise.resolve(source);
}
function complete(results) {
let errors = [];
let fields = {};
function add(e) {
if (Array.isArray(e)) {
errors = errors.concat(...e);
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, (0, _toConsumableArray2.default)(e));
} else {
errors.push(e);
}
}
for (var i = 0; i < results.length; i++) {
add(results[i]);
}
if (!errors.length) {
callback(null, source);
} else {
errors.push(e);
fields = (0, _util.convertFieldsError)(errors);
callback(errors, fields);
}
}
for (let i = 0; i < results.length; i++) {
add(results[i]);
}
if (!errors.length) {
callback(null, source);
if (options.messages) {
var messages = this.messages();
if (messages === _messages2.messages) {
messages = (0, _messages2.newMessages)();
}
(0, _util.deepMerge)(messages, options.messages);
options.messages = messages;
} else {
fields = (0, _util.convertFieldsError)(errors);
callback(errors, fields);
options.messages = this.messages();
}
}
if (options.messages) {
let messages = this.messages();
if (messages === _messages.messages) {
messages = (0, _messages.newMessages)();
}
(0, _util.deepMerge)(messages, options.messages);
options.messages = messages;
} else {
options.messages = this.messages();
}
const series = {};
const keys = options.keys || Object.keys(this.rules);
keys.forEach(z => {
const arr = this.rules[z];
let value = source[z];
arr.forEach(r => {
let rule = r;
if (typeof rule.transform === 'function') {
if (source === source_) {
source = {
...source
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 = (0, _objectSpread2.default)({}, source);
}
value = source[z] = rule.transform(value);
if (value !== undefined && value !== null) {
rule.type = rule.type || (Array.isArray(value) ? 'array' : (0, _typeof2.default)(value));
}
}
if (typeof rule === 'function') {
rule = {
validator: rule
};
} else {
rule = (0, _objectSpread2.default)({}, rule);
}
value = source[z] = rule.transform(value);
if (value !== undefined && value !== null) {
rule.type = rule.type || (Array.isArray(value) ? 'array' : typeof value);
// Fill validator. Skip if nothing need to validate
rule.validator = _this2.getValidationMethod(rule);
if (!rule.validator) {
return;
}
}
if (typeof rule === 'function') {
rule = {
validator: rule
};
} else {
rule = {
...rule
};
}
// Fill validator. Skip if nothing need to validate
rule.validator = this.getValidationMethod(rule);
if (!rule.validator) {
return;
}
rule.field = z;
rule.fullField = rule.fullField || z;
rule.type = this.getType(rule);
series[z] = series[z] || [];
series[z].push({
rule,
value,
source,
field: z
rule.field = z;
rule.fullField = rule.fullField || z;
rule.type = _this2.getType(rule);
series[z] = series[z] || [];
series[z].push({
rule: rule,
value: value,
source: source,
field: z
});
});
});
});
const errorFields = {};
return (0, _util.asyncMap)(series, options, (data, doIt) => {
const rule = data.rule;
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}`,
fullFields: rule.fullFields ? [...rule.fullFields, key] : [key]
};
}
function cb(e = []) {
let errorList = Array.isArray(e) ? e : [e];
if (!options.suppressWarning && errorList.length) {
Schema.warning('async-validator:', errorList);
var errorFields = {};
return (0, _util.asyncMap)(series, options, function (data, doIt) {
var rule = data.rule;
var deep = (rule.type === 'object' || rule.type === 'array') && ((0, _typeof2.default)(rule.fields) === 'object' || (0, _typeof2.default)(rule.defaultField) === 'object');
deep = deep && (rule.required || !rule.required && data.value);
rule.field = data.field;
function addFullField(key, schema) {
return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, schema), {}, {
fullField: "".concat(rule.fullField, ".").concat(key),
fullFields: rule.fullFields ? [].concat((0, _toConsumableArray2.default)(rule.fullFields), [key]) : [key]
});
}
if (errorList.length && rule.message !== undefined && rule.message !== null) {
errorList = [].concat(rule.message);
}
function cb() {
var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
var errorList = Array.isArray(e) ? e : [e];
if (!options.suppressWarning && errorList.length) {
Schema.warning('async-validator:', errorList);
}
if (errorList.length && rule.message !== undefined && rule.message !== null) {
errorList = [].concat(rule.message);
}
// Fill error info
let filledErrors = errorList.map((0, _util.complementError)(rule, source));
if (options.first && filledErrors.length) {
errorFields[rule.field] = 1;
return doIt(filledErrors);
}
if (!deep) {
doIt(filledErrors);
} 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 !== undefined) {
filledErrors = [].concat(rule.message).map((0, _util.complementError)(rule, source));
} else if (options.error) {
filledErrors = [options.error(rule, (0, _util.format)(options.messages.required, rule.field))];
}
// Fill error info
var filledErrors = errorList.map((0, _util.complementError)(rule, source));
if (options.first && filledErrors.length) {
errorFields[rule.field] = 1;
return doIt(filledErrors);
}
let fieldsSchema = {};
if (rule.defaultField) {
Object.keys(data.value).map(key => {
fieldsSchema[key] = rule.defaultField;
if (!deep) {
doIt(filledErrors);
} 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 !== undefined) {
filledErrors = [].concat(rule.message).map((0, _util.complementError)(rule, source));
} else if (options.error) {
filledErrors = [options.error(rule, (0, _util.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 = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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 Schema(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, (0, _toConsumableArray2.default)(filledErrors));
}
if (errs && errs.length) {
finalErrors.push.apply(finalErrors, (0, _toConsumableArray2.default)(errs));
}
doIt(finalErrors.length ? finalErrors : null);
});
}
fieldsSchema = {
...fieldsSchema,
...data.rule.fields
};
const paredFieldsSchema = {};
Object.keys(fieldsSchema).forEach(field => {
const fieldSchema = fieldsSchema[field];
const fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
});
const schema = new Schema(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, errs => {
const finalErrors = [];
if (filledErrors && filledErrors.length) {
finalErrors.push(...filledErrors);
}
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) {
var _console$error, _console;
(_console$error = (_console = console).error) === null || _console$error === void 0 || _console$error.call(_console, error);
// rethrow to report error
if (!options.suppressValidatorError) {
setTimeout(function () {
throw error;
}, 0);
}
if (errs && errs.length) {
finalErrors.push(...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) {
try {
res = rule.validator(rule, data.value, cb, data.source, options);
} catch (error) {
console.error?.(error);
// rethrow to report error
if (!options.suppressValidatorError) {
setTimeout(() => {
throw error;
}, 0);
cb(error.message);
}
cb(error.message);
if (res === true) {
cb();
} else if (res === false) {
cb(typeof rule.message === 'function' ? rule.message(rule.fullField || rule.field) : rule.message || "".concat(rule.fullField || rule.field, " fails"));
} else if (res instanceof Array) {
cb(res);
} else if (res instanceof Error) {
cb(res.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);
}
}, {
key: "getType",
value: function getType(rule) {
if (rule.type === undefined && rule.pattern instanceof RegExp) {
rule.type = 'pattern';
}
if (res && res.then) {
res.then(() => cb(), e => cb(e));
if (typeof rule.validator !== 'function' && rule.type && !_index.default.hasOwnProperty(rule.type)) {
throw new Error((0, _util.format)('Unknown rule type %s', rule.type));
}
}, results => {
complete(results);
}, source);
}
getType(rule) {
if (rule.type === undefined && rule.pattern instanceof RegExp) {
rule.type = 'pattern';
return rule.type || 'string';
}
if (typeof rule.validator !== 'function' && rule.type && !_index.default.hasOwnProperty(rule.type)) {
throw new Error((0, _util.format)('Unknown rule type %s', rule.type));
}, {
key: "getValidationMethod",
value: 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 _index.default.required;
}
return _index.default[this.getType(rule)] || undefined;
}
return rule.type || 'string';
}]);
return Schema;
}();
// ========================= Static =========================
(0, _defineProperty2.default)(Schema, "register", function register(type, validator) {
if (typeof validator !== 'function') {
throw new Error('Cannot register a validator by type, validator is not a 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 _index.default.required;
}
return _index.default[this.getType(rule)] || undefined;
}
}
_index.default[type] = validator;
});
(0, _defineProperty2.default)(Schema, "warning", _util.warning);
(0, _defineProperty2.default)(Schema, "messages", _messages2.messages);
(0, _defineProperty2.default)(Schema, "validators", _index.default);
var _default = exports.default = Schema;
+3
-3
lib/messages.js

@@ -56,4 +56,4 @@ "use strict";

},
clone() {
const cloned = JSON.parse(JSON.stringify(this));
clone: function clone() {
var cloned = JSON.parse(JSON.stringify(this));
cloned.clone = this.clone;

@@ -64,2 +64,2 @@ return cloned;

}
const messages = exports.messages = newMessages();
var messages = exports.messages = newMessages();
+2
-2
lib/rule/enum.js

@@ -8,4 +8,4 @@ "use strict";

var _util = require("../util");
const ENUM = 'enum';
const enumerable = (rule, value, source, errors, options) => {
var ENUM = 'enum';
var enumerable = function enumerable(rule, value, source, errors, options) {
rule[ENUM] = Array.isArray(rule[ENUM]) ? rule[ENUM] : [];

@@ -12,0 +12,0 @@ if (rule[ENUM].indexOf(value) === -1) {

+2
-2
lib/rule/pattern.js

@@ -8,3 +8,3 @@ "use strict";

var _util = require("../util");
const pattern = (rule, value, source, errors, options) => {
var pattern = function pattern(rule, value, source, errors, options) {
if (rule.pattern) {

@@ -20,3 +20,3 @@ if (rule.pattern instanceof RegExp) {

} else if (typeof rule.pattern === 'string') {
const _pattern = new RegExp(rule.pattern);
var _pattern = new RegExp(rule.pattern);
if (!_pattern.test(value)) {

@@ -23,0 +23,0 @@ errors.push((0, _util.format)(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));

+10
-10
lib/rule/range.js

@@ -8,13 +8,13 @@ "use strict";

var _util = require("../util");
const range = (rule, value, source, errors, options) => {
const len = typeof rule.len === 'number';
const min = typeof rule.min === 'number';
const max = typeof rule.max === 'number';
var range = function range(rule, value, source, errors, options) {
var len = typeof rule.len === 'number';
var min = typeof rule.min === 'number';
var max = typeof rule.max === 'number';
// 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）
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);
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) {

@@ -21,0 +21,0 @@ key = 'number';

+1
-1
lib/rule/required.js

@@ -8,3 +8,3 @@ "use strict";

var _util = require("../util");
const required = (rule, value, source, errors, options, type) => {
var required = function required(rule, value, source, errors, options, type) {
if (rule.required && (!source.hasOwnProperty(rule.field) || (0, _util.isEmptyValue)(value, type || rule.type))) {

@@ -11,0 +11,0 @@ errors.push((0, _util.format)(options.messages.required, rule.fullField));

+20
-19
lib/rule/type.js

@@ -8,2 +8,3 @@ "use strict";

exports.default = void 0;
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _util = require("../util");

@@ -14,3 +15,3 @@ var _required = _interopRequireDefault(require("./required"));

const pattern = {
var pattern = {
// http://emailregex.com/

@@ -31,13 +32,13 @@ 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,}))$/,

};
const types = {
integer(value) {
var types = {
integer: function integer(value) {
return types.number(value) && parseInt(value, 10) === value;
},
float(value) {
float: function float(value) {
return types.number(value) && !types.integer(value);
},
array(value) {
array: function array(value) {
return Array.isArray(value);
},
regexp(value) {
regexp: function regexp(value) {
if (value instanceof RegExp) {

@@ -52,6 +53,6 @@ return true;

},
date(value) {
date: function date(value) {
return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear === 'function' && !isNaN(value.getTime());
},
number(value) {
number: function number(value) {
if (isNaN(value)) {

@@ -62,22 +63,22 @@ return false;

},
object(value) {
return typeof value === 'object' && !types.array(value);
object: function object(value) {
return (0, _typeof2.default)(value) === 'object' && !types.array(value);
},
method(value) {
method: function method(value) {
return typeof value === 'function';
},
email(value) {
email: function email(value) {
return typeof value === 'string' && value.length <= 320 && !!value.match(pattern.email);
},
tel(value) {
tel: function tel(value) {
return typeof value === 'string' && value.length <= 32 && !!value.match(pattern.tel);
},
url(value) {
url: function url(value) {
return typeof value === 'string' && value.length <= 2048 && !!value.match((0, _url.default)());
},
hex(value) {
hex: function hex(value) {
return typeof value === 'string' && !!value.match(pattern.hex);
}
};
const type = (rule, value, source, errors, options) => {
var type = function type(rule, value, source, errors, options) {
if (rule.required && value === undefined) {

@@ -87,4 +88,4 @@ (0, _required.default)(rule, value, source, errors, options);

}
const custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'tel', 'number', 'date', 'url', 'hex'];
const ruleType = rule.type;
var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'tel', 'number', 'date', 'url', 'hex'];
var ruleType = rule.type;
if (custom.indexOf(ruleType) > -1) {

@@ -95,3 +96,3 @@ if (!types[ruleType](value)) {

// straight typeof check
} else if (ruleType && typeof value !== rule.type) {
} else if (ruleType && (0, _typeof2.default)(value) !== rule.type) {
errors.push((0, _util.format)(options.messages.types[ruleType], rule.fullField, rule.type));

@@ -98,0 +99,0 @@ }

+42
-42
lib/rule/url.js

@@ -8,51 +8,51 @@ "use strict";

// https://github.com/kevva/url-regex/blob/master/index.js
let urlReg;
var _default = () => {
var urlReg;
var _default = exports.default = function _default() {
if (urlReg) {
return urlReg;
}
const word = '[a-fA-F\\d:]';
const b = options => options && options.includeBoundaries ? `(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))` : '';
const v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
const v6seg = '[a-fA-F\\d]{1,4}';
const v6List = [`(?:${v6seg}:){7}(?:${v6seg}|:)`,
// 1:2:3:4:5:6:7:: 1:2:3:4:5:6:7:8
`(?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)`,
// 1:2:3:4:5:6:: 1:2:3:4:5:6::8 1:2:3:4:5:6::8 1:2:3:4:5:6::
`(?:${v6seg}:){5}(?::${v4}|(?::${v6seg}){1,2}|:)`,
// 1:2:3:4:5:: 1:2:3:4:5::7:8 1:2:3:4:5::8 1:2:3:4:5::
`(?:${v6seg}:){4}(?:(?::${v6seg}){0,1}:${v4}|(?::${v6seg}){1,3}|:)`,
// 1:2:3:4:: 1:2:3:4::6:7:8 1:2:3:4::8 1:2:3:4::
`(?:${v6seg}:){3}(?:(?::${v6seg}){0,2}:${v4}|(?::${v6seg}){1,4}|:)`,
// 1:2:3:: 1:2:3::5:6:7:8 1:2:3::8 1:2:3::
`(?:${v6seg}:){2}(?:(?::${v6seg}){0,3}:${v4}|(?::${v6seg}){1,5}|:)`,
// 1:2:: 1:2::4:5:6:7:8 1:2::8 1:2::
`(?:${v6seg}:){1}(?:(?::${v6seg}){0,4}:${v4}|(?::${v6seg}){1,6}|:)`,
// 1:: 1::3:4:5:6:7:8 1::8 1::
`(?::(?:(?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))` // ::2:3:4:5:6:7:8 ::2:3:4:5:6:7:8 ::8 ::
var word = '[a-fA-F\\d:]';
var b = function b(options) {
return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=".concat(word, ")|(?<=").concat(word, ")(?=\\s|$))") : '';
};
var v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
var v6seg = '[a-fA-F\\d]{1,4}';
var v6List = ["(?:".concat(v6seg, ":){7}(?:").concat(v6seg, "|:)"), // 1:2:3:4:5:6:7:: 1:2:3:4:5:6:7:8
"(?:".concat(v6seg, ":){6}(?:").concat(v4, "|:").concat(v6seg, "|:)"), // 1:2:3:4:5:6:: 1:2:3:4:5:6::8 1:2:3:4:5:6::8 1:2:3:4:5:6::
"(?:".concat(v6seg, ":){5}(?::").concat(v4, "|(?::").concat(v6seg, "){1,2}|:)"), // 1:2:3:4:5:: 1:2:3:4:5::7:8 1:2:3:4:5::8 1:2:3:4:5::
"(?:".concat(v6seg, ":){4}(?:(?::").concat(v6seg, "){0,1}:").concat(v4, "|(?::").concat(v6seg, "){1,3}|:)"), // 1:2:3:4:: 1:2:3:4::6:7:8 1:2:3:4::8 1:2:3:4::
"(?:".concat(v6seg, ":){3}(?:(?::").concat(v6seg, "){0,2}:").concat(v4, "|(?::").concat(v6seg, "){1,4}|:)"), // 1:2:3:: 1:2:3::5:6:7:8 1:2:3::8 1:2:3::
"(?:".concat(v6seg, ":){2}(?:(?::").concat(v6seg, "){0,3}:").concat(v4, "|(?::").concat(v6seg, "){1,5}|:)"), // 1:2:: 1:2::4:5:6:7:8 1:2::8 1:2::
"(?:".concat(v6seg, ":){1}(?:(?::").concat(v6seg, "){0,4}:").concat(v4, "|(?::").concat(v6seg, "){1,6}|:)"), // 1:: 1::3:4:5:6:7:8 1::8 1::
"(?::(?:(?::".concat(v6seg, "){0,5}:").concat(v4, "|(?::").concat(v6seg, "){1,7}|:))") // ::2:3:4:5:6:7:8 ::2:3:4:5:6:7:8 ::8 ::
];
const v6Eth0 = `(?:%[0-9a-zA-Z]{1,})?`; // %eth0 %1
var v6Eth0 = "(?:%[0-9a-zA-Z]{1,})?"; // %eth0 %1
const v6 = `(?:${v6List.join('|')})${v6Eth0}`;
var v6 = "(?:".concat(v6List.join('|'), ")").concat(v6Eth0);
// Pre-compile only the exact regexes because adding a global flag make regexes stateful
const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
const v4exact = new RegExp(`^${v4}$`);
const v6exact = new RegExp(`^${v6}$`);
const ip = options => options && options.exact ? v46Exact : new RegExp(`(?:${b(options)}${v4}${b(options)})|(?:${b(options)}${v6}${b(options)})`, 'g');
ip.v4 = options => options && options.exact ? v4exact : new RegExp(`${b(options)}${v4}${b(options)}`, 'g');
ip.v6 = options => options && options.exact ? v6exact : new RegExp(`${b(options)}${v6}${b(options)}`, 'g');
const protocol = `(?:(?:[a-z]+:)?//)`;
const auth = '(?:\\S+(?::\\S*)?@)?';
const ipv4 = ip.v4().source;
const ipv6 = ip.v6().source;
const host = '(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)';
const domain = '(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*';
const tld = `(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))`;
const port = '(?::\\d{2,5})?';
const path = '(?:[/?#][^\\s"]*)?';
const regex = `(?:${protocol}|www\\.)${auth}(?:localhost|${ipv4}|${ipv6}|${host}${domain}${tld})${port}${path}`;
urlReg = new RegExp(`(?:^${regex}$)`, 'i');
var v46Exact = new RegExp("(?:^".concat(v4, "$)|(?:^").concat(v6, "$)"));
var v4exact = new RegExp("^".concat(v4, "$"));
var v6exact = new RegExp("^".concat(v6, "$"));
var ip = function ip(options) {
return options && options.exact ? v46Exact : new RegExp("(?:".concat(b(options)).concat(v4).concat(b(options), ")|(?:").concat(b(options)).concat(v6).concat(b(options), ")"), 'g');
};
ip.v4 = function (options) {
return options && options.exact ? v4exact : new RegExp("".concat(b(options)).concat(v4).concat(b(options)), 'g');
};
ip.v6 = function (options) {
return options && options.exact ? v6exact : new RegExp("".concat(b(options)).concat(v6).concat(b(options)), 'g');
};
var protocol = "(?:(?:[a-z]+:)?//)";
var auth = '(?:\\S+(?::\\S*)?@)?';
var ipv4 = ip.v4().source;
var ipv6 = ip.v6().source;
var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
var port = '(?::\\d{2,5})?';
var path = '(?:[/?#][^\\s"]*)?';
var regex = "(?:".concat(protocol, "|www\\.)").concat(auth, "(?:localhost|").concat(ipv4, "|").concat(ipv6, "|").concat(host).concat(domain).concat(tld, ")").concat(port).concat(path);
urlReg = new RegExp("(?:^".concat(regex, "$)"), 'i');
return urlReg;
};
exports.default = _default;
};
+1
-1
lib/rule/whitespace.js

@@ -19,3 +19,3 @@ "use strict";

*/
const whitespace = (rule, value, source, errors, options) => {
var whitespace = function whitespace(rule, value, source, errors, options) {
if (/^\s+$/.test(value) || value === '') {

@@ -22,0 +22,0 @@ errors.push((0, _util.format)(options.messages.whitespace, rule.fullField));

+80
-59
lib/util.js
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {

@@ -15,13 +16,24 @@ value: true

exports.warning = void 0;
var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
/* eslint no-console:0 */
const formatRegExp = /%[sdj%]/g;
let warning = () => {};
var formatRegExp = /%[sdj%]/g;
var warning = exports.warning = function warning() {};
// don't print warning message when in production env or node runtime
exports.warning = warning;
if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production' && typeof window !== 'undefined' && typeof document !== 'undefined') {
exports.warning = warning = (type, errors) => {
exports.warning = warning = function warning(type, errors) {
if (typeof console !== 'undefined' && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === 'undefined') {
if (errors.every(e => typeof e === 'string')) {
if (errors.every(function (e) {
return typeof e === 'string';
})) {
console.warn(type, errors);

@@ -34,5 +46,5 @@ }

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

@@ -43,5 +55,8 @@ fields[field].push(error);

}
function format(template, ...args) {
let i = 0;
const len = args.length;
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') {

@@ -52,3 +67,3 @@ // eslint-disable-next-line prefer-spread

if (typeof template === 'string') {
const str = template.replace(formatRegExp, x => {
var str = template.replace(formatRegExp, function (x) {
if (x === '%%') {

@@ -99,7 +114,7 @@ return '%';

function asyncParallelArray(arr, func, callback) {
const results = [];
let total = 0;
const arrLength = arr.length;
var results = [];
var total = 0;
var arrLength = arr.length;
function count(errors) {
results.push(...(errors || []));
results.push.apply(results, (0, _toConsumableArray2.default)(errors || []));
total++;

@@ -110,3 +125,3 @@ if (total === arrLength) {

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

@@ -116,4 +131,4 @@ });

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

@@ -124,3 +139,3 @@ if (errors && errors.length) {

}
const original = index;
var original = index;
index = index + 1;

@@ -136,38 +151,45 @@ if (original < arrLength) {

function flattenObjArr(objArr) {
const ret = [];
Object.keys(objArr).forEach(k => {
ret.push(...(objArr[k] || []));
var ret = [];
Object.keys(objArr).forEach(function (k) {
ret.push.apply(ret, (0, _toConsumableArray2.default)(objArr[k] || []));
});
return ret;
}
class AsyncValidationError extends Error {
errors;
fields;
constructor(errors, fields) {
super('Async Validation Error');
this.errors = errors;
this.fields = fields;
var AsyncValidationError = exports.AsyncValidationError = /*#__PURE__*/function (_Error) {
(0, _inherits2.default)(AsyncValidationError, _Error);
var _super = (0, _createSuper2.default)(AsyncValidationError);
function AsyncValidationError(errors, fields) {
var _this;
(0, _classCallCheck2.default)(this, AsyncValidationError);
_this = _super.call(this, 'Async Validation Error');
(0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "errors", void 0);
(0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "fields", void 0);
_this.errors = errors;
_this.fields = fields;
return _this;
}
}
exports.AsyncValidationError = AsyncValidationError;
return (0, _createClass2.default)(AsyncValidationError);
}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
function asyncMap(objArr, option, func, callback, source) {
if (option.first) {
const pending = new Promise((resolve, reject) => {
const next = errors => {
var _pending = new Promise(function (resolve, reject) {
var next = function next(errors) {
callback(errors);
return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
};
const flattenArr = flattenObjArr(objArr);
var flattenArr = flattenObjArr(objArr);
asyncSerialArray(flattenArr, func, next);
});
pending.catch(e => e);
return pending;
_pending.catch(function (e) {
return e;
});
return _pending;
}
const firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
const objArrKeys = Object.keys(objArr);
const objArrLength = objArrKeys.length;
let total = 0;
const results = [];
const pending = new Promise((resolve, reject) => {
const next = errors => {
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 next(errors) {
// eslint-disable-next-line prefer-spread

@@ -185,4 +207,4 @@ results.push.apply(results, errors);

}
objArrKeys.forEach(key => {
const arr = objArr[key];
objArrKeys.forEach(function (key) {
var arr = objArr[key];
if (firstFields.indexOf(key) !== -1) {

@@ -195,3 +217,5 @@ asyncSerialArray(arr, func, next);

});
pending.catch(e => e);
pending.catch(function (e) {
return e;
});
return pending;

@@ -203,4 +227,4 @@ }

function getValue(value, path) {
let v = value;
for (let i = 0; i < path.length; i++) {
var v = value;
for (var i = 0; i < path.length; i++) {
if (v == undefined) {

@@ -214,4 +238,4 @@ return v;

function complementError(rule, source) {
return oe => {
let fieldValue;
return function (oe) {
var fieldValue;
if (rule.fullFields) {

@@ -229,3 +253,3 @@ fieldValue = getValue(source, rule.fullFields);

message: typeof oe === 'function' ? oe() : oe,
fieldValue,
fieldValue: fieldValue,
field: oe.field || rule.fullField

@@ -237,10 +261,7 @@ };

if (source) {
for (const s in source) {
for (var s in source) {
if (source.hasOwnProperty(s)) {
const value = source[s];
if (typeof value === 'object' && typeof target[s] === 'object') {
target[s] = {
...target[s],
...value
};
var value = source[s];
if ((0, _typeof2.default)(value) === 'object' && (0, _typeof2.default)(target[s]) === 'object') {
target[s] = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, target[s]), value);
} else {

@@ -247,0 +268,0 @@ target[s] = value;

+3
-3
lib/validator/any.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const any = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var any = function any(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if ((0, _util.isEmptyValue)(value) && !rule.required) {

+3
-3
lib/validator/array.js

@@ -9,5 +9,5 @@ "use strict";

var _index = _interopRequireDefault(require("../rule/index"));
const array = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var array = function array(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -14,0 +14,0 @@ if ((value === undefined || value === null) && !rule.required) {

+3
-3
lib/validator/boolean.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const boolean = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var boolean = function boolean(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if ((0, _util.isEmptyValue)(value) && !rule.required) {

+4
-4
lib/validator/date.js

@@ -10,6 +10,6 @@ "use strict";

var _util = require("../util");
const date = (rule, value, callback, source, options) => {
var date = function date(rule, value, callback, source, options) {
// console.log('integer rule called %j', rule);
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
// console.log('validate on %s value', value);

@@ -22,3 +22,3 @@ if (validate) {

if (!(0, _util.isEmptyValue)(value, 'date')) {
let dateObject;
var dateObject;
if (value instanceof Date) {

@@ -25,0 +25,0 @@ dateObject = value;

+4
-4
lib/validator/enum.js

@@ -10,6 +10,6 @@ "use strict";

var _util = require("../util");
const ENUM = 'enum';
const enumerable = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var ENUM = 'enum';
var enumerable = function enumerable(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -16,0 +16,0 @@ if ((0, _util.isEmptyValue)(value) && !rule.required) {

+3
-3
lib/validator/float.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const floatFn = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var floatFn = function floatFn(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if ((0, _util.isEmptyValue)(value) && !rule.required) {

+3
-3
lib/validator/integer.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const integer = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var integer = function integer(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if ((0, _util.isEmptyValue)(value) && !rule.required) {

+3
-3
lib/validator/method.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const method = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var method = function method(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if ((0, _util.isEmptyValue)(value) && !rule.required) {

+3
-3
lib/validator/number.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const number = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var number = function number(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if (value === '') {

+3
-3
lib/validator/object.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const object = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var object = function object(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if ((0, _util.isEmptyValue)(value) && !rule.required) {

+3
-3
lib/validator/pattern.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const pattern = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var pattern = function pattern(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if ((0, _util.isEmptyValue)(value, 'string') && !rule.required) {

+3
-3
lib/validator/regexp.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const regexp = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var regexp = function regexp(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if ((0, _util.isEmptyValue)(value) && !rule.required) {

+4
-3
lib/validator/required.js

@@ -8,6 +8,7 @@ "use strict";

exports.default = void 0;
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _rule = _interopRequireDefault(require("../rule"));
const required = (rule, value, callback, source, options) => {
const errors = [];
const type = Array.isArray(value) ? 'array' : typeof value;
var required = function required(rule, value, callback, source, options) {
var errors = [];
var type = Array.isArray(value) ? 'array' : (0, _typeof2.default)(value);
_rule.default.required(rule, value, source, errors, options, type);

@@ -14,0 +15,0 @@ callback(errors);

+3
-3
lib/validator/string.js

@@ -10,5 +10,5 @@ "use strict";

var _util = require("../util");
const string = (rule, value, callback, source, options) => {
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var string = function string(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -15,0 +15,0 @@ if ((0, _util.isEmptyValue)(value, 'string') && !rule.required) {

+4
-4
lib/validator/type.js

@@ -10,6 +10,6 @@ "use strict";

var _util = require("../util");
const type = (rule, value, callback, source, options) => {
const ruleType = rule.type;
const errors = [];
const validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
var type = function type(rule, value, callback, source, options) {
var ruleType = rule.type;
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {

@@ -16,0 +16,0 @@ if ((0, _util.isEmptyValue)(value, ruleType) && !rule.required) {

+4
-4
package.json
{
"name": "@rc-component/async-validator",
"version": "5.1.1",
"version": "5.1.2",
"description": "Validate form asynchronous",

@@ -32,3 +32,3 @@ "keywords": [

"now-build": "npm run docs:build",
"prepublishOnly": "npm run compile && rc-np",
"prepublishOnly": "npm run compile && np --yolo --no-publish --any-branch",
"prettier": "prettier . --write",

@@ -53,4 +53,3 @@ "postpublish": "npm run gh-pages",

"devDependencies": {
"@rc-component/father-plugin": "^2.2.0",
"@rc-component/np": "^1.0.3",
"@rc-component/father-plugin": "^1.0.2",
"@types/jest": "^29.5.12",

@@ -65,2 +64,3 @@ "@types/react": "18.x",

"lint-staged": "^15.2.2",
"np": "^10.0.3",
"prettier": "^3.2.5",

@@ -67,0 +67,0 @@ "rc-test": "^7.0.15",