Files
qbz/src/lib/stores/lyricsStore.ts
T
vicrodh 182479f6c2 feat(settings): add lyrics cache clear button
- Add Lyrics section to Settings with cache clear button
- Add explicit debug logging for lyrics fetch/parse
- Add track change detection logging to watcher
2026-01-10 07:15:21 -06:00

451 lines
11 KiB
TypeScript

/**
* Lyrics State Store
*
* Manages lyrics fetching, LRC parsing, and synced line tracking.
*/
import { invoke } from '@tauri-apps/api/core';
import { getCurrentTrack, getCurrentTime, subscribe as subscribePlayer } from './playerStore';
// ============ Types ============
export interface LyricsPayload {
track_id: number | null;
title: string;
artist: string;
album: string | null;
duration_secs: number | null;
plain: string | null;
synced_lrc: string | null;
provider: 'lrclib' | 'ovh';
cached: boolean;
}
export interface LyricsLine {
timeMs: number;
text: string;
}
export interface ParsedLyrics {
lines: LyricsLine[];
isSynced: boolean;
}
type LyricsStatus = 'idle' | 'loading' | 'loaded' | 'error' | 'not_found';
// ============ State ============
let status: LyricsStatus = 'idle';
let error: string | null = null;
let payload: LyricsPayload | null = null;
let parsedLyrics: ParsedLyrics = { lines: [], isSynced: false };
let activeIndex = -1;
let activeProgress = 0;
let sidebarVisible = false;
// Track the last fetched track to avoid duplicate fetches
let lastFetchedTrackId: number | null = null;
// Listeners
const listeners = new Set<() => void>();
function notifyListeners(): void {
for (const listener of listeners) {
listener();
}
}
// ============ Subscribe ============
export function subscribe(listener: () => void): () => void {
listeners.add(listener);
listener();
return () => listeners.delete(listener);
}
// ============ Getters ============
export function getStatus(): LyricsStatus {
return status;
}
export function getError(): string | null {
return error;
}
export function getPayload(): LyricsPayload | null {
return payload;
}
export function getParsedLyrics(): ParsedLyrics {
return parsedLyrics;
}
export function getActiveIndex(): number {
return activeIndex;
}
export function getActiveProgress(): number {
return activeProgress;
}
export function isSidebarVisible(): boolean {
return sidebarVisible;
}
export interface LyricsState {
status: LyricsStatus;
error: string | null;
payload: LyricsPayload | null;
lines: LyricsLine[];
isSynced: boolean;
activeIndex: number;
activeProgress: number;
sidebarVisible: boolean;
}
export function getLyricsState(): LyricsState {
return {
status,
error,
payload,
lines: parsedLyrics.lines,
isSynced: parsedLyrics.isSynced,
activeIndex,
activeProgress,
sidebarVisible
};
}
// ============ LRC Parser ============
/**
* Parse LRC format into array of lines with timestamps
* Supports: [mm:ss.xx], [mm:ss.xxx], [mm:ss]
*/
function parseLRC(lrc: string): LyricsLine[] {
const lines: LyricsLine[] = [];
const regex = /\[(\d{1,2}):(\d{2})(?:[.:](\d{2,3}))?\](.*)/g;
let match;
while ((match = regex.exec(lrc)) !== null) {
const minutes = parseInt(match[1], 10);
const seconds = parseInt(match[2], 10);
const ms = match[3] ? parseInt(match[3].padEnd(3, '0'), 10) : 0;
const text = match[4].trim();
if (text) {
const timeMs = (minutes * 60 + seconds) * 1000 + ms;
lines.push({ timeMs, text });
}
}
// Sort by time
lines.sort((a, b) => a.timeMs - b.timeMs);
return lines;
}
/**
* Parse plain lyrics (no timestamps)
*/
function parsePlain(plain: string): LyricsLine[] {
return plain
.split('\n')
.map(line => line.trim())
.filter(line => line.length > 0)
.map(text => ({ timeMs: 0, text }));
}
/**
* Parse lyrics payload into lines
*/
function parsePayload(p: LyricsPayload): ParsedLyrics {
if (p.synced_lrc && p.synced_lrc.trim()) {
const lines = parseLRC(p.synced_lrc);
if (lines.length > 0) {
return { lines, isSynced: true };
}
}
if (p.plain && p.plain.trim()) {
return { lines: parsePlain(p.plain), isSynced: false };
}
return { lines: [], isSynced: false };
}
// ============ Active Line Tracking ============
/**
* Find active line index using binary search
*/
function findActiveLineIndex(lines: LyricsLine[], currentTimeMs: number): number {
if (lines.length === 0) return -1;
let left = 0;
let right = lines.length - 1;
let result = -1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (lines[mid].timeMs <= currentTimeMs) {
result = mid;
left = mid + 1;
} else {
right = mid - 1;
}
}
return result;
}
/**
* Calculate progress within current line (0-1)
*/
function calculateLineProgress(lines: LyricsLine[], index: number, currentTimeMs: number): number {
if (index < 0 || index >= lines.length) return 0;
const currentLine = lines[index];
const nextLine = lines[index + 1];
if (!nextLine) {
// Last line - assume 5 seconds duration
const duration = 5000;
return Math.min(1, (currentTimeMs - currentLine.timeMs) / duration);
}
const lineDuration = nextLine.timeMs - currentLine.timeMs;
if (lineDuration <= 0) return 0;
return Math.min(1, (currentTimeMs - currentLine.timeMs) / lineDuration);
}
/**
* Update active line based on current playback time
*/
let lastLogTime = 0;
export function updateActiveLine(): void {
if (!parsedLyrics.isSynced || parsedLyrics.lines.length === 0) {
if (activeIndex !== -1 || activeProgress !== 0) {
activeIndex = -1;
activeProgress = 0;
notifyListeners();
}
return;
}
const currentTimeMs = getCurrentTime() * 1000;
const newIndex = findActiveLineIndex(parsedLyrics.lines, currentTimeMs);
const newProgress = calculateLineProgress(parsedLyrics.lines, newIndex, currentTimeMs);
// Debug log every 2 seconds
const now = Date.now();
if (now - lastLogTime > 2000) {
lastLogTime = now;
console.log('[Lyrics] Update:', {
currentTimeMs,
newIndex,
newProgress: newProgress.toFixed(2),
activeLine: parsedLyrics.lines[newIndex]?.text?.substring(0, 30)
});
}
if (newIndex !== activeIndex || Math.abs(newProgress - activeProgress) > 0.01) {
activeIndex = newIndex;
activeProgress = newProgress;
notifyListeners();
}
}
// ============ Actions ============
/**
* Fetch lyrics for current track
*/
export async function fetchLyrics(): Promise<void> {
const track = getCurrentTrack();
if (!track) {
reset();
return;
}
// Skip if already fetched for this track
if (track.id === lastFetchedTrackId && status === 'loaded') {
return;
}
lastFetchedTrackId = track.id;
status = 'loading';
error = null;
notifyListeners();
try {
console.log(`[Lyrics] Fetching for: "${track.title}" by "${track.artist}"`);
const result = await invoke<LyricsPayload | null>('lyrics_get', {
trackId: track.id,
title: track.title,
artist: track.artist,
album: track.album || null,
durationSecs: track.duration || null
});
// Explicit logging - no objects to expand
console.log(`[Lyrics] Backend: hasResult=${!!result}, hasSyncedLrc=${!!result?.synced_lrc}, syncedLen=${result?.synced_lrc?.length ?? 0}, hasPlain=${!!result?.plain}, provider=${result?.provider}`);
if (result?.synced_lrc) {
console.log(`[Lyrics] Synced LRC preview: ${result.synced_lrc.substring(0, 150)}`);
}
if (result) {
payload = result;
parsedLyrics = parsePayload(result);
console.log(`[Lyrics] Parsed: linesCount=${parsedLyrics.lines.length}, isSynced=${parsedLyrics.isSynced}, firstTimeMs=${parsedLyrics.lines[0]?.timeMs ?? 'N/A'}, firstText="${parsedLyrics.lines[0]?.text?.substring(0, 30) ?? 'N/A'}"`);
status = 'loaded';
activeIndex = -1;
activeProgress = 0;
// Immediately update active line
if (parsedLyrics.isSynced) {
updateActiveLine();
}
} else {
payload = null;
parsedLyrics = { lines: [], isSynced: false };
status = 'not_found';
}
} catch (err) {
console.error('Failed to fetch lyrics:', err);
status = 'error';
error = err instanceof Error ? err.message : String(err);
payload = null;
parsedLyrics = { lines: [], isSynced: false };
}
notifyListeners();
}
/**
* Toggle sidebar visibility
*/
export function toggleSidebar(): void {
sidebarVisible = !sidebarVisible;
notifyListeners();
}
/**
* Show sidebar
*/
export function showSidebar(): void {
if (!sidebarVisible) {
sidebarVisible = true;
notifyListeners();
}
}
/**
* Hide sidebar
*/
export function hideSidebar(): void {
if (sidebarVisible) {
sidebarVisible = false;
notifyListeners();
}
}
/**
* Clear lyrics cache (via backend)
*/
export async function clearCache(): Promise<void> {
try {
await invoke('lyrics_clear_cache');
console.log('Lyrics cache cleared');
} catch (err) {
console.error('Failed to clear lyrics cache:', err);
}
}
/**
* Reset store state
*/
export function reset(): void {
status = 'idle';
error = null;
payload = null;
parsedLyrics = { lines: [], isSynced: false };
activeIndex = -1;
activeProgress = 0;
lastFetchedTrackId = null;
notifyListeners();
}
// ============ Auto-update ============
let updateInterval: number | null = null;
/**
* Start auto-updating active line (call when lyrics are synced and playing)
*/
export function startActiveLineUpdates(): void {
if (updateInterval !== null) return;
console.log('[Lyrics] Starting active line updates, isSynced:', parsedLyrics.isSynced);
updateInterval = window.setInterval(() => {
if (parsedLyrics.isSynced) {
updateActiveLine();
}
}, 50); // 50ms for smooth progress
}
/**
* Stop auto-updating active line
*/
export function stopActiveLineUpdates(): void {
if (updateInterval !== null) {
clearInterval(updateInterval);
updateInterval = null;
}
}
// ============ Player Integration ============
let playerUnsubscribe: (() => void) | null = null;
let lastTrackId: number | null = null;
/**
* Start watching player state for track changes
* Prefetches lyrics as soon as a new track starts playing
*/
export function startWatching(): void {
if (playerUnsubscribe) return;
console.log('[Lyrics] Starting track watcher');
playerUnsubscribe = subscribePlayer(() => {
const track = getCurrentTrack();
const trackId = track?.id ?? null;
// Track changed - always prefetch lyrics for new track
if (trackId !== lastTrackId) {
console.log('[Lyrics] Track changed:', { from: lastTrackId, to: trackId, title: track?.title });
lastTrackId = trackId;
if (trackId !== null) {
// Always prefetch lyrics when a new track starts
fetchLyrics();
} else {
reset();
}
}
});
}
/**
* Stop watching player state
*/
export function stopWatching(): void {
if (playerUnsubscribe) {
playerUnsubscribe();
playerUnsubscribe = null;
}
stopActiveLineUpdates();
}