Merge pull request #578 from ueokande/move-to-typescript

Move to TypeScript

18 files changed, 425 insertions, 348 deletions

diff --git a/src/background/usecases/AddonEnabledUseCase.js b/src/background/usecases/AddonEnabledUseCase.ts
index bb2c347..0a6fb03 100644
--- a/src/background/usecases/AddonEnabledUseCase.js
+++ b/src/background/usecases/AddonEnabledUseCase.ts
@@ -3,10 +3,20 @@ import TabPresenter from '../presenters/TabPresenter';
 import ContentMessageClient from '../infrastructures/ContentMessageClient';
 
 export default class AddonEnabledUseCase {
+  private indicatorPresentor: IndicatorPresenter;
+
+  private tabPresenter: TabPresenter;
+
+  private contentMessageClient: ContentMessageClient;
+
   constructor() {
     this.indicatorPresentor = new IndicatorPresenter();
 
-    this.indicatorPresentor.onClick(tab => this.onIndicatorClick(tab.id));
+    this.indicatorPresentor.onClick((tab) => {
+      if (tab.id) {
+        this.onIndicatorClick(tab.id);
+      }
+    });
 
     this.tabPresenter = new TabPresenter();
     this.tabPresenter.onSelected(info => this.onTabSelected(info.tabId));
@@ -14,15 +24,15 @@ export default class AddonEnabledUseCase {
     this.contentMessageClient = new ContentMessageClient();
   }
 
-  indicate(enabled) {
+  indicate(enabled: boolean): Promise<void> {
     return this.indicatorPresentor.indicate(enabled);
   }
 
-  onIndicatorClick(tabId) {
+  onIndicatorClick(tabId: number): Promise<void> {
     return this.contentMessageClient.toggleAddonEnabled(tabId);
   }
 
-  async onTabSelected(tabId) {
+  async onTabSelected(tabId: number): Promise<void> {
     let enabled = await this.contentMessageClient.getAddonEnabled(tabId);
     return this.indicatorPresentor.indicate(enabled);
   }
diff --git a/src/background/usecases/CommandUseCase.js b/src/background/usecases/CommandUseCase.ts
index 9ec46fe..2247d7b 100644
--- a/src/background/usecases/CommandUseCase.js
+++ b/src/background/usecases/CommandUseCase.ts
@@ -6,9 +6,20 @@ import SettingRepository from '../repositories/SettingRepository';
 import BookmarkRepository from '../repositories/BookmarkRepository';
 import ConsoleClient from '../infrastructures/ConsoleClient';
 import ContentMessageClient from '../infrastructures/ContentMessageClient';
-import * as properties from 'shared/settings/properties';
 
 export default class CommandIndicator {
+  private tabPresenter: TabPresenter;
+
+  private windowPresenter: WindowPresenter;
+
+  private settingRepository: SettingRepository;
+
+  private bookmarkRepository: BookmarkRepository;
+
+  private consoleClient: ConsoleClient;
+
+  private contentMessageClient: ContentMessageClient;
+
   constructor() {
     this.tabPresenter = new TabPresenter();
     this.windowPresenter = new WindowPresenter();
@@ -19,34 +30,34 @@ export default class CommandIndicator {
     this.contentMessageClient = new ContentMessageClient();
   }
 
-  async open(keywords) {
+  async open(keywords: string): Promise<browser.tabs.Tab> {
     let url = await this.urlOrSearch(keywords);
     return this.tabPresenter.open(url);
   }
 
-  async tabopen(keywords) {
+  async tabopen(keywords: string): Promise<browser.tabs.Tab> {
     let url = await this.urlOrSearch(keywords);
     return this.tabPresenter.create(url);
   }
 
-  async winopen(keywords) {
+  async winopen(keywords: string): Promise<browser.windows.Window> {
     let url = await this.urlOrSearch(keywords);
     return this.windowPresenter.create(url);
   }
 
   // eslint-disable-next-line max-statements
-  async buffer(keywords) {
+  async buffer(keywords: string): Promise<any> {
     if (keywords.length === 0) {
       return;
     }
 
-    if (!isNaN(keywords)) {
+    if (!isNaN(Number(keywords))) {
       let tabs = await this.tabPresenter.getAll();
       let index = parseInt(keywords, 10) - 1;
       if (index < 0 || tabs.length <= index) {
         throw new RangeError(`tab ${index + 1} does not exist`);
       }
-      return this.tabPresenter.select(tabs[index].id);
+      return this.tabPresenter.select(tabs[index].id as number);
     } else if (keywords.trim() === '%') {
       // Select current window
       return;
@@ -66,13 +77,13 @@ export default class CommandIndicator {
     }
     for (let tab of tabs) {
       if (tab.index > current.index) {
-        return this.tabPresenter.select(tab.id);
+        return this.tabPresenter.select(tab.id as number);
       }
     }
-    return this.tabPresenter.select(tabs[0].id);
+    return this.tabPresenter.select(tabs[0].id as number);
   }
 
-  async bdelete(force, keywords) {
+  async bdelete(force: boolean, keywords: string): Promise<any> {
     let excludePinned = !force;
     let tabs = await this.tabPresenter.getByKeyword(keywords, excludePinned);
     if (tabs.length === 0) {
@@ -80,45 +91,45 @@ export default class CommandIndicator {
     } else if (tabs.length > 1) {
       throw new Error('More than one match for ' + keywords);
     }
-    return this.tabPresenter.remove([tabs[0].id]);
+    return this.tabPresenter.remove([tabs[0].id as number]);
   }
 
-  async bdeletes(force, keywords) {
+  async bdeletes(force: boolean, keywords: string): Promise<any> {
     let excludePinned = !force;
     let tabs = await this.tabPresenter.getByKeyword(keywords, excludePinned);
-    let ids = tabs.map(tab => tab.id);
+    let ids = tabs.map(tab => tab.id as number);
     return this.tabPresenter.remove(ids);
   }
 
-  async quit() {
+  async quit(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    return this.tabPresenter.remove([tab.id]);
+    return this.tabPresenter.remove([tab.id as number]);
   }
 
-  async quitAll() {
+  async quitAll(): Promise<any> {
     let tabs = await this.tabPresenter.getAll();
-    let ids = tabs.map(tab => tab.id);
+    let ids = tabs.map(tab => tab.id as number);
     this.tabPresenter.remove(ids);
   }
 
-  async addbookmark(title) {
+  async addbookmark(title: string): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    let item = await this.bookmarkRepository.create(title, tab.url);
+    let item = await this.bookmarkRepository.create(title, tab.url as string);
     let message = 'Saved current page: ' + item.url;
-    return this.consoleClient.showInfo(tab.id, message);
+    return this.consoleClient.showInfo(tab.id as number, message);
   }
 
-  async set(keywords) {
+  async set(keywords: string): Promise<any> {
     if (keywords.length === 0) {
       return;
     }
-    let [name, value] = parsers.parseSetOption(keywords, properties.types);
+    let [name, value] = parsers.parseSetOption(keywords);
     await this.settingRepository.setProperty(name, value);
 
     return this.contentMessageClient.broadcastSettingsChanged();
   }
 
-  async urlOrSearch(keywords) {
+  async urlOrSearch(keywords: string): Promise<any> {
     let settings = await this.settingRepository.get();
     return urls.searchUrl(keywords, settings.search);
   }
diff --git a/src/background/usecases/CompletionsUseCase.js b/src/background/usecases/CompletionsUseCase.ts
index 7dc30ac..ae1ceed 100644
--- a/src/background/usecases/CompletionsUseCase.js
+++ b/src/background/usecases/CompletionsUseCase.ts
@@ -1,23 +1,30 @@
-import CompletionItem from '../domains/CompletionItem';
 import CompletionGroup from '../domains/CompletionGroup';
-import Completions from '../domains/Completions';
 import CommandDocs from '../domains/CommandDocs';
 import CompletionsRepository from '../repositories/CompletionsRepository';
 import * as filters from './filters';
 import SettingRepository from '../repositories/SettingRepository';
 import TabPresenter from '../presenters/TabPresenter';
-import * as properties from '../../shared/settings/properties';
+import * as PropertyDefs from '../../shared/property-defs';
 
 const COMPLETION_ITEM_LIMIT = 10;
 
+type Tab = browser.tabs.Tab;
+type HistoryItem = browser.history.HistoryItem;
+
 export default class CompletionsUseCase {
+  private tabPresenter: TabPresenter;
+
+  private completionsRepository: CompletionsRepository;
+
+  private settingRepository: SettingRepository;
+
   constructor() {
     this.tabPresenter = new TabPresenter();
     this.completionsRepository = new CompletionsRepository();
     this.settingRepository = new SettingRepository();
   }
 
-  queryConsoleCommand(prefix) {
+  queryConsoleCommand(prefix: string): Promise<CompletionGroup[]> {
     let keys = Object.keys(CommandDocs);
     let items = keys
       .filter(name => name.startsWith(prefix))
@@ -28,48 +35,49 @@ export default class CompletionsUseCase {
       }));
 
     if (items.length === 0) {
-      return Promise.resolve(Completions.empty());
+      return Promise.resolve([]);
     }
-    return Promise.resolve(
-      new Completions([new CompletionGroup('Console Command', items)])
-    );
+    return Promise.resolve([{ name: 'Console Command', items }]);
   }
 
-  async queryOpen(name, keywords) {
+  async queryOpen(name: string, keywords: string): Promise<CompletionGroup[]> {
     let settings = await this.settingRepository.get();
-    let groups = [];
+    let groups: CompletionGroup[] = [];
 
-    let complete = settings.properties.complete || properties.defaults.complete;
+    let complete = settings.properties.complete;
     for (let c of complete) {
       if (c === 's') {
         // eslint-disable-next-line no-await-in-loop
         let engines = await this.querySearchEngineItems(name, keywords);
         if (engines.length > 0) {
-          groups.push(new CompletionGroup('Search Engines', engines));
+          groups.push({ name: 'Search Engines', items: engines });
         }
       } else if (c === 'h') {
         // eslint-disable-next-line no-await-in-loop
         let histories = await this.queryHistoryItems(name, keywords);
         if (histories.length > 0) {
-          groups.push(new CompletionGroup('History', histories));
+          groups.push({ name: 'History', items: histories });
         }
       } else if (c === 'b') {
         // eslint-disable-next-line no-await-in-loop
         let bookmarks = await this.queryBookmarkItems(name, keywords);
         if (bookmarks.length > 0) {
-          groups.push(new CompletionGroup('Bookmarks', bookmarks));
+          groups.push({ name: 'Bookmarks', items: bookmarks });
         }
       }
     }
-    return new Completions(groups);
+    return groups;
   }
 
   // eslint-disable-next-line max-statements
-  async queryBuffer(name, keywords) {
+  async queryBuffer(
+    name: string,
+    keywords: string,
+  ): Promise<CompletionGroup[]> {
     let lastId = await this.tabPresenter.getLastSelectedId();
     let trimmed = keywords.trim();
-    let tabs = [];
-    if (trimmed.length > 0 && !isNaN(trimmed)) {
+    let tabs: Tab[] = [];
+    if (trimmed.length > 0 && !isNaN(Number(trimmed))) {
       let all = await this.tabPresenter.getAll();
       let index = parseInt(trimmed, 10) - 1;
       if (index >= 0 && index < all.length) {
@@ -77,18 +85,18 @@ export default class CompletionsUseCase {
       }
     } else if (trimmed === '%') {
       let all = await this.tabPresenter.getAll();
-      let tab = all.find(t => t.active);
+      let tab = all.find(t => t.active) as Tab;
       tabs = [tab];
     } else if (trimmed === '#') {
       if (typeof lastId !== 'undefined' && lastId !== null) {
         let all = await this.tabPresenter.getAll();
-        let tab = all.find(t => t.id === lastId);
+        let tab = all.find(t => t.id === lastId) as Tab;
         tabs = [tab];
       }
     } else {
       tabs = await this.completionsRepository.queryTabs(keywords, false);
     }
-    const flag = (tab) => {
+    const flag = (tab: Tab) => {
       if (tab.active) {
         return '%';
       } else if (tab.id === lastId) {
@@ -96,87 +104,90 @@ export default class CompletionsUseCase {
       }
       return ' ';
     };
-    let items = tabs.map(tab => new CompletionItem({
+    let items = tabs.map(tab => ({
       caption: tab.index + 1 + ': ' + flag(tab) + ' ' + tab.title,
       content: name + ' ' + tab.title,
       url: tab.url,
-      icon: tab.favIconUrl
+      icon: tab.favIconUrl,
     }));
     if (items.length === 0) {
-      return Promise.resolve(Completions.empty());
+      return Promise.resolve([]);
     }
-    return new Completions([new CompletionGroup('Buffers', items)]);
+    return [{ name: 'Buffers', items }];
   }
 
-  queryBdelete(name, keywords) {
+  queryBdelete(name: string, keywords: string): Promise<CompletionGroup[]> {
     return this.queryTabs(name, true, keywords);
   }
 
-  queryBdeleteForce(name, keywords) {
+  queryBdeleteForce(
+    name: string, keywords: string,
+  ): Promise<CompletionGroup[]> {
     return this.queryTabs(name, false, keywords);
   }
 
-  querySet(name, keywords) {
-    let items = Object.keys(properties.docs).map((key) => {
-      if (properties.types[key] === 'boolean') {
+  querySet(name: string, keywords: string): Promise<CompletionGroup[]> {
+    let items = PropertyDefs.defs.map((def) => {
+      if (def.type === 'boolean') {
         return [
-          new CompletionItem({
-            caption: key,
-            content: name + ' ' + key,
-            url: 'Enable ' + properties.docs[key],
-          }),
-          new CompletionItem({
-            caption: 'no' + key,
-            content: name + ' no' + key,
-            url: 'Disable ' + properties.docs[key],
-          }),
+          {
+            caption: def.name,
+            content: name + ' ' + def.name,
+            url: 'Enable ' + def.description,
+          }, {
+            caption: 'no' + def.name,
+            content: name + ' no' + def.name,
+            url: 'Disable ' + def.description
+          }
         ];
       }
       return [
-        new CompletionItem({
-          caption: key,
-          content: name + ' ' + key,
-          url: 'Set ' + properties.docs[key],
-        })
+        {
+          caption: def.name,
+          content: name + ' ' + def.name,
+          url: 'Set ' + def.description,
+        }
       ];
     });
-    items = items.reduce((acc, val) => acc.concat(val), []);
-    items = items.filter((item) => {
+    let flatten = items.reduce((acc, val) => acc.concat(val), []);
+    flatten = flatten.filter((item) => {
       return item.caption.startsWith(keywords);
     });
-    if (items.length === 0) {
-      return Promise.resolve(Completions.empty());
+    if (flatten.length === 0) {
+      return Promise.resolve([]);
     }
     return Promise.resolve(
-      new Completions([new CompletionGroup('Properties', items)])
+      [{ name: 'Properties', items: flatten }],
     );
   }
 
-  async queryTabs(name, excludePinned, args) {
+  async queryTabs(
+    name: string, excludePinned: boolean, args: string,
+  ): Promise<CompletionGroup[]> {
     let tabs = await this.completionsRepository.queryTabs(args, excludePinned);
-    let items = tabs.map(tab => new CompletionItem({
+    let items = tabs.map(tab => ({
       caption: tab.title,
       content: name + ' ' + tab.title,
       url: tab.url,
       icon: tab.favIconUrl
     }));
     if (items.length === 0) {
-      return Promise.resolve(Completions.empty());
+      return Promise.resolve([]);
     }
-    return new Completions([new CompletionGroup('Buffers', items)]);
+    return [{ name: 'Buffers', items }];
   }
 
-  async querySearchEngineItems(name, keywords) {
+  async querySearchEngineItems(name: string, keywords: string) {
     let settings = await this.settingRepository.get();
     let engines = Object.keys(settings.search.engines)
       .filter(key => key.startsWith(keywords));
-    return engines.map(key => new CompletionItem({
+    return engines.map(key => ({
       caption: key,
       content: name + ' ' + key,
     }));
   }
 
-  async queryHistoryItems(name, keywords) {
+  async queryHistoryItems(name: string, keywords: string) {
     let histories = await this.completionsRepository.queryHistories(keywords);
     histories = [histories]
       .map(filters.filterBlankTitle)
@@ -184,19 +195,21 @@ export default class CompletionsUseCase {
       .map(filters.filterByTailingSlash)
       .map(pages => filters.filterByPathname(pages, COMPLETION_ITEM_LIMIT))
       .map(pages => filters.filterByOrigin(pages, COMPLETION_ITEM_LIMIT))[0]
-      .sort((x, y) => x.visitCount < y.visitCount)
+      .sort((x: HistoryItem, y: HistoryItem): number => {
+        return Number(x.visitCount) - Number(y.visitCount);
+      })
       .slice(0, COMPLETION_ITEM_LIMIT);
-    return histories.map(page => new CompletionItem({
+    return histories.map(page => ({
       caption: page.title,
       content: name + ' ' + page.url,
       url: page.url
     }));
   }
 
-  async queryBookmarkItems(name, keywords) {
+  async queryBookmarkItems(name: string, keywords: string) {
     let bookmarks = await this.completionsRepository.queryBookmarks(keywords);
     return bookmarks.slice(0, COMPLETION_ITEM_LIMIT)
-      .map(page => new CompletionItem({
+      .map(page => ({
         caption: page.title,
         content: name + ' ' + page.url,
         url: page.url
diff --git a/src/background/usecases/ConsoleUseCase.js b/src/background/usecases/ConsoleUseCase.js
deleted file mode 100644
index e8e5d4a..0000000
--- a/src/background/usecases/ConsoleUseCase.js
+++ /dev/null
@@ -1,61 +0,0 @@
-import TabPresenter from '../presenters/TabPresenter';
-import ConsoleClient from '../infrastructures/ConsoleClient';
-
-export default class ConsoleUseCase {
-  constructor() {
-    this.tabPresenter = new TabPresenter();
-    this.consoleClient = new ConsoleClient();
-  }
-
-  async showCommand() {
-    let tab = await this.tabPresenter.getCurrent();
-    return this.consoleClient.showCommand(tab.id, '');
-  }
-
-  async showOpenCommand(alter) {
-    let tab = await this.tabPresenter.getCurrent();
-    let command = 'open ';
-    if (alter) {
-      command += tab.url;
-    }
-    return this.consoleClient.showCommand(tab.id, command);
-  }
-
-  async showTabopenCommand(alter) {
-    let tab = await this.tabPresenter.getCurrent();
-    let command = 'tabopen ';
-    if (alter) {
-      command += tab.url;
-    }
-    return this.consoleClient.showCommand(tab.id, command);
-  }
-
-  async showWinopenCommand(alter) {
-    let tab = await this.tabPresenter.getCurrent();
-    let command = 'winopen ';
-    if (alter) {
-      command += tab.url;
-    }
-    return this.consoleClient.showCommand(tab.id, command);
-  }
-
-  async showBufferCommand() {
-    let tab = await this.tabPresenter.getCurrent();
-    let command = 'buffer ';
-    return this.consoleClient.showCommand(tab.id, command);
-  }
-
-  async showAddbookmarkCommand(alter) {
-    let tab = await this.tabPresenter.getCurrent();
-    let command = 'addbookmark ';
-    if (alter) {
-      command += tab.title;
-    }
-    return this.consoleClient.showCommand(tab.id, command);
-  }
-
-  async hideConsole() {
-    let tab = await this.tabPresenter.getCurrent();
-    return this.consoleClient.hide(tab.id);
-  }
-}
diff --git a/src/background/usecases/ConsoleUseCase.ts b/src/background/usecases/ConsoleUseCase.ts
new file mode 100644
index 0000000..60c0439
--- /dev/null
+++ b/src/background/usecases/ConsoleUseCase.ts
@@ -0,0 +1,65 @@
+import TabPresenter from '../presenters/TabPresenter';
+import ConsoleClient from '../infrastructures/ConsoleClient';
+
+export default class ConsoleUseCase {
+  private tabPresenter: TabPresenter;
+
+  private consoleClient: ConsoleClient;
+
+  constructor() {
+    this.tabPresenter = new TabPresenter();
+    this.consoleClient = new ConsoleClient();
+  }
+
+  async showCommand(): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    return this.consoleClient.showCommand(tab.id as number, '');
+  }
+
+  async showOpenCommand(alter: boolean): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    let command = 'open ';
+    if (alter) {
+      command += tab.url || '';
+    }
+    return this.consoleClient.showCommand(tab.id as number, command);
+  }
+
+  async showTabopenCommand(alter: boolean): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    let command = 'tabopen ';
+    if (alter) {
+      command += tab.url || '';
+    }
+    return this.consoleClient.showCommand(tab.id as number, command);
+  }
+
+  async showWinopenCommand(alter: boolean): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    let command = 'winopen ';
+    if (alter) {
+      command += tab.url || '';
+    }
+    return this.consoleClient.showCommand(tab.id as number, command);
+  }
+
+  async showBufferCommand(): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    let command = 'buffer ';
+    return this.consoleClient.showCommand(tab.id as number, command);
+  }
+
+  async showAddbookmarkCommand(alter: boolean): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    let command = 'addbookmark ';
+    if (alter) {
+      command += tab.title || '';
+    }
+    return this.consoleClient.showCommand(tab.id as number, command);
+  }
+
+  async hideConsole(): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    return this.consoleClient.hide(tab.id as number);
+  }
+}
diff --git a/src/background/usecases/FindUseCase.js b/src/background/usecases/FindUseCase.ts
index 224e4a9..d567800 100644
--- a/src/background/usecases/FindUseCase.js
+++ b/src/background/usecases/FindUseCase.ts
@@ -3,22 +3,28 @@ import TabPresenter from '../presenters/TabPresenter';
 import ConsoleClient from '../infrastructures/ConsoleClient';
 
 export default class FindUseCase {
+  private tabPresenter: TabPresenter;
+
+  private findRepository: FindRepository;
+
+  private consoleClient: ConsoleClient;
+
   constructor() {
     this.tabPresenter = new TabPresenter();
     this.findRepository = new FindRepository();
     this.consoleClient = new ConsoleClient();
   }
 
-  getKeyword() {
+  getKeyword(): Promise<string> {
     return this.findRepository.getKeyword();
   }
 
-  setKeyword(keyword) {
+  setKeyword(keyword: string): Promise<any> {
     return this.findRepository.setKeyword(keyword);
   }
 
-  async findStart() {
+  async findStart(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    return this.consoleClient.showFind(tab.id);
+    return this.consoleClient.showFind(tab.id as number);
   }
 }
diff --git a/src/background/usecases/LinkUseCase.js b/src/background/usecases/LinkUseCase.ts
index 89412c5..2f4df7b 100644
--- a/src/background/usecases/LinkUseCase.js
+++ b/src/background/usecases/LinkUseCase.ts
@@ -1,17 +1,17 @@
-import SettingRepository from '../repositories/SettingRepository';
 import TabPresenter from '../presenters/TabPresenter';
 
 export default class LinkUseCase {
+  private tabPresenter: TabPresenter;
+
   constructor() {
-    this.settingRepository = new SettingRepository();
     this.tabPresenter = new TabPresenter();
   }
 
-  openToTab(url, tabId) {
+  openToTab(url: string, tabId: number): Promise<any> {
     return this.tabPresenter.open(url, tabId);
   }
 
-  openNewTab(url, openerId, background) {
+  openNewTab(url: string, openerId: number, background: boolean): Promise<any> {
     return this.tabPresenter.create(url, {
       openerTabId: openerId, active: !background
     });
diff --git a/src/background/usecases/MarkUseCase.js b/src/background/usecases/MarkUseCase.ts
index 39c796b..e376c55 100644
--- a/src/background/usecases/MarkUseCase.js
+++ b/src/background/usecases/MarkUseCase.ts
@@ -1,10 +1,17 @@
-import GlobalMark from '../domains/GlobalMark';
 import TabPresenter from '../presenters/TabPresenter';
 import MarkRepository from '../repositories/MarkRepository';
 import ConsoleClient from '../infrastructures/ConsoleClient';
 import ContentMessageClient from '../infrastructures/ContentMessageClient';
 
 export default class MarkUseCase {
+  private tabPresenter: TabPresenter;
+
+  private markRepository: MarkRepository;
+
+  private consoleClient: ConsoleClient;
+
+  private contentMessageClient: ContentMessageClient;
+
   constructor() {
     this.tabPresenter = new TabPresenter();
     this.markRepository = new MarkRepository();
@@ -12,28 +19,28 @@ export default class MarkUseCase {
     this.contentMessageClient = new ContentMessageClient();
   }
 
-  async setGlobal(key, x, y) {
+  async setGlobal(key: string, x: number, y: number): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    let mark = new GlobalMark(tab.id, tab.url, x, y);
+    let mark = { tabId: tab.id as number, url: tab.url as string, x, y };
     return this.markRepository.setMark(key, mark);
   }
 
-  async jumpGlobal(key) {
+  async jumpGlobal(key: string): Promise<any> {
     let current = await this.tabPresenter.getCurrent();
 
     let mark = await this.markRepository.getMark(key);
     if (!mark) {
-      return this.consoleClient.showError(current.id, 'Mark is not set');
+      return this.consoleClient.showError(
+        current.id as number, 'Mark is not set');
     }
-
-    return this.contentMessageClient.scrollTo(
-      mark.tabId, mark.x, mark.y
-    ).then(() => {
+    try {
+      await this.contentMessageClient.scrollTo(mark.tabId, mark.x, mark.y);
       return this.tabPresenter.select(mark.tabId);
-    }).catch(async() => {
+    } catch (e) {
       let tab = await this.tabPresenter.create(mark.url);
-      let mark2 = new GlobalMark(tab.id, mark.url, mark.x, mark.y);
-      return this.markRepository.setMark(key, mark2);
-    });
+      return this.markRepository.setMark(key, {
+        tabId: tab.id as number, url: mark.url, x: mark.x, y: mark.y,
+      });
+    }
   }
 }
diff --git a/src/background/usecases/SettingUseCase.js b/src/background/usecases/SettingUseCase.ts
index 9e17408..aa3b534 100644
--- a/src/background/usecases/SettingUseCase.js
+++ b/src/background/usecases/SettingUseCase.ts
@@ -1,28 +1,31 @@
-import Setting from '../domains/Setting';
 // eslint-disable-next-line max-len
 import PersistentSettingRepository from '../repositories/PersistentSettingRepository';
 import SettingRepository from '../repositories/SettingRepository';
+import { DefaultSettingData } from '../../shared/SettingData';
+import Settings from '../../shared/Settings';
 
 export default class SettingUseCase {
+  private persistentSettingRepository: PersistentSettingRepository;
+
+  private settingRepository: SettingRepository;
+
   constructor() {
     this.persistentSettingRepository = new PersistentSettingRepository();
     this.settingRepository = new SettingRepository();
   }
 
-  get() {
+  get(): Promise<Settings> {
     return this.settingRepository.get();
   }
 
-  async reload() {
-    let settings = await this.persistentSettingRepository.load();
-    if (!settings) {
-      settings = Setting.defaultSettings();
+  async reload(): Promise<Settings> {
+    let data = await this.persistentSettingRepository.load();
+    if (!data) {
+      data = DefaultSettingData;
     }
 
-    let value = settings.value();
-
+    let value = data.toSettings();
     this.settingRepository.update(value);
-
     return value;
   }
 }
diff --git a/src/background/usecases/TabSelectUseCase.js b/src/background/usecases/TabSelectUseCase.ts
index 16b3e14..a0b52f0 100644
--- a/src/background/usecases/TabSelectUseCase.js
+++ b/src/background/usecases/TabSelectUseCase.ts
@@ -1,11 +1,13 @@
 import TabPresenter from '../presenters/TabPresenter';
 
 export default class TabSelectUseCase {
+  private tabPresenter: TabPresenter;
+
   constructor() {
     this.tabPresenter = new TabPresenter();
   }
 
-  async selectPrev(count) {
+  async selectPrev(count: number): Promise<any> {
     let tabs = await this.tabPresenter.getAll();
     if (tabs.length < 2) {
       return;
@@ -15,10 +17,10 @@ export default class TabSelectUseCase {
       return;
     }
     let select = (tab.index - count + tabs.length) % tabs.length;
-    return this.tabPresenter.select(tabs[select].id);
+    return this.tabPresenter.select(tabs[select].id as number);
   }
 
-  async selectNext(count) {
+  async selectNext(count: number): Promise<any> {
     let tabs = await this.tabPresenter.getAll();
     if (tabs.length < 2) {
       return;
@@ -28,24 +30,24 @@ export default class TabSelectUseCase {
       return;
     }
     let select = (tab.index + count) % tabs.length;
-    return this.tabPresenter.select(tabs[select].id);
+    return this.tabPresenter.select(tabs[select].id as number);
   }
 
-  async selectFirst() {
+  async selectFirst(): Promise<any> {
     let tabs = await this.tabPresenter.getAll();
-    return this.tabPresenter.select(tabs[0].id);
+    return this.tabPresenter.select(tabs[0].id as number);
   }
 
-  async selectLast() {
+  async selectLast(): Promise<any> {
     let tabs = await this.tabPresenter.getAll();
-    return this.tabPresenter.select(tabs[tabs.length - 1].id);
+    return this.tabPresenter.select(tabs[tabs.length - 1].id as number);
   }
 
-  async selectPrevSelected() {
+  async selectPrevSelected(): Promise<any> {
     let tabId = await this.tabPresenter.getLastSelectedId();
     if (tabId === null || typeof tabId === 'undefined') {
-      return;
+      return Promise.resolve();
     }
-    this.tabPresenter.select(tabId);
+    return this.tabPresenter.select(tabId);
   }
 }
diff --git a/src/background/usecases/TabUseCase.js b/src/background/usecases/TabUseCase.ts
index d930842..1615333 100644
--- a/src/background/usecases/TabUseCase.js
+++ b/src/background/usecases/TabUseCase.ts
@@ -2,20 +2,24 @@ import TabPresenter from '../presenters/TabPresenter';
 import BrowserSettingRepository from '../repositories/BrowserSettingRepository';
 
 export default class TabUseCase {
+  private tabPresenter: TabPresenter;
+
+  private browserSettingRepository: BrowserSettingRepository;
+
   constructor() {
     this.tabPresenter = new TabPresenter();
     this.browserSettingRepository = new BrowserSettingRepository();
   }
 
-  async close(force) {
+  async close(force: boolean): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
     if (!force && tab.pinned) {
-      return;
+      return Promise.resolve();
     }
-    return this.tabPresenter.remove([tab.id]);
+    return this.tabPresenter.remove([tab.id as number]);
   }
 
-  async closeRight() {
+  async closeRight(): Promise<any> {
     let tabs = await this.tabPresenter.getAll();
     tabs.sort((t1, t2) => t1.index - t2.index);
     let index = tabs.findIndex(t => t.active);
@@ -25,42 +29,42 @@ export default class TabUseCase {
     for (let i = index + 1; i < tabs.length; ++i) {
       let tab = tabs[i];
       if (!tab.pinned) {
-        this.tabPresenter.remove(tab.id);
+        this.tabPresenter.remove([tab.id as number]);
       }
     }
   }
 
-  reopen() {
+  reopen(): Promise<any> {
     return this.tabPresenter.reopen();
   }
 
-  async reload(cache) {
+  async reload(cache: boolean): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    return this.tabPresenter.reload(tab.id, cache);
+    return this.tabPresenter.reload(tab.id as number, cache);
   }
 
-  async setPinned(pinned) {
+  async setPinned(pinned: boolean): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    return this.tabPresenter.setPinned(tab.id, pinned);
+    return this.tabPresenter.setPinned(tab.id as number, pinned);
   }
 
-  async togglePinned() {
+  async togglePinned(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    return this.tabPresenter.setPinned(tab.id, !tab.pinned);
+    return this.tabPresenter.setPinned(tab.id as number, !tab.pinned);
   }
 
-  async duplicate() {
+  async duplicate(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    return this.tabPresenter.duplicate(tab.id);
+    return this.tabPresenter.duplicate(tab.id as number);
   }
 
-  async openPageSource() {
+  async openPageSource(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
     let url = 'view-source:' + tab.url;
     return this.tabPresenter.create(url);
   }
 
-  async openHome(newTab) {
+  async openHome(newTab: boolean): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
     let urls = await this.browserSettingRepository.getHomepageUrls();
     if (urls.length === 1 && urls[0] === 'about:home') {
diff --git a/src/background/usecases/VersionUseCase.js b/src/background/usecases/VersionUseCase.ts
index ed5112b..8154eba 100644
--- a/src/background/usecases/VersionUseCase.js
+++ b/src/background/usecases/VersionUseCase.ts
@@ -1,23 +1,27 @@
-import manifest from '../../../manifest.json';
 import TabPresenter from '../presenters/TabPresenter';
 import NotifyPresenter from '../presenters/NotifyPresenter';
 
 export default class VersionUseCase {
+  private tabPresenter: TabPresenter;
+
+  private notifyPresenter: NotifyPresenter;
+
   constructor() {
     this.tabPresenter = new TabPresenter();
     this.notifyPresenter = new NotifyPresenter();
   }
 
-  notify() {
+  notify(): Promise<void> {
+    let manifest = browser.runtime.getManifest();
     let title = `Vim Vixen ${manifest.version} has been installed`;
     let message = 'Click here to see release notes';
     let url = this.releaseNoteUrl(manifest.version);
-    this.notifyPresenter.notify(title, message, () => {
+    return this.notifyPresenter.notify(title, message, () => {
       this.tabPresenter.create(url);
     });
   }
 
-  releaseNoteUrl(version) {
+  releaseNoteUrl(version?: string): string {
     if (version) {
       return `https://github.com/ueokande/vim-vixen/releases/tag/${version}`;
     }
diff --git a/src/background/usecases/ZoomUseCase.js b/src/background/usecases/ZoomUseCase.js
deleted file mode 100644
index 692d6d9..0000000
--- a/src/background/usecases/ZoomUseCase.js
+++ /dev/null
@@ -1,35 +0,0 @@
-import TabPresenter from '../presenters/TabPresenter';
-
-const ZOOM_SETTINGS = [
-  0.33, 0.50, 0.66, 0.75, 0.80, 0.90, 1.00,
-  1.10, 1.25, 1.50, 1.75, 2.00, 2.50, 3.00
-];
-
-export default class ZoomUseCase {
-  constructor() {
-    this.tabPresenter = new TabPresenter();
-  }
-
-  async zoomIn(tabId) {
-    let tab = await this.tabPresenter.getCurrent();
-    let current = await this.tabPresenter.getZoom(tab.id);
-    let factor = ZOOM_SETTINGS.find(f => f > current);
-    if (factor) {
-      return this.tabPresenter.setZoom(tabId, factor);
-    }
-  }
-
-  async zoomOut(tabId) {
-    let tab = await this.tabPresenter.getCurrent();
-    let current = await this.tabPresenter.getZoom(tab.id);
-    let factor = [].concat(ZOOM_SETTINGS).reverse().find(f => f < current);
-    if (factor) {
-      return this.tabPresenter.setZoom(tabId, factor);
-    }
-  }
-
-  zoomNutoral(tabId) {
-    return this.tabPresenter.setZoom(tabId, 1);
-  }
-
-}
diff --git a/src/background/usecases/ZoomUseCase.ts b/src/background/usecases/ZoomUseCase.ts
new file mode 100644
index 0000000..661c3cd
--- /dev/null
+++ b/src/background/usecases/ZoomUseCase.ts
@@ -0,0 +1,39 @@
+import TabPresenter from '../presenters/TabPresenter';
+
+const ZOOM_SETTINGS: number[] = [
+  0.33, 0.50, 0.66, 0.75, 0.80, 0.90, 1.00,
+  1.10, 1.25, 1.50, 1.75, 2.00, 2.50, 3.00
+];
+
+export default class ZoomUseCase {
+  private tabPresenter: TabPresenter;
+
+  constructor() {
+    this.tabPresenter = new TabPresenter();
+  }
+
+  async zoomIn(): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    let tabId = tab.id as number;
+    let current = await this.tabPresenter.getZoom(tabId);
+    let factor = ZOOM_SETTINGS.find(f => f > current);
+    if (factor) {
+      return this.tabPresenter.setZoom(tabId as number, factor);
+    }
+  }
+
+  async zoomOut(): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    let tabId = tab.id as number;
+    let current = await this.tabPresenter.getZoom(tabId);
+    let factor = ZOOM_SETTINGS.slice(0).reverse().find(f => f < current);
+    if (factor) {
+      return this.tabPresenter.setZoom(tabId as number, factor);
+    }
+  }
+
+  async zoomNutoral(): Promise<any> {
+    let tab = await this.tabPresenter.getCurrent();
+    return this.tabPresenter.setZoom(tab.id as number, 1);
+  }
+}
diff --git a/src/background/usecases/filters.js b/src/background/usecases/filters.js
deleted file mode 100644
index d057dca..0000000
--- a/src/background/usecases/filters.js
+++ /dev/null
@@ -1,72 +0,0 @@
-const filterHttp = (items) => {
-  let httpsHosts = items.map(x => new URL(x.url))
-    .filter(x => x.protocol === 'https:')
-    .map(x => x.host);
-  httpsHosts = new Set(httpsHosts);
-
-  return items.filter((item) => {
-    let url = new URL(item.url);
-    return url.protocol === 'https:' || !httpsHosts.has(url.host);
-  });
-};
-
-const filterBlankTitle = (items) => {
-  return items.filter(item => item.title && item.title !== '');
-};
-
-const filterByTailingSlash = (items) => {
-  let urls = items.map(item => new URL(item.url));
-  let simplePaths = urls
-    .filter(url => url.hash === '' && url.search === '')
-    .map(url => url.origin + url.pathname);
-  simplePaths = new Set(simplePaths);
-
-  return items.filter((item) => {
-    let url = new URL(item.url);
-    if (url.hash !== '' || url.search !== '' ||
-      url.pathname.slice(-1) !== '/') {
-      return true;
-    }
-    return !simplePaths.has(url.origin + url.pathname.slice(0, -1));
-  });
-};
-
-const filterByPathname = (items, min) => {
-  let hash = {};
-  for (let item of items) {
-    let url = new URL(item.url);
-    let pathname = url.origin + url.pathname;
-    if (!hash[pathname]) {
-      hash[pathname] = item;
-    } else if (hash[pathname].url.length > item.url.length) {
-      hash[pathname] = item;
-    }
-  }
-  let filtered = Object.values(hash);
-  if (filtered.length < min) {
-    return items;
-  }
-  return filtered;
-};
-
-const filterByOrigin = (items, min) => {
-  let hash = {};
-  for (let item of items) {
-    let origin = new URL(item.url).origin;
-    if (!hash[origin]) {
-      hash[origin] = item;
-    } else if (hash[origin].url.length > item.url.length) {
-      hash[origin] = item;
-    }
-  }
-  let filtered = Object.values(hash);
-  if (filtered.length < min) {
-    return items;
-  }
-  return filtered;
-};
-
-export {
-  filterHttp, filterBlankTitle, filterByTailingSlash,
-  filterByPathname, filterByOrigin
-};
diff --git a/src/background/usecases/filters.ts b/src/background/usecases/filters.ts
new file mode 100644
index 0000000..84a42fb
--- /dev/null
+++ b/src/background/usecases/filters.ts
@@ -0,0 +1,76 @@
+type Item = browser.history.HistoryItem;
+
+const filterHttp = (items: Item[]): Item[] => {
+  let httpsHosts = items.map(x => new URL(x.url as string))
+    .filter(x => x.protocol === 'https:')
+    .map(x => x.host);
+  let hostsSet = new Set(httpsHosts);
+
+  return items.filter((item: Item) => {
+    let url = new URL(item.url as string);
+    return url.protocol === 'https:' || !hostsSet.has(url.host);
+  });
+};
+
+const filterBlankTitle = (items: Item[]): Item[] => {
+  return items.filter(item => item.title && item.title !== '');
+};
+
+const filterByTailingSlash = (items: Item[]): Item[] => {
+  let urls = items.map(item => new URL(item.url as string));
+  let simplePaths = urls
+    .filter(url => url.hash === '' && url.search === '')
+    .map(url => url.origin + url.pathname);
+  let pathsSet = new Set(simplePaths);
+
+  return items.filter((item) => {
+    let url = new URL(item.url as string);
+    if (url.hash !== '' || url.search !== '' ||
+      url.pathname.slice(-1) !== '/') {
+      return true;
+    }
+    return !pathsSet.has(url.origin + url.pathname.slice(0, -1));
+  });
+};
+
+const filterByPathname = (items: Item[], min: number): Item[] => {
+  let hash: {[key: string]: Item} = {};
+  for (let item of items) {
+    let url = new URL(item.url as string);
+    let pathname = url.origin + url.pathname;
+    if (!hash[pathname]) {
+      hash[pathname] = item;
+    } else if ((hash[pathname].url as string).length >
+      (item.url as string).length) {
+      hash[pathname] = item;
+    }
+  }
+  let filtered = Object.values(hash);
+  if (filtered.length < min) {
+    return items;
+  }
+  return filtered;
+};
+
+const filterByOrigin = (items: Item[], min: number): Item[] => {
+  let hash: {[key: string]: Item} = {};
+  for (let item of items) {
+    let origin = new URL(item.url as string).origin;
+    if (!hash[origin]) {
+      hash[origin] = item;
+    } else if ((hash[origin].url as string).length >
+      (item.url as string).length) {
+      hash[origin] = item;
+    }
+  }
+  let filtered = Object.values(hash);
+  if (filtered.length < min) {
+    return items;
+  }
+  return filtered;
+};
+
+export {
+  filterHttp, filterBlankTitle, filterByTailingSlash,
+  filterByPathname, filterByOrigin
+};
diff --git a/src/background/usecases/parsers.js b/src/background/usecases/parsers.js
deleted file mode 100644
index 43c8177..0000000
--- a/src/background/usecases/parsers.js
+++ /dev/null
@@ -1,31 +0,0 @@
-const mustNumber = (v) => {
-  let num = Number(v);
-  if (isNaN(num)) {
-    throw new Error('Not number: ' + v);
-  }
-  return num;
-};
-
-const parseSetOption = (word, types) => {
-  let [key, value] = word.split('=');
-  if (value === undefined) {
-    value = !key.startsWith('no');
-    key = value ? key : key.slice(2);
-  }
-  let type = types[key];
-  if (!type) {
-    throw new Error('Unknown property: ' + key);
-  }
-  if (type === 'boolean' && typeof value !== 'boolean' ||
-       type !== 'boolean' && typeof value === 'boolean') {
-    throw new Error('Invalid argument: ' + word);
-  }
-
-  switch (type) {
-  case 'string': return [key, value];
-  case 'number': return [key, mustNumber(value)];
-  case 'boolean': return [key, value];
-  }
-};
-
-export { parseSetOption };
diff --git a/src/background/usecases/parsers.ts b/src/background/usecases/parsers.ts
new file mode 100644
index 0000000..6135fd8
--- /dev/null
+++ b/src/background/usecases/parsers.ts
@@ -0,0 +1,36 @@
+import * as PropertyDefs from '../../shared//property-defs';
+
+const mustNumber = (v: any): number => {
+  let num = Number(v);
+  if (isNaN(num)) {
+    throw new Error('Not number: ' + v);
+  }
+  return num;
+};
+
+const parseSetOption = (
+  args: string,
+): any[] => {
+  let [key, value]: any[] = args.split('=');
+  if (value === undefined) {
+    value = !key.startsWith('no');
+    key = value ? key : key.slice(2);
+  }
+  let def = PropertyDefs.defs.find(d => d.name === key);
+  if (!def) {
+    throw new Error('Unknown property: ' + key);
+  }
+  if (def.type === 'boolean' && typeof value !== 'boolean' ||
+       def.type !== 'boolean' && typeof value === 'boolean') {
+    throw new Error('Invalid argument: ' + args);
+  }
+
+  switch (def.type) {
+  case 'string': return [key, value];
+  case 'number': return [key, mustNumber(value)];
+  case 'boolean': return [key, value];
+  }
+  throw new Error('Unknown property type: ' + def.type);
+};
+
+export { parseSetOption };