Types on src/background

14 files changed, 243 insertions, 168 deletions

diff --git a/src/background/usecases/AddonEnabledUseCase.ts b/src/background/usecases/AddonEnabledUseCase.ts
index bb2c347..0a6fb03 100644
--- a/src/background/usecases/AddonEnabledUseCase.ts
+++ 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.ts b/src/background/usecases/CommandUseCase.ts
index 9ec46fe..e0e3ada 100644
--- a/src/background/usecases/CommandUseCase.ts
+++ b/src/background/usecases/CommandUseCase.ts
@@ -6,9 +6,21 @@ 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';
+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 +31,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 +78,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,35 +92,35 @@ 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 message = 'Saved current page: ' + item.url;
     return this.consoleClient.showInfo(tab.id, message);
   }
 
-  async set(keywords) {
+  async set(keywords: string): Promise<any> {
     if (keywords.length === 0) {
       return;
     }
@@ -118,7 +130,7 @@ export default class CommandIndicator {
     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.ts b/src/background/usecases/CompletionsUseCase.ts
index 7dc30ac..037d6eb 100644
--- a/src/background/usecases/CompletionsUseCase.ts
+++ b/src/background/usecases/CompletionsUseCase.ts
@@ -1,6 +1,5 @@
-import CompletionItem from '../domains/CompletionItem';
-import CompletionGroup from '../domains/CompletionGroup';
 import Completions from '../domains/Completions';
+import CompletionGroup from '../domains/CompletionGroup';
 import CommandDocs from '../domains/CommandDocs';
 import CompletionsRepository from '../repositories/CompletionsRepository';
 import * as filters from './filters';
@@ -10,14 +9,23 @@ import * as properties from '../../shared/settings/properties';
 
 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<Completions> {
     let keys = Object.keys(CommandDocs);
     let items = keys
       .filter(name => name.startsWith(prefix))
@@ -28,16 +36,14 @@ 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 CompletionGroup', items }]);
   }
 
-  async queryOpen(name, keywords) {
+  async queryOpen(name: string, keywords: string): Promise<Completions> {
     let settings = await this.settingRepository.get();
-    let groups = [];
+    let groups: CompletionGroup[] = [];
 
     let complete = settings.properties.complete || properties.defaults.complete;
     for (let c of complete) {
@@ -45,31 +51,31 @@ export default class CompletionsUseCase {
         // 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<Completions> {
     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 +83,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 +102,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) {
+  querySet(name: string, keywords: string): Promise<CompletionGroup[]> {
     let items = Object.keys(properties.docs).map((key) => {
       if (properties.types[key] === '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],
-          }),
+          }
         ];
       }
       return [
-        new CompletionItem({
+        {
           caption: key,
           content: name + ' ' + key,
           url: 'Set ' + properties.docs[key],
-        })
+        }
       ];
     });
-    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 +193,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) => {
+        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.ts b/src/background/usecases/ConsoleUseCase.ts
index e8e5d4a..60c0439 100644
--- a/src/background/usecases/ConsoleUseCase.ts
+++ b/src/background/usecases/ConsoleUseCase.ts
@@ -2,60 +2,64 @@ 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() {
+  async showCommand(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    return this.consoleClient.showCommand(tab.id, '');
+    return this.consoleClient.showCommand(tab.id as number, '');
   }
 
-  async showOpenCommand(alter) {
+  async showOpenCommand(alter: boolean): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
     let command = 'open ';
     if (alter) {
-      command += tab.url;
+      command += tab.url || '';
     }
-    return this.consoleClient.showCommand(tab.id, command);
+    return this.consoleClient.showCommand(tab.id as number, command);
   }
 
-  async showTabopenCommand(alter) {
+  async showTabopenCommand(alter: boolean): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
     let command = 'tabopen ';
     if (alter) {
-      command += tab.url;
+      command += tab.url || '';
     }
-    return this.consoleClient.showCommand(tab.id, command);
+    return this.consoleClient.showCommand(tab.id as number, command);
   }
 
-  async showWinopenCommand(alter) {
+  async showWinopenCommand(alter: boolean): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
     let command = 'winopen ';
     if (alter) {
-      command += tab.url;
+      command += tab.url || '';
     }
-    return this.consoleClient.showCommand(tab.id, command);
+    return this.consoleClient.showCommand(tab.id as number, command);
   }
 
-  async showBufferCommand() {
+  async showBufferCommand(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
     let command = 'buffer ';
-    return this.consoleClient.showCommand(tab.id, command);
+    return this.consoleClient.showCommand(tab.id as number, command);
   }
 
-  async showAddbookmarkCommand(alter) {
+  async showAddbookmarkCommand(alter: boolean): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
     let command = 'addbookmark ';
     if (alter) {
-      command += tab.title;
+      command += tab.title || '';
     }
-    return this.consoleClient.showCommand(tab.id, command);
+    return this.consoleClient.showCommand(tab.id as number, command);
   }
 
-  async hideConsole() {
+  async hideConsole(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    return this.consoleClient.hide(tab.id);
+    return this.consoleClient.hide(tab.id as number);
   }
 }
diff --git a/src/background/usecases/FindUseCase.ts b/src/background/usecases/FindUseCase.ts
index 224e4a9..d567800 100644
--- a/src/background/usecases/FindUseCase.ts
+++ 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.ts b/src/background/usecases/LinkUseCase.ts
index 89412c5..2f4df7b 100644
--- a/src/background/usecases/LinkUseCase.ts
+++ 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.ts b/src/background/usecases/MarkUseCase.ts
index 39c796b..8b544aa 100644
--- a/src/background/usecases/MarkUseCase.ts
+++ 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,18 +19,19 @@ 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, url: tab.url, 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(
@@ -32,7 +40,7 @@ export default class MarkUseCase {
       return this.tabPresenter.select(mark.tabId);
     }).catch(async() => {
       let tab = await this.tabPresenter.create(mark.url);
-      let mark2 = new GlobalMark(tab.id, mark.url, mark.x, mark.y);
+      let mark2 = { tabId: tab.id, url: mark.url, x: mark.x, y: mark.y };
       return this.markRepository.setMark(key, mark2);
     });
   }
diff --git a/src/background/usecases/SettingUseCase.ts b/src/background/usecases/SettingUseCase.ts
index 9e17408..b66ce02 100644
--- a/src/background/usecases/SettingUseCase.ts
+++ b/src/background/usecases/SettingUseCase.ts
@@ -4,16 +4,20 @@ import PersistentSettingRepository from '../repositories/PersistentSettingReposi
 import SettingRepository from '../repositories/SettingRepository';
 
 export default class SettingUseCase {
+  private persistentSettingRepository: PersistentSettingRepository;
+
+  private settingRepository: SettingRepository;
+
   constructor() {
     this.persistentSettingRepository = new PersistentSettingRepository();
     this.settingRepository = new SettingRepository();
   }
 
-  get() {
+  get(): Promise<any> {
     return this.settingRepository.get();
   }
 
-  async reload() {
+  async reload(): Promise<any> {
     let settings = await this.persistentSettingRepository.load();
     if (!settings) {
       settings = Setting.defaultSettings();
diff --git a/src/background/usecases/TabSelectUseCase.ts b/src/background/usecases/TabSelectUseCase.ts
index 16b3e14..a0b52f0 100644
--- a/src/background/usecases/TabSelectUseCase.ts
+++ 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.ts b/src/background/usecases/TabUseCase.ts
index d930842..1615333 100644
--- a/src/background/usecases/TabUseCase.ts
+++ 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.ts b/src/background/usecases/VersionUseCase.ts
index ed5112b..207f9e2 100644
--- a/src/background/usecases/VersionUseCase.ts
+++ b/src/background/usecases/VersionUseCase.ts
@@ -3,21 +3,25 @@ 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<string> {
     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.ts b/src/background/usecases/ZoomUseCase.ts
index 692d6d9..661c3cd 100644
--- a/src/background/usecases/ZoomUseCase.ts
+++ b/src/background/usecases/ZoomUseCase.ts
@@ -1,35 +1,39 @@
 import TabPresenter from '../presenters/TabPresenter';
 
-const ZOOM_SETTINGS = [
+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(tabId) {
+  async zoomIn(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    let current = await this.tabPresenter.getZoom(tab.id);
+    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, factor);
+      return this.tabPresenter.setZoom(tabId as number, factor);
     }
   }
 
-  async zoomOut(tabId) {
+  async zoomOut(): Promise<any> {
     let tab = await this.tabPresenter.getCurrent();
-    let current = await this.tabPresenter.getZoom(tab.id);
-    let factor = [].concat(ZOOM_SETTINGS).reverse().find(f => f < current);
+    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, factor);
+      return this.tabPresenter.setZoom(tabId as number, factor);
     }
   }
 
-  zoomNutoral(tabId) {
-    return this.tabPresenter.setZoom(tabId, 1);
+  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.ts b/src/background/usecases/filters.ts
index d057dca..44eb56f 100644
--- a/src/background/usecases/filters.ts
+++ b/src/background/usecases/filters.ts
@@ -1,40 +1,42 @@
-const filterHttp = (items) => {
-  let httpsHosts = items.map(x => new URL(x.url))
+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);
-  httpsHosts = new Set(httpsHosts);
+  let hostsSet = new Set(httpsHosts);
 
-  return items.filter((item) => {
-    let url = new URL(item.url);
-    return url.protocol === 'https:' || !httpsHosts.has(url.host);
+  return items.filter((item: Item) => {
+    let url = new URL(item.url as string);
+    return url.protocol === 'https:' || !hostsSet.has(url.host);
   });
 };
 
-const filterBlankTitle = (items) => {
+const filterBlankTitle = (items: Item[]): Item[] => {
   return items.filter(item => item.title && item.title !== '');
 };
 
-const filterByTailingSlash = (items) => {
-  let urls = items.map(item => new URL(item.url));
+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);
-  simplePaths = new Set(simplePaths);
+  let pathsSet = new Set(simplePaths);
 
   return items.filter((item) => {
-    let url = new URL(item.url);
+    let url = new URL(item.url as string);
     if (url.hash !== '' || url.search !== '' ||
       url.pathname.slice(-1) !== '/') {
       return true;
     }
-    return !simplePaths.has(url.origin + url.pathname.slice(0, -1));
+    return !pathsSet.has(url.origin + url.pathname.slice(0, -1));
   });
 };
 
-const filterByPathname = (items, min) => {
-  let hash = {};
+const filterByPathname = (items: Item[], min: number): Item[] => {
+  let hash: {[key: string]: Item} = {};
   for (let item of items) {
-    let url = new URL(item.url);
+    let url = new URL(item.url as string);
     let pathname = url.origin + url.pathname;
     if (!hash[pathname]) {
       hash[pathname] = item;
@@ -49,10 +51,10 @@ const filterByPathname = (items, min) => {
   return filtered;
 };
 
-const filterByOrigin = (items, min) => {
-  let hash = {};
+const filterByOrigin = (items: Item[], min: number): Item[] => {
+  let hash: {[key: string]: Item} = {};
   for (let item of items) {
-    let origin = new URL(item.url).origin;
+    let origin = new URL(item.url as string).origin;
     if (!hash[origin]) {
       hash[origin] = item;
     } else if (hash[origin].url.length > item.url.length) {
diff --git a/src/background/usecases/parsers.ts b/src/background/usecases/parsers.ts
index 43c8177..3616ac3 100644
--- a/src/background/usecases/parsers.ts
+++ b/src/background/usecases/parsers.ts
@@ -1,4 +1,4 @@
-const mustNumber = (v) => {
+const mustNumber = (v: any): number => {
   let num = Number(v);
   if (isNaN(num)) {
     throw new Error('Not number: ' + v);
@@ -6,8 +6,11 @@ const mustNumber = (v) => {
   return num;
 };
 
-const parseSetOption = (word, types) => {
-  let [key, value] = word.split('=');
+const parseSetOption = (
+  word: string,
+  types: { [key: string]: string },
+): any[] => {
+  let [key, value]: any[] = word.split('=');
   if (value === undefined) {
     value = !key.startsWith('no');
     key = value ? key : key.slice(2);
@@ -26,6 +29,7 @@ const parseSetOption = (word, types) => {
   case 'number': return [key, mustNumber(value)];
   case 'boolean': return [key, value];
   }
+  throw new Error('Unknown property type: ' + type);
 };
 
 export { parseSetOption };