Aller au contenu
English

Travail final

  • Après les études de cas
  • environ 3 h

Où nous en sommes

Dans ce cours, vous avez construit le bureau des billets de Larkfield, d'une première page HTML jusqu'à une application React livrée : données du serveur en cache, brouillons d'IA en flux continu avec Arrêter, tâches en arrière-plan en mots simples, accélérations mesurées, Markdown sûr et bureau utilisable au clavier. Maintenant, l'équipe de facturation demande son propre écran. Dans ce travail, vous le construisez par vous-même, et vous appuyez chaque partie sur des preuves.

Ce que vous saurez faire

Créez vous-même un deuxième écran pour Larkfield : un petit assistant aux billets de soutien pour l’équipe de facturation. Il comprend une liste paginée, un brouillon en flux continu avec Arrêter, l’état d’une tâche en arrière-plan et des erreurs claires. Fournissez ensuite des preuves pour quatre points : des limites claires entre composants et états, une gestion correcte du chargement, des erreurs et de l’annulation, une amélioration de performance mesurée et des interactions au clavier.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 180 minutes
  • Vous avez terminé les modules 1 à 6. Chaque partie ci-dessous nomme les leçons qu’elle utilise.
  • Vous n’avez pas besoin des études de cas pour ce travail. Le certificat exige au moins l’une d’elles : Recherche rapide dans un jeu de données public ou Rendre accessible une interface de chat d’IA.
  • Le projet : votre ticket-desk à la fin de Tester et livrer, ou une copie de l’instantané end-of-m06 (voir les instantanés). npm test affiche ℹ pass 27 et Tests 48 passed (48), et npm run test:e2e affiche 6 passed.
  • Node.js 24 (LTS), VS Code et un navigateur basé sur Chromium avec ses outils de développement.
  • Vous n’avez besoin d’aucun compte, appel de modèle ou paiement. Les brouillons d’IA sont des réponses enregistrées de vrais modèles provenant de cours précédents, que l’API simulée rejoue. Les réponses lentes, en échec ou interrompues sont simulées. Indiquez-le partout où vous en montrez une.
  • Vous pouvez travailler en plusieurs séances. Exécutez npm test après chaque modification.

La situation : un écran pour l’équipe de facturation

Section intitulée « La situation : un écran pour l’équipe de facturation »

Les agents de Grace utilisent le bureau tous les jours. L’équipe de facturation demande maintenant son propre écran. Ses agents répondent uniquement aux billets de facturation ouverts : frais en double, remboursements, factures. Ils veulent une courte liste de ces billets et le brouillon d’IA du billet sélectionné pendant sa rédaction. Ils veulent aussi enregistrer rapidement un nouveau billet de facturation et voir son traitement par l’IA se terminer.

Vous créez cet écran dans le même projet, à l’adresse #/assistant, dans un nouveau dossier src/features/assistant/. Le reste du bureau ne change pas.

Vous pouvez réutiliser les parties du bureau qui n’affichent rien. Il s’agit des fonctions et types d’API dans src/api/ (listTickets, getTicket, createTicket, addMessage). Cela comprend aussi les hooks (fonctions React réutilisables) useTicket, useAddMessage, useDraftStream, useJobPolling et useJobActions. Vous pouvez également réutiliser describeError, renderMarkdown et LiveRegion. Vous écrivez la requête de liste, car la liste de facturation contient des pages de 20, ainsi que chaque composant de l’écran. Vous décidez où chaque élément d’état réside. Copier TicketList, TicketView, DraftPanel ou JobStatus dans le nouveau dossier ne constitue pas votre travail. Le réviseur cherche vos propres limites et vos propres raisons.

Utilise Bases de React, Organiser par responsabilité, État local et état serveur et Pagination et formulaires.

  1. Ajoutez la route. Dans src/router.ts, ajoutez { page: 'assistant' } à Route, et faites retourner cette valeur par parseRoute pour #/assistant. Ajoutez un lien Assistant de facturation dans l’en-tête de App.tsx. Chargez le nouvel écran avec lazy(), comme la page des exercices pratiques.
  2. La liste. Affichez les billets de facturation ouverts (status=open, team=billing), par pages serveur de 20, avec un curseur et un bouton Charger plus. Ajoutez un champ de recherche. Une ancienne réponse de recherche ne doit jamais remplacer une réponse plus récente.
  3. Le billet sélectionné. Un clic ou Entrée sur une ligne sélectionne le billet. Affichez son objet et le dernier message du client.
  4. La vue du brouillon. Pour le billet sélectionné, affichez le brouillon d’IA en flux continu avec un seul bouton Rédiger un brouillon / Arrêter. Affichez les huit états du brouillon, comme le bureau. Seul done (terminé) propose Utiliser ce brouillon, qui remplit un champ de réponse. Affichez les sources, needs_human (intervention humaine nécessaire), et le niveau de confiance lorsqu’il n’est pas high (élevé). Affichez le Markdown du brouillon terminé uniquement avec renderMarkdown.
  5. Un nouveau billet de facturation. Un petit formulaire (identifiant du client, objet, message) envoie POST /v1/tickets avec une clé d’idempotence. Ensuite, il suit la tâche par interrogation périodique et décrit ses six états en mots. Proposez Annuler pendant l’état queued (en attente), et Réessayer uniquement pour dead_letter (échec définitif).
  6. Dessinez l’arbre des composants de votre écran dans docs/assistant.md, comme dans Qui possède chaque valeur. Pour chaque élément d’état, nommez son propriétaire et son type. Les types sont l’état local (texte de recherche, billet sélectionné), l’état serveur en cache (pages de liste, billet, tâche) et la machine à états du brouillon. Justifiez chacun en une phrase.

Partie 2 : états de chargement, d’erreur et d’annulation

Section intitulée « Partie 2 : états de chargement, d’erreur et d’annulation »

Utilise Cycle de vie d’une requête, Interfaces en flux continu, Traitement en arrière-plan et Une rétroaction digne de confiance.

Chaque état possible de l’écran exige ses propres mots, ses propres boutons et un test. Écrivez des tests de composants avec la fausse API (installFakeApi, sseResponse, openStream) pour au moins ces situations :

Partie de l’écran Situations à tester
La liste chargement; première page; Charger plus ajoute 20 billets; aucun billet correspondant; serveur occupé (503 avec Retry-After) avec Réessayer
Le brouillon terminé (done); arrêté par l’agent; connexion interrompue; événement error (erreur); brouillon refusé (invalid, invalide); billet sans brouillon (no_draft, aucun brouillon, sans Réessayer)
La tâche queued avec Annuler; succeeded (réussie) avec l’équipe; failed (échouée) sans bouton; dead_letter avec Réessayer
Les formulaires nouveau billet refusé par l’API (invalid_request, requête invalide, avec le champ indiqué); réponse dont l’envoi échoue (503), qui conserve le texte saisi par l’agent

Vérifiez ensuite les mêmes états dans le navigateur, avec les modes simulés de l’API : --list fail, --stream interrupt, --stream error, --jobs fail, --jobs dead_letter et --writes fail (pour la réponse). Prenez une capture d’écran de chacun et ajoutez la mention simulé à chacune.

Arrêter doit fermer la connexion, pas seulement changer les mots. Montrez-le : après Arrêter, http://127.0.0.1:8100/admin/stats compte un stopped_by_client (arrêté par le client) de plus.

Utilise Mesurer dans le navigateur, Charger moins de travail et Décisions d’architecture.

Trouvez une attente réelle dans votre écran, modifiez une chose, puis mesurez de nouveau de la même façon. Choisissez l’une de ces options, ou la vôtre :

  • Rendu. Laissez la liste de facturation conserver chaque page que l’agent charge. Avec le grand jeu de données, chargez 1 000 lignes ou plus. Comparez le rendu de toutes les lignes à celui des seules lignes visibles.
  • Téléchargement. Comparez le premier fichier JavaScript contenant votre écran à celui obtenu avec le chargement différé de votre écran. Utilisez npm run size, et mesurez l’arrivée des premières lignes avec le profil qui simule un téléphone.
  • Travail pendant la saisie. Utilisez React Profiler sur la version de profilage (npm run build:profile) pendant la saisie dans le champ de recherche ou de réponse. Déplacez ensuite l’état qui cause le rendu supplémentaire.
  1. Écrivez d’abord la question en une phrase : ce que l’agent attend et comment vous le mesurerez.
  2. Mesurez la version avant la modification : version de production ou de profilage, jamais npm run dev; même ralentissement chaque fois; au moins 3 essais; médiane et étendue.
  3. Faites une seule modification. N’ajoutez aucun memo sans qu’une mesure le justifie.
  4. Mesurez après la modification, exactement de la même façon.
  5. Ajoutez une ligne à docs/performance-note.md : question, ordinateur, conditions, valeurs avant et après, et modification. Si le gain est inférieur à l’écart entre les essais, dites-le.

Les résultats du cours peuvent vous aider à juger les vôtres, mais ce ne sont pas des cibles. Sur le portable de l’équipe du cours, le rendu des 10 000 lignes prenait 274,3 ms, contre 29,6 ms pour les lignes visibles. Jusqu’à 1 000 lignes, il n’y avait aucun gain réel. Le découpage du code a retiré 30,8 ko du premier fichier. Les premières lignes arrivaient 144 ms plus tôt avec le profil simulant un téléphone, mais pas plus tôt sur un réseau rapide. Un constat honnête comme « aucun gain réel, et voici pourquoi », appuyé par de bonnes mesures, peut servir de démonstration. Un grand chiffre mesuré sur le serveur de développement ne le peut pas.

Utilise L’essentiel de HTML et CSS, Interactions accessibles et Tester et livrer.

  1. Effectuez la tâche principale au clavier seulement : du lien d’évitement à la recherche, puis à un billet, puis à Rédiger un brouillon, Arrêter ou Utiliser ce brouillon, puis au champ de réponse. Notez où se trouve le focus après chaque touche.
  2. Déplacez le focus uniquement là où l’agent a demandé du nouveau contenu : titre du billet sélectionné, résultat d’un formulaire envoyé. Une tâche qui se termine en arrière-plan reçoit un message d’état, jamais le focus.
  3. Donnez au brouillon une seule région dynamique qui annonce chaque changement d’état une fois. Ne placez jamais le texte en flux continu dans une région dynamique.
  4. Dans le volet Accessibility (accessibilité) de Chrome, vérifiez que chaque commande possède un nom accessible. Vérifiez que chaque couleur de texte ajoutée présente un contraste d’au moins 4,5 pour 1.
  5. Ajoutez un parcours de bout en bout, e2e/assistant.spec.ts. Au clavier, il sélectionne un billet de facturation, rédige un brouillon et l’utilise. Il vérifie le focus et l’état à chaque étape. Il doit réussir sur ordinateur et sur un écran de téléphone.

Montrez chacun avec une sortie, un test ou une capture d’écran, et indiquez le mode de l’API simulée utilisé. Étiquetez chaque cas construit ou simulé.

  1. Jamais le jeu de données entier. Le panneau Network (réseau) montre une requête de liste par page de 20, jamais 100 requêtes pour tous les billets.
  2. Jamais une ancienne recherche. Avec --list slow, tapez rapidement un mot. La liste montre les résultats du mot entier, et les requêtes pour les mots plus courts ont été annulées.
  3. Jamais un demi-brouillon présenté comme terminé. Avec --stream interrupt, le texte partiel est gris, le message indique qu’il est incomplet et Utiliser ce brouillon est absent.
  4. Jamais de secret dans le navigateur. Placez VITE_PROVIDER_API_KEY=demo-not-a-real-key dans .env, construisez le projet et montrez que npm run check:bundle échoue. Retirez la ligne, construisez le projet et montrez que la vérification réussit.
  5. Jamais de code provenant d’un brouillon. Ouvrez le billet d’exercice T-80010 dans votre vue du brouillon. Son brouillon terminé affiche une liste mise en forme, et aucune boîte de dialogue ne s’ouvre.

Avant de remettre votre travail, prouvez que le projet fonctionne en partant de zéro :

  1. Copiez le projet dans un nouveau dossier, sans node_modules, dist ni .env.
  2. Exécutez npm ci.
  3. Exécutez npm run check. La commande termine avec les tests, la construction, No secret found in … files of dist/. (aucun secret trouvé dans les fichiers de dist/) et le rapport de taille.
  4. Exécutez npm run test:e2e. Tous les parcours réussissent, y compris le vôtre.
  5. Lancez npm run api et npm run dev, puis ouvrez http://localhost:5173/#/assistant.

Collez les commandes et les dernières lignes de leurs sorties dans votre rapport. Si une étape nécessitait un élément absent du README, ajoutez-le au README et recommencez les étapes.

Une amélioration au choix : le focus après Envoyer la réponse

Section intitulée « Une amélioration au choix : le focus après Envoyer la réponse »

Interactions accessibles a laissé une lacune, et le document de remise la présente comme une limite connue. Après Envoyer la réponse, le bouton est désactivé pendant l’envoi, et le focus revient à la page. Un lecteur d’écran entend encore « Envoyé. », mais une personne au clavier repart du haut de la page.

Corrigez cette lacune dans le formulaire de réponse de votre écran, ou dans MessageForm.tsx du bureau. Déplacez le focus vers le résultat, comme le fait le formulaire de nouveau billet. Prouvez-le avec un test de composant qui vérifie le focus après l’envoi, et avec votre parcours de bout en bout. Retirez ensuite la limite de docs/handoff.md. Cette amélioration est facultative. Elle peut améliorer un critère clavier partiellement démontré, mais ne remplace aucune étape obligatoire.

Votre dossier de projet (sans node_modules, dist ni .env), avec src/features/assistant/, ses tests, e2e/assistant.spec.ts, docs/assistant.md, la nouvelle ligne de docs/performance-note.md et REPORT.md :

# Larkfield billing assistant
## Component and state boundaries (the tree; each piece of state with its owner, its kind and
why; what you reused from the desk, and what you wrote)
## Loading, error and cancellation (the states table with the test for each; the simulated
modes with a screenshot each; Stop closes the connection)
## Performance (the question; before and after, with the computer, the
conditions, the runs, the median and the range; the change)
## Keyboard and screen reader (the focus after each key press; the live region's sentences;
names and contrast; the end-to-end flow's output)
## Failure paths (each of the five, with its evidence)
## Fresh-environment run (the commands and their last lines)
## Limits (recorded and simulated answers, your computer and browser,
what you did not test)

Un réviseur évalue chaque élément requis comme démontré, partiellement démontré ou pas encore démontré, avec une raison concrète. Pour terminer le cours, vous devez démontrer les quatre éléments. Vous pouvez améliorer un élément et le soumettre à nouveau.

Élément requis Démontré Partiellement démontré, par exemple Pas encore démontré, par exemple
Limites claires des composants et de l’état L’arborescence dans docs/assistant.md correspond au code. Chaque élément d’état a un seul propriétaire et le bon type. Les données serveur sont dans le cache. Le texte de recherche et la sélection sont dans l’état local. Le brouillon est dans sa machine à états. Chaque choix a une raison. Les composants de l’écran sont les vôtres. Les limites sont bonnes, mais le document ne donne aucune raison. Ou une valeur est conservée deux fois, par exemple la liste dans le cache et dans l’état local. Les données serveur sont copiées dans l’état local et deviennent périmées. Ou le nouveau dossier contient les composants du bureau sous de nouveaux noms.
États de chargement, d’erreur et d’annulation corrects Chaque situation du tableau a ses textes, ses boutons et un test qui réussit. Les modes simulés sont affichés à l’écran. Seul un brouillon terminé propose Use this draft (utiliser ce brouillon). Try again (réessayer) apparaît seulement quand cela peut aider, et Stop (arrêter) ferme la connexion. La plupart des états sont testés, mais une fin manque. Ou Stop change le texte, mais la requête reste ouverte. Un brouillon arrêté ou interrompu peut être utilisé comme s’il était terminé. Ou chaque erreur affiche le message de l’API avec Try again.
Amélioration mesurée de la performance Une question est formulée, puis mesurée avant et après de la même façon. Une version de production ou de profilage, les mêmes limites de vitesse, au moins 3 essais, la médiane et l’étendue. Un seul changement et une note honnête. Le changement est mesuré, mais une seule fois, ou les conditions ne sont pas notées. La mesure se fait sur le serveur de développement. Ou « ça semble plus rapide » est la seule preuve. Ou memo a été ajouté partout sans mesure.
Interactions accessibles au clavier La tâche principale fonctionne au clavier seulement. Le focus passe au nouveau contenu. La région dynamique annonce chaque changement d’état une seule fois. Chaque commande a un nom, et le parcours de bout en bout réussit sur les deux écrans. La tâche fonctionne au clavier, mais le focus se perd après une étape. Ou il n’y a aucun parcours de bout en bout. Une étape exige la souris. Ou le texte reçu en flux continu est dans une région dynamique. Ou une commande n’a pas de nom.

Même si le reste est solide, le travail reste incomplet si un secret se trouve dans dist/. Il reste aussi incomplet si un brouillon terminé peut exécuter du code du modèle. Même chose si l’écran télécharge tous les billets de soutien pour afficher une seule page. Un écran rapide ou attrayant ne compense aucun de ces problèmes.

Erreur courante

#/assistant affiche la liste des billets

Symptôme : vous ouvrez http://localhost:5173/#/assistant, et le bureau affiche sa liste de billets au lieu de votre écran.

Cause : parseRoute renvoie la liste des billets pour chaque adresse qu’il ne connaît pas. Il ne connaît pas encore assistant.

Correction : ajoutez une ligne avant son dernier return : if (parts[0] === 'assistant') return { page: 'assistant' };. Ajoutez la page au type Route, puis ajoutez une vérification dans src/router.test.ts.

Erreur courante

La recherche affiche les résultats d'un ancien mot

Symptôme : avec --list slow, vous tapez rapidement « refund » (remboursement), et la liste affiche les résultats pour « r ».

Cause : la liste charge ses données dans un effet sans nettoyage, ou avec une clé de requête sans la recherche. La réponse lente pour « r » arrive en dernier et remplace les autres.

Correction : utilisez une requête dont la clé contient la recherche, comme le fait useTicketList. Transmettez le signal de la requête à listTickets. Une ancienne réponse arrive en dernier montre la course et la correction.

Récapitulatif

Dans ce cours, vous avez construit le bureau des billets de Larkfield, un module à la fois :

  • Le Web : HTML, CSS et JavaScript dans le navigateur, puis npm, Vite et TypeScript. Ensuite, la vérification CORS entre le bureau et l’API.
  • Les composants : composants React et état, organisés par responsabilité, avec des effets qui effectuent leur nettoyage.
  • Les données serveur : un cache avec des clés, des nouvelles tentatives et l’annulation. Des pages avec un curseur et des formulaires jamais envoyés deux fois.
  • Les états d’IA : un brouillon en flux continu avec Stop et huit états. Une tâche en arrière-plan décrite en mots, et des brouillons avec leurs sources et leur incertitude.
  • La performance : mesurer d’abord, puis réduire ce qu’il faut télécharger et afficher, et documenter une décision de rendu.
  • La livraison : du Markdown sûr, aucun secret dans le navigateur et un bureau qui fonctionne au clavier. Des tests des composants jusqu’à un parcours réel, et une remise du travail avec des preuves.

Si vous n’en avez pas encore fait, choisissez une étude de cas pour le certificat : Recherche rapide dans un jeu de données public ou Rendre accessible une interface de chat d’IA.