Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

mira tengo esto: import React, { useState, useEffect, useRef } from "react"; import…

  1. User

    mira tengo esto:

    import React, { useState, useEffect, useRef } from "react"; import YouTube, { YouTubeProps, YouTubePlayer } from "react-youtube"; import { Play, Pause, SkipBack, SkipForward, Shuffle, Repeat, VolumeX, Volume1, Volume2, Maximize2, Search, MoreHorizontal, Download, Share2, Mic2, ChevronDown, } from "lucide-react"; import { Button } from "./components/ui/button"; // Asegúrate de que la ruta sea correcta import { Input } from "./components/ui/input"; // Agregado para el campo de búsqueda import { Slider } from "./components/ui/slider"; // Asegúrate de tener este componente

    // Interfaz para las canciones interface Song { title: string; artist: string; album: string; added: string; duration?: number; // Duración en segundos youtubeId?: string; }

    // Lista de canciones con youtubeId const songs: Song[] = [ { title: "Las Piponas (Remix)", artist: "Kris R., Blessed", album: "Las Piponas (Remix)", added: "hace 2 horas", duration: 242, youtubeId: "Dftj21lTUIA", }, { title: "La Nueva Gerencia", artist: "Arcángel, Farruko", album: "La Nueva Gerencia", added: "hace 1 día", duration: 210, youtubeId: "ehYg8s7xHbs", }, { title: "Secretos", artist: "C.R.O, Kidd Keo", album: "Secretos", added: "hace 3 días", duration: 180, youtubeId: "GL7Xs9neldo", }, { title: "Lo Siento", artist: "Saigo", album: "Lo Siento", added: "hace una semana", duration: 200, youtubeId: "kLukLxV2J8M", }, // Puedes agregar más canciones aquí ];

    // Información de la playlist const playlist = { name: "Time Free", description: "Relajao", owner: "Johan Morales", timesSaved: 8, coverImage: "https://i.postimg.cc/y8KhsW1p/imagen-blessd.jpg", // Asegúrate de que esta URL sea correcta };

    // Función para obtener la miniatura de YouTube const getYouTubeThumbnail = (youtubeId: string): string => https://img.youtube.com/vi/${youtubeId}/hqdefault.jpg;

    // Función para formatear la duración total const formatTotalDuration = (totalSeconds: number): string => { const hours = Math.floor(totalSeconds / 3600); const minutes = Math.floor((totalSeconds % 3600) / 60); return ${hours} h ${minutes} min; };

    const SpotifyClone = () => { const [currentSong, setCurrentSong] = useState<Song | null>(null); const [isPlaying, setIsPlaying] = useState(false); const [isMobile, setIsMobile] = useState(window.innerWidth < 1024); const [showNavbar, setShowNavbar] = useState(true); const [isFullScreenPlayer, setIsFullScreenPlayer] = useState(false); // Nuevo estado

    const playerRef = useRef<YouTubePlayer | null>(null);

    const [currentTime, setCurrentTime] = useState(0); const [duration, setDuration] = useState(0);

    const [volume, setVolume] = useState(100);

    // Estado para manejar el último scroll const lastScrollY = useRef(0);

    // Calcular el número de canciones y la duración total const songsCount = songs.length; const totalDurationInSeconds = songs.reduce( (sum, song) => sum + (song.duration || 0), 0 ); const totalDuration = formatTotalDuration(totalDurationInSeconds);

    // Manejar el cambio de tamaño de la ventana useEffect(() => { const handleResize = () => { setIsMobile(window.innerWidth < 1024); };

    handleResize();
    
    window.addEventListener("resize", handleResize);
    return () => window.removeEventListener("resize", handleResize);
    

    }, []);

    // Manejar la visibilidad de la barra de navegación al hacer scroll useEffect(() => { const handleScroll = () => { if (typeof window !== "undefined" && !isFullScreenPlayer) { if (window.scrollY > lastScrollY.current && window.scrollY > 100) { // Scroll hacia abajo setShowNavbar(false); } else { // Scroll hacia arriba setShowNavbar(true); } lastScrollY.current = window.scrollY; } };

    window.addEventListener("scroll", handleScroll);
    
    return () => window.removeEventListener("scroll", handleScroll);
    

    }, [isFullScreenPlayer]);

    // Cargar y configurar el video cuando cambia la canción actual useEffect(() => { if (playerRef.current && currentSong?.youtubeId) { playerRef.current.loadVideoById(currentSong.youtubeId); setCurrentTime(0); setDuration(0); // La reproducción se manejará en onPlayerStateChange } }, [currentSong]);

    // Reproducir o pausar cuando cambia el estado isPlaying useEffect(() => { if (playerRef.current) { if (isPlaying) { playerRef.current.playVideo(); } else { playerRef.current.pauseVideo(); } } }, [isPlaying]);

    // Actualizar el tiempo actual y la duración useEffect(() => { let intervalId: NodeJS.Timeout | null = null;

    if (playerRef.current && isPlaying) {
      intervalId = setInterval(() => {
        const current = playerRef.current!.getCurrentTime();
        const dura = playerRef.current!.getDuration();
        setCurrentTime(current);
        setDuration(dura);
      }, 1000);
    }
    
    return () => {
      if (intervalId) clearInterval(intervalId);
    };
    

    }, [isPlaying]);

    // Función para manejar Play/Pause const handlePlayPause = () => { if (isPlaying) { playerRef.current?.pauseVideo(); } else { if (currentSong?.youtubeId) { playerRef.current?.playVideo(); } } setIsPlaying(!isPlaying); };

    // Función para cambiar a la siguiente canción const handleNextSong = () => { if (!currentSong) return; const currentIndex = songs.indexOf(currentSong); const nextIndex = (currentIndex + 1) % songs.length; const nextSong = songs[nextIndex]; setIsPlaying(true); // Asegurarse de que se reproduzca setCurrentSong(nextSong); };

    // Función para cambiar a la canción anterior const handlePreviousSong = () => { if (!currentSong) return; const currentIndex = songs.indexOf(currentSong); const previousIndex = (currentIndex - 1 + songs.length) % songs.length; const previousSong = songs[previousIndex]; setIsPlaying(true); // Asegurarse de que se reproduzca setCurrentSong(previousSong); };

    // Función para manejar cuando el reproductor está listo const onPlayerReady: YouTubeProps["onReady"] = (event) => { playerRef.current = event.target; setDuration(event.target.getDuration());

    event.target.setVolume(volume);
    
    if (isPlaying) {
      event.target.playVideo().catch((error) => {
        console.error("Error intentando reproducir el video:", error);
      });
    }
    

    };

    // Función para manejar cuando el video termina const onPlayerEnd: YouTubeProps["onEnd"] = () => { handleNextSong(); };

    // Función para manejar los cambios de estado del reproductor const onPlayerStateChange: YouTubeProps["onStateChange"] = (event) => { if (event.data === window.YT.PlayerState.ENDED) { handleNextSong(); } else if ( (event.data === window.YT.PlayerState.CUED || event.data === window.YT.PlayerState.BUFFERING) && isPlaying ) { // Intentar reproducir cuando el video está listo playerRef.current?.playVideo().catch((error) => { console.error("Error intentando reproducir el video:", error); }); } };

    // Opciones del reproductor de YouTube const opts: YouTubeProps["opts"] = { height: "0", width: "0", playerVars: { autoplay: 0, // Cambiar a 1 si deseas intentar autoplay, pero puede ser bloqueado controls: 0, disablekb: 1, fs: 0, modestbranding: 1, rel: 0, }, };

    // Función para formatear el tiempo const formatTime = (seconds: number): string => { const minutes = Math.floor(seconds / 60); const secs = Math.floor(seconds % 60); const minutesStr = minutes < 10 ? 0${minutes} : ${minutes}; const secondsStr = secs < 10 ? 0${secs} : ${secs}; return ${minutesStr}:${secondsStr}; };

    // Función para manejar el cambio de progreso const handleProgressChange = (e: React.ChangeEvent) => { const newTime = Number(e.target.value); if (playerRef.current) { playerRef.current.seekTo(newTime, true); setCurrentTime(newTime); } };

    // Función para manejar el cambio de volumen const handleVolumeChange = (e: React.ChangeEvent) => { const newVolume = Number(e.target.value); setVolume(newVolume); if (playerRef.current) { playerRef.current.setVolume(newVolume); } };

    // Función para alternar mute/unmute const toggleMute = () => { if (playerRef.current) { if (playerRef.current.isMuted()) { playerRef.current.unMute(); setVolume(playerRef.current.getVolume()); } else { playerRef.current.mute(); setVolume(0); } } };

    // Función para alternar el modo fullscreen del reproductor const toggleFullScreenPlayer = () => { setIsFullScreenPlayer(!isFullScreenPlayer); if (!isFullScreenPlayer) { setShowNavbar(false); // Ocultar la navbar al abrir el fullscreen } else { // Restaurar la visibilidad de la navbar al cerrar el fullscreen setShowNavbar(true); } };

    // Función para garantizar la reproducción en dispositivos móviles después de un cambio const ensurePlayback = () => { if (isPlaying && playerRef.current) { playerRef.current .playVideo() .then(() => { console.log("Reproducción iniciada automáticamente."); }) .catch((error: any) => { console.error("Error al intentar reproducir automáticamente:", error); }); } };

    // UseEffect adicional para manejar la reproducción después de un cambio de canción useEffect(() => { if (currentSong && isPlaying) { // Utilizar un timeout para dar tiempo al reproductor a cargar el video const timeoutId = setTimeout(() => { ensurePlayback(); }, 1000); // 1 segundo de retraso

      return () => clearTimeout(timeoutId);
    }
    

    }, [currentSong, isPlaying]);

    return ( {/* Renderizar el reproductor solo si hay una canción seleccionada */} {currentSong?.youtubeId && ( )}

      {/* Barra de navegación superior */}
      <div
        className={`flex items-center p-4 bg-gradient-to-b from-gray-600 to-red-900 transition-transform duration-300 ${
          showNavbar ? "translate-y-0" : "-translate-y-full"
        } fixed top-0 left-0 right-0 z-50`}
      >
        {/* Foto de perfil */}
        <div className="flex-shrink-0">
          <img
            src="https://i.postimg.cc/PJPVDPZW/boyaca-yo.webp" // Reemplaza con tu foto de perfil
            alt="Perfil"
            className="w-8 h-8 rounded-full"
          />
        </div>
    
        {/* Barra de búsqueda */}
        <div className="flex-1 mx-4">
          <div className="relative">
            <Search className="absolute left-3 top-1/2 transform -translate-y-1/2 text-gray-400 h-5 w-5" />
            <Input
              type="text"
              placeholder="¿Qué quieres reproducir?"
              className="pl-10 pr-4 py-2 w-full bg-white/10 text-white placeholder-gray-400 rounded-full focus:outline-none focus:ring-2 focus:ring-green-500"
            />
          </div>
        </div>
      </div>
    
      {/* Margen superior para evitar que el contenido quede oculto detrás de la barra fija */}
      <div
        className={`pt-20 flex-1 overflow-y-auto bg-gradient-to-b from-red-900 to-gray-900 ${
          isFullScreenPlayer ? "hidden" : ""
        }`} // Ocultar el contenido principal cuando se está en fullscreen
      >
        {/* Información de la Playlist */}
        <div className="flex flex-col lg:flex-row mb-6 px-6">
          <img
            src={playlist.coverImage || "/placeholder.svg"}
            alt="Playlist cover"
            className="w-40 h-40 object-cover rounded-md mx-auto lg:mx-0"
          />
          <div className="text-left mt-4 lg:mt-0 lg:ml-6">
            <h1 className="text-3xl lg:text-5xl font-bold mb-2">
              {playlist.name}
            </h1>
            <p className="text-sm">{playlist.description}</p>
            <div className="flex items-center mt-2">
              <img
                src="https://i.postimg.cc/PJPVDPZW/boyaca-yo.webp"
                alt="Propietario"
                className="w-6 h-6 rounded-full mr-2"
              />
              <div className="flex flex-col">
                <span className="text-sm">{playlist.owner}</span>
                <span className="text-sm text-gray-400">
                  {`${songsCount} canciones • ${totalDuration}`}
                </span>
              </div>
            </div>
          </div>
        </div>
    
        {/* Controles de reproducción */}
        {currentSong && (
          <div className="flex items-center space-x-4 mb-6 px-6">
            <Button
              size="lg"
              className="rounded-full bg-green-500 hover:bg-green-400"
              onClick={handlePlayPause}
              aria-label={isPlaying ? "Pausar" : "Reproducir"}
            >
              {isPlaying ? (
                <Pause fill="black" className="w-6 h-6 text-black" />
              ) : (
                <Play fill="black" className="w-6 h-6 text-black" />
              )}
            </Button>
            <Button
              variant="outline"
              size="icon"
              className="rounded-full"
              aria-label="Agregar a la cola"
            >
              <svg
                width="24"
                height="24"
                viewBox="0 0 24 24"
                fill="none"
                xmlns="http://www.w3.org/2000/svg"
              >
                <path
                  d="M4.5 12.75L19.5 12.75"
                  stroke="currentColor"
                  strokeWidth="1.5"
                  strokeLinecap="round"
                  strokeLinejoin="round"
                />
                <path
                  d="M12 5.25L12 20.25"
                  stroke="currentColor"
                  strokeWidth="1.5"
                  strokeLinecap="round"
                  strokeLinejoin="round"
                />
              </svg>
            </Button>
            <Button variant="ghost" size="icon" aria-label="Más opciones">
              •••
            </Button>
          </div>
        )}
    
        {/* Lista de canciones */}
        <div className="px-6">
          <table className="w-full">
            <thead>
              <tr className="text-left text-sm text-gray-400 border-b border-gray-800">
                {/* Columnas que se ocultarán en móviles */}
                <th className="hidden lg:table-cell pb-2">#</th>
                <th className="pb-2">Título</th>
                <th className="hidden lg:table-cell pb-2">Álbum</th>
                <th className="hidden lg:table-cell pb-2">
                  Fecha en que se agregó
                </th>
                <th className="hidden lg:table-cell pb-2">
                  <svg
                    width="16"
                    height="16"
                    viewBox="0 0 16 16"
                    fill="none"
                    xmlns="http://www.w3.org/2000/svg"
                  >
                    <path
                      d="M8 3.33337V12.6667"
                      stroke="currentColor"
                      strokeWidth="2"
                      strokeLinecap="round"
                      strokeLinejoin="round"
                    />
                    <path
                      d="M3.33331 8H12.6666"
                      stroke="currentColor"
                      strokeWidth="2"
                      strokeLinecap="round"
                      strokeLinejoin="round"
                    />
                  </svg>
                </th>
              </tr>
            </thead>
            <tbody>
              {songs.map((track, index) => (
                <tr
                  key={index}
                  className="hover:bg-gray-800 cursor-pointer"
                  onClick={() => {
                    if (track.youtubeId) {
                      setCurrentSong(track);
                      setIsPlaying(true); // Asegurar que se reproduzca al seleccionar
                    }
                  }}
                >
                  {/* Columna de número oculta en móviles */}
                  <td className="hidden lg:table-cell py-2">{index + 1}</td>
                  <td className="py-2">
                    <div className="flex items-center">
                      <img
                        src={
                          track.youtubeId
                            ? getYouTubeThumbnail(track.youtubeId)
                            : "/placeholder.svg"
                        }
                        alt="Video thumbnail"
                        className="w-10 h-10 mr-4 object-cover rounded-md"
                      />
                      <div>
                        <p className="font-medium">{track.title}</p>
                        <p className="text-sm text-gray-400">{track.artist}</p>
                      </div>
                    </div>
                  </td>
                  {/* Columna de álbum oculta en móviles */}
                  <td className="hidden lg:table-cell py-2 text-sm text-gray-400">
                    {track.album}
                  </td>
                  {/* Columna de fecha oculta en móviles */}
                  <td className="hidden lg:table-cell py-2 text-sm text-gray-400">
                    {track.added}
                  </td>
                  {/* Columna de duración oculta en móviles */}
                  <td className="hidden lg:table-cell py-2 text-sm text-gray-400">
                    {track.duration ? formatTime(track.duration) : "--:--"}
                  </td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>
      </div>
    
      {/* Now Playing Bar (solo para dispositivos móviles, solo si hay una canción seleccionada y no está en fullscreen) */}
      {isMobile && currentSong && !isFullScreenPlayer && (
        <div
          className="bg-gray-900 p-2 fixed bottom-0 left-0 right-0 z-50 cursor-pointer"
          onClick={toggleFullScreenPlayer}
        >
          <div className="flex items-center justify-between">
            <div className="flex items-center space-x-2 flex-grow">
              <img
                src={
                  currentSong.youtubeId
                    ? getYouTubeThumbnail(currentSong.youtubeId)
                    : "/placeholder.svg"
                }
                alt="Now playing cover"
                className="w-12 h-12 rounded"
              />
              <div>
                <p className="font-medium">{currentSong.title}</p>
                <p className="text-sm text-gray-400">{currentSong.artist}</p>
              </div>
            </div>
            <div className="flex items-center space-x-4">
              <Button
                variant="ghost"
                size="icon"
                className="text-white"
                onClick={(e) => {
                  e.stopPropagation(); // Evitar que el click se propague al div padre
                  handlePlayPause();
                }}
                aria-label={isPlaying ? "Pausar" : "Reproducir"}
              >
                {isPlaying ? (
                  <Pause className="h-6 w-6" fill="currentColor" />
                ) : (
                  <Play className="h-6 w-6" fill="currentColor" />
                )}
              </Button>
            </div>
          </div>
        </div>
      )}
    
      {/* Panel Completo de Reproducción para Móviles */}
      {isMobile && isFullScreenPlayer && currentSong && (
        <div className="flex flex-col h-screen bg-gradient-to-b from-gray-900 to-black text-white">
          {/* Navigation */}
          <div className="flex justify-between items-center p-4">
            <Button
              variant="ghost"
              size="icon"
              className="text-white"
              onClick={toggleFullScreenPlayer}
            >
              <ChevronDown className="h-6 w-6" />
            </Button>
            <span className="text-sm font-semibold">Time Free</span>
            <Button variant="ghost" size="icon" className="text-white">
              <MoreHorizontal className="h-6 w-6" />
            </Button>
          </div>
    
          {/* Album Art */}
          <div className="flex-grow flex items-center justify-center p-4">
            <img
              src={
                currentSong.youtubeId
                  ? getYouTubeThumbnail(currentSong.youtubeId)
                  : "/placeholder.svg"
              }
              alt="Album Art"
              className="w-full h-full max-w-xs max-h-xs object-cover rounded-lg"
            />
          </div>
    
          {/* Song Info */}
          <div className="px-4 py-2">
            <h2 className="text-2xl font-bold">{currentSong.title}</h2>
            <p className="text-gray-400">{currentSong.artist}</p>
          </div>
    
          {/* Progress Bar */}
          <div className="px-4 py-2">
            <Slider
              value={[(currentTime / duration) * 100 || 0]}
              max={100}
              step={1}
              onValueChange={(values) => {
                const newTime = (values[0] / 100) * duration;
                if (playerRef.current) {
                  playerRef.current.seekTo(newTime, true);
                  setCurrentTime(newTime);
                }
              }}
              className="w-full"
            />
            <div className="flex justify-between text-xs text-gray-400 mt-1">
              <span>{formatTime(currentTime)}</span>
              <span>-{formatTime(duration - currentTime)}</span>
            </div>
          </div>
    
          {/* Playback Controls */}
          <div className="flex justify-between items-center px-4 py-6">
            <Button
              variant="ghost"
              size="icon"
              className="text-white"
              onClick={() => {
                // Shuffle funcionalidad (seleccionar una canción al azar)
                const randomIndex = Math.floor(Math.random() * songs.length);
                setCurrentSong(songs[randomIndex]);
                setIsPlaying(true);
              }}
              aria-label="Shuffle"
            >
              <Shuffle className="h-6 w-6" />
            </Button>
            <Button
              variant="ghost"
              size="icon"
              className="text-white"
              onClick={handlePreviousSong}
              aria-label="Anterior"
            >
              <SkipBack className="h-6 w-6" />
            </Button>
            <Button
              size="icon"
              className="bg-white text-black rounded-full hover:bg-gray-200 h-16 w-16"
              onClick={handlePlayPause}
              aria-label={isPlaying ? "Pausar" : "Reproducir"}
            >
              {isPlaying ? (
                <Pause className="h-8 w-8" fill="currentColor" />
              ) : (
                <Play className="h-8 w-8" fill="currentColor" />
              )}
            </Button>
            <Button
              variant="ghost"
              size="icon"
              className="text-white"
              onClick={handleNextSong}
              aria-label="Siguiente"
            >
              <SkipForward className="h-6 w-6" />
            </Button>
            <Button
              variant="ghost"
              size="icon"
              className="text-white"
              aria-label="Repetir"
              onClick={() => {
                // Repeat funcionalidad (repetir la misma canción)
                setIsPlaying(false);
                setCurrentSong(currentSong);
                setIsPlaying(true);
              }}
            >
              <Repeat className="h-6 w-6" />
            </Button>
          </div>
    
          {/* Bottom Options */}
          <div className="flex justify-between items-center px-4 py-4">
            <Button variant="ghost" size="icon" className="text-white">
              <Download className="w-6 h-6" />
            </Button>
            <Button variant="ghost" size="icon" className="text-white">
              <Mic2 className="h-6 w-6" />
            </Button>
            <Button variant="ghost" size="icon" className="text-white">
              <Share2 className="h-6 w-6" />
            </Button>
          </div>
        </div>
      )}
    
      {/* Barra de reproducción (solo para pantallas grandes, solo si hay una canción seleccionada) */}
      {!isMobile && currentSong && (
        <div
          className={`flex flex-col lg:flex-row items-center justify-between p-4 bg-gray-900 border-t border-gray-800 fixed bottom-0 left-0 right-0 transition-margin duration-300 ease-in-out`}
        >
          {/* Información de la canción actual */}
          <div className="flex items-center mb-4 lg:mb-0 w-full lg:w-1/3 justify-center lg:justify-start">
            <img
              src={
                currentSong.youtubeId
                  ? getYouTubeThumbnail(currentSong.youtubeId)
                  : "/placeholder.svg"
              }
              alt="Album cover"
              className="w-10 h-10 mr-4 object-cover rounded-md"
            />
            <div>
              <p className="font-medium">{currentSong.title}</p>
              <p className="text-sm text-gray-400">{currentSong.artist}</p>
            </div>
          </div>
    
          {/* Controles de reproducción y progreso */}
          <div className="flex flex-col items-center w-full lg:w-1/3">
            <div className="flex items-center space-x-4 mb-2">
              <Button
                variant="ghost"
                size="icon"
                className="text-gray-400 hover:text-white"
                aria-label="Shuffle"
                onClick={() => {
                  // Shuffle funcionalidad (seleccionar una canción al azar)
                  const randomIndex = Math.floor(Math.random() * songs.length);
                  setCurrentSong(songs[randomIndex]);
                  setIsPlaying(true);
                }}
              >
                <Shuffle className="w-5 h-5" />
              </Button>
              <Button
                variant="ghost"
                size="icon"
                className="text-gray-400 hover:text-white"
                onClick={handlePreviousSong}
                aria-label="Anterior"
              >
                <SkipBack className="w-5 h-5" />
              </Button>
              <Button
                size="icon"
                className={`rounded-full bg-white hover:bg-gray-200`}
                onClick={handlePlayPause}
                aria-label={isPlaying ? "Pausar" : "Reproducir"}
              >
                {isPlaying ? (
                  <Pause className="w-6 h-6 text-black" />
                ) : (
                  <Play className="w-6 h-6 text-black" />
                )}
              </Button>
              <Button
                variant="ghost"
                size="icon"
                className="text-gray-400 hover:text-white"
                onClick={handleNextSong}
                aria-label="Siguiente"
              >
                <SkipForward className="w-5 h-5" />
              </Button>
              <Button
                variant="ghost"
                size="icon"
                className="text-gray-400 hover:text-white"
                aria-label="Repetir"
                onClick={() => {
                  // Repeat funcionalidad (repetir la misma canción)
                  setIsPlaying(false);
                  setCurrentSong(currentSong);
                  setIsPlaying(true);
                }}
              >
                <Repeat className="w-5 h-5" />
              </Button>
            </div>
            <div className="flex items-center w-full space-x-2">
              <span className="text-xs text-gray-400">
                {formatTime(currentTime)}
              </span>
              <input
                type="range"
                min={0}
                max={duration}
                value={currentTime}
                onChange={handleProgressChange}
                className="flex-1 h-1 bg-gray-600 rounded-full cursor-pointer appearance-none focus:outline-none"
              />
              <span className="text-xs text-gray-400">
                {formatTime(duration)}
              </span>
            </div>
          </div>
    
          {/* Controles de volumen y pantalla completa */}
          <div className="flex items-center justify-end w-full lg:w-1/3 mt-4 lg:mt-0">
            <Button
              variant="ghost"
              size="icon"
              className="text-gray-400 hover:text-white mr-2"
              onClick={toggleMute}
              aria-label={volume === 0 ? "Desmutear" : "Mute"}
            >
              {volume === 0 ? (
                <VolumeX className="w-5 h-5" />
              ) : volume <= 50 ? (
                <Volume1 className="w-5 h-5" />
              ) : (
                <Volume2 className="w-5 h-5" />
              )}
            </Button>
            <input
              type="range"
              min={0}
              max={100}
              value={volume}
              onChange={handleVolumeChange}
              className="w-24 h-1 bg-gray-600 rounded-full cursor-pointer appearance-none focus:outline-none"
            />
            <Button
              variant="ghost"
              size="icon"
              className="text-gray-400 hover:text-white ml-2"
              aria-label="Pantalla completa"
              onClick={toggleFullScreenPlayer}
            >
              <Maximize2 className="w-5 h-5" />
            </Button>
          </div>
        </div>
      )}
    </div>
    

    ); };

    export default SpotifyClone;

    pero me está saliendo este error:

    × 1 of 3 errors on the page TypeError playerRef.current.playVideo().catch is not a function onPlayerStateChange /App.tsx:249:37

    246 | isPlaying 247 | ) { 248 | // Intentar reproducir cuando el video está listo

    249 | playerRef.current?.playVideo().catch((error) => { | ^ 250 | console.error("Error intentando reproducir el video:", error); 251 | }); 252 | }

    View compiled ▶ 5 stack frames were collapsed. This screen is visible only in development. It will not appear if the app crashes in production. Open your browser’s developer console to further inspect this error. This error overlay is powered by react-error-overlay used in create-react-app.

  2. Assistant

    El error que estás enfrentando se debe a que estás intentando encadenar un método .catch a la función playVideo(), la cual no retorna una Promesa. En la API de YouTube utilizada por el paquete react-youtube, los métodos como playVideo() no devuelven Promesas, por lo que no soportan métodos como .then o .catch.

    Detalles del Error:

    playerRef.current?.playVideo().catch((error) => {
      console.error("Error intentando reproducir el video:", error);
    });
    

    Aquí, playVideo() no devuelve una Promesa, lo que hace que .catch no sea una función válida, resultando en el error TypeError: playerRef.current.playVideo(...).catch is not a function.

    Pasos para Solucionar el Problema:

    1. Eliminar el Uso de .catch: Debes eliminar todas las instancias donde intentas encadenar .catch (o .then) a playVideo(), ya que no son necesarias y causan errores.

    2. Manejo de Errores con Eventos de la API de YouTube: La API de YouTube proporciona eventos que puedes utilizar para manejar errores. Asegúrate de implementar los manejadores de eventos adecuados, como onError, para capturar y manejar cualquier problema que surja durante la reproducción.

    3. Actualizar el Código: A continuación, se muestra cómo puedes actualizar tu código para eliminar los .catch y manejar los errores correctamente.

    Código Actualizado:

    // ... (resto del código)
    
    const onPlayerReady: YouTubeProps["onReady"] = (event) => {
      playerRef.current = event.target;
      setDuration(event.target.getDuration());
    
      event.target.setVolume(volume);
    
      if (isPlaying) {
        try {
          event.target.playVideo();
        } catch (error) {
          console.error("Error intentando reproducir el video:", error);
        }
      }
    };
    
    // Actualiza onPlayerStateChange
    const onPlayerStateChange: YouTubeProps["onStateChange"] = (event) => {
      if (event.data === window.YT.PlayerState.ENDED) {
        handleNextSong();
      } else if (
        (event.data === window.YT.PlayerState.CUED ||
          event.data === window.YT.PlayerState.BUFFERING) &&
        isPlaying
      ) {
        try {
          playerRef.current?.playVideo();
        } catch (error) {
          console.error("Error intentando reproducir el video:", error);
        }
      }
    };
    
    // Actualiza ensurePlayback
    const ensurePlayback = () => {
      if (isPlaying && playerRef.current) {
        try {
          playerRef.current.playVideo();
          console.log("Reproducción iniciada automáticamente.");
        } catch (error) {
          console.error("Error al intentar reproducir automáticamente:", error);
        }
      }
    };
    
    // Actualiza el useEffect adicional
    useEffect(() => {
      if (currentSong && isPlaying) {
        // Utilizar un timeout para dar tiempo al reproductor a cargar el video
        const timeoutId = setTimeout(() => {
          ensurePlayback();
        }, 1000); // 1 segundo de retraso
    
        return () => clearTimeout(timeoutId);
      }
    }, [currentSong, isPlaying]);
    
    // ... (resto del código)
    

    Implementación con Manejador de Errores de la API de YouTube:

    Además de las modificaciones anteriores, puedes implementar un manejador de errores usando el evento onError. Esto te permitirá capturar y manejar errores específicos que la API de YouTube pueda lanzar.

    const onPlayerError: YouTubeProps["onError"] = (event) => {
      console.error("Error del reproductor de YouTube:", event.data);
      // Puedes manejar diferentes códigos de error aquí
    };
    
    // Y en el componente YouTube
    <YouTube
      videoId={currentSong.youtubeId}
      opts={opts}
      onReady={onPlayerReady}
      onEnd={onPlayerEnd}
      onStateChange={onPlayerStateChange}
      onError={onPlayerError} // Añade este manejador
    />
    

    Resumen:

    • Eliminar .catch y .then: No intentes encadenar métodos de Promesa a funciones que no retornan Promesas.
    • Usar try-catch: Si deseas manejar posibles errores de funciones síncronas, utiliza bloques try-catch.
    • Manejadores de Eventos: Utiliza los eventos proporcionados por la API de YouTube para manejar errores y otros estados del reproductor.

    Código Completo Actualizado:

    Aquí tienes una versión revisada de las partes relevantes de tu componente con las correcciones aplicadas:

    import React, { useState, useEffect, useRef } from "react";
    import YouTube, { YouTubeProps, YouTubePlayer } from "react-youtube";
    // ... (otros imports)
    
    // ... (definición de interfaces y datos)
    
    const SpotifyClone = () => {
      // ... (tus estados y referencias)
    
      const onPlayerReady: YouTubeProps["onReady"] = (event) => {
        playerRef.current = event.target;
        setDuration(event.target.getDuration());
    
        event.target.setVolume(volume);
    
        if (isPlaying) {
          try {
            event.target.playVideo();
          } catch (error) {
            console.error("Error intentando reproducir el video:", error);
          }
        }
      };
    
      const onPlayerEnd: YouTubeProps["onEnd"] = () => {
        handleNextSong();
      };
    
      const onPlayerError: YouTubeProps["onError"] = (event) => {
        console.error("Error del reproductor de YouTube:", event.data);
        // Manejar diferentes códigos de error si es necesario
      };
    
      const onPlayerStateChange: YouTubeProps["onStateChange"] = (event) => {
        if (event.data === window.YT.PlayerState.ENDED) {
          handleNextSong();
        } else if (
          (event.data === window.YT.PlayerState.CUED ||
            event.data === window.YT.PlayerState.BUFFERING) &&
          isPlaying
        ) {
          try {
            playerRef.current?.playVideo();
          } catch (error) {
            console.error("Error intentando reproducir el video:", error);
          }
        }
      };
    
      // Opciones del reproductor de YouTube
      const opts: YouTubeProps["opts"] = {
        height: "0",
        width: "0",
        playerVars: {
          autoplay: 0,
          controls: 0,
          disablekb: 1,
          fs: 0,
          modestbranding: 1,
          rel: 0,
        },
      };
    
      const ensurePlayback = () => {
        if (isPlaying && playerRef.current) {
          try {
            playerRef.current.playVideo();
            console.log("Reproducción iniciada automáticamente.");
          } catch (error) {
            console.error("Error al intentar reproducir automáticamente:", error);
          }
        }
      };
    
      useEffect(() => {
        if (currentSong && isPlaying) {
          const timeoutId = setTimeout(() => {
            ensurePlayback();
          }, 1000);
    
          return () => clearTimeout(timeoutId);
        }
      }, [currentSong, isPlaying]);
    
      return (
        <div className="flex flex-col h-screen text-gray-300 bg-black">
          {currentSong?.youtubeId && (
            <YouTube
              videoId={currentSong.youtubeId}
              opts={opts}
              onReady={onPlayerReady}
              onEnd={onPlayerEnd}
              onStateChange={onPlayerStateChange}
              onError={onPlayerError} // Añade el manejador de errores
            />
          )}
    
          {/* ... (resto del componente) */}
        </div>
      );
    };
    
    export default SpotifyClone;
    

    Conclusión:

    Al realizar estos cambios, evitarás el error TypeError: playerRef.current.playVideo(...).catch is not a function y mejorarás el manejo de errores en tu aplicación. Recuerda siempre verificar la documentación de las APIs que utilizas para entender qué tipos de respuestas y manejadores de errores soportan.

    Si tienes alguna otra duda o necesitas más ayuda, ¡no dudes en preguntar!


    Referencias:


    ¡Espero que esto te ayude a resolver el problema!

    Saludos,

    ChatGPT