React et accessibilité
Formulaire React accessible : gérer les erreurs côté serveur
Un formulaire peut sembler terminé parce que ses champs sont alignés et son bouton animé. Il reste pourtant inutilisable si une erreur n’est signalée que par une bordure rouge, si les valeurs disparaissent après un refus du serveur ou si un lecteur d’écran ne sait pas ce qui a changé. La qualité se mesure surtout au moment où quelque chose ne se passe pas comme prévu.
Ce guide construit une méthode pour React 19 et une API serveur. Le scénario est un formulaire de contact fictif comportant une adresse électronique et un message. Les extraits montrent le contrat d’interface et la validation ; ils ne prétendent pas envoyer un courriel. L’envoi réel doit être relié à un service et confirmé par son résultat.
Définir les états avant les styles
Écrivez d’abord les états visibles : formulaire initial, saisie en cours, soumission, erreurs de champs, échec technique et réussite réelle. Chaque état doit répondre à trois questions : que s’est-il passé, que peut faire la personne, et ses données sont-elles conservées ?
Une erreur de saisie et une panne réseau ne doivent pas recevoir le même message. « Vérifiez votre adresse » accuse à tort l’utilisateur si le serveur est indisponible. Inversement, « Une erreur est survenue » ne l’aide pas lorsqu’un message est trop court. Cette distinction doit exister dans la réponse de l’API, pas seulement dans la traduction de l’interface.
Pour un formulaire administratif, ajoutez les refus d’autorisation et les conflits de modification. Une validation syntaxique réussie ne signifie pas que l’utilisateur possède le droit d’enregistrer la ressource. Les contrôles de session, d’origine et de rôle appartiennent au serveur qui effectue l’opération.
Associer le champ, son aide et son erreur
Un placeholder n’est pas un label permanent. Il disparaît au moment où l’on saisit et ne doit pas porter seul l’information attendue. Utilisez un label visible, une aide concise et un message d’erreur relié au champ. Les recommandations WAI sur les notifications de formulaires détaillent ces associations et la gestion des erreurs après soumission.
Voici un composant de champ contrôlé. Il ne déclenche pas de validation à chaque caractère ; son parent lui fournit une erreur lorsque le moment est pertinent. Le nom d’autocomplétion aide le navigateur à proposer l’adresse connue.
import { useId } from 'react';
type EmailFieldProps = {
value: string;
error?: string;
onChange: (value: string) => void;
};
export function EmailField({ value, error, onChange }: EmailFieldProps) {
const id = useId();
const helpId = `${id}-help`;
const errorId = `${id}-error`;
return (
<div>
<label htmlFor={id}>Votre adresse électronique</label>
<p id={helpId}>Elle servira à répondre à votre message.</p>
<input
id={id}
name="email"
type="email"
autoComplete="email"
required
maxLength={254}
value={value}
onChange={event => onChange(event.target.value)}
aria-invalid={error ? true : undefined}
aria-describedby={`${helpId}${error ? ` ${errorId}` : ''}`}
/>
{error && <p id={errorId}>{error}</p>}
</div>
);
}L’identifiant créé par useId évite de réutiliser un identifiant fixe si le champ apparaît plusieurs fois. Dans l’App Router, ce composant appartient à une frontière client puisqu’il participe à une interaction. Le guide sur use client explique où placer cette frontière sans déplacer toute la page.
Garder une validation serveur indépendante du navigateur
Les attributs HTML améliorent l’expérience mais peuvent être contournés par une requête manuelle. Le serveur doit lire un format attendu, limiter la taille des entrées et renvoyer des erreurs stables. Il ne doit pas faire confiance à une propriété isValid envoyée par le client.
L’exemple ci-dessous utilise les schémas de validation de Zod 4 dans une fonction serveur. Il ne journalise pas le contenu personnel et ne renvoie pas d’exception interne. Les seuils sont des choix de démonstration à ajuster aux besoins du formulaire.
import { z } from 'zod';
const contactSchema = z.object({
email: z.string().trim().max(254).email('Adresse non valide.'),
message: z.string().trim()
.min(20, 'Ajoutez quelques précisions à votre message.')
.max(4000, 'Limitez votre message à 4 000 caractères.'),
}).strict();
export function validateContact(input: unknown) {
const result = contactSchema.safeParse(input);
if (result.success) return { ok: true as const, data: result.data };
const errors: Record<string, string> = {};
for (const issue of result.error.issues) {
const field = String(issue.path[0] ?? '_form');
errors[field] ??= issue.message;
}
return { ok: false as const, errors };
}Cette fonction valide uniquement les données. Le point d’entrée HTTP doit également limiter le corps de requête, gérer un JSON invalide et appliquer les protections adaptées. Pour un contact public, une limitation de fréquence et une stratégie contre les abus sont utiles. Pour une écriture authentifiée, l’autorisation et la protection contre les requêtes intersites sont essentielles.
Évitez d’ajouter automatiquement un CAPTCHA intrusif avant d’avoir évalué le problème. Si une protection supplémentaire devient nécessaire, testez son accessibilité, son comportement en cas de panne et les données qu’elle transmet. La sécurité et l’utilisabilité doivent être conçues ensemble.
Conserver les valeurs pendant la correction
Le refus du serveur doit enrichir le formulaire existant, pas le remplacer par une page vide. Avec des champs contrôlés, gardez les valeurs dans leur état et mettez à jour uniquement les erreurs correspondantes. Ne réinitialisez le message qu’après une confirmation réelle de l’opération prévue.
Pour les formulaires utilisant une action React, vérifiez également les règles de remise à zéro des champs non contrôlés. La référence du composant form décrit ce comportement. Choisir une API de soumission sans tester la conservation des données peut produire une régression invisible sur le parcours de réussite.
Prévoyez le cas où une personne modifie un champ pendant qu’une réponse précédente arrive. Désactiver toute saisie est une possibilité, mais elle peut être frustrante. Une autre approche consiste à conserver un identifiant de soumission ou un instantané des valeurs, pour ne pas appliquer une ancienne erreur à un contenu déjà corrigé.
Annoncer le résultat et déplacer le focus avec mesure
Après une soumission refusée, un résumé d’erreurs peut apparaître avant les champs, avec des liens vers chacun d’eux. Rendez ce résumé focalisable et déplacez le focus seulement à la suite de cette action utilisateur. Une validation silencieuse pendant la saisie ne devrait pas déplacer le curseur.
Un message de réussite peut utiliser une zone de statut pour être annoncé sans interrompre brutalement la lecture. Évitez d’ajouter simultanément plusieurs régions d’alerte qui répètent chaque erreur. Le résultat doit être intelligible à l’oreille autant qu’à l’écran.
Pour le bouton, indiquez une soumission en cours avec un texte explicite. Empêcher les clics répétés aide l’interface, mais ne garantit pas l’unicité d’une opération. Une commande ou un paiement exige aussi une protection serveur adaptée. Même un simple contact doit éviter de présenter deux confirmations contradictoires après un double clic.
Tester les scénarios difficiles
Commencez au clavier : tous les champs et boutons doivent être atteignables dans un ordre logique. Vérifiez que le focus est visible, que les labels restent présents et que les erreurs ne dépendent pas uniquement d’une couleur. Agrandissez le texte et réduisez la largeur de fenêtre pour observer les messages longs.
Testez ensuite une adresse invalide, un message vide, une réponse lente, une panne réseau et un refus serveur après une validation locale réussie. Rechargez la page après une erreur et décidez explicitement si la persistance des valeurs est souhaitable. Enregistrer automatiquement des messages personnels dans le stockage local n’est pas un choix neutre.
Un audit automatique détecte certains défauts, mais il ne sait pas toujours si un message permet réellement de corriger une saisie. Faites au moins un parcours avec un lecteur d’écran et une vérification manuelle des annonces. Pour les ralentissements pendant la frappe, le guide INP et React aide à isoler le travail inutile.
Questions fréquentes
Faut-il une bibliothèque de formulaires ?
Pas systématiquement. Deux champs simples peuvent rester lisibles avec React et un schéma serveur. Une bibliothèque devient intéressante pour les tableaux de champs, les règles conditionnelles ou les formulaires volumineux. Elle ne remplace pas le contrat d’erreur ni les vérifications d’accessibilité.
Peut-on partager le schéma entre client et serveur ?
Oui, pour des contraintes communes qui ne contiennent pas de secrets. Le serveur doit néanmoins exécuter sa propre validation et ses contrôles d’autorisation. Les messages destinés au navigateur doivent rester distincts des informations techniques sensibles.
Que doit annoncer le message de réussite ?
Exactement ce qui est confirmé. « Message enregistré » n’équivaut pas à « courriel délivré ». Si un traitement est asynchrone, décrivez cette étape sans promettre un résultat encore inconnu. Cette attention aux parcours fait partie des expertises présentées sur le portfolio.