Files
otunes/apps/mobile/hooks/use-media-menu-actions.ts
T
joshuafhiggins 9da758b196 perf: optimize app rendering and data loading (#18)
- Virtualize mobile lists and defer queue loading
- Split playback state from actions to reduce rerenders
- Skip invalid or unnecessary Convex queries

Reviewed-on: #18
2026-09-05 16:35:37 -04:00

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