Merge pull request #1159 from h3poteto/fix/electron-mock-ipc

Update jest version to 24.9.0 and fix some tests

package.json

@@ -144,8 +144,7 @@
     "moduleNameMapper": {
       "@/router": "<rootDir>/spec/mock/router.ts",
       "^@/(.+)": "<rootDir>/src/renderer/$1",
-      "^~/(.+)": "<rootDir>/$1",
+      "^~/(.+)": "<rootDir>/$1"
-      "electron": "<rootDir>/spec/mock/electron.ts"
     },
     "testMatch": [
       "**/spec/**/*.spec.ts"
@@ -263,7 +262,7 @@
     "eslint-plugin-vue": "^5.2.2",
     "file-loader": "^2.0.0",
     "html-webpack-plugin": "^3.2.0",
-    "jest": "^24.5.0",
+    "jest": "^24.9.0",
     "jsdom": "^15.2.1",
     "json-loader": "^0.5.7",
     "listr": "^0.14.3",

spec/main/unit/proxy.spec.ts

@@ -5,6 +5,11 @@ import { ManualProxy, ProxyProtocol } from '~/src/types/proxy'
 const preferencesDBPath = path.resolve(__dirname, '../../preferences.json')
 const proxyConfiguration = new ProxyConfiguration(preferencesDBPath)
 
+// electron.app is using in electron-json-storage
+jest.mock('electron', () => ({
+  app: jest.fn()
+}))
+
 describe('Parser', () => {
   it('do not use proxy', () => {
     proxyConfiguration.setSystemProxy('DIRECT')

spec/renderer/integration/store/App.spec.ts

@@ -1,6 +1,6 @@
 import { createLocalVue } from '@vue/test-utils'
 import Vuex from 'vuex'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import App from '@/store/App'
 import DisplayStyle from '~/src/constants/displayStyle'
 import { LightTheme, DarkTheme } from '~/src/constants/themeColor'
@@ -8,6 +8,8 @@ import Theme from '~/src/constants/theme'
 import TimeFormat from '~/src/constants/timeFormat'
 import Language from '~/src/constants/language'
 import DefaultFonts from '@/utils/fonts'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 const state = () => {
   return {

spec/renderer/integration/store/GlobalHeader.spec.ts

@@ -1,7 +1,9 @@
 import { createLocalVue } from '@vue/test-utils'
 import Vuex from 'vuex'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import GlobalHeader, { GlobalHeaderState } from '~/src/renderer/store/GlobalHeader'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 const state = (): GlobalHeaderState => {
   return {

spec/renderer/integration/store/Login.spec.ts

@@ -1,8 +1,10 @@
 import { createLocalVue } from '@vue/test-utils'
 import Vuex from 'vuex'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import Mastodon, { Instance, Response } from 'megalodon'
 import Login, { LoginState } from '@/store/Login'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 jest.mock('megalodon')
 

spec/renderer/integration/store/Preferences/Account.spec.ts

@@ -1,8 +1,10 @@
 import { createLocalVue } from '@vue/test-utils'
 import Vuex from 'vuex'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import Account, { AccountState } from '@/store/Preferences/Account'
 import { LocalAccount } from '~/src/types/localAccount'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 const account: LocalAccount = {
   _id: 'sample',

spec/renderer/integration/store/Preferences/Appearance.spec.ts

@@ -7,7 +7,9 @@ import TimeFormat from '~/src/constants/timeFormat'
 import { LightTheme, DarkTheme } from '~/src/constants/themeColor'
 import DefaultFonts from '@/utils/fonts'
 import Appearance, { AppearanceState } from '@/store/Preferences/Appearance'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 const state = (): AppearanceState => {
   return {

spec/renderer/integration/store/Preferences/General.spec.ts

@@ -1,7 +1,9 @@
 import { createLocalVue } from '@vue/test-utils'
 import Vuex from 'vuex'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import General, { GeneralState } from '@/store/Preferences/General'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 const state = (): GeneralState => {
   return {

spec/renderer/integration/store/Preferences/Language.spec.ts

@@ -1,8 +1,10 @@
 import { createLocalVue } from '@vue/test-utils'
 import Vuex from 'vuex'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import Language, { LanguageState } from '@/store/Preferences/Language'
 import DefaultLanguage from '~/src/constants/language'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 const state = (): LanguageState => {
   return {

spec/renderer/integration/store/Preferences/Notification.spec.ts

@@ -1,7 +1,9 @@
 import { createLocalVue } from '@vue/test-utils'
 import Vuex from 'vuex'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import Notification, { NotificationState } from '@/store/Preferences/Notification'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 const state = (): NotificationState => {
   return {

spec/renderer/integration/store/TimelineSpace.spec.ts

@@ -1,9 +1,11 @@
 import Mastodon, { Emoji, Instance, Response } from 'megalodon'
 import { createLocalVue } from '@vue/test-utils'
 import Vuex from 'vuex'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import TimelineSpace, { TimelineSpaceState, blankAccount } from '~/src/renderer/store/TimelineSpace'
 import unreadSettings from '~/src/constants/unreadNotification'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 jest.mock('megalodon')
 

spec/renderer/integration/store/TimelineSpace/Contents/Hashtag/List.spec.ts

@@ -1,9 +1,11 @@
 import { IpcMainEvent } from 'electron'
 import { createLocalVue } from '@vue/test-utils'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import Vuex from 'vuex'
 import { LocalTag } from '~/src/types/localTag'
 import List, { ListState } from '@/store/TimelineSpace/Contents/Hashtag/List'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 const tag1: LocalTag = {
   tagName: 'tag1',

spec/renderer/integration/store/TimelineSpace/SideMenu.spec.ts

@@ -2,9 +2,11 @@ import { Response, List } from 'megalodon'
 import mockedMegalodon from '~/spec/mock/megalodon'
 import { createLocalVue } from '@vue/test-utils'
 import Vuex from 'vuex'
-import { ipcMain } from '~/spec/mock/electron'
+import { ipcMain, ipcRenderer } from '~/spec/mock/electron'
 import SideMenu, { SideMenuState } from '~/src/renderer/store/TimelineSpace/SideMenu'
 import { LocalTag } from '~/src/types/localTag'
+import { MyWindow } from '~/src/types/global'
+;(window as MyWindow).ipcRenderer = ipcRenderer
 
 jest.mock('megalodon')
 

src/main/preload.js

@@ -1,6 +1,7 @@
 const electron = require('electron')
 const path = require('path')
 const mod = require('module')
+
 global.ipcRenderer = electron.ipcRenderer
 global.shell = electron.shell
 global.clipboard = electron.clipboard

src/renderer/store/App.ts

@@ -11,7 +11,9 @@ import { Notify } from '~/src/types/notify'
 import { BaseConfig } from '~/src/types/preference'
 import { Appearance } from '~/src/types/appearance'
 import { ProxyConfig } from 'megalodon'
-import { ipcRenderer } from 'electron'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type AppState = {
   theme: ThemeColorType
@@ -107,22 +109,22 @@ const mutations: MutationTree<AppState> = {
 
 const actions: ActionTree<AppState, RootState> = {
   watchShortcutsEvents: () => {
-    ipcRenderer.on('open-preferences', () => {
+    win.ipcRenderer.on('open-preferences', () => {
       router.push('/preferences/general')
     })
   },
   removeShortcutsEvents: () => {
-    ipcRenderer.removeAllListeners('open-preferences')
+    win.ipcRenderer.removeAllListeners('open-preferences')
   },
   loadPreferences: ({ commit, dispatch }) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('get-preferences')
+      win.ipcRenderer.send('get-preferences')
-      ipcRenderer.once('error-get-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-get-preferences')
+        win.ipcRenderer.removeAllListeners('response-get-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-get-preferences')
+        win.ipcRenderer.removeAllListeners('error-get-preferences')
         dispatch('updateTheme', conf.appearance)
         commit(MUTATION_TYPES.UPDATE_DISPLAY_NAME_STYLE, conf.appearance.displayNameStyle)
         commit(MUTATION_TYPES.UPDATE_FONT_SIZE, conf.appearance.fontSize)
@@ -166,11 +168,11 @@ const actions: ActionTree<AppState, RootState> = {
   },
   loadProxy: ({ commit }) => {
     return new Promise(resolve => {
-      ipcRenderer.once('response-get-proxy-configuration', (_, proxy: ProxyConfig | false) => {
+      win.ipcRenderer.once('response-get-proxy-configuration', (_, proxy: ProxyConfig | false) => {
         commit(MUTATION_TYPES.UPDATE_PROXY_CONFIGURATION, proxy)
         resolve(proxy)
       })
-      ipcRenderer.send('get-proxy-configuration')
+      win.ipcRenderer.send('get-proxy-configuration')
     })
   }
 }

src/renderer/store/Authorize.ts

@@ -1,6 +1,8 @@
-import { ipcRenderer } from 'electron'
 import { Module, ActionTree } from 'vuex'
 import { RootState } from '@/store'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type AuthorizeState = {}
 
@@ -9,13 +11,13 @@ const state = (): AuthorizeState => ({})
 const actions: ActionTree<AuthorizeState, RootState> = {
   submit: (_, code: string) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('get-access-token', code.trim())
+      win.ipcRenderer.send('get-access-token', code.trim())
-      ipcRenderer.once('response-get-access-token', (_, id: string) => {
+      win.ipcRenderer.once('response-get-access-token', (_, id: string) => {
-        ipcRenderer.removeAllListeners('error-get-access-token')
+        win.ipcRenderer.removeAllListeners('error-get-access-token')
         resolve(id)
       })
-      ipcRenderer.once('error-get-access-token', (_, err: Error) => {
+      win.ipcRenderer.once('error-get-access-token', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-get-access-token')
+        win.ipcRenderer.removeAllListeners('response-get-access-token')
         reject(err)
       })
     })

src/renderer/store/GlobalHeader.ts

@@ -1,9 +1,11 @@
-import { ipcRenderer } from 'electron'
 import router from '@/router'
 import { LocalAccount } from '~/src/types/localAccount'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
 import { StreamingError } from '~src/errors/streamingError'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type GlobalHeaderState = {
   accounts: Array<LocalAccount>
@@ -61,13 +63,13 @@ const actions: ActionTree<GlobalHeaderState, RootState> = {
   },
   listAccounts: ({ dispatch, commit }): Promise<Array<LocalAccount>> => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('list-accounts', 'list')
+      win.ipcRenderer.send('list-accounts', 'list')
-      ipcRenderer.once('error-list-accounts', (_, err: Error) => {
+      win.ipcRenderer.once('error-list-accounts', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-list-accounts')
+        win.ipcRenderer.removeAllListeners('response-list-accounts')
         reject(err)
       })
-      ipcRenderer.once('response-list-accounts', (_, accounts: Array<LocalAccount>) => {
+      win.ipcRenderer.once('response-list-accounts', (_, accounts: Array<LocalAccount>) => {
-        ipcRenderer.removeAllListeners('error-list-accounts')
+        win.ipcRenderer.removeAllListeners('error-list-accounts')
         commit(MUTATION_TYPES.UPDATE_ACCOUNTS, accounts)
         dispatch('refreshAccounts')
         resolve(accounts)
@@ -77,20 +79,20 @@ const actions: ActionTree<GlobalHeaderState, RootState> = {
   // Fetch account informations and save current state when GlobalHeader is displayed
   refreshAccounts: ({ commit }): Promise<Array<LocalAccount>> => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('refresh-accounts')
+      win.ipcRenderer.send('refresh-accounts')
-      ipcRenderer.once('error-refresh-accounts', (_, err: Error) => {
+      win.ipcRenderer.once('error-refresh-accounts', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-refresh-accounts')
+        win.ipcRenderer.removeAllListeners('response-refresh-accounts')
         reject(err)
       })
-      ipcRenderer.once('response-refresh-accounts', (_, accounts: Array<LocalAccount>) => {
+      win.ipcRenderer.once('response-refresh-accounts', (_, accounts: Array<LocalAccount>) => {
-        ipcRenderer.removeAllListeners('error-refresh-accounts')
+        win.ipcRenderer.removeAllListeners('error-refresh-accounts')
         commit(MUTATION_TYPES.UPDATE_ACCOUNTS, accounts)
         resolve(accounts)
       })
     })
   },
   watchShortcutEvents: ({ state, commit, rootState, rootGetters }) => {
-    ipcRenderer.on('change-account', (_, account: LocalAccount) => {
+    win.ipcRenderer.on('change-account', (_, account: LocalAccount) => {
       if (state.changing) {
         return null
       }
@@ -108,13 +110,13 @@ const actions: ActionTree<GlobalHeaderState, RootState> = {
     })
   },
   removeShortcutEvents: async () => {
-    ipcRenderer.removeAllListeners('change-account')
+    win.ipcRenderer.removeAllListeners('change-account')
     return true
   },
   loadHide: ({ commit }): Promise<boolean> => {
     return new Promise(resolve => {
-      ipcRenderer.send('get-global-header')
+      win.ipcRenderer.send('get-global-header')
-      ipcRenderer.once('response-get-global-header', (_, hide: boolean) => {
+      win.ipcRenderer.once('response-get-global-header', (_, hide: boolean) => {
         commit(MUTATION_TYPES.CHANGE_HIDE, hide)
         resolve(hide)
       })
@@ -122,8 +124,8 @@ const actions: ActionTree<GlobalHeaderState, RootState> = {
   },
   switchHide: ({ dispatch }, hide: boolean): Promise<boolean> => {
     return new Promise(resolve => {
-      ipcRenderer.send('change-global-header', hide)
+      win.ipcRenderer.send('change-global-header', hide)
-      ipcRenderer.once('response-change-global-header', () => {
+      win.ipcRenderer.once('response-change-global-header', () => {
         dispatch('loadHide')
         resolve(true)
       })
@@ -132,18 +134,18 @@ const actions: ActionTree<GlobalHeaderState, RootState> = {
   startUserStreamings: ({ state }): Promise<{}> => {
     // @ts-ignore
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-start-all-user-streamings', (_, err: StreamingError) => {
+      win.ipcRenderer.once('error-start-all-user-streamings', (_, err: StreamingError) => {
         reject(err)
       })
-      ipcRenderer.send('start-all-user-streamings', state.accounts)
+      win.ipcRenderer.send('start-all-user-streamings', state.accounts)
     })
   },
   stopUserStreamings: () => {
-    ipcRenderer.send('stop-all-user-streamings')
+    win.ipcRenderer.send('stop-all-user-streamings')
   },
   bindNotification: () => {
-    ipcRenderer.removeAllListeners('open-notification-tab')
+    win.ipcRenderer.removeAllListeners('open-notification-tab')
-    ipcRenderer.on('open-notification-tab', (_, id: string) => {
+    win.ipcRenderer.on('open-notification-tab', (_, id: string) => {
       router.push(`/${id}/home`)
       // We have to wait until change el-menu-item
       setTimeout(() => router.push(`/${id}/notifications`), 500)

src/renderer/store/Login.ts

@@ -1,7 +1,9 @@
-import { ipcRenderer } from 'electron'
 import Mastodon, { Instance } from 'megalodon'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type LoginState = {
   selectedInstance: string | null
@@ -30,13 +32,13 @@ const mutations: MutationTree<LoginState> = {
 const actions: ActionTree<LoginState, RootState> = {
   fetchLogin: (_, instance: string) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('get-auth-url', instance)
+      win.ipcRenderer.send('get-auth-url', instance)
-      ipcRenderer.once('error-get-auth-url', (_, err: Error) => {
+      win.ipcRenderer.once('error-get-auth-url', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-get-auth-url')
+        win.ipcRenderer.removeAllListeners('response-get-auth-url')
         reject(err)
       })
-      ipcRenderer.once('response-get-auth-url', (_, url: string) => {
+      win.ipcRenderer.once('response-get-auth-url', (_, url: string) => {
-        ipcRenderer.removeAllListeners('response-get-auth-url')
+        win.ipcRenderer.removeAllListeners('response-get-auth-url')
         resolve(url)
       })
     })

src/renderer/store/Preferences/Account.ts

@@ -1,7 +1,9 @@
-import { ipcRenderer } from 'electron'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { LocalAccount } from '~/src/types/localAccount'
 import { RootState } from '@/store'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type AccountState = {
   accounts: Array<LocalAccount>
@@ -30,13 +32,13 @@ const mutations: MutationTree<AccountState> = {
 const actions: ActionTree<AccountState, RootState> = {
   loadAccounts: ({ commit }): Promise<Array<LocalAccount>> => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('list-accounts', 'list')
+      win.ipcRenderer.send('list-accounts', 'list')
-      ipcRenderer.once('error-list-accounts', (_, err: Error) => {
+      win.ipcRenderer.once('error-list-accounts', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-list-accounts')
+        win.ipcRenderer.removeAllListeners('response-list-accounts')
         reject(err)
       })
-      ipcRenderer.once('response-list-accounts', (_, accounts: Array<LocalAccount>) => {
+      win.ipcRenderer.once('response-list-accounts', (_, accounts: Array<LocalAccount>) => {
-        ipcRenderer.removeAllListeners('error-list-accounts')
+        win.ipcRenderer.removeAllListeners('error-list-accounts')
         commit(MUTATION_TYPES.UPDATE_ACCOUNTS, accounts)
         resolve(accounts)
       })
@@ -44,52 +46,52 @@ const actions: ActionTree<AccountState, RootState> = {
   },
   removeAccount: (_, account: LocalAccount) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('remove-account', account._id)
+      win.ipcRenderer.send('remove-account', account._id)
-      ipcRenderer.once('error-remove-account', (_, err: Error) => {
+      win.ipcRenderer.once('error-remove-account', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-remove-account')
+        win.ipcRenderer.removeAllListeners('response-remove-account')
         reject(err)
       })
-      ipcRenderer.once('response-remove-account', (_, _id: string) => {
+      win.ipcRenderer.once('response-remove-account', (_, _id: string) => {
-        ipcRenderer.removeAllListeners('error-remove-account')
+        win.ipcRenderer.removeAllListeners('error-remove-account')
         resolve()
       })
     })
   },
   forwardAccount: (_, account: LocalAccount) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('forward-account', account)
+      win.ipcRenderer.send('forward-account', account)
-      ipcRenderer.once('error-forward-account', (_, err: Error) => {
+      win.ipcRenderer.once('error-forward-account', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-forward-account')
+        win.ipcRenderer.removeAllListeners('response-forward-account')
         reject(err)
       })
-      ipcRenderer.once('response-forward-account', () => {
+      win.ipcRenderer.once('response-forward-account', () => {
-        ipcRenderer.removeAllListeners('error-forward-account')
+        win.ipcRenderer.removeAllListeners('error-forward-account')
         resolve()
       })
     })
   },
   backwardAccount: (_, account: LocalAccount) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('backward-account', account)
+      win.ipcRenderer.send('backward-account', account)
-      ipcRenderer.once('error-backward-account', (_, err: Error) => {
+      win.ipcRenderer.once('error-backward-account', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-forward-account')
+        win.ipcRenderer.removeAllListeners('response-forward-account')
         reject(err)
       })
-      ipcRenderer.once('response-backward-account', () => {
+      win.ipcRenderer.once('response-backward-account', () => {
-        ipcRenderer.removeAllListeners('error-backward-account')
+        win.ipcRenderer.removeAllListeners('error-backward-account')
         resolve()
       })
     })
   },
   removeAllAccounts: () => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('remove-all-accounts')
+      win.ipcRenderer.send('remove-all-accounts')
-      ipcRenderer.once('error-remove-all-accounts', (_, err: Error) => {
+      win.ipcRenderer.once('error-remove-all-accounts', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-remove-all-accounts')
+        win.ipcRenderer.removeAllListeners('response-remove-all-accounts')
         reject(err)
       })
-      ipcRenderer.once('response-remove-all-accounts', () => {
+      win.ipcRenderer.once('response-remove-all-accounts', () => {
-        ipcRenderer.removeAllListeners('error-remove-all-accounts')
+        win.ipcRenderer.removeAllListeners('error-remove-all-accounts')
         resolve()
       })
     })

src/renderer/store/Preferences/Appearance.ts

@@ -1,4 +1,3 @@
-import { ipcRenderer } from 'electron'
 import DisplayStyle from '~/src/constants/displayStyle'
 import Theme from '~/src/constants/theme'
 import TimeFormat from '~/src/constants/timeFormat'
@@ -8,6 +7,9 @@ import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
 import { Appearance } from '~/src/types/appearance'
 import { BaseConfig } from '~/src/types/preference'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type AppearanceState = {
   appearance: Appearance
@@ -44,30 +46,30 @@ const mutations: MutationTree<AppearanceState> = {
 const actions: ActionTree<AppearanceState, RootState> = {
   loadAppearance: ({ commit }) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-get-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-get-preferences')
+        win.ipcRenderer.removeAllListeners('response-get-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-get-preferences')
+        win.ipcRenderer.removeAllListeners('error-get-preferences')
         commit(MUTATION_TYPES.UPDATE_APPEARANCE, conf.appearance)
         resolve(conf)
       })
-      ipcRenderer.send('get-preferences')
+      win.ipcRenderer.send('get-preferences')
     })
   },
   loadFonts: ({ commit }) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-list-fonts', (_, err: Error) => {
+      win.ipcRenderer.once('error-list-fonts', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-list-fonts')
+        win.ipcRenderer.removeAllListeners('response-list-fonts')
         reject(err)
       })
-      ipcRenderer.once('response-list-fonts', (_, fonts: Array<string>) => {
+      win.ipcRenderer.once('response-list-fonts', (_, fonts: Array<string>) => {
-        ipcRenderer.removeAllListeners('error-list-fonts')
+        win.ipcRenderer.removeAllListeners('error-list-fonts')
         commit(MUTATION_TYPES.UPDATE_FONTS, [DefaultFonts[0]].concat(fonts))
         resolve(fonts)
       })
-      ipcRenderer.send('list-fonts')
+      win.ipcRenderer.send('list-fonts')
     })
   },
   updateTheme: ({ dispatch, commit, state }, themeKey: string) => {
@@ -78,17 +80,17 @@ const actions: ActionTree<AppearanceState, RootState> = {
       appearance: newAppearance
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-preferences')
+        win.ipcRenderer.removeAllListeners('response-update-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-update-preferences')
+        win.ipcRenderer.removeAllListeners('error-update-preferences')
         commit(MUTATION_TYPES.UPDATE_APPEARANCE, conf.appearance)
         dispatch('App/loadPreferences', null, { root: true })
         resolve(conf.appearance)
       })
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
     })
   },
   updateFontSize: ({ dispatch, commit, state }, fontSize: number) => {
@@ -99,17 +101,17 @@ const actions: ActionTree<AppearanceState, RootState> = {
       appearance: newAppearance
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-preferences')
+        win.ipcRenderer.removeAllListeners('response-update-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-update-preferences')
+        win.ipcRenderer.removeAllListeners('error-update-preferences')
         commit(MUTATION_TYPES.UPDATE_APPEARANCE, conf.appearance)
         dispatch('App/loadPreferences', null, { root: true })
         resolve(conf.appearance)
       })
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
     })
   },
   updateDisplayNameStyle: ({ dispatch, commit, state }, value: number) => {
@@ -120,17 +122,17 @@ const actions: ActionTree<AppearanceState, RootState> = {
       appearance: newAppearance
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-preferences')
+        win.ipcRenderer.removeAllListeners('response-update-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-update-preferences')
+        win.ipcRenderer.removeAllListeners('error-update-preferences')
         dispatch('App/loadPreferences', null, { root: true })
         commit(MUTATION_TYPES.UPDATE_APPEARANCE, conf.appearance)
         resolve(conf.appearance)
       })
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
     })
   },
   updateTimeFormat: ({ dispatch, commit, state }, value: number) => {
@@ -141,17 +143,17 @@ const actions: ActionTree<AppearanceState, RootState> = {
       appearance: newAppearance
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-preferences')
+        win.ipcRenderer.removeAllListeners('response-update-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-update-preferences')
+        win.ipcRenderer.removeAllListeners('error-update-preferences')
         dispatch('App/loadPreferences', null, { root: true })
         commit(MUTATION_TYPES.UPDATE_APPEARANCE, conf.appearance)
         resolve(conf.appearance)
       })
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
     })
   },
   updateCustomThemeColor: ({ dispatch, state, commit }, value: object) => {
@@ -163,17 +165,17 @@ const actions: ActionTree<AppearanceState, RootState> = {
       appearance: newAppearance
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-preferences')
+        win.ipcRenderer.removeAllListeners('response-update-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-update-preferences')
+        win.ipcRenderer.removeAllListeners('error-update-preferences')
         commit(MUTATION_TYPES.UPDATE_APPEARANCE, conf.appearance)
         dispatch('App/loadPreferences', null, { root: true })
         resolve(conf.appearance)
       })
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
     })
   },
   updateFont: ({ dispatch, state, commit }, value: string) => {
@@ -184,17 +186,17 @@ const actions: ActionTree<AppearanceState, RootState> = {
       appearance: newAppearance
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-preferences')
+        win.ipcRenderer.removeAllListeners('response-update-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-update-preferences')
+        win.ipcRenderer.removeAllListeners('error-update-preferences')
         commit(MUTATION_TYPES.UPDATE_APPEARANCE, conf.appearance)
         dispatch('App/loadPreferences', null, { root: true })
         resolve(conf.appearance)
       })
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
     })
   },
   updateTootPadding: ({ dispatch, state, commit }, value: number) => {
@@ -205,17 +207,17 @@ const actions: ActionTree<AppearanceState, RootState> = {
       appearance: newAppearance
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-preferences')
+        win.ipcRenderer.removeAllListeners('response-update-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-update-preferences')
+        win.ipcRenderer.removeAllListeners('error-update-preferences')
         commit(MUTATION_TYPES.UPDATE_APPEARANCE, conf.appearance)
         dispatch('App/loadPreferences', null, { root: true })
         resolve(conf.appearance)
       })
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
     })
   }
 }

src/renderer/store/Preferences/General.ts

@@ -1,4 +1,3 @@
-import { ipcRenderer } from 'electron'
 import { Module, MutationTree, ActionTree, GetterTree } from 'vuex'
 import { RootState } from '@/store'
 import { Sound } from '~/src/types/sound'
@@ -49,14 +48,14 @@ const actions: ActionTree<GeneralState, RootState> = {
   loadGeneral: ({ commit }) => {
     return new Promise((resolve, reject) => {
       commit(MUTATION_TYPES.CHANGE_LOADING, true)
-      ipcRenderer.send('get-preferences')
+      win.ipcRenderer.send('get-preferences')
-      ipcRenderer.once('error-get-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-get-preferences')
+        win.ipcRenderer.removeAllListeners('response-get-preferences')
         commit(MUTATION_TYPES.CHANGE_LOADING, false)
         reject(err)
       })
-      ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-get-preferences')
+        win.ipcRenderer.removeAllListeners('error-get-preferences')
         commit(MUTATION_TYPES.UPDATE_GENERAL, conf.general as General)
         commit(MUTATION_TYPES.CHANGE_LOADING, false)
         resolve(conf)
@@ -73,14 +72,14 @@ const actions: ActionTree<GeneralState, RootState> = {
       general: newGeneral
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
-      ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-preferences')
+        win.ipcRenderer.removeAllListeners('response-update-preferences')
         commit(MUTATION_TYPES.CHANGE_LOADING, false)
         reject(err)
       })
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-update-preferences')
+        win.ipcRenderer.removeAllListeners('error-update-preferences')
         commit(MUTATION_TYPES.UPDATE_GENERAL, conf.general as General)
         commit(MUTATION_TYPES.CHANGE_LOADING, false)
         resolve(conf)
@@ -97,19 +96,19 @@ const actions: ActionTree<GeneralState, RootState> = {
       general: newGeneral
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-preferences')
+        win.ipcRenderer.removeAllListeners('response-update-preferences')
         commit(MUTATION_TYPES.CHANGE_LOADING, false)
         reject(err)
       })
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-update-preferences')
+        win.ipcRenderer.removeAllListeners('error-update-preferences')
         commit(MUTATION_TYPES.UPDATE_GENERAL, conf.general as General)
         commit(MUTATION_TYPES.CHANGE_LOADING, false)
         dispatch('App/loadPreferences', null, { root: true })
         resolve(conf)
       })
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
     })
   },
   updateOther: ({ commit, state, dispatch }, other: {}) => {
@@ -122,22 +121,22 @@ const actions: ActionTree<GeneralState, RootState> = {
       general: newGeneral
     }
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('response-change-auto-launch', () => {
+      win.ipcRenderer.once('response-change-auto-launch', () => {
-        ipcRenderer.once('error-update-preferences', (_, err: Error) => {
+        win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
-          ipcRenderer.removeAllListeners('response-update-preferences')
+          win.ipcRenderer.removeAllListeners('response-update-preferences')
           commit(MUTATION_TYPES.CHANGE_LOADING, false)
           reject(err)
         })
-        ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+        win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
-          ipcRenderer.removeAllListeners('error-update-preferences')
+          win.ipcRenderer.removeAllListeners('error-update-preferences')
           commit(MUTATION_TYPES.UPDATE_GENERAL, conf.general as General)
           commit(MUTATION_TYPES.CHANGE_LOADING, false)
           dispatch('App/loadPreferences', null, { root: true })
           resolve(conf)
         })
-        ipcRenderer.send('update-preferences', config)
+        win.ipcRenderer.send('update-preferences', config)
       })
-      ipcRenderer.send('change-auto-launch', newOther.launch)
+      win.ipcRenderer.send('change-auto-launch', newOther.launch)
     })
   }
 }

src/renderer/store/Preferences/Language.ts

@@ -1,9 +1,11 @@
-import { ipcRenderer } from 'electron'
 import Language from '~/src/constants/language'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
 import { Language as LanguageSet } from '~/src/types/language'
 import { BaseConfig } from '~/src/types/preference'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type LanguageState = {
   language: LanguageSet
@@ -32,13 +34,13 @@ const mutations: MutationTree<LanguageState> = {
 const actions: ActionTree<LanguageState, RootState> = {
   loadLanguage: ({ commit }) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('get-preferences')
+      win.ipcRenderer.send('get-preferences')
-      ipcRenderer.once('error-get-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-get-preferences')
+        win.ipcRenderer.removeAllListeners('response-get-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-get-preferences')
+        win.ipcRenderer.removeAllListeners('error-get-preferences')
         commit(MUTATION_TYPES.UPDATE_LANGUAGE, conf.language as LanguageSet)
         resolve(conf)
       })
@@ -46,15 +48,15 @@ const actions: ActionTree<LanguageState, RootState> = {
   },
   changeLanguage: ({ commit }, key: string) => {
     return new Promise(resolve => {
-      ipcRenderer.send('change-language', key)
+      win.ipcRenderer.send('change-language', key)
-      ipcRenderer.once('response-change-language', (_, value: string) => {
+      win.ipcRenderer.once('response-change-language', (_, value: string) => {
         commit(MUTATION_TYPES.CHANGE_LANGUAGE, value)
         resolve(value)
       })
     })
   },
   relaunch: () => {
-    ipcRenderer.send('relaunch')
+    win.ipcRenderer.send('relaunch')
   }
 }
 

src/renderer/store/Preferences/Network.ts

@@ -1,8 +1,10 @@
-import { ipcRenderer } from 'electron'
 import { Module, MutationTree, ActionTree, GetterTree } from 'vuex'
 import { RootState } from '@/store'
 import { BaseConfig } from '~/src/types/preference'
 import { Proxy, ProxySource, ProxyProtocol, ManualProxy } from '~/src/types/proxy'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type NetworkState = {
   source: ProxySource
@@ -92,13 +94,13 @@ const mutations: MutationTree<NetworkState> = {
 const actions: ActionTree<NetworkState, RootState> = {
   loadProxy: ({ commit }) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('get-preferences')
+      win.ipcRenderer.send('get-preferences')
-      ipcRenderer.once('error-get-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-get-preferences')
+        win.ipcRenderer.removeAllListeners('response-get-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-get-preferences')
+        win.ipcRenderer.removeAllListeners('error-get-preferences')
         commit(MUTATION_TYPES.UPDATE_PROXY, conf.proxy as Proxy)
         resolve(conf)
       })
@@ -127,13 +129,13 @@ const actions: ActionTree<NetworkState, RootState> = {
       source: state.source,
       manualProxyConfig: state.proxy
     }
-    ipcRenderer.once('response-update-proxy-config', async () => {
+    win.ipcRenderer.once('response-update-proxy-config', async () => {
       dispatch('App/loadProxy', {}, { root: true })
       // Originally we have to restart all streamings after user change proxy configuration.
       // But streamings are restart after close preferences.
       // So we don't have to restart streaming here.
     })
-    ipcRenderer.send('update-proxy-config', proxy)
+    win.ipcRenderer.send('update-proxy-config', proxy)
   }
 }
 

src/renderer/store/Preferences/Notification.ts

@@ -1,8 +1,10 @@
-import { ipcRenderer } from 'electron'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
 import { Notify } from '~/src/types/notify'
 import { BaseConfig, Notification } from '~/src/types/preference'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type NotificationState = {
   notification: Notification
@@ -32,13 +34,13 @@ const mutations: MutationTree<NotificationState> = {
 const actions: ActionTree<NotificationState, RootState> = {
   loadNotification: ({ commit }) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('get-preferences')
+      win.ipcRenderer.send('get-preferences')
-      ipcRenderer.once('error-get-preferences', (_, err: Error) => {
+      win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-get-preferences')
+        win.ipcRenderer.removeAllListeners('response-get-preferences')
         reject(err)
       })
-      ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
-        ipcRenderer.removeAllListeners('error-get-preferences')
+        win.ipcRenderer.removeAllListeners('error-get-preferences')
         commit(MUTATION_TYPES.UPDATE_NOTIFICATION, conf.notification)
         resolve(conf)
       })
@@ -53,8 +55,8 @@ const actions: ActionTree<NotificationState, RootState> = {
       notification: newNotification
     }
     return new Promise(resolve => {
-      ipcRenderer.send('update-preferences', config)
+      win.ipcRenderer.send('update-preferences', config)
-      ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
+      win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
         commit(MUTATION_TYPES.UPDATE_NOTIFICATION, conf.notification)
         dispatch('App/loadPreferences', null, { root: true })
         resolve(conf.notification)

src/renderer/store/Settings/Timeline.ts

@@ -1,8 +1,10 @@
-import { ipcRenderer } from 'electron'
 import unreadSettings from '~/src/constants/unreadNotification'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
 import { UnreadNotification } from '~/src/types/unreadNotification'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type TimelineState = {
   unreadNotification: UnreadNotification
@@ -29,13 +31,13 @@ const mutations: MutationTree<TimelineState> = {
 const actions: ActionTree<TimelineState, RootState> = {
   loadUnreadNotification: ({ commit, rootState }): Promise<boolean> => {
     return new Promise(resolve => {
-      ipcRenderer.once('response-get-unread-notification', (_, settings: UnreadNotification) => {
+      win.ipcRenderer.once('response-get-unread-notification', (_, settings: UnreadNotification) => {
-        ipcRenderer.removeAllListeners('error-get-unread-notification')
+        win.ipcRenderer.removeAllListeners('error-get-unread-notification')
         commit(MUTATION_TYPES.UPDATE_UNREAD_NOTIFICATION, settings)
         resolve(true)
       })
-      ipcRenderer.once('error-get-unread-notification', () => {
+      win.ipcRenderer.once('error-get-unread-notification', () => {
-        ipcRenderer.removeAllListeners('response-get-unread-notification')
+        win.ipcRenderer.removeAllListeners('response-get-unread-notification')
         const settings: UnreadNotification = {
           direct: unreadSettings.Direct.default,
           local: unreadSettings.Local.default,
@@ -44,7 +46,7 @@ const actions: ActionTree<TimelineState, RootState> = {
         commit(MUTATION_TYPES.UPDATE_UNREAD_NOTIFICATION, settings)
         resolve(false)
       })
-      ipcRenderer.send('get-unread-notification', rootState.Settings.accountID)
+      win.ipcRenderer.send('get-unread-notification', rootState.Settings.accountID)
     })
   },
   changeUnreadNotification: ({ dispatch, state, rootState }, timeline: { key: boolean }): Promise<boolean> => {
@@ -52,16 +54,16 @@ const actions: ActionTree<TimelineState, RootState> = {
       accountID: rootState.Settings.accountID
     })
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('response-update-unread-notification', () => {
+      win.ipcRenderer.once('response-update-unread-notification', () => {
-        ipcRenderer.removeAllListeners('error-update-unread-notification')
+        win.ipcRenderer.removeAllListeners('error-update-unread-notification')
         dispatch('loadUnreadNotification')
         resolve(true)
       })
-      ipcRenderer.once('error-update-unread-notification', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-unread-notification', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-unread-notification')
+        win.ipcRenderer.removeAllListeners('response-update-unread-notification')
         reject(err)
       })
-      ipcRenderer.send('update-unread-notification', settings)
+      win.ipcRenderer.send('update-unread-notification', settings)
     })
   }
 }

src/renderer/store/TimelineSpace.ts

@@ -1,4 +1,3 @@
-import { ipcRenderer } from 'electron'
 import Mastodon, { Account, Emoji, Instance, Status, Notification as NotificationType } from 'megalodon'
 import SideMenu, { SideMenuState } from './TimelineSpace/SideMenu'
 import HeaderMenu, { HeaderMenuState } from './TimelineSpace/HeaderMenu'
@@ -11,6 +10,9 @@ import { RootState } from '@/store'
 import { UnreadNotification } from '~/src/types/unreadNotification'
 import { AccountLoadError } from '@/errors/load'
 import { TimelineFetchError } from '@/errors/fetch'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type TimelineSpaceState = {
   account: LocalAccount
@@ -120,13 +122,13 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
   // -------------------------------------------------
   localAccount: async ({ dispatch, commit }, id: string): Promise<LocalAccount> => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('get-local-account', id)
+      win.ipcRenderer.send('get-local-account', id)
-      ipcRenderer.once('error-get-local-account', (_, err: Error) => {
+      win.ipcRenderer.once('error-get-local-account', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-get-local-account')
+        win.ipcRenderer.removeAllListeners('response-get-local-account')
         reject(err)
       })
-      ipcRenderer.once('response-get-local-account', (_, account: LocalAccount) => {
+      win.ipcRenderer.once('response-get-local-account', (_, account: LocalAccount) => {
-        ipcRenderer.removeAllListeners('error-get-local-account')
+        win.ipcRenderer.removeAllListeners('error-get-local-account')
 
         if (account.username === undefined || account.username === null || account.username === '') {
           dispatch('fetchAccount', account)
@@ -146,13 +148,13 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
   },
   fetchAccount: (_, account: LocalAccount): Promise<LocalAccount> => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.send('update-account', account)
+      win.ipcRenderer.send('update-account', account)
-      ipcRenderer.once('error-update-account', (_, err: Error) => {
+      win.ipcRenderer.once('error-update-account', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-update-account')
+        win.ipcRenderer.removeAllListeners('response-update-account')
         reject(err)
       })
-      ipcRenderer.once('response-update-account', (_, account: LocalAccount) => {
+      win.ipcRenderer.once('response-update-account', (_, account: LocalAccount) => {
-        ipcRenderer.removeAllListeners('error-update-account')
+        win.ipcRenderer.removeAllListeners('error-update-account')
         resolve(account)
       })
     })
@@ -173,16 +175,16 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
   // Shortcuts
   // -----------------------------------------------
   watchShortcutEvents: ({ commit, dispatch }) => {
-    ipcRenderer.on('CmdOrCtrl+N', () => {
+    win.ipcRenderer.on('CmdOrCtrl+N', () => {
       dispatch('TimelineSpace/Modals/NewToot/openModal', {}, { root: true })
     })
-    ipcRenderer.on('CmdOrCtrl+K', () => {
+    win.ipcRenderer.on('CmdOrCtrl+K', () => {
       commit('TimelineSpace/Modals/Jump/changeModal', true, { root: true })
     })
   },
   removeShortcutEvents: async () => {
-    ipcRenderer.removeAllListeners('CmdOrCtrl+N')
+    win.ipcRenderer.removeAllListeners('CmdOrCtrl+N')
-    ipcRenderer.removeAllListeners('CmdOrCtrl+K')
+    win.ipcRenderer.removeAllListeners('CmdOrCtrl+K')
     return true
   },
   /**
@@ -209,13 +211,13 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
   },
   loadUnreadNotification: ({ commit }, accountID: string) => {
     return new Promise(resolve => {
-      ipcRenderer.once('response-get-unread-notification', (_, settings: UnreadNotification) => {
+      win.ipcRenderer.once('response-get-unread-notification', (_, settings: UnreadNotification) => {
-        ipcRenderer.removeAllListeners('error-get-unread-notification')
+        win.ipcRenderer.removeAllListeners('error-get-unread-notification')
         commit(MUTATION_TYPES.UPDATE_UNREAD_NOTIFICATION, settings)
         resolve(settings)
       })
-      ipcRenderer.once('error-get-unread-notification', () => {
+      win.ipcRenderer.once('error-get-unread-notification', () => {
-        ipcRenderer.removeAllListeners('response-get-unread-notification')
+        win.ipcRenderer.removeAllListeners('response-get-unread-notification')
         commit(MUTATION_TYPES.UPDATE_UNREAD_NOTIFICATION, {
           direct: unreadSettings.Direct.default,
           local: unreadSettings.Local.default,
@@ -223,7 +225,7 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
         } as UnreadNotification)
         resolve({})
       })
-      ipcRenderer.send('get-unread-notification', accountID)
+      win.ipcRenderer.send('get-unread-notification', accountID)
     })
   },
   fetchContentsTimelines: async ({ dispatch, state }) => {
@@ -297,7 +299,7 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
     await dispatch('waitToUnbindUserStreaming')
 
     commit(MUTATION_TYPES.UPDATE_BINDING_ACCOUNT, state.account)
-    ipcRenderer.on(`update-start-all-user-streamings-${state.account._id!}`, (_, update: Status) => {
+    win.ipcRenderer.on(`update-start-all-user-streamings-${state.account._id!}`, (_, update: Status) => {
       commit('TimelineSpace/Contents/Home/appendTimeline', update, { root: true })
       // Sometimes archive old statuses
       if (rootState.TimelineSpace.Contents.Home.heading && Math.random() > 0.8) {
@@ -305,35 +307,35 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
       }
       commit('TimelineSpace/SideMenu/changeUnreadHomeTimeline', true, { root: true })
     })
-    ipcRenderer.on(`notification-start-all-user-streamings-${state.account._id!}`, (_, notification: NotificationType) => {
+    win.ipcRenderer.on(`notification-start-all-user-streamings-${state.account._id!}`, (_, notification: NotificationType) => {
       commit('TimelineSpace/Contents/Notifications/appendNotifications', notification, { root: true })
       if (rootState.TimelineSpace.Contents.Notifications.heading && Math.random() > 0.8) {
         commit('TimelineSpace/Contents/Notifications/archiveNotifications', null, { root: true })
       }
       commit('TimelineSpace/SideMenu/changeUnreadNotifications', true, { root: true })
     })
-    ipcRenderer.on(`mention-start-all-user-streamings-${state.account._id!}`, (_, mention: NotificationType) => {
+    win.ipcRenderer.on(`mention-start-all-user-streamings-${state.account._id!}`, (_, mention: NotificationType) => {
       commit('TimelineSpace/Contents/Mentions/appendMentions', mention, { root: true })
       if (rootState.TimelineSpace.Contents.Mentions.heading && Math.random() > 0.8) {
         commit('TimelineSpace/Contents/Mentions/archiveMentions', null, { root: true })
       }
       commit('TimelineSpace/SideMenu/changeUnreadMentions', true, { root: true })
     })
-    ipcRenderer.on(`delete-start-all-user-streamings-${state.account._id!}`, (_, id: string) => {
+    win.ipcRenderer.on(`delete-start-all-user-streamings-${state.account._id!}`, (_, id: string) => {
       commit('TimelineSpace/Contents/Home/deleteToot', id, { root: true })
       commit('TimelineSpace/Contents/Notifications/deleteToot', id, { root: true })
       commit('TimelineSpace/Contents/Mentions/deleteToot', id, { root: true })
     })
   },
   bindLocalStreaming: ({ commit, rootState }) => {
-    ipcRenderer.on('update-start-local-streaming', (_, update: Status) => {
+    win.ipcRenderer.on('update-start-local-streaming', (_, update: Status) => {
       commit('TimelineSpace/Contents/Local/appendTimeline', update, { root: true })
       if (rootState.TimelineSpace.Contents.Local.heading && Math.random() > 0.8) {
         commit('TimelineSpace/Contents/Local/archiveTimeline', {}, { root: true })
       }
       commit('TimelineSpace/SideMenu/changeUnreadLocalTimeline', true, { root: true })
     })
-    ipcRenderer.on('delete-start-local-streaming', (_, id: string) => {
+    win.ipcRenderer.on('delete-start-local-streaming', (_, id: string) => {
       commit('TimelineSpace/Contents/Local/deleteToot', id, { root: true })
     })
   },
@@ -341,23 +343,23 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
     // @ts-ignore
     return new Promise((resolve, reject) => {
       // eslint-disable-line no-unused-vars
-      ipcRenderer.send('start-local-streaming', {
+      win.ipcRenderer.send('start-local-streaming', {
         account: state.account
       })
-      ipcRenderer.once('error-start-local-streaming', (_, err: Error) => {
+      win.ipcRenderer.once('error-start-local-streaming', (_, err: Error) => {
         reject(err)
       })
     })
   },
   bindPublicStreaming: ({ commit, rootState }) => {
-    ipcRenderer.on('update-start-public-streaming', (_, update: Status) => {
+    win.ipcRenderer.on('update-start-public-streaming', (_, update: Status) => {
       commit('TimelineSpace/Contents/Public/appendTimeline', update, { root: true })
       if (rootState.TimelineSpace.Contents.Public.heading && Math.random() > 0.8) {
         commit('TimelineSpace/Contents/Public/archiveTimeline', {}, { root: true })
       }
       commit('TimelineSpace/SideMenu/changeUnreadPublicTimeline', true, { root: true })
     })
-    ipcRenderer.on('delete-start-public-streaming', (_, id: string) => {
+    win.ipcRenderer.on('delete-start-public-streaming', (_, id: string) => {
       commit('TimelineSpace/Contents/Public/deleteToot', id, { root: true })
     })
   },
@@ -365,23 +367,23 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
     // @ts-ignore
     return new Promise((resolve, reject) => {
       // eslint-disable-line no-unused-vars
-      ipcRenderer.send('start-public-streaming', {
+      win.ipcRenderer.send('start-public-streaming', {
         account: state.account
       })
-      ipcRenderer.once('error-start-public-streaming', (_, err: Error) => {
+      win.ipcRenderer.once('error-start-public-streaming', (_, err: Error) => {
         reject(err)
       })
     })
   },
   bindDirectMessagesStreaming: ({ commit, rootState }) => {
-    ipcRenderer.on('update-start-directmessages-streaming', (_, update: Status) => {
+    win.ipcRenderer.on('update-start-directmessages-streaming', (_, update: Status) => {
       commit('TimelineSpace/Contents/DirectMessages/appendTimeline', update, { root: true })
       if (rootState.TimelineSpace.Contents.DirectMessages.heading && Math.random() > 0.8) {
         commit('TimelineSpace/Contents/DirectMessages/archiveTimeline', {}, { root: true })
       }
       commit('TimelineSpace/SideMenu/changeUnreadDirectMessagesTimeline', true, { root: true })
     })
-    ipcRenderer.on('delete-start-directmessages-streaming', (_, id: string) => {
+    win.ipcRenderer.on('delete-start-directmessages-streaming', (_, id: string) => {
       commit('TimelineSpace/Contents/DirectMessages/deleteToot', id, { root: true })
     })
   },
@@ -389,10 +391,10 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
     // @ts-ignore
     return new Promise((resolve, reject) => {
       // eslint-disable-line no-unused-vars
-      ipcRenderer.send('start-directmessages-streaming', {
+      win.ipcRenderer.send('start-directmessages-streaming', {
         account: state.account
       })
-      ipcRenderer.once('error-start-directmessages-streaming', (_, err: Error) => {
+      win.ipcRenderer.once('error-start-directmessages-streaming', (_, err: Error) => {
         reject(err)
       })
     })
@@ -401,10 +403,10 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
     // When unbind is called, sometimes account is already cleared and account does not have _id.
     // So we have to get previous account to unbind streamings.
     if (state.bindingAccount) {
-      ipcRenderer.removeAllListeners(`update-start-all-user-streamings-${state.bindingAccount._id!}`)
+      win.ipcRenderer.removeAllListeners(`update-start-all-user-streamings-${state.bindingAccount._id!}`)
-      ipcRenderer.removeAllListeners(`mention-start-all-user-streamings-${state.bindingAccount._id!}`)
+      win.ipcRenderer.removeAllListeners(`mention-start-all-user-streamings-${state.bindingAccount._id!}`)
-      ipcRenderer.removeAllListeners(`notification-start-all-user-streamings-${state.bindingAccount._id!}`)
+      win.ipcRenderer.removeAllListeners(`notification-start-all-user-streamings-${state.bindingAccount._id!}`)
-      ipcRenderer.removeAllListeners(`delete-start-all-user-streamings-${state.bindingAccount._id!}`)
+      win.ipcRenderer.removeAllListeners(`delete-start-all-user-streamings-${state.bindingAccount._id!}`)
       // And we have to clear binding account after unbind.
       commit(MUTATION_TYPES.UPDATE_BINDING_ACCOUNT, null)
     } else {
@@ -412,28 +414,28 @@ const actions: ActionTree<TimelineSpaceState, RootState> = {
     }
   },
   unbindLocalStreaming: () => {
-    ipcRenderer.removeAllListeners('error-start-local-streaming')
+    win.ipcRenderer.removeAllListeners('error-start-local-streaming')
-    ipcRenderer.removeAllListeners('update-start-local-streaming')
+    win.ipcRenderer.removeAllListeners('update-start-local-streaming')
-    ipcRenderer.removeAllListeners('delete-start-local-streaming')
+    win.ipcRenderer.removeAllListeners('delete-start-local-streaming')
   },
   stopLocalStreaming: () => {
-    ipcRenderer.send('stop-local-streaming')
+    win.ipcRenderer.send('stop-local-streaming')
   },
   unbindPublicStreaming: () => {
-    ipcRenderer.removeAllListeners('error-start-public-streaming')
+    win.ipcRenderer.removeAllListeners('error-start-public-streaming')
-    ipcRenderer.removeAllListeners('update-start-public-streaming')
+    win.ipcRenderer.removeAllListeners('update-start-public-streaming')
-    ipcRenderer.removeAllListeners('delete-start-public-streaming')
+    win.ipcRenderer.removeAllListeners('delete-start-public-streaming')
   },
   stopPublicStreaming: () => {
-    ipcRenderer.send('stop-public-streaming')
+    win.ipcRenderer.send('stop-public-streaming')
   },
   unbindDirectMessagesStreaming: () => {
-    ipcRenderer.removeAllListeners('error-start-directmessages-streaming')
+    win.ipcRenderer.removeAllListeners('error-start-directmessages-streaming')
-    ipcRenderer.removeAllListeners('update-start-directmessages-streaming')
+    win.ipcRenderer.removeAllListeners('update-start-directmessages-streaming')
-    ipcRenderer.removeAllListeners('delete-start-directmessages-streaming')
+    win.ipcRenderer.removeAllListeners('delete-start-directmessages-streaming')
   },
   stopDirectMessagesStreaming: () => {
-    ipcRenderer.send('stop-directmessages-streaming')
+    win.ipcRenderer.send('stop-directmessages-streaming')
   },
   updateTootForAllTimelines: ({ commit, state }, status: Status): boolean => {
     commit('TimelineSpace/Contents/Home/updateToot', status, { root: true })

src/renderer/store/TimelineSpace/Contents/Hashtag.ts

@@ -1,8 +1,10 @@
-import { ipcRenderer } from 'electron'
 import List, { ListState } from './Hashtag/List'
 import Tag, { TagState } from './Hashtag/Tag'
 import { Module, ActionTree } from 'vuex'
 import { RootState } from '@/store'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type HashtagState = {}
 
@@ -17,10 +19,10 @@ const state = (): HashtagState => ({})
 
 const actions: ActionTree<HashtagState, RootState> = {
   saveTag: ({ dispatch }, tag: string) => {
-    ipcRenderer.once('response-save-hashtag', () => {
+    win.ipcRenderer.once('response-save-hashtag', () => {
       dispatch('TimelineSpace/SideMenu/listTags', {}, { root: true })
     })
-    ipcRenderer.send('save-hashtag', tag)
+    win.ipcRenderer.send('save-hashtag', tag)
   }
 }
 

src/renderer/store/TimelineSpace/Contents/Hashtag/List.ts

@@ -1,7 +1,9 @@
-import { ipcRenderer } from 'electron'
 import { LocalTag } from '~/src/types/localTag'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type ListState = {
   tags: Array<LocalTag>
@@ -24,31 +26,31 @@ const mutations: MutationTree<ListState> = {
 const actions: ActionTree<ListState, RootState> = {
   listTags: ({ commit }) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('response-list-hashtags', (_, tags: Array<LocalTag>) => {
+      win.ipcRenderer.once('response-list-hashtags', (_, tags: Array<LocalTag>) => {
-        ipcRenderer.removeAllListeners('error-list-hashtags')
+        win.ipcRenderer.removeAllListeners('error-list-hashtags')
         commit(MUTATION_TYPES.UPDATE_TAGS, tags)
         resolve(tags)
       })
-      ipcRenderer.once('error-list-hashtags', (_, err: Error) => {
+      win.ipcRenderer.once('error-list-hashtags', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-list-hashtags')
+        win.ipcRenderer.removeAllListeners('response-list-hashtags')
         reject(err)
       })
-      ipcRenderer.send('list-hashtags')
+      win.ipcRenderer.send('list-hashtags')
     })
   },
   removeTag: ({ dispatch }, tag: LocalTag) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('response-remove-hashtag', () => {
+      win.ipcRenderer.once('response-remove-hashtag', () => {
-        ipcRenderer.removeAllListeners('error-remove-hashtag')
+        win.ipcRenderer.removeAllListeners('error-remove-hashtag')
         dispatch('listTags')
         dispatch('TimelineSpace/SideMenu/listTags', {}, { root: true })
         resolve('deleted')
       })
-      ipcRenderer.once('error-remove-hashtag', (_, err: Error) => {
+      win.ipcRenderer.once('error-remove-hashtag', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-remove-hashtag')
+        win.ipcRenderer.removeAllListeners('response-remove-hashtag')
         reject(err)
       })
-      ipcRenderer.send('remove-hashtag', tag)
+      win.ipcRenderer.send('remove-hashtag', tag)
     })
   }
 }

src/renderer/store/TimelineSpace/Contents/Hashtag/Tag.ts

@@ -1,8 +1,10 @@
-import { ipcRenderer } from 'electron'
 import Mastodon, { Status, Response } from 'megalodon'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
 import { LoadPositionWithTag } from '@/types/loadPosition'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type TagState = {
   timeline: Array<Status>
@@ -111,33 +113,33 @@ const actions: ActionTree<TagState, RootState> = {
     return res.data
   },
   startStreaming: ({ state, commit, rootState }, tag: string) => {
-    ipcRenderer.on('update-start-tag-streaming', (_, update: Status) => {
+    win.ipcRenderer.on('update-start-tag-streaming', (_, update: Status) => {
       commit(MUTATION_TYPES.APPEND_TIMELINE, update)
       if (state.heading && Math.random() > 0.8) {
         commit(MUTATION_TYPES.ARCHIVE_TIMELINE)
       }
     })
-    ipcRenderer.on('delete-start-tag-streaming', (_, id: string) => {
+    win.ipcRenderer.on('delete-start-tag-streaming', (_, id: string) => {
       commit(MUTATION_TYPES.DELETE_TOOT, id)
     })
     // @ts-ignore
     return new Promise((resolve, reject) => {
       // eslint-disable-line no-unused-vars
-      ipcRenderer.send('start-tag-streaming', {
+      win.ipcRenderer.send('start-tag-streaming', {
         tag: encodeURIComponent(tag),
         account: rootState.TimelineSpace.account
       })
-      ipcRenderer.once('error-start-tag-streaming', (_, err: Error) => {
+      win.ipcRenderer.once('error-start-tag-streaming', (_, err: Error) => {
         reject(err)
       })
     })
   },
   stopStreaming: () => {
     return new Promise(resolve => {
-      ipcRenderer.removeAllListeners('error-start-tag-streaming')
+      win.ipcRenderer.removeAllListeners('error-start-tag-streaming')
-      ipcRenderer.removeAllListeners('update-start-tag-streaming')
+      win.ipcRenderer.removeAllListeners('update-start-tag-streaming')
-      ipcRenderer.removeAllListeners('delete-start-tag-streaming')
+      win.ipcRenderer.removeAllListeners('delete-start-tag-streaming')
-      ipcRenderer.send('stop-tag-streaming')
+      win.ipcRenderer.send('stop-tag-streaming')
       resolve()
     })
   },

src/renderer/store/TimelineSpace/Contents/Lists/Show.ts

@@ -1,8 +1,10 @@
-import { ipcRenderer } from 'electron'
 import Mastodon, { Status, Response } from 'megalodon'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
 import { LoadPositionWithList } from '@/types/loadPosition'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type ShowState = {
   timeline: Array<Status>
@@ -111,33 +113,33 @@ const actions: ActionTree<ShowState, RootState> = {
     return res.data
   },
   startStreaming: ({ state, commit, rootState }, listID: string) => {
-    ipcRenderer.on('update-start-list-streaming', (_, update: Status) => {
+    win.ipcRenderer.on('update-start-list-streaming', (_, update: Status) => {
       commit(MUTATION_TYPES.APPEND_TIMELINE, update)
       if (state.heading && Math.random() > 0.8) {
         commit(MUTATION_TYPES.ARCHIVE_TIMELINE)
       }
     })
-    ipcRenderer.on('delete-start-list-streaming', (_, id: string) => {
+    win.ipcRenderer.on('delete-start-list-streaming', (_, id: string) => {
       commit(MUTATION_TYPES.DELETE_TOOT, id)
     })
     // @ts-ignore
     return new Promise((resolve, reject) => {
       // eslint-disable-line no-unused-vars
-      ipcRenderer.send('start-list-streaming', {
+      win.ipcRenderer.send('start-list-streaming', {
         listID: listID,
         account: rootState.TimelineSpace.account
       })
-      ipcRenderer.once('error-start-list-streaming', (_, err: Error) => {
+      win.ipcRenderer.once('error-start-list-streaming', (_, err: Error) => {
         reject(err)
       })
     })
   },
   stopStreaming: () => {
     return new Promise(resolve => {
-      ipcRenderer.removeAllListeners('error-start-list-streaming')
+      win.ipcRenderer.removeAllListeners('error-start-list-streaming')
-      ipcRenderer.removeAllListeners('update-start-list-streaming')
+      win.ipcRenderer.removeAllListeners('update-start-list-streaming')
-      ipcRenderer.removeAllListeners('delete-start-list-streaming')
+      win.ipcRenderer.removeAllListeners('delete-start-list-streaming')
-      ipcRenderer.send('stop-list-streaming')
+      win.ipcRenderer.send('stop-list-streaming')
       resolve()
     })
   },

src/renderer/store/TimelineSpace/Contents/Notifications.ts

@@ -1,7 +1,9 @@
-import { ipcRenderer } from 'electron'
 import Mastodon, { Notification, Status, Response } from 'megalodon'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { RootState } from '@/store'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type NotificationsState = {
   lazyLoading: boolean
@@ -136,7 +138,7 @@ const actions: ActionTree<NotificationsState, RootState> = {
       })
   },
   resetBadge: () => {
-    ipcRenderer.send('reset-badge')
+    win.ipcRenderer.send('reset-badge')
   }
 }
 

src/renderer/store/TimelineSpace/Modals/NewToot.ts

@@ -1,5 +1,4 @@
 import Mastodon, { Status, Attachment, Tag, Response, Account } from 'megalodon'
-import { ipcRenderer } from 'electron'
 import Visibility, { VisibilityType } from '~/src/constants/visibility'
 import TootStatus, { StatusState } from './NewToot/Status'
 import { Module, MutationTree, ActionTree, GetterTree } from 'vuex'
@@ -15,6 +14,9 @@ import {
   NewTootUnknownType,
   AuthenticationError
 } from '@/errors/validations'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 type MediaDescription = {
   id: string
@@ -267,7 +269,7 @@ const actions: ActionTree<NewTootState, RootState> = {
     return client
       .post<Status>('/statuses', form)
       .then((res: Response<Status>) => {
-        ipcRenderer.send('toot-action-sound')
+        win.ipcRenderer.send('toot-action-sound')
         return res.data
       })
       .finally(() => {

src/renderer/store/TimelineSpace/Modals/NewToot/Status.ts

@@ -1,4 +1,3 @@
-import { ipcRenderer } from 'electron'
 import emojilib from 'emojilib'
 import Mastodon, { Account, Response, Results } from 'megalodon'
 import { Module, MutationTree, ActionTree, GetterTree } from 'vuex'
@@ -6,6 +5,9 @@ import { RootState } from '@/store/index'
 import { LocalTag } from '~/src/types/localTag'
 import { InsertAccountCache } from '~/src/types/insertAccountCache'
 import { CachedAccount } from '~/src/types/cachedAccount'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 type Suggest = {
   name: string
@@ -151,7 +153,7 @@ const actions: ActionTree<StatusState, RootState> = {
     const searchCache = () => {
       return new Promise(resolve => {
         const target = word.replace('@', '')
-        ipcRenderer.once('response-get-cache-accounts', (_, accounts: Array<CachedAccount>) => {
+        win.ipcRenderer.once('response-get-cache-accounts', (_, accounts: Array<CachedAccount>) => {
           const matched = accounts.map(account => account.acct).filter(acct => acct.includes(target))
           if (matched.length === 0) throw new Error('Empty')
           commit(MUTATION_TYPES.APPEND_FILTERED_ACCOUNTS, matched)
@@ -161,7 +163,7 @@ const actions: ActionTree<StatusState, RootState> = {
           commit(MUTATION_TYPES.FILTERED_SUGGESTION_FROM_ACCOUNTS)
           resolve(matched)
         })
-        ipcRenderer.send('get-cache-accounts', rootState.TimelineSpace.account._id)
+        win.ipcRenderer.send('get-cache-accounts', rootState.TimelineSpace.account._id)
       })
     }
     const searchAPI = async () => {
@@ -174,8 +176,11 @@ const actions: ActionTree<StatusState, RootState> = {
       commit(MUTATION_TYPES.SET_CLIENT, client)
       const res: Response<Array<Account>> = await client.get<Array<Account>>('/accounts/search', { q: word, resolve: false })
       if (res.data.length === 0) throw new Error('Empty')
-      commit(MUTATION_TYPES.APPEND_FILTERED_ACCOUNTS, res.data.map(account => account.acct))
+      commit(
-      ipcRenderer.send('insert-cache-accounts', {
+        MUTATION_TYPES.APPEND_FILTERED_ACCOUNTS,
+        res.data.map(account => account.acct)
+      )
+      win.ipcRenderer.send('insert-cache-accounts', {
         ownerID: rootState.TimelineSpace.account._id!,
         accts: res.data.map(a => a.acct)
       } as InsertAccountCache)
@@ -195,7 +200,7 @@ const actions: ActionTree<StatusState, RootState> = {
     const searchCache = () => {
       return new Promise(resolve => {
         const target = word.replace('#', '')
-        ipcRenderer.once('response-get-cache-hashtags', (_, tags: Array<LocalTag>) => {
+        win.ipcRenderer.once('response-get-cache-hashtags', (_, tags: Array<LocalTag>) => {
           const matched = tags.map(tag => tag.tagName).filter(tag => tag.includes(target))
           if (matched.length === 0) throw new Error('Empty')
           commit(MUTATION_TYPES.APPEND_FILTERED_HASHTAGS, matched)
@@ -205,7 +210,7 @@ const actions: ActionTree<StatusState, RootState> = {
           commit(MUTATION_TYPES.FILTERED_SUGGESTION_FROM_HASHTAGS)
           resolve(matched)
         })
-        ipcRenderer.send('get-cache-hashtags')
+        win.ipcRenderer.send('get-cache-hashtags')
       })
     }
     const searchAPI = async () => {
@@ -218,8 +223,14 @@ const actions: ActionTree<StatusState, RootState> = {
       commit(MUTATION_TYPES.SET_CLIENT, client)
       const res: Response<Results> = await client.get<Results>('/search', { q: word })
       if (res.data.hashtags.length === 0) throw new Error('Empty')
-      commit(MUTATION_TYPES.APPEND_FILTERED_HASHTAGS, res.data.hashtags.map(tag => tag.name))
+      commit(
-      ipcRenderer.send('insert-cache-hashtags', res.data.hashtags.map(tag => tag.name))
+        MUTATION_TYPES.APPEND_FILTERED_HASHTAGS,
+        res.data.hashtags.map(tag => tag.name)
+      )
+      win.ipcRenderer.send(
+        'insert-cache-hashtags',
+        res.data.hashtags.map(tag => tag.name)
+      )
       commit(MUTATION_TYPES.CHANGE_OPEN_SUGGEST, true)
       commit(MUTATION_TYPES.CHANGE_START_INDEX, start)
       commit(MUTATION_TYPES.CHANGE_MATCH_WORD, word)

src/renderer/store/TimelineSpace/SideMenu.ts

@@ -1,9 +1,11 @@
 import Mastodon, { List, Response, Account } from 'megalodon'
-import { ipcRenderer } from 'electron'
 import { Module, MutationTree, ActionTree } from 'vuex'
 import { LocalTag } from '~/src/types/localTag'
 import { LocalAccount } from '~/src/types/localAccount'
 import { RootState } from '@/store'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 export type SideMenuState = {
   unreadHomeTimeline: boolean
@@ -111,13 +113,13 @@ const actions: ActionTree<SideMenuState, RootState> = {
     commit(MUTATION_TYPES.CHANGE_UNREAD_PUBLIC_TIMELINE, false)
   },
   changeCollapse: ({ commit }, value: boolean) => {
-    ipcRenderer.send('change-collapse', value)
+    win.ipcRenderer.send('change-collapse', value)
     commit(MUTATION_TYPES.CHANGE_COLLAPSE, value)
   },
   readCollapse: ({ commit }) => {
     return new Promise(resolve => {
-      ipcRenderer.send('get-collapse')
+      win.ipcRenderer.send('get-collapse')
-      ipcRenderer.once('response-get-collapse', (_, value: boolean) => {
+      win.ipcRenderer.once('response-get-collapse', (_, value: boolean) => {
         commit(MUTATION_TYPES.CHANGE_COLLAPSE, value)
         resolve(value)
       })
@@ -125,16 +127,16 @@ const actions: ActionTree<SideMenuState, RootState> = {
   },
   listTags: ({ commit }) => {
     return new Promise((resolve, reject) => {
-      ipcRenderer.once('response-list-hashtags', (_, tags: Array<LocalTag>) => {
+      win.ipcRenderer.once('response-list-hashtags', (_, tags: Array<LocalTag>) => {
-        ipcRenderer.removeAllListeners('error-list-hashtags')
+        win.ipcRenderer.removeAllListeners('error-list-hashtags')
         commit(MUTATION_TYPES.UPDATE_TAGS, tags)
         resolve(tags)
       })
-      ipcRenderer.once('error-list-hashtags', (_, err: Error) => {
+      win.ipcRenderer.once('error-list-hashtags', (_, err: Error) => {
-        ipcRenderer.removeAllListeners('response-list-hashtags')
+        win.ipcRenderer.removeAllListeners('response-list-hashtags')
         reject(err)
       })
-      ipcRenderer.send('list-hashtags')
+      win.ipcRenderer.send('list-hashtags')
     })
   }
 }

src/renderer/store/organisms/Toot.ts

@@ -1,7 +1,9 @@
 import Mastodon, { Response, Status, Account, Poll } from 'megalodon'
-import { ipcRenderer } from 'electron'
 import { Module, ActionTree } from 'vuex'
 import { RootState } from '@/store'
+import { MyWindow } from '~/src/types/global'
+
+const win = window as MyWindow
 
 type VoteParam = {
   id: string
@@ -24,7 +26,7 @@ const actions: ActionTree<TootState, RootState> = {
     // API returns new status when reblog.
     // Reblog target status is in the data.reblog.
     // So I send data.reblog as status for update local timeline.
-    ipcRenderer.send('fav-rt-action-sound')
+    win.ipcRenderer.send('fav-rt-action-sound')
     dispatch('TimelineSpace/updateTootForAllTimelines', res.data.reblog, { root: true })
     return res.data.reblog
   },
@@ -47,7 +49,7 @@ const actions: ActionTree<TootState, RootState> = {
       rootState.App.proxyConfiguration
     )
     const res: Response<Status> = await client.post<Status>(`/statuses/${message.id}/favourite`)
-    ipcRenderer.send('fav-rt-action-sound')
+    win.ipcRenderer.send('fav-rt-action-sound')
     dispatch('TimelineSpace/updateTootForAllTimelines', res.data, { root: true })
     return res.data
   },