@involvex/youtube-music-cli 0.0.36 → 0.0.37

package/CHANGELOG.md

@@ -1,3 +1,5 @@
+## [0.0.37](https://github.com/involvex/youtube-music-cli/compare/v0.0.36...v0.0.37) (2026-02-22)
+
 ## [0.0.36](https://github.com/involvex/youtube-music-cli/compare/v0.0.35...v0.0.36) (2026-02-22)
 
 ### Features

package/dist/source/components/layouts/MainLayout.js

@@ -124,7 +124,7 @@ function MainLayout() {
         dispatch({ category: 'TOGGLE_PLAYER_MODE' });
     }, [dispatch]);
     // Global keyboard bindings
-    useKeyBinding(KEYBINDINGS.QUIT, handleQuit);
+    useKeyBinding(KEYBINDINGS.QUIT, handleQuit, { bypassBlock: true });
     useKeyBinding(KEYBINDINGS.SEARCH, goToSearch);
     useKeyBinding(KEYBINDINGS.PLAYLISTS, goToPlaylists);
     useKeyBinding(KEYBINDINGS.PLUGINS, goToPlugins);

package/dist/source/components/search/SearchBar.js

@@ -46,7 +46,7 @@ function SearchBar({ onInput, isActive = true }) {
         }
     }, [isActive, onInput]);
     useKeyBinding(['tab'], cycleType);
-    useKeyBinding(['escape'], clearSearch);
+    useKeyBinding(['escape'], clearSearch, { bypassBlock: true });
     useKeyboardBlocker(isActive);
     return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: theme.colors.secondary, paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.colors.dim, children: "Type: " }), searchTypes.map((type, index) => (_jsxs(Text, { color: navState.searchType === type
                             ? theme.colors.primary

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

@@ -3,7 +3,9 @@
  * 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 declare function useKeyBinding(keys: readonly string[], handler: () => void): void;
+export declare function useKeyBinding(keys: readonly string[], handler: () => void, options?: {
+    bypassBlock?: boolean;
+}): void;
 /**
  * Global Keyboard Manager Component
  * This should be rendered once at the root of the app.

package/dist/source/hooks/useKeyboard.js

@@ -10,16 +10,20 @@ const registry = new Set();
  * 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) {
+export function useKeyBinding(keys, handler, options) {
     const handlerRef = useRef(handler);
     handlerRef.current = handler;
     useEffect(() => {
-        const entry = { keys, handler: () => handlerRef.current() };
+        const entry = {
+            keys,
+            handler: () => handlerRef.current(),
+            bypassBlock: options?.bypassBlock,
+        };
         registry.add(entry);
         return () => {
             registry.delete(entry);
         };
-    }, [keys]); // keys is the only dep; handlerRef is a stable ref
+    }, [keys, options?.bypassBlock]); // keys and bypassBlock are deps; handlerRef is a stable ref
 }
 /**
  * Global Keyboard Manager Component
@@ -30,7 +34,65 @@ export function KeyboardManager() {
     useInput((input, key) => {
         if (blockCount > 0) {
             // When keyboard input is blocked (e.g., within a focused text input),
-            // we deliberately skip executing global shortcuts.
+            // 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)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@involvex/youtube-music-cli",
-	"version": "0.0.36",
+	"version": "0.0.37",
 	"description": "- A Commandline music player for youtube-music",
 	"repository": {
 		"type": "git",