melnary/akkoma-fe
1
0
Fork 0
forked from AkkomaGang/akkoma-fe
Code Pull requests Activity

Do not try to destructure when we don't need to

Browse source
This commit is contained in:
Floatingghost 2024-06-27 02:58:52 +01:00
parent 4211e05a75
commit 8765491399
1 changed files with 266 additions and 220 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

472
src/modules/api.js
View file

@ -1,28 +1,28 @@
import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js' import backendInteractorService from "../services/backend_interactor_service/backend_interactor_service.js";
import { WSConnectionStatus } from '../services/api/api.service.js' import { WSConnectionStatus } from "../services/api/api.service.js";
import { map } from 'lodash' import { map } from "lodash";
const retryTimeout = (multiplier) => 1000 * multiplier const retryTimeout = (multiplier) => 1000 * multiplier;
const isVisible = (store, message, visibility) => { const isVisible = (store, message, visibility) => {
if (visibility == 'all') { if (visibility == "all") {
return true return true;
} }
if (visibility == 'following') { if (visibility == "following") {
if (message.in_reply_to_user_id === null) { if (message.in_reply_to_user_id === null) {
return true return true;
} else { } else {
return store.getters.relationship(message.in_reply_to_user_id).following return store.getters.relationship(message.in_reply_to_user_id).following;
} }
} }
if (visibility == 'self') { if (visibility == "self") {
return message.in_reply_to_user_id === store.rootState.users.currentUser.id return message.in_reply_to_user_id === store.rootState.users.currentUser.id;
} }
return false return false;
} };
const api = { const api = {
state: { state: {
@ -32,43 +32,43 @@ const api = {
socket: null, socket: null,
mastoUserSocket: null, mastoUserSocket: null,
mastoUserSocketStatus: null, mastoUserSocketStatus: null,
followRequests: [] followRequests: [],
}, },
mutations: { mutations: {
setBackendInteractor (state, backendInteractor) { setBackendInteractor(state, backendInteractor) {
state.backendInteractor = backendInteractor state.backendInteractor = backendInteractor;
}, },
addFetcher (state, { fetcherName, fetcher }) { addFetcher(state, { fetcherName, fetcher }) {
state.fetchers[fetcherName] = fetcher state.fetchers[fetcherName] = fetcher;
}, },
removeFetcher (state, { fetcherName, fetcher }) { removeFetcher(state, { fetcherName, fetcher }) {
state.fetchers[fetcherName].stop() state.fetchers[fetcherName].stop();
delete state.fetchers[fetcherName] delete state.fetchers[fetcherName];
}, },
setWsToken (state, token) { setWsToken(state, token) {
state.wsToken = token state.wsToken = token;
}, },
setSocket (state, socket) { setSocket(state, socket) {
state.socket = socket state.socket = socket;
}, },
setMastoUserSocketStatus (state, value) { setMastoUserSocketStatus(state, value) {
state.mastoUserSocketStatus = value state.mastoUserSocketStatus = value;
}, },
incrementRetryMultiplier (state) { incrementRetryMultiplier(state) {
state.retryMultiplier = Math.max(++state.retryMultiplier, 3) state.retryMultiplier = Math.max(++state.retryMultiplier, 3);
}, },
resetRetryMultiplier (state) { resetRetryMultiplier(state) {
state.retryMultiplier = 1 state.retryMultiplier = 1;
}, },
setFollowRequests (state, value) { setFollowRequests(state, value) {
state.followRequests = [...value] state.followRequests = [...value];
}, },
saveFollowRequests (state, requests) { saveFollowRequests(state, requests) {
state.followRequests = [...state.followRequests, ...requests] state.followRequests = [...state.followRequests, ...requests];
},
saveFollowRequestPagination(state, pagination) {
state.followRequestsPagination = pagination;
}, },
saveFollowRequestPagination (state, pagination) {
state.followRequestsPagination = pagination
}
}, },
actions: { actions: {
/** /**
@ -76,260 +76,306 @@ const api = {
* *
* @param {Boolean} [initial] - whether this enabling happened at boot time or not * @param {Boolean} [initial] - whether this enabling happened at boot time or not
*/ */
enableMastoSockets (store, initial) { enableMastoSockets(store, initial) {
const { state, dispatch, commit } = store const { state, dispatch, commit } = store;
// Do not initialize unless nonexistent or closed // Do not initialize unless nonexistent or closed
if ( if (
state.mastoUserSocket && state.mastoUserSocket &&
![ ![WebSocket.CLOSED, WebSocket.CLOSING].includes(
WebSocket.CLOSED, state.mastoUserSocket.getState(),
WebSocket.CLOSING )
].includes(state.mastoUserSocket.getState())
) { ) {
return return;
} }
if (initial) { if (initial) {
commit('setMastoUserSocketStatus', WSConnectionStatus.STARTING_INITIAL) commit("setMastoUserSocketStatus", WSConnectionStatus.STARTING_INITIAL);
} else { } else {
commit('setMastoUserSocketStatus', WSConnectionStatus.STARTING) commit("setMastoUserSocketStatus", WSConnectionStatus.STARTING);
} }
return dispatch('startMastoUserSocket') return dispatch("startMastoUserSocket");
}, },
disableMastoSockets (store) { disableMastoSockets(store) {
const { state, dispatch, commit } = store const { state, dispatch, commit } = store;
if (!state.mastoUserSocket) return if (!state.mastoUserSocket) return;
commit('setMastoUserSocketStatus', WSConnectionStatus.DISABLED) commit("setMastoUserSocketStatus", WSConnectionStatus.DISABLED);
return dispatch('stopMastoUserSocket') return dispatch("stopMastoUserSocket");
}, },
// MastoAPI 'User' sockets // MastoAPI 'User' sockets
startMastoUserSocket (store) { startMastoUserSocket(store) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
try { try {
const { state, commit, dispatch, rootState } = store const { state, commit, dispatch, rootState } = store;
const timelineData = rootState.statuses.timelines.friends const timelineData = rootState.statuses.timelines.friends;
state.mastoUserSocket = state.backendInteractor.startUserSocket({ store }) state.mastoUserSocket = state.backendInteractor.startUserSocket({
store,
});
state.mastoUserSocket.addEventListener( state.mastoUserSocket.addEventListener(
'message', "message",
({ detail: message }) => { ({ detail: message }) => {
const replyVisibility = rootState.config.replyVisibility const replyVisibility = rootState.config.replyVisibility;
if (!message) return // pings if (!message) return; // pings
if (message.event === 'notification') { if (message.event === "notification") {
dispatch('addNewNotifications', { dispatch("addNewNotifications", {
notifications: [message.notification], notifications: [message.notification],
older: false older: false,
}) });
} else if (message.event === 'update' && isVisible(store, message.status, replyVisibility)) { } else if (
dispatch('addNewStatuses', { message.event === "update" &&
isVisible(store, message.status, replyVisibility)
) {
dispatch("addNewStatuses", {
statuses: [message.status], statuses: [message.status],
userId: false, userId: false,
showImmediately: timelineData.visibleStatuses.length === 0, showImmediately: timelineData.visibleStatuses.length === 0,
timeline: 'friends' timeline: "friends",
}) });
} else if (message.event === 'status.update' && isVisible(store, message.status, replyVisibility)) { } else if (
dispatch('addNewStatuses', { message.event === "status.update" &&
isVisible(store, message.status, replyVisibility)
) {
dispatch("addNewStatuses", {
statuses: [message.status], statuses: [message.status],
userId: false, userId: false,
showImmediately: message.status.id in timelineData.visibleStatusesObject, showImmediately:
timeline: 'friends' message.status.id in timelineData.visibleStatusesObject,
}) timeline: "friends",
} else if (message.event === 'delete') { });
dispatch('deleteStatusById', message.id) } else if (message.event === "delete") {
dispatch("deleteStatusById", message.id);
} }
} },
) );
state.mastoUserSocket.addEventListener('open', () => { state.mastoUserSocket.addEventListener("open", () => {
// Do not show notification when we just opened up the page // Do not show notification when we just opened up the page
if (state.mastoUserSocketStatus !== WSConnectionStatus.STARTING_INITIAL) { if (
dispatch('pushGlobalNotice', { state.mastoUserSocketStatus !==
level: 'success', WSConnectionStatus.STARTING_INITIAL
messageKey: 'timeline.socket_reconnected', ) {
timeout: 5000 dispatch("pushGlobalNotice", {
}) level: "success",
messageKey: "timeline.socket_reconnected",
timeout: 5000,
});
} }
// Stop polling if we were errored or disabled // Stop polling if we were errored or disabled
if (new Set([ if (
new Set([
WSConnectionStatus.ERROR, WSConnectionStatus.ERROR,
WSConnectionStatus.DISABLED WSConnectionStatus.DISABLED,
]).has(state.mastoUserSocketStatus)) { ]).has(state.mastoUserSocketStatus)
dispatch('stopFetchingTimeline', { timeline: 'friends' }) ) {
dispatch('stopFetchingNotifications') dispatch("stopFetchingTimeline", { timeline: "friends" });
dispatch("stopFetchingNotifications");
} }
commit('resetRetryMultiplier') commit("resetRetryMultiplier");
commit('setMastoUserSocketStatus', WSConnectionStatus.JOINED) commit("setMastoUserSocketStatus", WSConnectionStatus.JOINED);
}) });
state.mastoUserSocket.addEventListener('error', ({ detail: error }) => { state.mastoUserSocket.addEventListener(
console.error('Error in MastoAPI websocket:', error) "error",
}) ({ detail: error }) => {
state.mastoUserSocket.addEventListener('close', ({ detail: closeEvent }) => { console.error("Error in MastoAPI websocket:", error);
},
);
state.mastoUserSocket.addEventListener(
"close",
({ detail: closeEvent }) => {
const ignoreCodes = new Set([ const ignoreCodes = new Set([
1000, // Normal (intended) closure 1000, // Normal (intended) closure
1001 // Going away 1001, // Going away
]) ]);
const { code } = closeEvent const { code } = closeEvent;
if (ignoreCodes.has(code)) { if (ignoreCodes.has(code)) {
console.debug(`Not restarting socket becasue of closure code ${code} is in ignore list`) console.debug(
commit('setMastoUserSocketStatus', WSConnectionStatus.CLOSED) `Not restarting socket becasue of closure code ${code} is in ignore list`,
);
commit("setMastoUserSocketStatus", WSConnectionStatus.CLOSED);
} else { } else {
console.warn(`MastoAPI websocket disconnected, restarting. CloseEvent code: ${code}`) console.warn(
`MastoAPI websocket disconnected, restarting. CloseEvent code: ${code}`,
);
setTimeout(() => { setTimeout(() => {
dispatch('startMastoUserSocket') dispatch("startMastoUserSocket");
}, retryTimeout(state.retryMultiplier)) }, retryTimeout(state.retryMultiplier));
commit('incrementRetryMultiplier') commit("incrementRetryMultiplier");
if (state.mastoUserSocketStatus !== WSConnectionStatus.ERROR) { if (state.mastoUserSocketStatus !== WSConnectionStatus.ERROR) {
dispatch('startFetchingTimeline', { timeline: 'friends' }) dispatch("startFetchingTimeline", { timeline: "friends" });
dispatch('startFetchingNotifications') dispatch("startFetchingNotifications");
dispatch('startFetchingAnnouncements') dispatch("startFetchingAnnouncements");
dispatch('startFetchingReports') dispatch("startFetchingReports");
dispatch('pushGlobalNotice', { dispatch("pushGlobalNotice", {
level: 'error', level: "error",
messageKey: 'timeline.socket_broke', messageKey: "timeline.socket_broke",
messageArgs: [code], messageArgs: [code],
timeout: 5000 timeout: 5000,
}) });
} }
commit('setMastoUserSocketStatus', WSConnectionStatus.ERROR) commit("setMastoUserSocketStatus", WSConnectionStatus.ERROR);
} }
})
resolve()
} catch (e) {
reject(e)
}
})
}, },
stopMastoUserSocket ({ state, dispatch }) { );
dispatch('startFetchingTimeline', { timeline: 'friends' }) resolve();
dispatch('startFetchingNotifications') } catch (e) {
state.mastoUserSocket.close() reject(e);
}
});
},
stopMastoUserSocket({ state, dispatch }) {
dispatch("startFetchingTimeline", { timeline: "friends" });
dispatch("startFetchingNotifications");
state.mastoUserSocket.close();
}, },
// Timelines // Timelines
startFetchingTimeline (store, { startFetchingTimeline(
timeline = 'friends', store,
tag = false, { timeline = "friends", tag = false, userId = false, listId = false },
userId = false, ) {
listId = false if (store.state.fetchers[timeline]) return;
}) {
if (store.state.fetchers[timeline]) return
const fetcher = store.state.backendInteractor.startFetchingTimeline({ const fetcher = store.state.backendInteractor.startFetchingTimeline({
timeline, store, userId, listId, tag timeline,
}) store,
store.commit('addFetcher', { fetcherName: timeline, fetcher }) userId,
listId,
tag,
});
store.commit("addFetcher", { fetcherName: timeline, fetcher });
}, },
stopFetchingTimeline (store, timeline) { stopFetchingTimeline(store, timeline) {
const fetcher = store.state.fetchers[timeline] const fetcher = store.state.fetchers[timeline];
if (!fetcher) return if (!fetcher) return;
store.commit('removeFetcher', { fetcherName: timeline, fetcher }) store.commit("removeFetcher", { fetcherName: timeline, fetcher });
}, },
fetchTimeline (store, timeline, { ...rest }) { fetchTimeline(store, timeline, opts = {}) {
store.state.backendInteractor.fetchTimeline({ store.state.backendInteractor.fetchTimeline({
store, store,
timeline, timeline,
...rest ...opts,
}) });
}, },
startFetchingConfig (store) { startFetchingConfig(store) {
if (store.state.fetchers.config) return if (store.state.fetchers.config) return;
const fetcher = store.state.backendInteractor.startFetchingConfig({ store }) const fetcher = store.state.backendInteractor.startFetchingConfig({
store.commit('addFetcher', { fetcherName: 'config', fetcher }) store,
});
store.commit("addFetcher", { fetcherName: "config", fetcher });
}, },
stopFetchingConfig (store) { stopFetchingConfig(store) {
const fetcher = store.state.fetchers.config const fetcher = store.state.fetchers.config;
if (!fetcher) return if (!fetcher) return;
store.commit('removeFetcher', { fetcherName: 'config', fetcher }) store.commit("removeFetcher", { fetcherName: "config", fetcher });
}, },
// Notifications // Notifications
startFetchingNotifications (store) { startFetchingNotifications(store) {
if (store.state.fetchers.notifications) return if (store.state.fetchers.notifications) return;
const fetcher = store.state.backendInteractor.startFetchingNotifications({ store }) const fetcher = store.state.backendInteractor.startFetchingNotifications({
store.commit('addFetcher', { fetcherName: 'notifications', fetcher }) store,
});
store.commit("addFetcher", { fetcherName: "notifications", fetcher });
}, },
stopFetchingNotifications (store) { stopFetchingNotifications(store) {
const fetcher = store.state.fetchers.notifications const fetcher = store.state.fetchers.notifications;
if (!fetcher) return if (!fetcher) return;
store.commit('removeFetcher', { fetcherName: 'notifications', fetcher }) store.commit("removeFetcher", { fetcherName: "notifications", fetcher });
}, },
fetchNotifications (store, { ...rest }) { fetchNotifications(store, { ...rest }) {
store.state.backendInteractor.fetchNotifications({ store.state.backendInteractor.fetchNotifications({
store, store,
...rest ...rest,
}) });
}, },
removeFollowRequest (store, request) { removeFollowRequest(store, request) {
let requests = [...store.state.followRequests].filter((it) => it.id !== request.id) let requests = [...store.state.followRequests].filter(
store.commit('setFollowRequests', requests) (it) => it.id !== request.id,
);
store.commit("setFollowRequests", requests);
}, },
fetchFollowRequests ({ rootState, commit }) { fetchFollowRequests({ rootState, commit }) {
const pagination = rootState.api.followRequestsPagination const pagination = rootState.api.followRequestsPagination;
return rootState.api.backendInteractor.getFollowRequests({ pagination }) return rootState.api.backendInteractor
.getFollowRequests({ pagination })
.then((requests) => { .then((requests) => {
if (requests.data.length > 0) { if (requests.data.length > 0) {
commit('addNewUsers', requests.data) commit("addNewUsers", requests.data);
commit('saveFollowRequests', requests.data) commit("saveFollowRequests", requests.data);
commit('saveFollowRequestPagination', requests.pagination) commit("saveFollowRequestPagination", requests.pagination);
} }
return requests return requests;
}) });
}, },
// Lists // Lists
startFetchingLists (store) { startFetchingLists(store) {
if (store.state.fetchers['lists']) return if (store.state.fetchers["lists"]) return;
const fetcher = store.state.backendInteractor.startFetchingLists({ store }) const fetcher = store.state.backendInteractor.startFetchingLists({
store.commit('addFetcher', { fetcherName: 'lists', fetcher }) store,
});
store.commit("addFetcher", { fetcherName: "lists", fetcher });
}, },
stopFetchingLists (store) { stopFetchingLists(store) {
const fetcher = store.state.fetchers.lists const fetcher = store.state.fetchers.lists;
if (!fetcher) return if (!fetcher) return;
store.commit('removeFetcher', { fetcherName: 'lists', fetcher }) store.commit("removeFetcher", { fetcherName: "lists", fetcher });
}, },
// Lists // Lists
startFetchingAnnouncements (store) { startFetchingAnnouncements(store) {
if (store.state.fetchers['announcements']) return if (store.state.fetchers["announcements"]) return;
const fetcher = store.state.backendInteractor.startFetchingAnnouncements({ store }) const fetcher = store.state.backendInteractor.startFetchingAnnouncements({
store.commit('addFetcher', { fetcherName: 'announcements', fetcher }) store,
});
store.commit("addFetcher", { fetcherName: "announcements", fetcher });
}, },
stopFetchingAnnouncements (store) { stopFetchingAnnouncements(store) {
const fetcher = store.state.fetchers.announcements const fetcher = store.state.fetchers.announcements;
if (!fetcher) return if (!fetcher) return;
store.commit('removeFetcher', { fetcherName: 'announcements', fetcher }) store.commit("removeFetcher", { fetcherName: "announcements", fetcher });
}, },
// Reports // Reports
startFetchingReports (store) { startFetchingReports(store) {
if (store.state.fetchers['reports']) return if (store.state.fetchers["reports"]) return;
const fetcher = store.state.backendInteractor.startFetchingReports({ store }) const fetcher = store.state.backendInteractor.startFetchingReports({
store.commit('addFetcher', { fetcherName: 'reports', fetcher }) store,
});
store.commit("addFetcher", { fetcherName: "reports", fetcher });
}, },
stopFetchingReports (store) { stopFetchingReports(store) {
const fetcher = store.state.fetchers.reports const fetcher = store.state.fetchers.reports;
if (!fetcher) return if (!fetcher) return;
store.commit('removeFetcher', { fetcherName: 'reports', fetcher }) store.commit("removeFetcher", { fetcherName: "reports", fetcher });
}, },
getSupportedTranslationlanguages (store) { getSupportedTranslationlanguages(store) {
store.state.backendInteractor.getSupportedTranslationlanguages({ store }) store.state.backendInteractor
.getSupportedTranslationlanguages({ store })
.then((data) => { .then((data) => {
store.dispatch('setInstanceOption', { name: 'supportedTranslationLanguages', value: data }) store.dispatch("setInstanceOption", {
}) name: "supportedTranslationLanguages",
value: data,
});
});
}, },
listSettingsProfiles (store) { listSettingsProfiles(store) {
store.state.backendInteractor.listSettingsProfiles({ store }) store.state.backendInteractor
.listSettingsProfiles({ store })
.then((data) => { .then((data) => {
store.commit('setInstanceOption', { name: 'settingsProfiles', value: data }) store.commit("setInstanceOption", {
}) name: "settingsProfiles",
value: data,
});
});
}, },
// Pleroma websocket // Pleroma websocket
setWsToken (store, token) { setWsToken(store, token) {
store.commit('setWsToken', token) store.commit("setWsToken", token);
}, },
disconnectFromSocket ({ commit, state }) { disconnectFromSocket({ commit, state }) {
state.socket && state.socket.disconnect() state.socket && state.socket.disconnect();
commit('setSocket', null) commit("setSocket", null);
} },
} },
} };
export default api export default api;