morille 0.1.0

package/dist/hooks/use-playback.js

@@ -0,0 +1,282 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { POLL_INTERVAL_MS, SEEK_STEP_MS, TICK_INTERVAL_MS, VOLUME_STEP } from '../config.js';
+import { getCurrentTrackInfo, playUri, seek, setRepeat, setShuffle, setVolume, skipNext as skipNextTrack, skipPrevious as skipPreviousTrack, togglePlayback, } from '../spotify/playback.js';
+const NEXT_REPEAT = {
+    off: 'context',
+    context: 'track',
+    track: 'off',
+};
+/**
+ * React hook that manages Spotify playback state. Polls the current track
+ * at a regular interval and exposes toggle/refresh controls.
+ * @param client - Authenticated Spotify API client
+ * @returns Playback state, loading/error indicators, and control functions
+ */
+export function usePlayback(client) {
+    const [track, setTrack] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    // Wall clock timestamp when we last received progress from the API
+    const syncRef = useRef(null);
+    const refresh = useCallback(async () => {
+        try {
+            const info = await getCurrentTrackInfo(client);
+            if (info) {
+                syncRef.current = {
+                    progressMs: info.progressMs,
+                    timestamp: Date.now(),
+                };
+            }
+            setTrack(info);
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to fetch playback state');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [
+        client,
+    ]);
+    const toggle = useCallback(async () => {
+        const prevTrack = track;
+        try {
+            if (track) {
+                setTrack({
+                    ...track,
+                    isPlaying: !track.isPlaying,
+                });
+            }
+            await togglePlayback(client);
+            await refresh();
+        }
+        catch (err) {
+            setTrack(prevTrack);
+            setError(err instanceof Error ? err.message : 'Failed to toggle playback');
+        }
+    }, [
+        client,
+        track,
+        refresh,
+    ]);
+    const next = useCallback(async () => {
+        const deviceId = track?.deviceId;
+        if (!deviceId) {
+            setError('No active device found.');
+            return;
+        }
+        try {
+            setIsLoading(true);
+            await skipNextTrack(client, deviceId);
+            await refresh();
+        }
+        catch (err) {
+            setIsLoading(false);
+            setError(err instanceof Error ? err.message : 'Failed to skip to next track');
+        }
+    }, [
+        client,
+        track,
+        refresh,
+    ]);
+    const previous = useCallback(async () => {
+        const deviceId = track?.deviceId;
+        if (!deviceId) {
+            setError('No active device found.');
+            return;
+        }
+        try {
+            setIsLoading(true);
+            await skipPreviousTrack(client, deviceId);
+            await refresh();
+        }
+        catch (err) {
+            setIsLoading(false);
+            setError(err instanceof Error ? err.message : 'Failed to skip to previous track');
+        }
+    }, [
+        client,
+        track,
+        refresh,
+    ]);
+    const seekForward = useCallback(async () => {
+        if (!track)
+            return;
+        const newProgress = Math.min(track.progressMs + SEEK_STEP_MS, track.durationMs);
+        syncRef.current = {
+            progressMs: newProgress,
+            timestamp: Date.now(),
+        };
+        setTrack({
+            ...track,
+            progressMs: newProgress,
+        });
+        try {
+            await seek(client, newProgress, track.deviceId ?? undefined);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to seek');
+        }
+    }, [
+        client,
+        track,
+    ]);
+    const seekBackward = useCallback(async () => {
+        if (!track)
+            return;
+        const newProgress = Math.max(track.progressMs - SEEK_STEP_MS, 0);
+        syncRef.current = {
+            progressMs: newProgress,
+            timestamp: Date.now(),
+        };
+        setTrack({
+            ...track,
+            progressMs: newProgress,
+        });
+        try {
+            await seek(client, newProgress, track.deviceId ?? undefined);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to seek');
+        }
+    }, [
+        client,
+        track,
+    ]);
+    const volumeUp = useCallback(async () => {
+        if (!track || track.volume == null)
+            return;
+        const newVolume = Math.min(track.volume + VOLUME_STEP, 100);
+        setTrack({
+            ...track,
+            volume: newVolume,
+        });
+        try {
+            await setVolume(client, newVolume, track.deviceId ?? undefined);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to set volume');
+        }
+    }, [
+        client,
+        track,
+    ]);
+    const volumeDown = useCallback(async () => {
+        if (!track || track.volume == null)
+            return;
+        const newVolume = Math.max(track.volume - VOLUME_STEP, 0);
+        setTrack({
+            ...track,
+            volume: newVolume,
+        });
+        try {
+            await setVolume(client, newVolume, track.deviceId ?? undefined);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to set volume');
+        }
+    }, [
+        client,
+        track,
+    ]);
+    const toggleShuffleMode = useCallback(async () => {
+        if (!track)
+            return;
+        const newShuffle = !track.shuffle;
+        setTrack({
+            ...track,
+            shuffle: newShuffle,
+        });
+        try {
+            await setShuffle(client, newShuffle, track.deviceId ?? undefined);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to toggle shuffle');
+        }
+    }, [
+        client,
+        track,
+    ]);
+    const cycleRepeat = useCallback(async () => {
+        if (!track)
+            return;
+        const nextMode = NEXT_REPEAT[track.repeat];
+        setTrack({
+            ...track,
+            repeat: nextMode,
+        });
+        try {
+            await setRepeat(client, nextMode, track.deviceId ?? undefined);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to set repeat mode');
+        }
+    }, [
+        client,
+        track,
+    ]);
+    // Poll Spotify API for real state
+    useEffect(() => {
+        refresh();
+        const id = setInterval(refresh, POLL_INTERVAL_MS);
+        return () => clearInterval(id);
+    }, [
+        refresh,
+    ]);
+    // Locally interpolate progress using wall clock time while playing
+    const trackRef = useRef(track);
+    trackRef.current = track;
+    useEffect(() => {
+        if (!track?.isPlaying || !syncRef.current) {
+            return;
+        }
+        const id = setInterval(() => {
+            const current = trackRef.current;
+            const sync = syncRef.current;
+            if (current?.isPlaying && sync) {
+                const elapsed = Date.now() - sync.timestamp;
+                const progressMs = Math.min(sync.progressMs + elapsed, current.durationMs);
+                setTrack({
+                    ...current,
+                    progressMs,
+                });
+            }
+        }, TICK_INTERVAL_MS);
+        return () => clearInterval(id);
+    }, [
+        track?.isPlaying,
+    ]);
+    const playTrackUri = useCallback(async (uri) => {
+        const deviceId = track?.deviceId;
+        if (!deviceId)
+            return;
+        try {
+            await playUri(client, deviceId, uri);
+            await refresh();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to play track');
+        }
+    }, [
+        client,
+        track,
+        refresh,
+    ]);
+    return {
+        track,
+        isLoading,
+        error,
+        toggle,
+        next,
+        previous,
+        seekForward,
+        seekBackward,
+        volumeUp,
+        volumeDown,
+        toggleShuffleMode,
+        cycleRepeat,
+        playTrackUri,
+        refresh,
+    };
+}

package/dist/hooks/use-player-input.d.ts

@@ -0,0 +1,18 @@
+type PlaybackActions = {
+    toggle: () => void;
+    next: () => void;
+    previous: () => void;
+    seekForward: () => void;
+    seekBackward: () => void;
+    volumeUp: () => void;
+    volumeDown: () => void;
+    toggleShuffleMode: () => void;
+    cycleRepeat: () => void;
+};
+/**
+ * Handles all keyboard input for the player.
+ * Reads panel state from contexts for panel-specific keybindings.
+ * Disables shortcuts when a text input is active (isInputMode).
+ */
+export declare function usePlayerInput(playback: PlaybackActions): void;
+export {};

package/dist/hooks/use-player-input.js

@@ -0,0 +1,201 @@
+import { useApp, useInput } from 'ink';
+import { useLyricsContext } from '../contexts/lyrics-context.js';
+import { usePanelMode } from '../contexts/panel-mode-context.js';
+import { useQueueContext } from '../contexts/queue-context.js';
+import { useSearchContext } from '../contexts/search-context.js';
+/**
+ * Handles all keyboard input for the player.
+ * Reads panel state from contexts for panel-specific keybindings.
+ * Disables shortcuts when a text input is active (isInputMode).
+ */
+export function usePlayerInput(playback) {
+    const { exit } = useApp();
+    const { toggleLyrics, toggleQueue, toggleSearch, panelMode, isInputMode, setInputMode } = usePanelMode();
+    const { offsetUp, offsetDown, scrollUp, scrollDown, isPlainText } = useLyricsContext();
+    const { queueUp, queueDown, queueSelect, refresh: refreshQueue } = useQueueContext();
+    const { query, setQuery, navigateUp: searchUp, navigateDown: searchDown, navigateLeft: searchLeft, navigateRight: searchRight, select: searchSelect, goBack: searchGoBack, browseUserPlaylists, canGoBack: searchCanGoBack, } = useSearchContext();
+    const isQueueMode = panelMode === 'queue';
+    const isSearchMode = panelMode === 'search';
+    const isLyricsScrollMode = panelMode === 'lyrics' && isPlainText;
+    const handleSearchEscape = searchCanGoBack ? searchGoBack : toggleSearch;
+    const exitInputMode = () => {
+        if (query.trim().length > 0)
+            setInputMode(false);
+    };
+    // Text input handler for search mode
+    useInput((input, key) => {
+        if (key.escape) {
+            handleSearchEscape?.();
+            return;
+        }
+        if (key.return) {
+            exitInputMode();
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setQuery?.(query.slice(0, -1));
+            return;
+        }
+        if (key.tab) {
+            exitInputMode();
+            return;
+        }
+        // Accept printable characters
+        if (input && !key.ctrl && !key.meta) {
+            setQuery?.(query + input);
+        }
+    }, {
+        isActive: isInputMode,
+    });
+    // Each panel mode overrides keybindings to handle only its own actions.
+    // `q` (quit) is the one shortcut always available across modes.
+    const isLyricsMode = panelMode === 'lyrics';
+    const { actions, arrowActions } = buildBindings({
+        panelMode,
+        isLyricsScrollMode,
+        exit,
+        playback,
+        toggleLyrics,
+        toggleQueue,
+        toggleSearch,
+        browseUserPlaylists,
+        refreshQueue,
+        search: {
+            up: searchUp,
+            down: searchDown,
+            left: searchLeft,
+            right: searchRight,
+            select: searchSelect,
+        },
+        queue: {
+            up: queueUp,
+            down: queueDown,
+            select: queueSelect,
+        },
+        lyrics: {
+            offsetUp,
+            offsetDown,
+            scrollUp,
+            scrollDown,
+        },
+    });
+    const handlePanelEscape = () => {
+        if (isSearchMode) {
+            if (searchCanGoBack) {
+                searchGoBack?.();
+            }
+            else {
+                // Re-focus text input instead of closing the panel
+                setInputMode(true);
+            }
+            return;
+        }
+        if (isQueueMode) {
+            toggleQueue();
+            return;
+        }
+        if (isLyricsMode) {
+            toggleLyrics();
+        }
+    };
+    useInput((input, key) => {
+        if (key.escape && panelMode !== 'none') {
+            handlePanelEscape();
+            return;
+        }
+        const charAction = actions[input];
+        if (charAction) {
+            charAction();
+            return;
+        }
+        for (const [arrow, action] of Object.entries(arrowActions)) {
+            if (key[arrow] && action) {
+                action();
+                return;
+            }
+        }
+    }, {
+        isActive: !isInputMode,
+    });
+}
+/**
+ * Builds the keyboard bindings for the current panel mode.
+ * Each mode is isolated: only its own panel actions are bound (plus the global `q` quit).
+ * Playback shortcuts (space, n, p, s, r, seek, volume) are only active when no panel is open.
+ */
+function buildBindings(params) {
+    const { panelMode, isLyricsScrollMode, exit, playback, search, queue, lyrics } = params;
+    if (panelMode === 'search') {
+        return {
+            actions: {
+                q: exit,
+                '/': params.toggleSearch,
+                '\r': search.select,
+            },
+            arrowActions: {
+                upArrow: search.up,
+                downArrow: search.down,
+                leftArrow: search.left,
+                rightArrow: search.right,
+            },
+        };
+    }
+    if (panelMode === 'queue') {
+        return {
+            actions: {
+                q: exit,
+                d: params.toggleQueue,
+                '\r': queue.select,
+            },
+            arrowActions: {
+                upArrow: queue.up,
+                downArrow: queue.down,
+                leftArrow: undefined,
+                rightArrow: undefined,
+            },
+        };
+    }
+    if (panelMode === 'lyrics') {
+        return {
+            actions: {
+                q: exit,
+                l: params.toggleLyrics,
+                '+': lyrics.offsetUp,
+                '=': lyrics.offsetUp,
+                '-': lyrics.offsetDown,
+            },
+            arrowActions: {
+                upArrow: isLyricsScrollMode ? lyrics.scrollUp : undefined,
+                downArrow: isLyricsScrollMode ? lyrics.scrollDown : undefined,
+                leftArrow: undefined,
+                rightArrow: undefined,
+            },
+        };
+    }
+    // Default mode (no panel): all playback shortcuts are active
+    return {
+        actions: {
+            q: exit,
+            ' ': playback.toggle,
+            n: playback.next,
+            p: playback.previous,
+            '.': playback.seekForward,
+            ',': playback.seekBackward,
+            s: () => {
+                playback.toggleShuffleMode();
+                params.refreshQueue();
+            },
+            r: playback.cycleRepeat,
+            l: params.toggleLyrics,
+            d: params.toggleQueue,
+            '/': params.toggleSearch,
+            b: params.browseUserPlaylists,
+        },
+        arrowActions: {
+            upArrow: playback.volumeUp,
+            downArrow: playback.volumeDown,
+            leftArrow: playback.seekBackward,
+            rightArrow: playback.seekForward,
+        },
+    };
+}

package/dist/hooks/use-queue.d.ts

@@ -0,0 +1,28 @@
+import type { SpotifyApi } from '@spotify/web-api-ts-sdk';
+import type { PlaybackContext } from '../spotify/playback.js';
+export type QueueItem = {
+    name: string;
+    artist: string;
+    durationMs: number;
+    uri: string;
+    isCurrent: boolean;
+    isPrevious: boolean;
+};
+/**
+ * Fetches the current playlist/album content and marks the currently playing track.
+ * Falls back to the Spotify queue API if no context is available.
+ * @param client - Authenticated Spotify API client
+ * @param enabled - Whether to fetch data
+ * @param trackKey - Current track identity for refresh triggers
+ * @param context - Current playback context (playlist/album)
+ * @param currentTrackUri - URI of the currently playing track
+ * @returns Queue items with current track marked, loading state, and current track index
+ */
+export declare function useQueue(client: SpotifyApi, enabled: boolean, context: PlaybackContext | null, currentTrackUri: string | null): {
+    queue: QueueItem[];
+    contextName: string | null;
+    contextSubtitle: string | null;
+    isLoading: boolean;
+    currentIndex: number;
+    refresh: () => Promise<void>;
+};