@supasayan/ytm 1.0.0

package/client/src/hooks/usePlayer.js

@@ -0,0 +1,188 @@
+import { useState, useRef, useEffect, useCallback } from 'react';
+
+export function usePlayer() {
+  const [currentSong, setCurrentSong] = useState(null);
+  const [source, setSource] = useState(null); // 'stream' | 'local'
+  const [audioUrl, setAudioUrl] = useState(null);
+  const [isPlaying, setIsPlaying] = useState(false);
+  const [currentTime, setCurrentTime] = useState(0);
+  const [duration, setDuration] = useState(0);
+  const [volume, setVolumeState] = useState(0.8);
+  const [isPlayerVisible, setIsPlayerVisible] = useState(false);
+  const [queue, setQueue] = useState([]);
+  
+  const audioRef = useRef(null);
+  const onTrackEndedRef = useRef(null);
+
+  // playNext definition
+  const playNext = useCallback(() => {
+    if (queue.length === 0) return;
+    const currentIndex = queue.findIndex(item => item.videoId === currentSong?.videoId);
+    if (currentIndex === -1) return;
+    
+    const nextIndex = (currentIndex + 1) % queue.length;
+    const nextSong = queue[nextIndex];
+    
+    const isLocal = !!(nextSong.filePath || nextSong.status === 'completed');
+    const filePath = nextSong.filePath;
+    
+    play(nextSong, isLocal ? 'local' : 'stream', queue, filePath);
+  }, [queue, currentSong]);
+
+  const playPrevious = useCallback(() => {
+    if (queue.length === 0) return;
+    const currentIndex = queue.findIndex(item => item.videoId === currentSong?.videoId);
+    if (currentIndex === -1) return;
+    
+    const prevIndex = (currentIndex - 1 + queue.length) % queue.length;
+    const prevSong = queue[prevIndex];
+    
+    const isLocal = !!(prevSong.filePath || prevSong.status === 'completed');
+    const filePath = prevSong.filePath;
+    
+    play(prevSong, isLocal ? 'local' : 'stream', queue, filePath);
+  }, [queue, currentSong]);
+
+  // Keep track-ended reference up-to-date to avoid effect re-binding cycles
+  useEffect(() => {
+    onTrackEndedRef.current = playNext;
+  }, [playNext]);
+
+  // Sync state with audio element events
+  useEffect(() => {
+    const audio = audioRef.current;
+    if (!audio) return;
+
+    const handleTimeUpdate = () => setCurrentTime(audio.currentTime);
+    
+    const updateDuration = () => {
+      if (audio.duration && isFinite(audio.duration)) {
+        setDuration(audio.duration);
+      }
+    };
+
+    const handleEnded = () => {
+      setIsPlaying(false);
+      if (onTrackEndedRef.current) {
+        onTrackEndedRef.current();
+      }
+    };
+    const handlePause = () => setIsPlaying(false);
+    const handlePlay = () => setIsPlaying(true);
+
+    audio.addEventListener('timeupdate', handleTimeUpdate);
+    audio.addEventListener('loadedmetadata', updateDuration);
+    audio.addEventListener('durationchange', updateDuration);
+    audio.addEventListener('ended', handleEnded);
+    audio.addEventListener('pause', handlePause);
+    audio.addEventListener('play', handlePlay);
+
+    // Initial check in case metadata loaded before effect binded
+    updateDuration();
+
+    // Initial volume
+    audio.volume = volume;
+
+    return () => {
+      audio.removeEventListener('timeupdate', handleTimeUpdate);
+      audio.removeEventListener('loadedmetadata', updateDuration);
+      audio.removeEventListener('durationchange', updateDuration);
+      audio.removeEventListener('ended', handleEnded);
+      audio.removeEventListener('pause', handlePause);
+      audio.removeEventListener('play', handlePlay);
+    };
+  }, [audioRef, volume, audioUrl]);
+
+  const play = useCallback((song, srcType, queueList = [], localFilePath = null) => {
+    if (audioRef.current) {
+      audioRef.current.pause();
+      audioRef.current.removeAttribute('src');
+      audioRef.current.load();
+    }
+
+    setCurrentSong(song);
+    setSource(srcType);
+    setQueue(queueList);
+    setIsPlayerVisible(true);
+    setCurrentTime(0);
+    setDuration(0);
+
+    let newUrl = '';
+    if (srcType === 'stream') {
+      newUrl = `/api/stream/${song.videoId}`;
+    } else if (srcType === 'local' && localFilePath) {
+      newUrl = `/api/play-local?path=${encodeURIComponent(localFilePath)}`;
+    }
+
+    setAudioUrl(newUrl);
+
+    // When URL changes, React will re-render the <audio src={newUrl}>
+    // We need to wait for the DOM to update before calling play()
+    setTimeout(() => {
+      if (audioRef.current) {
+        audioRef.current.play().catch(err => console.error("Auto-play prevented", err));
+      }
+    }, 50);
+  }, []);
+
+  const pause = useCallback(() => {
+    if (audioRef.current) {
+      audioRef.current.pause();
+    }
+  }, []);
+
+  const resume = useCallback(() => {
+    if (audioRef.current) {
+      audioRef.current.play();
+    }
+  }, []);
+
+  const seek = useCallback((time) => {
+    if (audioRef.current) {
+      audioRef.current.currentTime = time;
+      setCurrentTime(time);
+    }
+  }, []);
+
+  const setVolume = useCallback((v) => {
+    if (audioRef.current) {
+      audioRef.current.volume = v;
+    }
+    setVolumeState(v);
+  }, []);
+
+  const stop = useCallback(() => {
+    if (audioRef.current) {
+      audioRef.current.pause();
+      // Remove src to abort stream
+      audioRef.current.removeAttribute('src');
+      audioRef.current.load();
+    }
+    setCurrentSong(null);
+    setAudioUrl(null);
+    setQueue([]);
+    setIsPlayerVisible(false);
+    setIsPlaying(false);
+  }, []);
+
+  return {
+    audioRef,
+    currentSong,
+    source,
+    audioUrl,
+    isPlaying,
+    currentTime,
+    duration,
+    volume,
+    isPlayerVisible,
+    queue,
+    playNext,
+    playPrevious,
+    play,
+    pause,
+    resume,
+    seek,
+    setVolume,
+    stop
+  };
+}

package/client/src/hooks/usePlaylist.js

@@ -0,0 +1,52 @@
+import { useState, useCallback } from 'react';
+
+export function usePlaylist() {
+  const [playlist, setPlaylist] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+
+  const fetchPlaylist = useCallback(async (url) => {
+    if (!url) {
+      setPlaylist(null);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const res = await fetch('/api/playlist', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ url })
+      });
+
+      if (!res.ok) {
+        const errorData = await res.json();
+        throw new Error(errorData.error || 'Failed to fetch playlist');
+      }
+
+      const data = await res.json();
+      setPlaylist(data);
+    } catch (err) {
+      setError(err.message);
+      setPlaylist(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  const removeTrack = useCallback((videoId) => {
+    setPlaylist(prev => {
+      if (!prev) return null;
+      const updatedTracks = prev.tracks.filter(t => t.videoId !== videoId);
+      return {
+        ...prev,
+        trackCount: updatedTracks.length,
+        tracks: updatedTracks
+      };
+    });
+  }, []);
+
+  return { playlist, isLoading, error, fetchPlaylist, removeTrack };
+}

package/client/src/hooks/useSearch.js

@@ -0,0 +1,34 @@
+import { useState, useCallback } from 'react';
+
+export function useSearch() {
+  const [results, setResults] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+
+  const search = useCallback(async (query) => {
+    if (!query) {
+      setResults([]);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const res = await fetch(`/api/search?q=${encodeURIComponent(query)}`);
+      if (!res.ok) {
+        const errorData = await res.json();
+        throw new Error(errorData.error || 'Failed to search');
+      }
+      const data = await res.json();
+      setResults(data.results || []);
+    } catch (err) {
+      setError(err.message);
+      setResults([]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  return { results, isLoading, error, search };
+}

package/client/src/index.css

@@ -0,0 +1,245 @@
+:root {
+  /* Background  /* Colors */
+  --bg-primary: #0f172a;
+  --bg-secondary: #1e293b;
+  --bg-tertiary: #334155;
+  --bg-hover: #475569;
+  
+  --accent-primary: #6366f1;
+  --accent-secondary: #8b5cf6;
+  --accent-tertiary: #ec4899;
+  --accent-hover: #4f46e5;
+  --accent-gradient: linear-gradient(135deg, var(--accent-primary) 0%, var(--accent-secondary) 50%, var(--accent-tertiary) 100%);
+  
+  --text-primary: #f8fafc;
+  --text-secondary: #94a3b8;
+  --text-muted: #64748b;
+  
+  --border: #334155;
+  --border-hover: #475569;
+  
+  /* Layout */
+  --radius-sm: 8px;
+  --radius-md: 12px;
+  --radius-lg: 16px;
+  --radius-full: 9999px;
+  
+  /* Shadows */
+  --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+  --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+  --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+  --shadow-glow: 0 0 20px rgba(99, 102, 241, 0.15);
+  
+  /* Liquid Glass */
+  --glass-bg: rgba(255, 255, 255, 0.03);
+  --glass-border: rgba(255, 255, 255, 0.12);
+  --glass-highlight: linear-gradient(
+    135deg,
+    rgba(255, 255, 255, 0.12) 0%,
+    rgba(255, 255, 255, 0.04) 40%,
+    rgba(255, 255, 255, 0) 60%,
+    rgba(255, 255, 255, 0.06) 100%
+  );
+  --glass-blur: 20px;
+  --glass-shadow: 0 8px 32px rgba(0, 0, 0, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.08);
+
+  /* Transitions */
+  --transition-fast: 0.15s ease;
+  --transition-normal: 0.25s ease;
+  --transition-slow: 0.4s ease;
+}
+
+@keyframes pulse {
+  0%, 100% { transform: scale(1); }
+  50%      { transform: scale(1.15); }
+}
+
+@keyframes equalizerBounce {
+  0%, 100% { height: 4px; }
+  50% { height: 16px; }
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+  background-color: var(--bg-primary);
+  color: var(--text-primary);
+  line-height: 1.5;
+}
+
+/* Base styles */
+h1, h2, h3, h4, h5, h6 {
+  margin: 0;
+  font-weight: 600;
+}
+
+.app {
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+a {
+  color: var(--accent-primary);
+  text-decoration: none;
+}
+
+a:hover {
+  color: var(--accent-hover);
+}
+
+button {
+  cursor: pointer;
+  font-family: inherit;
+  border: none;
+  background: none;
+}
+
+.liquid-glass {
+  background: var(--glass-bg);
+  backdrop-filter: blur(var(--glass-blur));
+  -webkit-backdrop-filter: blur(var(--glass-blur));
+  border: 1px solid var(--glass-border);
+  box-shadow: var(--glass-shadow);
+  border-radius: var(--radius-md);
+  position: relative;
+  overflow: hidden;
+}
+
+.liquid-glass::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: var(--glass-highlight);
+  pointer-events: none;
+  z-index: 1;
+}
+
+/* SKELETON LOADER SYSTEM */
+.skeleton-card {
+  display: flex;
+  align-items: center;
+  padding: 0.75rem;
+  border-radius: var(--radius-md);
+  border: 1px solid var(--border);
+  gap: 1rem;
+  height: 84px;
+  box-sizing: border-box;
+}
+
+.skeleton-thumbnail {
+  width: 60px;
+  height: 60px;
+  border-radius: var(--radius-sm);
+  background: var(--bg-secondary);
+  position: relative;
+  overflow: hidden;
+}
+
+.skeleton-info {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  min-width: 0;
+}
+
+.skeleton-line {
+  height: 12px;
+  border-radius: var(--radius-full);
+  background: var(--bg-secondary);
+  position: relative;
+  overflow: hidden;
+}
+
+.skeleton-title-line {
+  width: 60%;
+  height: 14px;
+}
+
+.skeleton-meta-line {
+  width: 40%;
+  height: 10px;
+}
+
+.skeleton-button {
+  width: 40px;
+  height: 40px;
+  border-radius: var(--radius-sm);
+  background: var(--bg-secondary);
+  position: relative;
+  overflow: hidden;
+}
+
+.skeleton-thumbnail::after,
+.skeleton-line::after,
+.skeleton-button::after,
+.skeleton-header::after {
+  content: '';
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  transform: translateX(-100%);
+  background: linear-gradient(
+    90deg,
+    rgba(255, 255, 255, 0) 0%,
+    rgba(255, 255, 255, 0.04) 20%,
+    rgba(255, 255, 255, 0.08) 60%,
+    rgba(255, 255, 255, 0) 100%
+  );
+  animation: shimmer 1.5s infinite ease-in-out;
+}
+
+@keyframes shimmer {
+  100% {
+    transform: translateX(100%);
+  }
+}
+
+/* Unified Empty State Styling */
+.empty-state {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 5rem 2rem;
+  text-align: center;
+  background: var(--glass-bg);
+  border: 1px solid var(--glass-border);
+  border-radius: var(--radius-md);
+  backdrop-filter: blur(10px);
+  -webkit-backdrop-filter: blur(10px);
+  box-shadow: var(--glass-shadow);
+  margin-top: 1rem;
+}
+
+.empty-state-icon {
+  color: var(--text-muted);
+  margin-bottom: 1.25rem;
+  opacity: 0.4;
+  animation: pulse-slow 2.5s infinite ease-in-out;
+}
+
+.empty-state p {
+  margin: 0;
+  font-size: 1.1rem;
+  color: var(--text-secondary);
+  font-weight: 500;
+  letter-spacing: -0.01em;
+}
+
+@keyframes pulse-slow {
+  0% { transform: scale(1); opacity: 0.4; }
+  50% { transform: scale(1.05); opacity: 0.6; }
+  100% { transform: scale(1); opacity: 0.4; }
+}

package/client/src/main.jsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('app')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

package/client/src/pages/DownloadsPage.css

@@ -0,0 +1,37 @@
+.downloads-page {
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+}
+
+.downloads-section {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.section-title {
+  font-size: 1.15rem;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin: 0;
+  padding-bottom: 0.25rem;
+}
+
+.history-section .section-title {
+  color: var(--text-secondary);
+}
+
+.downloads-list {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(340px, 1fr));
+  gap: 1rem;
+}
+
+@media (max-width: 768px) {
+  .downloads-list {
+    grid-template-columns: 1fr;
+  }
+}
+
+

package/client/src/pages/DownloadsPage.jsx

@@ -0,0 +1,80 @@
+import DownloadItem from '../components/Download/DownloadItem';
+import { DownloadCloud } from 'lucide-react';
+import './DownloadsPage.css';
+
+export default function DownloadsPage({ downloads, onPlay, currentSong, onSearchAlternative, onClearQueue }) {
+  const downloadArray = downloads ? Array.from(downloads.values()).reverse() : [];
+  const activeDownloads = downloadArray.filter(d => d.status === 'queued' || d.status === 'downloading');
+  // UI Freeze Protection: Cap rendered completed downloads to the most recent 50
+  const historyDownloads = downloadArray.filter(d => d.status === 'completed' || d.status === 'error').slice(0, 50);
+
+  if (downloadArray.length === 0) {
+    return (
+      <div className="downloads-page">
+        <div className="empty-state">
+          <DownloadCloud size={48} className="empty-state-icon" />
+          <p>No downloads yet</p>
+        </div>
+      </div>
+    );
+  }
+
+  const queuedCount = activeDownloads.filter(d => d.status === 'queued').length;
+
+  return (
+    <div className="downloads-page">
+      {activeDownloads.length > 0 && (
+        <section className="downloads-section">
+          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '1rem' }}>
+            <h3 className="section-title" style={{ margin: 0 }}>Active Downloads</h3>
+            {queuedCount > 0 && (
+              <button 
+                onClick={onClearQueue}
+                style={{
+                  background: 'rgba(255, 59, 48, 0.2)',
+                  color: '#ff3b30',
+                  border: '1px solid rgba(255, 59, 48, 0.4)',
+                  padding: '8px 16px',
+                  borderRadius: '20px',
+                  cursor: 'pointer',
+                  fontWeight: '600',
+                  transition: 'all 0.2s ease'
+                }}
+              >
+                Clear Pending Queue ({queuedCount})
+              </button>
+            )}
+          </div>
+          <div className="downloads-list">
+            {activeDownloads.map(dl => (
+              <DownloadItem 
+                key={dl.downloadId} 
+                download={dl} 
+                onPlay={onPlay} 
+                isCurrentlyPlaying={currentSong?.videoId === dl.videoId} 
+                onSearchAlternative={onSearchAlternative}
+              />
+            ))}
+          </div>
+        </section>
+      )}
+
+      {historyDownloads.length > 0 && (
+        <section className="downloads-section history-section">
+          <h3 className="section-title">Download History</h3>
+          <div className="downloads-list">
+            {historyDownloads.map(dl => (
+              <DownloadItem 
+                key={dl.downloadId} 
+                download={dl} 
+                onPlay={(song, rect) => onPlay(dl, rect, historyDownloads)} 
+                isCurrentlyPlaying={currentSong?.videoId === dl.videoId} 
+                onSearchAlternative={onSearchAlternative}
+              />
+            ))}
+          </div>
+        </section>
+      )}
+    </div>
+  );
+}

package/client/src/pages/PlaylistPage.jsx

@@ -0,0 +1,46 @@
+import { usePlaylist } from '../hooks/usePlaylist';
+import PlaylistInput from '../components/Playlist/PlaylistInput';
+import PlaylistView from '../components/Playlist/PlaylistView';
+import { ListMusic } from 'lucide-react';
+
+export default function PlaylistPage({ outputDir, onDownloadSingle, onBulkDownload, onFlyAnimation, downloads, onPlay, currentSong }) {
+  const { playlist, isLoading, error, fetchPlaylist, removeTrack } = usePlaylist();
+
+  const handleDownloadAll = (tracks) => {
+    onBulkDownload(tracks, outputDir);
+  };
+
+  const handleDownloadSingle = (song) => {
+    onDownloadSingle(song, outputDir);
+  };
+
+  return (
+    <div className="playlist-page">
+      <PlaylistInput onFetch={fetchPlaylist} isLoading={isLoading} />
+      
+      {error && (
+        <div className="error-message">
+          <p>⚠️ {error}</p>
+        </div>
+      )}
+
+      {!playlist && !isLoading && (
+        <div className="empty-state">
+          <ListMusic size={48} className="empty-state-icon" />
+          <p>No playlist loaded yet</p>
+        </div>
+      )}
+
+        <PlaylistView 
+          playlist={playlist} 
+          onDownloadSingle={(song) => onDownloadSingle(song, outputDir)}
+          onDownloadAll={() => onBulkDownload(playlist.tracks, outputDir)}
+          onFlyAnimation={onFlyAnimation}
+          downloads={downloads}
+          onPlay={onPlay}
+          currentSong={currentSong}
+          onRemoveTrack={removeTrack}
+        />
+    </div>
+  );
+}