@involvex/youtube-music-cli 0.0.2 → 0.0.3

package/dist/source/components/settings/Settings.js

@@ -1,42 +1,105 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // Settings component
-import { useState, useCallback } from 'react';
+import { useState } from 'react';
 import { Box, Text } from 'ink';
 import { useTheme } from "../../hooks/useTheme.js";
 import { useNavigation } from "../../hooks/useNavigation.js";
 import { getConfigService } from "../../services/config/config.service.js";
 import { useKeyBinding } from "../../hooks/useKeyboard.js";
 import { KEYBINDINGS, VIEW } from "../../utils/constants.js";
+import { useSleepTimer } from "../../hooks/useSleepTimer.js";
+import { formatTime } from "../../utils/format.js";
 const QUALITIES = ['low', 'medium', 'high'];
-const SETTINGS_ITEMS = ['Stream Quality', 'Manage Plugins'];
+const SETTINGS_ITEMS = [
+    'Stream Quality',
+    'Audio Normalization',
+    'Notifications',
+    'Discord Rich Presence',
+    'Sleep Timer',
+    'Custom Keybindings',
+    'Manage Plugins',
+];
 export default function Settings() {
     const { theme } = useTheme();
     const { dispatch } = useNavigation();
     const config = getConfigService();
     const [selectedIndex, setSelectedIndex] = useState(0);
     const [quality, setQuality] = useState(config.get('streamQuality') || 'high');
-    const navigateUp = useCallback(() => {
+    const [audioNormalization, setAudioNormalization] = useState(config.get('audioNormalization') ?? false);
+    const [notifications, setNotifications] = useState(config.get('notifications') ?? false);
+    const [discordRpc, setDiscordRpc] = useState(config.get('discordRichPresence') ?? false);
+    const { isActive, activeMinutes, remainingSeconds, startTimer, cancelTimer, presets, } = useSleepTimer();
+    const navigateUp = () => {
         setSelectedIndex(prev => Math.max(0, prev - 1));
-    }, [setSelectedIndex]);
-    const navigateDown = useCallback(() => {
+    };
+    const navigateDown = () => {
         setSelectedIndex(prev => Math.min(SETTINGS_ITEMS.length - 1, prev + 1));
-    }, [setSelectedIndex]);
-    const toggleQuality = useCallback(() => {
+    };
+    const toggleQuality = () => {
         const currentIndex = QUALITIES.indexOf(quality);
         const nextQuality = QUALITIES[(currentIndex + 1) % QUALITIES.length];
         setQuality(nextQuality);
         config.set('streamQuality', nextQuality);
-    }, [quality, config]);
-    const handleSelect = useCallback(() => {
+    };
+    const toggleNormalization = () => {
+        const next = !audioNormalization;
+        setAudioNormalization(next);
+        config.set('audioNormalization', next);
+    };
+    const toggleNotifications = () => {
+        const next = !notifications;
+        setNotifications(next);
+        config.set('notifications', next);
+    };
+    const toggleDiscordRpc = () => {
+        const next = !discordRpc;
+        setDiscordRpc(next);
+        config.set('discordRichPresence', next);
+    };
+    const cycleSleepTimer = () => {
+        if (isActive) {
+            cancelTimer();
+            return;
+        }
+        // Find next preset (start from first if none active)
+        const currentPresetIndex = activeMinutes
+            ? presets.indexOf(activeMinutes)
+            : -1;
+        const nextPreset = presets[(currentPresetIndex + 1) % presets.length];
+        startTimer(nextPreset);
+    };
+    const handleSelect = () => {
         if (selectedIndex === 0) {
             toggleQuality();
         }
         else if (selectedIndex === 1) {
+            toggleNormalization();
+        }
+        else if (selectedIndex === 2) {
+            toggleNotifications();
+        }
+        else if (selectedIndex === 3) {
+            toggleDiscordRpc();
+        }
+        else if (selectedIndex === 4) {
+            cycleSleepTimer();
+        }
+        else if (selectedIndex === 5) {
+            dispatch({ category: 'NAVIGATE', view: VIEW.KEYBINDINGS });
+        }
+        else if (selectedIndex === 6) {
             dispatch({ category: 'NAVIGATE', view: VIEW.PLUGINS });
         }
-    }, [selectedIndex, toggleQuality, dispatch]);
+    };
     useKeyBinding(KEYBINDINGS.UP, navigateUp);
     useKeyBinding(KEYBINDINGS.DOWN, navigateDown);
     useKeyBinding(KEYBINDINGS.SELECT, handleSelect);
-    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Box, { borderStyle: "double", borderColor: theme.colors.secondary, paddingX: 1, marginBottom: 1, children: _jsx(Text, { bold: true, color: theme.colors.primary, children: "Settings" }) }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { backgroundColor: selectedIndex === 0 ? theme.colors.primary : undefined, color: selectedIndex === 0 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 0, children: ["Stream Quality: ", quality.toUpperCase()] }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 1 ? theme.colors.primary : undefined, color: selectedIndex === 1 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 1, children: "Manage Plugins" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.colors.dim, children: "Arrows to navigate, Enter to select, Esc/q to go back" }) })] }));
+    const sleepTimerLabel = isActive && remainingSeconds !== null
+        ? `Sleep Timer: ${formatTime(remainingSeconds)} remaining (Enter to cancel)`
+        : 'Sleep Timer: Off (Enter to set)';
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Box, { borderStyle: "double", borderColor: theme.colors.secondary, paddingX: 1, marginBottom: 1, children: _jsx(Text, { bold: true, color: theme.colors.primary, children: "Settings" }) }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { backgroundColor: selectedIndex === 0 ? theme.colors.primary : undefined, color: selectedIndex === 0 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 0, children: ["Stream Quality: ", quality.toUpperCase()] }) }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { backgroundColor: selectedIndex === 1 ? theme.colors.primary : undefined, color: selectedIndex === 1 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 1, children: ["Audio Normalization: ", audioNormalization ? 'ON' : 'OFF'] }) }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { backgroundColor: selectedIndex === 2 ? theme.colors.primary : undefined, color: selectedIndex === 2 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 2, children: ["Desktop Notifications: ", notifications ? 'ON' : 'OFF'] }) }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { backgroundColor: selectedIndex === 3 ? theme.colors.primary : undefined, color: selectedIndex === 3 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 3, children: ["Discord Rich Presence: ", discordRpc ? 'ON' : 'OFF'] }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 4 ? theme.colors.primary : undefined, color: selectedIndex === 4
+                        ? theme.colors.background
+                        : isActive
+                            ? theme.colors.accent
+                            : theme.colors.text, bold: selectedIndex === 4, children: sleepTimerLabel }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 5 ? theme.colors.primary : undefined, color: selectedIndex === 5 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 5, children: "Custom Keybindings \u2192" }) }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { backgroundColor: selectedIndex === 6 ? theme.colors.primary : undefined, color: selectedIndex === 6 ? theme.colors.background : theme.colors.text, bold: selectedIndex === 6, children: "Manage Plugins" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.colors.dim, children: "Arrows to navigate, Enter to select, Esc/q to go back" }) })] }));
 }

package/dist/source/config/themes.config.js

@@ -59,5 +59,65 @@ export const BUILTIN_THEMES = {
         },
         inverse: false,
     },
+    dracula: {
+        name: 'Dracula',
+        colors: {
+            primary: 'magenta',
+            secondary: 'cyan',
+            background: 'black',
+            text: 'white',
+            accent: 'yellow',
+            dim: 'gray',
+            error: 'red',
+            success: 'green',
+            warning: 'yellow',
+        },
+        inverse: false,
+    },
+    nord: {
+        name: 'Nord',
+        colors: {
+            primary: 'blue',
+            secondary: 'cyan',
+            background: 'black',
+            text: 'white',
+            accent: 'blueBright',
+            dim: 'gray',
+            error: 'red',
+            success: 'greenBright',
+            warning: 'yellow',
+        },
+        inverse: false,
+    },
+    solarized: {
+        name: 'Solarized',
+        colors: {
+            primary: 'cyan',
+            secondary: 'blue',
+            background: 'black',
+            text: 'white',
+            accent: 'yellow',
+            dim: 'gray',
+            error: 'red',
+            success: 'green',
+            warning: 'magenta',
+        },
+        inverse: false,
+    },
+    catppuccin: {
+        name: 'Catppuccin',
+        colors: {
+            primary: 'magenta',
+            secondary: 'blue',
+            background: 'black',
+            text: 'white',
+            accent: 'cyan',
+            dim: 'gray',
+            error: 'red',
+            success: 'green',
+            warning: 'yellow',
+        },
+        inverse: false,
+    },
 };
 export const DEFAULT_THEME = BUILTIN_THEMES['dark'];

package/dist/source/hooks/usePlayer.d.ts

@@ -13,6 +13,8 @@ export declare function usePlayer(): {
     setVolume: (volume: number) => void;
     volumeUp: () => void;
     volumeDown: () => void;
+    volumeFineUp: () => void;
+    volumeFineDown: () => void;
     toggleShuffle: () => void;
     toggleRepeat: () => void;
     setQueue: (queue: Track[]) => void;
@@ -20,4 +22,7 @@ export declare function usePlayer(): {
     removeFromQueue: (index: number) => void;
     clearQueue: () => void;
     setQueuePosition: (position: number) => void;
+    setSpeed: (speed: number) => void;
+    speedUp: () => void;
+    speedDown: () => void;
 };

package/dist/source/hooks/usePlaylist.d.ts

@@ -1,8 +1,9 @@
 import type { Playlist, Track } from '../types/youtube-music.types.ts';
+export type AddTrackResult = 'added' | 'duplicate';
 export declare function usePlaylist(): {
     playlists: Playlist[];
     createPlaylist: (name: string) => void;
     deletePlaylist: (playlistId: string) => void;
-    addTrackToPlaylist: (playlistId: string, track: Track) => void;
+    addTrackToPlaylist: (playlistId: string, track: Track, force?: boolean) => AddTrackResult;
     removeTrackFromPlaylist: (playlistId: string, trackIndex: number) => void;
 };

package/dist/source/hooks/usePlaylist.js

@@ -22,14 +22,20 @@ export function usePlaylist() {
         setPlaylists(updatedPlaylists);
         configService.set('playlists', updatedPlaylists);
     }, [playlists, configService]);
-    const addTrackToPlaylist = useCallback((playlistId, track) => {
+    const addTrackToPlaylist = useCallback((playlistId, track, force = false) => {
         const playlistIndex = playlists.findIndex(p => p.playlistId === playlistId);
         if (playlistIndex === -1)
-            return;
+            return 'added';
+        const playlist = playlists[playlistIndex];
+        const isDuplicate = playlist.tracks.some(t => t.videoId === track.videoId);
+        if (isDuplicate && !force) {
+            return 'duplicate';
+        }
         const updatedPlaylists = [...playlists];
         updatedPlaylists[playlistIndex].tracks.push(track);
         setPlaylists(updatedPlaylists);
         configService.set('playlists', updatedPlaylists);
+        return 'added';
     }, [playlists, configService]);
     const removeTrackFromPlaylist = useCallback((playlistId, trackIndex) => {
         const playlistIndex = playlists.findIndex(p => p.playlistId === playlistId);

package/dist/source/hooks/useSleepTimer.d.ts

@@ -0,0 +1,9 @@
+import { type SleepTimerPreset } from '../services/sleep-timer/sleep-timer.service.ts';
+export declare function useSleepTimer(): {
+    isActive: boolean;
+    activeMinutes: number | null;
+    remainingSeconds: number | null;
+    startTimer: (minutes: SleepTimerPreset) => void;
+    cancelTimer: () => void;
+    presets: readonly [5, 10, 15, 30, 60];
+};

package/dist/source/hooks/useSleepTimer.js

@@ -0,0 +1,48 @@
+// Hook for managing the sleep timer
+import { useState, useEffect, useCallback } from 'react';
+import { getSleepTimerService, SLEEP_TIMER_PRESETS, } from "../services/sleep-timer/sleep-timer.service.js";
+import { usePlayer } from "./usePlayer.js";
+export function useSleepTimer() {
+    const { pause } = usePlayer();
+    const timerService = getSleepTimerService();
+    const [remainingSeconds, setRemainingSeconds] = useState(null);
+    const [activeMinutes, setActiveMinutes] = useState(null);
+    // Poll remaining time every second when active
+    useEffect(() => {
+        if (!timerService.isActive())
+            return;
+        const interval = setInterval(() => {
+            const remaining = timerService.getRemainingSeconds();
+            setRemainingSeconds(remaining);
+            if (remaining === 0) {
+                setActiveMinutes(null);
+                clearInterval(interval);
+            }
+        }, 1000);
+        return () => {
+            clearInterval(interval);
+        };
+    }, [activeMinutes, timerService]);
+    const startTimer = useCallback((minutes) => {
+        setActiveMinutes(minutes);
+        setRemainingSeconds(minutes * 60);
+        timerService.start(minutes, () => {
+            pause();
+            setActiveMinutes(null);
+            setRemainingSeconds(null);
+        });
+    }, [timerService, pause]);
+    const cancelTimer = useCallback(() => {
+        timerService.cancel();
+        setActiveMinutes(null);
+        setRemainingSeconds(null);
+    }, [timerService]);
+    return {
+        isActive: timerService.isActive(),
+        activeMinutes,
+        remainingSeconds,
+        startTimer,
+        cancelTimer,
+        presets: SLEEP_TIMER_PRESETS,
+    };
+}

package/dist/source/services/cache/cache.service.d.ts

@@ -0,0 +1,14 @@
+export declare class CacheService<T = unknown> {
+    private cache;
+    private readonly maxSize;
+    private readonly defaultTtlMs;
+    constructor(maxSize?: number, defaultTtlMs?: number);
+    get(key: string): T | null;
+    set(key: string, value: T, ttlMs?: number): void;
+    has(key: string): boolean;
+    delete(key: string): void;
+    clear(): void;
+    get size(): number;
+    private evictLru;
+}
+export declare const getSearchCache: () => CacheService;

package/dist/source/services/cache/cache.service.js

@@ -0,0 +1,67 @@
+// In-memory LRU cache with optional TTL for API responses
+import { logger } from "../logger/logger.service.js";
+export class CacheService {
+    cache = new Map();
+    maxSize;
+    defaultTtlMs;
+    constructor(maxSize = 100, defaultTtlMs = 5 * 60 * 1000) {
+        this.maxSize = maxSize;
+        this.defaultTtlMs = defaultTtlMs;
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return null;
+        }
+        entry.lastAccessed = Date.now();
+        return entry.value;
+    }
+    set(key, value, ttlMs) {
+        // Evict LRU entry if at capacity
+        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            this.evictLru();
+        }
+        this.cache.set(key, {
+            value,
+            expiresAt: Date.now() + (ttlMs ?? this.defaultTtlMs),
+            lastAccessed: Date.now(),
+        });
+    }
+    has(key) {
+        return this.get(key) !== null;
+    }
+    delete(key) {
+        this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    get size() {
+        return this.cache.size;
+    }
+    evictLru() {
+        let lruKey = null;
+        let lruTime = Infinity;
+        for (const [key, entry] of this.cache) {
+            if (entry.lastAccessed < lruTime) {
+                lruTime = entry.lastAccessed;
+                lruKey = key;
+            }
+        }
+        if (lruKey) {
+            logger.debug('CacheService', 'Evicting LRU entry', { key: lruKey });
+            this.cache.delete(lruKey);
+        }
+    }
+}
+// Shared search result cache (100 entries, 5min TTL)
+let searchCacheInstance = null;
+export const getSearchCache = () => {
+    if (!searchCacheInstance) {
+        searchCacheInstance = new CacheService(100, 5 * 60 * 1000);
+    }
+    return searchCacheInstance;
+};

package/dist/source/services/config/config.service.d.ts

@@ -17,6 +17,8 @@ declare class ConfigService {
     setKeybinding(action: string, keys: string[]): void;
     addToHistory(trackId: string): void;
     getHistory(): string[];
+    addToSearchHistory(query: string): void;
+    getSearchHistory(): string[];
     addFavorite(trackId: string): void;
     removeFavorite(trackId: string): void;
     isFavorite(trackId: string): boolean;

package/dist/source/services/config/config.service.js

@@ -18,11 +18,15 @@ class ConfigService {
             keybindings: {},
             playlists: [],
             history: [],
+            searchHistory: [],
             favorites: [],
             repeat: 'off',
             shuffle: false,
             customTheme: undefined,
             streamQuality: 'high',
+            audioNormalization: false,
+            notifications: false,
+            discordRichPresence: false,
         };
     }
     load() {
@@ -98,6 +102,19 @@ class ConfigService {
     getHistory() {
         return this.config.history;
     }
+    addToSearchHistory(query) {
+        const trimmed = query.trim();
+        if (!trimmed)
+            return;
+        this.config.searchHistory = [
+            trimmed,
+            ...(this.config.searchHistory ?? []).filter(q => q !== trimmed),
+        ].slice(0, 100);
+        this.save();
+    }
+    getSearchHistory() {
+        return this.config.searchHistory ?? [];
+    }
     addFavorite(trackId) {
         if (!this.config.favorites.includes(trackId)) {
             this.config.favorites.push(trackId);

package/dist/source/services/discord/discord-rpc.service.d.ts

@@ -0,0 +1,17 @@
+interface TrackInfo {
+    title: string;
+    artist: string;
+    startTimestamp?: number;
+}
+export declare class DiscordRpcService {
+    private client;
+    private connected;
+    private enabled;
+    setEnabled(enabled: boolean): void;
+    connect(): Promise<void>;
+    updateActivity(track: TrackInfo): Promise<void>;
+    clearActivity(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export declare const getDiscordRpcService: () => DiscordRpcService;
+export {};

package/dist/source/services/discord/discord-rpc.service.js

@@ -0,0 +1,95 @@
+// Discord Rich Presence service
+// Uses discord-rpc package if available; gracefully no-ops if Discord is not running
+import { logger } from "../logger/logger.service.js";
+export class DiscordRpcService {
+    client = null;
+    connected = false;
+    enabled = false;
+    setEnabled(enabled) {
+        this.enabled = enabled;
+        if (!enabled) {
+            void this.disconnect();
+        }
+    }
+    async connect() {
+        if (!this.enabled || this.connected)
+            return;
+        try {
+            // Dynamic import so missing package doesn't crash startup
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            const rpc = await import('discord-rpc');
+            const client = new rpc.Client({ transport: 'ipc' });
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Discord RPC connection timeout'));
+                }, 5000);
+                client.on('ready', () => {
+                    clearTimeout(timeout);
+                    this.connected = true;
+                    logger.info('DiscordRpcService', 'Connected to Discord');
+                    resolve();
+                });
+                client
+                    .login({ clientId: '1234567890' }) // Public client ID for music players
+                    .catch(reject);
+            });
+            this.client = client;
+        }
+        catch (error) {
+            logger.warn('DiscordRpcService', 'Could not connect to Discord', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async updateActivity(track) {
+        if (!this.enabled || !this.connected || !this.client)
+            return;
+        try {
+            const c = this.client;
+            await c.setActivity({
+                details: track.title,
+                state: `by ${track.artist}`,
+                startTimestamp: track.startTimestamp ?? Date.now(),
+                largeImageKey: 'logo',
+                largeImageText: 'YouTube Music CLI',
+                instance: false,
+            });
+        }
+        catch (error) {
+            logger.warn('DiscordRpcService', 'Failed to update Discord activity', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async clearActivity() {
+        if (!this.connected || !this.client)
+            return;
+        try {
+            const c = this.client;
+            await c.clearActivity();
+        }
+        catch {
+            // Ignore
+        }
+    }
+    async disconnect() {
+        if (!this.client)
+            return;
+        try {
+            const c = this.client;
+            await c.destroy();
+        }
+        catch {
+            // Ignore
+        }
+        this.client = null;
+        this.connected = false;
+    }
+}
+let instance = null;
+export const getDiscordRpcService = () => {
+    if (!instance)
+        instance = new DiscordRpcService();
+    return instance;
+};

package/dist/source/services/lyrics/lyrics.service.d.ts

@@ -0,0 +1,22 @@
+export interface LyricLine {
+    time: number;
+    text: string;
+}
+export interface Lyrics {
+    synced: LyricLine[] | null;
+    plain: string | null;
+}
+declare class LyricsService {
+    private static instance;
+    private cache;
+    private constructor();
+    static getInstance(): LyricsService;
+    /** Parse LRC format into timed lines */
+    private parseLrc;
+    getLyrics(trackName: string, artistName: string, duration?: number): Promise<Lyrics | null>;
+    /** Get the current lyric line index based on playback position */
+    getCurrentLineIndex(lines: LyricLine[], currentTime: number): number;
+    clearCache(): void;
+}
+export declare const getLyricsService: () => LyricsService;
+export {};

package/dist/source/services/lyrics/lyrics.service.js

@@ -0,0 +1,93 @@
+// Lyrics service using LRCLIB API (https://lrclib.net)
+// Free, no authentication required
+import { logger } from "../logger/logger.service.js";
+const LRCLIB_BASE = 'https://lrclib.net/api';
+class LyricsService {
+    static instance;
+    cache = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!LyricsService.instance) {
+            LyricsService.instance = new LyricsService();
+        }
+        return LyricsService.instance;
+    }
+    /** Parse LRC format into timed lines */
+    parseLrc(lrc) {
+        const lines = [];
+        const lineRegex = /\[(\d{2}):(\d{2})\.(\d{2,3})\](.*)/;
+        for (const rawLine of lrc.split('\n')) {
+            const match = lineRegex.exec(rawLine.trim());
+            if (match) {
+                const minutes = Number.parseInt(match[1], 10);
+                const seconds = Number.parseInt(match[2], 10);
+                const centiseconds = Number.parseInt(match[3].padEnd(3, '0'), 10);
+                const time = minutes * 60 + seconds + centiseconds / 1000;
+                const text = match[4].trim();
+                lines.push({ time, text });
+            }
+        }
+        return lines.sort((a, b) => a.time - b.time);
+    }
+    async getLyrics(trackName, artistName, duration) {
+        const cacheKey = `${trackName}::${artistName}`;
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey) ?? null;
+        }
+        try {
+            const params = new URLSearchParams({
+                track_name: trackName,
+                artist_name: artistName,
+                ...(duration ? { duration: String(Math.round(duration)) } : {}),
+            });
+            const response = await fetch(`${LRCLIB_BASE}/get?${params.toString()}`);
+            if (!response.ok) {
+                if (response.status === 404) {
+                    logger.debug('LyricsService', 'No lyrics found', {
+                        trackName,
+                        artistName,
+                    });
+                    this.cache.set(cacheKey, null);
+                    return null;
+                }
+                throw new Error(`LRCLIB API error: ${response.status}`);
+            }
+            const data = (await response.json());
+            const lyrics = {
+                synced: data.syncedLyrics ? this.parseLrc(data.syncedLyrics) : null,
+                plain: data.plainLyrics ?? null,
+            };
+            this.cache.set(cacheKey, lyrics);
+            logger.info('LyricsService', 'Lyrics loaded', {
+                trackName,
+                hasSynced: !!lyrics.synced,
+                hasPlain: !!lyrics.plain,
+            });
+            return lyrics;
+        }
+        catch (error) {
+            logger.warn('LyricsService', 'Failed to fetch lyrics', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this.cache.set(cacheKey, null);
+            return null;
+        }
+    }
+    /** Get the current lyric line index based on playback position */
+    getCurrentLineIndex(lines, currentTime) {
+        let index = 0;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].time <= currentTime) {
+                index = i;
+            }
+            else {
+                break;
+            }
+        }
+        return index;
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+}
+export const getLyricsService = () => LyricsService.getInstance();