aboutsummaryrefslogtreecommitdiff
path: root/src/shared/settings/Search.ts
blob: 4580236591e5d08c0769d803be496c63d651052b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
type Entries = { [name: string]: string };

export type SearchJSON = {
  default: string;
  engines: { [key: string]: string };
};

export default class Search {
  constructor(
    public defaultEngine: string,
    public engines: Entries,
  ) {
  }

  static fromJSON(json: any): Search {
    let defaultEngine = Search.getStringField(json, 'default');
    let engines = Search.getObjectField(json, 'engines');

    for (let [name, url] of Object.entries(engines)) {
      if ((/\s/).test(name)) {
        throw new TypeError(
          `While space in the search engine not allowed: "${name}"`);
      }
      if (typeof url !== 'string') {
        throw new TypeError(
          `Invalid type of value in filed "engines": ${JSON.stringify(json)}`);
      }
      let matches = url.match(/{}/g);
      if (matches === null) {
        throw new TypeError(`No {}-placeholders in URL of "${name}"`);
      } else if (matches.length > 1) {
        throw new TypeError(`Multiple {}-placeholders in URL of "${name}"`);
      }
    }

    if (!Object.keys(engines).includes(defaultEngine)) {
      throw new TypeError(`Default engine "${defaultEngine}" not found`);
    }

    return new Search(
      json.default as string,
      json.engines,
    );
  }

  toJSON(): SearchJSON {
    return {
      default: this.defaultEngine,
      engines: this.engines,
    };
  }

  private static getStringField(json: any, name: string): string {
    if (!Object.prototype.hasOwnProperty.call(json, name)) {
      throw new TypeError(
        `missing field "${name}" on search: ${JSON.stringify(json)}`);
    }
    if (typeof json[name] !== 'string') {
      throw new TypeError(
        `invalid type of filed "${name}" on search: ${JSON.stringify(json)}`);
    }
    return json[name];
  }

  private static getObjectField(json: any, name: string): Object {
    if (!Object.prototype.hasOwnProperty.call(json, name)) {
      throw new TypeError(
        `missing field "${name}" on search: ${JSON.stringify(json)}`);
    }
    if (typeof json[name] !== 'object' || json[name] === null) {
      throw new TypeError(
        `invalid type of filed "${name}" on search: ${JSON.stringify(json)}`);
    }
    return json[name];
  }
}