Aller au contenu
English

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.

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.

Étude de casPièce de portfolio

Licence
CC0 1.0
Durée
Environ 2 h
S’exécute dans
VS Code, Node.js 24 (LTS), Chromium
Compétences utilisées
  • Arbre d'accessibilité
  • Noms accessibles
  • Focus au clavier
  • Régions dynamiques
  • Contraste (WCAG)
  • Langue des parties
  • Vérifications Playwright
  • Comparaison équitable

Décompressez le projet de départ, ouvrez le dossier dans VS Code et suivez les étapes ci-dessous. Elles commencent par l’installation des paquets du projet avec npm.

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 mainEnviron 120 minutes

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.

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.

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é

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.

  1. 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.

  2. Dans VS Code, choisissez File > Open Folder (fichier, ouvrir un dossier) et ouvrez policy-chat. Ouvrez un terminal : Terminal > New Terminal (terminal, nouveau terminal).

  3. Installez les paquets et vérifiez le fichier de données :

    Fenêtre de terminal
    npm install
    cd mock/data && shasum -a 256 -c SHA256SUMS && cd ../..

    La vérification affiche replies.json: OK (replies.json : correct).

  4. Exécutez les tests. La sortie se termine par ℹ pass 4 (4 réussites, pour la simulation) et Tests 2 passed (2) (2 tests réussis sur 2, pour les composants) :

    Fenêtre de terminal
    npm test
  5. 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.
  6. 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 »

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.

Le chat de départ pendant la rédaction de la deuxième réponse. Le champ de message est grisé. À sa droite se trouve un bouton carré rouge sans texte, et aucun élément de la page n'a de contour de focus. Les petites étiquettes grises You (vous), Assistant et la ligne des sources sont difficiles à lire.
Le projet de départ après Enter : le champ de message est désactivé, donc le focus est passé à la page. Aucun élément n'a de contour de focus, et le carré rouge Stop ne peut pas recevoir le focus. L’image est en anglais.

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.

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 :

Fenêtre de terminal
npm run tree

La 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:
- img

Lisez-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 :

Un tableau de six lignes. Chaque ligne indique ce que lit la vérification, sa condition de réussite et le résultat du projet de départ. 1, Noms : lit l'arbre d'accessibilité, le rôle, le nom et l'origine du nom; réussit quand chaque commande a un nom, pas seulement un texte indicatif; projet de départ : champ de texte nommé seulement par son texte indicatif, bouton sans nom. 2, Focus : lit le focus au clavier après Enter; réussit quand le champ de message garde le focus; projet de départ : body, le champ était désactivé. 3, Clavier : lit le focus après chaque Tab et l'arbre; réussit quand Tab atteint un bouton Stop et qu'Enter arrête la réponse; projet de départ : 4 Tab, focus sur body chaque fois, Stop est un div, une img dans l'arbre. 4, Annonces : lit chaque nouveau texte d'une région dynamique et attend pendant aria-busy; réussit quand il y en a exactement un par réponse, contenant la réponse entière; projet de départ : 17, 21 et 13 changements pour trois réponses. 5, Contraste : lit les couleurs calculées; réussit à 4,5 pour 1; projet de départ : gris 9aa4ae, de 2,20 à 2,53 pour 1. 6, Langue : lit l'attribut lang autour de chaque réponse; projet de départ : réussit, les 12 questions sont en anglais. Une ligne rouge : non vérifié, ce que dit un vrai lecteur d'écran et comment cela sonne.
Six vérifications, chacune avec ce qu'elle lit dans le navigateur. Cinq échouent sur le projet de départ. Aucune ne remplace un vrai lecteur d'écran.
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 :

e2e/checks.ts (part)
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.

Fenêtre de terminal
npm run check:a11y

Les 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.

Ces trois corrections utilisent les notions enseignées dans Interactions accessibles. Ouvrez src/App.tsx.

  1. 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-describedby fournit les touches au lecteur d’écran, après le nom.

  2. Focus. Retirez disabled={busy} du <textarea>. Le champ garde le focus. submit refuse 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();
    }
  3. 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> avec onClick reç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.

  4. 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 .ask et .send, .stop par les règles .ask label, .ask-row, .help, .send, .stop et button:focus-visible, textarea:focus-visible du projet terminé.

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 :

src/chat/announce.ts (part)
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 :

src/App.tsx (the conversation)
<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.

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 :

Fenêtre de terminal
npm run compare

L’exécution a pris 1,4 minute sur le portable de l’équipe du cours. Elle affiche :

way median min max last change = whole reply
pieces 16.5 10 72 12 of 12
busy 1 1 1 12 of 12
sentences 1 1 2 12 of 12
reply 1 1 1 12 of 12

La 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
Median changes per reply, 12 questions: pieces 16.5, busy 1, sentences 1, reply 1.
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 :

Une ligne en haut : Q01, Entrée à 0 ms, premier fragment à 1 092 ms, 16 fragments espacés de 5 ms, fin vers 1 170 ms. Puis quatre lignes, une par approche, avec le nombre de changements pour Q01 et ce que le lecteur d'écran doit dire. pieces : 17 changements; la question, puis Nous, Nous remboursons, Nous remboursons les, et ainsi de suite, un changement par fragment. busy : 1 changement, si le lecteur d'écran attend; rien pendant que aria-busy est vrai, puis le nouveau texte, et le contenu lu dépend du lecteur d'écran. sentences : 1 changement, car Q01 contient une phrase; Q02 et Q45 en avaient 2; la phrase Nous remboursons les frais supplémentaires dans les 3 jours ouvrables après confirmation de la double facturation. reply : 1 changement, à la fin : Assistant : Nous remboursons les frais supplémentaires dans les 3 jours ouvrables après confirmation de la double facturation. 2 sources.
Une réponse, Q01, quatre approches. Seule la dernière lit la réponse une fois, quand elle est terminée, avec des mots indépendants du lecteur d'écran.
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.

Choisissez reply, pour trois raisons que le nombre de changements ne peut pas montrer :

  • busy dé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 ignore aria-busy ramè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.
  • sentences interrompt 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.
  • reply dit 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.

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) :

src/styles.css
--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 :

Fenêtre de terminal
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.

Fenêtre de terminal
QUESTIONS=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.

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 :

src/App.tsx (each 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.

Le chat terminé pendant la rédaction de la deuxième réponse. Au-dessus du champ de message, l'étiquette Your question (Votre question). Le champ de message reste actif. À sa droite, un bouton rouge avec une icône carrée et le mot Stop (Arrêter) a un contour de focus bleu. En dessous, l'indication : Entrée envoie. Maj+Entrée commence une nouvelle ligne. Échap arrête une réponse. Les étiquettes You (Vous) et Assistant ainsi que la ligne des sources sont gris foncé.
Le chat terminé après Entrée et une pression sur Tab : le contour de focus est sur Arrêter, le champ garde son étiquette et le texte gris est plus foncé. L’image est en anglais.
  • Chaque correction était petite; le travail consistait à trouver les problèmes. Une étiquette, un disabled retiré, un <button> au lieu d’un <div>, un jeton de couleur, une région dynamique, un attribut lang. 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. pieces serait 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.
  • 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.

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
  1. Créez un nouveau dépôt Git à partir du dossier de votre projet et poussez-le vers GitHub. .gitignore exclut déjà node_modules/, dist/ et les résultats des tests. Retirez results/ de .gitignore si vous voulez publier votre comparaison.
  2. 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.
  3. 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.
  4. 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é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.

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.

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.

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