@ciphore/radiocli 0.1.0

package/dist/ui/use-app-input.js

@@ -0,0 +1,387 @@
+import { useEffect } from 'react';
+import { useInput } from 'ink';
+import { homeItems, settingsItems } from './screen-items.js';
+import { applyTextInput, clamp, favoriteTarget, isEditableInput, isPlainPrintableInput, mediaTransportActionForInput } from './app-state.js';
+import { parseSgrMouseEvents, primaryMousePress } from './terminal-mouse.js';
+export function useAppInput({ adjustVolume, beginLearningTransportKey, capturingTransportAction, commandMode, commandText, currentItemCount, cycleDisplayColor, cyclePlaybackBackend, cycleReceiverStyle, cycleSleepTimer, editingCountryFilter, editingSearch, executeCommand, filteredCountries, go, lastRawTransportAtRef, lastSubmittedSearchRef, loadCountry, openAdjacentTab, openScreen, playAdjacent, playStation, player, playingStation, moveExploreCursor, moveExploreCursorToCell, refreshProviderHealth, resetLearnedTransportKeys, runSearch, saveLearnedTransportKey, screen, searchQuery, selected, selectedStation, setCapturingTransportAction, setCommandMode, setCommandText, setCountryFilter, setEditingCountryFilter, setEditingSearch, setMessage, setSearchQuery, setSelected, setShowDiagnostics, settingsRef, shutdown, stdin, toggleFavorite, toggleMute, toggleNearbyLocation, toggleRadioGarden, toggleSkipBrokenStreams }) {
+    useEffect(() => {
+        const onData = (data) => {
+            const rawInput = String(data);
+            if (capturingTransportAction) {
+                if (rawInput === '\u001B') {
+                    setCapturingTransportAction(null);
+                    setMessage('Media key learning canceled.');
+                    return;
+                }
+                if (rawInput === '\u0003' || rawInput.length === 0) {
+                    return;
+                }
+                saveLearnedTransportKey(capturingTransportAction, rawInput);
+                return;
+            }
+            const mouseEvents = parseSgrMouseEvents(rawInput);
+            if (mouseEvents.length > 0) {
+                const click = primaryMousePress(mouseEvents);
+                lastRawTransportAtRef.current = Date.now();
+                if (!commandMode && screen === 'explore' && click) {
+                    moveExploreCursorToCell(click.x, click.y);
+                }
+                return;
+            }
+            const action = mediaTransportActionForInput(rawInput, settingsRef.current.mediaKeys);
+            if (isPlainPrintableInput(rawInput) &&
+                (commandMode || (screen === 'search' && editingSearch) || ((screen === 'countries' || screen === 'map') && editingCountryFilter))) {
+                return;
+            }
+            if (action === 'previous') {
+                lastRawTransportAtRef.current = Date.now();
+                playAdjacent(-1);
+            }
+            else if (action === 'next') {
+                lastRawTransportAtRef.current = Date.now();
+                playAdjacent(1);
+            }
+            else if (action === 'playPause') {
+                lastRawTransportAtRef.current = Date.now();
+                void player.togglePause();
+            }
+        };
+        stdin.on('data', onData);
+        return () => {
+            stdin.off('data', onData);
+        };
+    }, [
+        capturingTransportAction,
+        commandMode,
+        editingCountryFilter,
+        editingSearch,
+        lastRawTransportAtRef,
+        playAdjacent,
+        player,
+        moveExploreCursorToCell,
+        saveLearnedTransportKey,
+        screen,
+        setCapturingTransportAction,
+        setMessage,
+        settingsRef,
+        stdin
+    ]);
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            shutdown();
+            return;
+        }
+        if (capturingTransportAction) {
+            return;
+        }
+        if (Date.now() - lastRawTransportAtRef.current < 50) {
+            return;
+        }
+        if (commandMode) {
+            if (key.return) {
+                void executeCommand(commandText);
+                setCommandText('');
+                setCommandMode(false);
+                return;
+            }
+            if (key.escape) {
+                setCommandText('');
+                setCommandMode(false);
+                return;
+            }
+            if (isEditableInput(input, key)) {
+                setCommandText(value => applyTextInput(value, input, key));
+            }
+            return;
+        }
+        if (key.shift && key.leftArrow) {
+            playAdjacent(-1);
+            return;
+        }
+        if (key.shift && key.rightArrow) {
+            playAdjacent(1);
+            return;
+        }
+        if (key.tab) {
+            openAdjacentTab(key.shift ? -1 : 1);
+            return;
+        }
+        if (key.rightArrow) {
+            openAdjacentTab(1);
+            return;
+        }
+        if (key.leftArrow) {
+            openAdjacentTab(-1);
+            return;
+        }
+        if (screen === 'search' && editingSearch) {
+            if (key.return) {
+                if (searchQuery.trim() && searchQuery.trim() === lastSubmittedSearchRef.current && selectedStation) {
+                    void playStation(selectedStation);
+                }
+                else {
+                    void runSearch();
+                }
+                return;
+            }
+            if (key.escape) {
+                setEditingSearch(false);
+                return;
+            }
+            if (isEditableInput(input, key)) {
+                setSearchQuery(value => applyTextInput(value, input, key));
+                setEditingSearch(true);
+                return;
+            }
+        }
+        if ((screen === 'countries' || screen === 'map') && editingCountryFilter) {
+            if (key.return || key.escape) {
+                setEditingCountryFilter(false);
+                setSelected(0);
+                return;
+            }
+            if (isEditableInput(input, key)) {
+                setCountryFilter(value => applyTextInput(value, input, key));
+            }
+            return;
+        }
+        if (screen === 'explore') {
+            const exploreMove = exploreMoveForInput(input);
+            if (exploreMove) {
+                moveExploreCursor(exploreMove.direction, exploreMove.fast);
+                return;
+            }
+        }
+        if (input === 'q') {
+            shutdown();
+            return;
+        }
+        if (input.startsWith(':')) {
+            const seed = input.slice(1).replace(/[\r\n]+$/g, '');
+            if (/[\r\n]/.test(input)) {
+                void executeCommand(seed);
+            }
+            else {
+                setCommandMode(true);
+                setCommandText(seed);
+            }
+            return;
+        }
+        if (input === '+' || input === '=') {
+            adjustVolume(5);
+            return;
+        }
+        if (input === '-') {
+            adjustVolume(-5);
+            return;
+        }
+        if (input === 'm') {
+            toggleMute();
+            return;
+        }
+        if (input === ',' || input === '<') {
+            playAdjacent(-1);
+            return;
+        }
+        if (input === '.' || input === '>') {
+            playAdjacent(1);
+            return;
+        }
+        if (input === 't') {
+            cycleDisplayColor();
+            return;
+        }
+        if (input === 'v') {
+            cycleReceiverStyle();
+            return;
+        }
+        if (input === 'o') {
+            cyclePlaybackBackend();
+            return;
+        }
+        if (input === 'g') {
+            toggleRadioGarden();
+            return;
+        }
+        if (input === 'l') {
+            toggleNearbyLocation();
+            return;
+        }
+        if (input === 'x') {
+            toggleSkipBrokenStreams();
+            return;
+        }
+        if (input === 'r') {
+            refreshProviderHealth();
+            setMessage('Provider health refreshed.');
+            return;
+        }
+        if (input === 's' && screen === 'now-playing') {
+            cycleSleepTimer();
+            return;
+        }
+        if (input === 'd' && screen === 'now-playing') {
+            setShowDiagnostics(value => !value);
+            return;
+        }
+        if (input === ']') {
+            setSelected(value => clamp(value + 10, currentItemCount(screen) - 1));
+            return;
+        }
+        if (input === '[') {
+            setSelected(value => clamp(value - 10, currentItemCount(screen) - 1));
+            return;
+        }
+        if (screen === 'home' && (/^[1-9]$/.test(input) || input === '0')) {
+            const menuIndex = input === '0' ? 9 : Number(input) - 1;
+            setSelected(menuIndex);
+            const target = homeItems[menuIndex]?.screen;
+            if (target) {
+                openScreen(target);
+            }
+            return;
+        }
+        if (input === 'b' || key.escape) {
+            go('home');
+            return;
+        }
+        if (input === '/') {
+            if (screen === 'search') {
+                setEditingSearch(true);
+            }
+            if (screen === 'countries' || screen === 'map') {
+                setEditingCountryFilter(true);
+            }
+            return;
+        }
+        if (input === 'w' && screen === 'countries') {
+            go('map');
+            return;
+        }
+        if (input === 'w' && screen === 'map') {
+            go('countries');
+            return;
+        }
+        if (input === 'f') {
+            toggleFavorite(favoriteTarget(screen, selectedStation, playingStation));
+            return;
+        }
+        if (input === ' ') {
+            void player.togglePause();
+            return;
+        }
+        if (input === 'n' && screen === 'now-playing') {
+            playAdjacent(1);
+            return;
+        }
+        if (input === 'p' && screen === 'now-playing') {
+            playAdjacent(-1);
+            return;
+        }
+        if (input === 'n') {
+            setSelected(value => clamp(value + 1, currentItemCount(screen) - 1));
+            return;
+        }
+        if (input === 'p') {
+            setSelected(value => clamp(value - 1, currentItemCount(screen) - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setSelected(value => clamp(value + 1, currentItemCount(screen) - 1));
+            return;
+        }
+        if (key.upArrow) {
+            setSelected(value => clamp(value - 1, currentItemCount(screen) - 1));
+            return;
+        }
+        if (key.return) {
+            if (screen === 'home') {
+                const target = homeItems[selected]?.screen;
+                if (target) {
+                    openScreen(target);
+                }
+                return;
+            }
+            if (screen === 'countries') {
+                const country = filteredCountries[selected];
+                if (country) {
+                    void loadCountry(country);
+                }
+                return;
+            }
+            if (screen === 'settings') {
+                const item = settingsItems[selected];
+                if (item === 'Cycle display color') {
+                    cycleDisplayColor();
+                }
+                else if (item === 'Toggle Radio Garden experimental adapter') {
+                    toggleRadioGarden();
+                }
+                else if (item === 'Cycle receiver style') {
+                    cycleReceiverStyle();
+                }
+                else if (item === 'Toggle nearby location lookup') {
+                    toggleNearbyLocation();
+                }
+                else if (item === 'Cycle playback backend') {
+                    cyclePlaybackBackend();
+                }
+                else if (item === 'Volume up') {
+                    adjustVolume(5);
+                }
+                else if (item === 'Volume down') {
+                    adjustVolume(-5);
+                }
+                else if (item === 'Mute or unmute') {
+                    toggleMute();
+                }
+                else if (item === 'Toggle skip broken streams') {
+                    toggleSkipBrokenStreams();
+                }
+                else if (item === 'Refresh provider health') {
+                    refreshProviderHealth();
+                    setMessage('Provider health refreshed.');
+                }
+                else if (item === 'Learn previous media key') {
+                    beginLearningTransportKey('previous');
+                }
+                else if (item === 'Learn play/pause media key') {
+                    beginLearningTransportKey('playPause');
+                }
+                else if (item === 'Learn next media key') {
+                    beginLearningTransportKey('next');
+                }
+                else if (item === 'Reset learned media keys') {
+                    resetLearnedTransportKeys();
+                }
+                return;
+            }
+            if (screen === 'map') {
+                const country = filteredCountries[selected];
+                if (country) {
+                    void loadCountry(country);
+                }
+                return;
+            }
+            if (selectedStation) {
+                void playStation(selectedStation);
+            }
+        }
+    });
+}
+function exploreMoveForInput(input) {
+    const normalized = input.toLowerCase();
+    if (normalized === 'w') {
+        return { direction: 'up', fast: input === 'W' };
+    }
+    if (normalized === 's') {
+        return { direction: 'down', fast: input === 'S' };
+    }
+    if (normalized === 'a') {
+        return { direction: 'left', fast: input === 'A' };
+    }
+    if (normalized === 'd') {
+        return { direction: 'right', fast: input === 'D' };
+    }
+    return null;
+}

package/dist/ui/use-command-executor.js

@@ -0,0 +1,156 @@
+import { useCallback } from 'react';
+import { favoriteTarget, normalizeMediaKeyBindings, parseMediaActionName } from './app-state.js';
+export function useCommandExecutor({ beginLearningTransportKey, countries, go, loadCountry, openLibrary, player, playingStation, providers, resetLearnedTransportKeys, runSearch, screen, selectedStation, setCountries, setFilters, setLibrary, setMessage, setSearchQuery, setSleepUntil, setVolume, settingsRef, store, toggleFavorite, toggleMute, updateSettings }) {
+    return useCallback(async (rawCommand) => {
+        const trimmed = rawCommand.trim();
+        if (!trimmed) {
+            return;
+        }
+        const [name = '', ...rest] = trimmed.split(/\s+/);
+        const value = rest.join(' ');
+        if (name === 'search' || name === 's') {
+            setSearchQuery(value);
+            go('search');
+            await runSearch(value);
+            return;
+        }
+        if (name === 'country' || name === 'c') {
+            if (!value.trim()) {
+                setMessage('Usage: :country <name or code>');
+                return;
+            }
+            const availableCountries = countries.length > 0 ? countries : await providers.countries();
+            if (countries.length === 0) {
+                setCountries(availableCountries);
+            }
+            const match = availableCountries.find(country => `${country.code} ${country.name}`.toLowerCase().includes(value.toLowerCase()));
+            if (!match) {
+                setMessage(`Country not found: ${value}`);
+                return;
+            }
+            await loadCountry(match);
+            return;
+        }
+        if (name === 'codec') {
+            setFilters(current => ({ ...current, codec: value && value !== 'any' ? value.toUpperCase() : null }));
+            return;
+        }
+        if (name === 'language' || name === 'lang') {
+            setFilters(current => ({ ...current, language: value && value !== 'any' ? value : null }));
+            return;
+        }
+        if (name === 'bitrate') {
+            const bitrate = Number(value);
+            setFilters(current => ({ ...current, minBitrate: Number.isFinite(bitrate) && bitrate > 0 ? bitrate : null }));
+            return;
+        }
+        if (name === 'clear') {
+            setFilters({ codec: null, language: null, minBitrate: null });
+            setMessage('Filters cleared.');
+            return;
+        }
+        if (name === 'vol' || name === 'volume') {
+            const volume = Number(value);
+            if (Number.isFinite(volume)) {
+                setVolume(volume);
+            }
+            return;
+        }
+        if (name === 'mute') {
+            toggleMute();
+            return;
+        }
+        if (name === 'location') {
+            const enabled = value === 'on' || value === 'true' || value === '1';
+            updateSettings({ enableNearbyLocation: enabled });
+            setMessage(`Nearby location lookup ${enabled ? 'enabled' : 'disabled'}.`);
+            return;
+        }
+        if (name === 'timeout') {
+            const seconds = Number(value);
+            if (Number.isFinite(seconds)) {
+                updateSettings({ tuneTimeoutSeconds: Math.min(45, Math.max(3, seconds)) });
+            }
+            return;
+        }
+        if (name === 'skip') {
+            const enabled = value !== 'off' && value !== 'false' && value !== '0';
+            updateSettings({ skipBrokenStreams: enabled });
+            return;
+        }
+        if (name === 'learn' || name === 'bind' || name === 'key') {
+            const action = parseMediaActionName(value);
+            if (!action) {
+                setMessage('Usage: :learn previous, :learn play, or :learn next');
+                return;
+            }
+            beginLearningTransportKey(action);
+            return;
+        }
+        if (name === 'keys') {
+            if (value === 'reset' || value === 'clear') {
+                resetLearnedTransportKeys();
+                return;
+            }
+            const mediaKeys = normalizeMediaKeyBindings(settingsRef.current.mediaKeys);
+            setMessage(`Learned keys: prev ${mediaKeys.previous.length}, play ${mediaKeys.playPause.length}, next ${mediaKeys.next.length}. Use :keys reset to clear.`);
+            return;
+        }
+        if (name === 'sleep') {
+            const minutes = Number(value);
+            setSleepUntil(Number.isFinite(minutes) && minutes > 0 ? Date.now() + minutes * 60_000 : null);
+            return;
+        }
+        if (name === 'map') {
+            go('map');
+            return;
+        }
+        if (name === 'stats') {
+            go('stats');
+            return;
+        }
+        if (name === 'library' || name === 'recent' || name === 'favorites' || name === 'imports') {
+            openLibrary();
+            return;
+        }
+        if (name === 'favorite' || name === 'fav') {
+            toggleFavorite(favoriteTarget(screen, selectedStation, playingStation));
+            return;
+        }
+        if (name === 'settings') {
+            go('settings');
+            return;
+        }
+        if (name === 'stop') {
+            setLibrary(store.finishActiveListeningSession());
+            await player.stop();
+            return;
+        }
+        setMessage(`Unknown command: ${name}`);
+    }, [
+        beginLearningTransportKey,
+        countries,
+        go,
+        loadCountry,
+        openLibrary,
+        player,
+        playingStation,
+        providers,
+        resetLearnedTransportKeys,
+        runSearch,
+        screen,
+        selectedStation,
+        setCountries,
+        setFilters,
+        setLibrary,
+        setMessage,
+        setSearchQuery,
+        setSleepUntil,
+        setVolume,
+        settingsRef,
+        store,
+        toggleFavorite,
+        toggleMute,
+        updateSettings
+    ]);
+}