@alifd/validate
Version:
Validation to be used with @alifd/field
318 lines (261 loc) • 7.92 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.asyncMap = asyncMap;
exports.asyncMapPromise = asyncMapPromise;
exports.complementError = complementError;
exports.format = format;
exports.processErrorResults = processErrorResults;
var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
var formatRegExp = /%[sdj%]/g;
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(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]';
}
default:
return x;
}
});
return str;
}
return f;
}
/**
* 串联校验一组数据，只返回第一个出错结果
* @param {*} arr
* @param {*} validator
* @param {*} callback 出递归，告诉错误校验完成
*/
function _asyncValidateSerials(arr, validator, callback) {
var index = 0;
var arrLength = arr.length;
function next(errors) {
if (errors && errors.length) {
return callback(errors);
}
var original = index;
index = index + 1;
if (original < arrLength) {
validator(arr[original], next);
} else {
return callback([]);
}
}
next([]);
}
/**
* 串联校验一组数据，只返回第一个出错结果
* @param {*} arr
* @param {*} validator
* @returns
*/
function _promiseValidateSeries(_x, _x2) {
return _promiseValidateSeries2.apply(this, arguments);
}
/**
* 平铺规则
* @param {object} objArr {name: [{value, rule}, {value, rule2}], name2: [{value2, rule3}]}
* @return {Array} [{value, rule}, {value, rule2}, {value2, rule3}]
*/
function _promiseValidateSeries2() {
_promiseValidateSeries2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(arr, validator) {
return _regenerator.default.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
return _context2.abrupt("return", arr.reduce( /*#__PURE__*/function () {
var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(prevPromise, next) {
var errors;
return _regenerator.default.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.prev = 0;
_context.next = 3;
return prevPromise;
case 3:
errors = _context.sent;
_context.next = 9;
break;
case 6:
_context.prev = 6;
_context.t0 = _context["catch"](0);
errors = _context.t0;
case 9:
if (!(errors && errors.length)) {
_context.next = 11;
break;
}
return _context.abrupt("return", errors);
case 11:
return _context.abrupt("return", validator(next));
case 12:
case "end":
return _context.stop();
}
}
}, _callee, null, [[0, 6]]);
}));
return function (_x6, _x7) {
return _ref.apply(this, arguments);
};
}(), []));
case 1:
case "end":
return _context2.stop();
}
}
}, _callee2);
}));
return _promiseValidateSeries2.apply(this, arguments);
}
function flattenObjArr(objArr) {
var ret = [];
Object.keys(objArr).forEach(function (k) {
Object.keys(objArr[k]).forEach(function (r) {
ret.push(objArr[k][r]);
});
});
return ret;
}
/**
* 异步调用
* @param {map} objArr 校验规则对象列表
* @param {object} option 配置项
* @param {Function} validator 每个校验规则
* @param {Function} callback 全部完成后的执行
*/
function asyncMap(objArr, option, validator, callback) {
// 发现第一个错误即返回
if (option.first) {
var flattenArr = flattenObjArr(objArr);
return _asyncValidateSerials(flattenArr, validator, callback);
}
var objArrKeys = Object.keys(objArr);
var objArrLength = objArrKeys.length;
var total = 0;
var results = [];
var next = function next(errors) {
results.push(errors);
total++;
if (total === objArrLength) {
return callback(results);
}
};
objArrKeys.forEach(function (key) {
var arr = objArr[key];
_asyncValidateSerials(arr, validator, next);
});
}
function asyncMapPromise(_x3, _x4, _x5) {
return _asyncMapPromise.apply(this, arguments);
}
function _asyncMapPromise() {
_asyncMapPromise = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(objArr, option, validator) {
var flatObjArr, objArrValues;
return _regenerator.default.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
if (!option.first) {
_context3.next = 5;
break;
}
flatObjArr = flattenObjArr(objArr);
_context3.next = 4;
return _promiseValidateSeries(flatObjArr, validator);
case 4:
return _context3.abrupt("return", _context3.sent);
case 5:
objArrValues = Object.values(objArr);
_context3.next = 8;
return Promise.all(objArrValues.map(function (val) {
return _promiseValidateSeries(val, validator);
}));
case 8:
return _context3.abrupt("return", _context3.sent);
case 9:
case "end":
return _context3.stop();
}
}
}, _callee3);
}));
return _asyncMapPromise.apply(this, arguments);
}
function complementError(rule) {
return function (oe) {
if (oe && oe.message) {
oe.field = rule.field;
return oe;
}
return {
message: oe,
field: rule.field
};
};
}
/**
*
* @param {Array} results errors from running validation
* @returns {Object} { errors: Array, fields: Object }
*/
function processErrorResults() {
var results = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
var errors = [];
var fields = {};
function add(e) {
if (Array.isArray(e)) {
errors = errors.concat(e);
} else {
errors.push(e);
}
}
for (var i = 0; i < results.length; i++) {
add(results[i]);
}
if (!errors.length) {
errors = null;
fields = null;
} else {
for (var _i = 0; _i < errors.length; _i++) {
var field = errors[_i].field;
if (field) {
fields[field] = fields[field] || [];
fields[field].push(errors[_i]);
}
}
}
return {
errors: errors,
fields: fields
};
}