Modèles d'interface React (React UI Patterns)
Principes Fondamentaux
- Ne jamais afficher une interface obsolète - Indicateurs de chargement uniquement en cas de chargement effectif
- Toujours faire apparaître les erreurs - Les utilisateurs doivent savoir quand quelque chose échoue
- Mises à jour optimistes - Rendre l'interface instantanée
- Divulgation progressive - Afficher le contenu au fur et à mesure qu'il devient disponible
- Dégradation gracieuse - Des données partielles valent mieux que pas de données du tout
Modèles d'État de Chargement
La Règle d'Or
Afficher l'indicateur de chargement UNIQUEMENT lorsqu'il n'y a aucune donnée à afficher.
// CORRECT - Afficher le chargement uniquement quand il n'y a pas de données
const { data, loading, error } = useGetItemsQuery();
if (error) return <ErrorState error={error} onRetry={refetch} />;
if (loading && !data) return <LoadingState />;
if (!data?.items.length) return <EmptyState />;
return <ItemList items={data.items} />;
// INCORRECT - Affiche un spinner même quand on a des données en cache
if (loading) return <LoadingState />; // Flash au rechargement !
Arbre de Décision pour l'État de Chargement
Y a-t-il une erreur ?
→ Oui : Afficher l'état d'erreur avec option de réessai
→ Non : Continuer
Est-ce en cours de chargement ET nous n'avons pas de données ?
→ Oui : Afficher l'indicateur de chargement (spinner/squelette)
→ Non : Continuer
Avons-nous des données ?
→ Oui, avec éléments : Afficher les données
→ Oui, mais vide : Afficher l'état vide
→ Non : Afficher le chargement (solution de repli)
Squelette vs Spinner
| Utiliser un Squelette Quand | Utiliser un Spinner Quand |
|---|---|
| La forme du contenu est connue | La forme du contenu est inconnue |
| Dispositions de listes/cartes | Actions modales |
| Chargement initial de la page | Soumissions de boutons |
| Espaces réservés de contenu | Opérations en ligne |
Modèles de Gestion des Erreurs
Hiérarchie de Gestion des Erreurs
1. Erreur en ligne (au niveau du champ) → Erreurs de validation de formulaire
2. Notification toast → Erreurs récupérables, l'utilisateur peut réessayer
3. Bannière d'erreur → Erreurs au niveau de la page, données encore partiellement utilisables
4. Écran d'erreur complet → Non récupérable, nécessite une action de l'utilisateur
Toujours Afficher les Erreurs
CRITIQUE : Ne jamais avaler les erreurs silencieusement.
// CORRECT - L'erreur est toujours présentée à l'utilisateur
const [createItem, { loading }] = useCreateItemMutation({
onCompleted: () => {
toast.success({ title: 'Élément créé' });
},
onError: (error) => {
console.error('createItem a échoué:', error);
toast.error({ title: 'Échec de la création de l\'élément' });
},
});
// INCORRECT - Erreur avalée silencieusement, l'utilisateur ne sait rien
const [createItem] = useCreateItemMutation({
onError: (error) => {
console.error(error); // L'utilisateur ne voit rien !
},
});
Modèle de Composant d'État d'Erreur
interface ErrorStateProps {
error: Error;
onRetry?: () => void;
title?: string;
}
const ErrorState = ({ error, onRetry, title }: ErrorStateProps) => (
<div className="error-state">
<Icon name="exclamation-circle" />
<h3>{title ?? 'Quelque chose s\'est mal passé'}</h3>
<p>{error.message}</p>
{onRetry && (
<Button onClick={onRetry}>Réessayer</Button>
)}
</div>
);
Modèles d'État des Boutons
État de Chargement du Bouton
<Button
onClick={handleSubmit}
isLoading={isSubmitting}
disabled={!isValid || isSubmitting}
>
Soumettre
</Button>
Désactiver Pendant les Opérations
CRITIQUE : Toujours désactiver les déclencheurs pendant les opérations asynchrones.
// CORRECT - Bouton désactivé pendant le chargement
<Button
disabled={isSubmitting}
isLoading={isSubmitting}
onClick={handleSubmit}
>
Soumettre
</Button>
// INCORRECT - L'utilisateur peut appuyer plusieurs fois
<Button onClick={handleSubmit}>
{isSubmitting ? 'Soumission en cours...' : 'Soumettre'}
</Button>
États Vides
Exigences pour l'État Vide
Chaque liste/collection DOIT avoir un état vide :
// INCORRECT - Aucun état vide
return <FlatList data={items} />;
// CORRECT - État vide explicite
return (
<FlatList
data={items}
ListEmptyComponent={<EmptyState />}
/>
);
États Vides Contextuels
// Recherche sans résultats
<EmptyState
icon="search"
title="Aucun résultat trouvé"
description="Essayez d'autres termes de recherche"
/>
// Liste sans éléments pour le moment
<EmptyState
icon="plus-circle"
title="Aucun élément pour le moment"
description="Créez votre premier élément"
action={{ label: 'Créer un élément', onClick: handleCreate }}
/>
Modèle de Soumission de Formulaire
const MyForm = () => {
const [submit, { loading }] = useSubmitMutation({
onCompleted: handleSuccess,
onError: handleError,
});
const handleSubmit = async () => {
if (!isValid) {
toast.error({ title: 'Veuillez corriger les erreurs' });
return;
}
await submit({ variables: { input: values } });
};
return (
<form>
<Input
value={values.name}
onChange={handleChange('name')}
error={touched.name ? errors.name : undefined}
/>
<Button
type="submit"
onClick={handleSubmit}
disabled={!isValid || loading}
isLoading={loading}
>
Soumettre
</Button>
</form>
);
};
Anti-Patterns
États de Chargement
// INCORRECT - Spinner quand les données existent (provoque un flash)
if (loading) return <Spinner />;
// CORRECT - Afficher le chargement uniquement sans données
if (loading && !data) return <Spinner />;
Gestion des Erreurs
// INCORRECT - Erreur avalée
try {
await mutation();
} catch (e) {
console.log(e); // L'utilisateur ne sait rien !
}
// CORRECT - Erreur présentée
onError: (error) => {
console.error('opération échouée:', error);
toast.error({ title: 'Opération échouée' });
}
États des Boutons
// INCORRECT - Bouton non désactivé pendant la soumission
<Button onClick={submit}>Soumettre</Button>
// CORRECT - Désactivé et affiche le chargement
<Button onClick={submit} disabled={loading} isLoading={loading}>
Soumettre
</Button>
Liste de Vérification
Avant de finaliser tout composant d'interface :
États d'interface :
- L'état d'erreur est géré et affiché à l'utilisateur
- L'état de chargement est affiché uniquement quand il n'y a pas de données
- Un état vide est fourni pour les collections
- Les boutons sont désactivés pendant les opérations asynchrones
- Les boutons affichent un indicateur de chargement quand c'est approprié
Données et mutations :
- Les mutations ont un gestionnaire onError
- Toutes les actions utilisateur ont un retour (toast/visuel)
Intégration avec d'Autres Compétences
- graphql-schema : Utiliser les motifs de mutation avec une gestion appropriée des erreurs
- testing-patterns : Tester tous les états d'interface (chargement, erreur, vide, succès)
- formik-patterns : Appliquer les motifs de soumission de formulaire