Rendre accessible une interface de chat d'IA
- Étude de cas 2
- 120 min
- Facultative · 1 étude de cas requise pour le certificat
Où nous en sommes
Cette étude de cas applique les interactions accessibles du module 6 à un petit chat d'IA qui fonctionne seulement à la souris. Vous trouvez chaque problème avec l'arbre d'accessibilité et des vérifications automatiques, vous le corrigez, et un lecteur d'écran lit chaque réponse en flux continu une seule fois, quand elle se termine.
Étude de cas 2 sur 2 · Architecture frontend et performance des applications d'IARendre accessible une interface de chat d'IA
1. Premiers pas avec le Web
2. Composants et structure de l'application
3. Récupération des données et gestion de l'état
4. États d'interaction propres à l'IA
5. Performance et capacité de croissance
6. Sécurité, accessibilité et remise du travail
Ce que vous saurez faire
Prenez un petit chat d’IA qui fonctionne à la souris et rendez-le utilisable au clavier et avec un lecteur d’écran. Trouvez chaque problème avec l’arbre d’accessibilité du navigateur et des vérifications automatiques, corrigez-le et prouvez la correction. La réponse en flux continu est la partie la plus difficile. Un lecteur d’écran doit lire chaque réponse une seule fois, quand elle est terminée, jamais morceau par morceau.
Le projet de départ est un petit chat, écrit pour cette étude de cas. Ce n’est pas le bureau des tickets. C’est une deuxième interface, plus simple, pour que vous puissiez voir chaque problème séparément. Le projet terminé présente le résultat, pour vous aider si vous bloquez. Le code est sous licence MIT.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
Cette étude de cas utilise tout le cours, surtout Interactions accessibles : les cinq vérifications, les régions dynamiques et l’arbre d’accessibilité. Elle utilise aussi Interfaces en flux continu (une réponse lue avec fetch et un lecteur de flux, et le bouton Stop) et Tester et livrer (Playwright).
Ce qu’il vous faut sur votre ordinateur
- Node.js 24 (LTS) et VS Code, comme dans Installer le bureau des tickets.
- Environ 300 Mo d’espace disque libre : les paquets (125 Mo) et Chromium pour Playwright.
- Facultatif : un lecteur d’écran. macOS comprend VoiceOver (Cmd+F5); sous Windows, NVDA est gratuit.
Testé sur macOS (Apple M4, 16 Go, Node.js 24.18.0, Chromium 156 avec Playwright 1.64.0). Les commandes Windows et Linux sont fournies, mais non testées. L’équipe du cours n’a pas testé le chat avec un vrai lecteur d’écran.
La situation
Section intitulée « La situation »Les agents de Grace aiment l’assistant de politiques du cours RAG. Ils lui posent des questions comme « À quelle vitesse remboursons-nous une double facturation? » et obtiennent une courte réponse avec ses sources. Teodor a créé une fenêtre de chat en un après-midi. Elle affiche chaque réponse en flux continu pendant sa rédaction et comprend un bouton Stop. À la souris, elle fonctionne bien.
Camille, qui travaille comme agent à Montréal, utilise un clavier et un lecteur d’écran pendant une partie de la journée. Camille l’a essayé lundi. Son compte rendu était court : « J’ai pu taper une question. Ensuite, je ne savais plus où j’étais. Le lecteur d’écran lisait la réponse par petits morceaux, mot par mot. Je ne trouvais pas Stop. Et je ne pouvais pas poser une deuxième question sans la souris. »
La règle de Grace : « Chaque agent doit pouvoir utiliser le chat. Trouvez tous les problèmes, corrigez-les et montrez-moi qu’ils restent corrigés. »
L’objectif. Avec le clavier seulement, Camille peut poser une question, arrêter une réponse et poser la suivante. Chaque commande a un nom. Le texte a un contraste d’au moins 4,5:1. Un lecteur d’écran lit chaque réponse une seule fois, quand elle est terminée, avec le nombre de sources, jamais morceau par morceau. Six vérifications automatiques le prouvent sur 12 questions, puis sur 10 questions non utilisées pendant la création.
Ce que vous allez créer
Section intitulée « Ce que vous allez créer »| Partie | Ce que vous faites | Mesure après cette partie |
|---|---|---|
| 1 | Examinez le chat comme les outils de Camille : au clavier et dans l’arbre d’accessibilité | – |
| 2 | Exécutez les six vérifications sur le projet de départ : la référence de base | 5 vérifications sur 6 échouent |
| 3 | Corrigez les noms, le focus et Stop | – |
| 4 | Comparez quatre façons d’annoncer une réponse avec une même mesure, puis choisissez | changements par réponse |
| 5 | Corrigez le contraste | les 6 vérifications réussissent |
| 6 | De bout en bout : les vérifications sur 10 nouvelles questions | un nouveau problème, corrigé |
Les données
Section intitulée « Les données »Le chat n’appelle pas de modèle. Une API simulée dans le projet (mock/server.mjs, port 8200) rejoue les 67 réponses enregistrées de l’assistant de politiques du cours RAG. Un modèle hébergé (chat-small) les a rédigées. Le cours a enregistré chacune une fois, avec la durée de l’appel (978 à 5 342 ms, médiane de 1 458 ms). Chaque réponse contient une à trois phrases et ses sources. 13 réponses indiquent que les documents ne répondent pas à la question. 9 questions et leurs réponses sont en français : Larkfield a des agents et des clients au Québec.
La simulation coupe chaque réponse en morceaux : un mot avec son espace, ou un signe de ponctuation. Elle envoie le premier morceau après la majeure partie du temps enregistré, puis un morceau toutes les quelques millisecondes. C’est ce que font les vrais flux (voir Interfaces en flux continu). Elle choisit la question enregistrée qui partage le plus de mots avec la vôtre. Les questions, les documents et les réponses sont sous licence CC0 1.0. Le fichier est mock/data/replies.json (34 467 octets). Son empreinte SHA-256 se trouve dans mock/data/SHA256SUMS et dans la fiche du jeu de données.
Préparer le projet
Section intitulée « Préparer le projet »-
Téléchargez le projet de départ depuis l’encadré en haut de cette page. Décompressez-le dans votre dossier de projets. Vous obtenez le dossier
policy-chat. -
Dans VS Code, choisissez File > Open Folder (fichier, ouvrir un dossier) et ouvrez
policy-chat. Ouvrez un terminal : Terminal > New Terminal (terminal, nouveau terminal). -
Installez les paquets et vérifiez le fichier de données :
Fenêtre de terminal npm installcd mock/data && shasum -a 256 -c SHA256SUMS && cd ../..Fenêtre de terminal npm install(Get-FileHash mock\data\replies.json -Algorithm SHA256).Hash.ToLower()Comparez le résultat avec la valeur dans
mock\data\SHA256SUMS.Fenêtre de terminal npm installcd mock/data && sha256sum -c SHA256SUMS && cd ../..La vérification affiche
replies.json: OK(replies.json : correct). -
Exécutez les tests. La sortie se termine par
ℹ pass 4(4 réussites, pour la simulation) etTests 2 passed (2)(2 tests réussis sur 2, pour les composants) :Fenêtre de terminal npm test -
Démarrez la simulation dans ce terminal avec
npm run mock. Elle affiche :Mock chat API on http://127.0.0.1:8200 (67 recorded answers; stream=recorded)The answers were recorded from a real model in an earlier course; the streaming is simulated. -
Ouvrez un deuxième terminal (Terminal > New Terminal) et exécutez
npm run dev. Ouvrez http://localhost:5173/ dans Chrome.
Posez la question « Combien de points Rewards faut-il à un client pour une récompense de 10 dollars? » avec la souris. Après environ une seconde, la réponse apparaît, quelques mots à la fois. À la souris, le chat fonctionne.
Partie 1 : examiner le chat comme les outils de Camille
Section intitulée « Partie 1 : examiner le chat comme les outils de Camille »Au clavier
Section intitulée « Au clavier »Rechargez la page. Ne touchez pas à la souris. Appuyez une fois sur Tab : le focus va au champ de message. Tapez une question et appuyez sur Enter (entrée). Appuyez maintenant sur Tab pour atteindre Stop.

Aucun élément n’a le focus. Le champ de message est désactivé pendant la réponse en flux continu, et un élément désactivé perd le focus. Le focus est revenu à la page elle-même, comme pour le formulaire de nouveau billet dans Interactions accessibles. Chaque pression sur Tab repart maintenant du haut, et le carré rouge n’est jamais atteint.
Dans l’arbre d’accessibilité
Section intitulée « Dans l’arbre d’accessibilité »Un lecteur d’écran lit l’arbre d’accessibilité, pas les pixels. npm run tree l’affiche avec ariaSnapshot() de Playwright, une fois pendant la rédaction d’une réponse, puis après. Arrêtez d’abord le serveur de développement (Ctrl+C). Exécutez une fois npx playwright install chromium pour télécharger le navigateur. Ensuite :
npm run treeLa sortie, abrégée au milieu :
--- while the reply is written ---- banner: - heading "Policy assistant" [level=1] - paragraph: Answers from Larkfield's policy documents. Check them before you reply to a customer.- main: - text: You A customer was charged twice for the same order. How quickly do we refund the extra charge? Assistant Writing… - textbox "Ask about a policy…" [disabled] - img--- after the reply ---- main: - text: "You A customer was charged twice … Assistant We refund the extra charge within 3 business days after confirming the double charge. Sources: Refunds and payments policy (Double charges); Manual refunds and goodwill credits (Rules)" - textbox "Ask about a policy…" - button: - imgLisez-la comme le lecteur d’écran de Camille. Le champ de message se nomme « Ask about a policy… » (posez une question sur une politique…). C’est son texte indicatif, qui disparaît quand Camille tape. Pendant la rédaction de la réponse, Stop est seulement une img (image) : une image, pas une commande. Après la réponse, le bouton d’envoi est un button (bouton) sans nom. Un lecteur d’écran dit donc « bouton », sans rien ajouter.
Partie 2 : la référence de base, six vérifications automatiques
Section intitulée « Partie 2 : la référence de base, six vérifications automatiques »L’idée : un vérificateur lit ce que lisent les outils d’assistance
Section intitulée « L’idée : un vérificateur lit ce que lisent les outils d’assistance »Un correcteur orthographique trouve la plupart des fautes de frappe en quelques secondes. Mais il ne peut pas dire si une lettre est aimable. Les vérifications automatiques d’accessibilité fonctionnent de la même façon. Elles lisent ce que lisent les outils d’assistance et trouvent vite les problèmes mécaniques. Par exemple, un bouton sans nom ou un texte gris trop pâle. Elles ne peuvent pas dire si le chat est agréable à utiliser avec un lecteur d’écran.
Le vérificateur le plus connu est axe-core. Sa licence est MPL-2.0, qui ne fait pas partie des licences permissives utilisées dans ce cours. Il vérifie une page à un instant donné. Les problèmes d’un chat surviennent au fil du temps : après Enter, pendant un flux. Le projet comprend donc ses propres six vérifications, dans e2e/checks.ts (environ 150 lignes). Chaque vérification lit un élément dans Chromium :
Description textuelle du diagramme
Le diagramme est un tableau de six lignes et trois colonnes : ce que lit la vérification, sa condition de réussite et le résultat du projet de départ. Noms lit l’arbre d’accessibilité, avec le rôle, le nom et l’origine du nom. Focus lit l’élément qui a le focus au clavier après Enter. Clavier lit le focus après chaque Tab et l’arbre. Annonces lit chaque nouveau texte d’une région dynamique et attend pendant qu’une région est aria-busy. Contraste lit les couleurs calculées de chaque texte et de son arrière-plan. Langue lit l’attribut lang autour de chaque réponse. Le projet de départ échoue aux cinq premières vérifications et réussit la sixième, car les 12 questions sont toutes en anglais. Une ligne rouge en bas indique qu’aucune vérification n’entend ce que dit un vrai lecteur d’écran.
La vérification des noms demande l’arbre entier au navigateur avec le Chrome DevTools Protocol et examine l’origine de chaque nom :
const { nodes } = await cdp.send('Accessibility.getFullAXTree');for (const n of nodes) { const role = String(n.role?.value ?? ''); if (n.ignored || !CONTROLS.has(role)) continue; const name = String(n.name?.value ?? '').trim(); const used = n.name?.sources?.find((s) => s.value && !s.superseded && String(s.value.value ?? '').trim() === name); if (!name) problems.push(`${role} with no name`); else if (used?.attribute === 'placeholder') problems.push(`${role} "${name}" is named only by its placeholder`);}La vérification des annonces compte les changements de chaque région dynamique pendant une réponse, comme l’équipe du cours pour le bureau. Chaque nouveau texte demande au lecteur d’écran de parler.
Exécuter les vérifications
Section intitulée « Exécuter les vérifications »npm run check:a11yLes vérifications construisent l’application, démarrent la simulation et l’application construite sur leurs propres ports, puis pilotent Chromium. L’exécution a pris 33 secondes sur le portable de l’équipe du cours :
✘ 1 e2e/a11y.spec.ts:12:1 › names: every control has a name, and not only a placeholder (1.7s) ✘ 2 e2e/a11y.spec.ts:17:1 › focus: after sending, the focus stays in the message box (1.3s) ✘ 3 e2e/a11y.spec.ts:27:1 › keyboard: Tab reaches Stop while a reply is written, and Enter stops it (107ms) ✘ 4 e2e/a11y.spec.ts:43:1 › announcements: one per finished reply, never one per piece (4.8s) ✘ 5 e2e/a11y.spec.ts:55:1 › contrast: all text has at least 4.5:1 (3:1 when large) (1.6s) ✓ 6 e2e/a11y.spec.ts:60:1 › language: each reply is marked with its language (21.3s)Chaque échec énumère tous les problèmes. Voici les lignes importantes, tirées de la même exécution :
+ "textbox \"Ask about a policy…\" is named only by its placeholder", + "button with no name",
Received string: "body (nothing)"
Error: where each Tab went: body (nothing) → body (nothing) → body (nothing) → body (nothing)
+ "Q01: 17 changes, last one complete: true", + "Q02: 21 changes, last one complete: true", + "Q04: 13 changes, last one complete: true",
+ "\"Answers from Larkfield's polic\": #9aa4ae on #f4f6f8 is 2.34:1, needs 4.5:1", + "\"You\": #9aa4ae on #e8f0fa is 2.20:1, needs 4.5:1", + "\"Assistant\": #9aa4ae on #ffffff is 2.53:1, needs 4.5:1", + "\"Sources: Refunds and payments \": #9aa4ae on #ffffff is 2.53:1, needs 4.5:1", + "\"placeholder Ask about a policy\": #9aa4ae on #ffffff is 2.53:1, needs 4.5:1",C’est la référence de base : 5 vérifications sur 6 échouent. La réponse à Q01 comporte 16 morceaux. Ses 17 changements sont la question, puis un changement par morceau. Camille a entendu « We » (nous), « We refund » (nous remboursons), « We refund the » (nous remboursons le), et ainsi de suite, comme dans son compte rendu.
Partie 3 : noms, focus et Stop
Section intitulée « Partie 3 : noms, focus et Stop »Ces trois corrections utilisent les notions enseignées dans Interactions accessibles. Ouvrez src/App.tsx.
-
Noms. Donnez au champ de message une étiquette visible, et au bouton un texte visible. Masquez les icônes dans l’arbre avec
aria-hidden="true"sur chaque<svg>: elles ne font que répéter le texte.src/App.tsx (the form) <label htmlFor="question">Your question</label><div className="ask-row"><textarea id="question" value={question} onChange={(e) => setQuestion(e.target.value)}onKeyDown={onKey} placeholder="For example: how long does a refund take?"aria-describedby="question-help" rows={2} />{/* The button comes in step 3. */}</div><p id="question-help" className="help">Enter sends. Shift+Enter starts a new line. Escape stops a reply.</p>Le texte indicatif est maintenant un exemple, pas le nom.
aria-describedbyfournit les touches au lecteur d’écran, après le nom. -
Focus. Retirez
disabled={busy}du<textarea>. Le champ garde le focus.submitrefuse déjà une deuxième question pendant la rédaction d’une réponse (if (!question.trim() || busy) return;). Permettez aussi à Escape (échap) d’arrêter une réponse depuis le champ :src/App.tsx (onKey) if (e.key === 'Enter' && !e.shiftKey) {e.preventDefault();submit();} else if (e.key === 'Escape' && busy) {stop();} -
Stop. Remplacez le
<div className="stop" onClick={stop}>et le bouton d’envoi par un seul vrai<button>dont l’étiquette change :src/App.tsx (after the textarea) {/* One real button whose label changes: Tab reaches it, Enter and Space press it. */}<button className={busy ? 'stop' : 'send'} type={busy ? 'button' : 'submit'} onClick={busy ? stop : undefined}>{busy ? <StopIcon /> : <SendIcon />}<span>{busy ? 'Stop' : 'Send'}</span></button>Un
<div>aveconClickreçoit les clics, mais pas les actions du clavier. Il n’est pas dans l’ordre de Tab, et Enter n’y fait rien. Un<button>offre tout cela automatiquement. Un seul bouton, plutôt que deux, garde le focus quand l’étiquette change, comme dans le panneau de brouillon du bureau. -
Dans
src/styles.css, donnez au bouton assez d’espace pour son texte, et aux commandes un contour de focus visible. Remplacez les règles.asket.send, .stoppar les règles.ask label,.ask-row,.help,.send, .stopetbutton:focus-visible, textarea:focus-visibledu projet terminé.
Partie 4 : une annonce par réponse
Section intitulée « Partie 4 : une annonce par réponse »Le problème et quatre solutions possibles
Section intitulée « Le problème et quatre solutions possibles »La conversation du projet de départ a aria-live="polite". Chaque fragment de texte est donc un changement qu’un lecteur d’écran peut lire. Si vous retirez cet attribut, le chat devient silencieux : Camille doit chercher la réponse dans la page après chaque question. Il existe quatre approches courantes. Le projet terminé contient les quatre dans src/chat/announce.ts, choisies selon l’adresse, par exemple http://localhost:5173/?announce=pieces :
| Approche | Ce qu’elle fait |
|---|---|
pieces |
L’approche du projet de départ : la conversation est la région dynamique; chaque fragment la modifie. |
busy |
La même approche, avec aria-busy="true" sur la conversation pendant la rédaction d’une réponse. La spécification ARIA permet aux outils d’assistance d’attendre pendant qu’une région est occupée, puis de la lire une fois terminée. Elle ne les oblige pas à attendre. |
sentences |
La conversation n’est pas dynamique. Une région d’état distincte reçoit chaque phrase une fois qu’elle est complète. |
reply |
La conversation n’est pas dynamique. Une région d’état distincte reçoit un message à la fin de la réponse : « Assistant : », toute la réponse et le nombre de sources. |
La région d’état est le LiveRegion du bureau : un élément masqué visuellement avec role="status" et aria-atomic="true", toujours présent dans la page. Un piège : ne donnez pas role="log" à la conversation pour bien la présenter dans l’arbre. Un journal est une région dynamique par définition. Il ramène donc le problème de pieces.
La fonction qui choisit le message est courte :
export function announcement(way: Way, reply: Message | undefined): string { if (!reply || reply.role !== 'assistant') return ''; if (way === 'pieces' || way === 'busy') return ''; // the conversation itself is the live region if (reply.status === 'stopped') return 'You stopped the reply. The text is not complete.'; if (reply.status === 'failed') return `No reply. ${reply.problem ?? ''}`.trim(); if (way === 'sentences') { const all = sentences(reply.text); if (reply.status === 'streaming') return all.length > 1 ? all[all.length - 2] : ''; return reply.status === 'done' ? (all.at(-1) ?? '') : ''; } if (reply.status !== 'done') return ''; const n = reply.sources?.length ?? 0; return `Assistant: ${reply.text} ${n ? `${n} ${n === 1 ? 'source' : 'sources'}.` : 'No sources.'}`;}Copiez src/chat/announce.ts, src/ui/LiveRegion.tsx et la règle .visually-hidden de src/styles.css depuis le projet terminé; e2e/compare.spec.ts est déjà dans le vôtre. Dans App.tsx, lisez l’approche une seule fois avec wayFromAddress(window.location.search). Placez data-announce={way} sur le <div> extérieur, puis modifiez la conversation et la région d’état :
<section className="log" aria-label="Conversation" {...live} aria-busy={way === 'busy' ? busy : undefined}> {/* the messages, as before */}</section><LiveRegion message={announcement(way, messages.at(-1))} />Ici, live vaut { 'aria-live': 'polite' } pour les deux premières approches, et rien pour les autres.
Une comparaison équitable avec une seule mesure
Section intitulée « Une comparaison équitable avec une seule mesure »Faites d’abord une prédiction. Pour les 12 questions, combien de changements par réponse chaque approche produira-t-elle?
La mesure est le nombre de changements de région dynamique par réponse : chaque changement est une demande de lecture. Une bonne conception produit un seul changement, qui contient toute la réponse. Pour une comparaison équitable, chaque approche utilise les mêmes 12 questions, les mêmes délais enregistrés, la même version construite et le même navigateur :
npm run compareL’exécution a pris 1,4 minute sur le portable de l’équipe du cours. Elle affiche :
way median min max last change = whole replypieces 16.5 10 72 12 of 12busy 1 1 1 12 of 12sentences 1 1 2 12 of 12reply 1 1 1 12 of 12La dernière colonne indique si le dernier changement se termine par les derniers mots de la réponse.
- un changement par fragment
- moins de changements
- l'approche choisie
Description textuelle du graphique
Un diagramme à quatre colonnes : le nombre médian de changements de région dynamique par réponse pour 12 questions. pieces : 16.5. busy : 1. sentences : 1. reply : 1.
L’approche pieces a produit un changement par fragment de texte. Cela donne 10 pour la réponse la plus courte (Q34, « Un arroseur de jardin a une garantie d’un an. »), et 72 pour la plus longue (Q45, 64 mots). Les trois autres approches ont produit un ou deux changements par réponse. Selon cette mesure, busy, sentences et reply sont à égalité. La mesure élimine la pire conception, mais ne permet pas de choisir parmi les trois autres. Pour cela, regardez ce que chaque approche demande au lecteur d’écran de dire, pour la même réponse :
Description textuelle du diagramme
Pour Q01, le premier fragment arrive après 1 092 ms, puis les 16 fragments suivent à 5 ms d’intervalle. Avec pieces, le lecteur d’écran reçoit 17 changements : la question, puis un texte plus long après chaque fragment. Avec busy, il ne reçoit rien pendant que la conversation est occupée, puis reçoit le nouveau texte. Cela fonctionne seulement si le lecteur d’écran respecte aria-busy, et les mots dépendent du lecteur d’écran. Avec sentences, il reçoit l’unique phrase de Q01 une fois qu’elle est complète. Avec reply, il reçoit un message à la fin : Assistant, toute la réponse et 2 sources.
La recommandation
Section intitulée « La recommandation »Choisissez reply, pour trois raisons que le nombre de changements ne peut pas montrer :
busydépend du lecteur d’écran. La vérification compte ce que la spécification ARIA permet, pas ce que font NVDA ou VoiceOver. La spécification leur permet d’attendre; elle ne les oblige pas à le faire. Un lecteur d’écran qui ignorearia-busyramène les 17 changements. Et quand la région n’est plus occupée, chaque lecteur d’écran décide quelle partie de la conversation lire.sentencesinterrompt et en dit moins. Ces réponses sont courtes, donc cette approche a produit un ou deux changements. Une réponse plus longue produit une interruption par phrase pendant que Camille tape sa prochaine question. Et aucun message n’indique où la réponse se termine ni combien de sources elle contient.replydit les mêmes mots dans chaque lecteur d’écran. Vous les choisissez : « Assistant : », toute la réponse, le nombre de sources. Les réponses arrêtées ou échouées ont leur propre phrase, comme dans le panneau de brouillon du bureau.
Le coût. Camille n’entend rien avant la fin de la réponse. Dans les enregistrements, le délai médian après Entrée est de 1 458 ms, et le maximum est de 5 342 ms. La majeure partie de cette attente précède de toute façon le premier fragment, comme l’a montré Interfaces en flux continu. Camille perd donc peu en n’entendant pas le flux. Une longue réponse est lue d’un seul coup. Camille peut arrêter la lecture avec Ctrl et lire la conversation directement. Quand ne pas l’utiliser : pour des réponses de plusieurs paragraphes. Annoncez alors un court état, comme « Réponse terminée, 3 paragraphes, 2 sources. », et laissez Camille lire la réponse dans la page.
Partie 5 : contraste
Section intitulée « Partie 5 : contraste »Le gris #9aa4ae est le gris « plus calme » de Tomás dans Interactions accessibles : 2,53:1 sur blanc, 2,20:1 sur le bleu de vos propres messages. Dans src/styles.css, modifiez un jeton (token) :
--soft: #56616d;C’est le gris du bureau : 6,31:1 sur une carte. Les étiquettes, la ligne des sources, l’indication et le texte indicatif utilisent tous ce jeton. Une seule ligne corrige donc cinq types de texte. Relancez maintenant les vérifications :
npm run check:a11y ✓ 1 e2e/a11y.spec.ts:12:1 › names: every control has a name, and not only a placeholder (1.6s) ✓ 2 e2e/a11y.spec.ts:17:1 › focus: after sending, the focus stays in the message box (1.3s) ✓ 3 e2e/a11y.spec.ts:27:1 › keyboard: Tab reaches Stop while a reply is written, and Enter stops it (85ms) ✓ 4 e2e/a11y.spec.ts:43:1 › announcements: one per finished reply, never one per piece (4.7s) ✓ 5 e2e/a11y.spec.ts:55:1 › contrast: all text has at least 4.5:1 (3:1 when large) (1.6s) ✓ 6 e2e/a11y.spec.ts:60:1 › language: each reply is marked with its language (21.3s)
6 passed (33.0s)Les six vérifications réussissent. npm run tree montre maintenant un textbox "Your question" (champ de texte « Votre question »), et un button "Stop" (bouton « Arrêter ») pendant la rédaction de la réponse. Après la réponse, il montre l’état : "Assistant: We refund the extra charge within 3 business days after confirming the double charge. 2 sources." (« Assistant : Nous remboursons les frais supplémentaires dans les 3 jours ouvrables après confirmation de la double facturation. 2 sources. »).
Partie 6 : de bout en bout, avec de nouvelles questions
Section intitulée « Partie 6 : de bout en bout, avec de nouvelles questions »Vous avez construit et vérifié le chat avec 12 questions. Les corrections tiennent-elles pour des questions que vous n’avez pas examinées? e2e/questions.ts garde 10 autres questions enregistrées à part. Elles comprennent des réponses plus longues (jusqu’à 70 mots), une réponse lente (5 342 ms), une question sans réponse dans les documents et 4 questions en français.
QUESTIONS=new npm run check:a11y$env:QUESTIONS="new"; npm run check:a11y; Remove-Item Env:QUESTIONSQUESTIONS=new npm run check:a11y ✓ 1 e2e/a11y.spec.ts:12:1 › names: every control has a name, and not only a placeholder (2.8s) ✓ 2 e2e/a11y.spec.ts:17:1 › focus: after sending, the focus stays in the message box (2.4s) ✓ 3 e2e/a11y.spec.ts:27:1 › keyboard: Tab reaches Stop while a reply is written, and Enter stops it (81ms) ✓ 4 e2e/a11y.spec.ts:43:1 › announcements: one per finished reply, never one per piece (8.2s) ✓ 5 e2e/a11y.spec.ts:55:1 › contrast: all text has at least 4.5:1 (3:1 when large) (2.7s) ✘ 6 e2e/a11y.spec.ts:60:1 › language: each reply is marked with its language (30.4s)
+ "Q21: reply in \"fr\", marked \"en\"", + "Q37: reply in \"fr\", marked \"en\"", + "Q47: reply in \"fr\", marked \"en\"", + "Q59: reply in \"fr\", marked \"en\"",
1 failed 5 passed (47.9s)Cinq vérifications réussissent avec les nouvelles questions. Même les réponses les plus longues ont produit une seule annonce chacune. La sixième vérification échoue, ce qui était impossible auparavant : les 12 questions utilisées pour construire le chat étaient toutes en anglais. Ici, les 4 réponses en français sont marquées comme étant en anglais.
L’idée : la langue de chaque partie
Section intitulée « L’idée : la langue de chaque partie »Pensez à une personne à la radio qui lit un nom français avec les sons de l’anglais : l’auditeur pourrait ne pas le reconnaître. Un lecteur d’écran choisit sa voix selon l’attribut lang. La page indique <html lang="en">. Le lecteur d’écran lit donc une réponse française avec les sons de l’anglais, et Camille entend quelque chose de presque incompréhensible. Les Règles pour l’accessibilité des contenus Web appellent cela la langue des passages : un texte dans une autre langue doit indiquer sa langue. La simulation envoie déjà la langue de chaque réponse ("language": "fr", au début du flux). Dans src/App.tsx, ajoutez un attribut à chaque message :
<div key={m.id} className={`msg ${m.role}`} data-status={m.status} lang={m.language}>Vos propres messages n’ont pas de language, donc ils conservent l’anglais de la page. Relancez les nouvelles questions :
✓ 6 e2e/a11y.spec.ts:60:1 › language: each reply is marked with its language (30.4s)
6 passed (47.9s)Les six vérifications réussissent avec les nouvelles questions, et npm run check:a11y réussit toujours avec les 12 premières.
Enfin, ajoutez les tests de composants du projet terminé (src/App.test.tsx, src/chat/announce.test.ts) : focus après Entrée, bouton Arrêter avec Tab et Entrée, un seul message d’état et lang="fr". npm test se termine par ℹ pass 4 (4 réussites) et Tests 9 passed (9) (9 tests réussis sur 9). Ces tests prennent environ une seconde. Ils protègent donc les corrections à chaque modification. Les vérifications dans le navigateur protègent ce que seul un navigateur peut voir.

Constats et limites
Section intitulée « Constats et limites »- Chaque correction était petite; le travail consistait à trouver les problèmes. Une étiquette, un
disabledretiré, un<button>au lieu d’un<div>, un jeton de couleur, une région dynamique, un attributlang. L’arbre d’accessibilité et les vérifications ont montré chaque problème en quelques secondes. - Une mesure peut éliminer une mauvaise conception sans en choisir une bonne. Le nombre de changements séparait
pieces(médiane de 16,5 changements) des autres (1), mais trois approches étaient à égalité. Le choix reposait sur ce que le nombre ne montre pas : qui décide des mots. Précisez-le quand vous présentez une comparaison. - Gardez des questions à part. Le problème de langue était présent dans les données dès le départ (9 réponses françaises sur 67). Mais les 12 questions utilisées pour construire le chat ne pouvaient pas le révéler.
- Limites. Aucun vrai lecteur d’écran n’a été utilisé : le nombre d’annonces est une mesure indirecte, tirée des changements des régions dynamiques. L’équipe du cours a testé seulement Chromium sur macOS, avec une taille d’écran d’ordinateur. Les 67 réponses sont courtes (70 mots au maximum), et la simulation les rejoue. Les vrais modèles transmettent de plus petits fragments : de 87 à 106 dans les flux enregistrés du cours, contre 9 à 71 ici.
piecesserait donc encore pire. Les vérifications ne voient que les parcours qu’elles exécutent : les tests unitaires couvrent une réponse échouée, mais pas les vérifications dans le navigateur. Les temps proviennent du portable de l’équipe du cours, avec d’autres tâches en cours; les vôtres seront différents.
Utilisation responsable
Section intitulée « Utilisation responsable »- Les vérifications automatiques sont un minimum, pas un certificat. Six vérifications vertes signifient que six problèmes connus sont absents. Elles ne signifient pas que le chat est accessible. Avant que les agents en dépendent, demandez à une personne utilisant quotidiennement un lecteur d’écran d’essayer les tâches principales. Utilisez au moins VoiceOver et NVDA.
- Ne faites pas d’un collègue en situation de handicap votre suite de tests. Le signalement de Camille a lancé ce travail, et Camille devrait tester le résultat. Mais corrigez d’abord ce que les vérifications et le clavier peuvent trouver. Son temps servira ainsi à ce que Camille seul peut juger.
- Une annonce répète les mots du modèle. Si la réponse est fausse, le lecteur d’écran la dit avec autant d’assurance que l’écran l’affiche. Gardez les sources dans le message (« 2 sources », « Aucune source »). Camille saura ainsi quand vérifier, comme les agents voyants.
- Ne masquez pas le flux pour corriger les annonces. Les agents voyants voient toujours le texte arriver, et le bouton Arrêter fonctionne toujours à tout moment.
Faites-en un projet de portfolio
Section intitulée « Faites-en un projet de portfolio »Ce projet montre ce que les employeurs recherchent chez un développeur frontend. Vous trouvez des problèmes d’accessibilité avec des outils et les corrigez dans une vraie interface. Vous prouvez chaque correction avec des tests, et vous comparez des conceptions avec une mesure, pas des opinions.
Quoi mettre dans le dépôt :
policy-chat/ README.md what it is, how to run and check it, the results table, the limits DATASET.md the recorded answers: source, licence, checksum, changes LICENSE MIT, for the code src/ the chat, announce.ts and LiveRegion.tsx mock/ the mock API and its 4 checks e2e/ the six checks, the tree, the comparison results/ compare.json from your own run- Créez un nouveau dépôt Git à partir du dossier de votre projet et poussez-le vers GitHub.
.gitignoreexclut déjànode_modules/,dist/et les résultats des tests. Retirezresults/de.gitignoresi vous voulez publier votre comparaison. - Dans le README, ajoutez un tableau : les six vérifications avant et après, puis les quatre approches avec vos médianes de changements par réponse. Ajoutez une phrase sur l’exécution de bout en bout.
- Ajoutez un court enregistrement d’écran du parcours au clavier : Tab vers le champ, une question, Tab vers Arrêter, Entrée. Si vous avez un lecteur d’écran, enregistrez aussi sa voix.
- Indiquez ce que vous n’avez pas testé : les vrais lecteurs d’écran, Firefox et Safari, les téléphones.
En entrevue, en deux phrases : « J’ai rendu un chat d’IA en flux continu utilisable au clavier et avec un lecteur d’écran, avec six vérifications dans le navigateur comme preuve. J’ai comparé quatre façons d’annoncer une réponse en flux continu, et les questions gardées à part ont révélé des réponses françaises sans indication de langue. »
Pour aller plus loin : annoncez « L’assistant rédige une réponse » une seule fois au début d’une réponse. Décidez si cela aide ou ajoute du bruit. Ajoutez un raccourci qui relit la dernière réponse. Exécutez les vérifications dans Firefox avec Playwright et trouvez ce qui change. Testez avec VoiceOver et NVDA, et notez ce que chacun dit.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
La zone de message affiche le texte indicatif "Ask about a policy…" (posez une question sur une politique…). L'arbre d'accessibilité de Chrome l'utilise comme nom. Pourquoi la vérification des noms échoue-t-elle quand même, et comment corriger le problème?
Afficher la réponse
Le texte indicatif sert de nom seulement parce qu’il n’y a rien de mieux. Les sources du nom dans l’arbre indiquent qu’il vient de l’attribut placeholder (texte indicatif). Ce texte disparaît quand vous tapez, donc le champ perd son sens visible. De plus, le texte indicatif est souvent trop pâle. La solution est une vraie étiquette : <label htmlFor="question">Your question</label> (votre question). Le texte indicatif peut rester comme exemple.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
La méthode avec état occupé produisait un changement par réponse, comme la méthode par réponse. Pourquoi l'étude de cas choisit-elle quand même la méthode par réponse?
Afficher la réponse
Le nombre est une mesure indirecte : il compte ce que la spécification ARIA permet quand une région est occupée. La spécification permet aux lecteurs d’écran d’attendre, mais elle ne les oblige pas à le faire. Un lecteur d’écran qui ignore aria-busy lirait donc encore chaque morceau. Quand la région cesse d’être occupée, chaque lecteur d’écran décide aussi quel texte lire. La méthode par réponse place un seul message dans une région d’état, avec des mots choisis par l’équipe. Ce message contient « Assistant : » (assistant), la réponse et le nombre de sources. Cette méthode fonctionne de la même façon dans tous les lecteurs d’écran. Son coût est le silence jusqu’à la fin de la réponse : une médiane de 1 458 ms dans les enregistrements.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Les six vérifications ont réussi sur les 12 questions utilisées pendant le développement. Pourtant, la vérification de la langue a échoué sur les nouvelles questions. Qu'est-ce que cela enseigne sur les données de test, et quelle était la correction?
Afficher la réponse
Les 12 questions étaient toutes en anglais, donc la vérification de la langue ne pouvait pas échouer : elle ne testait rien. Le jeu réservé contenait 4 réponses en français, et la page indiquait que chacune était en anglais. Les données de test doivent contenir les cas que les utilisateurs rencontrent réellement. Une partie doit rester à l’écart jusqu’à la fin, pour éviter d’adapter les corrections à ces données. La correction tenait à un seul attribut : lang={m.language} sur chaque message, selon la langue transmise par l’API.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Vous avez examiné le chat comme le font les outils de Camille : au clavier et dans l’arbre d’accessibilité. Six vérifications automatiques ont trouvé cinq problèmes. Les commandes n’avaient pas de nom, et le focus se perdait après Enter (Entrée). Le clavier ne permettait pas d’atteindre Stop (arrêter). Une réponse produisait de 10 à 72 annonces, et le texte gris avait un contraste de 2,20:1 à 2,53:1.
- Une étiquette, un champ qui n’est jamais désactivé, un vrai
<button>et un jeton de couleur ont corrigé quatre problèmes. - Vous avez comparé quatre façons d’annoncer une réponse sur les mêmes 12 questions, avec une seule mesure.
pieces(morceaux) produisait une médiane de 16,5 changements par réponse; les autres en produisaient un. Le chat annonce chaque réponse une fois, quand elle se termine, avec le nombre de sources. Il utilise des mots qui ne dépendent pas du lecteur d’écran. - Dix questions réservées ont révélé un autre problème : les réponses en français étaient marquées comme étant en anglais. Un attribut
lang(langue) l’a corrigé. - Les vérifications sont un minimum. Il faut encore tester avec un vrai lecteur d’écran et une personne qui en utilise un chaque jour.
Ensuite, le travail final : l’interface de l’assistant aux billets, construite et mesurée avec tout ce que vous avez appris dans ce cours.
Leçon suivante : Travail final