schema-validate.js

/*! @luobotang/schema-validate v0.1.6 */

var SchemaValidate = (function (exports) {
  'use strict';

  function isEmpty(value) {
    return typeof value === 'undefined' || value === null || value === ''
  }

  function checkRequired(value, trim) {
    // String trim
    if (trim && typeof value === 'string') {
      value = value.replace(/(^\s*)|(\s*$)/g, '');
    }

    // Array
    if (Array.isArray(value)) {
      return !!value.length
    }

    return !isEmpty(value)
  }

  function createValidator(data, desc) {
    return function (value, rules) {
      for (var i = 0; i < rules.length; i += 1) {
        var ref = rules[i];
        var onValid = ref.onValid;
        var errorMessage = ref.errorMessage;
        var checkResult = onValid(value, data);

        if (checkResult === false) {
          return { hasError: true, errorMessage: desc + errorMessage } // "数据描述" + "规则错误描述"
        } else if (typeof checkResult === 'object' && checkResult.hasError) {
          return checkResult
        }
      }

      return null
    }
  }

  var Type = function Type(name, desc) {
    this.name = name;
    this._desc = desc || ''; // 数据描述，用于拼接规则 errorMessage 得到最终错误描述
    this._required = false;
    this._requiredMessage = '';
    this._trim = false;
    this._rules = [];
    this._priorityRules = []; // 优先规则
  };

  Type.prototype.check = function check (value, data) {
    if (this._required && !checkRequired(value, this.trim)) {
      return { hasError: true, errorMessage: this._desc + this._requiredMessage }
    }

    var validator = createValidator(data, this._desc);
    var checkStatus = validator(value, this._priorityRules);

    if (checkStatus) {
      return checkStatus
    }

    if (!this._required && isEmpty(value)) {
      return { hasError: false }
    }

    return validator(value, this._rules) || { hasError: false }
  };

  Type.prototype.rule = function rule (onValid, errorMessage, priority) {
    if (priority) {
      this._priorityRules.push({ onValid: onValid, errorMessage: errorMessage });
    } else {
      this._rules.push({ onValid: onValid, errorMessage: errorMessage });
    }
    return this
  };

  Type.prototype.required = function required (errorMessage, trim) {
      if ( errorMessage === void 0 ) errorMessage = '不能为空';
      if ( trim === void 0 ) trim = true;

    this._required = true;
    this._trim = trim;
    this._requiredMessage = errorMessage;
    return this
  };

  Type.prototype.desc = function desc (desc$1) {
    this._desc = desc$1 || '';
    return this
  };

  /**
   * 复制当前对象，得到新的 Type 实例对象，便于复用已有 Type
   */
  Type.prototype.clone = function clone () {
    var t = this;
    var n = {};
    Object.setPrototypeOf(n, Object.getPrototypeOf(t)); // 配置继承关系
    n.name = t.name;
    n._desc = t._desc;
    n._required = t._required;
    n._requiredMessage = t._requiredMessage;
    n._trim = t._trim;
    n._rules = t._rules.concat();
    n._priorityRules = t._priorityRules.concat();
    return n
  };

  var Type_1 = Type;

  var REG_EMAIL = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; // http://emailregex.com/
  var REG_IP = /^((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})){3}$/;
  var REG_URL = new RegExp(
    '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
    'i'
  );

  var StringType = /*@__PURE__*/(function (Type) {
    function StringType(desc) {
      Type.call(this, 'string', desc);
      this.rule(function (v) { return typeof v === 'string'; }, '应为字符串');
    }

    if ( Type ) StringType.__proto__ = Type;
    StringType.prototype = Object.create( Type && Type.prototype );
    StringType.prototype.constructor = StringType;

    StringType.prototype.hasLetter = function hasLetter (errorMessage) {
      return this.rule(function (v) { return /[a-zA-Z]/.test(v); }, errorMessage || '应包含字母')
    };

    StringType.prototype.hasUppercaseLetter = function hasUppercaseLetter (errorMessage) {
      return this.rule(function (v) { return /[A-Z]/.test(v); }, errorMessage || '应包含大写字母')
    };

    StringType.prototype.hasLowercaseLetter = function hasLowercaseLetter (errorMessage) {
      return this.rule(function (v) { return /[a-z]/.test(v); }, errorMessage || '应包含小写字母')
    };

    StringType.prototype.letterOnly = function letterOnly (errorMessage) {
      return this.rule(function (v) { return /^[a-zA-Z]+$/.test(v); }, errorMessage || '只能是字母')
    };

    StringType.prototype.hasNumber = function hasNumber (errorMessage) {
      return this.rule(function (v) { return /[0-9]/.test(v); }, errorMessage || '应包含数字')
    };

    StringType.prototype.numberOnly = function numberOnly (errorMessage) {
      return this.rule(function (v) { return /^\d+$/.test(v); }, errorMessage || '只能是数字')
    };

    StringType.prototype.isInteger = function isInteger (errorMessage)  {
      return this.rule(function (v) { return /^-?\d+$/.test(v); }, errorMessage || '应为整数')
    };

    StringType.prototype.isNumber = function isNumber (errorMessage)  {
      return this.rule(function (v) { return /^-?\d+(\.\d+)?$/.test(v); }, errorMessage || '应为数值')
    };

    StringType.prototype.isFloat = function isFloat (errorMessage)  {
      return this.rule(function (v) { return /^-?\d+\.\d+$/.test(v); }, errorMessage || '应为 Float')
    };

    StringType.prototype.isDouble = function isDouble (errorMessage)  {
      return this.isFloat(errorMessage || '应为 Double')
    };

    StringType.prototype.oneOf = function oneOf (list, errorMessage) {
      return this.rule(function (v) { return list.indexOf(v) !== -1; }, errorMessage || '非指定值')
    };

    StringType.prototype.email = function email (errorMessage) {
      return this.rule(function (v) { return REG_EMAIL.test(v); }, errorMessage || '应为 Email')
    };

    StringType.prototype.ip = function ip (errorMessage) {
      return this.rule(function (v) { return REG_IP.test(v); }, errorMessage || '应为 IP 地址')
    };

    StringType.prototype.url = function url (errorMessage) {
      return this.rule(function (v) { return REG_URL.test(v); }, errorMessage || '应为 URL')
    };

    // 颜色值？例如 #fff #ffffff
    StringType.prototype.hex = function hex (errorMessage) {
      return this.rule(function (v) { return /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i.test(v); }, errorMessage || '应为十六进制颜色')
    };

    StringType.prototype.pattern = function pattern (regex, errorMessage) {
      return this.rule(function (value) { return regex.test(value); }, errorMessage || '格式错误')
    };

    StringType.prototype.range = function range (min, max, errorMessage) {
      return this.rule(
        function (value) { return value.length >= min && value.length <= max; },
        errorMessage || ("长度应在 " + min + " 到 " + max + " 字符之间")
      )
    };

    StringType.prototype.minlen = function minlen (min, errorMessage) {
      return this.rule(function (value) { return value.length >= min; }, errorMessage || ("长度不小于 " + min + " 字符"))
    };

    StringType.prototype.maxlen = function maxlen (max, errorMessage) {
      return this.rule(function (value) { return value.length <= max; }, errorMessage || ("长度不大于 " + max + " 字符"))
    };

    StringType.prototype.length = function length (len, errorMessage) {
      return this.rule(function (value) { return value.length === len; }, errorMessage || ("长度应为 " + len + " 字符"))
    };

    StringType.prototype.same = function same (field, errorMessage) {
      return this.rule(
        function (value, data) { return data ? data[field] === value : false; },
        errorMessage || ("值应与字段 " + field + " 一致")
      )
    };

    return StringType;
  }(Type_1));

  var StringType_1 = function (errorMessage) { return new StringType(errorMessage); };

  var Schema = function Schema(schema) {
    this.schema = schema;
  };

  Schema.prototype.getFieldType = function getFieldType (fieldName) {
    return this.schema[fieldName] || new StringType_1()
  };

  Schema.prototype.getKeys = function getKeys () {
    return Object.keys(this.schema)
  };

  Schema.prototype.checkForField = function checkForField (fieldName, fieldValue, data) {
    var fieldChecker = this.schema[fieldName];
    if (!fieldChecker) { return { hasError: false } }
    return fieldChecker.check(fieldValue, data)
  };

  /**
   * 检查整个对象，返回各个属性的检查结果
   * 
   * { name: 'abc', age: 18 } => { name: { hasError: false }, age: { hasError: true, errorMessage: 'xxx' } }
   */
  Schema.prototype.check = function check (data) {
      var this$1 = this;

    var checkResult = {};
    Object.keys(this.schema).forEach(function (key) {
      checkResult[key] = this$1.checkForField(key, data[key], data);
    });
    return checkResult
  };

  /**
   * 检查整个对象，返回第一个检查失败的属性及结果
   * 
   * { name: 'abc', age: 18 } => { hasError: true, errorMessage: 'xxx', field: 'age' }
   */
  Schema.prototype.validate = function validate (data) {
    for (var i = 0, list = Object.keys(this.schema); i < list.length; i += 1) {
      var field = list[i];

        var result = this.checkForField(field, data[field], data);
      if (result.hasError) {
        result.field = field;
        return result
      }
    }
    return { hasError: false }
  };

  var Schema_2 = Schema;

  var SchemaModel = function (o) { return new Schema(o); };

  SchemaModel.combine = function () {
    var models = [], len = arguments.length;
    while ( len-- ) models[ len ] = arguments[ len ];

    return new Schema(
    models
      .map(function (model) { return model.schema; })
      .reduce(function (accumulator, currentValue) { return Object.assign(accumulator, currentValue); }, {})
  );
  };

  var SchemaModel_1 = SchemaModel;

  var Schema_1 = {
  	Schema: Schema_2,
  	SchemaModel: SchemaModel_1
  };

  var NumberType = /*@__PURE__*/(function (Type) {
    function NumberType(desc) {
      Type.call(this, 'number', desc);
      this.rule(function (value) { return typeof value === 'number'; }, '应为数值');
    }

    if ( Type ) NumberType.__proto__ = Type;
    NumberType.prototype = Object.create( Type && Type.prototype );
    NumberType.prototype.constructor = NumberType;

    NumberType.prototype.integer = function integer (errorMessage) {
      return this.rule(function (value) { return value.toString().indexOf('.') === -1; }, errorMessage || '应为整数')
    };

    NumberType.prototype.range = function range (min, max, errorMessage) {
      return this.rule(function (value) { return value >= min && value <= max; }, errorMessage || ("应在 " + min + " 到 " + max + " 之间"))
    };

    NumberType.prototype.min = function min (min$1, errorMessage) {
      return this.rule(function (value) { return value >= min$1; }, errorMessage || ("应不小于 " + min$1))
    };

    NumberType.prototype.max = function max (max$1, errorMessage) {
      return this.rule(function (value) { return value <= max$1; }, errorMessage || ("应不大于 " + max$1))
    };

    NumberType.prototype.oneOf = function oneOf (list, errorMessage) {
      return this.rule(function (value) { return list.indexOf(value) !== -1; }, errorMessage || '非指定值')
    };

    return NumberType;
  }(Type_1));

  var NumberType_1 = function (errorMessage) { return new NumberType(errorMessage); };

  var BooleanType = /*@__PURE__*/(function (Type) {
    function BooleanType(desc) {
      Type.call(this, 'boolean', desc);
      this.rule(function (v) { return typeof v === 'boolean'; }, '应为布尔值');
    }

    if ( Type ) BooleanType.__proto__ = Type;
    BooleanType.prototype = Object.create( Type && Type.prototype );
    BooleanType.prototype.constructor = BooleanType;

    return BooleanType;
  }(Type_1));

  var BooleanType_1 = function (errorMessage) { return new BooleanType(errorMessage); };

  var DateType = /*@__PURE__*/(function (Type) {
    function DateType(desc) {
      Type.call(this, 'date', desc);
      this.rule(function (value) { return !/Invalid|NaN/.test(new Date(value)); }, '应为日期');
    }

    if ( Type ) DateType.__proto__ = Type;
    DateType.prototype = Object.create( Type && Type.prototype );
    DateType.prototype.constructor = DateType;

    DateType.prototype.range = function range (min, max, errorMessage) {
      return this.rule(
        function (value) { return new Date(value) >= new Date(min) && new Date(value) <= new Date(max); },
        errorMessage || ("应在 " + (min.toString()) + " 到 " + (max.toString()) + " 之间")
      )
    };

    DateType.prototype.min = function min (min$1, errorMessage) {
      return this.rule(function (value) { return new Date(value) >= new Date(min$1); }, errorMessage || ("应不小于 " + (min$1.toString())))
    };

    DateType.prototype.max = function max (max$1, errorMessage) {
      return this.rule(function (value) { return new Date(value) <= new Date(max$1); }, errorMessage || ("应不大于 " + (max$1.toString())))
    };

    DateType.prototype.strict = function strict (errorMessage) {
      return this.rule(function (value) { return Object.prototype.toString.call(value) === '[object Date]'; }, errorMessage || '应为日期类型')
    };

    return DateType;
  }(Type_1));

  var DateType_1 = function (errorMessage) { return new DateType(errorMessage); };

  var ObjectType = /*@__PURE__*/(function (Type) {
    function ObjectType(desc) {
      Type.call(this, 'object', desc);
      this.rule(function (v) { return typeof v === 'object'; }, '应为对象');
    }

    if ( Type ) ObjectType.__proto__ = Type;
    ObjectType.prototype = Object.create( Type && Type.prototype );
    ObjectType.prototype.constructor = ObjectType;

    /**
     * @example
     * ObjectType('这是一个对象').shape({
     *  name: StringType(),
     *  age: NumberType()
     * })
     */
    ObjectType.prototype.shape = function shape (types) {
      return this.rule(function (values) {
        var valids = Object.entries(types).map(function (item) {
          var key = item[0];
          var type = item[1];
          return type.check(values[key], values)
        });

        var errors = valids.filter(function (item) { return item.hasError; }) || [];

        if (errors.length) {
          return errors[0];
        }

        return errors.length === 0
      }, null)
    };

    return ObjectType;
  }(Type_1));

  var ObjectType_1 = function (errorMessage) { return new ObjectType(errorMessage); };

  var ArrayType = /*@__PURE__*/(function (Type) {
    function ArrayType(desc) {
      Type.call(this, 'array', desc);
      this.rule(function (v) { return Array.isArray(v); }, '应为数组');
    }

    if ( Type ) ArrayType.__proto__ = Type;
    ArrayType.prototype = Object.create( Type && Type.prototype );
    ArrayType.prototype.constructor = ArrayType;

    ArrayType.prototype.range = function range (min, max, errorMessage) {
      return this.rule(
        function (value) { return value.length >= min && value.length <= max; },
        errorMessage || ("长度应在 " + min + " 到 " + max + " 之间")
      )
    };

    ArrayType.prototype.minlen = function minlen (min, errorMessage) {
      return this.rule(function (value) { return value.length >= min; }, errorMessage || ("长度不小于 " + min))
    };

    ArrayType.prototype.maxlen = function maxlen (max, errorMessage) {
      return this.rule(function (value) { return value.length <= max; }, errorMessage || ("长度不大于 " + max))
    };

    ArrayType.prototype.length = function length (len, errorMessage) {
      return this.rule(function (value) { return value.length === len; }, errorMessage || ("长度应为 " + len))
    };

    ArrayType.prototype.unique = function unique (errorMessage) {
      return this.rule(function (items) {
        var hash = {};
        for (var i$1 = 0, list = items; i$1 < list.length; i$1 += 1) {
          var i = list[i$1];

          if (hash[i]) {
            return false
          }
          hash[i] = true;
        }
        return true
      }, errorMessage || '不能重复')
    };

    ArrayType.prototype.uniqueKey = function uniqueKey (key, errorMessage) {
      return this.rule(function (items) {
        var hash = {};
        for (var i = 0, list = items; i < list.length; i += 1) {
          var item = list[i];

          var v = item[key];
          if (hash[v]) {
            return false
          }
          hash[v] = true;
        }
        return true
      }, errorMessage || '不能重复')
    };

    /**
     * @example
     * ArrayType('这是一个数组').of(
     *   StringType().isOneOf(['数码','体育','游戏','旅途','其他']
     * )
     */
    ArrayType.prototype.of = function of (type) {
      return this.rule(function (items, data) {
        for (var i = 0, list = items; i < list.length; i += 1) {
          var item = list[i];

          var result = type.check(item, data);
          if (result.hasError) { return result }
        }
        return true
      })
    };

    return ArrayType;
  }(Type_1));

  var ArrayType_1 = function (errorMessage) { return new ArrayType(errorMessage); };

  var AnyType = /*@__PURE__*/(function (Type) {
    function AnyType() {
      var types = [], len = arguments.length;
      while ( len-- ) types[ len ] = arguments[ len ];

      Type.call(this, 'any');
      this.rule(function (value, data) {
        var result;
        for (var i = 0, list = types; i < list.length; i += 1) {
          var type = list[i];

          result = type.check(value, data);
          if (!result.hasError) { return result }
        }
        return result
      }, null);
    }

    if ( Type ) AnyType.__proto__ = Type;
    AnyType.prototype = Object.create( Type && Type.prototype );
    AnyType.prototype.constructor = AnyType;

    return AnyType;
  }(Type_1));

  var AnyType_1 = function () {
    var types = [], len = arguments.length;
    while ( len-- ) types[ len ] = arguments[ len ];

    return new (Function.prototype.bind.apply( AnyType, [ null ].concat( types) ));
  };

  var Schema$1 = Schema_1.Schema;
  var SchemaModel$1 = Schema_1.SchemaModel;

  var Schema_1$1 = Schema$1;
  var SchemaModel_1$1 = SchemaModel$1;

  var T = {
    string: StringType_1,
    number: NumberType_1,
    boolean: BooleanType_1,
    date: DateType_1,
    object: ObjectType_1,
    array: ArrayType_1,
    any: AnyType_1
  };

  var lib = {
  	Schema: Schema_1$1,
  	SchemaModel: SchemaModel_1$1,
  	T: T
  };

  exports.Schema = Schema_1$1;
  exports.SchemaModel = SchemaModel_1$1;
  exports.T = T;
  exports.default = lib;

  return exports;

}({}));