Lint all files

src/renderer/features/shared/mutations/create-favorite-mutation.ts

@@ -3,77 +3,80 @@ import { AxiosError } from 'axios';
 import { api } from '/@/renderer/api';
 import { queryKeys } from '/@/renderer/api/query-keys';
 import {
-  AlbumArtistDetailResponse,
-  AlbumDetailResponse,
-  FavoriteArgs,
-  FavoriteResponse,
-  LibraryItem,
+    AlbumArtistDetailResponse,
+    AlbumDetailResponse,
+    FavoriteArgs,
+    FavoriteResponse,
+    LibraryItem,
 } from '/@/renderer/api/types';
 import { MutationHookArgs } from '/@/renderer/lib/react-query';
 import { getServerById, useSetAlbumListItemDataById, useSetQueueFavorite } from '/@/renderer/store';
 
 export const useCreateFavorite = (args: MutationHookArgs) => {
-  const { options } = args || {};
-  const queryClient = useQueryClient();
-  const setAlbumListData = useSetAlbumListItemDataById();
-  const setQueueFavorite = useSetQueueFavorite();
+    const { options } = args || {};
+    const queryClient = useQueryClient();
+    const setAlbumListData = useSetAlbumListItemDataById();
+    const setQueueFavorite = useSetQueueFavorite();
 
-  return useMutation<
-    FavoriteResponse,
-    AxiosError,
-    Omit<FavoriteArgs, 'server' | 'apiClientProps'>,
-    null
-  >({
-    mutationFn: (args) => {
-      const server = getServerById(args.serverId);
-      if (!server) throw new Error('Server not found');
-      return api.controller.createFavorite({ ...args, apiClientProps: { server } });
-    },
-    onSuccess: (_data, variables) => {
-      const { serverId } = variables;
+    return useMutation<
+        FavoriteResponse,
+        AxiosError,
+        Omit<FavoriteArgs, 'server' | 'apiClientProps'>,
+        null
+    >({
+        mutationFn: (args) => {
+            const server = getServerById(args.serverId);
+            if (!server) throw new Error('Server not found');
+            return api.controller.createFavorite({ ...args, apiClientProps: { server } });
+        },
+        onSuccess: (_data, variables) => {
+            const { serverId } = variables;
 
-      if (!serverId) return;
+            if (!serverId) return;
 
-      for (const id of variables.query.id) {
-        // Set the userFavorite property to true for the album in the album list data store
-        if (variables.query.type === LibraryItem.ALBUM) {
-          setAlbumListData(id, { userFavorite: true });
-        }
-      }
+            for (const id of variables.query.id) {
+                // Set the userFavorite property to true for the album in the album list data store
+                if (variables.query.type === LibraryItem.ALBUM) {
+                    setAlbumListData(id, { userFavorite: true });
+                }
+            }
 
-      if (variables.query.type === LibraryItem.SONG) {
-        setQueueFavorite(variables.query.id, true);
-      }
+            if (variables.query.type === LibraryItem.SONG) {
+                setQueueFavorite(variables.query.id, true);
+            }
 
-      // We only need to set if we're already on the album detail page
-      if (variables.query.type === LibraryItem.ALBUM && variables.query.id.length === 1) {
-        const queryKey = queryKeys.albums.detail(serverId, { id: variables.query.id[0] });
-        const previous = queryClient.getQueryData<AlbumDetailResponse>(queryKey);
+            // We only need to set if we're already on the album detail page
+            if (variables.query.type === LibraryItem.ALBUM && variables.query.id.length === 1) {
+                const queryKey = queryKeys.albums.detail(serverId, { id: variables.query.id[0] });
+                const previous = queryClient.getQueryData<AlbumDetailResponse>(queryKey);
 
-        if (previous) {
-          queryClient.setQueryData<AlbumDetailResponse>(queryKey, {
-            ...previous,
-            userFavorite: true,
-          });
-        }
-      }
+                if (previous) {
+                    queryClient.setQueryData<AlbumDetailResponse>(queryKey, {
+                        ...previous,
+                        userFavorite: true,
+                    });
+                }
+            }
 
-      // We only need to set if we're already on the album detail page
-      if (variables.query.type === LibraryItem.ALBUM_ARTIST && variables.query.id.length === 1) {
-        const queryKey = queryKeys.albumArtists.detail(serverId, {
-          id: variables.query.id[0],
-        });
+            // We only need to set if we're already on the album detail page
+            if (
+                variables.query.type === LibraryItem.ALBUM_ARTIST &&
+                variables.query.id.length === 1
+            ) {
+                const queryKey = queryKeys.albumArtists.detail(serverId, {
+                    id: variables.query.id[0],
+                });
 
-        const previous = queryClient.getQueryData<AlbumArtistDetailResponse>(queryKey);
+                const previous = queryClient.getQueryData<AlbumArtistDetailResponse>(queryKey);
 
-        if (previous) {
-          queryClient.setQueryData<AlbumArtistDetailResponse>(queryKey, {
-            ...previous,
-            userFavorite: true,
-          });
-        }
-      }
-    },
-    ...options,
-  });
+                if (previous) {
+                    queryClient.setQueryData<AlbumArtistDetailResponse>(queryKey, {
+                        ...previous,
+                        userFavorite: true,
+                    });
+                }
+            }
+        },
+        ...options,
+    });
 };

src/renderer/features/shared/mutations/delete-favorite-mutation.ts

@@ -3,76 +3,79 @@ import { AxiosError } from 'axios';
 import { api } from '/@/renderer/api';
 import { queryKeys } from '/@/renderer/api/query-keys';
 import {
-  AlbumArtistDetailResponse,
-  AlbumDetailResponse,
-  FavoriteArgs,
-  FavoriteResponse,
-  LibraryItem,
+    AlbumArtistDetailResponse,
+    AlbumDetailResponse,
+    FavoriteArgs,
+    FavoriteResponse,
+    LibraryItem,
 } from '/@/renderer/api/types';
 import { MutationHookArgs } from '/@/renderer/lib/react-query';
 import { getServerById, useSetAlbumListItemDataById, useSetQueueFavorite } from '/@/renderer/store';
 
 export const useDeleteFavorite = (args: MutationHookArgs) => {
-  const { options } = args || {};
-  const queryClient = useQueryClient();
-  const setAlbumListData = useSetAlbumListItemDataById();
-  const setQueueFavorite = useSetQueueFavorite();
+    const { options } = args || {};
+    const queryClient = useQueryClient();
+    const setAlbumListData = useSetAlbumListItemDataById();
+    const setQueueFavorite = useSetQueueFavorite();
 
-  return useMutation<
-    FavoriteResponse,
-    AxiosError,
-    Omit<FavoriteArgs, 'server' | 'apiClientProps'>,
-    null
-  >({
-    mutationFn: (args) => {
-      const server = getServerById(args.serverId);
-      if (!server) throw new Error('Server not found');
-      return api.controller.deleteFavorite({ ...args, apiClientProps: { server } });
-    },
-    onSuccess: (_data, variables) => {
-      const { serverId } = variables;
+    return useMutation<
+        FavoriteResponse,
+        AxiosError,
+        Omit<FavoriteArgs, 'server' | 'apiClientProps'>,
+        null
+    >({
+        mutationFn: (args) => {
+            const server = getServerById(args.serverId);
+            if (!server) throw new Error('Server not found');
+            return api.controller.deleteFavorite({ ...args, apiClientProps: { server } });
+        },
+        onSuccess: (_data, variables) => {
+            const { serverId } = variables;
 
-      if (!serverId) return;
+            if (!serverId) return;
 
-      for (const id of variables.query.id) {
-        // Set the userFavorite property to false for the album in the album list data store
-        if (variables.query.type === LibraryItem.ALBUM) {
-          setAlbumListData(id, { userFavorite: false });
-        }
-      }
+            for (const id of variables.query.id) {
+                // Set the userFavorite property to false for the album in the album list data store
+                if (variables.query.type === LibraryItem.ALBUM) {
+                    setAlbumListData(id, { userFavorite: false });
+                }
+            }
 
-      if (variables.query.type === LibraryItem.SONG) {
-        setQueueFavorite(variables.query.id, false);
-      }
+            if (variables.query.type === LibraryItem.SONG) {
+                setQueueFavorite(variables.query.id, false);
+            }
 
-      // We only need to set if we're already on the album detail page
-      if (variables.query.type === LibraryItem.ALBUM && variables.query.id.length === 1) {
-        const queryKey = queryKeys.albums.detail(serverId, { id: variables.query.id[0] });
-        const previous = queryClient.getQueryData<AlbumDetailResponse>(queryKey);
+            // We only need to set if we're already on the album detail page
+            if (variables.query.type === LibraryItem.ALBUM && variables.query.id.length === 1) {
+                const queryKey = queryKeys.albums.detail(serverId, { id: variables.query.id[0] });
+                const previous = queryClient.getQueryData<AlbumDetailResponse>(queryKey);
 
-        if (previous) {
-          queryClient.setQueryData<AlbumDetailResponse>(queryKey, {
-            ...previous,
-            userFavorite: false,
-          });
-        }
-      }
+                if (previous) {
+                    queryClient.setQueryData<AlbumDetailResponse>(queryKey, {
+                        ...previous,
+                        userFavorite: false,
+                    });
+                }
+            }
 
-      // We only need to set if we're already on the album artist detail page
-      if (variables.query.type === LibraryItem.ALBUM_ARTIST && variables.query.id.length === 1) {
-        const queryKey = queryKeys.albumArtists.detail(serverId, {
-          id: variables.query.id[0],
-        });
-        const previous = queryClient.getQueryData<AlbumArtistDetailResponse>(queryKey);
+            // We only need to set if we're already on the album artist detail page
+            if (
+                variables.query.type === LibraryItem.ALBUM_ARTIST &&
+                variables.query.id.length === 1
+            ) {
+                const queryKey = queryKeys.albumArtists.detail(serverId, {
+                    id: variables.query.id[0],
+                });
+                const previous = queryClient.getQueryData<AlbumArtistDetailResponse>(queryKey);
 
-        if (previous) {
-          queryClient.setQueryData<AlbumArtistDetailResponse>(queryKey, {
-            ...previous,
-            userFavorite: false,
-          });
-        }
-      }
-    },
-    ...options,
-  });
+                if (previous) {
+                    queryClient.setQueryData<AlbumArtistDetailResponse>(queryKey, {
+                        ...previous,
+                        userFavorite: false,
+                    });
+                }
+            }
+        },
+        ...options,
+    });
 };

src/renderer/features/shared/mutations/set-rating-mutation.ts

@@ -3,99 +3,100 @@ import { AxiosError } from 'axios';
 import { api } from '/@/renderer/api';
 import { queryKeys } from '/@/renderer/api/query-keys';
 import {
-  Album,
-  AlbumArtist,
-  AnyLibraryItems,
-  LibraryItem,
-  SetRatingArgs,
-  RatingResponse,
-  AlbumDetailResponse,
-  AlbumArtistDetailResponse,
+    Album,
+    AlbumArtist,
+    AnyLibraryItems,
+    LibraryItem,
+    SetRatingArgs,
+    RatingResponse,
+    AlbumDetailResponse,
+    AlbumArtistDetailResponse,
 } from '/@/renderer/api/types';
 import { MutationHookArgs } from '/@/renderer/lib/react-query';
 import { getServerById, useSetAlbumListItemDataById, useSetQueueRating } from '/@/renderer/store';
 
 export const useSetRating = (args: MutationHookArgs) => {
-  const { options } = args || {};
-  const queryClient = useQueryClient();
-  const setAlbumListData = useSetAlbumListItemDataById();
-  const setQueueRating = useSetQueueRating();
+    const { options } = args || {};
+    const queryClient = useQueryClient();
+    const setAlbumListData = useSetAlbumListItemDataById();
+    const setQueueRating = useSetQueueRating();
 
-  return useMutation<
-    RatingResponse,
-    AxiosError,
-    Omit<SetRatingArgs, 'server' | 'apiClientProps'>,
-    { previous: { items: AnyLibraryItems } | undefined }
-  >({
-    mutationFn: (args) => {
-      const server = getServerById(args.serverId);
-      if (!server) throw new Error('Server not found');
-      return api.controller.updateRating({ ...args, apiClientProps: { server } });
-    },
-    onError: (_error, _variables, context) => {
-      for (const item of context?.previous?.items || []) {
-        switch (item.itemType) {
-          case LibraryItem.ALBUM:
-            setAlbumListData(item.id, { userRating: item.userRating });
-            break;
-          case LibraryItem.SONG:
-            setQueueRating([item.id], item.userRating);
-            break;
-        }
-      }
-    },
-    onMutate: (variables) => {
-      for (const item of variables.query.item) {
-        switch (item.itemType) {
-          case LibraryItem.ALBUM:
-            setAlbumListData(item.id, { userRating: variables.query.rating });
-            break;
-          case LibraryItem.SONG:
-            setQueueRating([item.id], variables.query.rating);
-            break;
-        }
-      }
+    return useMutation<
+        RatingResponse,
+        AxiosError,
+        Omit<SetRatingArgs, 'server' | 'apiClientProps'>,
+        { previous: { items: AnyLibraryItems } | undefined }
+    >({
+        mutationFn: (args) => {
+            const server = getServerById(args.serverId);
+            if (!server) throw new Error('Server not found');
+            return api.controller.updateRating({ ...args, apiClientProps: { server } });
+        },
+        onError: (_error, _variables, context) => {
+            for (const item of context?.previous?.items || []) {
+                switch (item.itemType) {
+                    case LibraryItem.ALBUM:
+                        setAlbumListData(item.id, { userRating: item.userRating });
+                        break;
+                    case LibraryItem.SONG:
+                        setQueueRating([item.id], item.userRating);
+                        break;
+                }
+            }
+        },
+        onMutate: (variables) => {
+            for (const item of variables.query.item) {
+                switch (item.itemType) {
+                    case LibraryItem.ALBUM:
+                        setAlbumListData(item.id, { userRating: variables.query.rating });
+                        break;
+                    case LibraryItem.SONG:
+                        setQueueRating([item.id], variables.query.rating);
+                        break;
+                }
+            }
 
-      return { previous: { items: variables.query.item } };
-    },
-    onSuccess: (_data, variables) => {
-      // We only need to set if we're already on the album detail page
-      const isAlbumDetailPage =
-        variables.query.item.length === 1 && variables.query.item[0].itemType === LibraryItem.ALBUM;
+            return { previous: { items: variables.query.item } };
+        },
+        onSuccess: (_data, variables) => {
+            // We only need to set if we're already on the album detail page
+            const isAlbumDetailPage =
+                variables.query.item.length === 1 &&
+                variables.query.item[0].itemType === LibraryItem.ALBUM;
 
-      if (isAlbumDetailPage) {
-        const { id: albumId, serverId } = variables.query.item[0] as Album;
+            if (isAlbumDetailPage) {
+                const { id: albumId, serverId } = variables.query.item[0] as Album;
 
-        const queryKey = queryKeys.albums.detail(serverId || '', { id: albumId });
-        const previous = queryClient.getQueryData<AlbumDetailResponse>(queryKey);
-        if (previous) {
-          queryClient.setQueryData<AlbumDetailResponse>(queryKey, {
-            ...previous,
-            userRating: variables.query.rating,
-          });
-        }
-      }
+                const queryKey = queryKeys.albums.detail(serverId || '', { id: albumId });
+                const previous = queryClient.getQueryData<AlbumDetailResponse>(queryKey);
+                if (previous) {
+                    queryClient.setQueryData<AlbumDetailResponse>(queryKey, {
+                        ...previous,
+                        userRating: variables.query.rating,
+                    });
+                }
+            }
 
-      // We only need to set if we're already on the album artist detail page
-      const isAlbumArtistDetailPage =
-        variables.query.item.length === 1 &&
-        variables.query.item[0].itemType === LibraryItem.ALBUM_ARTIST;
+            // We only need to set if we're already on the album artist detail page
+            const isAlbumArtistDetailPage =
+                variables.query.item.length === 1 &&
+                variables.query.item[0].itemType === LibraryItem.ALBUM_ARTIST;
 
-      if (isAlbumArtistDetailPage) {
-        const { id: albumArtistId, serverId } = variables.query.item[0] as AlbumArtist;
+            if (isAlbumArtistDetailPage) {
+                const { id: albumArtistId, serverId } = variables.query.item[0] as AlbumArtist;
 
-        const queryKey = queryKeys.albumArtists.detail(serverId || '', {
-          id: albumArtistId,
-        });
-        const previous = queryClient.getQueryData<AlbumArtistDetailResponse>(queryKey);
-        if (previous) {
-          queryClient.setQueryData<AlbumArtistDetailResponse>(queryKey, {
-            ...previous,
-            userRating: variables.query.rating,
-          });
-        }
-      }
-    },
-    ...options,
-  });
+                const queryKey = queryKeys.albumArtists.detail(serverId || '', {
+                    id: albumArtistId,
+                });
+                const previous = queryClient.getQueryData<AlbumArtistDetailResponse>(queryKey);
+                if (previous) {
+                    queryClient.setQueryData<AlbumArtistDetailResponse>(queryKey, {
+                        ...previous,
+                        userRating: variables.query.rating,
+                    });
+                }
+            }
+        },
+        ...options,
+    });
 };