@involvex/youtube-music-cli 0.0.47 → 0.0.49

package/dist/source/hooks/useKeyboard.js

@@ -1,188 +0,0 @@
-// Keyboard input handling hook
-import { useEffect, useRef } from 'react';
-import { useInput } from 'ink';
-import { logger } from "../services/logger/logger.service.js";
-import { useKeyboardBlockContext } from "./useKeyboardBlocker.js";
-// Global registry for key handlers
-const registry = new Set();
-/**
- * Hook to bind keyboard shortcuts.
- * This uses a centralized manager to avoid multiple useInput calls and memory leaks.
- * Uses a ref-based approach to always call the latest handler without stale closures.
- */
-export function useKeyBinding(keys, handler, options) {
-    const handlerRef = useRef(handler);
-    handlerRef.current = handler;
-    useEffect(() => {
-        const entry = {
-            keys,
-            handler: () => handlerRef.current(),
-            bypassBlock: options?.bypassBlock,
-        };
-        registry.add(entry);
-        return () => {
-            registry.delete(entry);
-        };
-    }, [keys, options?.bypassBlock]); // keys and bypassBlock are deps; handlerRef is a stable ref
-}
-/**
- * Global Keyboard Manager Component
- * This should be rendered once at the root of the app.
- */
-export function KeyboardManager() {
-    const { blockCount } = useKeyboardBlockContext();
-    useInput((input, key) => {
-        if (blockCount > 0) {
-            // When keyboard input is blocked (e.g., within a focused text input),
-            // check if any entry has bypassBlock flag and matches this key.
-            for (const entry of registry) {
-                if (entry.bypassBlock) {
-                    for (const binding of entry.keys) {
-                        const lowerBinding = binding.toLowerCase();
-                        // Check for ESC key (most common bypass case)
-                        if (lowerBinding === 'escape' && key.escape) {
-                            entry.handler();
-                            return;
-                        }
-                        // Handle other bypass keys
-                        const isMatch = ((lowerBinding === 'return' || lowerBinding === 'enter') &&
-                            key.return) ||
-                            (lowerBinding === 'backspace' && key.backspace) ||
-                            (lowerBinding === 'tab' && key.tab) ||
-                            (lowerBinding === 'up' && key.upArrow) ||
-                            (lowerBinding === 'down' && key.downArrow) ||
-                            (lowerBinding === 'left' && key.leftArrow) ||
-                            (lowerBinding === 'right' && key.rightArrow) ||
-                            (lowerBinding === 'pageup' && key.pageUp) ||
-                            (lowerBinding === 'pagedown' && key.pageDown) ||
-                            (() => {
-                                const parts = lowerBinding.split('+');
-                                const hasCtrl = parts.includes('ctrl');
-                                const hasMeta = parts.includes('meta') || parts.includes('alt');
-                                const hasShift = parts.includes('shift');
-                                const mainKey = parts[parts.length - 1];
-                                if (hasCtrl && !key.ctrl)
-                                    return false;
-                                if (hasMeta && !key.meta)
-                                    return false;
-                                if (hasShift && !key.shift)
-                                    return false;
-                                // Check arrow keys
-                                if (mainKey === 'up' && key.upArrow)
-                                    return true;
-                                if (mainKey === 'down' && key.downArrow)
-                                    return true;
-                                if (mainKey === 'left' && key.leftArrow)
-                                    return true;
-                                if (mainKey === 'right' && key.rightArrow)
-                                    return true;
-                                // Handle '=' and '+'
-                                if (mainKey === '=' && input === '=')
-                                    return true;
-                                if (mainKey === '+' && input === '+')
-                                    return true;
-                                if (mainKey === '+' && key.shift && input === '=')
-                                    return true;
-                                return (input.toLowerCase() === mainKey && !key.ctrl && !key.meta);
-                            })();
-                        if (isMatch) {
-                            entry.handler();
-                            return;
-                        }
-                    }
-                }
-            }
-            // If no bypass handler matched, skip all global shortcuts
-            return;
-        }
-        // Debug logging for key presses (helps diagnose binding issues)
-        if (input || key.ctrl || key.meta || key.shift) {
-            logger.debug('KeyboardManager', 'Key pressed', {
-                input,
-                ctrl: key.ctrl,
-                meta: key.meta,
-                shift: key.shift,
-                upArrow: key.upArrow,
-                downArrow: key.downArrow,
-                leftArrow: key.leftArrow,
-                rightArrow: key.rightArrow,
-            });
-        }
-        // Global quit handling
-        if (key.ctrl && input === 'c') {
-            // Exit cleanly without clearing screen (let Ink handle cleanup)
-            process.exit(0);
-        }
-        // Note: Ctrl+L refresh removed to fix scroll-to-top issue
-        // Direct ANSI escapes bypass Ink's rendering and cause scrolling problems
-        // Dispatch to all registered handlers
-        for (const entry of registry) {
-            const { keys, handler } = entry;
-            for (const binding of keys) {
-                const lowerBinding = binding.toLowerCase();
-                // Handle special keys
-                const isMatch = (lowerBinding === 'escape' && key.escape) ||
-                    ((lowerBinding === 'return' || lowerBinding === 'enter') &&
-                        key.return) ||
-                    (lowerBinding === 'backspace' && key.backspace) ||
-                    (lowerBinding === 'tab' && key.tab) ||
-                    (lowerBinding === 'up' && key.upArrow) ||
-                    (lowerBinding === 'down' && key.downArrow) ||
-                    (lowerBinding === 'left' && key.leftArrow) ||
-                    (lowerBinding === 'right' && key.rightArrow) ||
-                    (lowerBinding === 'pageup' && key.pageUp) ||
-                    (lowerBinding === 'pagedown' && key.pageDown) ||
-                    // Handle combinations
-                    (() => {
-                        const parts = lowerBinding.split('+');
-                        const hasCtrl = parts.includes('ctrl');
-                        const hasMeta = parts.includes('meta') || parts.includes('alt');
-                        const hasShift = parts.includes('shift');
-                        const mainKey = parts[parts.length - 1];
-                        const uppercaseShiftInput = input.length === 1 &&
-                            input === input.toUpperCase() &&
-                            input.toLowerCase() === mainKey;
-                        if (hasCtrl && !key.ctrl)
-                            return false;
-                        if (hasMeta && !key.meta)
-                            return false;
-                        if (hasShift && !key.shift && !uppercaseShiftInput)
-                            return false;
-                        // Block lowercase-only bindings when shift is active or the input is
-                        // an uppercase letter (which implies Shift was held).
-                        // Example: the 'p' (Plugins) binding must not fire when the user
-                        // presses Shift+P, which should only trigger 'shift+p' (Playlists).
-                        // Note: `input !== input.toLowerCase()` is true only for uppercase
-                        // alphabetical characters, avoiding false positives on symbols/digits.
-                        if (!hasShift &&
-                            (key.shift ||
-                                (input.length === 1 && input !== input.toLowerCase())))
-                            return false;
-                        // Check the actual key
-                        if (mainKey === 'up' && key.upArrow)
-                            return true;
-                        if (mainKey === 'down' && key.downArrow)
-                            return true;
-                        if (mainKey === 'left' && key.leftArrow)
-                            return true;
-                        if (mainKey === 'right' && key.rightArrow)
-                            return true;
-                        // Handle '=' and '+' specially (+ is shift+=)
-                        if (mainKey === '=' && input === '=')
-                            return true;
-                        if (mainKey === '+' && input === '+')
-                            return true;
-                        if (mainKey === '+' && key.shift && input === '=')
-                            return true; // shift+= produces '+'
-                        return input.toLowerCase() === mainKey && !key.ctrl && !key.meta;
-                    })();
-                if (isMatch) {
-                    handler();
-                    // We don't break here because multiple handlers might want to react
-                    // but usually only one does.
-                }
-            }
-        }
-    });
-    return null;
-}

package/dist/source/hooks/useKeyboardBlocker.js

@@ -1,45 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
-const KeyboardBlockContext = createContext(null);
-export function KeyboardBlockProvider({ children }) {
-    const [blockCount, setBlockCount] = useState(0);
-    const increment = useCallback(() => {
-        setBlockCount(prev => prev + 1);
-    }, []);
-    const decrement = useCallback(() => {
-        setBlockCount(prev => Math.max(0, prev - 1));
-    }, []);
-    const value = useMemo(() => ({ blockCount, increment, decrement }), [blockCount, increment, decrement]);
-    return (_jsx(KeyboardBlockContext.Provider, { value: value, children: children }));
-}
-export function useKeyboardBlockContext() {
-    const context = useContext(KeyboardBlockContext);
-    if (!context) {
-        throw new Error('useKeyboardBlockContext must be used within KeyboardBlockProvider');
-    }
-    return context;
-}
-export function useKeyboardBlocker(shouldBlock) {
-    const { increment, decrement } = useKeyboardBlockContext();
-    const blockedRef = useRef(false);
-    useEffect(() => {
-        if (shouldBlock && !blockedRef.current) {
-            increment();
-            blockedRef.current = true;
-        }
-        else if (!shouldBlock && blockedRef.current) {
-            decrement();
-            blockedRef.current = false;
-        }
-        return () => {
-            if (blockedRef.current) {
-                decrement();
-                blockedRef.current = false;
-            }
-        };
-    }, [shouldBlock, increment, decrement]);
-}
-export function useIsKeyboardBlocked() {
-    const { blockCount } = useKeyboardBlockContext();
-    return blockCount > 0;
-}

package/dist/source/hooks/useNavigation.js

@@ -1,5 +0,0 @@
-// Navigation hook
-import { useNavigation as useNavigationStore } from "../stores/navigation.store.js";
-export function useNavigation() {
-    return useNavigationStore();
-}

package/dist/source/hooks/usePlayer.js

@@ -1,43 +0,0 @@
-// Player hook - audio playback orchestration
-import { useCallback } from 'react';
-import { usePlayer as usePlayerStore } from "../stores/player.store.js";
-import { getConfigService } from "../services/config/config.service.js";
-export function usePlayer() {
-    const { state, dispatch, ...playerStore } = usePlayerStore();
-    const play = useCallback((track, options) => {
-        if (options?.clearQueue) {
-            // When clearing the queue, always dispatch fresh play commands rather
-            // than relying on the stale queue state captured in this closure.
-            // This fixes a bug where a track already in the queue wouldn't replay
-            // after clearQueue because SET_QUEUE_POSITION would be dispatched
-            // against the (now-empty) queue.
-            dispatch({ category: 'CLEAR_QUEUE' });
-            dispatch({ category: 'ADD_TO_QUEUE', track });
-            dispatch({ category: 'PLAY', track });
-        }
-        else {
-            // Add to queue if not already there
-            const isInQueue = state.queue.some(t => t.videoId === track.videoId);
-            if (!isInQueue) {
-                dispatch({ category: 'ADD_TO_QUEUE', track });
-            }
-            // Find position and play
-            const position = state.queue.findIndex(t => t.videoId === track.videoId);
-            if (position >= 0) {
-                dispatch({ category: 'SET_QUEUE_POSITION', position });
-            }
-            else {
-                dispatch({ category: 'PLAY', track });
-            }
-        }
-        // Add to history
-        const config = getConfigService();
-        config.addToHistory(track.videoId);
-    }, [state.queue, dispatch]);
-    return {
-        ...playerStore,
-        state,
-        dispatch,
-        play,
-    };
-}

package/dist/source/hooks/usePlaylist.js

@@ -1,65 +0,0 @@
-// Playlist management hook
-import { getConfigService } from "../services/config/config.service.js";
-import { useState, useCallback, useEffect } from 'react';
-export function usePlaylist() {
-    const [playlists, setPlaylists] = useState([]);
-    const configService = getConfigService();
-    useEffect(() => {
-        setPlaylists(configService.get('playlists'));
-    }, []);
-    const createPlaylist = useCallback((name, tracks = []) => {
-        const newPlaylist = {
-            playlistId: Date.now().toString(),
-            name,
-            tracks: tracks.map(track => ({ ...track })),
-        };
-        const updatedPlaylists = [...playlists, newPlaylist];
-        setPlaylists(updatedPlaylists);
-        configService.set('playlists', updatedPlaylists);
-        return newPlaylist;
-    }, [playlists, configService]);
-    const deletePlaylist = useCallback((playlistId) => {
-        const updatedPlaylists = playlists.filter(p => p.playlistId !== playlistId);
-        setPlaylists(updatedPlaylists);
-        configService.set('playlists', updatedPlaylists);
-    }, [playlists, configService]);
-    const addTrackToPlaylist = useCallback((playlistId, track, force = false) => {
-        const playlistIndex = playlists.findIndex(p => p.playlistId === playlistId);
-        if (playlistIndex === -1)
-            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 renamePlaylist = useCallback((playlistId, newName) => {
-        const updatedPlaylists = playlists.map(playlist => playlist.playlistId === playlistId
-            ? { ...playlist, name: newName }
-            : playlist);
-        setPlaylists(updatedPlaylists);
-        configService.set('playlists', updatedPlaylists);
-    }, [playlists, configService]);
-    const removeTrackFromPlaylist = useCallback((playlistId, trackIndex) => {
-        const playlistIndex = playlists.findIndex(p => p.playlistId === playlistId);
-        if (playlistIndex === -1)
-            return;
-        const updatedPlaylists = [...playlists];
-        updatedPlaylists[playlistIndex].tracks.splice(trackIndex, 1);
-        setPlaylists(updatedPlaylists);
-        configService.set('playlists', updatedPlaylists);
-    }, [playlists, configService]);
-    return {
-        playlists,
-        createPlaylist,
-        deletePlaylist,
-        renamePlaylist,
-        addTrackToPlaylist,
-        removeTrackFromPlaylist,
-    };
-}

package/dist/source/hooks/useSearch.js

@@ -1,76 +0,0 @@
-// Search hook
-import { getSearchService } from "../services/youtube-music/search.service.js";
-import { useState, useCallback } from 'react';
-export function useSearch() {
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const searchService = getSearchService();
-    const searchSongs = useCallback(async (query) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const results = await searchService.searchSongs(query);
-            return results;
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Search failed');
-            return [];
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [searchService]);
-    const searchAlbums = useCallback(async (query) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const results = await searchService.searchAlbums(query);
-            return results;
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Search failed');
-            return [];
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [searchService]);
-    const searchArtists = useCallback(async (query) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const results = await searchService.searchArtists(query);
-            return results;
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Search failed');
-            return [];
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [searchService]);
-    const searchPlaylists = useCallback(async (query) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const results = await searchService.searchPlaylists(query);
-            return results;
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Search failed');
-            return [];
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [searchService]);
-    return {
-        isLoading,
-        error,
-        searchSongs,
-        searchAlbums,
-        searchArtists,
-        searchPlaylists,
-    };
-}

package/dist/source/hooks/useSleepTimer.js

@@ -1,48 +0,0 @@
-// 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/hooks/useTerminalSize.js

@@ -1,24 +0,0 @@
-import { useState, useEffect } from 'react';
-import { useStdout } from 'ink';
-export function useTerminalSize() {
-    const { stdout } = useStdout();
-    const [size, setSize] = useState({
-        columns: stdout?.columns || 80,
-        rows: stdout?.rows || 24,
-    });
-    useEffect(() => {
-        if (!stdout)
-            return;
-        const onResize = () => {
-            setSize({
-                columns: stdout.columns,
-                rows: stdout.rows,
-            });
-        };
-        stdout.on('resize', onResize);
-        return () => {
-            stdout.off('resize', onResize);
-        };
-    }, [stdout]);
-    return size;
-}

package/dist/source/hooks/useTheme.js

@@ -1,5 +0,0 @@
-// Theme management hook
-import { useTheme as useThemeContext } from "../contexts/theme.context.js";
-export function useTheme() {
-    return useThemeContext();
-}

package/dist/source/hooks/useYouTubeMusic.js

@@ -1,112 +0,0 @@
-import { getMusicService } from "../services/youtube-music/api.js";
-import { useState, useCallback } from 'react';
-export function useYouTubeMusic() {
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const musicService = getMusicService();
-    const search = useCallback(async (query, options = {}) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const response = await musicService.search(query, options);
-            return response;
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Search failed');
-            return null;
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [musicService]);
-    const getTrack = useCallback(async (videoId) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const track = await musicService.getTrack(videoId);
-            return track;
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Failed to get track');
-            return null;
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [musicService]);
-    const getAlbum = useCallback(async (albumId) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const album = await musicService.getAlbum(albumId);
-            return album;
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Failed to get album');
-            return null;
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [musicService]);
-    const getArtist = useCallback(async (artistId) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const artist = await musicService.getArtist(artistId);
-            return artist;
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Failed to get artist');
-            return null;
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [musicService]);
-    const getPlaylist = useCallback(async (playlistId) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const playlist = await musicService.getPlaylist(playlistId);
-            return playlist;
-        }
-        catch (err) {
-            setError(err instanceof Error ? err.message : 'Failed to get playlist');
-            return null;
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [musicService]);
-    const getSuggestions = useCallback(async (trackId) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const suggestions = await musicService.getSuggestions(trackId);
-            return suggestions;
-        }
-        catch (err) {
-            // Suppress YouTubeJS parsing errors (library limitation with YouTube's changing API)
-            // These are not user-actionable and create noise in the UI
-            const errorMessage = err instanceof Error ? err.message : 'Failed to get suggestions';
-            if (!errorMessage.includes('ParsingError')) {
-                setError(errorMessage);
-            }
-            return [];
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [musicService]);
-    return {
-        isLoading,
-        error,
-        search,
-        getTrack,
-        getAlbum,
-        getArtist,
-        getPlaylist,
-        getSuggestions,
-    };
-}