Cours Vibe coding avec Claude Code · Module 6: Clone de YouTube

La taverne sous le film : commentaires avec horodatages

8 min de lecture ·
Dans cette leçon8

Sous le film du Kraken, les spectateurs écrivent « le meilleur moment est à 1:23 » et chacun qui le lit fait glisser le curseur en devinant où se trouve 1:23. Sur YouTube, un tel horodatage dans un commentaire est cliquable : un clic et le film saute à l'endroit indiqué. Dans cette leçon, Claude Code construit des commentaires sous le film avec de tels horodatages, et toi, tu vérifies que le texte d'un spectateur se transforme en boutons sans laisser monter son HTML à bord.

Des motifs connus, une cargaison nouvelle

Tu reprends trois règles des modules précédents sans les réapprendre. La liste des commentaires vit dans un seul composant et la carte ne fait que l'afficher, comme les données communes de la leçon 2_3. La fonction pure reçoit ses tests avant le code, comme dans la leçon 4_1. Le texte d'un utilisateur arrive dans le JSX comme du texte simple, sans dangerouslySetInnerHTML, comme pour le markdown du module 4. Les réponses en fils, tu les as construites avec le clone de Reddit, donc ici les commentaires sont à plat, et toute la nouveauté, ce sont les horodatages.

Demande pour Claude Code

Le changement touche la page du film, le lecteur et une nouvelle section, donc tu commences par un plan :

/plan Ajoute des commentaires sous le film sur /watch/[id]. Un type
VideoComment dans lib/comments.ts avec quelques commentaires pour le
premier film, la liste dans un seul composant CommentsSection avec
un formulaire et un bouton J'aime (toggleId de @lib/toggle.ts). Les
horodatages dans le texte, comme 1:23 ou 1:02:05, doivent être des
boutons qui font avancer le lecteur et lancent le film. Le parseur
est une fonction pure dans lib/timestamps.ts, les tests d'abord :
heures, 1:75, durée plus longue que le film, balises HTML dans le
texte. Le texte seulement en texte, sans dangerouslySetInnerHTML. Les
films YouTube restent sans déplacement dans la vidéo. À la fin,
tests, lint et build.

Dans le plan, tu cherches trois choses : le parseur renvoie des données et non du HTML tout fait ; la liste des commentaires a un seul foyer ; il y a une idée pour qu'un commentaire en bas de la page atteigne le lecteur tout en haut.

Ce que Claude a écrit : le parseur avec ses tests

Ouvre lib/timestamps.test.ts dans Cursor. Les tests décrivent les règles avant que le code existe :

it("gère les heures", () => {
  expect(parseTimestamp("1:02:05")).toBe(3725);
});

it("une durée plus longue que le film reste du texte", () => {
  expect(splitTimestamps("Au port à 12:30", 596)).toEqual([
    { kind: "text", text: "Au port à 12:30" },
  ]);
});

parseTimestamp transforme un texte en nombre de secondes, et pour "1:75" il renvoie null, parce qu'une minute a 60 secondes. splitTimestamps reçoit le texte du commentaire et la durée du film, et renvoie une liste de morceaux. Le second test surveille un cas que l'agent oublie d'habitude : Big Buck Bunny dure 9:56, soit 596 secondes, donc « 12:30 » est une heure au port et non un endroit du film. Un autre test passe "<b>0:10</b>" et attend que <b> reste un morceau de texte. Un morceau a l'une de deux formes, et le champ kind dit laquelle, comme VideoSource de la leçon 5_1 :

export type CommentPart =
  | { kind: "text"; text: string }
  | { kind: "time"; text: string; seconds: number };

La fonction cherche les horodatages avec l'expression régulière /\b(?:(\d{1,2}):)?(\d{1,2}):(\d{2})\b/g : des heures facultatives, des minutes et toujours deux chiffres de secondes. Chaque occurrence passe par parseTimestamp et par la comparaison avec la durée du film, et le texte entre les occurrences reste un morceau text. La fonction ne sait rien de React ni du lecteur, c'est pourquoi six tests passent en quelques millisecondes.

Ce que Claude a écrit : les morceaux en texte et en boutons

Ouvre components/CommentText.tsx. Le composant dessine les morceaux l'un après l'autre :

{parts.map((part, index) =>
  part.kind === "time" ? (
    <button key={index} type="button" onClick={() => onSeek?.(part.seconds)}>
      {part.text}
    </button>
  ) : (
    <span key={index}>{part.text}</span>
  ),
)}

L'horodatage est un vrai <button>, donc tu y arrives avec la touche Tab et tu l'actives avec Entrée. Le texte simple va dans un <span> comme texte : React affiche les signes < et > comme des lettres, donc un <img> dans un commentaire reste une inscription et non une image avec un script. L'indice comme key suffit, parce que les morceaux d'un même commentaire ne changent pas d'ordre. Quand onSeek n'est pas fourni, le composant ne découpe pas du tout le texte et tout le commentaire est un seul morceau.

Comment un commentaire atteint le lecteur

Le lecteur se trouve en haut de la page et les commentaires en bas. Leur parent commun est un nouveau Client Component components/WatchView.tsx, qui détient le ref vers l'élément <video> :

const videoRef = useRef<HTMLVideoElement>(null);

const seekTo = (seconds: number) => {
  const player = videoRef.current;
  if (!player) return;
  player.currentTime = seconds;
  player.play().catch(() => undefined);
  player.scrollIntoView({ behavior: "smooth", block: "center" });
};

Selon MDN, currentTime est la position actuelle en secondes, et lui attribuer une nouvelle valeur fait avancer le film. play() renvoie une promesse que le navigateur peut rejeter quand il ne permet pas la lecture, et MDN conseille de s'y préparer ; .catch laisse alors le film à l'arrêt sans erreur dans la console. scrollIntoView fait défiler la page jusqu'au lecteur, parce qu'un commentaire est parfois loin sous le film.

Dans React 19, ref est une prop ordinaire, donc VideoPlayer la reçoit et la transmet à <video ref={ref}>. WatchView dessine le lecteur, puis children avec le titre et la description venus de la page serveur, et enfin CommentsSection avec onSeek={video.source.kind === "file" ? seekTo : undefined}. Le cadre YouTube est la page d'un autre et notre ref ne l'atteint pas, c'est pourquoi les horodatages y restent du texte.

La liste en un seul endroit

components/CommentsSection.tsx détient les commentaires et les mentions J'aime, et la carte ne retient rien d'elle-même :

const [comments, setComments] = useState<VideoComment[]>(() => getComments(videoId));
const [likedIds, setLikedIds] = useState<string[]>([]);
// dans la carte du commentaire
const isLiked = likedIds.includes(comment.id);
// compteur : comment.likes + (isLiked ? 1 : 0)

Le useState paresseux lit une seule fois les commentaires du film, au premier rendu. Les mentions J'aime forment une liste d'identifiants basculée par toggleId de la leçon 5_2, et le compteur se calcule au rendu, donc il n'y a pas de deuxième état avec un nombre qui pourrait diverger. Un nouveau commentaire reçoit son id de crypto.randomUUID() et sa date seulement au clic sur Ajouter. Le type s'appelle VideoComment et non Comment : le navigateur a un type intégré Comment, donc un fichier qui oublie l'import reçoit le type d'un autre. Chez nous, npx tsc --noEmit a alors signalé Property 'author' does not exist on type 'Comment'.

La revue du capitaine

Lance npm run dev et ouvre le premier film :

  1. HTML dans un commentaire. Le raccourci typique d'un agent est text.replace(...), qui colle un <button> dans le texte, avec dangerouslySetInnerHTML pour l'afficher. Ça marche dès le premier clic, et avec les horodatages, il laisse entrer sur la page le HTML de n'importe quel spectateur. Cherche dangerouslySetInnerHTML dans le projet, dans Cursor : il doit y avoir zéro résultat. Ajoute ensuite le commentaire <img src=x onerror="alert(1)"> regarde 0:10. Chez nous, une inscription est apparue à l'écran, et 0:10 était un bouton.
  2. Clique et regarde le compteur. Après un clic sur 1:23, le compteur de temps du lecteur doit afficher 1:23 et continuer. Le commentaire de Morgan avec « 12:30 » doit rester du texte simple, tout comme « 1:75 ».
  3. Le clavier. Va jusqu'à l'horodatage avec la touche Tab et appuie sur Entrée. Un <span onClick> dans le diff est un horodatage que ne pourra pas utiliser une personne sans souris.
  4. Un film YouTube. Sur la page d'un film avec cadre, le commentaire « Ça devient intéressant à partir de 0:10 » doit rester du texte. Un bouton qui ne fait rien est pire que pas de bouton.

Étape suivante

Avant le commit, lance /code-review de la leçon 2_9, puis demande un commit, par exemple « Commentaires avec horodatages ». Une autre petite étape :

Ajoute près du champ de commentaire un bouton « Insérer l'heure »
qui ajoute au texte la position actuelle du film au format
formatTime. Transmets la lecture de la position depuis WatchView,
seulement pour les films de fichier.

Claude a donné à CommentsSection la prop getCurrentTime : une fonction qui lit videoRef.current.currentTime seulement au clic, et non au rendu. Chez nous, après l'arrêt du film à la 46e seconde, le champ a reçu « 0:46 ». Dans l'éditeur ci-dessous t'attend la taverne en miniature : clique sur un horodatage dans un commentaire, insère ton propre temps et essaie de faire passer un <b> dans le texte.

Retiens : dans la taverne, le spectateur peut écrire n'importe quoi, mais le capitaine ne hisse au mât que du texte, et il ne transforme un nombre en cap que s'il tient sur la carte du film.

Code de cette leçon : App.jsx
// La taverne sous le film : des commentaires dont les horodatages font avancer le film.
// parseTimestamp et splitTimestamps sont les mêmes fonctions que dans lib/timestamps.ts.
import { useRef, useState } from 'react';

const DURATION = 596; // Big Buck Bunny dure 9:56
const SRC = 'https://archive.org/download/BigBuckBunny_124/Content/big_buck_bunny_720p_surround.mp4';
const TIMESTAMP = /\b(?:(\d{1,2}):)?(\d{1,2}):(\d{2})\b/g;

function parseTimestamp(value) {
  const match = /^(?:(\d{1,2}):)?(\d{1,2}):(\d{2})$/.exec(value);
  if (!match) return null;
  const [, hours, minutes, seconds] = match;
  if (Number(seconds) > 59 || (hours !== undefined && Number(minutes) > 59)) return null;
  return Number(hours ?? 0) * 3600 + Number(minutes) * 60 + Number(seconds);
}

function splitTimestamps(text, duration) {
  const parts = [];
  let last = 0;
  for (const match of text.matchAll(TIMESTAMP)) {
    const seconds = parseTimestamp(match[0]);
    if (seconds === null || seconds > duration) continue;
    if (match.index > last) parts.push({ kind: 'text', text: text.slice(last, match.index) });
    parts.push({ kind: 'time', text: match[0], seconds });
    last = match.index + match[0].length;
  }
  if (last < text.length) parts.push({ kind: 'text', text: text.slice(last) });
  return parts;
}

function formatTime(seconds) {
  const mins = Math.floor(seconds / 60);
  const secs = seconds % 60;
  return `${mins}:${secs.toString().padStart(2, '0')}`;
}

const toggleId = (ids, id) => (ids.includes(id) ? ids.filter((x) => x !== id) : [...ids, id]);

const initialComments = [
  { id: 'c1', author: 'Anne Bonny', text: 'Le meilleur moment est à 1:23, regardez à partir de là.', likes: 14 },
  { id: 'c2', author: 'Jack Silverhand', text: 'Je reviens à 0:45 pour la troisième fois, et à 8:02 pour la deuxième.', likes: 3 },
  { id: 'c3', author: 'Morgan Blackheart', text: "Je regardais à 12:30 au port et personne ne m'a dérangé.", likes: 1 },
];

function CommentText({ text, onSeek }) {
  const parts = splitTimestamps(text, DURATION);
  return (
    <p className="mt-1 whitespace-pre-wrap text-sm">
      {parts.map((part, index) =>
        part.kind === 'time' ? (
          <button key={index} type="button" onClick={() => onSeek(part.seconds)} className="font-semibold text-blue-700 hover:underline">
            {part.text}
          </button>
        ) : (
          <span key={index}>{part.text}</span>
        ),
      )}
    </p>
  );
}

export default function App() {
  const videoRef = useRef(null);
  const [comments, setComments] = useState(initialComments);
  const [likedIds, setLikedIds] = useState([]);
  const [draft, setDraft] = useState('');

  const seekTo = (seconds) => {
    const player = videoRef.current;
    if (!player) return;
    player.currentTime = seconds;
    player.play().catch(() => undefined);
  };

  const insertTime = () => {
    const stamp = formatTime(Math.floor(videoRef.current?.currentTime ?? 0));
    setDraft((prev) => (prev ? `${prev} ${stamp}` : stamp));
  };

  const handleSubmit = (event) => {
    event.preventDefault();
    const text = draft.trim();
    if (!text) return;
    setComments((prev) => [{ id: crypto.randomUUID(), author: 'Toi', text, likes: 0 }, ...prev]);
    setDraft('');
  };

  return (
    <div className="min-h-screen bg-white p-4 text-gray-900">
      <div className="mx-auto max-w-2xl">
        <video ref={videoRef} controls playsInline preload="metadata" className="aspect-video w-full rounded-lg bg-black">
          <source src={SRC} type="video/mp4" />
        </video>
        <h1 className="mt-3 text-lg font-bold">La chasse au Kraken, partie 1</h1>
        <form onSubmit={handleSubmit} className="mt-4 flex gap-2">
          <input
            value={draft}
            onChange={(event) => setDraft(event.target.value)}
            placeholder="Ajoute un commentaire, par ex. super plan à 1:23"
            aria-label="Texte du commentaire"
            className="flex-1 rounded border border-gray-300 px-3 py-2 text-sm"
          />
          <button type="button" onClick={insertTime} className="rounded border border-gray-300 px-3 py-2 text-sm hover:bg-gray-50">
            Insérer le temps
          </button>
          <button type="submit" className="rounded bg-red-600 px-4 py-2 text-sm font-semibold text-white hover:bg-red-700">
            Ajouter
          </button>
        </form>
        <ul className="mt-4 space-y-3">
          {comments.map((comment) => {
            const isLiked = likedIds.includes(comment.id);
            return (
              <li key={comment.id} className="border-b border-gray-200 pb-3">
                <p className="text-sm font-semibold">{comment.author}</p>
                <CommentText text={comment.text} onSeek={seekTo} />
                <button
                  type="button"
                  aria-pressed={isLiked}
                  onClick={() => setLikedIds((prev) => toggleId(prev, comment.id))}
                  className={isLiked ? 'mt-1 text-xs font-semibold text-red-600' : 'mt-1 text-xs text-gray-600 hover:text-gray-900'}
                >
                  J’aime ({comment.likes + (isLiked ? 1 : 0)})
                </button>
              </li>
            );
          })}
        </ul>
      </div>
    </div>
  );
}

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. Que renverra parseTimestamp("1:02:05") ?

  2. 2. Pourquoi CommentText dessine-t-il les morceaux du commentaire en <span> et <button>, et non avec dangerouslySetInnerHTML ?

Voici 2 des 3 questions de cette leçon. Réponds aux autres dans le jeu.

Tâches pratiques dans le jeu

  • Tri vertical

    Ordonne les lignes de la fonction seekTo dans WatchView (de haut en bas) :

  • Tri horizontal

    Ordonne la ligne qui vérifie dans CommentsSection si le commentaire est aimé (une seule ligne) :

  1. QuestionRésultat de parseTimestamp
  2. Remets dans l'ordreDéfilement dans seekTo
  3. QuestionBalisage sûr dans un commentaire
  4. Remets dans l'ordreLe commentaire est-il aimé
  5. QuestionUn horodatage plus long que le film

Articles utiles