Kurs vibe coding z Claude Code · Moduł 11: Klon Spotify
Odtwarzacz i kolejka: polecenie z kryterium ukończenia
W tej lekcji9
Ahoj! Załoga śpiewa szanty przy każdej wachcie, a nagrania leżą w folderze na pokładowym komputerze i każde trzeba włączać ręcznie. W tej lokacji budujesz Sea Shanty Sounds, klon Spotify: odtwarzacz z kolejką, playlisty i wyszukiwarkę. Zaczynasz od odtwarzacza, bo to najzdradliwszy kawałek klonu. Wygląda na gotowy po pierwszym kliknięciu Graj, a kłopoty zaczynają się dopiero wtedy, gdy utwór skończy się sam.
Czego się nauczysz
- dopisać do polecenia kryterium ukończenia, które Claude sprawdzi sam;
- przeczytać w Cursorze odtwarzacz, którego stan słucha zdarzeń audio, a nie kliknięć;
- rozpoznać dwa źródła prawdy i przycisk, który pokazuje "Pauza", choć nic nie gra;
- zadać pytanie poboczne przez
/btw, które nie zaśmieca rozmowy.
Nowy port: projekt sea-shanty-sounds
Sea Shanty Sounds to osobna aplikacja, więc zakładasz ją poleceniem z lekcji 1_2, zmieniając tylko nazwę. Zanim klikniesz Yes, porównaj komendę z tą:
npx create-next-app@latest sea-shanty-sounds --ts --eslint --tailwind --app --no-src-dir --no-cache-components --agents-md --no-agent-feedback --use-npmDalej znana pętla: sesja w folderze sea-shanty-sounds, CLAUDE.md z importem @AGENTS.md, Vitest z poprawką @types/node z lekcji 4_1 i pierwszy commit. Do odtwarzacza potrzebujesz kilku plików dźwiękowych w public/audio/. Jeśli masz program ffmpeg, poproś Claude o cztery pliki MP3 z czystym tonem, każdy o innej wysokości i długości, a pierwszy dokładnie na 125 sekund. Bez ffmpeg poproś o te same tony w plikach WAV: to prosty format, który Claude zapisze krótkim skryptem Node.js bez dodatkowych programów, a element <audio> odtwarza go w głównych przeglądarkach. Inny ton w każdym pliku pozwoli Ci usłyszeć, który utwór gra.
Kryterium ukończenia
Dobre praktyki Claude Code mówią wprost, że Claude kończy pracę, gdy wygląda ona na skończoną. Jeśli nie ma niczego, co odpowie "zalicza" albo "nie zalicza", to Ty zostajesz jego jedynym sprawdzianem. Odtwarzacz to idealny przykład: po kliknięciu Graj wszystko działa, a błąd ujawnia się po dwóch minutach, gdy utwór się kończy.
Dlatego polecenie kończy się listą warunków pod hasłem "Będzie gotowe, gdy:". Każdy warunek da się sprawdzić testem albo komendą, a nie oceną "wygląda dobrze". Dokumentacja wymienia to jako pierwszy, najmniej rygorystyczny sposób: warunek w samym poleceniu, a Claude sam ocenia, kiedy jest spełniony, więc i tak prosisz o dowód. Mocniejsze stopnie poznasz w lekcji 10_4. Krok jest duży, więc zaczynasz od planu, jak w lekcji 1_6.
Polecenie dla Claude Code:
/plan Zbuduj odtwarzacz Sea Shanty Sounds. Typy Track, Artist i Album
w types/music.ts, cztery utwory z public/audio w lib/catalog.ts,
komponenty components/MusicPlayer.tsx i components/Queue.tsx:
graj i pauza, poprzedni i następny, pasek postępu z przewijaniem,
głośność, wyciszenie, losowo i powtarzanie (wył., wszystko, jeden).
Kolejka pokazuje, co gra i co będzie następne. Losowo i powtarzanie
trzymaj w jednym miejscu, czas formatuj jedną funkcją w lib/format.ts.
Będzie gotowe, gdy:
1. formatTime(125) zwraca "2:05", a formatTime(NaN) zwraca "0:00";
2. przycisk pokazuje "Pauza" tylko wtedy, gdy audio naprawdę gra,
także gdy utwór skończy się sam albo audio zatrzyma się bez
kliknięcia w przycisk;
3. po końcu utworu gra następny, a przy powtarzaniu wszystkiego
po ostatnim gra pierwszy;
4. odrzucone play() pokazuje komunikat zamiast udawać, że gra.
Warunki 1-4 sprawdź testami Vitest, potem npm run lint,
npx tsc --noEmit i npm run build. Pokaż komendy i ich wyniki.Warunek 2 to haczyk. Najprostszy kod, jaki agent może napisać, przełącza napis na przycisku przy kliknięciu, więc warunek 2 wymusza inny projekt: stan odtwarzacza ma wynikać z tego, co robi element <audio>. Przeczytaj plan i sprawdź, czy mówi, skąd przycisk wie, że utwór się skończył. Jeśli chcesz pełnej dyscypliny z lekcji 4_1, dopisz jeszcze: "Najpierw napisz testy warunków 1-4 i pokaż, że padają".
Co napisał Claude: typy i jeden formater
Otwórz w Cursorze types/music.ts. Utwór ma wykonawcę i album jako obiekty, ścieżkę do pliku i długość w sekundach:
export interface Track {
id: string;
title: string;
artist: Artist;
album: Album;
src: string; // "/audio/hymn.mp3"
duration: number; // w sekundach
genre: Genre;
}genre to gatunek z krótkiej listy, a przyda się w lekcji 10_3 przy poleceniach. Czas na ekranie przechodzi przez jedną funkcję z lib/format.ts:
export function formatTime(seconds: number): string {
if (!Number.isFinite(seconds) || seconds < 0) return "0:00";
const whole = Math.floor(seconds);
const minutes = Math.floor(whole / 60);
const rest = whole % 60;
return `${minutes}:${String(rest).padStart(2, "0")}`;
}padStart(2, "0") dopisuje zero z przodu, więc 5 sekund to "05". Pierwsza linia nie jest przesadną ostrożnością: według MDN właściwość duration elementu audio zwraca NaN, dopóki przeglądarka nie wczyta danych pliku, a dla transmisji na żywo Infinity. Bez tej linii pasek pokazałby "NaN:NaN". U nas test zwrócił "2:05" dla 125 sekund i "0:00" dla NaN.
Co napisał Claude: stan słucha audio
Otwórz components/MusicPlayer.tsx. Najważniejszy jest efekt, który podpina się pod zdarzenia elementu <audio>, czyli komunikaty, które odtwarzacz wysyła sam:
useEffect(() => {
const audio = audioRef.current;
if (!audio) return;
const syncPlaying = () => setIsPlaying(!audio.paused);
const syncTime = () => setCurrentTime(audio.currentTime);
audio.addEventListener("play", syncPlaying);
audio.addEventListener("pause", syncPlaying);
audio.addEventListener("emptied", syncPlaying);
audio.addEventListener("timeupdate", syncTime);
return () => {
audio.removeEventListener("play", syncPlaying);
audio.removeEventListener("pause", syncPlaying);
audio.removeEventListener("emptied", syncPlaying);
audio.removeEventListener("timeupdate", syncTime);
};
}, []);isPlaying zmienia się tylko tutaj, zawsze na to, co mówi audio.paused. Według MDN zdarzenie pause przychodzi, gdy paused ma już wartość true, a timeupdate kilka razy na sekundę w trakcie grania (MDN podaje od około 4 do 66 razy). Na końcu utworu przychodzi najpierw pause, potem ended: tak opisuje to specyfikacja HTML i tak było w naszej przeglądarce. emptied ma swój powód: przy zmianie pliku przeglądarka zatrzymała stary utwór bez zdarzenia pause, wysłała tylko abort i emptied. Wersja bez emptied po przejściu do uszkodzonego pliku pokazywała u nas "Pauza", choć nic nie grało.
return z funkcją sprzątającą odpina każdego słuchacza, gdy odtwarzacz znika ze strony. Prawdziwy kod ma jeszcze słuchacza loadedmetadata, który zapisuje długość utworu, gdy przeglądarka ją pozna.
Co napisał Claude: przycisk tylko prosi
Przycisk Graj nie ustawia stanu. Prosi element audio o zmianę, a stan dogoni rzeczywistość przez zdarzenia:
function togglePlay() {
const audio = audioRef.current;
if (!audio) return;
if (audio.paused) {
setAutoPlay(true);
audio.play().catch(() => setError("Przeglądarka nie pozwoliła odtworzyć utworu. Kliknij Graj jeszcze raz."));
} else {
audio.pause();
}
}Według MDN play() zwraca obietnicę, którą przeglądarka odrzuca, gdy nie pozwala grać, na przykład błędem NotAllowedError, a strona nie powinna pokazywać interfejsu, który zakłada, że odtwarzanie ruszyło. Znasz to z feedu w lekcji 9_1. Tu odrzucenie zostawia napis Graj, bo zdarzenie play nie przyszło, i pokazuje komunikat. autoPlay to stan atrybutu autoPlay na <audio>: od pierwszego kliknięcia Graj każdy nowy utwór startuje sam, gdy przeglądarka go wczyta.
Co napisał Claude: kolejka i powtarzanie
Tryby powtarzania i wybór następnego utworu siedzą w czystych funkcjach w lib/queue.ts, więc łatwo je przetestować. Typ RepeatMode powstaje z tablicy trybów: as const zostawia w niej trzy dokładne napisy, a (typeof REPEAT_MODES)[number] zbiera je w typ "off" | "all" | "one", więc funkcja nie przyjmie literówki:
export const REPEAT_MODES = ["off", "all", "one"] as const;
export type RepeatMode = (typeof REPEAT_MODES)[number];
export function nextIndex(current: number, length: number, repeat: RepeatMode): number | null {
if (current + 1 < length) return current + 1;
return repeat === "all" ? 0 : null;
}Przycisk powtarzania przechodzi po tablicy w kółko: wył., wszystko, jeden i znowu wył. null znaczy "koniec kolejki, nic więcej nie gra", a przy powtarzaniu wszystkiego po ostatnim utworze wraca indeks 0. Powtarzanie jednego utworu robi sama przeglądarka przez atrybut loop={repeat === "one"}. MDN pisze, że przy włączonym loop zdarzenie ended w ogóle nie przychodzi: u nas utwór na końcu wrócił na początek bez pause i bez ended.
Losowania w nextIndex nie ma i tak ma zostać. W tym samym pliku leży funkcja shuffled, która tasuje kopię listy i nie rusza oryginału, co sprawdza osobny test. Kliknięcie Losowo stawia grający utwór na początku kolejki, za nim tasuje resztę i ustawia indeks 0, więc muzyka się nie przerywa, a nextIndex dalej idzie po kolei. Drugie kliknięcie przywraca kolejność z katalogu i odnajduje w niej grający utwór. Tego szukaj, gdy czytasz kod: losowanie zmienia kolejkę raz, a nie wybiera nowego utworu przy każdym końcu, bo wtedy ten sam utwór mógłby zagrać dwa razy z rzędu.
Przejście po końcu utworu obsługuje osobny efekt:
useEffect(() => {
const audio = audioRef.current;
if (!audio) return;
function handleEnded() {
const next = nextIndex(index, queue.length, repeat);
if (next !== null) setIndex(next);
}
audio.addEventListener("ended", handleEnded);
return () => audio.removeEventListener("ended", handleEnded);
}, [index, queue.length, repeat]);Zależności to zwykłe liczby i napis, więc efekt podpina świeżego słuchacza tylko wtedy, gdy zmieni się utwór, długość kolejki albo tryb. Stan losowania i powtarzania żyje tylko w MusicPlayer. Queue dostaje kolejkę i indeks w propsach, pokazuje "Teraz gra" i listę "Następne", czyli queue.slice(index + 1), a przycisk Usuń stoi tylko przy utworach, które dopiero będą grać. Usunięcie ich nie przesuwa więc indeksu tego, co gra. Głośność to suwak od 0 do 1, bo według MDN volume przyjmuje właśnie taki zakres.
Przegląd kapitana
- Stan z kliknięcia. Typowy błąd agenta to
setIsPlaying(!isPlaying)wtogglePlayi ani jednego słuchaczaplayipause. U nas taka wersja przeszła lint itsc, a test z warunku 2 oblał:Unable to find role="button" and name "Graj". Wyszukaj w pliku (Cmd+F na Macu, Ctrl+F na Windowsie)setIsPlaying(: jedyne trafienie ma stać w słuchaczu zdarzeń. - Jedno źródło prawdy. Wyszukaj w projekcie (Cmd+Shift+F)
useState<RepeatMode>. Dwa trafienia, na przykład wMusicPlayeri w rodzicu z funkcjąonRepeat, to dwie kopie tego samego stanu: przycisk pokazuje jedno, a odtwarzacz robi drugie. - Sprzątanie. Każde
addEventListenerw efekcie ma swojeremoveEventListenerwreturn. Policz trafienia obu nazw. - Jeden formater.
padStartznajdziesz tylko wlib/format.ts. Drugi, prawie taki sam formater wQueue.tsxto kopia, która kiedyś zacznie liczyć inaczej. - Dowód. Wynik testów i buildu w odpowiedzi Claude to pierwszy dowód, a drugi sprawdzasz w przeglądarce. Uruchom
npm run dev, kliknij Graj, otwórz narzędzia deweloperskie i w konsoli wpiszdocument.querySelector("audio").pause(). Przycisk ma zmienić się na Graj, choć go nie kliknąłeś.
Te punkty wrócą przy każdym kolejnym odtwarzaczu. Jeśli powtarzasz je trzeci raz, zapisz je jako własnego subagenta recenzenta, tak jak video-reviewer z lekcji 9_5.
Następny krok
Jeśli w kodzie coś Cię zdziwiło, nie musisz dokładać tego do rozmowy. Dokumentacja Claude Code opisuje /btw jako pytanie o bieżącą pracę, które nie trafia do historii rozmowy:
/btw dlaczego efekt z handleEnded ma zależności [index, queue.length, repeat]?Claude odpowiada z tego, co już jest w rozmowie, czyli z kodu, który sam napisał. Nie ma przy tym narzędzi: nie czyta plików i nie uruchamia komend. Odpowiedź pojawia się w nakładce, którą zamykasz spacją, Enterem albo Escape, a /btw działa nawet wtedy, gdy Claude jest w trakcie pracy. Gdy potrzebujesz czegoś nowego z projektu, potrzebujesz subagenta, a do tego wrócisz w lekcji 10_3.
Gdy testy i przeglądarka się zgadzają, poproś o commit, na przykład "Odtwarzacz i kolejka". W edytorze poniżej czeka odtwarzacz w miniaturze z udawanym dźwiękiem, który liczy sekundy. Zakończ utwór przyciskiem, zatrzymaj go "z zewnątrz", a potem włącz błąd agenta i porównaj napis na przycisku z tym, co naprawdę gra.
Zapamiętaj: pozytywka kapitana gra, dopóki ktoś słucha nuty, a nie dopóki trybiki ładnie wyglądają, a przycisk odtwarzacza ma mówić to, co słychać, a nie to, co ktoś kliknął.
Kod do tej lekcji: App.jsx
// Odtwarzacz w miniaturze: udawane audio liczy sekundy i wysyła zdarzenia jak <audio>
import { useEffect, useState } from 'react';
const tracks = [
{ id: 't1', title: 'Hymn piratów', duration: 8 },
{ id: 't2', title: 'Werble bitewne', duration: 6 },
{ id: 't3', title: 'Szanta o wyspie', duration: 10 },
{ id: 't4', title: 'Pieśń krakena', duration: 5 },
];
const REPEAT_MODES = ['off', 'all', 'one'];
const REPEAT_LABELS = { off: 'Powtarzanie: wył.', all: 'Powtarzanie: wszystko', one: 'Powtarzanie: jeden' };
// Jeden formater czasu dla całego odtwarzacza
function formatTime(seconds) {
if (!Number.isFinite(seconds) || seconds < 0) return '0:00';
const whole = Math.floor(seconds);
return `${Math.floor(whole / 60)}:${String(whole % 60).padStart(2, '0')}`;
}
function nextIndex(current, length, repeat) {
if (current + 1 < length) return current + 1;
return repeat === 'all' ? 0 : null;
}
export default function App() {
const [index, setIndex] = useState(0);
const [audio, setAudio] = useState({ paused: true, time: 0 }); // udawany element <audio>
const [isPlaying, setIsPlaying] = useState(false); // to, co pokazuje przycisk
const [autoPlay, setAutoPlay] = useState(false);
const [repeat, setRepeat] = useState('off');
const [log, setLog] = useState([]);
const [error, setError] = useState('');
const [agentBug, setAgentBug] = useState(false);
const [blockPlay, setBlockPlay] = useState(false);
const track = tracks[index];
// Zdarzenie z udawanego audio. Bez błędu agenta przycisk słucha play, pause i emptied.
function emit(name, paused) {
setLog((l) => [`${name} (paused = ${paused})`, ...l].slice(0, 8));
if (!agentBug && ['play', 'pause', 'emptied'].includes(name)) setIsPlaying(!paused);
}
function playAudio() {
if (blockPlay) {
// play() odrzucone (NotAllowedError): żadnego zdarzenia play
if (!agentBug) setError('Przeglądarka nie pozwoliła odtworzyć utworu. Kliknij Graj jeszcze raz.');
return;
}
setError('');
setAutoPlay(true);
setAudio((a) => ({ ...a, paused: false }));
emit('play', false);
}
function pauseAudio() {
setAudio((a) => ({ ...a, paused: true }));
emit('pause', true);
}
function startTrack(i, play) {
setIndex(i);
emit('emptied', true); // zmiana pliku: paused = true bez zdarzenia pause
if (play && !blockPlay) {
setAudio({ paused: false, time: 0 });
emit('play', false);
} else {
setAudio({ paused: true, time: 0 });
}
}
function togglePlay() {
if (agentBug) {
// błąd agenta: przycisk przełącza napis sam i nie słucha audio
if (isPlaying) pauseAudio();
else playAudio();
setIsPlaying(!isPlaying);
return;
}
if (audio.paused) playAudio();
else pauseAudio();
}
// Zegar udawanego audio: co sekundę dolicza czas, na końcu utworu wysyła pause i ended
useEffect(() => {
if (audio.paused) return;
const id = setTimeout(() => {
const time = audio.time + 1;
if (time < track.duration) {
setAudio({ paused: false, time });
} else if (repeat === 'one') {
setAudio({ paused: false, time: 0 }); // loop: bez pause i bez ended
} else {
setAudio({ paused: true, time: track.duration });
emit('pause', true);
emit('ended', true);
const next = nextIndex(index, tracks.length, repeat);
if (next !== null) startTrack(next, autoPlay);
}
}, 1000);
return () => clearTimeout(id);
}, [audio, index, repeat, agentBug, autoPlay, blockPlay]);
const reallyPlaying = !audio.paused;
const lying = isPlaying !== reallyPlaying;
return (
<div className="min-h-screen bg-gray-950 p-4 text-white">
<div className="mx-auto max-w-xl space-y-4">
<div className="rounded-xl bg-gray-900 p-4">
<p className="text-lg font-semibold">{track.title}</p>
<div className="mt-3 flex flex-wrap items-center gap-2">
<button type="button" onClick={() => startTrack(Math.max(0, index - 1), autoPlay)} className="rounded bg-gray-700 px-3 py-1">Poprzedni</button>
<button type="button" onClick={togglePlay} className="rounded-full bg-white px-5 py-2 font-semibold text-black">
{isPlaying ? 'Pauza' : 'Graj'}
</button>
<button type="button" onClick={() => { const n = nextIndex(index, tracks.length, repeat); if (n !== null) startTrack(n, autoPlay); }} className="rounded bg-gray-700 px-3 py-1">Następny</button>
<button type="button" onClick={() => setRepeat(REPEAT_MODES[(REPEAT_MODES.indexOf(repeat) + 1) % REPEAT_MODES.length])} className="rounded bg-gray-700 px-3 py-1 text-sm">
{REPEAT_LABELS[repeat]}
</button>
</div>
<p className="mt-3 text-sm text-gray-300">
{formatTime(audio.time)} / {formatTime(track.duration)}
</p>
{error && <p className="mt-2 text-sm text-red-400">{error}</p>}
</div>
<div className={`rounded-xl p-3 text-sm ${lying ? 'bg-red-900' : 'bg-gray-800'}`}>
<p>Audio naprawdę: <strong>{reallyPlaying ? 'gra' : 'stoi'}</strong>. Przycisk mówi: <strong>{isPlaying ? 'Pauza' : 'Graj'}</strong>.</p>
{lying && <p className="mt-1 font-semibold">Przycisk kłamie: pokazuje coś innego, niż słychać.</p>}
</div>
<div className="flex flex-wrap gap-2 text-sm">
<button type="button" onClick={() => setAudio((a) => ({ ...a, time: Math.max(0, track.duration - 2) }))} className="rounded bg-gray-700 px-3 py-1">Przewiń pod koniec</button>
<button type="button" onClick={pauseAudio} className="rounded bg-gray-700 px-3 py-1">Zatrzymaj z zewnątrz</button>
</div>
<div className="rounded-xl bg-gray-900 p-3 text-sm">
<p className="text-gray-400">Teraz gra</p>
<p>{track.title}</p>
<p className="mt-2 text-gray-400">Następne</p>
{tracks.slice(index + 1).length === 0 && <p className="text-gray-500">Kolejka jest pusta.</p>}
<ol>
{tracks.slice(index + 1).map((t, i) => (
<li key={t.id}>
<button type="button" onClick={() => startTrack(index + 1 + i, true)} className="hover:underline">
{t.title} ({formatTime(t.duration)})
</button>
</li>
))}
</ol>
</div>
<div className="space-y-1 text-sm">
<label className="flex items-center gap-2">
<input type="checkbox" checked={agentBug} onChange={(e) => setAgentBug(e.target.checked)} />
Błąd agenta: setIsPlaying(!isPlaying) zamiast zdarzeń
</label>
<label className="flex items-center gap-2">
<input type="checkbox" checked={blockPlay} onChange={(e) => setBlockPlay(e.target.checked)} />
Przeglądarka odrzuca play() (NotAllowedError)
</label>
</div>
<div className="rounded-xl bg-black p-3 font-mono text-xs text-green-400">
<p className="text-gray-400">Zdarzenia audio (najnowsze na górze):</p>
{log.map((line, i) => <p key={i}>{line}</p>)}
</div>
</div>
</div>
);
}Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Po co polecenie dla Claude Code kończy się listą "Będzie gotowe, gdy:"?
2. Co zwraca formatTime(NaN) w odtwarzaczu z lekcji i skąd bierze się NaN?
To 2 z 7 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż w jednej linii wywołanie odtwarzania z obsługą odrzucenia:
- Układanie w poziomie
Ułóż w jednej linii wyliczenie utworów, które zagrają po bieżącym:
- Edytor kodu
Music player component
- Klikanie w kolejności
Kliknij elementy, aby zbudować warunek z togglePlay, który sprawdza, czy audio stoi:
- Klikanie w kolejności
Kliknij elementy, aby zbudować funkcję, która ustawia stan przycisku według elementu audio:
- Układanie w poziomie
Ułóż w jednej linii ustawienie głośności elementu audio na połowę:
- Układanie w pionie
Uporządkuj tryby powtarzania tak, jak stoją w tablicy REPEAT_MODES, po której chodzi przycisk:
- Układanie w poziomie
Ułóż w jednej linii zwrot wyniku z formatTime:
- Klikanie w kolejności
Kliknij elementy, aby podłączyć nasłuchiwanie postępu:
- Edytor kodu
Queue management interface
- Układanie w pionie
Uporządkuj, co dzieje się na końcu utworu przy powtarzaniu wyłączonym, gdy w kolejce jest następny:
- Układanie w pionie
Uporządkuj linie efektu, który przechodzi do następnego utworu:
Zadania po tej lekcji
- PytanieKryterium ukończenia
- PytanieDługość nieznanego utworu
- Ułóż w kolejnościplay() z obsługą odrzucenia
- Ułóż w kolejnościLista Następne w kolejce
- Zadanie z kodemPraktyka: Music player UI
- PytaniePrzycisk Graj tylko prosi
- Kliknij w kolejnościWarunek audio.paused
- Kliknij w kolejnościStan z audio.paused
- PytaniePytanie poboczne /btw
- Ułóż w kolejnościGłośność od 0 do 1
- Ułóż w kolejnościKolejność trybów powtarzania
- PytaniePowtarzanie wszystkiego
- Ułóż w kolejnościSekundy z zerem z przodu
- Kliknij w kolejnościZbuduj addEventListener timeupdate
- Zadanie z kodemPraktyka: Queue component
- PytaniePowtarzanie jednego utworu
- Ułóż w kolejnościKoniec utworu krok po kroku
- Ułóż w kolejnościEfekt ze słuchaczem ended
- PytanieUsuwanie z kolejki