Mastodon/Whalebird-desktop-client-mac-linux-windows
1
0
Fork 0
mirror of https://github.com/h3poteto/whalebird-desktop synced 2025-02-07 23:38:48 +01:00
Code Issues Releases Wiki Activity

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

Browse Source 
Update jest version to 24.9.0 and fix some tests
This commit is contained in:
AkiraFukushima 2019-12-04 23:23:21 +09:00 committed by GitHub
commit 80f978b7e9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
36 changed files with 1057 additions and 1164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1550
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

5
package.json
View File

@ -144,8 +144,7 @@
"moduleNameMapper": {
"@/router": "<rootDir>/spec/mock/router.ts",
"^@/(.+)": "<rootDir>/src/renderer/$1",
"^~/(.+)": "<rootDir>/$1",
"electron": "<rootDir>/spec/mock/electron.ts"
"^~/(.+)": "<rootDir>/$1"
},
"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",

5
spec/main/unit/proxy.spec.ts
View File

@ -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')

4
spec/renderer/integration/store/App.spec.ts
View File

@ -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 {

4
spec/renderer/integration/store/GlobalHeader.spec.ts
View File

@ -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 {

4
spec/renderer/integration/store/Login.spec.ts
View File

@ -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')

4
spec/renderer/integration/store/Preferences/Account.spec.ts
View File

@ -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',

4
spec/renderer/integration/store/Preferences/Appearance.spec.ts
View File

@ -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 {

4
spec/renderer/integration/store/Preferences/General.spec.ts
View File

@ -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 {

4
spec/renderer/integration/store/Preferences/Language.spec.ts
View File

@ -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 {

4
spec/renderer/integration/store/Preferences/Notification.spec.ts
View File

@ -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 {

4
spec/renderer/integration/store/TimelineSpace.spec.ts
View File

@ -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')

4
spec/renderer/integration/store/TimelineSpace/Contents/Hashtag/List.spec.ts
View File

@ -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',

4
spec/renderer/integration/store/TimelineSpace/SideMenu.spec.ts
View File

@ -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')

1
src/main/preload.js
View File

@ -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

22
src/renderer/store/App.ts
View File

@ -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')
ipcRenderer.once('error-get-preferences', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-get-preferences')
win.ipcRenderer.send('get-preferences')
win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-get-preferences')
reject(err)
})
ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-get-preferences')
win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
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')
})
}
}

14
src/renderer/store/Authorize.ts
View File

@ -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())
ipcRenderer.once('response-get-access-token', (_, id: string) => {
ipcRenderer.removeAllListeners('error-get-access-token')
win.ipcRenderer.send('get-access-token', code.trim())
win.ipcRenderer.once('response-get-access-token', (_, id: string) => {
win.ipcRenderer.removeAllListeners('error-get-access-token')
resolve(id)
})
ipcRenderer.once('error-get-access-token', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-get-access-token')
win.ipcRenderer.once('error-get-access-token', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-get-access-token')
reject(err)
})
})

46
src/renderer/store/GlobalHeader.ts
View File

@ -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')
ipcRenderer.once('error-list-accounts', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-list-accounts')
win.ipcRenderer.send('list-accounts', 'list')
win.ipcRenderer.once('error-list-accounts', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-list-accounts')
reject(err)
})
ipcRenderer.once('response-list-accounts', (_, accounts: Array<LocalAccount>) => {
ipcRenderer.removeAllListeners('error-list-accounts')
win.ipcRenderer.once('response-list-accounts', (_, accounts: Array<LocalAccount>) => {
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')
ipcRenderer.once('error-refresh-accounts', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-refresh-accounts')
win.ipcRenderer.send('refresh-accounts')
win.ipcRenderer.once('error-refresh-accounts', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-refresh-accounts')
reject(err)
})
ipcRenderer.once('response-refresh-accounts', (_, accounts: Array<LocalAccount>) => {
ipcRenderer.removeAllListeners('error-refresh-accounts')
win.ipcRenderer.once('response-refresh-accounts', (_, accounts: Array<LocalAccount>) => {
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')
ipcRenderer.once('response-get-global-header', (_, hide: boolean) => {
win.ipcRenderer.send('get-global-header')
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)
ipcRenderer.once('response-change-global-header', () => {
win.ipcRenderer.send('change-global-header', hide)
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')
ipcRenderer.on('open-notification-tab', (_, id: string) => {
win.ipcRenderer.removeAllListeners('open-notification-tab')
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)

14
src/renderer/store/Login.ts
View File

@ -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)
ipcRenderer.once('error-get-auth-url', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-get-auth-url')
win.ipcRenderer.send('get-auth-url', instance)
win.ipcRenderer.once('error-get-auth-url', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-get-auth-url')
reject(err)
})
ipcRenderer.once('response-get-auth-url', (_, url: string) => {
ipcRenderer.removeAllListeners('response-get-auth-url')
win.ipcRenderer.once('response-get-auth-url', (_, url: string) => {
win.ipcRenderer.removeAllListeners('response-get-auth-url')
resolve(url)
})
})

54
src/renderer/store/Preferences/Account.ts
View File

@ -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')
ipcRenderer.once('error-list-accounts', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-list-accounts')
win.ipcRenderer.send('list-accounts', 'list')
win.ipcRenderer.once('error-list-accounts', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-list-accounts')
reject(err)
})
ipcRenderer.once('response-list-accounts', (_, accounts: Array<LocalAccount>) => {
ipcRenderer.removeAllListeners('error-list-accounts')
win.ipcRenderer.once('response-list-accounts', (_, accounts: Array<LocalAccount>) => {
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)
ipcRenderer.once('error-remove-account', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-remove-account')
win.ipcRenderer.send('remove-account', account._id)
win.ipcRenderer.once('error-remove-account', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-remove-account')
reject(err)
})
ipcRenderer.once('response-remove-account', (_, _id: string) => {
ipcRenderer.removeAllListeners('error-remove-account')
win.ipcRenderer.once('response-remove-account', (_, _id: string) => {
win.ipcRenderer.removeAllListeners('error-remove-account')
resolve()
})
})
},
forwardAccount: (_, account: LocalAccount) => {
return new Promise((resolve, reject) => {
ipcRenderer.send('forward-account', account)
ipcRenderer.once('error-forward-account', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-forward-account')
win.ipcRenderer.send('forward-account', account)
win.ipcRenderer.once('error-forward-account', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-forward-account')
reject(err)
})
ipcRenderer.once('response-forward-account', () => {
ipcRenderer.removeAllListeners('error-forward-account')
win.ipcRenderer.once('response-forward-account', () => {
win.ipcRenderer.removeAllListeners('error-forward-account')
resolve()
})
})
},
backwardAccount: (_, account: LocalAccount) => {
return new Promise((resolve, reject) => {
ipcRenderer.send('backward-account', account)
ipcRenderer.once('error-backward-account', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-forward-account')
win.ipcRenderer.send('backward-account', account)
win.ipcRenderer.once('error-backward-account', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-forward-account')
reject(err)
})
ipcRenderer.once('response-backward-account', () => {
ipcRenderer.removeAllListeners('error-backward-account')
win.ipcRenderer.once('response-backward-account', () => {
win.ipcRenderer.removeAllListeners('error-backward-account')
resolve()
})
})
},
removeAllAccounts: () => {
return new Promise((resolve, reject) => {
ipcRenderer.send('remove-all-accounts')
ipcRenderer.once('error-remove-all-accounts', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-remove-all-accounts')
win.ipcRenderer.send('remove-all-accounts')
win.ipcRenderer.once('error-remove-all-accounts', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-remove-all-accounts')
reject(err)
})
ipcRenderer.once('response-remove-all-accounts', () => {
ipcRenderer.removeAllListeners('error-remove-all-accounts')
win.ipcRenderer.once('response-remove-all-accounts', () => {
win.ipcRenderer.removeAllListeners('error-remove-all-accounts')
resolve()
})
})

94
src/renderer/store/Preferences/Appearance.ts
View File

@ -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) => {
ipcRenderer.removeAllListeners('response-get-preferences')
win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-get-preferences')
reject(err)
})
ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-get-preferences')
win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
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) => {
ipcRenderer.removeAllListeners('response-list-fonts')
win.ipcRenderer.once('error-list-fonts', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-list-fonts')
reject(err)
})
ipcRenderer.once('response-list-fonts', (_, fonts: Array<string>) => {
ipcRenderer.removeAllListeners('error-list-fonts')
win.ipcRenderer.once('response-list-fonts', (_, fonts: Array<string>) => {
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) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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)
})
}
}

45
src/renderer/store/Preferences/General.ts
View File

@ -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')
ipcRenderer.once('error-get-preferences', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-get-preferences')
win.ipcRenderer.send('get-preferences')
win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-get-preferences')
commit(MUTATION_TYPES.CHANGE_LOADING, false)
reject(err)
})
ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-get-preferences')
win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
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)
ipcRenderer.once('error-update-preferences', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.send('update-preferences', config)
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
commit(MUTATION_TYPES.CHANGE_LOADING, false)
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
commit(MUTATION_TYPES.CHANGE_LOADING, false)
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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', () => {
ipcRenderer.once('error-update-preferences', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-update-preferences')
win.ipcRenderer.once('response-change-auto-launch', () => {
win.ipcRenderer.once('error-update-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-preferences')
commit(MUTATION_TYPES.CHANGE_LOADING, false)
reject(err)
})
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-update-preferences')
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
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)
})
}
}

20
src/renderer/store/Preferences/Language.ts
View File

@ -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')
ipcRenderer.once('error-get-preferences', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-get-preferences')
win.ipcRenderer.send('get-preferences')
win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-get-preferences')
reject(err)
})
ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-get-preferences')
win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
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)
ipcRenderer.once('response-change-language', (_, value: string) => {
win.ipcRenderer.send('change-language', key)
win.ipcRenderer.once('response-change-language', (_, value: string) => {
commit(MUTATION_TYPES.CHANGE_LANGUAGE, value)
resolve(value)
})
})
},
relaunch: () => {
ipcRenderer.send('relaunch')
win.ipcRenderer.send('relaunch')
}
}

18
src/renderer/store/Preferences/Network.ts
View File

@ -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')
ipcRenderer.once('error-get-preferences', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-get-preferences')
win.ipcRenderer.send('get-preferences')
win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-get-preferences')
reject(err)
})
ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-get-preferences')
win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
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)
}
}

18
src/renderer/store/Preferences/Notification.ts
View File

@ -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')
ipcRenderer.once('error-get-preferences', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-get-preferences')
win.ipcRenderer.send('get-preferences')
win.ipcRenderer.once('error-get-preferences', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-get-preferences')
reject(err)
})
ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
ipcRenderer.removeAllListeners('error-get-preferences')
win.ipcRenderer.once('response-get-preferences', (_, conf: BaseConfig) => {
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)
ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
win.ipcRenderer.send('update-preferences', config)
win.ipcRenderer.once('response-update-preferences', (_, conf: BaseConfig) => {
commit(MUTATION_TYPES.UPDATE_NOTIFICATION, conf.notification)
dispatch('App/loadPreferences', null, { root: true })
resolve(conf.notification)

24
src/renderer/store/Settings/Timeline.ts
View File

@ -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) => {
ipcRenderer.removeAllListeners('error-get-unread-notification')
win.ipcRenderer.once('response-get-unread-notification', (_, settings: UnreadNotification) => {
win.ipcRenderer.removeAllListeners('error-get-unread-notification')
commit(MUTATION_TYPES.UPDATE_UNREAD_NOTIFICATION, settings)
resolve(true)
})
ipcRenderer.once('error-get-unread-notification', () => {
ipcRenderer.removeAllListeners('response-get-unread-notification')
win.ipcRenderer.once('error-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', () => {
ipcRenderer.removeAllListeners('error-update-unread-notification')
win.ipcRenderer.once('response-update-unread-notification', () => {
win.ipcRenderer.removeAllListeners('error-update-unread-notification')
dispatch('loadUnreadNotification')
resolve(true)
})
ipcRenderer.once('error-update-unread-notification', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-update-unread-notification')
win.ipcRenderer.once('error-update-unread-notification', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-unread-notification')
reject(err)
})
ipcRenderer.send('update-unread-notification', settings)
win.ipcRenderer.send('update-unread-notification', settings)
})
}
}

106
src/renderer/store/TimelineSpace.ts
View File

@ -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)
ipcRenderer.once('error-get-local-account', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-get-local-account')
win.ipcRenderer.send('get-local-account', id)
win.ipcRenderer.once('error-get-local-account', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-get-local-account')
reject(err)
})
ipcRenderer.once('response-get-local-account', (_, account: LocalAccount) => {
ipcRenderer.removeAllListeners('error-get-local-account')
win.ipcRenderer.once('response-get-local-account', (_, account: LocalAccount) => {
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)
ipcRenderer.once('error-update-account', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-update-account')
win.ipcRenderer.send('update-account', account)
win.ipcRenderer.once('error-update-account', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-update-account')
reject(err)
})
ipcRenderer.once('response-update-account', (_, account: LocalAccount) => {
ipcRenderer.removeAllListeners('error-update-account')
win.ipcRenderer.once('response-update-account', (_, account: LocalAccount) => {
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')
ipcRenderer.removeAllListeners('CmdOrCtrl+K')
win.ipcRenderer.removeAllListeners('CmdOrCtrl+N')
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) => {
ipcRenderer.removeAllListeners('error-get-unread-notification')
win.ipcRenderer.once('response-get-unread-notification', (_, settings: UnreadNotification) => {
win.ipcRenderer.removeAllListeners('error-get-unread-notification')
commit(MUTATION_TYPES.UPDATE_UNREAD_NOTIFICATION, settings)
resolve(settings)
})
ipcRenderer.once('error-get-unread-notification', () => {
ipcRenderer.removeAllListeners('response-get-unread-notification')
win.ipcRenderer.once('error-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!}`)
ipcRenderer.removeAllListeners(`mention-start-all-user-streamings-${state.bindingAccount._id!}`)
ipcRenderer.removeAllListeners(`notification-start-all-user-streamings-${state.bindingAccount._id!}`)
ipcRenderer.removeAllListeners(`delete-start-all-user-streamings-${state.bindingAccount._id!}`)
win.ipcRenderer.removeAllListeners(`update-start-all-user-streamings-${state.bindingAccount._id!}`)
win.ipcRenderer.removeAllListeners(`mention-start-all-user-streamings-${state.bindingAccount._id!}`)
win.ipcRenderer.removeAllListeners(`notification-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')
ipcRenderer.removeAllListeners('update-start-local-streaming')
ipcRenderer.removeAllListeners('delete-start-local-streaming')
win.ipcRenderer.removeAllListeners('error-start-local-streaming')
win.ipcRenderer.removeAllListeners('update-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')
ipcRenderer.removeAllListeners('update-start-public-streaming')
ipcRenderer.removeAllListeners('delete-start-public-streaming')
win.ipcRenderer.removeAllListeners('error-start-public-streaming')
win.ipcRenderer.removeAllListeners('update-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')
ipcRenderer.removeAllListeners('update-start-directmessages-streaming')
ipcRenderer.removeAllListeners('delete-start-directmessages-streaming')
win.ipcRenderer.removeAllListeners('error-start-directmessages-streaming')
win.ipcRenderer.removeAllListeners('update-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 })

8
src/renderer/store/TimelineSpace/Contents/Hashtag.ts
View File

@ -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)
}
}

24
src/renderer/store/TimelineSpace/Contents/Hashtag/List.ts
View File

@ -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>) => {
ipcRenderer.removeAllListeners('error-list-hashtags')
win.ipcRenderer.once('response-list-hashtags', (_, tags: Array<LocalTag>) => {
win.ipcRenderer.removeAllListeners('error-list-hashtags')
commit(MUTATION_TYPES.UPDATE_TAGS, tags)
resolve(tags)
})
ipcRenderer.once('error-list-hashtags', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-list-hashtags')
win.ipcRenderer.once('error-list-hashtags', (_, err: Error) => {
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', () => {
ipcRenderer.removeAllListeners('error-remove-hashtag')
win.ipcRenderer.once('response-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) => {
ipcRenderer.removeAllListeners('response-remove-hashtag')
win.ipcRenderer.once('error-remove-hashtag', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-remove-hashtag')
reject(err)
})
ipcRenderer.send('remove-hashtag', tag)
win.ipcRenderer.send('remove-hashtag', tag)
})
}
}

20
src/renderer/store/TimelineSpace/Contents/Hashtag/Tag.ts
View File

@ -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')
ipcRenderer.removeAllListeners('update-start-tag-streaming')
ipcRenderer.removeAllListeners('delete-start-tag-streaming')
ipcRenderer.send('stop-tag-streaming')
win.ipcRenderer.removeAllListeners('error-start-tag-streaming')
win.ipcRenderer.removeAllListeners('update-start-tag-streaming')
win.ipcRenderer.removeAllListeners('delete-start-tag-streaming')
win.ipcRenderer.send('stop-tag-streaming')
resolve()
})
},

20
src/renderer/store/TimelineSpace/Contents/Lists/Show.ts
View File

@ -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')
ipcRenderer.removeAllListeners('update-start-list-streaming')
ipcRenderer.removeAllListeners('delete-start-list-streaming')
ipcRenderer.send('stop-list-streaming')
win.ipcRenderer.removeAllListeners('error-start-list-streaming')
win.ipcRenderer.removeAllListeners('update-start-list-streaming')
win.ipcRenderer.removeAllListeners('delete-start-list-streaming')
win.ipcRenderer.send('stop-list-streaming')
resolve()
})
},

6
src/renderer/store/TimelineSpace/Contents/Notifications.ts
View File

@ -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')
}
}

6
src/renderer/store/TimelineSpace/Modals/NewToot.ts
View File

@ -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(() => {

29
src/renderer/store/TimelineSpace/Modals/NewToot/Status.ts
View File

@ -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))
ipcRenderer.send('insert-cache-accounts', {
commit(
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))
ipcRenderer.send('insert-cache-hashtags', res.data.hashtags.map(tag => tag.name))
commit(
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)

20
src/renderer/store/TimelineSpace/SideMenu.ts
View File

@ -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')
ipcRenderer.once('response-get-collapse', (_, value: boolean) => {
win.ipcRenderer.send('get-collapse')
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>) => {
ipcRenderer.removeAllListeners('error-list-hashtags')
win.ipcRenderer.once('response-list-hashtags', (_, tags: Array<LocalTag>) => {
win.ipcRenderer.removeAllListeners('error-list-hashtags')
commit(MUTATION_TYPES.UPDATE_TAGS, tags)
resolve(tags)
})
ipcRenderer.once('error-list-hashtags', (_, err: Error) => {
ipcRenderer.removeAllListeners('response-list-hashtags')
win.ipcRenderer.once('error-list-hashtags', (_, err: Error) => {
win.ipcRenderer.removeAllListeners('response-list-hashtags')
reject(err)
})
ipcRenderer.send('list-hashtags')
win.ipcRenderer.send('list-hashtags')
})
}
}

8
src/renderer/store/organisms/Toot.ts
View File

@ -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
},