Lyrics search kept only the top 50 search index hits before checking lines, so phrases of common words like "let your people go" lost the song. Check the whole index page instead, and match titles, artists, albums and lyrics with typo tolerance, ignoring accents and apostrophes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
260 lines
7.9 KiB
TypeScript
260 lines
7.9 KiB
TypeScript
/**
|
|
* Lyrics as tagged in the music files: plain text, LRC (`[mm:ss.xx]line`), or
|
|
* word-timed LRC (`<mm:ss.xx>word`). The server stores that text unchanged and
|
|
* clients parse it here, so a downloaded file's tag and the server copy read
|
|
* the same.
|
|
*/
|
|
|
|
import { matchWords, searchWords } from "./fuzzy-search"
|
|
|
|
export type LyricWord = {
|
|
/** Includes its trailing space, so a line's words join back into its text. */
|
|
text: string
|
|
start: number
|
|
end: number
|
|
}
|
|
|
|
export type LyricLine = {
|
|
text: string
|
|
/** Seconds; `null` for plain lyrics. */
|
|
start: number | null
|
|
/**
|
|
* The line's words as they are sung. Line-timed lyrics get estimated
|
|
* ones (see `estimateWords`); plain lyrics have none.
|
|
*/
|
|
words: LyricWord[] | null
|
|
}
|
|
|
|
export type Lyrics = {
|
|
/** How the source was timed, whatever `words` were estimated. */
|
|
synced: "none" | "line" | "word"
|
|
lines: LyricLine[]
|
|
}
|
|
|
|
const LINE_STAMP = /^\[(\d+):(\d+(?:[.:]\d+)?)\]/
|
|
const WORD_STAMP = /<(\d+):(\d+(?:[.:]\d+)?)>/g
|
|
const HAS_WORD_STAMP = /<\d+:\d+(?:[.:]\d+)?>/
|
|
const ID_TAG = /^\[[a-z]+:.*\]$/i
|
|
/** A rough singing pace, so a line-timed line's fill tracks its words. */
|
|
const ESTIMATED_SECONDS_PER_CHAR = 0.07
|
|
|
|
function seconds(minutes: string, rest: string) {
|
|
return Number(minutes) * 60 + Number(rest.replace(":", "."))
|
|
}
|
|
|
|
/** Splits `<t>word <t>word<t>` into words; the last stamp ends the last word. */
|
|
function parseWords(body: string): LyricWord[] {
|
|
const stamps = [...body.matchAll(WORD_STAMP)]
|
|
const words: LyricWord[] = []
|
|
for (let i = 0; i < stamps.length; i++) {
|
|
const stamp = stamps[i]
|
|
const textStart = stamp.index + stamp[0].length
|
|
const next = stamps[i + 1]
|
|
const text = body.slice(textStart, next?.index ?? body.length)
|
|
const start = seconds(stamp[1], stamp[2])
|
|
if (text.trim()) {
|
|
words.push({
|
|
text,
|
|
start,
|
|
end: next ? seconds(next[1], next[2]) : start,
|
|
})
|
|
}
|
|
}
|
|
return words
|
|
}
|
|
|
|
export function parseLyrics(raw: string): Lyrics | null {
|
|
const rows = raw.replace(/\r\n?/g, "\n").split("\n")
|
|
const timed = rows.some((row) => LINE_STAMP.test(row.trim()))
|
|
const wordTimed = rows.some((row) => HAS_WORD_STAMP.test(row))
|
|
|
|
if (!timed && !wordTimed) {
|
|
const lines = rows.map((row) => ({
|
|
text: row.trim(),
|
|
start: null,
|
|
words: null,
|
|
}))
|
|
// Blank rows between stanzas stay as spacing; ones at the ends go.
|
|
while (lines[0]?.text === "") lines.shift()
|
|
while (lines.at(-1)?.text === "") lines.pop()
|
|
return lines.length > 0 ? { synced: "none", lines } : null
|
|
}
|
|
|
|
const lines: LyricLine[] = []
|
|
for (const row of rows) {
|
|
let body = row.trim()
|
|
if (ID_TAG.test(body) && !LINE_STAMP.test(body)) continue
|
|
// A line may repeat under several stamps: `[00:12.00][01:30.00]Chorus`.
|
|
const starts: number[] = []
|
|
for (let match = LINE_STAMP.exec(body); match;) {
|
|
starts.push(seconds(match[1], match[2]))
|
|
body = body.slice(match[0].length)
|
|
match = LINE_STAMP.exec(body)
|
|
}
|
|
const words = wordTimed ? parseWords(body) : []
|
|
const text = (
|
|
words.length > 0 ? words.map((word) => word.text).join("") : body
|
|
).trim()
|
|
if (!text) continue
|
|
if (starts.length === 0 && words.length > 0) starts.push(words[0].start)
|
|
for (const start of starts) {
|
|
const shift = words.length > 0 ? start - words[0].start : 0
|
|
lines.push({
|
|
text,
|
|
start,
|
|
words:
|
|
words.length > 0
|
|
? words.map((word) => ({
|
|
...word,
|
|
start: word.start + shift,
|
|
end: word.end + shift,
|
|
}))
|
|
: null,
|
|
})
|
|
}
|
|
}
|
|
lines.sort((a, b) => a.start! - b.start!)
|
|
if (lines.length === 0) return null
|
|
const synced = lines.every((line) => line.words) ? "word" : "line"
|
|
if (synced === "line") estimateWords(lines)
|
|
return { synced, lines }
|
|
}
|
|
|
|
/**
|
|
* Gives timed lines without word timing words spread over them by length,
|
|
* at a singing pace but never past the next line, so they fill as they play.
|
|
*/
|
|
function estimateWords(lines: LyricLine[]) {
|
|
lines.forEach((line, index) => {
|
|
if (line.words || line.start === null) return
|
|
const next = lines[index + 1]?.start ?? Infinity
|
|
const duration = Math.min(
|
|
next - line.start,
|
|
line.text.length * ESTIMATED_SECONDS_PER_CHAR
|
|
)
|
|
const perChar = duration / line.text.length
|
|
let at = line.start
|
|
line.words = (line.text.match(/\S+\s*/g) ?? []).map((text) => {
|
|
const start = at
|
|
at += text.length * perChar
|
|
return { text, start, end: at }
|
|
})
|
|
})
|
|
}
|
|
|
|
/** The text without timestamps, one line per row, for search and snippets. */
|
|
export function plainLyrics(lyrics: Lyrics) {
|
|
return lyrics.lines.map((line) => line.text).join("\n")
|
|
}
|
|
|
|
/** How well a tag's lyrics are timed, to keep the best of a song's files. */
|
|
export function lyricsRank(raw: string | null) {
|
|
const synced = raw ? parseLyrics(raw)?.synced : undefined
|
|
return synced === "word" ? 3 : synced === "line" ? 2 : synced ? 1 : 0
|
|
}
|
|
|
|
/**
|
|
* The line playing at `time` (the last one started), or -1 before the first.
|
|
* Plain lyrics never have one.
|
|
*/
|
|
export function activeLineIndex(lyrics: Lyrics, time: number) {
|
|
let active = -1
|
|
for (let i = 0; i < lyrics.lines.length; i++) {
|
|
const start = lyrics.lines[i].start
|
|
if (start === null || start > time) break
|
|
active = i
|
|
}
|
|
return active
|
|
}
|
|
|
|
/** When the highlighted line or word next changes after `time`, if ever. */
|
|
export function nextLyricsChange(lyrics: Lyrics, time: number) {
|
|
let next = Infinity
|
|
for (const line of lyrics.lines) {
|
|
if (line.start !== null && line.start > time) {
|
|
next = Math.min(next, line.start)
|
|
break
|
|
}
|
|
for (const word of line.words ?? []) {
|
|
if (word.start > time) {
|
|
next = Math.min(next, word.start)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return next
|
|
}
|
|
|
|
/**
|
|
* While audio plays on from `time` seconds, calls `onChange` with the playback
|
|
* time whenever the highlighted line or word changes. Players report progress
|
|
* only a few times a second, which is too coarse for word timing. Returns a
|
|
* function that stops it.
|
|
*/
|
|
export function followLyrics(
|
|
lyrics: Lyrics,
|
|
time: number,
|
|
onChange: (time: number) => void
|
|
) {
|
|
const startedAt = Date.now() - time * 1000
|
|
let timer: ReturnType<typeof setTimeout> | undefined
|
|
const schedule = (from: number) => {
|
|
const next = nextLyricsChange(lyrics, from)
|
|
if (!Number.isFinite(next)) return
|
|
timer = setTimeout(
|
|
() => {
|
|
const now = (Date.now() - startedAt) / 1000
|
|
onChange(now)
|
|
schedule(now)
|
|
},
|
|
(next - from) * 1000
|
|
)
|
|
}
|
|
if (lyrics.synced !== "none") schedule(time)
|
|
return () => clearTimeout(timer)
|
|
}
|
|
|
|
const SNIPPET_LEAD = 24
|
|
|
|
export type LyricsMatch = {
|
|
/** The matched line, trimmed to start near the match. */
|
|
snippet: string
|
|
/**
|
|
* 2 when the line holds the query as typed, 1 when it holds every word of
|
|
* it, 0 when it does give or take typos.
|
|
*/
|
|
score: 0 | 1 | 2
|
|
}
|
|
|
|
/**
|
|
* Where a search matched the lyrics: the best line holding the query as
|
|
* typed, or else every word of it (see `matchWords`). Null when no single
|
|
* line does.
|
|
*/
|
|
export function matchLyrics(plain: string, query: string): LyricsMatch | null {
|
|
const needle = query.trim().toLowerCase()
|
|
const terms = searchWords(needle)
|
|
// Most songs miss a word entirely, so skip them before checking lines.
|
|
if (!needle || !matchWords([...new Set(searchWords(plain))], terms)) {
|
|
return null
|
|
}
|
|
|
|
let loose: LyricsMatch | null = null
|
|
for (const line of plain.split("\n")) {
|
|
const column = line.toLowerCase().indexOf(needle)
|
|
if (column !== -1) {
|
|
const snippet =
|
|
column > SNIPPET_LEAD
|
|
? `…${line.slice(column - SNIPPET_LEAD).trimStart()}`
|
|
: line.trim()
|
|
return { snippet, score: 2 }
|
|
}
|
|
if (loose?.score === 1) continue
|
|
const quality = matchWords(searchWords(line), terms)
|
|
if (quality === "exact" || (quality && !loose)) {
|
|
loose = { snippet: line.trim(), score: quality === "exact" ? 1 : 0 }
|
|
}
|
|
}
|
|
return loose
|
|
}
|