Validate on top-level settings and use pre-compiled ajv

src/shared/settings/Blacklist.ts

@@ -1,23 +1,4 @@
 import Key from './Key';
-import Validator from './Validator';
-
-const ItemSchema = {
-  anyOf: [
-    { type: 'string' },
-    {
-      type: 'object',
-      properties: {
-        url: { type: 'string' },
-        keys: {
-          type: 'array',
-          items: { type: 'string', minLength: 1 },
-          minItems: 1,
-        }
-      },
-      required: ['url', 'keys'],
-    }
-  ],
-};
 
 export type BlacklistItemJSON = string | {
   url: string,
@@ -54,11 +35,10 @@ export class BlacklistItem {
     this.keyEntities = this.keys.map(Key.fromMapKey);
   }
 
-  static fromJSON(json: unknown): BlacklistItem {
-    let obj = new Validator<BlacklistItemJSON>(ItemSchema).validate(json);
-    return typeof obj === 'string'
-      ? new BlacklistItem(obj, false, [])
-      : new BlacklistItem(obj.url, true, obj.keys);
+  static fromJSON(json: BlacklistItemJSON): BlacklistItem {
+    return typeof json === 'string'
+      ? new BlacklistItem(json, false, [])
+      : new BlacklistItem(json.url, true, json.keys);
   }
 
   toJSON(): BlacklistItemJSON {
@@ -91,10 +71,7 @@ export default class Blacklist {
   ) {
   }
 
-  static fromJSON(json: unknown): Blacklist {
-    if (!Array.isArray(json)) {
-      throw new TypeError('blacklist is not an array');
-    }
+  static fromJSON(json: BlacklistJSON): Blacklist {
     let items = json.map(o => BlacklistItem.fromJSON(o));
     return new Blacklist(items);
   }

src/shared/settings/Keymaps.ts

@@ -1,32 +1,23 @@
 import * as operations from '../operations';
-import Validator from './Validator';
 
-const Schema = {
-  type: 'object',
-  patternProperties: {
-    '.*': {
-      type: 'object',
-      properties: {
-        type: { type: 'string' },
-      },
-      required: ['type'],
-    },
-  }
+type OperationJson = {
+  type: string
+} | {
+  type: string;
+  [prop: string]: string | number | boolean;
 };
-
-export type KeymapsJSON = { [key: string]: operations.Operation };
+export type KeymapsJSON = { [key: string]: OperationJson };
 
 export default class Keymaps {
   constructor(
-    private readonly data: KeymapsJSON,
+    private readonly data: { [key: string]: operations.Operation },
   ) {
   }
 
-  static fromJSON(json: unknown): Keymaps {
-    let obj = new Validator<KeymapsJSON>(Schema).validate(json);
-    let entries: KeymapsJSON = {};
-    for (let key of Object.keys(obj)) {
-      entries[key] = operations.valueOf(obj[key]);
+  static fromJSON(json: KeymapsJSON): Keymaps {
+    let entries: { [key: string]: operations.Operation } = {};
+    for (let key of Object.keys(json)) {
+      entries[key] = operations.valueOf(json[key]);
     }
     return new Keymaps(entries);
   }

src/shared/settings/Properties.ts

@@ -1,19 +1,3 @@
-import Validator from './Validator';
-
-const Schema = {
-  type: 'object',
-  properties: {
-    hintchars: {
-      type: 'string',
-    },
-    smoothscroll: {
-      type: 'boolean',
-    },
-    complete: {
-      type: 'string',
-    },
-  },
-};
 
 export type PropertiesJSON = {
   hintchars?: string;
@@ -82,9 +66,8 @@ export default class Properties {
     this.complete = complete || defaultValues.complete;
   }
 
-  static fromJSON(json: unknown): Properties {
-    let obj = new Validator<PropertiesJSON>(Schema).validate(json);
-    return new Properties(obj);
+  static fromJSON(json: PropertiesJSON): Properties {
+    return new Properties(json);
   }
 
   static types(): PropertyTypes {

src/shared/settings/Search.ts

@@ -1,22 +1,3 @@
-import Validator from './Validator';
-
-const Schema = {
-  type: 'object',
-  properties: {
-    default: { type: 'string' },
-    engines: {
-      type: 'object',
-      propertyNames: {
-        pattern: '^[A-Za-z_][A-Za-z0-9_]+$',
-      },
-      patternProperties: {
-        '.*': { type: 'string' },
-      },
-    },
-  },
-  required: ['default'],
-};
-
 type Entries = { [name: string]: string };
 
 export type SearchJSON = {
@@ -31,10 +12,11 @@ export default class Search {
   ) {
   }
 
-  static fromJSON(json: unknown): Search {
-    let obj = new Validator<SearchJSON>(Schema).validate(json);
-
-    for (let [name, url] of Object.entries(obj.engines)) {
+  static fromJSON(json: SearchJSON): Search {
+    for (let [name, url] of Object.entries(json.engines)) {
+      if (!(/^[a-zA-Z0-9]+$/).test(name)) {
+        throw new TypeError('Search engine\'s name must be [a-zA-Z0-9]+');
+      }
       let matches = url.match(/{}/g);
       if (matches === null) {
         throw new TypeError(`No {}-placeholders in URL of "${name}"`);
@@ -42,11 +24,11 @@ export default class Search {
         throw new TypeError(`Multiple {}-placeholders in URL of "${name}"`);
       }
     }
-    if (!Object.keys(obj.engines).includes(obj.default)) {
-      throw new TypeError(`Default engine "${obj.default}" not found`);
+    if (!Object.keys(json.engines).includes(json.default)) {
+      throw new TypeError(`Default engine "${json.default}" not found`);
     }
 
-    return new Search(obj.default, obj.engines);
+    return new Search(json.default, json.engines);
   }
 
   toJSON(): SearchJSON {

src/shared/settings/Settings.ts

@@ -1,13 +1,16 @@
+import Ajv from 'ajv';
+
 import Keymaps, { KeymapsJSON } from './Keymaps';
 import Search, { SearchJSON } from './Search';
 import Properties, { PropertiesJSON } from './Properties';
 import Blacklist, { BlacklistJSON } from './Blacklist';
+import validate from './validate';
 
 export type SettingsJSON = {
-  keymaps: KeymapsJSON,
-  search: SearchJSON,
-  properties: PropertiesJSON,
-  blacklist: BlacklistJSON,
+  keymaps?: KeymapsJSON,
+  search?: SearchJSON,
+  properties?: PropertiesJSON,
+  blacklist?: BlacklistJSON,
 };
 
 export default class Settings {
@@ -36,25 +39,30 @@ export default class Settings {
     this.blacklist = blacklist;
   }
 
-  static fromJSON(json: any): Settings {
+  static fromJSON(json: unknown): Settings {
+    let valid = validate(json);
+    if (!valid) {
+      let message = (validate as any).errors!!
+        .map((err: Ajv.ErrorObject) => {
+          return `'${err.dataPath}' of ${err.keyword} ${err.message}`;
+        })
+        .join('; ');
+      throw new TypeError(message);
+    }
+
+    let obj = json as SettingsJSON;
     let settings = { ...DefaultSetting };
-    for (let key of Object.keys(json)) {
-      switch (key) {
-      case 'keymaps':
-        settings.keymaps = Keymaps.fromJSON(json.keymaps);
-        break;
-      case 'search':
-        settings.search = Search.fromJSON(json.search);
-        break;
-      case 'properties':
-        settings.properties = Properties.fromJSON(json.properties);
-        break;
-      case 'blacklist':
-        settings.blacklist = Blacklist.fromJSON(json.blacklist);
-        break;
-      default:
-        throw new TypeError('unknown setting: ' + key);
-      }
+    if (obj.keymaps) {
+      settings.keymaps = Keymaps.fromJSON(obj.keymaps);
+    }
+    if (obj.search) {
+      settings.search = Search.fromJSON(obj.search);
+    }
+    if (obj.properties) {
+      settings.properties = Properties.fromJSON(obj.properties);
+    }
+    if (obj.blacklist) {
+      settings.blacklist = Blacklist.fromJSON(obj.blacklist);
     }
     return new Settings(settings);
   }

src/shared/settings/Validator.ts

@@ -1,20 +0,0 @@
-import Ajv from 'ajv';
-
-export default class Validator<T> {
-  constructor(
-    private schema: object | boolean,
-  ) {
-  }
-
-  validate(data: any): T {
-    let ajv = new Ajv();
-    let valid = ajv.validate(this.schema, data);
-    if (!valid) {
-      let message = ajv.errors!!
-        .map(err => `'${err.dataPath}' of ${err.keyword} ${err.message}`)
-        .join('; ');
-      throw new TypeError(message);
-    }
-    return data as T;
-  }
-}

src/shared/settings/schema.json

@@ -78,5 +78,6 @@
         ]
       }
     }
-  }
+  },
+  "additionalProperties": false
 }

src/shared/settings/validate.js

@@ -9,168 +9,90 @@ var validate = (function() {
     if ((data && typeof data === "object" && !Array.isArray(data))) {
       var errs__0 = errors;
       var valid1 = true;
-      var data1 = data.keymaps;
-      if (data1 === undefined) {
-        valid1 = true;
-      } else {
-        var errs_1 = errors;
-        if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) {
-          var errs__1 = errors;
-          var valid2 = true;
-          for (var key1 in data1) {
-            if (pattern0.test(key1)) {
-              var data2 = data1[key1];
-              var errs_2 = errors;
-              if ((data2 && typeof data2 === "object" && !Array.isArray(data2))) {
-                if (true) {
-                  var errs__2 = errors;
-                  var valid3 = true;
-                  if (data2.type === undefined) {
-                    valid3 = false;
-                    validate.errors = [{
-                      keyword: 'required',
-                      dataPath: (dataPath || '') + '.keymaps[\'' + key1 + '\']',
-                      schemaPath: '#/properties/keymaps/patternProperties/.*/required',
-                      params: {
-                        missingProperty: 'type'
-                      },
-                      message: 'should have required property \'type\''
-                    }];
-                    return false;
-                  } else {
-                    var errs_3 = errors;
-                    if (typeof data2.type !== "string") {
-                      validate.errors = [{
-                        keyword: 'type',
-                        dataPath: (dataPath || '') + '.keymaps[\'' + key1 + '\'].type',
-                        schemaPath: '#/properties/keymaps/patternProperties/.*/properties/type/type',
-                        params: {
-                          type: 'string'
-                        },
-                        message: 'should be string'
-                      }];
-                      return false;
-                    }
-                    var valid3 = errors === errs_3;
-                  }
-                }
-              } else {
-                validate.errors = [{
-                  keyword: 'type',
-                  dataPath: (dataPath || '') + '.keymaps[\'' + key1 + '\']',
-                  schemaPath: '#/properties/keymaps/patternProperties/.*/type',
-                  params: {
-                    type: 'object'
-                  },
-                  message: 'should be object'
-                }];
-                return false;
-              }
-              var valid2 = errors === errs_2;
-              if (!valid2) break;
-            } else valid2 = true;
-          }
-        } else {
+      for (var key0 in data) {
+        var isAdditional0 = !(false || key0 == 'keymaps' || key0 == 'search' || key0 == 'properties' || key0 == 'blacklist');
+        if (isAdditional0) {
+          valid1 = false;
           validate.errors = [{
-            keyword: 'type',
-            dataPath: (dataPath || '') + '.keymaps',
-            schemaPath: '#/properties/keymaps/type',
+            keyword: 'additionalProperties',
+            dataPath: (dataPath || '') + "",
+            schemaPath: '#/additionalProperties',
             params: {
-              type: 'object'
+              additionalProperty: '' + key0 + ''
             },
-            message: 'should be object'
+            message: 'should NOT have additional properties'
           }];
           return false;
+          break;
         }
-        var valid1 = errors === errs_1;
       }
       if (valid1) {
-        var data1 = data.search;
+        var data1 = data.keymaps;
         if (data1 === undefined) {
           valid1 = true;
         } else {
           var errs_1 = errors;
           if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) {
-            if (true) {
-              var errs__1 = errors;
-              var valid2 = true;
-              if (data1.default === undefined) {
-                valid2 = false;
-                validate.errors = [{
-                  keyword: 'required',
-                  dataPath: (dataPath || '') + '.search',
-                  schemaPath: '#/properties/search/required',
-                  params: {
-                    missingProperty: 'default'
-                  },
-                  message: 'should have required property \'default\''
-                }];
-                return false;
-              } else {
+            var errs__1 = errors;
+            var valid2 = true;
+            for (var key1 in data1) {
+              if (pattern0.test(key1)) {
+                var data2 = data1[key1];
                 var errs_2 = errors;
-                if (typeof data1.default !== "string") {
+                if ((data2 && typeof data2 === "object" && !Array.isArray(data2))) {
+                  if (true) {
+                    var errs__2 = errors;
+                    var valid3 = true;
+                    if (data2.type === undefined) {
+                      valid3 = false;
+                      validate.errors = [{
+                        keyword: 'required',
+                        dataPath: (dataPath || '') + '.keymaps[\'' + key1 + '\']',
+                        schemaPath: '#/properties/keymaps/patternProperties/.*/required',
+                        params: {
+                          missingProperty: 'type'
+                        },
+                        message: 'should have required property \'type\''
+                      }];
+                      return false;
+                    } else {
+                      var errs_3 = errors;
+                      if (typeof data2.type !== "string") {
+                        validate.errors = [{
+                          keyword: 'type',
+                          dataPath: (dataPath || '') + '.keymaps[\'' + key1 + '\'].type',
+                          schemaPath: '#/properties/keymaps/patternProperties/.*/properties/type/type',
+                          params: {
+                            type: 'string'
+                          },
+                          message: 'should be string'
+                        }];
+                        return false;
+                      }
+                      var valid3 = errors === errs_3;
+                    }
+                  }
+                } else {
                   validate.errors = [{
                     keyword: 'type',
-                    dataPath: (dataPath || '') + '.search.default',
-                    schemaPath: '#/properties/search/properties/default/type',
+                    dataPath: (dataPath || '') + '.keymaps[\'' + key1 + '\']',
+                    schemaPath: '#/properties/keymaps/patternProperties/.*/type',
                     params: {
-                      type: 'string'
+                      type: 'object'
                     },
-                    message: 'should be string'
+                    message: 'should be object'
                   }];
                   return false;
                 }
                 var valid2 = errors === errs_2;
-              }
-              if (valid2) {
-                var data2 = data1.engines;
-                if (data2 === undefined) {
-                  valid2 = true;
-                } else {
-                  var errs_2 = errors;
-                  if ((data2 && typeof data2 === "object" && !Array.isArray(data2))) {
-                    var errs__2 = errors;
-                    var valid3 = true;
-                    for (var key2 in data2) {
-                      if (pattern0.test(key2)) {
-                        var errs_3 = errors;
-                        if (typeof data2[key2] !== "string") {
-                          validate.errors = [{
-                            keyword: 'type',
-                            dataPath: (dataPath || '') + '.search.engines[\'' + key2 + '\']',
-                            schemaPath: '#/properties/search/properties/engines/patternProperties/.*/type',
-                            params: {
-                              type: 'string'
-                            },
-                            message: 'should be string'
-                          }];
-                          return false;
-                        }
-                        var valid3 = errors === errs_3;
-                        if (!valid3) break;
-                      } else valid3 = true;
-                    }
-                  } else {
-                    validate.errors = [{
-                      keyword: 'type',
-                      dataPath: (dataPath || '') + '.search.engines',
-                      schemaPath: '#/properties/search/properties/engines/type',
-                      params: {
-                        type: 'object'
-                      },
-                      message: 'should be object'
-                    }];
-                    return false;
-                  }
-                  var valid2 = errors === errs_2;
-                }
-              }
+                if (!valid2) break;
+              } else valid2 = true;
             }
           } else {
             validate.errors = [{
               keyword: 'type',
-              dataPath: (dataPath || '') + '.search',
-              schemaPath: '#/properties/search/type',
+              dataPath: (dataPath || '') + '.keymaps',
+              schemaPath: '#/properties/keymaps/type',
               params: {
                 type: 'object'
               },
@@ -181,65 +103,80 @@ var validate = (function() {
           var valid1 = errors === errs_1;
         }
         if (valid1) {
-          var data1 = data.properties;
+          var data1 = data.search;
           if (data1 === undefined) {
             valid1 = true;
           } else {
             var errs_1 = errors;
             if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) {
-              var errs__1 = errors;
-              var valid2 = true;
-              if (data1.hintchars === undefined) {
-                valid2 = true;
-              } else {
-                var errs_2 = errors;
-                if (typeof data1.hintchars !== "string") {
+              if (true) {
+                var errs__1 = errors;
+                var valid2 = true;
+                if (data1.default === undefined) {
+                  valid2 = false;
                   validate.errors = [{
-                    keyword: 'type',
-                    dataPath: (dataPath || '') + '.properties.hintchars',
-                    schemaPath: '#/properties/properties/properties/hintchars/type',
+                    keyword: 'required',
+                    dataPath: (dataPath || '') + '.search',
+                    schemaPath: '#/properties/search/required',
                     params: {
-                      type: 'string'
+                      missingProperty: 'default'
                     },
-                    message: 'should be string'
+                    message: 'should have required property \'default\''
                   }];
                   return false;
-                }
-                var valid2 = errors === errs_2;
-              }
-              if (valid2) {
-                if (data1.smoothscroll === undefined) {
-                  valid2 = true;
                 } else {
                   var errs_2 = errors;
-                  if (typeof data1.smoothscroll !== "boolean") {
+                  if (typeof data1.default !== "string") {
                     validate.errors = [{
                       keyword: 'type',
-                      dataPath: (dataPath || '') + '.properties.smoothscroll',
-                      schemaPath: '#/properties/properties/properties/smoothscroll/type',
+                      dataPath: (dataPath || '') + '.search.default',
+                      schemaPath: '#/properties/search/properties/default/type',
                       params: {
-                        type: 'boolean'
+                        type: 'string'
                       },
-                      message: 'should be boolean'
+                      message: 'should be string'
                     }];
                     return false;
                   }
                   var valid2 = errors === errs_2;
                 }
                 if (valid2) {
-                  if (data1.complete === undefined) {
+                  var data2 = data1.engines;
+                  if (data2 === undefined) {
                     valid2 = true;
                   } else {
                     var errs_2 = errors;
-                    if (typeof data1.complete !== "string") {
+                    if ((data2 && typeof data2 === "object" && !Array.isArray(data2))) {
+                      var errs__2 = errors;
+                      var valid3 = true;
+                      for (var key2 in data2) {
+                        if (pattern0.test(key2)) {
+                          var errs_3 = errors;
+                          if (typeof data2[key2] !== "string") {
+                            validate.errors = [{
+                              keyword: 'type',
+                              dataPath: (dataPath || '') + '.search.engines[\'' + key2 + '\']',
+                              schemaPath: '#/properties/search/properties/engines/patternProperties/.*/type',
+                              params: {
+                                type: 'string'
+                              },
+                              message: 'should be string'
+                            }];
+                            return false;
+                          }
+                          var valid3 = errors === errs_3;
+                          if (!valid3) break;
+                        } else valid3 = true;
+                      }
+                    } else {
                       validate.errors = [{
                         keyword: 'type',
-                        dataPath: (dataPath || '') + '.properties.complete',
-                        schemaPath: '#/properties/properties/properties/complete/type',
+                        dataPath: (dataPath || '') + '.search.engines',
+                        schemaPath: '#/properties/search/properties/engines/type',
                         params: {
-                          type: 'string'
+                          type: 'object'
                         },
-                        message: 'should be string'
+                        message: 'should be object'
                       }];
                       return false;
                     }
@@ -250,8 +187,8 @@ var validate = (function() {
             } else {
               validate.errors = [{
                 keyword: 'type',
-                dataPath: (dataPath || '') + '.properties',
-                schemaPath: '#/properties/properties/type',
+                dataPath: (dataPath || '') + '.search',
+                schemaPath: '#/properties/search/type',
                 params: {
                   type: 'object'
                 },
@@ -262,123 +199,148 @@ var validate = (function() {
             var valid1 = errors === errs_1;
           }
           if (valid1) {
-            var data1 = data.blacklist;
+            var data1 = data.properties;
             if (data1 === undefined) {
               valid1 = true;
             } else {
               var errs_1 = errors;
-              if (Array.isArray(data1)) {
+              if ((data1 && typeof data1 === "object" && !Array.isArray(data1))) {
                 var errs__1 = errors;
-                var valid1;
-                for (var i1 = 0; i1 < data1.length; i1++) {
-                  var data2 = data1[i1];
+                var valid2 = true;
+                if (data1.hintchars === undefined) {
+                  valid2 = true;
+                } else {
                   var errs_2 = errors;
-                  var errs__2 = errors;
-                  var valid2 = false;
-                  var errs_3 = errors;
-                  if (typeof data2 !== "string") {
-                    var err = {
+                  if (typeof data1.hintchars !== "string") {
+                    validate.errors = [{
                       keyword: 'type',
-                      dataPath: (dataPath || '') + '.blacklist[' + i1 + ']',
-                      schemaPath: '#/properties/blacklist/items/anyOf/0/type',
+                      dataPath: (dataPath || '') + '.properties.hintchars',
+                      schemaPath: '#/properties/properties/properties/hintchars/type',
                       params: {
                         type: 'string'
                       },
                       message: 'should be string'
-                    };
-                    if (vErrors === null) vErrors = [err];
-                    else vErrors.push(err);
-                    errors++;
+                    }];
+                    return false;
+                  }
+                  var valid2 = errors === errs_2;
+                }
+                if (valid2) {
+                  if (data1.smoothscroll === undefined) {
+                    valid2 = true;
+                  } else {
+                    var errs_2 = errors;
+                    if (typeof data1.smoothscroll !== "boolean") {
+                      validate.errors = [{
+                        keyword: 'type',
+                        dataPath: (dataPath || '') + '.properties.smoothscroll',
+                        schemaPath: '#/properties/properties/properties/smoothscroll/type',
+                        params: {
+                          type: 'boolean'
+                        },
+                        message: 'should be boolean'
+                      }];
+                      return false;
+                    }
+                    var valid2 = errors === errs_2;
+                  }
+                  if (valid2) {
+                    if (data1.complete === undefined) {
+                      valid2 = true;
+                    } else {
+                      var errs_2 = errors;
+                      if (typeof data1.complete !== "string") {
+                        validate.errors = [{
+                          keyword: 'type',
+                          dataPath: (dataPath || '') + '.properties.complete',
+                          schemaPath: '#/properties/properties/properties/complete/type',
+                          params: {
+                            type: 'string'
+                          },
+                          message: 'should be string'
+                        }];
+                        return false;
+                      }
+                      var valid2 = errors === errs_2;
+                    }
                   }
-                  var valid3 = errors === errs_3;
-                  valid2 = valid2 || valid3;
-                  if (!valid2) {
+                }
+              } else {
+                validate.errors = [{
+                  keyword: 'type',
+                  dataPath: (dataPath || '') + '.properties',
+                  schemaPath: '#/properties/properties/type',
+                  params: {
+                    type: 'object'
+                  },
+                  message: 'should be object'
+                }];
+                return false;
+              }
+              var valid1 = errors === errs_1;
+            }
+            if (valid1) {
+              var data1 = data.blacklist;
+              if (data1 === undefined) {
+                valid1 = true;
+              } else {
+                var errs_1 = errors;
+                if (Array.isArray(data1)) {
+                  var errs__1 = errors;
+                  var valid1;
+                  for (var i1 = 0; i1 < data1.length; i1++) {
+                    var data2 = data1[i1];
+                    var errs_2 = errors;
+                    var errs__2 = errors;
+                    var valid2 = false;
                     var errs_3 = errors;
-                    if ((data2 && typeof data2 === "object" && !Array.isArray(data2))) {
-                      if (true) {
-                        var errs__3 = errors;
-                        var valid4 = true;
-                        if (data2.url === undefined) {
-                          valid4 = false;
-                          var err = {
-                            keyword: 'required',
-                            dataPath: (dataPath || '') + '.blacklist[' + i1 + ']',
-                            schemaPath: '#/properties/blacklist/items/anyOf/1/required',
-                            params: {
-                              missingProperty: 'url'
-                            },
-                            message: 'should have required property \'url\''
-                          };
-                          if (vErrors === null) vErrors = [err];
-                          else vErrors.push(err);
-                          errors++;
-                        } else {
-                          var errs_4 = errors;
-                          if (typeof data2.url !== "string") {
-                            var err = {
-                              keyword: 'type',
-                              dataPath: (dataPath || '') + '.blacklist[' + i1 + '].url',
-                              schemaPath: '#/properties/blacklist/items/anyOf/1/properties/url/type',
-                              params: {
-                                type: 'string'
-                              },
-                              message: 'should be string'
-                            };
-                            if (vErrors === null) vErrors = [err];
-                            else vErrors.push(err);
-                            errors++;
-                          }
-                          var valid4 = errors === errs_4;
-                        }
-                        if (valid4) {
-                          var data3 = data2.keys;
-                          if (data3 === undefined) {
+                    if (typeof data2 !== "string") {
+                      var err = {
+                        keyword: 'type',
+                        dataPath: (dataPath || '') + '.blacklist[' + i1 + ']',
+                        schemaPath: '#/properties/blacklist/items/anyOf/0/type',
+                        params: {
+                          type: 'string'
+                        },
+                        message: 'should be string'
+                      };
+                      if (vErrors === null) vErrors = [err];
+                      else vErrors.push(err);
+                      errors++;
+                    }
+                    var valid3 = errors === errs_3;
+                    valid2 = valid2 || valid3;
+                    if (!valid2) {
+                      var errs_3 = errors;
+                      if ((data2 && typeof data2 === "object" && !Array.isArray(data2))) {
+                        if (true) {
+                          var errs__3 = errors;
+                          var valid4 = true;
+                          if (data2.url === undefined) {
                             valid4 = false;
                             var err = {
                               keyword: 'required',
                               dataPath: (dataPath || '') + '.blacklist[' + i1 + ']',
                               schemaPath: '#/properties/blacklist/items/anyOf/1/required',
                               params: {
-                                missingProperty: 'keys'
+                                missingProperty: 'url'
                               },
-                              message: 'should have required property \'keys\''
+                              message: 'should have required property \'url\''
                             };
                             if (vErrors === null) vErrors = [err];
                             else vErrors.push(err);
                             errors++;
                           } else {
                             var errs_4 = errors;
-                            if (Array.isArray(data3)) {
-                              var errs__4 = errors;
-                              var valid4;
-                              for (var i4 = 0; i4 < data3.length; i4++) {
-                                var errs_5 = errors;
-                                if (typeof data3[i4] !== "string") {
-                                  var err = {
-                                    keyword: 'type',
-                                    dataPath: (dataPath || '') + '.blacklist[' + i1 + '].keys[' + i4 + ']',
-                                    schemaPath: '#/properties/blacklist/items/anyOf/1/properties/keys/items/type',
-                                    params: {
-                                      type: 'string'
-                                    },
-                                    message: 'should be string'
-                                  };
-                                  if (vErrors === null) vErrors = [err];
-                                  else vErrors.push(err);
-                                  errors++;
-                                }
-                                var valid5 = errors === errs_5;
-                                if (!valid5) break;
-                              }
-                            } else {
+                            if (typeof data2.url !== "string") {
                               var err = {
                                 keyword: 'type',
-                                dataPath: (dataPath || '') + '.blacklist[' + i1 + '].keys',
-                                schemaPath: '#/properties/blacklist/items/anyOf/1/properties/keys/type',
+                                dataPath: (dataPath || '') + '.blacklist[' + i1 + '].url',
+                                schemaPath: '#/properties/blacklist/items/anyOf/1/properties/url/type',
                                 params: {
-                                  type: 'array'
+                                  type: 'string'
                                 },
-                                message: 'should be array'
+                                message: 'should be string'
                               };
                               if (vErrors === null) vErrors = [err];
                               else vErrors.push(err);
@@ -386,61 +348,118 @@ var validate = (function() {
                             }
                             var valid4 = errors === errs_4;
                           }
+                          if (valid4) {
+                            var data3 = data2.keys;
+                            if (data3 === undefined) {
+                              valid4 = false;
+                              var err = {
+                                keyword: 'required',
+                                dataPath: (dataPath || '') + '.blacklist[' + i1 + ']',
+                                schemaPath: '#/properties/blacklist/items/anyOf/1/required',
+                                params: {
+                                  missingProperty: 'keys'
+                                },
+                                message: 'should have required property \'keys\''
+                              };
+                              if (vErrors === null) vErrors = [err];
+                              else vErrors.push(err);
+                              errors++;
+                            } else {
+                              var errs_4 = errors;
+                              if (Array.isArray(data3)) {
+                                var errs__4 = errors;
+                                var valid4;
+                                for (var i4 = 0; i4 < data3.length; i4++) {
+                                  var errs_5 = errors;
+                                  if (typeof data3[i4] !== "string") {
+                                    var err = {
+                                      keyword: 'type',
+                                      dataPath: (dataPath || '') + '.blacklist[' + i1 + '].keys[' + i4 + ']',
+                                      schemaPath: '#/properties/blacklist/items/anyOf/1/properties/keys/items/type',
+                                      params: {
+                                        type: 'string'
+                                      },
+                                      message: 'should be string'
+                                    };
+                                    if (vErrors === null) vErrors = [err];
+                                    else vErrors.push(err);
+                                    errors++;
+                                  }
+                                  var valid5 = errors === errs_5;
+                                  if (!valid5) break;
+                                }
+                              } else {
+                                var err = {
+                                  keyword: 'type',
+                                  dataPath: (dataPath || '') + '.blacklist[' + i1 + '].keys',
+                                  schemaPath: '#/properties/blacklist/items/anyOf/1/properties/keys/type',
+                                  params: {
+                                    type: 'array'
+                                  },
+                                  message: 'should be array'
+                                };
+                                if (vErrors === null) vErrors = [err];
+                                else vErrors.push(err);
+                                errors++;
+                              }
+                              var valid4 = errors === errs_4;
+                            }
+                          }
                         }
+                      } else {
+                        var err = {
+                          keyword: 'type',
+                          dataPath: (dataPath || '') + '.blacklist[' + i1 + ']',
+                          schemaPath: '#/properties/blacklist/items/anyOf/1/type',
+                          params: {
+                            type: 'object'
+                          },
+                          message: 'should be object'
+                        };
+                        if (vErrors === null) vErrors = [err];
+                        else vErrors.push(err);
+                        errors++;
                       }
-                    } else {
+                      var valid3 = errors === errs_3;
+                      valid2 = valid2 || valid3;
+                    }
+                    if (!valid2) {
                       var err = {
-                        keyword: 'type',
+                        keyword: 'anyOf',
                         dataPath: (dataPath || '') + '.blacklist[' + i1 + ']',
-                        schemaPath: '#/properties/blacklist/items/anyOf/1/type',
-                        params: {
-                          type: 'object'
-                        },
-                        message: 'should be object'
+                        schemaPath: '#/properties/blacklist/items/anyOf',
+                        params: {},
+                        message: 'should match some schema in anyOf'
                       };
                       if (vErrors === null) vErrors = [err];
                       else vErrors.push(err);
                       errors++;
+                      validate.errors = vErrors;
+                      return false;
+                    } else {
+                      errors = errs__2;
+                      if (vErrors !== null) {
+                        if (errs__2) vErrors.length = errs__2;
+                        else vErrors = null;
+                      }
                     }
-                    var valid3 = errors === errs_3;
-                    valid2 = valid2 || valid3;
-                  }
-                  if (!valid2) {
-                    var err = {
-                      keyword: 'anyOf',
-                      dataPath: (dataPath || '') + '.blacklist[' + i1 + ']',
-                      schemaPath: '#/properties/blacklist/items/anyOf',
-                      params: {},
-                      message: 'should match some schema in anyOf'
-                    };
-                    if (vErrors === null) vErrors = [err];
-                    else vErrors.push(err);
-                    errors++;
-                    validate.errors = vErrors;
-                    return false;
-                  } else {
-                    errors = errs__2;
-                    if (vErrors !== null) {
-                      if (errs__2) vErrors.length = errs__2;
-                      else vErrors = null;
-                    }
+                    var valid2 = errors === errs_2;
+                    if (!valid2) break;
                   }
-                  var valid2 = errors === errs_2;
-                  if (!valid2) break;
+                } else {
+                  validate.errors = [{
+                    keyword: 'type',
+                    dataPath: (dataPath || '') + '.blacklist',
+                    schemaPath: '#/properties/blacklist/type',
+                    params: {
+                      type: 'array'
+                    },
+                    message: 'should be array'
+                  }];
+                  return false;
                 }
-              } else {
-                validate.errors = [{
-                  keyword: 'type',
-                  dataPath: (dataPath || '') + '.blacklist',
-                  schemaPath: '#/properties/blacklist/type',
-                  params: {
-                    type: 'array'
-                  },
-                  message: 'should be array'
-                }];
-                return false;
+                var valid1 = errors === errs_1;
               }
-              var valid1 = errors === errs_1;
             }
           }
         }
@@ -531,7 +550,8 @@ validate.schema = {
         }]
       }
     }
-  }
+  },
+  "additionalProperties": false
 };
 validate.errors = null;
 module.exports = validate;

test/shared/settings/Blacklist.test.ts

@@ -16,16 +16,6 @@ describe('BlacklistItem', () => {
       expect(item.partial).to.be.true;
       expect(item.keys).to.deep.equal(['j', 'k']);
     });
-
-    it('throws a TypeError', () => {
-      expect(() => BlacklistItem.fromJSON(null)).to.throw(TypeError);
-      expect(() => BlacklistItem.fromJSON(100)).to.throw(TypeError);
-      expect(() => BlacklistItem.fromJSON({})).to.throw(TypeError);
-      expect(() => BlacklistItem.fromJSON({url: 'google.com'})).to.throw(TypeError);
-      expect(() => BlacklistItem.fromJSON({keys: ['a']})).to.throw(TypeError);
-      expect(() => BlacklistItem.fromJSON({url: 'google.com', keys: 10})).to.throw(TypeError);
-      expect(() => BlacklistItem.fromJSON({url: 'google.com', keys: ['a', 'b', 3]})).to.throw(TypeError);
-    });
   });
 
   describe('#matches', () => {
@@ -118,14 +108,6 @@ describe('Blacklist', () => {
       let blacklist = Blacklist.fromJSON([]);
       expect(blacklist.toJSON()).to.deep.equals([]);
     });
-
-    it('throws a TypeError', () => {
-      expect(() => Blacklist.fromJSON(null)).to.throw(TypeError);
-      expect(() => Blacklist.fromJSON(100)).to.throw(TypeError);
-      expect(() => Blacklist.fromJSON({})).to.throw(TypeError);
-      expect(() => Blacklist.fromJSON([100])).to.throw(TypeError);
-      expect(() => Blacklist.fromJSON([{}])).to.throw(TypeError);
-    })
   });
 
   describe('#includesEntireBlacklist', () => {

test/shared/settings/Keymaps.test.ts

@@ -19,7 +19,6 @@ describe('Keymaps', () => {
     });
 
     it('throws a TypeError by invalid settings', () => {
-      expect(() => Keymaps.fromJSON(null)).to.throw(TypeError);
       expect(() => Keymaps.fromJSON({
         k: { type: "invalid.operation" },
       })).to.throw(TypeError);

test/shared/settings/Search.test.ts

@@ -26,19 +26,6 @@ describe('Search', () => {
   });
 
   it('throws a TypeError by invalid settings', () => {
-    expect(() => Search.fromJSON(null)).to.throw(TypeError);
-    expect(() => Search.fromJSON({})).to.throw(TypeError);
-    expect(() => Search.fromJSON([])).to.throw(TypeError);
-    expect(() => Search.fromJSON({
-      default: 123,
-      engines: {}
-    })).to.throw(TypeError);
-    expect(() => Search.fromJSON({
-      default: 'google',
-      engines: {
-        'google': 123456,
-      }
-    })).to.throw(TypeError);
     expect(() => Search.fromJSON({
       default: 'wikipedia',
       engines: {