106 lines
3.1 KiB
TypeScript
106 lines
3.1 KiB
TypeScript
"use client"
|
|
|
|
import { useEffect, useMemo, useState, useSyncExternalStore } from "react"
|
|
|
|
import { api } from "@otunes/convex/_generated/api"
|
|
import type { Id } from "@otunes/convex/_generated/dataModel"
|
|
import {
|
|
followLyrics,
|
|
parseLyrics,
|
|
type Lyrics,
|
|
} from "@otunes/convex/client/lyrics"
|
|
import { readLyricsTag } from "@otunes/convex/client/lyrics-tags"
|
|
import { useCachedQuery } from "@/hooks/use-cached-query"
|
|
import { downloadedAudioBlob, downloadQueue } from "@/lib/downloads"
|
|
|
|
// Lyrics read from downloaded files, by song. Files do not change once saved.
|
|
const localLyrics = new Map<string, Promise<string | null>>()
|
|
|
|
function readLocalLyrics(songId: string) {
|
|
let lyrics = localLyrics.get(songId)
|
|
if (!lyrics) {
|
|
lyrics = downloadedAudioBlob(songId)
|
|
.then((blob) =>
|
|
blob
|
|
? readLyricsTag({
|
|
size: blob.size,
|
|
read: async (offset, length) =>
|
|
new Uint8Array(
|
|
await blob.slice(offset, offset + length).arrayBuffer()
|
|
),
|
|
})
|
|
: null
|
|
)
|
|
.then((text) => text?.trim() || null)
|
|
.catch(() => null)
|
|
localLyrics.set(songId, lyrics)
|
|
}
|
|
return lyrics
|
|
}
|
|
|
|
/**
|
|
* A song's lyrics: from its downloaded file when there is one, otherwise from
|
|
* the server. `undefined` while loading, `null` when the song has none.
|
|
*/
|
|
export function useLyrics(songId: Id<"songs"> | null) {
|
|
const downloaded = useSyncExternalStore(
|
|
downloadQueue.subscribe,
|
|
() => (songId ? downloadQueue.getDownloaded(songId) !== undefined : false),
|
|
() => false
|
|
)
|
|
const [local, setLocal] = useState<{
|
|
songId: string
|
|
text: string | null
|
|
} | null>(null)
|
|
|
|
useEffect(() => {
|
|
if (!songId || !downloaded) return
|
|
let current = true
|
|
void readLocalLyrics(songId).then((text) => {
|
|
if (current) setLocal({ songId, text })
|
|
})
|
|
return () => {
|
|
current = false
|
|
}
|
|
}, [songId, downloaded])
|
|
|
|
const localText =
|
|
songId && downloaded && local?.songId === songId ? local.text : undefined
|
|
// Songs without a downloaded copy, or whose copy has no lyrics tag.
|
|
const remote = useCachedQuery(
|
|
api.lyrics.forSong,
|
|
songId && (!downloaded || localText === null) ? { id: songId } : "skip"
|
|
)
|
|
const text = localText || remote
|
|
|
|
return useMemo<Lyrics | null | undefined>(() => {
|
|
if (!songId) return null
|
|
if (text === undefined) return undefined
|
|
return text ? parseLyrics(text) : null
|
|
}, [songId, text])
|
|
}
|
|
|
|
/**
|
|
* The playback time for highlighting lyrics: the player's `currentTime`,
|
|
* advanced by `followLyrics` between its progress updates.
|
|
*/
|
|
export function useLyricsTime(
|
|
lyrics: Lyrics | null | undefined,
|
|
currentTime: number,
|
|
isPlaying: boolean
|
|
) {
|
|
// Time reached since the player last reported `from`.
|
|
const [advanced, setAdvanced] = useState<{ from: number; time: number }>()
|
|
|
|
useEffect(() => {
|
|
if (!lyrics || !isPlaying) return
|
|
return followLyrics(lyrics, currentTime, (time) =>
|
|
setAdvanced({ from: currentTime, time })
|
|
)
|
|
}, [lyrics, currentTime, isPlaying])
|
|
|
|
return isPlaying && advanced?.from === currentTime
|
|
? advanced.time
|
|
: currentTime
|
|
}
|