feat(web): persistent client cache, skeleton navigations, and local-first playback

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
joshuafhigginsandCursor committed 2026-10-08 15:46:42 -04:00 Verified
1 parent 26bea15b20
commit 3a02bfc38f
57 files changed
+2402 -598

No files matched your search

+10
View File
@@ -0,0 +1,10 @@
import { HomeSkeleton, PageHeader } from "@/components/library-skeletons"
export default function Loading() {
return (
<div className="flex h-svh flex-col">
<PageHeader title="Home" />
<HomeSkeleton />
</div>
)
}
+42
View File
@@ -0,0 +1,42 @@
"use client"
import { ContentCarousel } from "@/components/content-carousel"
import { HomeSkeleton, PageHeader } from "@/components/library-skeletons"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { api } from "@otunes/convex/_generated/api"
export default function Page() {
const recentlyAdded = useCachedQuery(api.library.browseRecentlyAdded, {
limit: 9,
})
const recentlyPlayed = useCachedQuery(api.library.browseRecentlyPlayed, {
limit: 9,
})
return (
<div className="flex h-svh flex-col">
<PageHeader title="Home" />
{recentlyAdded === undefined || recentlyPlayed === undefined ? (
<HomeSkeleton />
) : (
<div className="flex-1 overflow-y-auto p-6 pb-28">
<div className="flex flex-col gap-10">
{recentlyPlayed.length > 0 ? (
<ContentCarousel
title="Recently Played"
href="/recently-played"
content={recentlyPlayed}
/>
) : null}
<ContentCarousel
title="Recently Added"
href="/recently-added"
content={recentlyAdded}
/>
</div>
</div>
)}
</div>
)
}
+2 -6
View File
@@ -1,9 +1,5 @@
import { LibraryLoading } from "@/components/library-loading"
import { CollectionDetailSkeleton } from "@/components/library-skeletons"
export default function Loading() {
return (
<div className="flex h-svh flex-col">
<LibraryLoading />
</div>
)
return <CollectionDetailSkeleton />
}
+9 -24
View File
@@ -1,5 +1,4 @@
import { AlbumView } from "@/components/album-view"
import { LibraryLoading } from "@/components/library-loading"
import { AlbumPage } from "@/components/album-page"
import { api } from "@otunes/convex/_generated/api"
import { fetchQuery } from "convex/nextjs"
import { convexServerOptions } from "@/lib/convex-server"
@@ -49,29 +48,15 @@ export async function generateMetadata({
}
export default async function Page({ params, searchParams }: PageProps) {
const { id } = await params
const [{ s: highlightedSongId }, album] = await Promise.all([
const [{ id }, { s: highlightedSongId }] = await Promise.all([
params,
searchParams,
fetchAlbumDetail(id as Id<"albums">),
])
if (album === undefined) {
return (
<div className="flex h-svh flex-col">
<LibraryLoading />
</div>
)
}
if (album === null) {
return (
<div className="flex h-svh flex-col">
<div className="flex flex-1 items-center justify-center pb-28">
<p className="text-sm text-muted-foreground">Album not found.</p>
</div>
</div>
)
}
return <AlbumView album={album} highlightedSongId={highlightedSongId} />
return (
<AlbumPage
albumId={id as Id<"albums">}
highlightedSongId={highlightedSongId}
/>
)
}
+2 -6
View File
@@ -1,9 +1,5 @@
import { LibraryLoading } from "@/components/library-loading"
import { ArtistDetailSkeleton } from "@/components/library-skeletons"
export default function Loading() {
return (
<div className="flex h-svh flex-col">
<LibraryLoading />
</div>
)
return <ArtistDetailSkeleton />
}
+2 -23
View File
@@ -1,7 +1,6 @@
import { fetchQuery } from "convex/nextjs"
import { convexServerOptions } from "@/lib/convex-server"
import { ArtistView } from "@/components/artist-view"
import { LibraryLoading } from "@/components/library-loading"
import { ArtistPage } from "@/components/artist-page"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import { Metadata } from "next"
@@ -39,25 +38,5 @@ export async function generateMetadata({
export default async function Page({ params }: PageProps) {
const { id } = await params
const data = await fetchArtistDetail(id as Id<"artists">)
if (data === undefined) {
return (
<div className="flex h-svh flex-col">
<LibraryLoading />
</div>
)
}
if (data === null) {
return (
<div className="flex h-svh flex-col">
<div className="flex flex-1 items-center justify-center pb-28">
<p className="text-sm text-muted-foreground">Artist not found.</p>
</div>
</div>
)
}
return <ArtistView artist={data.artist} albums={data.albums} />
return <ArtistPage artistId={id as Id<"artists">} />
}
@@ -0,0 +1,10 @@
import { CardGridSkeleton, PageHeader } from "@/components/library-skeletons"
export default function Loading() {
return (
<div className="flex h-svh flex-col">
<PageHeader title="Albums" />
<CardGridSkeleton />
</div>
)
}
+7 -9
View File
@@ -1,25 +1,23 @@
"use client"
import { useQuery } from "convex/react"
import { AlbumCard } from "@/components/album-card"
import { LibraryLoading } from "@/components/library-loading"
import { CardGridSkeleton, PageHeader } from "@/components/library-skeletons"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { albumGridClassName } from "@/lib/album-grid-classes"
import { api } from "@otunes/convex/_generated/api"
export default function Page() {
const albums = useQuery(api.library.browseAlbums)
const albums = useCachedQuery(api.library.browseAlbums)
return (
<div className="flex h-svh flex-col">
<header className="flex items-center gap-2 border-b px-4 py-3">
<h1 className="text-lg font-semibold">Albums</h1>
</header>
<PageHeader title="Albums" />
{albums === undefined ? (
<LibraryLoading />
<CardGridSkeleton />
) : (
<div className="flex-1 overflow-y-auto p-6 pb-28">
<div className="grid grid-cols-2 gap-x-6 gap-y-8 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-6">
<div className={albumGridClassName}>
{albums.map((album) => (
<AlbumCard key={album.id} album={album} />
))}
@@ -1,23 +1,21 @@
import { fetchQuery } from "convex/nextjs"
import { convexServerOptions } from "@/lib/convex-server"
import { ArtistsView } from "@/components/artists-view"
import { api } from "@otunes/convex/_generated/api"
import { Metadata } from "next"
import { cache } from "react"
interface PageProps {
params: Promise<{ id: string }>
}
const fetchArtists = cache(() =>
fetchQuery(api.library.browseArtists, {}, convexServerOptions())
)
export async function generateMetadata({
params,
}: PageProps): Promise<Metadata> {
const { id } = await params
const artists = await fetchArtists()
const artists = await fetchQuery(
api.library.browseArtists,
{},
convexServerOptions()
)
const selectedArtist = artists.find((artist) => artist.id === id)
return {
@@ -36,19 +34,6 @@ export async function generateMetadata({
}
}
export default async function Page({ params }: PageProps) {
const { id } = await params
const [artists, albums] = await Promise.all([
fetchArtists(),
fetchQuery(api.library.browseAlbums, {}, convexServerOptions()),
])
return (
<div className="flex h-svh flex-col">
<header className="flex items-center gap-2 border-b px-4 py-3">
<h1 className="text-lg font-semibold">Artists</h1>
</header>
<ArtistsView artists={artists} albums={albums} artistId={id} />
</div>
)
export default function Page() {
return null
}
@@ -0,0 +1,14 @@
import { ArtistsPage } from "@/components/artists-page"
export default function ArtistsLayout({
children,
}: Readonly<{
children: React.ReactNode
}>) {
return (
<>
<ArtistsPage />
{children}
</>
)
}
@@ -0,0 +1,7 @@
/**
* The artists UI lives in the layout and renders from the client cache, so
* navigations only need this (empty) boundary to commit.
*/
export default function Loading() {
return null
}
+2 -25
View File
@@ -1,26 +1,3 @@
import { fetchQuery } from "convex/nextjs"
import { convexServerOptions } from "@/lib/convex-server"
import { ArtistsView } from "@/components/artists-view"
import { LibraryLoading } from "@/components/library-loading"
import { api } from "@otunes/convex/_generated/api"
export default async function Page() {
const [artists, albums] = await Promise.all([
fetchQuery(api.library.browseArtists, {}, convexServerOptions()),
fetchQuery(api.library.browseAlbums, {}, convexServerOptions()),
])
return (
<div className="flex h-svh flex-col">
<header className="flex items-center gap-2 border-b px-4 py-3">
<h1 className="text-lg font-semibold">Artists</h1>
</header>
{artists === undefined || albums === undefined ? (
<LibraryLoading />
) : (
<ArtistsView artists={artists} albums={albums} />
)}
</div>
)
export default function Page() {
return null
}
@@ -0,0 +1,10 @@
import { PageHeader, SongListSkeleton } from "@/components/library-skeletons"
export default function Loading() {
return (
<div className="flex h-svh flex-col">
<PageHeader title="Songs" />
<SongListSkeleton />
</div>
)
}
-50
View File
@@ -1,50 +0,0 @@
"use client"
import { useQuery } from "convex/react"
import { ContentCarousel } from "@/components/content-carousel"
import { LibraryLoading } from "@/components/library-loading"
import { api } from "@otunes/convex/_generated/api"
export default function Page() {
const recentlyAdded = useQuery(api.library.browseRecentlyAdded, { limit: 9 })
const recentlyPlayed = useQuery(api.library.browseRecentlyPlayed, {
limit: 9,
})
if (recentlyAdded === undefined || recentlyPlayed === undefined) {
return (
<div className="flex h-svh flex-col">
<header className="flex items-center gap-2 border-b px-4 py-3">
<h1 className="text-lg font-semibold">Home</h1>
</header>
<LibraryLoading />
</div>
)
}
return (
<div className="flex h-svh flex-col">
<header className="flex items-center gap-2 border-b px-4 py-3">
<h1 className="text-lg font-semibold">Home</h1>
</header>
<div className="flex-1 overflow-y-auto p-6 pb-28">
<div className="flex flex-col gap-10">
{recentlyPlayed.length > 0 ? (
<ContentCarousel
title="Recently Played"
href="/recently-played"
content={recentlyPlayed}
/>
) : null}
<ContentCarousel
title="Recently Added"
href="/recently-added"
content={recentlyAdded}
/>
</div>
</div>
</div>
)
}
@@ -0,0 +1,5 @@
import { CollectionDetailSkeleton } from "@/components/library-skeletons"
export default function Loading() {
return <CollectionDetailSkeleton />
}
+2 -23
View File
@@ -1,5 +1,4 @@
import { LibraryLoading } from "@/components/library-loading"
import { PlaylistView } from "@/components/playlist-view"
import { PlaylistPage } from "@/components/playlist-page"
import { api } from "@otunes/convex/_generated/api"
import { convexAuthNextjsToken } from "@convex-dev/auth/nextjs/server"
import { fetchQuery } from "convex/nextjs"
@@ -41,25 +40,5 @@ export async function generateMetadata({
export default async function Page({ params }: PageProps) {
const { id } = await params
const playlist = await fetchPlaylistDetail(id as Id<"playlists">)
if (playlist === undefined) {
return (
<div className="flex h-svh flex-col">
<LibraryLoading />
</div>
)
}
if (playlist === null) {
return (
<div className="flex h-svh flex-col">
<div className="flex flex-1 items-center justify-center pb-28">
<p className="text-sm text-muted-foreground">Playlist not found.</p>
</div>
</div>
)
}
return <PlaylistView key={playlist.id} playlist={playlist} />
return <PlaylistPage playlistId={id as Id<"playlists">} />
}
@@ -0,0 +1,5 @@
import { CollectionDetailSkeleton } from "@/components/library-skeletons"
export default function Loading() {
return <CollectionDetailSkeleton />
}
+2 -28
View File
@@ -1,33 +1,7 @@
"use client"
import { useQuery } from "convex/react"
import { LibraryLoading } from "@/components/library-loading"
import { PlaylistView } from "@/components/playlist-view"
import { api } from "@otunes/convex/_generated/api"
import { FavoritesPlaylistPage } from "@/components/playlist-page"
export default function Page() {
const favorites = useQuery(api.favorites.browseFavoritesPlaylistDetail)
if (favorites === undefined) {
return (
<div className="flex h-svh flex-col">
<LibraryLoading />
</div>
)
}
if (favorites === null) {
return (
<div className="flex h-svh flex-col">
<div className="flex flex-1 items-center justify-center pb-28">
<p className="text-sm text-muted-foreground">
Sign in to view your favorites.
</p>
</div>
</div>
)
}
return <PlaylistView playlist={favorites} />
return <FavoritesPlaylistPage />
}
+10
View File
@@ -0,0 +1,10 @@
import { CardGridSkeleton, PageHeader } from "@/components/library-skeletons"
export default function Loading() {
return (
<div className="flex h-svh flex-col">
<PageHeader title="Playlists" />
<CardGridSkeleton />
</div>
)
}
+6 -5
View File
@@ -1,16 +1,17 @@
"use client"
import { useQuery } from "convex/react"
import { Plus } from "lucide-react"
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
import { LibraryLoading } from "@/components/library-loading"
import { CardGridSkeleton } from "@/components/library-skeletons"
import { PlaylistCard } from "@/components/playlist-card"
import { Button } from "@/components/ui/button"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { albumGridClassName } from "@/lib/album-grid-classes"
import { api } from "@otunes/convex/_generated/api"
export default function Page() {
const playlists = useQuery(api.playlists.listAllPlaylists)
const playlists = useCachedQuery(api.playlists.listAllPlaylists)
const { openCreatePlaylist } = useAddToPlaylist()
return (
@@ -29,10 +30,10 @@ export default function Page() {
</header>
{playlists === undefined ? (
<LibraryLoading />
<CardGridSkeleton />
) : (
<div className="flex-1 overflow-y-auto p-6 pb-28">
<div className="grid grid-cols-2 gap-x-6 gap-y-8 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-6">
<div className={albumGridClassName}>
{playlists.map((playlist) => (
<PlaylistCard key={playlist.id} playlist={playlist} />
))}
@@ -0,0 +1,10 @@
import { CardGridSkeleton, PageHeader } from "@/components/library-skeletons"
export default function Loading() {
return (
<div className="flex h-svh flex-col">
<PageHeader title="Recently Added" />
<CardGridSkeleton />
</div>
)
}
+7 -9
View File
@@ -1,25 +1,23 @@
"use client"
import { useQuery } from "convex/react"
import { AlbumCard } from "@/components/album-card"
import { LibraryLoading } from "@/components/library-loading"
import { CardGridSkeleton, PageHeader } from "@/components/library-skeletons"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { albumGridClassName } from "@/lib/album-grid-classes"
import { api } from "@otunes/convex/_generated/api"
export default function Page() {
const albums = useQuery(api.library.browseRecentlyAdded, {})
const albums = useCachedQuery(api.library.browseRecentlyAdded, {})
return (
<div className="flex h-svh flex-col">
<header className="flex items-center gap-2 border-b px-4 py-3">
<h1 className="text-lg font-semibold">Recently Added</h1>
</header>
<PageHeader title="Recently Added" />
{albums === undefined ? (
<LibraryLoading />
<CardGridSkeleton />
) : (
<div className="flex-1 overflow-y-auto p-6 pb-28">
<div className="grid grid-cols-2 gap-x-6 gap-y-8 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-6">
<div className={albumGridClassName}>
{albums.map((album) => (
<AlbumCard key={album.id} album={album} />
))}
@@ -0,0 +1,10 @@
import { CardGridSkeleton, PageHeader } from "@/components/library-skeletons"
export default function Loading() {
return (
<div className="flex h-svh flex-col">
<PageHeader title="Recently Played" />
<CardGridSkeleton />
</div>
)
}
+7 -9
View File
@@ -1,10 +1,10 @@
"use client"
import { useQuery } from "convex/react"
import { AlbumCard } from "@/components/album-card"
import { LibraryLoading } from "@/components/library-loading"
import { CardGridSkeleton, PageHeader } from "@/components/library-skeletons"
import { PlaylistCard } from "@/components/playlist-card"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { albumGridClassName } from "@/lib/album-grid-classes"
import { api } from "@otunes/convex/_generated/api"
import type { BrowseAlbum, PlaylistSummary } from "@otunes/convex/types"
@@ -20,16 +20,14 @@ function RecentlyPlayedCard({
}
export default function Page() {
const recentlyPlayed = useQuery(api.library.browseRecentlyPlayed, {})
const recentlyPlayed = useCachedQuery(api.library.browseRecentlyPlayed, {})
return (
<div className="flex h-svh flex-col">
<header className="flex items-center gap-2 border-b px-4 py-3">
<h1 className="text-lg font-semibold">Recently Played</h1>
</header>
<PageHeader title="Recently Played" />
{recentlyPlayed === undefined ? (
<LibraryLoading />
<CardGridSkeleton />
) : recentlyPlayed.length === 0 ? (
<div className="flex flex-1 items-center justify-center p-6 pb-28">
<p className="text-sm text-muted-foreground">
@@ -38,7 +36,7 @@ export default function Page() {
</div>
) : (
<div className="flex-1 overflow-y-auto p-6 pb-28">
<div className="grid grid-cols-2 gap-x-6 gap-y-8 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-6">
<div className={albumGridClassName}>
{recentlyPlayed.map((item) => (
<RecentlyPlayedCard key={item.id} item={item} />
))}
+13
View File
@@ -0,0 +1,13 @@
import { SearchResultsSkeleton } from "@/components/library-skeletons"
import { Skeleton } from "@/components/ui/skeleton"
export default function Loading() {
return (
<div className="flex h-svh flex-col">
<header className="flex items-center justify-center border-b px-4 py-3">
<Skeleton className="h-10 w-full max-w-xl rounded-full" />
</header>
<SearchResultsSkeleton />
</div>
)
}
+6 -6
View File
@@ -1,14 +1,14 @@
"use client"
import { Suspense, useCallback, useEffect, useRef, useState } from "react"
import { useQuery } from "convex/react"
import { SearchIcon } from "lucide-react"
import { usePathname, useSearchParams } from "next/navigation"
import { ContentCarousel } from "@/components/content-carousel"
import { LibraryLoading } from "@/components/library-loading"
import { SearchResultsSkeleton } from "@/components/library-skeletons"
import { SearchSongItem } from "@/components/search-song-item"
import { SearchTopResultCard, type TopResult } from "@/components/search-top-result-card"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { api } from "@otunes/convex/_generated/api"
const SEARCH_DEBOUNCE_MS = 300
@@ -30,11 +30,11 @@ function readUrlQuery() {
function SearchResults({ query }: { query: string }) {
const hasQuery = query.length > 0
const results = useQuery(
const results = useCachedQuery(
api.library.searchLibrary,
hasQuery ? { query } : "skip"
)
const playlistResults = useQuery(
const playlistResults = useCachedQuery(
api.playlists.searchPlaylists,
hasQuery ? { query } : "skip"
)
@@ -51,7 +51,7 @@ function SearchResults({ query }: { query: string }) {
const showResults = hasQuery && results !== undefined
if (isSearching) {
return <LibraryLoading />
return <SearchResultsSkeleton />
}
if (!hasQuery) {
@@ -239,7 +239,7 @@ function SearchPageContent() {
export default function Page() {
return (
<Suspense fallback={<LibraryLoading />}>
<Suspense fallback={<SearchResultsSkeleton />}>
<SearchPageContent />
</Suspense>
)
@@ -6,6 +6,7 @@ import { useRouter } from "next/navigation"
import { ListMusic, Plus } from "lucide-react"
import { toast } from "sonner"
import { useCacheScope } from "@/components/persistent-cache-provider"
import { Button } from "@/components/ui/button"
import {
Dialog,
@@ -19,6 +20,7 @@ import { Input } from "@/components/ui/input"
import { ScrollArea } from "@/components/ui/scroll-area"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import { fetchCachedQuery } from "@/lib/cached-query"
function countSongsToAdd(
playlistSongIds: Id<"songs">[],
@@ -80,6 +82,7 @@ export function AddToPlaylistProvider({
children: React.ReactNode
}) {
const convex = useConvex()
const cacheScope = useCacheScope()
const router = useRouter()
const addSongs = useMutation(api.playlists.addSongsToPlaylist)
const createPlaylist = useMutation(api.playlists.createPlaylist)
@@ -117,9 +120,14 @@ export function AddToPlaylistProvider({
async (albumId: Id<"albums">) => {
const requestId = ++selectionRequestRef.current
try {
const songIds = await convex.query(api.playlists.getAlbumSongIds, {
albumId,
})
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getAlbumSongIds,
{
albumId,
}
)
if (requestId === selectionRequestRef.current) {
showAddToPlaylist(songIds)
}
@@ -131,16 +139,21 @@ export function AddToPlaylistProvider({
}
}
},
[convex, showAddToPlaylist]
[convex, cacheScope, showAddToPlaylist]
)
const openAddPlaylistToPlaylist = React.useCallback(
async (playlistId: Id<"playlists">) => {
const requestId = ++selectionRequestRef.current
try {
const songIds = await convex.query(api.playlists.getPlaylistSongIds, {
playlistId,
})
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getPlaylistSongIds,
{
playlistId,
}
)
if (requestId === selectionRequestRef.current) {
showAddToPlaylist(songIds)
}
@@ -152,16 +165,21 @@ export function AddToPlaylistProvider({
}
}
},
[convex, showAddToPlaylist]
[convex, cacheScope, showAddToPlaylist]
)
const openAddArtistToPlaylist = React.useCallback(
async (artistId: Id<"artists">) => {
const requestId = ++selectionRequestRef.current
try {
const songIds = await convex.query(api.playlists.getArtistSongIds, {
artistId,
})
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getArtistSongIds,
{
artistId,
}
)
if (requestId === selectionRequestRef.current) {
showAddToPlaylist(songIds)
}
@@ -173,7 +191,7 @@ export function AddToPlaylistProvider({
}
}
},
[convex, showAddToPlaylist]
[convex, cacheScope, showAddToPlaylist]
)
const openCreatePlaylist = React.useCallback(() => {
+11 -3
View File
@@ -6,6 +6,7 @@ import Link from "next/link"
import { MoreHorizontal, Play } from "lucide-react"
import { useConvex } from "convex/react"
import { useCacheScope } from "@/components/persistent-cache-provider"
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
import { useFavorites } from "@/components/favorites-provider"
import {
@@ -25,6 +26,7 @@ import type { BrowseAlbum } from "@otunes/convex/types"
import type { Id } from "@otunes/convex/_generated/dataModel"
import { albumCoverUrl } from "@/lib/cover-urls"
import { cn } from "@/lib/utils"
import { fetchCachedQuery } from "@/lib/cached-query"
let activeAlbumCardMenuClose: (() => void) | null = null
@@ -43,6 +45,7 @@ function closeExclusiveAlbumCardMenu(closeMenu: () => void) {
export function AlbumCard({ album }: { album: BrowseAlbum }) {
const convex = useConvex()
const cacheScope = useCacheScope()
const { openAddAlbumToPlaylist } = useAddToPlaylist()
const { isAlbumFavorite, toggleAlbumFavorite } = useFavorites()
const { playAlbum } = usePlayback()
@@ -77,9 +80,14 @@ export function AlbumCard({ album }: { album: BrowseAlbum }) {
case "play-next":
case "play-last":
case "shuffle": {
const songIds = await convex.query(api.playlists.getAlbumSongIds, {
albumId: album.id as Id<"albums">,
})
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getAlbumSongIds,
{
albumId: album.id as Id<"albums">,
}
)
void runQueueAction(action, songIds)
break
}
+34
View File
@@ -0,0 +1,34 @@
"use client"
import { AlbumView } from "@/components/album-view"
import { CollectionDetailSkeleton } from "@/components/library-skeletons"
import { PageMessage } from "@/components/page-message"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
export function AlbumPage({
albumId,
highlightedSongId,
}: {
albumId: Id<"albums">
highlightedSongId?: string
}) {
const album = useCachedQuery(api.library.browseAlbumDetail, { id: albumId })
if (album === undefined) {
return <CollectionDetailSkeleton />
}
if (album === null) {
return <PageMessage>Album not found.</PageMessage>
}
return (
<AlbumView
key={album.id}
album={album}
highlightedSongId={highlightedSongId}
/>
)
}
+15 -2
View File
@@ -39,6 +39,7 @@ import {
} from "@/lib/selection-range-styles"
import { albumCoverUrl } from "@/lib/cover-urls"
import { sumDurationSeconds } from "@/lib/media-summary"
import { albumDetailSongs, rememberSongs } from "@/lib/song-cache"
function formatDuration(seconds: number): string {
const minutes = Math.floor(seconds / 60)
@@ -269,6 +270,11 @@ export function AlbumView({
() => album.tracks.map((track) => track.id as Id<"songs">),
[album.tracks]
)
React.useEffect(() => {
rememberSongs(albumDetailSongs(album))
}, [album])
const metadata = formatMetadata(album.genre, album.year)
const [activeTrackId, setActiveTrackId] = React.useState("")
const validHighlightedSongId = React.useMemo(() => {
@@ -398,14 +404,21 @@ export function AlbumView({
size="icon"
className="rounded-full"
aria-label="Shuffle album"
onClick={() => void playAlbumShuffled(album.id as Id<"albums">)}
onClick={() =>
void playAlbumShuffled(
album.id as Id<"albums">,
albumSongIds
)
}
>
<Shuffle />
</Button>
<Button
className="h-10 gap-2 rounded-full bg-foreground px-6 text-background hover:bg-foreground/90"
aria-label={`Play ${album.title}`}
onClick={() => void playAlbum(album.id as Id<"albums">)}
onClick={() =>
void playAlbum(album.id as Id<"albums">, albumSongIds)
}
>
<Play className="fill-current" />
Play
+7 -3
View File
@@ -41,9 +41,11 @@ import Image from "next/image"
import Link from "next/link"
import { useTheme } from "next-themes"
import * as React from "react"
import { useQuery } from "convex/react"
import { api } from "@otunes/convex/_generated/api"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { useMounted } from "@/hooks/use-mounted"
import { clearPersistentCache } from "@/lib/persistent-cache"
import { resetPlaybackStores } from "@/lib/playback-store"
const OptionsModal = dynamic(() =>
import("@/components/options-modal").then((module) => module.OptionsModal)
@@ -64,8 +66,8 @@ export function AppSidebar() {
const pathname = usePathname()
const router = useRouter()
const { signOut } = useAuthActions()
const user = useQuery(api.auth.currentUser)
const sidebarPlaylists = useQuery(api.playlists.listSidebarPlaylists)
const user = useCachedQuery(api.auth.currentUser)
const sidebarPlaylists = useCachedQuery(api.playlists.listSidebarPlaylists)
const fallbackLetters = user?.name?.match(/\b(\w)/g)?.join("") || "NA"
const { resolvedTheme } = useTheme()
@@ -74,6 +76,8 @@ export function AppSidebar() {
async function handleSignOut() {
await signOut()
resetPlaybackStores()
await clearPersistentCache()
router.push("/signin")
}
+22
View File
@@ -0,0 +1,22 @@
"use client"
import { ArtistView } from "@/components/artist-view"
import { ArtistDetailSkeleton } from "@/components/library-skeletons"
import { PageMessage } from "@/components/page-message"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
export function ArtistPage({ artistId }: { artistId: Id<"artists"> }) {
const data = useCachedQuery(api.library.browseArtistDetail, { id: artistId })
if (data === undefined) {
return <ArtistDetailSkeleton />
}
if (data === null) {
return <PageMessage>Artist not found.</PageMessage>
}
return <ArtistView artist={data.artist} albums={data.albums} />
}
+6 -1
View File
@@ -5,6 +5,7 @@ import Image from "next/image"
import { Play, Shuffle } from "lucide-react"
import { useConvex } from "convex/react"
import { useCacheScope } from "@/components/persistent-cache-provider"
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
import { useFavorites } from "@/components/favorites-provider"
import { usePlayback } from "@/components/playback-provider"
@@ -22,6 +23,7 @@ import type { Id } from "@otunes/convex/_generated/dataModel"
import type { BrowseAlbum, BrowseArtist } from "@otunes/convex/types"
import { albumGridClassName } from "@/lib/album-grid-classes"
import { artistCoverUrl } from "@/lib/cover-urls"
import { fetchCachedQuery } from "@/lib/cached-query"
export function ArtistView({
artist,
@@ -35,6 +37,7 @@ export function ArtistView({
const { playArtist, playArtistShuffled } = usePlayback()
const { runQueueAction } = useQueueMediaActions()
const convex = useConvex()
const cacheScope = useCacheScope()
async function handleMediaAction(action: MediaContextAction) {
switch (action) {
@@ -47,7 +50,9 @@ export function ArtistView({
case "play-next":
case "play-last":
case "shuffle": {
const songIds = await convex.query(
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getOrderedArtistSongIds,
{ artistId: artist.id as Id<"artists"> }
)
+43
View File
@@ -0,0 +1,43 @@
"use client"
import { usePathname } from "next/navigation"
import { useCallback } from "react"
import { ArtistsView } from "@/components/artists-view"
import { ArtistsSkeleton, PageHeader } from "@/components/library-skeletons"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { api } from "@otunes/convex/_generated/api"
const ARTISTS_PATH = "/library/artists"
function artistIdFromPathname(pathname: string) {
const [, id] = pathname.slice(ARTISTS_PATH.length).split("/")
return id ? decodeURIComponent(id) : undefined
}
export function ArtistsPage() {
const pathname = usePathname()
const artists = useCachedQuery(api.library.browseArtists)
const albums = useCachedQuery(api.library.browseAlbums)
const selectArtist = useCallback((artistId: string) => {
window.history.pushState(null, "", `${ARTISTS_PATH}/${artistId}`)
}, [])
return (
<div className="flex h-svh flex-col">
<PageHeader title="Artists" />
{artists === undefined || albums === undefined ? (
<ArtistsSkeleton />
) : (
<ArtistsView
artists={artists}
albums={albums}
artistId={artistIdFromPathname(pathname)}
onSelectArtist={selectArtist}
/>
)}
</div>
)
}
+9 -4
View File
@@ -3,10 +3,10 @@
import * as React from "react"
import Image from "next/image"
import Link from "next/link"
import { useRouter } from "next/navigation"
import { ChevronRightIcon, Play, Shuffle } from "lucide-react"
import { useConvex } from "convex/react"
import { useCacheScope } from "@/components/persistent-cache-provider"
import { AlbumCard } from "@/components/album-card"
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
import { FavoriteMediaButton } from "@/components/favorite-media-button"
@@ -24,6 +24,7 @@ import { cn } from "@/lib/utils"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type { BrowseAlbum, BrowseArtist } from "@otunes/convex/types"
import { artistCoverUrl } from "@/lib/cover-urls"
import { fetchCachedQuery } from "@/lib/cached-query"
function ArtistAvatar({ artist }: { artist: BrowseArtist }) {
return (
@@ -91,12 +92,13 @@ export function ArtistsView({
artists,
albums,
artistId,
onSelectArtist,
}: {
artists: BrowseArtist[]
albums: BrowseAlbum[]
artistId?: string
onSelectArtist: (artistId: string) => void
}) {
const router = useRouter()
const sortedArtists = React.useMemo(
() => [...artists].sort((a, b) => a.name.localeCompare(b.name)),
[artists]
@@ -109,6 +111,7 @@ export function ArtistsView({
return sortedArtists[0]?.id ?? ""
}, [artistId, sortedArtists])
const convex = useConvex()
const cacheScope = useCacheScope()
const { openAddArtistToPlaylist } = useAddToPlaylist()
const { isArtistFavorite, toggleArtistFavorite } = useFavorites()
const { playArtist, playArtistShuffled } = usePlayback()
@@ -141,7 +144,9 @@ export function ArtistsView({
case "play-next":
case "play-last":
case "shuffle": {
const songIds = await convex.query(
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getOrderedArtistSongIds,
{ artistId: artistId as Id<"artists"> }
)
@@ -162,7 +167,7 @@ export function ArtistsView({
albumCount={albumCountByArtistId.get(artist.id) ?? 0}
isSelected={artist.id === selectedId}
isFavorite={isArtistFavorite(artist.id)}
onSelect={() => router.push(`/library/artists/${artist.id}`)}
onSelect={() => onSelectArtist(artist.id)}
onMediaAction={(action) =>
void handleMediaAction(artist.id, action)
}
@@ -5,6 +5,8 @@ import { buildConvexUrl } from "@otunes/convex/server-url"
import { ConvexReactClient } from "convex/react"
import { ReactNode } from "react"
import { PersistentCacheProvider } from "@/components/persistent-cache-provider"
// Server rendering never runs Convex queries, so this URL is never contacted.
const SSR_CONVEX_URL = "http://127.0.0.1:3210"
@@ -37,7 +39,6 @@ export function ConvexClientProvider({
}) {
return (
<ConvexAuthNextjsProvider client={getConvexClient(convexUrl)}>
{children}
</ConvexAuthNextjsProvider>
<PersistentCacheProvider>{children}</PersistentCacheProvider> </ConvexAuthNextjsProvider>
)
}
+3 -2
View File
@@ -1,9 +1,10 @@
"use client"
import * as React from "react"
import { useMutation, useQuery } from "convex/react"
import { useMutation } from "convex/react"
import { toast } from "sonner"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
@@ -32,7 +33,7 @@ export function useFavorites() {
}
export function FavoritesProvider({ children }: { children: React.ReactNode }) {
const favorites = useQuery(api.favorites.getUserFavorites)
const favorites = useCachedQuery(api.favorites.getUserFavorites)
const favoriteSong = useMutation(api.favorites.favoriteSong).withOptimisticUpdate(
(store, { songId }) => {
const current = store.getQuery(api.favorites.getUserFavorites, {})
-9
View File
@@ -1,9 +0,0 @@
import { Spinner } from "@/components/ui/spinner"
export function LibraryLoading() {
return (
<div className="flex flex-1 items-center justify-center p-6 pb-28">
<Spinner className="size-6 text-muted-foreground" />
</div>
)
}
+245
View File
@@ -0,0 +1,245 @@
import { Skeleton } from "@/components/ui/skeleton"
import { albumGridClassName } from "@/lib/album-grid-classes"
import { TRACK_LIST_CONTAINER } from "@/lib/selection-range-styles"
import { cn } from "@/lib/utils"
function LoadingRegion({
className,
children,
}: {
className?: string
children: React.ReactNode
}) {
return (
<div role="status" aria-busy className={className}>
<span className="sr-only">Loading</span>
{children}
</div>
)
}
export function PageHeader({ title }: { title: string }) {
return (
<header className="flex items-center gap-2 border-b px-4 py-3">
<h1 className="text-lg font-semibold">{title}</h1>
</header>
)
}
function CardSkeleton({ round = false }: { round?: boolean }) {
return (
<div className="flex flex-col gap-2">
<Skeleton
className={cn(
"aspect-square w-full",
round ? "rounded-full" : "rounded-lg"
)}
/>
<div className={cn("flex flex-col gap-1.5", round && "items-center")}>
<Skeleton className="h-3.5 w-3/4" />
{round ? null : <Skeleton className="h-3 w-1/2" />}
</div>
</div>
)
}
function CardGrid({ count }: { count: number }) {
return (
<div className={albumGridClassName}>
{Array.from({ length: count }, (_, index) => (
<CardSkeleton key={index} />
))}
</div>
)
}
export function CardGridSkeleton({ count = 18 }: { count?: number }) {
return (
<LoadingRegion className="flex-1 overflow-hidden p-6 pb-28">
<CardGrid count={count} />
</LoadingRegion>
)
}
function CarouselRowSkeleton() {
return (
<section className="flex min-w-0 flex-col gap-4">
<Skeleton className="h-7 w-44" />
<div className="-ml-4 flex overflow-hidden">
{Array.from({ length: 6 }, (_, index) => (
<div
key={index}
className="min-w-0 shrink-0 grow-0 basis-1/2 pl-4 sm:basis-1/3 md:basis-1/4 lg:basis-1/5 xl:basis-1/6"
>
<CardSkeleton />
</div>
))}
</div>
</section>
)
}
export function HomeSkeleton() {
return (
<LoadingRegion className="flex flex-1 flex-col gap-10 overflow-hidden p-6 pb-28">
<CarouselRowSkeleton />
<CarouselRowSkeleton />
</LoadingRegion>
)
}
function TrackRowSkeleton({ showCover = false }: { showCover?: boolean }) {
return (
<div className="flex items-center gap-4 py-2.5 pr-10 pl-8">
{showCover ? (
<Skeleton className="size-9 shrink-0 rounded" />
) : (
<Skeleton className="h-3.5 w-5 shrink-0" />
)}
<div className="flex min-w-0 flex-1 flex-col gap-1.5">
<Skeleton className="h-3.5 w-2/5 max-w-72" />
<Skeleton className="h-3 w-1/4 max-w-40" />
</div>
<Skeleton className="h-3 w-9 shrink-0" />
</div>
)
}
export function TrackListSkeleton({
count = 12,
showCover = false,
}: {
count?: number
showCover?: boolean
}) {
return (
<div className="flex flex-col">
{Array.from({ length: count }, (_, index) => (
<TrackRowSkeleton key={index} showCover={showCover} />
))}
</div>
)
}
export function SongListSkeleton() {
return (
<LoadingRegion className="flex-1 overflow-hidden pt-9 pb-28">
<TrackListSkeleton count={16} showCover />
</LoadingRegion>
)
}
/** Matches the header + track list layout of album and playlist pages. */
export function CollectionDetailSkeleton() {
return (
<LoadingRegion className="flex h-svh flex-col overflow-hidden pb-28">
<div className="mx-auto w-full max-w-9/10 min-w-0">
<div className="flex flex-col gap-8 px-6 pt-6 pb-8 sm:flex-row sm:items-end">
<Skeleton className="mx-auto aspect-square w-full max-w-60 shrink-0 rounded-lg sm:mx-0" />
<div className="flex min-w-0 flex-1 flex-col items-center gap-4 sm:items-start">
<div className="flex w-full flex-col items-center gap-2 sm:items-start">
<Skeleton className="h-3 w-14" />
<Skeleton className="h-9 w-2/3 max-w-96" />
<Skeleton className="h-5 w-40" />
</div>
<div className="flex items-center gap-2">
<Skeleton className="size-9 rounded-full" />
<Skeleton className="h-10 w-28 rounded-full" />
<Skeleton className="size-9 rounded-full" />
<Skeleton className="size-9 rounded-full" />
</div>
</div>
</div>
</div>
<div className={TRACK_LIST_CONTAINER}>
<TrackListSkeleton />
</div>
</LoadingRegion>
)
}
export function ArtistDetailSkeleton() {
return (
<LoadingRegion className="flex h-svh flex-col overflow-hidden pb-28">
<div className="flex min-w-0 items-center gap-4 px-6 pt-6 pb-8 sm:gap-6">
<Skeleton className="size-32 shrink-0 rounded-full sm:size-40" />
<div className="flex min-w-0 flex-1 flex-col gap-4">
<Skeleton className="h-10 w-1/2 max-w-80" />
<div className="flex items-center gap-2">
<Skeleton className="size-11 rounded-full" />
<Skeleton className="size-11 rounded-full" />
<Skeleton className="size-11 rounded-full" />
</div>
</div>
</div>
<div className="flex flex-col gap-4 px-6">
<Skeleton className="h-7 w-24" />
<CardGrid count={6} />
</div>
</LoadingRegion>
)
}
function ArtistListSkeleton() {
return (
<div className="w-72 shrink-0 overflow-hidden border-r pb-28">
{Array.from({ length: 14 }, (_, index) => (
<div key={index} className="flex items-center gap-3 px-4 py-2.5">
<Skeleton className="size-8 shrink-0 rounded-full" />
<Skeleton className="h-3.5 flex-1" />
</div>
))}
</div>
)
}
export function ArtistsSkeleton() {
return (
<LoadingRegion className="flex min-h-0 flex-1">
<ArtistListSkeleton />
<div className="min-w-0 flex-1 overflow-hidden">
<div className="flex items-center justify-between gap-4 border-b px-6 py-4">
<Skeleton className="h-7 w-48" />
<div className="flex items-center gap-2">
<Skeleton className="size-9 rounded-full" />
<Skeleton className="size-9 rounded-full" />
</div>
</div>
<div className="p-6">
<div className="grid grid-cols-2 gap-x-6 gap-y-8 sm:grid-cols-3 lg:grid-cols-4">
{Array.from({ length: 8 }, (_, index) => (
<CardSkeleton key={index} />
))}
</div>
</div>
</div>
</LoadingRegion>
)
}
export function SearchResultsSkeleton() {
return (
<LoadingRegion className="flex-1 overflow-hidden p-6 pb-28">
<div className="mx-auto flex max-w-6xl flex-col gap-10">
<section className="flex flex-col gap-4">
<Skeleton className="h-7 w-36" />
<div className="grid gap-2 sm:grid-cols-2 xl:grid-cols-3">
{Array.from({ length: 3 }, (_, index) => (
<div
key={index}
className="flex items-center gap-4 rounded-lg p-3"
>
<Skeleton className="size-16 shrink-0 rounded-md" />
<div className="flex flex-1 flex-col gap-2">
<Skeleton className="h-4 w-2/3" />
<Skeleton className="h-3 w-1/3" />
</div>
</div>
))}
</div>
</section>
<CarouselRowSkeleton />
</div>
</LoadingRegion>
)
}
+9
View File
@@ -0,0 +1,9 @@
export function PageMessage({ children }: { children: React.ReactNode }) {
return (
<div className="flex h-svh flex-col">
<div className="flex flex-1 items-center justify-center pb-28">
<p className="text-sm text-muted-foreground">{children}</p>
</div>
</div>
)
}
@@ -0,0 +1,52 @@
"use client"
import { useAuthToken } from "@convex-dev/auth/react"
import { createContext, ReactNode, useContext, useEffect, useMemo } from "react"
import { loadPersistentCache } from "@/lib/persistent-cache"
export const ANONYMOUS_CACHE_SCOPE = "anon"
const CacheScopeContext = createContext(ANONYMOUS_CACHE_SCOPE)
if (typeof window !== "undefined") {
void loadPersistentCache()
}
function userIdFromToken(token: string | null) {
const payload = token?.split(".")[1]
if (!payload) {
return null
}
try {
const json = atob(payload.replace(/-/g, "+").replace(/_/g, "/"))
const subject = (JSON.parse(json) as { sub?: unknown }).sub
return typeof subject === "string" ? (subject.split("|")[0] ?? null) : null
} catch {
return null
}
}
/** Namespaces persisted client data by the signed-in user. */
export function PersistentCacheProvider({ children }: { children: ReactNode }) {
const token = useAuthToken()
const scope = useMemo(
() => userIdFromToken(token) ?? ANONYMOUS_CACHE_SCOPE,
[token]
)
useEffect(() => {
void loadPersistentCache()
}, [])
return (
<CacheScopeContext.Provider value={scope}>
{children}
</CacheScopeContext.Provider>
)
}
export function useCacheScope() {
return useContext(CacheScopeContext)
}
+356 -196
View File
@@ -12,7 +12,7 @@ import {
useSyncExternalStore,
useMemo,
} from "react"
import { useMutation, useQuery } from "convex/react"
import { useConvex, useMutation, useQuery } from "convex/react"
import type Hls from "hls.js"
import { toast } from "sonner"
@@ -20,13 +20,26 @@ import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type { BrowseSong } from "@otunes/convex/types"
import { playbackStreamPlan } from "@otunes/convex/playback-stream"
import {
ANONYMOUS_CACHE_SCOPE,
useCacheScope,
} from "@/components/persistent-cache-provider"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { useMediaSession } from "@/hooks/use-media-session"
import { fetchCachedQuery } from "@/lib/cached-query"
import { supportsDolbyAtmosPlayback } from "@/lib/dolby-atmos-support"
import { flushPersistentCache } from "@/lib/persistent-cache"
import * as playbackQueue from "@/lib/playback-queue"
import type { RepeatMode } from "@/lib/playback-queue"
import {
getPlaybackStore,
getServerPlaybackSnapshot,
} from "@/lib/playback-store"
import { rememberSongs, useSong } from "@/lib/song-cache"
import { songHlsPlaylistUrl, songPlayUrl } from "@/lib/song-play-url"
type RepeatMode = "none" | "once" | "always"
const PREVIOUS_TRACK_RESTART_THRESHOLD_SECONDS = 5
const PROGRESS_SAVE_INTERVAL_MS = 5000
type PlaybackContextValue = {
queueSongIds: Id<"songs">[]
@@ -53,12 +66,23 @@ type PlaybackContextValue = {
sortDirection: "asc" | "desc"
}
) => Promise<void>
playAlbum: (albumId: Id<"albums">) => Promise<void>
playAlbumShuffled: (albumId: Id<"albums">) => Promise<void>
/** Pass `songIds` when the caller already has the album's tracks. */
playAlbum: (albumId: Id<"albums">, songIds?: Id<"songs">[]) => Promise<void>
playAlbumShuffled: (
albumId: Id<"albums">,
songIds?: Id<"songs">[]
) => Promise<void>
playArtist: (artistId: Id<"artists">) => Promise<void>
playArtistShuffled: (artistId: Id<"artists">) => Promise<void>
playPlaylist: (playlistId: Id<"playlists">) => Promise<void>
playPlaylistShuffled: (playlistId: Id<"playlists">) => Promise<void>
/** Pass `songIds` when the caller already has the playlist's songs. */
playPlaylist: (
playlistId: Id<"playlists">,
songIds?: Id<"songs">[]
) => Promise<void>
playPlaylistShuffled: (
playlistId: Id<"playlists">,
songIds?: Id<"songs">[]
) => Promise<void>
toggleShuffle: () => Promise<void>
cycleRepeat: () => Promise<void>
clearQueue: () => Promise<void>
@@ -279,8 +303,62 @@ export function usePlaybackProgress() {
}
export function PlaybackProvider({ children }: { children: ReactNode }) {
const user = useQuery(api.auth.currentUser)
const playback = useQuery(api.playback.getPlaybackState)
const convex = useConvex()
const cacheScope = useCacheScope()
const isSignedIn = cacheScope !== ANONYMOUS_CACHE_SCOPE
const store = useMemo(
() => getPlaybackStore(isSignedIn ? cacheScope : null),
[cacheScope, isSignedIn]
)
const playback = useSyncExternalStore(
store.subscribe,
store.getSnapshot,
getServerPlaybackSnapshot
)
const user = useCachedQuery(api.auth.currentUser)
const serverPlayback = useQuery(
api.playback.getPlaybackState,
isSignedIn ? {} : "skip"
)
const syncPlaybackStateMutation = useMutation(
api.playback.syncPlaybackState
)
const recordPlayMutation = useMutation(api.playback.recordPlay)
const updateSongProgressMutation = useMutation(api.playback.updateSongProgress)
useEffect(() => {
if (!isSignedIn) {
return
}
store.setTransport((state) =>
syncPlaybackStateMutation({
songQueue: state.queue,
queueHistory: state.history,
shuffleEnabled: state.shuffleEnabled,
repeatEnabled: state.repeatEnabled,
currentSongProgress: state.progressSeconds,
})
)
return () => store.setTransport(null)
}, [store, isSignedIn, syncPlaybackStateMutation])
useEffect(() => {
if (!serverPlayback) {
return
}
if (serverPlayback.currentSong) {
rememberSongs([serverPlayback.currentSong])
}
store.receiveServerState(serverPlayback)
}, [store, serverPlayback])
const recordPlay = useCallback(
(args: { songId?: Id<"songs">; playlistId?: Id<"playlists"> }) => {
void recordPlayMutation(args).catch(() => {})
},
[recordPlayMutation]
)
const audioRef = useRef<HTMLAudioElement | null>(null)
const hlsRef = useRef<Hls | null>(null)
const preloadAudioRef = useRef<HTMLAudioElement | null>(null)
@@ -292,56 +370,6 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
const autoPlayNextRef = useRef(false)
const intentionalLoadRef = useRef(false)
const ignoreAudioSyncRef = useRef(false)
const playInOrderMutation = useMutation(api.playback.playInOrder)
const playShuffledMutation = useMutation(api.playback.playShuffled)
const addToQueueNextMutation = useMutation(api.playback.addToQueueNext)
const addToQueueLastMutation = useMutation(api.playback.addToQueueLast)
const playFromSongMutation = useMutation(api.playback.playFromSong)
const playFromLibrarySongMutation = useMutation(
api.playback.playFromLibrarySong
)
const playAlbumMutation = useMutation(api.playback.playAlbum)
const playAlbumShuffledMutation = useMutation(api.playback.playAlbumShuffled)
const playArtistMutation = useMutation(api.playback.playArtist)
const playArtistShuffledMutation = useMutation(
api.playback.playArtistShuffled
)
const playPlaylistMutation = useMutation(api.playback.playPlaylist)
const playPlaylistShuffledMutation = useMutation(
api.playback.playPlaylistShuffled
)
const toggleShuffleMutation = useMutation(
api.playback.toggleShuffle
).withOptimisticUpdate((store) => {
const current = store.getQuery(api.playback.getPlaybackState, {})
if (!current) return
store.setQuery(api.playback.getPlaybackState, {}, {
...current,
shuffleEnabled: !current.shuffleEnabled,
})
})
const cycleRepeatMutation = useMutation(
api.playback.cycleRepeat
).withOptimisticUpdate((store) => {
const current = store.getQuery(api.playback.getPlaybackState, {})
if (!current) return
const next =
current.repeatEnabled === "none"
? "once"
: current.repeatEnabled === "once"
? "always"
: "none"
store.setQuery(api.playback.getPlaybackState, {}, {
...current,
repeatEnabled: next,
})
})
const clearQueueMutation = useMutation(api.playback.clearQueue)
const reorderQueueMutation = useMutation(api.playback.reorderQueue)
const skipToQueueIndexMutation = useMutation(api.playback.skipToQueueIndex)
const skipNextMutation = useMutation(api.playback.skipNext)
const skipPreviousMutation = useMutation(api.playback.skipPrevious)
const updateSongProgressMutation = useMutation(api.playback.updateSongProgress)
const progressRestoredForSongRef = useRef<Id<"songs"> | null>(null)
const lastSavedProgressRef = useRef(-1)
@@ -381,29 +409,29 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
}
}, [])
const currentSong = playback?.currentSong ?? null
const currentSongId = currentSong?.id ?? null
const queueSongIds = playback.queue
const currentSongId = queueSongIds[0] ?? null
const currentSong = useSong(currentSongId)
const playbackQuality = user?.playbackQuality
const preferAtmos = user?.preferAtmos
const duration =
currentSong && measuredDuration?.songId === currentSong.id
currentSongId && measuredDuration?.songId === currentSongId
? measuredDuration.seconds
: (currentSong?.durationSeconds ?? 0)
useEffect(() => {
durationRef.current = duration
}, [duration])
const currentSongDoc = useQuery(
const currentSongDoc = useCachedQuery(
api.library.getSongPlaybackInfo,
currentSong ? { id: currentSong.id } : "skip"
currentSongId ? { id: currentSongId } : "skip"
)
const isPlaybackActive = Boolean(currentSong && isPlaying)
const repeatEnabled = playback?.repeatEnabled ?? "none"
const queueLength = playback?.queueSongIds.length ?? 0
const queueSongIds = playback?.queueSongIds ?? []
const isPlaybackActive = Boolean(currentSongId && isPlaying)
const repeatEnabled = playback.repeatEnabled
const queueLength = queueSongIds.length
const nextQueueSongId =
queueSongIds.length > 1 ? queueSongIds[1] : null
const nextQueueSongDoc = useQuery(
const nextQueueSongDoc = useCachedQuery(
api.library.getSongPlaybackInfo,
nextQueueSongId ? { id: nextQueueSongId } : "skip"
)
@@ -439,16 +467,19 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
}
lastSavedProgressRef.current = progressSeconds
void updateSongProgressMutation({
songId: currentSongId,
progressSeconds,
})
store.setProgress(currentSongId, progressSeconds)
if (isSignedIn) {
void updateSongProgressMutation({
songId: currentSongId,
progressSeconds,
}).catch(() => {})
}
},
[currentSongId, updateSongProgressMutation]
[currentSongId, store, isSignedIn, updateSongProgressMutation]
)
useEffect(() => {
if (!currentSongId || !playback) {
if (!currentSongId) {
return
}
@@ -458,8 +489,8 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
progressRestoredForSongRef.current = currentSongId
lastSavedProgressRef.current = -1
setProgressToRestore(playback.currentSongProgress ?? 0)
}, [currentSongId, playback])
setProgressToRestore(store.getState().progressSeconds)
}, [currentSongId, store])
useEffect(() => {
if (progressToRestore === null || progressToRestore <= 0) {
@@ -520,13 +551,36 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
}
saveProgress(audio.currentTime)
}, 5000)
}, PROGRESS_SAVE_INTERVAL_MS)
return () => {
window.clearInterval(interval)
}
}, [isPlaying, currentSongId, saveProgress])
useEffect(() => {
const persistNow = () => {
const audio = audioRef.current
const restorePending = progressToRestore !== null && progressToRestore > 0
if (audio && currentSongId && !restorePending) {
saveProgress(audio.currentTime)
}
flushPersistentCache()
}
const onVisibilityChange = () => {
if (document.visibilityState === "hidden") {
persistNow()
}
}
window.addEventListener("pagehide", persistNow)
document.addEventListener("visibilitychange", onVisibilityChange)
return () => {
window.removeEventListener("pagehide", persistNow)
document.removeEventListener("visibilitychange", onVisibilityChange)
}
}, [currentSongId, progressToRestore, saveProgress])
useEffect(() => {
isPlayingRef.current = isPlaying
}, [isPlaying])
@@ -797,7 +851,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
useEffect(() => {
const audio = audioRef.current
if (!audio || !currentSong) {
if (!audio || !currentSongId) {
return
}
@@ -827,7 +881,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
return () => {
audio.removeEventListener("canplay", onCanPlay)
}
}, [isPlaying, currentSong, attemptPlayback])
}, [isPlaying, currentSongId, attemptPlayback])
useEffect(() => {
const audio = audioRef.current
@@ -836,7 +890,8 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
}
const handleEnded = () => {
if (repeatEnabled === "once") {
const loopsSingleSong = repeatEnabled === "always" && queueLength === 1
if (repeatEnabled === "once" || loopsSingleSong) {
audio.currentTime = 0
void audio.play()
return
@@ -885,34 +940,23 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
}
}
void skipNextMutation()
.then(() => {
if (shouldContinuePlaying) {
autoPlayNextRef.current = true
isPlayingRef.current = true
setIsPlaying(true)
return
}
store.update(playbackQueue.skipNext)
autoPlayNextRef.current = false
isPlayingRef.current = false
audio.currentTime = 0
currentTimeRef.current = 0
setCurrentTime(0)
setIsPlaying(false)
})
.catch(() => {
autoPlayNextRef.current = false
isPlayingRef.current = false
setIsPlaying(false)
})
if (!shouldContinuePlaying) {
autoPlayNextRef.current = false
isPlayingRef.current = false
audio.currentTime = 0
currentTimeRef.current = 0
setCurrentTime(0)
setIsPlaying(false)
}
}
const handleError = () => {
if (intentionalLoadRef.current) {
return
}
if (!currentSong || playbackErrorHandledRef.current) {
if (!currentSongId || playbackErrorHandledRef.current) {
return
}
playbackErrorHandledRef.current = true
@@ -936,7 +980,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
toast.error("Playback error", {
description: "Could not play this track. The queue has been cleared.",
})
void clearQueueMutation()
store.update(playbackQueue.clearQueue)
}
audio.addEventListener("ended", handleEnded)
@@ -948,14 +992,13 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
}
}, [
repeatEnabled,
currentSong,
currentSongId,
queueLength,
nextQueueSongId,
nextQueueSongDoc,
user,
dolbyAtmosSupported,
skipNextMutation,
clearQueueMutation,
store,
destroyHls,
runWithoutAudioSync,
attemptPlayback,
@@ -968,16 +1011,17 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
}
const syncDuration = () => {
if (!currentSongId) {
return
}
if (Number.isFinite(audio.duration) && audio.duration > 0) {
if (currentSong) {
setMeasuredDuration({
songId: currentSong.id,
seconds: audio.duration,
})
}
setMeasuredDuration({
songId: currentSongId,
seconds: audio.duration,
})
} else if (currentSong) {
setMeasuredDuration({
songId: currentSong.id,
songId: currentSongId,
seconds: currentSong.durationSeconds,
})
}
@@ -999,17 +1043,72 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
audio.removeEventListener("loadedmetadata", syncDuration)
audio.removeEventListener("seeked", syncTime)
}
}, [currentSong])
}, [currentSongId, currentSong])
const playRequestRef = useRef(0)
const startPlayback = useCallback(
(
recipe: (
state: playbackQueue.PlaybackQueueState
) => playbackQueue.PlaybackQueueState,
recorded: { playlistId?: Id<"playlists"> } = {}
) => {
playRequestRef.current += 1
const previousSongId = store.getState().queue[0]
store.update(recipe)
const firstSongId = store.getState().queue[0]
if (!firstSongId) {
return
}
if (firstSongId === previousSongId) {
seekTo(0)
}
setIsPlaying(true)
recordPlay(
recorded.playlistId
? { playlistId: recorded.playlistId }
: { songId: firstSongId }
)
},
[store, seekTo, recordPlay]
)
const playCollection = useCallback(
async (
songIds: Id<"songs">[] | Promise<Id<"songs">[]>,
shuffled: boolean,
recorded: { playlistId?: Id<"playlists"> } = {}
) => {
const request = ++playRequestRef.current
let resolvedSongIds: Id<"songs">[]
try {
resolvedSongIds = await songIds
} catch {
toast.error("Could not load songs to play")
return
}
if (request !== playRequestRef.current || resolvedSongIds.length === 0) {
return
}
startPlayback(
(state) => playbackQueue.startQueue(state, resolvedSongIds, shuffled),
recorded
)
},
[startPlayback]
)
const playInOrder = useCallback(
async (songIds: Id<"songs">[]) => {
if (songIds.length === 0) {
return
}
await playInOrderMutation({ songIds })
setIsPlaying(true)
startPlayback((state) => playbackQueue.startQueue(state, songIds, false))
},
[playInOrderMutation]
[startPlayback]
)
const playShuffled = useCallback(
@@ -1017,10 +1116,9 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
if (songIds.length === 0) {
return
}
await playShuffledMutation({ songIds })
setIsPlaying(true)
startPlayback((state) => playbackQueue.startQueue(state, songIds, true))
},
[playShuffledMutation]
[startPlayback]
)
const addToQueueNext = useCallback(
@@ -1028,10 +1126,10 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
if (songIds.length === 0) {
return
}
await addToQueueNextMutation({ songIds })
store.update((state) => playbackQueue.addToQueue(state, songIds, "next"))
setIsPlaying(true)
},
[addToQueueNextMutation]
[store]
)
const addToQueueLast = useCallback(
@@ -1039,18 +1137,19 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
if (songIds.length === 0) {
return
}
await addToQueueLastMutation({ songIds })
store.update((state) => playbackQueue.addToQueue(state, songIds, "last"))
setIsPlaying(true)
},
[addToQueueLastMutation]
[store]
)
const playFromSong = useCallback(
async (songId: Id<"songs">, songIds: Id<"songs">[]) => {
await playFromSongMutation({ songId, songIds })
setIsPlaying(true)
startPlayback((state) =>
playbackQueue.startQueueFromSong(state, songId, songIds)
)
},
[playFromSongMutation]
[startPlayback]
)
const playFromLibrarySong = useCallback(
@@ -1061,84 +1160,155 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
sortDirection: "asc" | "desc"
}
) => {
await playFromLibrarySongMutation({ songId, ...sort })
setIsPlaying(true)
startPlayback((state) =>
playbackQueue.startQueueFromSong(state, songId, [songId])
)
const request = playRequestRef.current
let songIds: Id<"songs">[]
try {
songIds = await fetchCachedQuery(
convex,
cacheScope,
api.library.browseSortedSongIds,
sort
)
} catch {
return
}
if (request === playRequestRef.current) {
store.update((state) =>
playbackQueue.extendQueueFromSong(state, songId, songIds)
)
}
},
[playFromLibrarySongMutation]
[convex, cacheScope, store, startPlayback]
)
const loadAlbumSongIds = useCallback(
(albumId: Id<"albums">, songIds?: Id<"songs">[]) =>
songIds ??
fetchCachedQuery(convex, cacheScope, api.playlists.getAlbumSongIds, {
albumId,
}),
[convex, cacheScope]
)
const loadArtistSongIds = useCallback(
(artistId: Id<"artists">) =>
fetchCachedQuery(
convex,
cacheScope,
api.playlists.getOrderedArtistSongIds,
{ artistId }
),
[convex, cacheScope]
)
const loadPlaylistSongIds = useCallback(
(playlistId: Id<"playlists">, songIds?: Id<"songs">[]) =>
songIds ??
fetchCachedQuery(convex, cacheScope, api.playlists.getPlaylistSongIds, {
playlistId,
}),
[convex, cacheScope]
)
const playAlbum = useCallback(
async (albumId: Id<"albums">) => {
await playAlbumMutation({ albumId })
setIsPlaying(true)
},
[playAlbumMutation]
(albumId: Id<"albums">, songIds?: Id<"songs">[]) =>
playCollection(loadAlbumSongIds(albumId, songIds), false),
[playCollection, loadAlbumSongIds]
)
const playAlbumShuffled = useCallback(
async (albumId: Id<"albums">) => {
await playAlbumShuffledMutation({ albumId })
setIsPlaying(true)
},
[playAlbumShuffledMutation]
(albumId: Id<"albums">, songIds?: Id<"songs">[]) =>
playCollection(loadAlbumSongIds(albumId, songIds), true),
[playCollection, loadAlbumSongIds]
)
const playArtist = useCallback(
async (artistId: Id<"artists">) => {
await playArtistMutation({ artistId })
setIsPlaying(true)
},
[playArtistMutation]
(artistId: Id<"artists">) =>
playCollection(loadArtistSongIds(artistId), false),
[playCollection, loadArtistSongIds]
)
const playArtistShuffled = useCallback(
async (artistId: Id<"artists">) => {
await playArtistShuffledMutation({ artistId })
setIsPlaying(true)
},
[playArtistShuffledMutation]
(artistId: Id<"artists">) =>
playCollection(loadArtistSongIds(artistId), true),
[playCollection, loadArtistSongIds]
)
const playPlaylist = useCallback(
async (playlistId: Id<"playlists">) => {
await playPlaylistMutation({ playlistId })
setIsPlaying(true)
},
[playPlaylistMutation]
(playlistId: Id<"playlists">, songIds?: Id<"songs">[]) =>
playCollection(loadPlaylistSongIds(playlistId, songIds), false, {
playlistId,
}),
[playCollection, loadPlaylistSongIds]
)
const playPlaylistShuffled = useCallback(
async (playlistId: Id<"playlists">) => {
await playPlaylistShuffledMutation({ playlistId })
setIsPlaying(true)
},
[playPlaylistShuffledMutation]
(playlistId: Id<"playlists">, songIds?: Id<"songs">[]) =>
playCollection(loadPlaylistSongIds(playlistId, songIds), true, {
playlistId,
}),
[playCollection, loadPlaylistSongIds]
)
const toggleQueueOpen = useCallback(() => {
setQueueOpen((open) => !open)
}, [])
const toggleShuffle = useCallback(async () => {
store.update(playbackQueue.toggleShuffle)
}, [store])
const cycleRepeat = useCallback(async () => {
store.update(playbackQueue.cycleRepeat)
}, [store])
const clearQueue = useCallback(async () => {
playRequestRef.current += 1
store.update(playbackQueue.clearQueue)
setIsPlaying(false)
}, [store])
const reorderQueue = useCallback(
async (songIds: Id<"songs">[]) => {
store.update((state) => playbackQueue.reorderQueue(state, songIds))
},
[store]
)
const skipToQueueIndex = useCallback(
async (index: number) => {
store.update((state) => playbackQueue.skipToQueueIndex(state, index))
},
[store]
)
const skipNext = useCallback(async () => {
const isFinishingQueue =
repeatEnabled === "none" && queueSongIds.length <= 1
if (isFinishingQueue) {
const before = store.getState()
if (before.repeatEnabled === "none" && before.queue.length <= 1) {
setIsPlaying(false)
}
store.update(playbackQueue.skipNext)
if (store.getState().queue[0] === before.queue[0]) {
seekTo(0)
}
await skipNextMutation()
if (isFinishingQueue) {
seekTo(0)
}
}, [repeatEnabled, queueSongIds.length, seekTo, skipNextMutation])
}, [store, seekTo])
const skipPrevious = useCallback(async () => {
if (currentTimeRef.current > PREVIOUS_TRACK_RESTART_THRESHOLD_SECONDS) {
seekTo(0)
return
}
await skipPreviousMutation()
}, [seekTo, skipPreviousMutation])
const previousSongId = store.getState().queue[0]
store.update(playbackQueue.skipPrevious)
if (store.getState().queue[0] === previousSongId) {
seekTo(0)
}
}, [store, seekTo])
useMediaSession({
song: currentSong,
@@ -1153,11 +1323,11 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
const value = useMemo<PlaybackContextValue>(
() => ({
queueSongIds: playback?.queueSongIds ?? [],
queueHistorySongIds: playback?.queueHistorySongIds ?? [],
currentSong: playback?.currentSong ?? null,
shuffleEnabled: playback?.shuffleEnabled ?? false,
repeatEnabled: playback?.repeatEnabled ?? "none",
queueSongIds: playback.queue,
queueHistorySongIds: playback.history,
currentSong,
shuffleEnabled: playback.shuffleEnabled,
repeatEnabled: playback.repeatEnabled,
queueOpen,
isPlaying: isPlaybackActive,
volume,
@@ -1177,28 +1347,18 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
playArtistShuffled,
playPlaylist,
playPlaylistShuffled,
toggleShuffle: async () => {
await toggleShuffleMutation()
},
cycleRepeat: async () => {
await cycleRepeatMutation()
},
clearQueue: async () => {
await clearQueueMutation()
setIsPlaying(false)
},
reorderQueue: async (songIds) => {
await reorderQueueMutation({ songIds })
},
skipToQueueIndex: async (index) => {
await skipToQueueIndexMutation({ index })
},
toggleShuffle,
cycleRepeat,
clearQueue,
reorderQueue,
skipToQueueIndex,
skipNext,
skipPrevious,
dolbyAtmosSupported,
}),
[
playback,
currentSong,
queueOpen,
isPlaybackActive,
volume,
@@ -1216,11 +1376,11 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
playArtistShuffled,
playPlaylist,
playPlaylistShuffled,
toggleShuffleMutation,
cycleRepeatMutation,
clearQueueMutation,
reorderQueueMutation,
skipToQueueIndexMutation,
toggleShuffle,
cycleRepeat,
clearQueue,
reorderQueue,
skipToQueueIndex,
skipNext,
skipPrevious,
dolbyAtmosSupported,
+11 -3
View File
@@ -9,6 +9,7 @@ import { playlistCoverUrl } from "@/lib/cover-urls"
import { useConvex } from "convex/react"
import { MoreHorizontal, Play } from "lucide-react"
import { useCacheScope } from "@/components/persistent-cache-provider"
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
import {
MediaContextMenuItems,
@@ -23,9 +24,11 @@ import {
} from "@/components/ui/dropdown-menu"
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
import { api } from "@otunes/convex/_generated/api"
import { fetchCachedQuery } from "@/lib/cached-query"
export function PlaylistCard({ playlist }: { playlist: PlaylistSummary }) {
const convex = useConvex()
const cacheScope = useCacheScope()
const { openAddPlaylistToPlaylist } = useAddToPlaylist()
const { playPlaylist } = usePlayback()
const { runQueueAction } = useQueueMediaActions()
@@ -38,9 +41,14 @@ export function PlaylistCard({ playlist }: { playlist: PlaylistSummary }) {
case "play-next":
case "play-last":
case "shuffle": {
const songIds = await convex.query(api.playlists.getPlaylistSongIds, {
playlistId: playlist.id as Id<"playlists">,
})
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getPlaylistSongIds,
{
playlistId: playlist.id as Id<"playlists">,
}
)
void runQueueAction(action, songIds)
break
}
+38
View File
@@ -0,0 +1,38 @@
"use client"
import { CollectionDetailSkeleton } from "@/components/library-skeletons"
import { PageMessage } from "@/components/page-message"
import { PlaylistView } from "@/components/playlist-view"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
export function PlaylistPage({ playlistId }: { playlistId: Id<"playlists"> }) {
const playlist = useCachedQuery(api.playlists.browsePlaylistDetail, {
id: playlistId,
})
if (playlist === undefined) {
return <CollectionDetailSkeleton />
}
if (playlist === null) {
return <PageMessage>Playlist not found.</PageMessage>
}
return <PlaylistView key={playlist.id} playlist={playlist} />
}
export function FavoritesPlaylistPage() {
const favorites = useCachedQuery(api.favorites.browseFavoritesPlaylistDetail)
if (favorites === undefined) {
return <CollectionDetailSkeleton />
}
if (favorites === null) {
return <PageMessage>Sign in to view your favorites.</PageMessage>
}
return <PlaylistView playlist={favorites} />
}
+28 -8
View File
@@ -3,7 +3,7 @@
import * as React from "react"
import Image from "next/image"
import { useRouter } from "next/navigation"
import { useMutation, useQuery } from "convex/react"
import { useMutation } from "convex/react"
import { Play, Share2, Shuffle, Star, Trash2 } from "lucide-react"
import { toast } from "sonner"
@@ -22,6 +22,7 @@ import {
DropdownMenuSeparator,
} from "@/components/ui/dropdown-menu"
import { ScrollArea } from "@/components/ui/scroll-area"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
import { useTrackSelection } from "@/hooks/use-track-selection"
import { api } from "@otunes/convex/_generated/api"
@@ -30,6 +31,7 @@ import type { BrowsePlaylistDetail, BrowseSong } from "@otunes/convex/types"
import { albumCoverUrl, playlistCoverUrl } from "@/lib/cover-urls"
import { copyPlaylistLink } from "@/lib/media-links"
import { sumDurationSeconds } from "@/lib/media-summary"
import { rememberSongs } from "@/lib/song-cache"
import { cn } from "@/lib/utils"
import {
getSelectionRangePositions,
@@ -263,7 +265,7 @@ function PlaylistSongRow({
export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
const router = useRouter()
const isFavorites = playlist.isFavorites === true
const currentUser = useQuery(api.auth.currentUser)
const currentUser = useCachedQuery(api.auth.currentUser)
const isOwner =
currentUser === undefined
? playlist.isOwner
@@ -277,6 +279,8 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
} = useFavorites()
const {
currentSong,
playInOrder,
playShuffled,
playPlaylist,
playPlaylistShuffled,
playFromSong,
@@ -289,6 +293,7 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
const unsubscribe = useMutation(api.playlists.unsubscribeFromPlaylist)
const [playlistSongs, setPlaylistSongs] = React.useState(playlist.songs)
const [syncedPlaylist, setSyncedPlaylist] = React.useState(playlist)
const [hiddenFavoriteIds, setHiddenFavoriteIds] = React.useState(
() => new Set<string>()
)
@@ -304,6 +309,12 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
const [isSubscribed, setIsSubscribed] = React.useState(playlist.isSubscribed)
const [subscriptionPending, setSubscriptionPending] = React.useState(false)
if (syncedPlaylist !== playlist) {
setSyncedPlaylist(playlist)
setPlaylistSongs(playlist.songs)
setIsSubscribed(playlist.isSubscribed)
}
const {
selectedIds,
selectedCount,
@@ -322,6 +333,19 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
[songs]
)
React.useEffect(() => {
rememberSongs(playlist.songs)
}, [playlist.songs])
function playAll(shuffled: boolean) {
if (playlist.id) {
const play = shuffled ? playPlaylistShuffled : playPlaylist
void play(playlist.id, playlistSongIds)
} else {
void (shuffled ? playShuffled : playInOrder)(playlistSongIds)
}
}
function resolveTargetIds(fallbackSongId?: string) {
return selectedIds.size > 0
? Array.from(selectedIds)
@@ -520,9 +544,7 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
size="icon"
className="rounded-full"
aria-label="Shuffle playlist"
onClick={() =>
void playPlaylistShuffled(playlist.id as Id<"playlists">)
}
onClick={() => playAll(true)}
disabled={playlistSongIds.length === 0}
>
<Shuffle />
@@ -530,9 +552,7 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
<Button
className="h-10 gap-2 rounded-full bg-foreground px-6 text-background hover:bg-foreground/90"
aria-label={`Play ${playlist.title}`}
onClick={() =>
void playPlaylist(playlist.id as Id<"playlists">)
}
onClick={() => playAll(false)}
disabled={playlistSongIds.length === 0}
>
<Play className="fill-current" />
+95 -88
View File
@@ -2,19 +2,17 @@
import * as React from "react"
import Image from "next/image"
import { useMutation, usePaginatedQuery, useQuery } from "convex/react"
import { Music2 } from "lucide-react"
import { toast } from "sonner"
import { PlaybackSongMeta } from "@/components/playback-song-meta"
import { usePlayback } from "@/components/playback-provider"
import { Button } from "@/components/ui/button"
import { ScrollArea } from "@/components/ui/scroll-area"
import { Skeleton } from "@/components/ui/skeleton"
import { Spinner } from "@/components/ui/spinner"
import { useTrackSelection } from "@/hooks/use-track-selection"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type { HistorySong, QueueSong } from "@otunes/convex/types"
import type { BrowseSong, HistorySong, QueueSong } from "@otunes/convex/types"
import { albumCoverUrl } from "@/lib/cover-urls"
import {
getContiguousSelectedIndices,
@@ -28,18 +26,18 @@ import {
QueueTrackRowHoverHighlight,
type SelectionRangePosition,
} from "@/lib/selection-range-styles"
import { useSongs } from "@/lib/song-cache"
import { cn } from "@/lib/utils"
const QUEUE_PAGINATION_THRESHOLD = 100
const QUEUE_INITIAL_VISIBLE_COUNT = 100
const QUEUE_PAGE_SIZE = 50
type QueueSelectable = QueueSong & { selectionId: string }
function getQueueVersion(queueSongIds: Id<"songs">[]) {
if (queueSongIds.length === 0) {
return "empty"
}
return `${queueSongIds.length}:${queueSongIds[0]}:${queueSongIds[queueSongIds.length - 1]}`
type QueueItem = {
selectionId: string
queueIndex: number
song: QueueSelectable | null
}
function formatDuration(seconds: number): string {
@@ -48,11 +46,19 @@ function formatDuration(seconds: number): string {
return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`
}
function toSelectableQueue(songs: QueueSong[]): QueueSelectable[] {
return songs.map((song) => ({
...song,
selectionId: `${song.id}-${song.queueIndex}`,
}))
function toSelectableQueue(
songIds: Id<"songs">[],
songs: (BrowseSong | undefined)[]
): QueueItem[] {
return songIds.map((songId, queueIndex) => {
const selectionId = `${songId}-${queueIndex}`
const song = songs[queueIndex]
return {
selectionId,
queueIndex,
song: song ? { ...song, queueIndex, selectionId } : null,
}
})
}
function QueueSongCover({
@@ -214,39 +220,52 @@ const QueueSongRow = React.forwardRef<
)
})
function QueueSongRowSkeleton() {
return (
<li className="flex items-center gap-3 px-2 py-2" aria-hidden>
<Skeleton className="size-10 shrink-0 rounded-none" />
<div className="flex min-w-0 flex-1 flex-col gap-1.5">
<Skeleton className="h-3.5 w-3/4" />
<Skeleton className="h-3 w-1/2" />
</div>
<Skeleton className="h-3 w-8 shrink-0" />
</li>
)
}
export function QueuePanel() {
const { queueSongIds, queueOpen, clearQueue, skipToQueueIndex } =
usePlayback()
const reorderQueue = useMutation(api.playback.reorderQueue)
const {
queueSongIds,
queueHistorySongIds,
queueOpen,
clearQueue,
reorderQueue,
skipToQueueIndex,
} = usePlayback()
const loadMoreRef = React.useRef<HTMLDivElement>(null)
const nowPlayingRef = React.useRef<HTMLLIElement>(null)
const historySongs = useQuery(
api.playback.getQueueHistory,
queueOpen ? {} : "skip"
const [visibleCount, setVisibleCount] = React.useState(
QUEUE_INITIAL_VISIBLE_COUNT
)
const queueVersion = React.useMemo(
() => getQueueVersion(queueSongIds),
[queueSongIds]
const visibleQueueIds = React.useMemo(
() => queueSongIds.slice(0, visibleCount),
[queueSongIds, visibleCount]
)
const shouldPaginate = queueSongIds.length > QUEUE_PAGINATION_THRESHOLD
const initialPageSize = shouldPaginate
? QUEUE_PAGE_SIZE
: queueSongIds.length
const { results, status, loadMore } = usePaginatedQuery(
api.playback.getQueuePaginated,
queueOpen && queueSongIds.length > 0
? { queueVersion }
: "skip",
{ initialNumItems: initialPageSize }
const visibleQueueSongs = useSongs(visibleQueueIds)
const historySongMetadata = useSongs(queueHistorySongIds)
const historySongs = React.useMemo(
() =>
historySongMetadata.flatMap((song, historyIndex) =>
song ? [{ ...song, historyIndex }] : []
),
[historySongMetadata]
)
const hasMore = queueSongIds.length > visibleCount
const queueSongs = React.useMemo(() => results ?? [], [results])
const selectableQueue = React.useMemo(
() => toSelectableQueue(queueSongs),
[queueSongs]
() => toSelectableQueue(visibleQueueIds, visibleQueueSongs),
[visibleQueueIds, visibleQueueSongs]
)
const [dragIndex, setDragIndex] = React.useState<number | null>(null)
@@ -265,7 +284,7 @@ export function QueuePanel() {
}, [queueOpen, queueSongIds.length, currentQueueSongId])
React.useEffect(() => {
if (!shouldPaginate) {
if (!hasMore) {
return
}
@@ -281,8 +300,8 @@ export function QueuePanel() {
const observer = new IntersectionObserver(
(entries) => {
if (entries[0]?.isIntersecting && status === "CanLoadMore") {
loadMore(QUEUE_PAGE_SIZE)
if (entries[0]?.isIntersecting) {
setVisibleCount((count) => count + QUEUE_PAGE_SIZE)
}
},
{ root: viewport, rootMargin: "240px" }
@@ -290,7 +309,7 @@ export function QueuePanel() {
observer.observe(sentinel)
return () => observer.disconnect()
}, [shouldPaginate, status, loadMore])
}, [hasMore])
const {
selectedIds,
@@ -318,16 +337,6 @@ export function QueuePanel() {
)
}, [dragIndex, selectableQueue, selectedIds])
async function persistOrder(nextQueue: Id<"songs">[]) {
try {
await reorderQueue({ songIds: nextQueue })
} catch (error) {
toast.error(
error instanceof Error ? error.message : "Failed to reorder queue"
)
}
}
function handleDrop(targetLocalIndex: number) {
if (dragIndex === null) {
return
@@ -350,7 +359,7 @@ export function QueuePanel() {
return
}
void persistOrder(next)
void reorderQueue(next)
}
if (!queueOpen) {
@@ -382,13 +391,9 @@ export function QueuePanel() {
<p className="px-4 py-8 text-sm text-muted-foreground">
Nothing in the queue.
</p>
) : status === "LoadingFirstPage" ? (
<div className="flex items-center justify-center py-8">
<Spinner className="size-5 text-muted-foreground" />
</div>
) : (
<>
{historySongs && historySongs.length > 0 ? (
{historySongs.length > 0 ? (
<ul className="flex flex-col border-b py-1">
{historySongs.map((song) => (
<HistorySongRow key={`history-${song.id}-${song.historyIndex}`} song={song} />
@@ -396,40 +401,42 @@ export function QueuePanel() {
</ul>
) : null}
<ul className="flex flex-col py-1">
{selectableQueue.map((song, index) => (
<QueueSongRow
key={song.selectionId}
ref={song.queueIndex === 0 ? nowPlayingRef : undefined}
song={song}
isNowPlaying={song.queueIndex === 0}
selectionPosition={selectionPositions[index]}
isDragging={draggingIndices.has(index)}
onPointerDown={handlePointerDown}
onSelect={(event) => {
handleSelect(song.selectionId, index, event)
}}
onSkipTo={() => void skipToQueueIndex(song.queueIndex)}
onDragStart={(event) => {
setDragIndex(index)
event.dataTransfer.effectAllowed = "move"
}}
onDragOver={(event) => event.preventDefault()}
onDrop={(event) => {
event.preventDefault()
handleDrop(index)
}}
/>
))}
{selectableQueue.map((item, index) =>
item.song ? (
<QueueSongRow
key={item.selectionId}
ref={item.queueIndex === 0 ? nowPlayingRef : undefined}
song={item.song}
isNowPlaying={item.queueIndex === 0}
selectionPosition={selectionPositions[index]}
isDragging={draggingIndices.has(index)}
onPointerDown={handlePointerDown}
onSelect={(event) => {
handleSelect(item.selectionId, index, event)
}}
onSkipTo={() => void skipToQueueIndex(item.queueIndex)}
onDragStart={(event) => {
setDragIndex(index)
event.dataTransfer.effectAllowed = "move"
}}
onDragOver={(event) => event.preventDefault()}
onDrop={(event) => {
event.preventDefault()
handleDrop(index)
}}
/>
) : (
<QueueSongRowSkeleton key={item.selectionId} />
)
)}
</ul>
{shouldPaginate ? (
{hasMore ? (
<div
ref={loadMoreRef}
className="flex items-center justify-center py-4"
aria-hidden={status !== "LoadingMore"}
aria-hidden
>
{status === "LoadingMore" ? (
<Spinner className="size-5 text-muted-foreground" />
) : null}
<Spinner className="size-5 text-muted-foreground" />
</div>
) : null}
</>
+5 -5
View File
@@ -3,7 +3,6 @@
import { useEffect, useMemo, useState, useRef, MouseEvent } from "react"
import Image from "next/image"
import Link from "next/link"
import { usePaginatedQuery } from "convex/react"
import { ArrowUpDown, Play, Star } from "lucide-react"
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
@@ -23,9 +22,10 @@ import {
DropdownMenuSeparator,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu"
import { useCachedPaginatedQuery } from "@/hooks/use-cached-query"
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
import { useTrackSelection } from "@/hooks/use-track-selection"
import { LibraryLoading } from "@/components/library-loading"
import { SongListSkeleton } from "@/components/library-skeletons"
import { ScrollArea } from "@/components/ui/scroll-area"
import { Spinner } from "@/components/ui/spinner"
import { api } from "@otunes/convex/_generated/api"
@@ -271,7 +271,7 @@ export function SongsView() {
useState<SortDirection>("asc")
const loadMoreRef = useRef<HTMLDivElement>(null)
const { results, status, loadMore } = usePaginatedQuery(
const { results, status, loadMore, isCached } = useCachedPaginatedQuery(
api.library.browseSongsPaginated,
{ sortKey, sortDirection },
{ initialNumItems: SONGS_PAGE_SIZE }
@@ -344,13 +344,13 @@ export function SongsView() {
}
}
if (status === "LoadingFirstPage") {
if (status === "LoadingFirstPage" && !isCached) {
return (
<div className="flex h-svh flex-col">
<header className="flex items-center justify-between gap-2 border-b px-4 py-3">
<h1 className="text-lg font-semibold">Songs</h1>
</header>
<LibraryLoading />
<SongListSkeleton />
</div>
)
}
+92
View File
@@ -0,0 +1,92 @@
"use client"
import {
usePaginatedQuery,
useQuery,
type OptionalRestArgsOrSkip,
type PaginatedQueryArgs,
type PaginatedQueryItem,
type PaginatedQueryReference,
} from "convex/react"
import type { FunctionReference } from "convex/server"
import { useCallback, useEffect, useSyncExternalStore } from "react"
import { useCacheScope } from "@/components/persistent-cache-provider"
import { queryCacheKey } from "@/lib/cached-query"
import { readCache, subscribeCache, writeCache } from "@/lib/persistent-cache"
const MAX_CACHED_PAGINATED_ITEMS = 200
const noopUnsubscribe = () => {}
function useCachedValue<T>(key: string | null) {
const subscribe = useCallback(
(listener: () => void) =>
key ? subscribeCache(key, listener) : noopUnsubscribe,
[key]
)
return useSyncExternalStore(
subscribe,
() => (key ? readCache<T>(key) : undefined),
() => undefined
)
}
/**
* `useQuery` that falls back to the last result persisted on this device while
* the live subscription is loading, so revisits render immediately.
*/
export function useCachedQuery<Query extends FunctionReference<"query">>(
query: Query,
...args: OptionalRestArgsOrSkip<Query>
): Query["_returnType"] | undefined {
const scope = useCacheScope()
const live = useQuery(query, ...args)
const queryArgs = args[0]
const key =
queryArgs === "skip"
? null
: queryCacheKey(
scope,
query,
(queryArgs ?? {}) as Record<string, unknown>
)
const cached = useCachedValue<Query["_returnType"]>(key)
useEffect(() => {
if (key && live !== undefined) {
writeCache(key, live)
}
}, [key, live])
return live !== undefined ? live : cached
}
/**
* `usePaginatedQuery` that shows the first persisted pages while the first live
* page loads. `isCached` is true while those persisted results are shown.
*/
export function useCachedPaginatedQuery<Query extends PaginatedQueryReference>(
query: Query,
args: PaginatedQueryArgs<Query> | "skip",
options: { initialNumItems: number }
) {
const scope = useCacheScope()
const result = usePaginatedQuery(query, args, options)
const key =
args === "skip"
? null
: `${queryCacheKey(scope, query, args as Record<string, unknown>)}:pages`
const cached = useCachedValue<PaginatedQueryItem<Query>[]>(key)
useEffect(() => {
if (key && result.status !== "LoadingFirstPage") {
writeCache(key, result.results.slice(0, MAX_CACHED_PAGINATED_ITEMS))
}
}, [key, result.status, result.results])
if (result.status === "LoadingFirstPage" && cached !== undefined) {
return { ...result, results: cached, isCached: true }
}
return { ...result, isCached: false }
}
+51
View File
@@ -0,0 +1,51 @@
import type { ConvexReactClient } from "convex/react"
import {
getFunctionName,
type FunctionArgs,
type FunctionReference,
type FunctionReturnType,
} from "convex/server"
import { convexToJson, type Value } from "convex/values"
import {
loadPersistentCache,
readCache,
writeCache,
} from "@/lib/persistent-cache"
export function queryCacheKey(
scope: string,
query: FunctionReference<"query">,
args: Record<string, unknown>
) {
return `q:${scope}:${getFunctionName(query)}:${JSON.stringify(
convexToJson(args as Value)
)}`
}
/**
* Resolves from the persistent cache when possible and refreshes it in the
* background; only waits on the network for a cold cache.
*/
export async function fetchCachedQuery<
Query extends FunctionReference<"query">,
>(
convex: ConvexReactClient,
scope: string,
query: Query,
args: FunctionArgs<Query>
): Promise<FunctionReturnType<Query>> {
await loadPersistentCache()
const key = queryCacheKey(scope, query, args)
const cached = readCache<FunctionReturnType<Query>>(key)
const request = convex.query(query, args).then((result) => {
writeCache(key, result, { notify: true })
return result
})
if (cached !== undefined) {
request.catch(() => {})
return cached
}
return request
}
+268
View File
@@ -0,0 +1,268 @@
const DB_NAME = "otunes-cache"
const DB_VERSION = 1
const STORE_NAME = "entries"
const WRITE_DELAY_MS = 250
/** Keys are `<prefix>:<rest>`; prefixes without a limit are never evicted. */
const MAX_ENTRIES_BY_PREFIX: Record<string, number> = {
q: 400,
song: 5000,
}
type Entry = { value: unknown; touchedAt: number }
const memory = new Map<string, Entry>()
const prefixCounts = new Map<string, number>()
const listeners = new Map<string, Set<() => void>>()
const loadListeners = new Set<() => void>()
const pendingWrites = new Map<string, Entry | null>()
let flushTimer: ReturnType<typeof setTimeout> | null = null
let dbPromise: Promise<IDBDatabase | null> | null = null
let loadPromise: Promise<void> | null = null
let loaded = false
function requestToPromise<T>(request: IDBRequest<T>) {
return new Promise<T>((resolve, reject) => {
request.onsuccess = () => resolve(request.result)
request.onerror = () => reject(request.error)
})
}
function transactionDone(transaction: IDBTransaction) {
return new Promise<void>((resolve, reject) => {
transaction.oncomplete = () => resolve()
transaction.onabort = () => reject(transaction.error)
transaction.onerror = () => reject(transaction.error)
})
}
function openDb() {
if (dbPromise) {
return dbPromise
}
dbPromise = new Promise<IDBDatabase | null>((resolve) => {
if (typeof indexedDB === "undefined") {
resolve(null)
return
}
try {
const request = indexedDB.open(DB_NAME, DB_VERSION)
request.onupgradeneeded = () => {
if (!request.result.objectStoreNames.contains(STORE_NAME)) {
request.result.createObjectStore(STORE_NAME)
}
}
request.onsuccess = () => resolve(request.result)
request.onerror = () => resolve(null)
request.onblocked = () => resolve(null)
} catch {
resolve(null)
}
})
return dbPromise
}
function notify(key: string) {
for (const listener of listeners.get(key) ?? []) {
listener()
}
}
function notifyAll() {
for (const key of listeners.keys()) {
notify(key)
}
for (const listener of loadListeners) {
listener()
}
}
async function flushWrites() {
flushTimer = null
if (pendingWrites.size === 0) {
return
}
const writes = [...pendingWrites]
pendingWrites.clear()
const db = await openDb()
if (!db) {
return
}
try {
const transaction = db.transaction(STORE_NAME, "readwrite")
const store = transaction.objectStore(STORE_NAME)
for (const [key, entry] of writes) {
if (entry === null) {
store.delete(key)
} else {
store.put(entry, key)
}
}
await transactionDone(transaction)
} catch {
// Persisting is best-effort; the in-memory copy stays authoritative.
}
}
function scheduleWrite(key: string, entry: Entry | null) {
pendingWrites.set(key, entry)
if (flushTimer === null) {
flushTimer = setTimeout(() => void flushWrites(), WRITE_DELAY_MS)
}
}
function entryPrefix(key: string) {
const index = key.indexOf(":")
return index === -1 ? key : key.slice(0, index)
}
function evictOldEntries(prefix: string, force = false) {
const limit = MAX_ENTRIES_BY_PREFIX[prefix]
const count = prefixCounts.get(prefix) ?? 0
if (limit === undefined || count <= (force ? limit : limit * 1.25)) {
return
}
const oldest = [...memory.entries()]
.filter(([key]) => entryPrefix(key) === prefix)
.sort(([, a], [, b]) => a.touchedAt - b.touchedAt)
.slice(0, count - limit)
for (const [key] of oldest) {
removeFromMemory(key)
scheduleWrite(key, null)
}
}
function setInMemory(key: string, entry: Entry) {
if (!memory.has(key)) {
const prefix = entryPrefix(key)
prefixCounts.set(prefix, (prefixCounts.get(prefix) ?? 0) + 1)
}
memory.set(key, entry)
}
function removeFromMemory(key: string) {
if (memory.delete(key)) {
const prefix = entryPrefix(key)
prefixCounts.set(prefix, (prefixCounts.get(prefix) ?? 1) - 1)
}
}
/** Writes pending entries now instead of after the batching delay. */
export function flushPersistentCache() {
if (flushTimer !== null) {
clearTimeout(flushTimer)
}
void flushWrites()
}
export function loadPersistentCache() {
if (loadPromise) {
return loadPromise
}
loadPromise = (async () => {
const db = await openDb()
if (db) {
try {
const transaction = db.transaction(STORE_NAME, "readonly")
const store = transaction.objectStore(STORE_NAME)
const [keys, values] = await Promise.all([
requestToPromise(store.getAllKeys()),
requestToPromise(store.getAll() as IDBRequest<Entry[]>),
])
keys.forEach((key, index) => {
const entry = values[index]
if (typeof key === "string" && entry && !memory.has(key)) {
setInMemory(key, entry)
}
})
for (const prefix of Object.keys(MAX_ENTRIES_BY_PREFIX)) {
evictOldEntries(prefix, true)
}
} catch {
// Treat an unreadable cache as empty.
}
}
loaded = true
notifyAll()
})()
return loadPromise
}
export function isPersistentCacheLoaded() {
return loaded
}
export function readCache<T>(key: string): T | undefined {
return memory.get(key)?.value as T | undefined
}
export function writeCache(
key: string,
value: unknown,
options: { notify?: boolean } = {}
) {
const entry = { value, touchedAt: Date.now() }
setInMemory(key, entry)
scheduleWrite(key, entry)
evictOldEntries(entryPrefix(key))
if (options.notify) {
notify(key)
}
}
export async function clearPersistentCache() {
memory.clear()
prefixCounts.clear()
pendingWrites.clear()
if (flushTimer !== null) {
clearTimeout(flushTimer)
flushTimer = null
}
notifyAll()
const db = await openDb()
if (!db) {
return
}
try {
const transaction = db.transaction(STORE_NAME, "readwrite")
transaction.objectStore(STORE_NAME).clear()
await transactionDone(transaction)
} catch {
// Ignore; stale entries are scoped per user and evicted over time.
}
}
export function subscribeCache(key: string, listener: () => void) {
let keyListeners = listeners.get(key)
if (!keyListeners) {
keyListeners = new Set()
listeners.set(key, keyListeners)
}
keyListeners.add(listener)
return () => {
keyListeners.delete(listener)
if (keyListeners.size === 0) {
listeners.delete(key)
}
}
}
export function subscribeCacheLoaded(listener: () => void) {
loadListeners.add(listener)
return () => {
loadListeners.delete(listener)
}
}
+200
View File
@@ -0,0 +1,200 @@
import type { Id } from "@otunes/convex/_generated/dataModel"
import { shuffleArray } from "@/lib/shuffle-array"
/** Mirrors the queue rules in `packages/convex/convex/playback.ts`. */
export type RepeatMode = "none" | "once" | "always"
export type PlaybackQueueState = {
queue: Id<"songs">[]
history: Id<"songs">[]
shuffleEnabled: boolean
repeatEnabled: RepeatMode
/** Saved position of `queue[0]`, in seconds. */
progressSeconds: number
}
export const EMPTY_PLAYBACK_QUEUE: PlaybackQueueState = {
queue: [],
history: [],
shuffleEnabled: false,
repeatEnabled: "none",
progressSeconds: 0,
}
const MAX_QUEUE_HISTORY = 30
function uniqueSongIds(songIds: Id<"songs">[]) {
return [...new Set(songIds)]
}
function appendToHistory(history: Id<"songs">[], songIds: Id<"songs">[]) {
const next = [...history, ...songIds]
return next.length <= MAX_QUEUE_HISTORY
? next
: next.slice(next.length - MAX_QUEUE_HISTORY)
}
export function startQueue(
state: PlaybackQueueState,
songIds: Id<"songs">[],
shuffled: boolean
): PlaybackQueueState {
const unique = uniqueSongIds(songIds)
return {
...state,
queue: shuffled ? shuffleArray(unique) : unique,
history: [],
shuffleEnabled: shuffled,
progressSeconds: 0,
}
}
export function startQueueFromSong(
state: PlaybackQueueState,
songId: Id<"songs">,
songIds: Id<"songs">[]
): PlaybackQueueState {
const index = songIds.indexOf(songId)
const rest = index === -1 ? [] : songIds.slice(index + 1)
return {
...state,
queue: [songId, ...(state.shuffleEnabled ? shuffleArray(rest) : rest)],
history: [],
progressSeconds: 0,
}
}
/**
* Fills in the rest of a queue started with only `songId`, unless the queue
* changed in the meantime.
*/
export function extendQueueFromSong(
state: PlaybackQueueState,
songId: Id<"songs">,
songIds: Id<"songs">[]
): PlaybackQueueState {
if (state.queue.length !== 1 || state.queue[0] !== songId) {
return state
}
const { queue } = startQueueFromSong(state, songId, songIds)
return queue.length > 1 ? { ...state, queue } : state
}
export function addToQueue(
state: PlaybackQueueState,
songIds: Id<"songs">[],
position: "next" | "last"
): PlaybackQueueState {
const toAdd = state.shuffleEnabled ? shuffleArray(songIds) : songIds
if (state.queue.length === 0) {
return { ...state, queue: toAdd, progressSeconds: 0 }
}
const [current, ...rest] = state.queue
return {
...state,
queue:
position === "next"
? [current, ...toAdd, ...rest]
: [...state.queue, ...toAdd],
}
}
export function toggleShuffle(state: PlaybackQueueState): PlaybackQueueState {
const shuffleEnabled = !state.shuffleEnabled
if (shuffleEnabled && state.queue.length > 1) {
const [current, ...upNext] = state.queue
return {
...state,
shuffleEnabled,
queue: [current, ...shuffleArray(upNext)],
}
}
return { ...state, shuffleEnabled }
}
export function cycleRepeat(state: PlaybackQueueState): PlaybackQueueState {
const repeatEnabled: RepeatMode =
state.repeatEnabled === "none"
? "once"
: state.repeatEnabled === "once"
? "always"
: "none"
return { ...state, repeatEnabled }
}
export function clearQueue(state: PlaybackQueueState): PlaybackQueueState {
return { ...state, queue: [], history: [], progressSeconds: 0 }
}
export function reorderQueue(
state: PlaybackQueueState,
songIds: Id<"songs">[]
): PlaybackQueueState {
const currentSongChanged =
songIds.length > 0 &&
state.queue.length > 0 &&
songIds[0] !== state.queue[0]
return {
...state,
queue: songIds,
history: currentSongChanged
? appendToHistory(state.history, [state.queue[0]])
: state.history,
progressSeconds: currentSongChanged ? 0 : state.progressSeconds,
}
}
export function skipToQueueIndex(
state: PlaybackQueueState,
index: number
): PlaybackQueueState {
if (index <= 0 || index >= state.queue.length) {
return state
}
return {
...state,
queue: state.queue.slice(index),
history: appendToHistory(state.history, state.queue.slice(0, index)),
progressSeconds: 0,
}
}
export function skipNext(state: PlaybackQueueState): PlaybackQueueState {
if (state.queue.length === 0) {
return state
}
if (state.repeatEnabled === "once") {
return { ...state, progressSeconds: 0 }
}
const [current, ...rest] = state.queue
if (state.repeatEnabled === "always") {
return { ...state, queue: [...rest, current], progressSeconds: 0 }
}
if (rest.length === 0) {
return { ...state, progressSeconds: 0 }
}
return {
...state,
queue: rest,
history: appendToHistory(state.history, [current]),
progressSeconds: 0,
}
}
export function skipPrevious(state: PlaybackQueueState): PlaybackQueueState {
if (state.queue.length === 0) {
return state
}
if (state.history.length === 0) {
return { ...state, progressSeconds: 0 }
}
return {
...state,
queue: [state.history[state.history.length - 1], ...state.queue],
history: state.history.slice(0, -1),
progressSeconds: 0,
}
}
+274
View File
@@ -0,0 +1,274 @@
import type { Id } from "@otunes/convex/_generated/dataModel"
import {
EMPTY_PLAYBACK_QUEUE,
type PlaybackQueueState,
type RepeatMode,
} from "@/lib/playback-queue"
import {
loadPersistentCache,
readCache,
writeCache,
} from "@/lib/persistent-cache"
const SYNC_DELAY_MS = 300
const RETRY_DELAYS_MS = [1_000, 3_000, 10_000, 30_000]
export type ServerPlaybackState = {
queueSongIds: Id<"songs">[]
queueHistorySongIds: Id<"songs">[]
shuffleEnabled: boolean
repeatEnabled: RepeatMode
currentSongProgress: number
revision: number
}
/** Everything except progress, which changes too often to re-render on. */
export type PlaybackSnapshot = Omit<PlaybackQueueState, "progressSeconds"> & {
hydrated: boolean
}
type PersistedPlayback = PlaybackQueueState & {
/** Server revision the local state was last reconciled with. */
revision: number | null
/** Local changes that the server has not acknowledged yet. */
dirty: boolean
}
export type PlaybackSyncTransport = (
state: PlaybackQueueState
) => Promise<number>
/**
* Client-owned playback queue. Changes apply locally (and persist on this
* device) immediately, then sync to Convex in the background. Remote changes
* are adopted only when there are no unsynced local changes.
*/
export class PlaybackStore {
private state: PlaybackQueueState = EMPTY_PLAYBACK_QUEUE
private snapshot: PlaybackSnapshot = toSnapshot(EMPTY_PLAYBACK_QUEUE, false)
private revision: number | null = null
private dirty = false
private changeCount = 0
private inFlight = false
private retryAttempt = 0
private syncTimer: ReturnType<typeof setTimeout> | null = null
private latestServerState: ServerPlaybackState | null = null
private transport: PlaybackSyncTransport | null = null
private readonly listeners = new Set<() => void>()
constructor(private readonly storageKey: string | null) {
if (typeof window !== "undefined") {
void this.hydrate()
}
}
subscribe = (listener: () => void) => {
this.listeners.add(listener)
return () => {
this.listeners.delete(listener)
}
}
getSnapshot = () => this.snapshot
getState() {
return this.state
}
setTransport(transport: PlaybackSyncTransport | null) {
this.transport = transport
if (transport && this.dirty) {
this.scheduleSync(0)
}
}
update(recipe: (state: PlaybackQueueState) => PlaybackQueueState) {
const next = recipe(this.state)
if (next === this.state) {
return
}
this.changeCount += 1
this.dirty = true
this.setState(next)
this.scheduleSync(SYNC_DELAY_MS)
}
/** Records progress locally; the server copy is synced separately. */
setProgress(songId: Id<"songs">, progressSeconds: number) {
if (this.state.queue[0] !== songId) {
return
}
this.state = { ...this.state, progressSeconds }
this.persist()
}
receiveServerState(serverState: ServerPlaybackState) {
this.latestServerState = serverState
if (this.snapshot.hydrated) {
this.adoptServerState()
}
}
private async hydrate() {
await loadPersistentCache()
const persisted = this.storageKey
? readCache<PersistedPlayback>(this.storageKey)
: undefined
if (persisted && this.changeCount === 0) {
const { revision, dirty, ...state } = persisted
this.revision = revision
this.dirty = dirty
this.state = { ...EMPTY_PLAYBACK_QUEUE, ...state }
}
this.snapshot = toSnapshot(this.state, true)
this.emit()
this.adoptServerState()
if (this.dirty) {
this.scheduleSync(0)
}
}
private adoptServerState() {
const serverState = this.latestServerState
if (!serverState || this.dirty || this.inFlight) {
return
}
if (this.revision !== null && serverState.revision <= this.revision) {
return
}
this.revision = serverState.revision
this.setState({
queue: serverState.queueSongIds,
history: serverState.queueHistorySongIds,
shuffleEnabled: serverState.shuffleEnabled,
repeatEnabled: serverState.repeatEnabled,
progressSeconds: serverState.currentSongProgress,
})
}
private scheduleSync(delayMs: number) {
if (this.syncTimer !== null) {
clearTimeout(this.syncTimer)
}
this.syncTimer = setTimeout(() => {
this.syncTimer = null
void this.flush()
}, delayMs)
}
private async flush() {
const transport = this.transport
if (!transport || this.inFlight || !this.dirty) {
return
}
this.inFlight = true
const changeCountAtStart = this.changeCount
let failed = false
try {
const revision = await transport(this.state)
this.revision = Math.max(revision, this.revision ?? 0)
this.retryAttempt = 0
if (this.changeCount === changeCountAtStart) {
this.dirty = false
}
} catch {
failed = true
} finally {
this.inFlight = false
}
this.persist()
if (failed) {
const delay =
RETRY_DELAYS_MS[Math.min(this.retryAttempt, RETRY_DELAYS_MS.length - 1)]
this.retryAttempt += 1
this.scheduleSync(delay)
} else if (this.dirty) {
this.scheduleSync(SYNC_DELAY_MS)
} else {
this.adoptServerState()
}
}
private setState(state: PlaybackQueueState) {
const previous = this.state
this.state = state
this.persist()
if (
previous.queue !== state.queue ||
previous.history !== state.history ||
previous.shuffleEnabled !== state.shuffleEnabled ||
previous.repeatEnabled !== state.repeatEnabled
) {
this.snapshot = toSnapshot(state, this.snapshot.hydrated)
this.emit()
}
}
private persist() {
if (!this.storageKey) {
return
}
writeCache(this.storageKey, {
...this.state,
revision: this.revision,
dirty: this.dirty,
} satisfies PersistedPlayback)
}
private emit() {
for (const listener of this.listeners) {
listener()
}
}
}
function toSnapshot(
state: PlaybackQueueState,
hydrated: boolean
): PlaybackSnapshot {
return {
queue: state.queue,
history: state.history,
shuffleEnabled: state.shuffleEnabled,
repeatEnabled: state.repeatEnabled,
hydrated,
}
}
const SERVER_SNAPSHOT = toSnapshot(EMPTY_PLAYBACK_QUEUE, false)
export function getServerPlaybackSnapshot() {
return SERVER_SNAPSHOT
}
const stores = new Map<string, PlaybackStore>()
export function getPlaybackStore(scope: string | null) {
if (typeof window === "undefined") {
return new PlaybackStore(null)
}
const key = scope ?? ""
let store = stores.get(key)
if (!store) {
store = new PlaybackStore(scope ? `playback:${scope}` : null)
stores.set(key, store)
}
return store
}
export function resetPlaybackStores() {
for (const store of stores.values()) {
store.setTransport(null)
}
stores.clear()
}
+173
View File
@@ -0,0 +1,173 @@
import { useConvex, type ConvexReactClient } from "convex/react"
import { useEffect, useMemo, useSyncExternalStore } from "react"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type { BrowseAlbumDetail, BrowseSong } from "@otunes/convex/types"
import {
isPersistentCacheLoaded,
readCache,
subscribeCacheLoaded,
writeCache,
} from "@/lib/persistent-cache"
const FETCH_BATCH_SIZE = 100
const FETCH_DELAY_MS = 16
const listeners = new Set<() => void>()
const missingSongIds = new Set<string>()
const inFlightSongIds = new Set<string>()
const queuedSongIds = new Set<Id<"songs">>()
let version = 0
let fetchTimer: ReturnType<typeof setTimeout> | null = null
function songKey(songId: string) {
return `song:${songId}`
}
function notify() {
version += 1
for (const listener of listeners) {
listener()
}
}
if (typeof window !== "undefined") {
subscribeCacheLoaded(notify)
}
function subscribe(listener: () => void) {
listeners.add(listener)
return () => {
listeners.delete(listener)
}
}
function sameSong(a: BrowseSong, b: BrowseSong) {
return (
a.title === b.title &&
a.durationSeconds === b.durationSeconds &&
a.explicit === b.explicit &&
a.artist.id === b.artist.id &&
a.artist.name === b.artist.name &&
a.artist.photo === b.artist.photo &&
a.album.id === b.album.id &&
a.album.title === b.album.title &&
a.album.cover === b.album.cover
)
}
export function getCachedSong(songId: string) {
return readCache<BrowseSong>(songKey(songId))
}
/** Stores song metadata so the player and queue can render it offline. */
export function rememberSongs(songs: readonly BrowseSong[]) {
let changed = false
for (const song of songs) {
const existing = getCachedSong(song.id)
if (existing && sameSong(existing, song)) {
continue
}
writeCache(songKey(song.id), song)
missingSongIds.delete(song.id)
changed = true
}
if (changed) {
notify()
}
}
export function albumDetailSongs(album: BrowseAlbumDetail): BrowseSong[] {
return album.tracks.map((track) => ({
id: track.id,
title: track.title,
artist: album.artist,
album: { id: album.id, title: album.title, cover: album.cover },
durationSeconds: track.durationSeconds,
}))
}
async function fetchQueuedSongs(convex: ConvexReactClient) {
fetchTimer = null
const ids = [...queuedSongIds]
queuedSongIds.clear()
for (let start = 0; start < ids.length; start += FETCH_BATCH_SIZE) {
const batch = ids.slice(start, start + FETCH_BATCH_SIZE)
try {
const songs = await convex.query(api.library.browseSongsByIds, {
ids: batch,
})
const found = new Set(songs.map((song) => song.id as string))
for (const id of batch) {
if (!found.has(id)) {
missingSongIds.add(id)
}
}
rememberSongs(songs)
} catch {
// Leave them uncached so a later render retries.
} finally {
for (const id of batch) {
inFlightSongIds.delete(id)
}
}
}
notify()
}
function requestSongs(convex: ConvexReactClient, songIds: Id<"songs">[]) {
for (const songId of songIds) {
if (
getCachedSong(songId) ||
missingSongIds.has(songId) ||
inFlightSongIds.has(songId)
) {
continue
}
inFlightSongIds.add(songId)
queuedSongIds.add(songId)
}
if (queuedSongIds.size > 0 && fetchTimer === null) {
fetchTimer = setTimeout(() => void fetchQueuedSongs(convex), FETCH_DELAY_MS)
}
}
/**
* Resolves song metadata from the persistent song cache, fetching anything
* missing in batches. Entries are `undefined` until loaded.
*/
export function useSongs(songIds: readonly Id<"songs">[]) {
const convex = useConvex()
const songsVersion = useSyncExternalStore(
subscribe,
() => version,
() => 0
)
const songs = useMemo(
() => songIds.map((songId) => getCachedSong(songId)),
// songsVersion invalidates the lookup when the cache changes.
// eslint-disable-next-line react-hooks/exhaustive-deps
[songIds, songsVersion]
)
useEffect(() => {
if (!isPersistentCacheLoaded()) {
return
}
const missing = songIds.filter((songId, index) => !songs[index])
if (missing.length > 0) {
requestSongs(convex, missing)
}
}, [convex, songIds, songs])
return songs
}
export function useSong(songId: Id<"songs"> | null) {
const songIds = useMemo(() => (songId ? [songId] : []), [songId])
return useSongs(songIds)[0] ?? null
}
+7
View File
@@ -4,6 +4,13 @@ import type { NextConfig } from "next"
const nextConfig: NextConfig = {
output: "standalone",
outputFileTracingRoot: path.join(__dirname, "../../"),
experimental: {
// App pages render their data from the client cache, so reusing a visited
// page's server payload is safe and skips a round trip on revisits.
staleTimes: {
dynamic: 300,
},
},
images: {
minimumCacheTTL: 60,
dangerouslyAllowSVG: true,
+23 -1
View File
@@ -1,7 +1,7 @@
import { paginationOptsValidator } from "convex/server"
import { getAuthUserId } from "@convex-dev/auth/server"
import { internalMutation, internalQuery, query } from "./_generated/server"
import { v } from "convex/values"
import { ConvexError, v } from "convex/values"
import type { Doc, Id } from "./_generated/dataModel"
import type { QueryCtx } from "./_generated/server"
import type { PaginationOptions, PaginationResult } from "convex/server"
@@ -494,6 +494,28 @@ export const browseSongsPaginated = query({
},
})
export const browseSortedSongIds = query({
args: {
sortKey: songsSortKeyValidator,
sortDirection: songsSortDirectionValidator,
},
handler: async (ctx, args) => {
return getSortedLibrarySongIds(ctx, args.sortKey, args.sortDirection)
},
})
const MAX_SONGS_BY_IDS = 200
export const browseSongsByIds = query({
args: { ids: v.array(v.id("songs")) },
handler: async (ctx, args): Promise<BrowseSong[]> => {
if (args.ids.length > MAX_SONGS_BY_IDS) {
throw new ConvexError(`Request at most ${MAX_SONGS_BY_IDS} songs`)
}
return browseSongsFromIds(ctx, args.ids)
},
})
export const browseAlbumDetail = query({
args: { id: v.id("albums") },
handler: async (ctx, args): Promise<BrowseAlbumDetail | null> => {
+84 -14
View File
@@ -1,7 +1,7 @@
import { getAuthUserId } from "@convex-dev/auth/server"
import { paginationOptsValidator } from "convex/server"
import { ConvexError, v } from "convex/values"
import type { Id } from "./_generated/dataModel"
import type { Doc, Id } from "./_generated/dataModel"
import type { MutationCtx } from "./_generated/server"
import { mutation, query } from "./_generated/server"
import type { QueueSong } from "./types"
@@ -144,6 +144,30 @@ function appendManyToQueueHistory(
return next
}
async function patchPlayback(
ctx: MutationCtx,
userId: Id<"users">,
patch: Partial<
Pick<
Doc<"users">,
| "songQueue"
| "queueHistory"
| "currentSongProgress"
| "shuffleEnabled"
| "repeatEnabled"
>
>
) {
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const playbackRevision = (user.playbackRevision ?? 0) + 1
await ctx.db.patch(userId, { ...patch, playbackRevision })
return playbackRevision
}
async function setQueueState(
ctx: MutationCtx,
userId: Id<"users">,
@@ -154,7 +178,7 @@ async function setQueueState(
resetHistory?: boolean
}
) {
await ctx.db.patch(userId, {
await patchPlayback(ctx, userId, {
songQueue: patch.songQueue,
currentSongProgress: patch.currentSongProgress ?? 0,
...(patch.resetHistory ? { queueHistory: [] } : {}),
@@ -190,6 +214,52 @@ export const getPlaybackState = query({
shuffleEnabled: user.shuffleEnabled ?? false,
repeatEnabled: user.repeatEnabled ?? ("none" as const),
currentSongProgress: user.currentSongProgress ?? 0,
revision: user.playbackRevision ?? 0,
}
},
})
const repeatModeValidator = v.union(
v.literal("none"),
v.literal("once"),
v.literal("always")
)
/**
* Replaces the whole playback state with the client's local copy. Clients
* apply queue changes locally first and push snapshots here in the background.
*/
export const syncPlaybackState = mutation({
args: {
songQueue: v.array(v.id("songs")),
queueHistory: v.array(v.id("songs")),
shuffleEnabled: v.boolean(),
repeatEnabled: repeatModeValidator,
currentSongProgress: v.number(),
},
handler: async (ctx, args) => {
const userId = await requireAuth(ctx)
return await patchPlayback(ctx, userId, {
songQueue: args.songQueue,
queueHistory: args.queueHistory.slice(-MAX_QUEUE_HISTORY),
shuffleEnabled: args.shuffleEnabled,
repeatEnabled: args.repeatEnabled,
currentSongProgress: Math.max(0, Math.floor(args.currentSongProgress)),
})
},
})
export const recordPlay = mutation({
args: {
songId: v.optional(v.id("songs")),
playlistId: v.optional(v.id("playlists")),
},
handler: async (ctx, { songId, playlistId }) => {
const userId = await requireAuth(ctx)
if (playlistId) {
await recordRecentlyPlayed(ctx, userId, playlistId)
} else if (songId) {
await recordRecentlyPlayedFromSong(ctx, userId, songId)
}
},
})
@@ -543,14 +613,14 @@ export const toggleShuffle = mutation({
if (shuffleEnabled && queue.length > 1) {
const [current, ...upNext] = queue
await ctx.db.patch(userId, {
await patchPlayback(ctx, userId, {
shuffleEnabled: true,
songQueue: [current, ...shuffleArray(upNext)],
})
return
}
await ctx.db.patch(userId, { shuffleEnabled })
await patchPlayback(ctx, userId, { shuffleEnabled })
},
})
@@ -567,7 +637,7 @@ export const cycleRepeat = mutation({
const next =
current === "none" ? "once" : current === "once" ? "always" : "none"
await ctx.db.patch(userId, { repeatEnabled: next })
await patchPlayback(ctx, userId, { repeatEnabled: next })
},
})
@@ -575,7 +645,7 @@ export const clearQueue = mutation({
args: {},
handler: async (ctx) => {
const userId = await requireAuth(ctx)
await ctx.db.patch(userId, {
await patchPlayback(ctx, userId, {
songQueue: [],
queueHistory: [],
currentSongProgress: 0,
@@ -602,7 +672,7 @@ export const reorderQueue = mutation({
? appendToQueueHistory(user.queueHistory ?? [], queue[0])
: (user.queueHistory ?? [])
await ctx.db.patch(userId, {
await patchPlayback(ctx, userId, {
songQueue: songIds,
queueHistory: history,
...(currentSongChanged ? { currentSongProgress: 0 } : {}),
@@ -627,7 +697,7 @@ export const skipToQueueIndex = mutation({
const skipped = queue.slice(0, index)
const history = appendManyToQueueHistory(user.queueHistory ?? [], skipped)
await ctx.db.patch(userId, {
await patchPlayback(ctx, userId, {
songQueue: queue.slice(index),
queueHistory: history,
currentSongProgress: 0,
@@ -652,14 +722,14 @@ export const skipNext = mutation({
const repeat = user.repeatEnabled ?? "none"
if (repeat === "once") {
await ctx.db.patch(userId, { currentSongProgress: 0 })
await patchPlayback(ctx, userId, { currentSongProgress: 0 })
return
}
const [current, ...rest] = queue
if (repeat === "always") {
await ctx.db.patch(userId, {
await patchPlayback(ctx, userId, {
songQueue: [...rest, current],
currentSongProgress: 0,
})
@@ -667,7 +737,7 @@ export const skipNext = mutation({
}
if (rest.length === 0) {
await ctx.db.patch(userId, {
await patchPlayback(ctx, userId, {
songQueue: [current],
currentSongProgress: 0,
})
@@ -676,7 +746,7 @@ export const skipNext = mutation({
const history = appendToQueueHistory(user.queueHistory ?? [], current)
await ctx.db.patch(userId, {
await patchPlayback(ctx, userId, {
songQueue: rest,
queueHistory: history,
currentSongProgress: 0,
@@ -701,7 +771,7 @@ export const skipPrevious = mutation({
}
if (history.length === 0) {
await ctx.db.patch(userId, { currentSongProgress: 0 })
await patchPlayback(ctx, userId, { currentSongProgress: 0 })
return
}
@@ -709,7 +779,7 @@ export const skipPrevious = mutation({
const previous = history[history.length - 1]
const newHistory = history.slice(0, -1)
await ctx.db.patch(userId, {
await patchPlayback(ctx, userId, {
songQueue: [previous, current, ...rest],
queueHistory: newHistory,
currentSongProgress: 0,
+1
View File
@@ -28,6 +28,7 @@ export default defineSchema({
v.array(v.union(v.id("playlists"), v.id("albums")))
),
currentSongProgress: v.optional(v.number()),
playbackRevision: v.optional(v.number()),
shuffleEnabled: v.optional(v.boolean()),
repeatEnabled: v.optional(
v.union(v.literal("always"), v.literal("once"), v.literal("none"))