@json-editor/json-editor 1.3.5 → 1.17.0

package/src/validator.js

@@ -1,645 +1,1008 @@
-JSONEditor.Validator = Class.extend({
-  init: function(jsoneditor,schema,options) {
-    this.jsoneditor = jsoneditor;
-    this.schema = schema || this.jsoneditor.schema;
-    this.options = options || {};
-    this.translate = this.jsoneditor.translate || JSONEditor.defaults.translate;
-  },
-  validate: function(value) {
-    return this._validateSchema(this.schema, value);
-  },
-  _validateSchema: function(schema,value,path) {
-    var self = this;
-    var errors = [];
-    var valid, i, j;
-    var stringified = JSON.stringify(value);
-
-    path = path || 'root';
-
-    // Work on a copy of the schema
-    schema = $extend({},this.jsoneditor.expandRefs(schema));
+import { ipValidator } from './validators/ip-validator.js'
+import { extend, hasOwnProperty } from './utilities.js'
+
+export class Validator {
+  constructor (jsoneditor, schema, options, defaults) {
+    this.jsoneditor = jsoneditor
+    this.schema = schema || this.jsoneditor.schema
+    this.options = options || {}
+    this.translate = this.jsoneditor.translate || defaults.translate
+    this.translateProperty = this.jsoneditor.translateProperty || defaults.translateProperty
+    this.defaults = defaults
+
+    this._validateSubSchema = {
+      dependentRequired (schema, value, path) {
+        const errors = []
+
+        if (typeof schema.dependentRequired !== 'undefined') {
+          let missingProperties = []
+
+          Object.keys(schema.dependentRequired).forEach((key) => {
+            if (typeof value[key] !== 'undefined') {
+              const requiredProperties = schema.dependentRequired[key]
+
+              missingProperties = requiredProperties.filter((property) => {
+                return !hasOwnProperty(value, property)
+              })
+            }
+          })
 
-    /*
-     * Type Agnostic Validation
-     */
+          const invalid = missingProperties.length > 0
 
-    // Version 3 `required` and `required_by_default`
-    if(typeof value === "undefined") {
-      if((typeof schema.required !== "undefined" && schema.required === true) || (typeof schema.required === "undefined" && this.jsoneditor.options.required_by_default === true)) {
-        errors.push({
-          path: path,
-          property: 'required',
-          message: this.translate("error_notset")
-        });
-      }
-      
-      return errors;
-    }
+          if (invalid) {
+            errors.push({
+              message: 'Must have the required properties: ' + missingProperties.join(', '),
+              path
+            })
+          }
+        }
 
-    // `enum`
-    if(schema["enum"]) {
-      valid = false;
-      for(i=0; i<schema["enum"].length; i++) {
-        if(stringified === JSON.stringify(schema["enum"][i])) valid = true;
-      }
-      if(!valid) {
-        errors.push({
-          path: path,
-          property: 'enum',
-          message: this.translate("error_enum")
-        });
-      }
-    }
+        return errors
+      },
+      dependentSchemas (schema, value, path) {
+        let errors = []
 
-    // `extends` (version 3)
-    if(schema["extends"]) {
-      for(i=0; i<schema["extends"].length; i++) {
-        errors = errors.concat(this._validateSchema(schema["extends"][i],value,path));
-      }
-    }
+        Object.keys(schema.dependentSchemas).forEach((key) => {
+          if (typeof value[key] !== 'undefined') {
+            const dependentSchema = schema.dependentSchemas[key]
+            const tmpErrors = this._validateSchema(dependentSchema, value, path)
+            errors = [...errors, ...tmpErrors]
+          }
+        })
 
-    // `allOf`
-    if(schema.allOf) {
-      for(i=0; i<schema.allOf.length; i++) {
-        errors = errors.concat(this._validateSchema(schema.allOf[i],value,path));
-      }
-    }
+        return errors
+      },
+      contains (schema, value, path) {
+        const errors = []
+        let counter = 0
 
-    // `anyOf`
-    if(schema.anyOf) {
-      valid = false;
-      for(i=0; i<schema.anyOf.length; i++) {
-        if(!this._validateSchema(schema.anyOf[i],value,path).length) {
-          valid = true;
-          break;
-        }
-      }
-      if(!valid) {
-        errors.push({
-          path: path,
-          property: 'anyOf',
-          message: this.translate('error_anyOf')
-        });
-      }
-    }
+        value.forEach((item) => {
+          const containsErrors = this._validateSchema(schema.contains, item, path)
 
-    // `oneOf`
-    if(schema.oneOf) {
-      valid = 0;
-      var oneof_errors = [];
-      for(i=0; i<schema.oneOf.length; i++) {
-        // Set the error paths to be path.oneOf[i].rest.of.path
-        var tmp = this._validateSchema(schema.oneOf[i],value,path);
-        if(!tmp.length) {
-          valid++;
-        }
+          if (containsErrors.length === 0) {
+            counter++
+          }
+        })
 
-        for(j=0; j<tmp.length; j++) {
-          tmp[j].path = path+'.oneOf['+i+']'+tmp[j].path.substr(path.length);
-        }
-        oneof_errors = oneof_errors.concat(tmp);
+        const containsInvalid = (counter === 0)
 
-      }
-      if(valid !== 1) {
-        errors.push({
-          path: path,
-          property: 'oneOf',
-          message: this.translate('error_oneOf', [valid])
-        });
-        errors = errors.concat(oneof_errors);
-      }
-    }
+        if (typeof schema.minContains !== 'undefined') {
+          const minContainsInvalid = (counter < schema.minContains)
 
-    // `not`
-    if(schema.not) {
-      if(!this._validateSchema(schema.not,value,path).length) {
-        errors.push({
-          path: path,
-          property: 'not',
-          message: this.translate('error_not')
-        });
-      }
-    }
-
-    // `type` (both Version 3 and Version 4 support)
-    if(schema.type) {
-      // Union type
-      if(Array.isArray(schema.type)) {
-        valid = false;
-        for(i=0;i<schema.type.length;i++) {
-          if(this._checkType(schema.type[i], value)) {
-            valid = true;
-            break;
+          if (minContainsInvalid) {
+            errors.push({
+              message: this.translate('error_minContains', [counter, schema.minContains], schema),
+              path
+            })
           }
-        }
-        if(!valid) {
-          errors.push({
-            path: path,
-            property: 'type',
-            message: this.translate('error_type_union')
-          });
-        }
-      }
-      // Simple type
-      else {
-        if(['date', 'time', 'datetime-local'].indexOf(schema.format) != -1 && schema.type == 'integer') {
-          // Hack to get validator to validate as string even if value is integer
-          // As validation of 'date', 'time', 'datetime-local' is done in separate validator
-          if(!this._checkType('string', ""+value)) {
+        } else {
+          if (containsInvalid) {
             errors.push({
-              path: path,
-              property: 'type',
-              message: this.translate('error_type', [schema.format])
-            });
+              message: this.translate('error_contains', null, schema),
+              path
+            })
           }
         }
-        else if(!this._checkType(schema.type, value)) {
-          errors.push({
-            path: path,
-            property: 'type',
-            message: this.translate('error_type', [schema.type])
-          });
-        }
-      }
-    }
 
+        if (typeof schema.maxContains !== 'undefined') {
+          const maxContainsInvalid = (counter > schema.maxContains)
 
-    // `disallow` (version 3)
-    if(schema.disallow) {
-      // Union type
-      if(Array.isArray(schema.disallow)) {
-        valid = true;
-        for(i=0;i<schema.disallow.length;i++) {
-          if(this._checkType(schema.disallow[i], value)) {
-            valid = false;
-            break;
+          if (maxContainsInvalid) {
+            errors.push({
+              message: this.translate('error_maxContains', [counter, schema.maxContains], schema),
+              path
+            })
           }
         }
-        if(!valid) {
-          errors.push({
-            path: path,
-            property: 'disallow',
-            message: this.translate('error_disallow_union')
-          });
-        }
-      }
-      // Simple type
-      else {
-        if(this._checkType(schema.disallow, value)) {
-          errors.push({
-            path: path,
-            property: 'disallow',
-            message: this.translate('error_disallow', [schema.disallow])
-          });
-        }
-      }
-    }
-
-    /*
-     * Type Specific Validation
-     */
-
-    // Number Specific Validation
-    if(typeof value === "number") {
-      // `multipleOf` and `divisibleBy`
-      if(schema.multipleOf || schema.divisibleBy) {
-        var divisor = schema.multipleOf || schema.divisibleBy;
-        // Vanilla JS, prone to floating point rounding errors (e.g. 1.14 / .01 == 113.99999)
-        valid = (value/divisor === Math.floor(value/divisor));
 
-        // Use math.js is available
-        if(window.math) {
-          valid = window.math.mod(window.math.bignumber(value), window.math.bignumber(divisor)).equals(0);
-        }
-        // Use decimal.js is available
-        else if(window.Decimal) {
-          valid = (new window.Decimal(value)).mod(new window.Decimal(divisor)).equals(0);
-        }
+        return errors
+      },
+      if (schema, value, path) {
+        if (typeof schema.then === 'undefined' && typeof schema.else === 'undefined') {
+          return []
+        }
+
+        const ifErrors = this._validateSchema(schema.if, value, path)
+        let thenErrors = []
+        let elseErrors = []
+
+        if (typeof schema.then !== 'undefined') {
+          thenErrors = this._validateSchema(schema.then, value, path)
+        }
+
+        if (typeof schema.else !== 'undefined') {
+          elseErrors = this._validateSchema(schema.else, value, path)
+        }
+
+        if (schema.if === true) {
+          return thenErrors
+        }
+
+        if (schema.if === false) {
+          return elseErrors
+        }
+
+        if (ifErrors.length === 0) {
+          return thenErrors
+        }
+
+        if (ifErrors.length > 0) {
+          return elseErrors
+        }
+
+        return []
+      },
+      const (schema, value, path) {
+        const valid = JSON.stringify(schema.const) === JSON.stringify(value)
+
+        if (!valid) {
+          return [{
+            path,
+            property: 'const',
+            message: this.translate('error_const', null, schema)
+          }]
+        }
+        return []
+      },
+      enum (schema, value, path) {
+        const stringified = JSON.stringify(value)
+        const valid = schema.enum.some(e => stringified === JSON.stringify(e))
+        if (!valid) {
+          return [{
+            path,
+            property: 'enum',
+            message: this.translate('error_enum', null, schema)
+          }]
+        }
+        return []
+      },
+      extends (schema, value, path) {
+        const validate = (errors, e) => {
+          errors.push(...this._validateSchema(e, value, path))
+          return errors
+        }
+        return schema.extends.reduce(validate, [])
+      },
+      allOf (schema, value, path) {
+        const validate = (errors, e) => {
+          errors.push(...this._validateSchema(e, value, path))
+          return errors
+        }
+        return schema.allOf.reduce(validate, [])
+      },
+      anyOf (schema, value, path) {
+        const valid = schema.anyOf.some(e => !this._validateSchema(e, value, path).length)
+        if (!valid) {
+          return [{
+            path,
+            property: 'anyOf',
+            message: this.translate('error_anyOf', null, schema)
+          }]
+        }
+        return []
+      },
+      oneOf (schema, value, path) {
+        let valid = 0
+        const oneofErrors = []
+        schema.oneOf.forEach((o, i) => {
+          /* Set the error paths to be path.oneOf[i].rest.of.path */
+          const tmp = this._validateSchema(o, value, path)
+          if (!tmp.length) {
+            valid++
+          }
 
-        if(!valid) {
+          tmp.forEach(e => {
+            e.path = `${path}.oneOf[${i}]${e.path.substr(path.length)}`
+          })
+          oneofErrors.push(...tmp)
+        })
+        const errors = []
+        if (valid !== 1) {
           errors.push({
-            path: path,
-            property: schema.multipleOf? 'multipleOf' : 'divisibleBy',
-            message: this.translate('error_multipleOf', [divisor])
-          });
+            path,
+            property: 'oneOf',
+            message: this.translate('error_oneOf', [valid], schema)
+          })
+          errors.push(...oneofErrors)
+        }
+        return errors
+      },
+      not (schema, value, path) {
+        if (!this._validateSchema(schema.not, value, path).length) {
+          return [{
+            path,
+            property: 'not',
+            message: this.translate('error_not', null, schema)
+          }]
+        }
+        return []
+      },
+      type (schema, value, path) {
+        /* Union type */
+        if (Array.isArray(schema.type)) {
+          const valid = schema.type.some(e => this._checkType(e, value))
+          if (!valid) {
+            return [{
+              path,
+              property: 'type',
+              message: this.translate('error_type_union', null, schema)
+            }]
+          }
+        } else {
+          /* Simple type */
+          if (['date', 'time', 'datetime-local'].includes(schema.format) && schema.type === 'integer') {
+            /* Hack to get validator to validate as string even if value is integer */
+            /* As validation of 'date', 'time', 'datetime-local' is done in separate validator */
+            if (!this._checkType('string', `${value}`)) {
+              return [{
+                path,
+                property: 'type',
+                message: this.translate('error_type', [schema.format], schema)
+              }]
+            }
+          } else if (!this._checkType(schema.type, value)) {
+            return [{
+              path,
+              property: 'type',
+              message: this.translate('error_type', [schema.type], schema)
+            }]
+          }
+        }
+        return []
+      },
+      disallow (schema, value, path) {
+        /* Union type */
+        if (Array.isArray(schema.disallow)) {
+          const invalid = schema.disallow.some(e => this._checkType(e, value))
+          if (invalid) {
+            return [{
+              path,
+              property: 'disallow',
+              message: this.translate('error_disallow_union', null, schema)
+            }]
+          }
+        } else {
+          /* Simple type */
+          if (this._checkType(schema.disallow, value)) {
+            return [{
+              path,
+              property: 'disallow',
+              message: this.translate('error_disallow', [schema.disallow], schema)
+            }]
+          }
         }
+        return []
       }
+    }
 
-      // `maximum`
-      if(schema.hasOwnProperty('maximum')) {
-        // Vanilla JS, prone to floating point rounding errors (e.g. .999999999999999 == 1)
-        valid = schema.exclusiveMaximum? (value < schema.maximum) : (value <= schema.maximum);
+    this._validateNumberSubSchema = {
+      multipleOf (schema, value, path) { return this._validateNumberSubSchemaMultipleDivisible(schema, value, path) },
+      divisibleBy (schema, value, path) { return this._validateNumberSubSchemaMultipleDivisible(schema, value, path) },
+      maximum (schema, value, path) {
+        /* Vanilla JS, prone to floating point rounding errors (e.g. .999999999999999 == 1) */
+        let valid = schema.exclusiveMaximum ? (value < schema.maximum) : (value <= schema.maximum)
 
-        // Use math.js is available
-        if(window.math) {
-          valid = window.math[schema.exclusiveMaximum?'smaller':'smallerEq'](
+        /* Use math.js is available */
+        if (window.math) {
+          valid = window.math[schema.exclusiveMaximum ? 'smaller' : 'smallerEq'](
             window.math.bignumber(value),
             window.math.bignumber(schema.maximum)
-          );
-        }
-        // Use Decimal.js if available
-        else if(window.Decimal) {
-          valid = (new window.Decimal(value))[schema.exclusiveMaximum?'lt':'lte'](new window.Decimal(schema.maximum));
+          )
+        } else if (window.Decimal) {
+          /* Use Decimal.js if available */
+          valid = (new window.Decimal(value))[schema.exclusiveMaximum ? 'lt' : 'lte'](new window.Decimal(schema.maximum))
         }
 
-        if(!valid) {
-          errors.push({
-            path: path,
+        if (!valid) {
+          return [{
+            path,
             property: 'maximum',
             message: this.translate(
-              (schema.exclusiveMaximum?'error_maximum_excl':'error_maximum_incl'),
-              [schema.maximum]
+              (schema.exclusiveMaximum ? 'error_maximum_excl' : 'error_maximum_incl'),
+              [schema.maximum],
+              schema
             )
-          });
+          }]
         }
-      }
+        return []
+      },
+      minimum (schema, value, path) {
+        /* Vanilla JS, prone to floating point rounding errors (e.g. .999999999999999 == 1) */
+        let valid = schema.exclusiveMinimum ? (value > schema.minimum) : (value >= schema.minimum)
 
-      // `minimum`
-      if(schema.hasOwnProperty('minimum')) {
-        // Vanilla JS, prone to floating point rounding errors (e.g. .999999999999999 == 1)
-        valid = schema.exclusiveMinimum? (value > schema.minimum) : (value >= schema.minimum);
-
-        // Use math.js is available
-        if(window.math) {
-          valid = window.math[schema.exclusiveMinimum?'larger':'largerEq'](
+        /* Use math.js is available */
+        if (window.math) {
+          valid = window.math[schema.exclusiveMinimum ? 'larger' : 'largerEq'](
             window.math.bignumber(value),
             window.math.bignumber(schema.minimum)
-          );
-        }
-        // Use Decimal.js if available
-        else if(window.Decimal) {
-          valid = (new window.Decimal(value))[schema.exclusiveMinimum?'gt':'gte'](new window.Decimal(schema.minimum));
+          )
+          /* Use Decimal.js if available */
+        } else if (window.Decimal) {
+          valid = (new window.Decimal(value))[schema.exclusiveMinimum ? 'gt' : 'gte'](new window.Decimal(schema.minimum))
         }
 
-        if(!valid) {
-          errors.push({
-            path: path,
+        if (!valid) {
+          return [{
+            path,
             property: 'minimum',
             message: this.translate(
-              (schema.exclusiveMinimum?'error_minimum_excl':'error_minimum_incl'),
-              [schema.minimum]
+              (schema.exclusiveMinimum ? 'error_minimum_excl' : 'error_minimum_incl'),
+              [schema.minimum],
+              schema
             )
-          });
+          }]
         }
+        return []
       }
     }
-    // String specific validation
-    else if(typeof value === "string") {
-      // `maxLength`
-      if(schema.maxLength) {
-        if((value+"").length > schema.maxLength) {
-          errors.push({
-            path: path,
-            property: 'maxLength',
-            message: this.translate('error_maxLength', [schema.maxLength])
-          });
-        }
-      }
 
-      // `minLength`
-      if(schema.minLength) {
-        if((value+"").length < schema.minLength) {
+    this._validateStringSubSchema = {
+      maxLength (schema, value, path) {
+        const errors = []
+        if ((`${value}`).length > schema.maxLength) {
           errors.push({
-            path: path,
+            path,
+            property: 'maxLength',
+            message: this.translate('error_maxLength', [schema.maxLength], schema)
+          })
+        }
+        return errors
+      },
+      /* `minLength` */
+      minLength (schema, value, path) {
+        if ((`${value}`).length < schema.minLength) {
+          return [{
+            path,
             property: 'minLength',
-            message: this.translate((schema.minLength===1?'error_notempty':'error_minLength'), [schema.minLength])
-          });
-        }
-      }
-
-      // `pattern`
-      if(schema.pattern) {
-        if(!(new RegExp(schema.pattern)).test(value)) {
-          errors.push({
-            path: path,
+            message: this.translate((schema.minLength === 1 ? 'error_notempty' : 'error_minLength'), [schema.minLength], schema)
+          }]
+        }
+        return []
+      },
+      /* `pattern` */
+      pattern (schema, value, path) {
+        if (!(new RegExp(schema.pattern)).test(value)) {
+          return [{
+            path,
             property: 'pattern',
-            message: this.translate('error_pattern', [schema.pattern])
-          });
+            message: (schema.options && schema.options.patternmessage) ? schema.options.patternmessage : this.translate('error_pattern', [schema.pattern], schema)
+          }]
         }
+        return []
       }
     }
-    // Array specific validation
-    else if(typeof value === "object" && value !== null && Array.isArray(value)) {
-      // `items` and `additionalItems`
-      if(schema.items) {
-        // `items` is an array
-        if(Array.isArray(schema.items)) {
-          for(i=0; i<value.length; i++) {
-            // If this item has a specific schema tied to it
-            // Validate against it
-            if(schema.items[i]) {
-              errors = errors.concat(this._validateSchema(schema.items[i],value[i],path+'.'+i));
-            }
-            // If all additional items are allowed
-            else if(schema.additionalItems === true) {
-              break;
-            }
-            // If additional items is a schema
-            // TODO: Incompatibility between version 3 and 4 of the spec
-            else if(schema.additionalItems) {
-              errors = errors.concat(this._validateSchema(schema.additionalItems,value[i],path+'.'+i));
-            }
-            // If no additional items are allowed
-            else if(schema.additionalItems === false) {
+
+    this._validateArraySubSchema = {
+      items (schema, value, path) {
+        const errors = []
+        if (Array.isArray(schema.items)) {
+          for (let i = 0; i < value.length; i++) {
+            /* If this item has a specific schema tied to it */
+            /* Validate against it */
+            if (schema.items[i]) {
+              errors.push(...this._validateSchema(schema.items[i], value[i], `${path}.${i}`))
+              /* If all additional items are allowed */
+            } else if (schema.additionalItems === true) {
+              break
+              /* If additional items is a schema */
+              /* TODO: Incompatibility between version 3 and 4 of the spec */
+            } else if (schema.additionalItems) {
+              errors.push(...this._validateSchema(schema.additionalItems, value[i], `${path}.${i}`))
+              /* If no additional items are allowed */
+            } else if (schema.additionalItems === false) {
               errors.push({
-                path: path,
+                path,
                 property: 'additionalItems',
-                message: this.translate('error_additionalItems')
-              });
-              break;
-            }
-            // Default for `additionalItems` is an empty schema
-            else {
-              break;
+                message: this.translate('error_additionalItems', null, schema)
+              })
+              break
+              /* Default for `additionalItems` is an empty schema */
+            } else {
+              break
             }
           }
-        }
-        // `items` is a schema
-        else {
-          // Each item in the array must validate against the schema
-          for(i=0; i<value.length; i++) {
-            errors = errors.concat(this._validateSchema(schema.items,value[i],path+'.'+i));
-          }
-        }
-      }
-
-      // `maxItems`
-      if(schema.maxItems) {
-        if(value.length > schema.maxItems) {
-          errors.push({
-            path: path,
+          /* `items` is a schema */
+        } else {
+          /* Each item in the array must validate against the schema */
+          value.forEach((e, i) => {
+            errors.push(...this._validateSchema(schema.items, e, `${path}.${i}`))
+          })
+        }
+        return errors
+      },
+      maxItems (schema, value, path) {
+        if (value.length > schema.maxItems) {
+          return [{
+            path,
             property: 'maxItems',
-            message: this.translate('error_maxItems', [schema.maxItems])
-          });
-        }
-      }
-
-      // `minItems`
-      if(schema.minItems) {
-        if(value.length < schema.minItems) {
-          errors.push({
-            path: path,
+            message: this.translate('error_maxItems', [schema.maxItems], schema)
+          }]
+        }
+        return []
+      },
+      minItems (schema, value, path) {
+        if (value.length < schema.minItems) {
+          return [{
+            path,
             property: 'minItems',
-            message: this.translate('error_minItems', [schema.minItems])
-          });
-        }
-      }
-
-      // `uniqueItems`
-      if(schema.uniqueItems) {
-        var seen = {};
-        for(i=0; i<value.length; i++) {
-          valid = JSON.stringify(value[i]);
-          if(seen[valid]) {
-            errors.push({
-              path: path,
+            message: this.translate('error_minItems', [schema.minItems], schema)
+          }]
+        }
+        return []
+      },
+      uniqueItems (schema, value, path) {
+        const seen = {}
+        for (let i = 0; i < value.length; i++) {
+          const valid = JSON.stringify(value[i])
+          if (seen[valid]) {
+            return [{
+              path,
               property: 'uniqueItems',
-              message: this.translate('error_uniqueItems')
-            });
-            break;
+              message: this.translate('error_uniqueItems', null, schema)
+            }]
           }
-          seen[valid] = true;
+          seen[valid] = true
         }
+        return []
       }
     }
-    // Object specific validation
-    else if(typeof value === "object" && value !== null) {
-      // `maxProperties`
-      if(schema.maxProperties) {
-        valid = 0;
-        for(i in value) {
-          if(!value.hasOwnProperty(i)) continue;
-          valid++;
-        }
-        if(valid > schema.maxProperties) {
-          errors.push({
-            path: path,
-            property: 'maxProperties',
-            message: this.translate('error_maxProperties', [schema.maxProperties])
-          });
-        }
-      }
 
-      // `minProperties`
-      if(schema.minProperties) {
-        valid = 0;
-        for(i in value) {
-          if(!value.hasOwnProperty(i)) continue;
-          valid++;
-        }
-        if(valid < schema.minProperties) {
-          errors.push({
-            path: path,
+    this._validateObjectSubSchema = {
+      maxProperties (schema, value, path) {
+        if (Object.keys(value).length > schema.maxProperties) {
+          return [{
+            path,
+            property: 'maxProperties',
+            message: this.translate('error_maxProperties', [schema.maxProperties], schema)
+          }]
+        }
+        return []
+      },
+      minProperties (schema, value, path) {
+        if (Object.keys(value).length < schema.minProperties) {
+          return [{
+            path,
             property: 'minProperties',
-            message: this.translate('error_minProperties', [schema.minProperties])
-          });
-        }
-      }
-
-      // Version 4 `required`
-      if(typeof schema.required !== "undefined" && Array.isArray(schema.required)) {
-        for(i=0; i<schema.required.length; i++) {
-          if(typeof value[schema.required[i]] === "undefined") {
+            message: this.translate('error_minProperties', [schema.minProperties], schema)
+          }]
+        }
+        return []
+      },
+      required (schema, value, path) {
+        const errors = []
+        if (Array.isArray(schema.required)) {
+          schema.required.forEach(e => {
+            if (typeof value[e] !== 'undefined') return
+            const editor = this.jsoneditor.getEditor(`${path}.${e}`)
+            if (editor && editor.dependenciesFulfilled === false) return
+            /* Ignore required error if editor is of type "button" or "info" */
+            if (editor && ['button', 'info'].includes(editor.schema.format || editor.schema.type)) return
             errors.push({
-              path: path,
+              path,
               property: 'required',
-              message: this.translate('error_required', [schema.required[i]])
-            });
-          }
-        }
-      }
-
-      // `properties`
-      var validated_properties = {};
-      for(i in schema.properties) {
-        if(!schema.properties.hasOwnProperty(i)) continue;
-        validated_properties[i] = true;
-        errors = errors.concat(this._validateSchema(schema.properties[i],value[i],path+'.'+i));
-      }
-
-      // `patternProperties`
-      if(schema.patternProperties) {
-        for(i in schema.patternProperties) {
-          if(!schema.patternProperties.hasOwnProperty(i)) continue;
-          var regex = new RegExp(i);
-
-          // Check which properties match
-          for(j in value) {
-            if(!value.hasOwnProperty(j)) continue;
-            if(regex.test(j)) {
-              validated_properties[j] = true;
-              errors = errors.concat(this._validateSchema(schema.patternProperties[i],value[j],path+'.'+j));
+              message: this.translate('error_required', [schema && schema.properties && schema.properties[e] && schema.properties[e].title ? schema.properties[e].title : e], schema)
+            })
+          })
+        }
+        return errors
+      },
+      properties (schema, value, path, validatedProperties) {
+        const errors = []
+        Object.entries(schema.properties).forEach(([key, prop]) => {
+          validatedProperties[key] = true
+          errors.push(...this._validateSchema(prop, value[key], `${path}.${key}`))
+        })
+        return errors
+      },
+      patternProperties (schema, value, path, validatedProperties) {
+        const errors = []
+        Object.entries(schema.patternProperties).forEach(([i, prop]) => {
+          const regex = new RegExp(i)
+          /* Check which properties match */
+          Object.entries(value).forEach(([j, v]) => {
+            if (regex.test(j)) {
+              validatedProperties[j] = true
+              errors.push(...this._validateSchema(prop, v, `${path}.${j}`))
             }
-          }
-        }
-      }
-
-      // The no_additional_properties option currently doesn't work with extended schemas that use oneOf or anyOf
-      if(typeof schema.additionalProperties === "undefined" && this.jsoneditor.options.no_additional_properties && !schema.oneOf && !schema.anyOf) {
-        schema.additionalProperties = false;
+          })
+        })
+        return errors
       }
+    }
 
-      // `additionalProperties`
-      if(typeof schema.additionalProperties !== "undefined") {
-        for(i in value) {
-          if(!value.hasOwnProperty(i)) continue;
-          if(!validated_properties[i]) {
-            // No extra properties allowed
-            if(!schema.additionalProperties) {
-              errors.push({
-                path: path,
-                property: 'additionalProperties',
-                message: this.translate('error_additional_properties', [i])
-              });
-              break;
+    this._validateObjectSubSchema2 = {
+      propertyNames (schema, value, path, validatedProperties) {
+        const errors = []
+        const keys = Object.keys(value)
+        let k = null
+        for (let i = 0; i < keys.length; i++) {
+          let msg = ''
+          let truthy = false
+          k = keys[i]
+          /* Check property names that don't match */
+          if (typeof schema.propertyNames === 'boolean') {
+            if (schema.propertyNames === true) {
+              continue
             }
-            // Allowed
-            else if(schema.additionalProperties === true) {
-              break;
-            }
-            // Must match schema
-            // TODO: incompatibility between version 3 and 4 of the spec
-            else {
-              errors = errors.concat(this._validateSchema(schema.additionalProperties,value[i],path+'.'+i));
+            errors.push({
+              path,
+              property: 'propertyNames',
+              message: this.translate('error_property_names_false', [k], schema)
+            })
+            break
+          }
+          truthy = Object.entries(schema.propertyNames).every(([j, prop]) => {
+            let match = false
+            let regex = null
+            switch (j) {
+              case 'maxLength':
+                if (typeof prop !== 'number') {
+                  msg = 'error_property_names_maxlength'
+                  break
+                }
+                if (k.length > prop) {
+                  msg = 'error_property_names_exceeds_maxlength'
+                  break
+                }
+                return true
+              case 'const':
+                if (prop !== k) {
+                  msg = 'error_property_names_const_mismatch'
+                  break
+                }
+                return true
+              case 'enum':
+                if (!Array.isArray(prop)) {
+                  msg = 'error_property_names_enum'
+                  break
+                }
+                prop.forEach(p => {
+                  if (p === k) {
+                    match = true
+                  }
+                })
+                if (!match) {
+                  msg = 'error_property_names_enum_mismatch'
+                  break
+                }
+                return true
+              case 'pattern':
+                if (typeof prop !== 'string') {
+                  msg = 'error_property_names_pattern'
+                  break
+                }
+                regex = new RegExp(prop)
+                if (!regex.test(k)) {
+                  msg = 'error_property_names_pattern_mismatch'
+                  break
+                }
+                return true
+              default:
+                errors.push({
+                  path,
+                  property: 'propertyNames',
+                  message: this.translate('error_property_names_unsupported', [j], schema)
+                })
+                return false
             }
+            errors.push({
+              path,
+              property: 'propertyNames',
+              message: this.translate(msg, [k], schema)
+            })
+            return false
+          })
+          if (!truthy) break
+        }
+        return errors
+      },
+      additionalProperties (schema, value, path, validatedProperties) {
+        const errors = []
+        const keys = Object.keys(value)
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i]
+          if (validatedProperties[k]) continue
+          /* No extra properties allowed */
+          if (!schema.additionalProperties) {
+            errors.push({
+              path,
+              property: 'additionalProperties',
+              message: this.translate('error_additional_properties', [k], schema)
+            })
+            break
+            /* Allowed */
+          } else if (schema.additionalProperties === true) {
+            break
+            /* Must match schema */
+            /* TODO: incompatibility between version 3 and 4 of the spec */
+          } else {
+            errors.push(...this._validateSchema(schema.additionalProperties, value[k], `${path}.${k}`))
           }
         }
-      }
-
-      // `dependencies`
-      if(schema.dependencies) {
-        for(i in schema.dependencies) {
-          if(!schema.dependencies.hasOwnProperty(i)) continue;
-
-          // Doesn't need to meet the dependency
-          if(typeof value[i] === "undefined") continue;
-
-          // Property dependency
-          if(Array.isArray(schema.dependencies[i])) {
-            for(j=0; j<schema.dependencies[i].length; j++) {
-              if(typeof value[schema.dependencies[i][j]] === "undefined") {
+        return errors
+      },
+      dependencies (schema, value, path) {
+        const errors = []
+        Object.entries(schema.dependencies).forEach(([i, dep]) => {
+          /* Doesn't need to meet the dependency */
+          if (typeof value[i] === 'undefined') return
+
+          /* Property dependency */
+          if (Array.isArray(dep)) {
+            dep.forEach(d => {
+              if (typeof value[d] === 'undefined') {
                 errors.push({
-                  path: path,
+                  path,
                   property: 'dependencies',
-                  message: this.translate('error_dependency', [schema.dependencies[i][j]])
-                });
+                  message: this.translate('error_dependency', [d], schema)
+                })
               }
-            }
+            })
+            /* Schema dependency */
+          } else {
+            errors.push(...this._validateSchema(dep, value, path))
           }
-          // Schema dependency
-          else {
-            errors = errors.concat(this._validateSchema(schema.dependencies[i],value,path));
-          }
-        }
+        })
+        return errors
       }
     }
+  }
 
-    // date, time and datetime-local validation
-    if(['date', 'time', 'datetime-local'].indexOf(schema.format) != -1) {
-
-      var validator = {
-          'date': /^(\d{4}\D\d{2}\D\d{2})?$/,
-          'time': /^(\d{2}:\d{2}(?::\d{2})?)?$/,
-          'datetime-local': /^(\d{4}\D\d{2}\D\d{2} \d{2}:\d{2}(?::\d{2})?)?$/
-      };
-      var format = {
-          'date': '"YYYY-MM-DD"',
-          'time': '"HH:MM"',
-          'datetime-local': '"YYYY-MM-DD HH:MM"'
-      };
-
-      var ed = this.jsoneditor.getEditor(path);
-      var dateFormat = ed.flatpickr ? ed.flatpickr.config.dateFormat : format[ed.format];
-
-      if (schema.type == 'integer') {
-        // The value is a timestamp
-        if (value * 1 < 1) {
-          // If value is less than 1, then it's an invalid epoch date before 00:00:00 UTC Thursday, 1 January 1970
-          errors.push({
-            path: path,
-            property: 'format',
-            message: this.translate('error_invalid_epoch')
-          });
+  fitTest (value, givenSchema, weight = 10000000) {
+    const fit = { match: 0, extra: 0 }
+    if (typeof value === 'object' && value !== null) {
+      /* Work on a copy of the schema */
+      const schema = this._getSchema(givenSchema)
+      /* If the schema is an anyOf declaration, do use the properties of the allowed sub schemata instead.
+      Of these sub schemata, the best fit is selected */
+      if (schema.anyOf) {
+        let bestFit = { ...fit }
+        for (const subSchema of schema.anyOf) {
+          const subFit = this.fitTest(value, subSchema, weight)
+          /* The best fit is the one with the best value for match. If there are multiple results
+          with the same match value, use the one with the least number of extra properties */
+          if ((subFit.match > bestFit.match) || (subFit.match === bestFit.match && subFit.extra < bestFit.extra)) {
+            bestFit = subFit
+          }
         }
-        else if (value != Math.abs(parseInt(value))) {
-          // not much to check for, so we assume value is ok if it's a positive number
-          errors.push({
-            path: path,
-            property: 'format',
-            message: this.translate('error_' + ed.format.replace(/-/g, "_"), [dateFormat])
-          });
+        return bestFit
+      } else {
+        const properties = this._getSchema(givenSchema).properties
+        for (const i in properties) {
+          if (!hasOwnProperty(properties, i)) {
+            fit.extra += weight
+            continue
+          }
+          if (typeof value[i] === 'object' && typeof properties[i] === 'object' && typeof properties[i].properties === 'object') {
+            const result = this.fitTest(value[i], properties[i], weight / 100)
+            fit.match += result.match
+            fit.extra += result.extra
+          }
+          if (typeof value[i] !== 'undefined') {
+            fit.match += weight
+          }
         }
       }
-      else if (!ed.flatpickr) {
-        // Standard string input, without flatpickr
-        if(!validator[ed.format].test(value)) {
-          errors.push({
-            path: path,
-            property: 'format',
-            message: this.translate('error_' + ed.format.replace(/-/g, "_"), [format[ed.format]])
-          });
-        }
+    }
+    return fit
+  }
+
+  _getSchema (schema) {
+    return typeof schema === 'undefined' ? extend({}, this.jsoneditor.expandRefs(this.schema)) : schema
+  }
+
+  validate (value) {
+    return this._validateSchema(this.schema, value)
+  }
+
+  _validateSchema (schema, value, path) {
+    const errors = []
+    path = path || this.jsoneditor.root.formname
+
+    /* Work on a copy of the schema */
+    schema = extend({}, this.jsoneditor.expandRefs(schema))
+
+    /*
+     * Type Agnostic Validation
+     */
+    /* Version 3 `required` and `required_by_default` */
+    if (typeof value === 'undefined') {
+      return this._validateV3Required(schema, value, path)
+    }
+
+    Object.keys(schema).forEach(key => {
+      if (this._validateSubSchema[key]) {
+        errors.push(...this._validateSubSchema[key].call(this, schema, value, path))
       }
-      else {
-        // Flatpickr validation
-        if (value !== '') {
-
-          var compareValue;
-          if(ed.flatpickr.config.mode != 'single') {
-            var seperator = ed.flatpickr.config.mode == 'range' ? ed.flatpickr.l10n.rangeSeparator : ', ';
-            var selectedDates = ed.flatpickr.selectedDates.map(function(val) {
-                return ed.flatpickr.formatDate(val, ed.flatpickr.config.dateFormat);
-            });
-            compareValue = selectedDates.join(seperator);
-          }
+    })
 
-          try {
-            if (compareValue) {
-              // Not the best validation method, but range and multiple mode are special
-              // Optimal solution would be if it is possible to change the return format from string/integer to array
-              if (compareValue != value) throw ed.flatpickr.config.mode + ' mismatch';
-            }
-            else if (ed.flatpickr.formatDate(ed.flatpickr.parseDate(value, ed.flatpickr.config.dateFormat), ed.flatpickr.config.dateFormat) != value) throw 'mismatch';
-          }
-          catch(err) {
-            var errorDateFormat = ed.flatpickr.config.errorDateFormat !== undefined ? ed.flatpickr.config.errorDateFormat : ed.flatpickr.config.dateFormat;
-            errors.push({
-              path: path,
-              property: 'format',
-              message: this.translate('error_' + ed.format.replace(/-/g, "_"), [errorDateFormat])
-            });
+    /*
+     * Type Specific Validation
+     */
+    errors.push(...this._validateByValueType(schema, value, path))
+
+    if (schema.links) {
+      schema.links.forEach((s, m) => {
+        if (s.rel && s.rel.toLowerCase() === 'describedby') {
+          schema = this._expandSchemaLink(schema, m)
+          errors.push(...this._validateSchema(schema, value, path, this.translate))
+        }
+      })
+    }
+
+    /* date, time and datetime-local validation */
+    if (['date', 'time', 'datetime-local'].includes(schema.format)) {
+      errors.push(...this._validateDateTimeSubSchema(schema, value, path))
+    }
+
+    /* uuid validation */
+    if (['uuid'].includes(schema.format)) {
+      errors.push(...this._validateUUIDSchema(schema, value, path))
+    }
+
+    /* custom validator */
+    errors.push(...this._validateCustomValidator(schema, value, path))
+
+    /* Remove duplicate errors and add "errorcount" property */
+    return this._removeDuplicateErrors(errors)
+  }
+
+  _expandSchemaLink (schema, m) {
+    const href = schema.links[m].href
+    const data = this.jsoneditor.root.getValue()
+    const template = this.jsoneditor.compileTemplate(href, this.jsoneditor.template)
+    const ref = document.location.origin + document.location.pathname + template(data)
+
+    schema.links = schema.links.slice(0, m).concat(schema.links.slice(m + 1))
+    return extend({}, schema, this.jsoneditor.refs[ref])
+  }
+
+  _validateV3Required (schema, value, path) {
+    if (((typeof schema.required !== 'undefined' && schema.required === true) || (typeof schema.required === 'undefined' && this.jsoneditor.options.required_by_default === true)) && (schema.type !== 'info')) {
+      return [{
+        path,
+        property: 'required',
+        message: this.translate('error_notset', null, schema)
+      }]
+    }
+    return []
+  }
+
+  _validateByValueType (schema, value, path) {
+    const errors = []
+    if (value === null) return errors
+    /* Number Specific Validation */
+    if (typeof value === 'number') {
+      /* `multipleOf` and `divisibleBy` */
+      /* `maximum` */
+      /* `minimum` */
+      Object.keys(schema).forEach(key => {
+        if (this._validateNumberSubSchema[key]) {
+          errors.push(...this._validateNumberSubSchema[key].call(this, schema, value, path))
+        }
+      })
+      /* String specific validation */
+    } else if (typeof value === 'string') {
+      /* `maxLength` */
+      /* `minLength` */
+      /* `pattern` */
+      Object.keys(schema).forEach(key => {
+        if (this._validateStringSubSchema[key]) {
+          errors.push(...this._validateStringSubSchema[key].call(this, schema, value, path))
+        }
+      })
+      /* Array specific validation */
+    } else if (Array.isArray(value)) {
+      /* `items` and `additionalItems`
+      /* `maxItems`
+      /* `minItems`
+      /* `uniqueItems` */
+      Object.keys(schema).forEach(key => {
+        if (this._validateArraySubSchema[key]) {
+          errors.push(...this._validateArraySubSchema[key].call(this, schema, value, path))
+        }
+      })
+      /* Object specific validation */
+    } else if (typeof value === 'object') {
+      const validatedProperties = {}
+      /* `maxProperties`
+      /* `minProperties`
+      /*  Version 4 `required`
+      /* `properties`
+      /* `patternProperties` */
+      Object.keys(schema).forEach(key => {
+        if (this._validateObjectSubSchema[key]) {
+          errors.push(...this._validateObjectSubSchema[key].call(this, schema, value, path, validatedProperties))
+        }
+      })
+
+      /* The no_additional_properties option currently doesn't work with extended schemas that use oneOf or anyOf or allOf */
+      if (typeof schema.additionalProperties === 'undefined' && this.jsoneditor.options.no_additional_properties && !schema.oneOf && !schema.anyOf && !schema.allOf) {
+        schema.additionalProperties = false
+      }
+
+      /* `additionalProperties` */
+      /* `dependencies` */
+      Object.keys(schema).forEach(key => {
+        if (typeof this._validateObjectSubSchema2[key] !== 'undefined') {
+          errors.push(...this._validateObjectSubSchema2[key].call(this, schema, value, path, validatedProperties))
+        }
+      })
+    }
+    return errors
+  }
+
+  _validateUUIDSchema (schema, value, path) {
+    if (!(/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value))) {
+      return [{
+        path,
+        property: 'format',
+        message: this.translate('error_pattern', ['^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$'], schema)
+      }]
+    }
+    return []
+  }
+
+  _validateNumberSubSchemaMultipleDivisible (schema, value, path) {
+    const divisor = schema.multipleOf || schema.divisibleBy
+    /* Vanilla JS, prone to floating point rounding errors (e.g. 1.14 / .01 == 113.99999) */
+    let valid = (value / divisor === Math.floor(value / divisor))
+
+    /* Use math.js is available */
+    if (window.math) {
+      valid = window.math.mod(window.math.bignumber(value), window.math.bignumber(divisor)).equals(0)
+    } else if (window.Decimal) {
+      /* Use decimal.js is available */
+      valid = (new window.Decimal(value)).mod(new window.Decimal(divisor)).equals(0)
+    }
+
+    if (!valid) {
+      return [{
+        path,
+        property: schema.multipleOf ? 'multipleOf' : 'divisibleBy',
+        message: this.translate('error_multipleOf', [divisor], schema)
+      }]
+    }
+    return []
+  }
+
+  _validateDateTimeSubSchema (schema, value, path) {
+    const _validateInteger = (schema, value, path) => {
+      /* The value is a timestamp */
+      if (value * 1 < 1) {
+        /* If value is less than 1, then it's an invalid epoch date before 00:00:00 UTC Thursday, 1 January 1970 */
+        return [{
+          path,
+          property: 'format',
+          message: this.translate('error_invalid_epoch', null, schema)
+        }]
+      } else if (value !== Math.abs(parseInt(value))) {
+        /* not much to check for, so we assume value is ok if it's a positive number */
+        return [{
+          path,
+          property: 'format',
+          message: this.translate(`error_${schema.format.replace(/-/g, '_')}`, [dateFormat], schema)
+        }]
+      }
+      return []
+    }
+    const _validateFlatPicker = (schema, value, path, editor) => {
+      if (value !== '') {
+        let compareValue
+        if (editor.flatpickr.config.mode !== 'single') {
+          const seperator = editor.flatpickr.config.mode === 'range' ? editor.flatpickr.l10n.rangeSeparator : ', '
+          const selectedDates = editor.flatpickr.selectedDates.map(val =>
+            editor.flatpickr.formatDate(val, editor.flatpickr.config.dateFormat)
+          )
+          compareValue = selectedDates.join(seperator)
+        }
+
+        try {
+          if (compareValue) {
+            /* Not the best validation method, but range and multiple mode are special */
+            /* Optimal solution would be if it is possible to change the return format from string/integer to array */
+            if (compareValue !== value) throw new Error(`${editor.flatpickr.config.mode} mismatch`)
+          } else if (editor.flatpickr.formatDate(editor.flatpickr.parseDate(value, editor.flatpickr.config.dateFormat), editor.flatpickr.config.dateFormat) !== value) {
+            throw new Error('mismatch')
           }
+        } catch (err) {
+          const errorDateFormat = editor.flatpickr.config.errorDateFormat !== undefined ? editor.flatpickr.config.errorDateFormat : editor.flatpickr.config.dateFormat
+          return [{
+            path,
+            property: 'format',
+            message: this.translate(`error_${editor.format.replace(/-/g, '_')}`, [errorDateFormat], schema)
+          }]
         }
       }
+      return []
     }
-    // Custom type validation (global)
-    $each(JSONEditor.defaults.custom_validators,function(i,validator) {
-      errors = errors.concat(validator.call(self,schema,value,path));
-    });
-    // Custom type validation (instance specific)
-    if(this.options.custom_validators) {
-      $each(this.options.custom_validators,function(i,validator) {
-        errors = errors.concat(validator.call(self,schema,value,path));
-      });
+
+    const validatorRx = {
+      date: /^(\d{4}\D\d{2}\D\d{2})$/,
+      time: /^(\d{2}:\d{2}(?::\d{2})?)$/,
+      'datetime-local': /^(\d{4}\D\d{2}\D\d{2}[ T]\d{2}:\d{2}(?::\d{2})?)$/
+    }
+    const format = {
+      date: '"YYYY-MM-DD"',
+      time: '"HH:MM"',
+      'datetime-local': '"YYYY-MM-DD HH:MM"'
+    }
+
+    const editor = this.jsoneditor.getEditor(path)
+    const dateFormat = (editor && editor.flatpickr) ? editor.flatpickr.config.dateFormat : format[schema.format]
+
+    if (schema.type === 'integer') {
+      return _validateInteger(schema, value, path)
+    } else if (!editor || !editor.flatpickr) {
+      /* Standard string input, without flatpickr */
+      if (!validatorRx[schema.format].test(value)) {
+        return [{
+          path,
+          property: 'format',
+          message: this.translate(`error_${schema.format.replace(/-/g, '_')}`, [dateFormat], schema)
+        }]
+      }
+    } else if (editor) {
+      /* Flatpickr validation */
+      return _validateFlatPicker(schema, value, path, editor)
     }
 
-    return errors;
-  },
-  _checkType: function(type, value) {
-    // Simple types
-    if(typeof type === "string") {
-      if(type==="string") return typeof value === "string";
-      else if(type==="number") return typeof value === "number";
-      else if(type==="integer") return typeof value === "number" && value === Math.floor(value);
-      else if(type==="boolean") return typeof value === "boolean";
-      else if(type==="array") return Array.isArray(value);
-      else if(type === "object") return value !== null && !(Array.isArray(value)) && typeof value === "object";
-      else if(type === "null") return value === null;
-      else return true;
+    return []
+  }
+
+  _validateCustomValidator (schema, value, path) {
+    const errors = []
+    /* Internal validators using the custom validator format */
+    errors.push(...ipValidator.call(this, schema, value, path, this.translate))
+
+    const validate = validator => {
+      errors.push(...validator.call(this, schema, value, path))
+    }
+    /* Custom type validation (global) */
+    this.defaults.custom_validators.forEach(validate)
+    /* Custom type validation (instance specific) */
+    if (this.options.custom_validators) {
+      this.options.custom_validators.forEach(validate)
+    }
+    return errors
+  }
+
+  _removeDuplicateErrors (errors) {
+    return errors.reduce((err, obj) => {
+      let first = true
+      if (!err) err = []
+      err.forEach(a => {
+        if (a.message === obj.message && a.path === obj.path && a.property === obj.property) {
+          a.errorcount++
+          first = false
+        }
+      })
+      if (first) {
+        obj.errorcount = 1
+        err.push(obj)
+      }
+      return err
+    }, [])
+  }
+
+  _checkType (type, value) {
+    const types = {
+      string: value => typeof value === 'string',
+      number: value => typeof value === 'number',
+      integer: value => typeof value === 'number' && value === Math.floor(value),
+      boolean: value => typeof value === 'boolean',
+      array: value => Array.isArray(value),
+      object: value => value !== null && !(Array.isArray(value)) && typeof value === 'object',
+      null: value => value === null
     }
-    // Schema
-    else {
-      return !this._validateSchema(type,value).length;
+    /* Simple types */
+    if (typeof type === 'string') {
+      if (types[type]) {
+        return types[type](value)
+      } else return true
+      /* Schema */
+    } else {
+      return !this._validateSchema(type, value).length
     }
   }
-});
+}