@opentiny/vue-renderless 3.1.0-alpha.0

package/common/validate/rules/required.js

@@ -0,0 +1,13 @@
+import * as util from '../util';
+import { hasOwn } from '@opentiny/vue-renderless/common/type';
+export default function (_ref) {
+  var rule = _ref.rule,
+    checkValue = _ref.checkValue,
+    source = _ref.source,
+    errors = _ref.errors,
+    options = _ref.options,
+    type = _ref.type;
+  if (rule.required && (!hasOwn.call(source, rule.field) || util.isEmptyValue(checkValue, type || rule.type))) {
+    errors.push(util.format(options.messages.required, rule.fullField));
+  }
+}

package/common/validate/rules/type.js

@@ -0,0 +1,110 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import * as util from '../util';
+import required from './required';
+import { format } from '@opentiny/vue-renderless/common/date';
+import { isNullOrEmpty } from '@opentiny/vue-renderless/common/string';
+import { isNumber, isObject, isDate, typeOf } from '@opentiny/vue-renderless/common/type';
+var emailReg1 = '^(([^<>()\\[\\]\\\\.,;:\\s@"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@"]+)*)|(".+"))';
+var emailReg = new RegExp(emailReg1 + '@((\\[[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,6}))$');
+var pattern = {
+  acceptImg: /\.(png|jpe?g|gif)$/,
+  acceptFile: /\.(doc?x|xls?x|ppt?x|txt)$/,
+  email: emailReg,
+  fileSize: /^\d+(\.\d+)?[KMGTPEZY]?B$/i,
+  hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i,
+  speczh: /^[0-9a-zA-Z_\u4e00-\u9fa5]+$/,
+  specialch: /^[0-9a-zA-Z_\-.]+$/,
+  specialch2: /^[0-9a-zA-Z_-]+$/,
+  url: /^([a-zA-Z]{3,}):\/\/([\w-]+\.)+[\w]+(\/[a-zA-Z- ./?%&=]*)?/i,
+  version: /^\d+\.\d+(\.\d+)*$/
+};
+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: Array.isArray,
+  regexp: function regexp(value) {
+    if (value instanceof RegExp) {
+      return true;
+    }
+    try {
+      return !!new RegExp(value);
+    } catch (e) {
+      return false;
+    }
+  },
+  date: isDate,
+  number: isNumber,
+  object: function object(value) {
+    return isObject(value) && !types.array(value);
+  },
+  method: function method(value) {
+    return typeOf(value) === 'function';
+  },
+  email: function email(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.email) && value.length < 255;
+  },
+  url: function url(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.url);
+  },
+  hex: function hex(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.hex);
+  },
+  digits: function digits(value) {
+    return isNullOrEmpty(value) || /^\d+$/.test(value);
+  },
+  time: function time(value) {
+    return isNullOrEmpty(value) || /^((0)[0-9]|1[0-9]|20|21|22|23):([0-5][0-9])$/.test(value);
+  },
+  dateYM: function dateYM(value) {
+    return isNullOrEmpty(value) || format(value, 'yyyy-MM') === value;
+  },
+  dateYMD: function dateYMD(value) {
+    return isNullOrEmpty(value) || format(value, 'yyyy-MM-dd') === value;
+  },
+  dateTime: function dateTime(value) {
+    return isNullOrEmpty(value) || format(value, 'yyyy-MM-dd hh:mm') === value;
+  },
+  longDateTime: function longDateTime(value) {
+    return isNullOrEmpty(value) || format(value, 'yyyy-MM-dd hh:mm:ss') === value;
+  },
+  version: function version(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.version);
+  },
+  speczh: function speczh(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.speczh);
+  },
+  specialch: function specialch(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.specialch);
+  },
+  specialch2: function specialch2(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.specialch2);
+  },
+  acceptImg: function acceptImg(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.acceptImg);
+  },
+  acceptFile: function acceptFile(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.acceptFile);
+  },
+  fileSize: function fileSize(value) {
+    return isNullOrEmpty(value) || !!value.match(pattern.fileSize);
+  }
+};
+export default function (rule, value, source, errors, options) {
+  if (rule.required && value === undefined) {
+    required(rule, value, source, errors, options);
+    return;
+  }
+  var custom = ['array', 'acceptImg', 'acceptFile', 'date', 'digits', 'dateTime', 'dateYM', 'dateYMD', 'email', 'float', 'fileSize', 'hex', 'integer', 'longDateTime', 'method', 'number', 'object', 'regexp', 'speczh', 'specialch', 'specialch2', 'time', 'version', 'url'];
+  var ruleType = rule.type;
+  if (custom.indexOf(ruleType) > -1) {
+    if (!types[ruleType](value)) {
+      errors.push(util.format(options.messages.types[ruleType], rule.fullField, rule.type));
+    }
+  } else if (ruleType && _typeof(value) !== rule.type) {
+    errors.push(util.format(options.messages.types[ruleType], rule.fullField, rule.type));
+  }
+}

package/common/validate/rules/whitespace.js

@@ -0,0 +1,6 @@
+import * as util from '../util';
+export default function (rule, checkValue, source, errors, options) {
+  if (/^\s+$/.test(checkValue) || checkValue === '') {
+    errors.push(util.format(options.messages.whitespace, rule.fullField));
+  }
+}

package/common/validate/schema.js

@@ -0,0 +1,323 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { format, complementError, asyncMap, warning, deepMerge, convertFieldsError } from './util';
+import { hasOwn, isFunction } from '@opentiny/vue-renderless/common/type';
+function Schema(descriptor, translate) {
+  Schema.getSystemMessage = function () {
+    return Schema.getDefaultMessage(translate);
+  };
+  Schema.messages = Schema.getSystemMessage(translate);
+  Schema.systemMessages = Schema.messages;
+  this.rules = null;
+  this._messages = Schema.systemMessages;
+  this.define(descriptor);
+}
+var getCompleteFn = function getCompleteFn(validCallback) {
+  return function (results) {
+    var idx;
+    var errors = [];
+    var fields = {};
+    function addValid(eror) {
+      if (Array.isArray(eror)) {
+        var _errors;
+        errors = (_errors = errors).concat.apply(_errors, _toConsumableArray(eror));
+      } else {
+        errors.push(eror);
+      }
+    }
+    for (idx = 0; idx < results.length; idx++) {
+      addValid(results[idx]);
+    }
+    if (errors.length) {
+      fields = convertFieldsError(errors);
+    } else {
+      errors = null;
+      fields = null;
+    }
+    validCallback(errors, fields);
+  };
+};
+var isDeep = function isDeep(rule, data) {
+  var deep = (rule.type === 'object' || rule.type === 'array') && (_typeof(rule.fields) === 'object' || _typeof(rule.defaultField) === 'object');
+  deep = deep && (rule.required || !rule.required && data.value);
+  return deep;
+};
+var getFieldsSchema = function getFieldsSchema(rule, data) {
+  var schema = {};
+  function addFullfield(key, item) {
+    return _objectSpread(_objectSpread({}, item), {}, {
+      fullField: "".concat(rule.fullField, ".").concat(key)
+    });
+  }
+  if (rule.defaultField) {
+    for (var k in data.value) {
+      if (hasOwn.call(data.value, k)) {
+        schema[k] = rule.defaultField;
+      }
+    }
+  }
+  schema = _objectSpread(_objectSpread({}, schema), data.rule.fields);
+  for (var f in schema) {
+    if (hasOwn.call(schema, f)) {
+      var fieldSchema = Array.isArray(schema[f]) ? schema[f] : [schema[f]];
+      schema[f] = fieldSchema.map(addFullfield.bind(null, f));
+    }
+  }
+  return schema;
+};
+var arrayed = function arrayed(failds) {
+  if (!Array.isArray(failds)) {
+    failds = [failds];
+  }
+  return failds;
+};
+var getRequiredErrorFeilds = function getRequiredErrorFeilds(_ref) {
+  var rule = _ref.rule,
+    failds = _ref.failds,
+    options = _ref.options;
+  if (rule.message) {
+    failds = [].concat(rule.message).map(complementError(rule));
+  } else if (options.error) {
+    failds = [options.error(rule, format(options.messages.required, rule.field))];
+  } else {
+    failds = [];
+  }
+  return failds;
+};
+var setDataRuleOptions = function setDataRuleOptions(_ref2) {
+  var data = _ref2.data,
+    options = _ref2.options;
+  if (data.rule.options) {
+    var messages = options.messages,
+      error = options.error;
+    Object.assign(data.rule.options, {
+      messages: messages,
+      error: error
+    });
+  }
+};
+var getValidateCallback = function getValidateCallback(_ref3) {
+  var failds = _ref3.failds,
+    doIt = _ref3.doIt;
+  return function (errs) {
+    var finalErrors = [];
+    if (failds && failds.length) {
+      finalErrors.push.apply(finalErrors, _toConsumableArray(failds));
+    }
+    if (errs && errs.length) {
+      finalErrors.push.apply(finalErrors, _toConsumableArray(errs));
+    }
+    doIt(finalErrors.length ? finalErrors : null);
+  };
+};
+var asyncCallback = function asyncCallback(options, rule, errorFields, doIt, data) {
+  return function () {
+    var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var failds = e;
+    var deep = isDeep(rule, data);
+    failds = arrayed(failds);
+    if (!options.suppressWarning && failds.length) {
+      Schema.warning('async-validator:', failds);
+    }
+    if (failds.length && rule.message) {
+      failds = [].concat(rule.message);
+    }
+    failds = failds.map(complementError(rule));
+    if (options.first && failds.length) {
+      errorFields[rule.field] = 1;
+      return doIt(failds);
+    }
+    if (deep) {
+      if (rule.required && !data.value) {
+        failds = getRequiredErrorFeilds({
+          rule: rule,
+          failds: failds,
+          options: options
+        });
+        return doIt(failds);
+      }
+      var schema = new Schema(getFieldsSchema(rule, data));
+      schema.messages(options.messages);
+      setDataRuleOptions({
+        data: data,
+        options: options
+      });
+      schema.validate(data.value, data.rule.options || options, getValidateCallback({
+        failds: failds,
+        doIt: doIt
+      }));
+    } else {
+      doIt(failds);
+    }
+  };
+};
+Schema.prototype = {
+  messages: function messages(_messages) {
+    if (_messages) {
+      this._messages = deepMerge(Schema.getSystemMessage(), _messages);
+    }
+    return this._messages;
+  },
+  define: function define(rules) {
+    var _this = this;
+    if (!rules) {
+      throw new Error('Cannot configure a schema with no rules');
+    }
+    if (Array.isArray(rules) || _typeof(rules) !== 'object') {
+      throw new Error('Rules must be an object');
+    }
+    this.rules = {};
+    var rule;
+    Object.keys(rules).forEach(function (key) {
+      if (hasOwn.call(rules, key)) {
+        rule = rules[key];
+        _this.rules[key] = Array.isArray(rule) ? rule : [rule];
+      }
+    });
+  },
+  getSeries: function getSeries(options, source, source_) {
+    var _this2 = this;
+    var arr;
+    var value;
+    var series = {};
+    var keys = options.keys || Object.keys(this.rules);
+    keys.forEach(function (key) {
+      arr = _this2.rules[key];
+      value = source[key];
+      arr.forEach(function (r) {
+        var rule = r;
+        if (typeof rule.transform === 'function') {
+          if (source === source_) {
+            source = _objectSpread({}, source);
+          }
+          source[key] = rule.transform(value);
+          value = source[key];
+        }
+        if (typeof rule === 'function') {
+          rule = {
+            validator: rule
+          };
+        } else {
+          rule = _objectSpread({}, rule);
+        }
+        rule.validator = _this2.getValidationMethod(rule);
+        rule.field = key;
+        rule.fullField = rule.fullField || key;
+        rule.type = _this2.getType(rule);
+        options.custom && Object.assign(rule, options.custom);
+        if (!rule.validator) {
+          return;
+        }
+        series[key] = series[key] || [];
+        series[key].push({
+          rule: rule,
+          value: value,
+          source: source,
+          field: key
+        });
+      });
+    });
+    return series;
+  },
+  mergeMessage: function mergeMessage(options) {
+    if (options.messages) {
+      var messages = this.messages();
+      if (messages === Schema.systemMessages) {
+        messages = Schema.getSystemMessage();
+      }
+      deepMerge(messages, options.messages);
+      options.messages = messages;
+    } else {
+      options.messages = this.messages();
+    }
+  },
+  validate: function validate(source_) {
+    var o = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var oc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
+      return undefined;
+    };
+    var source = source_;
+    var options = o;
+    var validCallback = oc;
+    if (typeof options === 'function') {
+      validCallback = options;
+      options = {};
+    }
+    if (!this.rules || Object.keys(this.rules).length === 0) {
+      validCallback && validCallback();
+      return Promise.resolve();
+    }
+    var complete = getCompleteFn(validCallback);
+    this.mergeMessage(options);
+    var seriesData = this.getSeries(options, source, source_);
+    var errorFields = {};
+    return asyncMap(seriesData, options, function (data, doIt) {
+      var rule = data.rule;
+      var validHandler = asyncCallback(options, rule, errorFields, doIt, data);
+      var validResult;
+      if (rule.asyncValidator) {
+        validResult = rule.asyncValidator(rule, data.value, validHandler, data.source, options);
+      } else if (rule.validator) {
+        validResult = rule.validator(rule, data.value, validHandler, data.source, options);
+        if (validResult === true) {
+          validHandler();
+        } else if (validResult === false) {
+          validHandler(rule.message || "".concat(rule.field, " fails"));
+        } else if (Array.isArray(validResult)) {
+          validHandler(validResult);
+        } else if (validResult instanceof Error) {
+          validHandler(validResult.message);
+        }
+      }
+      if (validResult && validResult.then) {
+        validResult.then(function () {
+          return validHandler();
+        }, function (e) {
+          return validHandler(e);
+        });
+      }
+    }, function (results) {
+      complete(results);
+    });
+  },
+  getValidationMethod: function getValidationMethod(rule) {
+    if (isFunction(rule.validator)) {
+      return rule.validator;
+    }
+    var ruleKeys = Object.keys(rule);
+    var messageIndex = ruleKeys.indexOf('message');
+    if (messageIndex > -1) {
+      ruleKeys.splice(messageIndex, 1);
+    }
+    if (ruleKeys.length === 1 && ruleKeys[0] === 'required') {
+      return Schema.validators.required;
+    }
+    return Schema.validators[this.getType(rule)] || false;
+  },
+  getType: function getType(rule) {
+    if (rule.type === undefined && rule.pattern instanceof RegExp) {
+      rule.type = 'pattern';
+    }
+    if (typeof rule.validator !== 'function' && rule.type && !hasOwn.call(Schema.validators, rule.type)) {
+      throw new Error(format('Unknown rule type %s', rule.type));
+    }
+    return rule.type || 'string';
+  }
+};
+Schema.register = function (type, validator) {
+  if (typeof validator !== 'function') {
+    throw new Error('Cannot register a validator by type, validator is not a function');
+  }
+  Schema.validators[type] = validator;
+};
+Schema.validators = {};
+Schema.warning = warning;
+Schema.messages = {};
+Schema.systemMessages = {};
+Schema.getDefaultMessage = function () {
+  return undefined;
+};
+export default Schema;

package/common/validate/util.js

@@ -0,0 +1,198 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _typeof from "@babel/runtime/helpers/typeof";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { hasOwn, isNull } from '@opentiny/vue-renderless/common/type';
+var formatRegExp = /%[sdj%]/g;
+export var warning = function warning() {
+  return undefined;
+};
+export 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;
+}
+export function format() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  var i = 1;
+  var checkData = args[0];
+  var len = args.length;
+  if (typeof checkData === 'function') {
+    return checkData.apply(null, args.slice(1));
+  }
+  if (typeof checkData === 'string') {
+    var str = String(checkData).replace(formatRegExp, function (matchChar) {
+      if (matchChar === '%%') {
+        return '%';
+      }
+      if (i >= len) {
+        return matchChar;
+      }
+      switch (matchChar) {
+        case '%j':
+          try {
+            return JSON.stringify(args[i++]);
+          } catch (e) {
+            return '[Circular]';
+          }
+        case '%d':
+          return Number(args[i++]);
+        case '%s':
+          return String(args[i++]);
+        default:
+          return matchChar;
+      }
+    });
+    return str;
+  }
+  return checkData;
+}
+function isNativeStringType(type) {
+  return ~['string', 'url', 'hex', 'email', 'pattern', 'digits', 'time', 'dateYMD', 'longDateTime', 'dateTime', 'dateYM', 'version', 'speczh', 'specialch', 'specialch2', 'acceptImg', 'acceptFile', 'fileSize'].indexOf(type);
+}
+export function isEmptyValue(data, dataType) {
+  if (isNull(data)) {
+    return true;
+  }
+  if (dataType === 'array' && Array.isArray(data) && !data.length) {
+    return true;
+  }
+  if (isNativeStringType(dataType) && typeof data === 'string' && !data) {
+    return true;
+  }
+  return false;
+}
+export function isEmptyObject(data) {
+  return Object.keys(data).length === 0;
+}
+function asyncParallelArray(arrData, func, callback) {
+  var count = 0;
+  var results = [];
+  var arrLength = arrData.length;
+  function checkCount(errors) {
+    results.push.apply(results, errors);
+    count++;
+    if (count === arrLength) {
+      callback(results);
+    }
+  }
+  arrData.forEach(function (rule) {
+    func(rule, checkCount);
+  });
+}
+function asyncSerialArray(arr, fn, cb) {
+  var idx = 0;
+  var arrLength = arr.length;
+  function checkNext(errorList) {
+    if (errorList && errorList.length) {
+      cb(errorList);
+      return;
+    }
+    var original = idx;
+    idx = idx + 1;
+    if (original < arrLength) {
+      fn(arr[original], checkNext);
+    } else {
+      cb([]);
+    }
+  }
+  checkNext([]);
+}
+function flattenObjArr(objArr) {
+  var result = [];
+  Object.keys(objArr).forEach(function (item) {
+    result.push.apply(result, objArr[item]);
+  });
+  return result;
+}
+export function asyncMap(objArray, option, func, callback) {
+  if (option.first) {
+    var _pending = new Promise(function (resolve, reject) {
+      var errorFn = reject;
+      var next = function next(errors) {
+        callback(errors);
+        return errors.length ? errorFn({
+          errors: errors,
+          fields: convertFieldsError(errors)
+        }) : resolve();
+      };
+      var flattenArr = flattenObjArr(objArray);
+      asyncSerialArray(flattenArr, func, next);
+    });
+    _pending["catch"](function (error) {
+      return error;
+    });
+    return _pending;
+  }
+  var firstFields = option.firstFields || [];
+  if (firstFields === true) {
+    firstFields = Object.keys(objArray);
+  }
+  var total = 0;
+  var objArrayKeys = Object.keys(objArray);
+  var objArrLength = objArrayKeys.length;
+  var results = [];
+  var pending = new Promise(function (resolve, reject) {
+    var errorFn = reject;
+    var next = function next(errors) {
+      results.push.apply(results, errors);
+      total++;
+      if (total === objArrLength) {
+        callback(results);
+        return results.length ? errorFn({
+          errors: results,
+          fields: convertFieldsError(results)
+        }) : resolve();
+      }
+    };
+    objArrayKeys.forEach(function (key) {
+      var arr = objArray[key];
+      if (~firstFields.indexOf(key)) {
+        asyncSerialArray(arr, func, next);
+      } else {
+        asyncParallelArray(arr, func, next);
+      }
+    });
+  });
+  pending["catch"](function (e) {
+    return e;
+  });
+  return pending;
+}
+export function complementError(rule) {
+  return function (onError) {
+    if (onError && onError.message) {
+      onError.field = onError.field || rule.fullField;
+      return onError;
+    }
+    return {
+      message: typeof onError === 'function' ? onError() : onError,
+      field: onError.field || rule.fullField
+    };
+  };
+}
+export function deepMerge(target, sources) {
+  if (!sources) {
+    return target;
+  }
+  for (var source in sources) {
+    if (hasOwn.call(sources, source)) {
+      var value = sources[source];
+      if (_typeof(value) === 'object' && _typeof(target[source]) === 'object') {
+        target[source] = _objectSpread(_objectSpread({}, target[source]), value);
+      } else {
+        target[source] = value;
+      }
+    }
+  }
+  return target;
+}

package/common/validate/validations/array.js

@@ -0,0 +1,25 @@
+import rules from '../rules/index';
+import { isEmptyValue } from '../util';
+import { hasOwn } from '@opentiny/vue-renderless/common/type';
+export default function (rule, checkValue, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
+  if (validate) {
+    if (isEmptyValue(checkValue, 'array') && !rule.required) {
+      return callback();
+    }
+    rules.required({
+      rule: rule,
+      checkValue: checkValue,
+      source: source,
+      errors: errors,
+      options: options,
+      type: 'array'
+    });
+    if (!isEmptyValue(checkValue, 'array')) {
+      rules.type(rule, checkValue, source, errors, options);
+      rules.range(rule, checkValue, source, errors, options);
+    }
+  }
+  callback(errors);
+}