Types on src/background

src/background/infrastructures/ConsoleClient.ts

@@ -1,34 +1,34 @@
 import messages from '../../shared/messages';
 
 export default class ConsoleClient {
-  showCommand(tabId, command) {
+  showCommand(tabId: number, command: string): Promise<any> {
     return browser.tabs.sendMessage(tabId, {
       type: messages.CONSOLE_SHOW_COMMAND,
       command,
     });
   }
 
-  showFind(tabId) {
+  showFind(tabId: number): Promise<any> {
     return browser.tabs.sendMessage(tabId, {
       type: messages.CONSOLE_SHOW_FIND
     });
   }
 
-  showInfo(tabId, message) {
+  showInfo(tabId: number, message: string): Promise<any> {
     return browser.tabs.sendMessage(tabId, {
       type: messages.CONSOLE_SHOW_INFO,
       text: message,
     });
   }
 
-  showError(tabId, message) {
+  showError(tabId: number, message: string): Promise<any> {
     return browser.tabs.sendMessage(tabId, {
       type: messages.CONSOLE_SHOW_ERROR,
       text: message,
     });
   }
 
-  hide(tabId) {
+  hide(tabId: number): Promise<any> {
     return browser.tabs.sendMessage(tabId, {
       type: messages.CONSOLE_HIDE,
     });

src/background/infrastructures/ContentMessageClient.ts

@@ -1,10 +1,10 @@
 import messages from '../../shared/messages';
 
 export default class ContentMessageClient {
-  async broadcastSettingsChanged() {
+  async broadcastSettingsChanged(): Promise<void> {
     let tabs = await browser.tabs.query({});
     for (let tab of tabs) {
-      if (tab.url.startsWith('about:')) {
+      if (!tab.id || tab.url && tab.url.startsWith('about:')) {
         continue;
       }
       browser.tabs.sendMessage(tab.id, {
@@ -13,20 +13,20 @@ export default class ContentMessageClient {
     }
   }
 
-  async getAddonEnabled(tabId) {
+  async getAddonEnabled(tabId: number): Promise<boolean> {
     let { enabled } = await browser.tabs.sendMessage(tabId, {
       type: messages.ADDON_ENABLED_QUERY,
-    });
+    }) as { enabled: boolean };
     return enabled;
   }
 
-  toggleAddonEnabled(tabId) {
+  toggleAddonEnabled(tabId: number): Promise<void> {
     return browser.tabs.sendMessage(tabId, {
       type: messages.ADDON_TOGGLE_ENABLED,
     });
   }
 
-  scrollTo(tabId, x, y) {
+  scrollTo(tabId: number, x: number, y: number): Promise<void> {
     return browser.tabs.sendMessage(tabId, {
       type: messages.TAB_SCROLL_TO,
       x,

src/background/infrastructures/ContentMessageListener.ts

@@ -1,4 +1,5 @@
 import messages from '../../shared/messages';
+import CompletionGroup from '../domains/CompletionGroup';
 import CommandController from '../controllers/CommandController';
 import SettingController from '../controllers/SettingController';
 import FindController from '../controllers/FindController';
@@ -8,6 +9,22 @@ import OperationController from '../controllers/OperationController';
 import MarkController from '../controllers/MarkController';
 
 export default class ContentMessageListener {
+  private settingController: SettingController;
+
+  private commandController: CommandController;
+
+  private findController: FindController;
+
+  private addonEnabledController: AddonEnabledController;
+
+  private linkController: LinkController;
+
+  private backgroundOperationController: OperationController;
+
+  private markController: MarkController;
+
+  private consolePorts: {[tabId: number]: browser.runtime.Port};
+
   constructor() {
     this.settingController = new SettingController();
     this.commandController = new CommandController();
@@ -20,20 +37,28 @@ export default class ContentMessageListener {
     this.consolePorts = {};
   }
 
-  run() {
-    browser.runtime.onMessage.addListener((message, sender) => {
+  run(): void {
+    browser.runtime.onMessage.addListener((
+      message: any, sender: browser.runtime.MessageSender,
+    ) => {
       try {
-        let ret = this.onMessage(message, sender);
+        let ret = this.onMessage(message, sender.tab as browser.tabs.Tab);
         if (!(ret instanceof Promise)) {
           return {};
         }
         return ret.catch((e) => {
+          if (!sender.tab || !sender.tab.id) {
+            return;
+          }
           return browser.tabs.sendMessage(sender.tab.id, {
             type: messages.CONSOLE_SHOW_ERROR,
             text: e.message,
           });
         });
       } catch (e) {
+        if (!sender.tab || !sender.tab.id) {
+          return;
+        }
         return browser.tabs.sendMessage(sender.tab.id, {
           type: messages.CONSOLE_SHOW_ERROR,
           text: e.message,
@@ -43,7 +68,7 @@ export default class ContentMessageListener {
     browser.runtime.onConnect.addListener(this.onConnected.bind(this));
   }
 
-  onMessage(message, sender) {
+  onMessage(message: any, senderTab: browser.tabs.Tab): Promise<any> | any {
     switch (message.type) {
     case messages.CONSOLE_QUERY_COMPLETIONS:
       return this.onConsoleQueryCompletions(message.text);
@@ -59,7 +84,10 @@ export default class ContentMessageListener {
       return this.onAddonEnabledResponse(message.enabled);
     case messages.OPEN_URL:
       return this.onOpenUrl(
-        message.newTab, message.url, sender.tab.id, message.background);
+        message.newTab,
+        message.url,
+        senderTab.id as number,
+        message.background);
     case messages.BACKGROUND_OPERATION:
       return this.onBackgroundOperation(message.operation);
     case messages.MARK_SET_GLOBAL:
@@ -67,56 +95,60 @@ export default class ContentMessageListener {
     case messages.MARK_JUMP_GLOBAL:
       return this.onMarkJumpGlobal(message.key);
     case messages.CONSOLE_FRAME_MESSAGE:
-      return this.onConsoleFrameMessage(sender.tab.id, message.message);
+      return this.onConsoleFrameMessage(
+        senderTab.id as number, message.message,
+      );
     }
+    throw new Error('unsupported message: ' + message.type);
   }
 
-  async onConsoleQueryCompletions(line) {
+  async onConsoleQueryCompletions(line: string): Promise<CompletionGroup[]> {
     let completions = await this.commandController.getCompletions(line);
-    return Promise.resolve(completions.serialize());
+    return Promise.resolve(completions);
   }
 
-  onConsoleEnterCommand(text) {
+  onConsoleEnterCommand(text: string): Promise<any> {
     return this.commandController.exec(text);
   }
 
-
-  onSettingsQuery() {
+  onSettingsQuery(): Promise<any> {
     return this.settingController.getSetting();
   }
 
-  onFindGetKeyword() {
+  onFindGetKeyword(): Promise<string> {
     return this.findController.getKeyword();
   }
 
-  onFindSetKeyword(keyword) {
+  onFindSetKeyword(keyword: string): Promise<any> {
     return this.findController.setKeyword(keyword);
   }
 
-  onAddonEnabledResponse(enabled) {
+  onAddonEnabledResponse(enabled: boolean): Promise<any> {
     return this.addonEnabledController.indicate(enabled);
   }
 
-  onOpenUrl(newTab, url, openerId, background) {
+  onOpenUrl(
+    newTab: boolean, url: string, openerId: number, background: boolean,
+  ): Promise<any> {
     if (newTab) {
       return this.linkController.openNewTab(url, openerId, background);
     }
     return this.linkController.openToTab(url, openerId);
   }
 
-  onBackgroundOperation(operation) {
+  onBackgroundOperation(operation: any): Promise<any> {
     return this.backgroundOperationController.exec(operation);
   }
 
-  onMarkSetGlobal(key, x, y) {
+  onMarkSetGlobal(key: string, x: number, y: number): Promise<any> {
     return this.markController.setGlobal(key, x, y);
   }
 
-  onMarkJumpGlobal(key) {
+  onMarkJumpGlobal(key: string): Promise<any> {
     return this.markController.jumpGlobal(key);
   }
 
-  onConsoleFrameMessage(tabId, message) {
+  onConsoleFrameMessage(tabId: number, message: any): void {
     let port = this.consolePorts[tabId];
     if (!port) {
       return;
@@ -124,12 +156,14 @@ export default class ContentMessageListener {
     port.postMessage(message);
   }
 
-  onConnected(port) {
+  onConnected(port: browser.runtime.Port): void {
     if (port.name !== 'vimvixen-console') {
       return;
     }
 
-    let id = port.sender.tab.id;
-    this.consolePorts[id] = port;
+    if (port.sender && port.sender.tab && port.sender.tab.id) {
+      let id = port.sender.tab.id;
+      this.consolePorts[id] = port;
+    }
   }
 }

src/background/infrastructures/MemoryStorage.ts

@@ -1,7 +1,7 @@
-const db = {};
+const db: {[key: string]: any} = {};
 
 export default class MemoryStorage {
-  set(name, value) {
+  set(name: string, value: any): void {
     let data = JSON.stringify(value);
     if (typeof data === 'undefined') {
       throw new Error('value is not serializable');
@@ -9,7 +9,7 @@ export default class MemoryStorage {
     db[name] = data;
   }
 
-  get(name) {
+  get(name: string): any {
     let data = db[name];
     if (!data) {
       return undefined;