- Virtualize mobile lists and defer queue loading - Split playback state from actions to reduce rerenders - Skip invalid or unnecessary Convex queries Reviewed-on: #18
269 lines
7.3 KiB
TypeScript
269 lines
7.3 KiB
TypeScript
import { useConvex } from "convex/react"
|
|
import { useCallback } from "react"
|
|
|
|
import type { MediaAction } from "@/components/media-context-menu"
|
|
import { useAddToPlaylist } from "@/contexts/add-to-playlist"
|
|
import { useFavorites } from "@/contexts/favorites"
|
|
import { usePlaybackActions } from "@/contexts/playback"
|
|
import { useAppNavigation } from "@/lib/app-navigation"
|
|
import { showError, showSuccess } from "@/lib/toast"
|
|
import { api } from "@otunes/convex/_generated/api"
|
|
import type { Id } from "@otunes/convex/_generated/dataModel"
|
|
import type {
|
|
BrowseAlbum,
|
|
BrowseAlbumDetail,
|
|
BrowseAlbumTrack,
|
|
BrowseArtist,
|
|
BrowseSong,
|
|
PlaylistSummary,
|
|
} from "@otunes/convex/types"
|
|
|
|
async function runMediaAction(action: () => Promise<void>) {
|
|
try {
|
|
await action()
|
|
} catch (error) {
|
|
showError(error instanceof Error ? error.message : "Media action failed")
|
|
}
|
|
}
|
|
|
|
export function useMediaMenuActions() {
|
|
const convex = useConvex()
|
|
const { push } = useAppNavigation()
|
|
const {
|
|
openAddToPlaylist,
|
|
openAddAlbumToPlaylist,
|
|
openAddArtistToPlaylist,
|
|
openAddPlaylistToPlaylist,
|
|
} = useAddToPlaylist()
|
|
const {
|
|
isAlbumFavorite,
|
|
isArtistFavorite,
|
|
toggleAlbumFavorite,
|
|
toggleArtistFavorite,
|
|
toggleSongFavorite,
|
|
favoriteSongs,
|
|
} = useFavorites()
|
|
const { addToQueueNext, addToQueueLast, playShuffled } = usePlaybackActions()
|
|
|
|
const runQueueAction = useCallback(
|
|
async (action: MediaAction, songIds: Id<"songs">[]) => {
|
|
if (songIds.length === 0) return
|
|
await runMediaAction(async () => {
|
|
switch (action) {
|
|
case "play-next":
|
|
await addToQueueNext(songIds)
|
|
showSuccess("Queued to play next")
|
|
break
|
|
case "play-last":
|
|
await addToQueueLast(songIds)
|
|
showSuccess("Queued to play last")
|
|
break
|
|
case "shuffle":
|
|
await playShuffled(songIds)
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
})
|
|
},
|
|
[addToQueueLast, addToQueueNext, playShuffled]
|
|
)
|
|
|
|
const handleSongAction = useCallback(
|
|
async (song: BrowseSong, action: MediaAction) => {
|
|
const songIds = [song.id as Id<"songs">]
|
|
switch (action) {
|
|
case "playlist":
|
|
openAddToPlaylist(songIds)
|
|
break
|
|
case "play-next":
|
|
case "play-last":
|
|
case "shuffle":
|
|
await runQueueAction(action, songIds)
|
|
break
|
|
case "favorite":
|
|
await toggleSongFavorite(song.id as Id<"songs">)
|
|
break
|
|
case "go-artist":
|
|
push(`/artist/${song.artist.id}`)
|
|
break
|
|
case "go-album":
|
|
push(`/album/${song.album.id}`)
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
},
|
|
[openAddToPlaylist, push, runQueueAction, toggleSongFavorite]
|
|
)
|
|
|
|
const handleAlbumAction = useCallback(
|
|
async (album: BrowseAlbum, action: MediaAction) => {
|
|
await runMediaAction(async () => {
|
|
switch (action) {
|
|
case "playlist":
|
|
await openAddAlbumToPlaylist(album.id as Id<"albums">)
|
|
break
|
|
case "favorite":
|
|
await toggleAlbumFavorite(album.id as Id<"albums">)
|
|
break
|
|
case "play-next":
|
|
case "play-last":
|
|
case "shuffle": {
|
|
const songIds = await convex.query(api.playlists.getAlbumSongIds, {
|
|
albumId: album.id as Id<"albums">,
|
|
})
|
|
await runQueueAction(action, songIds)
|
|
break
|
|
}
|
|
case "go-artist":
|
|
push(`/artist/${album.artist.id}`)
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
})
|
|
},
|
|
[convex, openAddAlbumToPlaylist, push, runQueueAction, toggleAlbumFavorite]
|
|
)
|
|
|
|
const handleArtistAction = useCallback(
|
|
async (artist: BrowseArtist, action: MediaAction) => {
|
|
await runMediaAction(async () => {
|
|
switch (action) {
|
|
case "playlist":
|
|
await openAddArtistToPlaylist(artist.id as Id<"artists">)
|
|
break
|
|
case "favorite":
|
|
await toggleArtistFavorite(artist.id as Id<"artists">)
|
|
break
|
|
case "play-next":
|
|
case "play-last":
|
|
case "shuffle": {
|
|
const songIds = await convex.query(
|
|
api.playlists.getOrderedArtistSongIds,
|
|
{ artistId: artist.id as Id<"artists"> }
|
|
)
|
|
await runQueueAction(action, songIds)
|
|
break
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
})
|
|
},
|
|
[convex, openAddArtistToPlaylist, runQueueAction, toggleArtistFavorite]
|
|
)
|
|
|
|
const handlePlaylistAction = useCallback(
|
|
async (playlist: PlaylistSummary, action: MediaAction) => {
|
|
await runMediaAction(async () => {
|
|
switch (action) {
|
|
case "playlist":
|
|
await openAddPlaylistToPlaylist(playlist.id as Id<"playlists">)
|
|
break
|
|
case "play-next":
|
|
case "play-last":
|
|
case "shuffle": {
|
|
const songIds = await convex.query(
|
|
api.playlists.getPlaylistSongIds,
|
|
{
|
|
playlistId: playlist.id as Id<"playlists">,
|
|
}
|
|
)
|
|
await runQueueAction(action, songIds)
|
|
break
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
})
|
|
},
|
|
[convex, openAddPlaylistToPlaylist, runQueueAction]
|
|
)
|
|
|
|
const handleAlbumDetailAction = useCallback(
|
|
async (
|
|
albumId: Id<"albums">,
|
|
songIds: Id<"songs">[],
|
|
action: MediaAction
|
|
) => {
|
|
switch (action) {
|
|
case "favorite":
|
|
await toggleAlbumFavorite(albumId)
|
|
break
|
|
case "playlist":
|
|
openAddToPlaylist(songIds)
|
|
break
|
|
case "play-next":
|
|
case "play-last":
|
|
case "shuffle":
|
|
await runQueueAction(action, songIds)
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
},
|
|
[openAddToPlaylist, runQueueAction, toggleAlbumFavorite]
|
|
)
|
|
|
|
const handleAlbumTrackAction = useCallback(
|
|
async (
|
|
track: BrowseAlbumTrack,
|
|
album: BrowseAlbumDetail,
|
|
action: MediaAction
|
|
) => {
|
|
const song: BrowseSong = {
|
|
id: track.id,
|
|
title: track.title,
|
|
durationSeconds: track.durationSeconds,
|
|
artist: album.artist,
|
|
album: {
|
|
id: album.id,
|
|
title: album.title,
|
|
cover: album.cover,
|
|
},
|
|
}
|
|
await handleSongAction(song, action)
|
|
},
|
|
[handleSongAction]
|
|
)
|
|
|
|
const handlePlaylistDetailAction = useCallback(
|
|
async (songIds: Id<"songs">[], action: MediaAction) => {
|
|
await runMediaAction(async () => {
|
|
switch (action) {
|
|
case "favorite":
|
|
if (songIds.length > 0) {
|
|
await favoriteSongs(songIds)
|
|
}
|
|
break
|
|
case "playlist":
|
|
openAddToPlaylist(songIds)
|
|
break
|
|
case "play-next":
|
|
case "play-last":
|
|
case "shuffle":
|
|
await runQueueAction(action, songIds)
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
})
|
|
},
|
|
[favoriteSongs, openAddToPlaylist, runQueueAction]
|
|
)
|
|
|
|
return {
|
|
handleSongAction,
|
|
handleAlbumAction,
|
|
handleArtistAction,
|
|
handlePlaylistAction,
|
|
handleAlbumDetailAction,
|
|
handleAlbumTrackAction,
|
|
handlePlaylistDetailAction,
|
|
isAlbumFavorite,
|
|
isArtistFavorite,
|
|
}
|
|
}
|