174 lines
4.5 KiB
TypeScript
174 lines
4.5 KiB
TypeScript
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
|
|
}
|