Motifs d'interface Angular
Principes Fondamentaux
- Ne jamais afficher d'interface obsolète - États de chargement uniquement lors du chargement effectif
- Toujours faire remonter les erreurs - Les utilisateurs doivent savoir quand quelque chose échoue
- Mises à jour optimistes - Rendre l'interface instantanée
- Divulgation progressive - Utiliser
@deferpour afficher le contenu au fur et à mesure - Dégradation gracieuse - Des données partielles valent mieux que pas de données du tout
Motifs d'état de chargement
La règle d'or
Afficher l'indicateur de chargement UNIQUEMENT lorsqu'il n'y a pas de données à afficher.
@Component({
template: `
@if (error()) {
<app-error-state [error]="error()" (retry)="load()" />
} @else if (loading() && !items().length) {
<app-skeleton-list />
} @else if (!items().length) {
<app-empty-state message="Aucun élément trouvé" />
} @else {
<app-item-list [items]="items()" />
}
`,
})
export class ItemListComponent {
private store = inject(ItemStore);
items = this.store.items;
loading = this.store.loading;
error = this.store.error;
}
Arbre de décision de 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 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 des éléments : Afficher les données
→ Oui, mais vides : Afficher l'état vide
→ Non : Afficher le chargement (solution de repli)
Squelette vs Spinner
| Utiliser un squelette quand | Utiliser un spinner quand |
|---|---|
| Forme de contenu connue | Forme de contenu inconnue |
| Dispositions de liste/carte | Actions de modale |
| Chargement initial de page | Soumissions de bouton |
| Espaces réservés de contenu | Opérations en ligne |
Motifs de flux de contrôle
@if/@else pour le rendu conditionnel
@if (user(); as user) {
<span>Bienvenue, {{ user.name }}</span>
} @else if (loading()) {
<app-spinner size="small" />
} @else {
<a routerLink="/login">Se connecter</a>
}
@for avec Track
@for (item of items(); track item.id) {
<app-item-card [item]="item" (delete)="remove(item.id)" />
} @empty {
<app-empty-state
icon="inbox"
message="Pas encore d'éléments"
actionLabel="Créer un élément"
(action)="create()"
/>
}
@defer pour le chargement progressif
<!-- Le contenu critique se charge immédiatement -->
<app-header />
<app-hero-section />
<!-- Le contenu non critique est différé -->
@defer (on viewport) {
<app-comments [postId]="postId()" />
} @placeholder {
<div class="h-32 bg-gray-100 animate-pulse"></div>
} @loading (minimum 200ms) {
<app-spinner />
} @error {
<app-error-state message="Échec du chargement des commentaires" />
}
Motifs de gestion des erreurs
Hiérarchie de gestion des erreurs
1. Erreur en ligne (niveau 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 exploitables
4. Écran d'erreur complet → Irrécupérable, nécessite une action de l'utilisateur
Toujours afficher les erreurs
CRITIQUE : Ne jamais avaler les erreurs en silence.
// CORRECT - L'erreur est toujours remontée à l'utilisateur
@Component({...})
export class CreateItemComponent {
private store = inject(ItemStore);
private toast = inject(ToastService);
async create(data: CreateItemDto) {
try {
await this.store.create(data);
this.toast.success('Élément créé avec succès');
this.router.navigate(['/items']);
} catch (error) {
console.error('createItem a échoué :', error);
this.toast.error('Échec de la création de l\'élément. Veuillez réessayer.');
}
}
}
// INCORRECT - Erreur avalée silencieusement
async create(data: CreateItemDto) {
try {
await this.store.create(data);
} catch (error) {
console.error(error); // L'utilisateur ne voit rien !
}
}
Motif de composant d'état d'erreur
@Component({
selector: "app-error-state",
standalone: true,
imports: [NgOptimizedImage],
template: `
<div class="error-state">
<img ngSrc="/assets/error-icon.svg" width="64" height="64" alt="" />
<h3>{{ title() }}</h3>
<p>{{ message() }}</p>
@if (retry.observed) {
<button (click)="retry.emit()" class="btn-primary">Réessayer</button>
}
</div>
`,
})
export class ErrorStateComponent {
title = input("Une erreur est survenue");
message = input("Une erreur inattendue s'est produite");
retry = output<void>();
}
Motifs d'état des boutons
État de chargement du bouton
<button
(click)="handleSubmit()"
[disabled]="isSubmitting() || !form.valid"
class="btn-primary"
>
@if (isSubmitting()) {
<app-spinner size="small" class="mr-2" />
Enregistrement... } @else { Enregistrer les modifications }
</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
@Component({
template: `
<button
[disabled]="saving()"
(click)="save()"
>
@if (saving()) {
<app-spinner size="sm" /> Enregistrement...
} @else {
Enregistrer
}
</button>
`
})
export class SaveButtonComponent {
saving = signal(false);
async save() {
this.saving.set(true);
try {
await this.service.save();
} finally {
this.saving.set(false);
}
}
}
// INCORRECT - L'utilisateur peut cliquer plusieurs fois
<button (click)="save()">
{{ saving() ? 'Enregistrement...' : 'Enregistrer' }}
</button>
États vides
Exigences pour les états vides
Chaque liste/collection DOIT avoir un état vide :
@for (item of items(); track item.id) {
<app-item-card [item]="item" />
} @empty {
<app-empty-state
icon="folder-open"
title="Pas encore d'éléments"
description="Créez votre premier élément pour commencer"
actionLabel="Créer un élément"
(action)="openCreateDialog()"
/>
}
États vides contextuels
@Component({
selector: "app-empty-state",
template: `
<div class="empty-state">
<span class="icon" [class]="icon()"></span>
<h3>{{ title() }}</h3>
<p>{{ description() }}</p>
@if (actionLabel()) {
<button (click)="action.emit()" class="btn-primary">
{{ actionLabel() }}
</button>
}
</div>
`,
})
export class EmptyStateComponent {
icon = input("inbox");
title = input.required<string>();
description = input("");
actionLabel = input<string | null>(null);
action = output<void>();
}
Motifs de formulaires
Formulaire avec chargement et validation
@Component({
template: `
<form [formGroup]="form" (ngSubmit)="onSubmit()">
<div class="form-field">
<label for="name">Nom</label>
<input
id="name"
formControlName="name"
[class.error]="isFieldInvalid('name')"
/>
@if (isFieldInvalid("name")) {
<span class="error-text">
{{ getFieldError("name") }}
</span>
}
</div>
<div class="form-field">
<label for="email">Email</label>
<input id="email" type="email" formControlName="email" />
@if (isFieldInvalid("email")) {
<span class="error-text">
{{ getFieldError("email") }}
</span>
}
</div>
<button type="submit" [disabled]="form.invalid || submitting()">
@if (submitting()) {
<app-spinner size="sm" /> Soumission en cours...
} @else {
Soumettre
}
</button>
</form>
`,
})
export class UserFormComponent {
private fb = inject(FormBuilder);
submitting = signal(false);
form = this.fb.group({
name: ["", [Validators.required, Validators.minLength(2)]],
email: ["", [Validators.required, Validators.email]],
});
isFieldInvalid(field: string): boolean {
const control = this.form.get(field);
return control ? control.invalid && control.touched : false;
}
getFieldError(field: string): string {
const control = this.form.get(field);
if (control?.hasError("required")) return "Ce champ est requis";
if (control?.hasError("email")) return "Format d'email invalide";
if (control?.hasError("minlength")) return "Trop court";
return "";
}
async onSubmit() {
if (this.form.invalid) return;
this.submitting.set(true);
try {
await this.service.submit(this.form.value);
this.toast.success("Soumis avec succès");
} catch {
this.toast.error("Échec de la soumission");
} finally {
this.submitting.set(false);
}
}
}
Motifs de dialogue/modal
Dialogue de confirmation
// dialog.service.ts
@Injectable({ providedIn: 'root' })
export class DialogService {
private dialog = inject(Dialog); // CDK Dialog ou personnalisé
async confirm(options: {
title: string;
message: string;
confirmText?: string;
cancelText?: string;
}): Promise<boolean> {
const dialogRef = this.dialog.open(ConfirmDialogComponent, {
data: options,
});
return await firstValueFrom(dialogRef.closed) ?? false;
}
}
// Utilisation
async deleteItem(item: Item) {
const confirmed = await this.dialog.confirm({
title: 'Supprimer l\'élément',
message: `Êtes-vous sûr de vouloir supprimer "${item.name}" ?`,
confirmText: 'Supprimer',
});
if (confirmed) {
await this.store.delete(item.id);
}
}
Anti-motifs
États de chargement
// INCORRECT - Spinner alors que les données existent (provoque un flash lors du rechargement)
@if (loading()) {
<app-spinner />
}
// CORRECT - Afficher le chargement uniquement sans données
@if (loading() && !items().length) {
<app-spinner />
}
Gestion des erreurs
// INCORRECT - Erreur avalée
try {
await this.service.save();
} catch (e) {
console.log(e); // L'utilisateur n'a aucune idée !
}
// CORRECT - Erreur remontée
try {
await this.service.save();
} catch (e) {
console.error("Échec de l'enregistrement :", e);
this.toast.error("Échec de l'enregistrement. Veuillez réessayer.");
}
États des boutons
<!-- INCORRECT - Le bouton n'est pas désactivé pendant la soumission -->
<button (click)="submit()">Soumettre</button>
<!-- CORRECT - Désactivé et affiche le chargement -->
<button (click)="submit()" [disabled]="loading()">
@if (loading()) {
<app-spinner size="sm" />
} Soumettre
</button>
Checklist d'état de l'interface
Avant de terminer tout composant d'interface :
États de l'interface
- L'état d'erreur est géré et affiché à l'utilisateur
- L'état de chargement est affiché uniquement lorsqu'il n'y a pas de données
- Un état vide est fourni pour les collections (bloc
@empty) - Les boutons sont désactivés pendant les opérations asynchrones
- Les boutons affichent un indicateur de chargement le cas échéant
Données et mutations
- Toutes les opérations asynchrones ont une gestion des erreurs
- Toutes les actions utilisateur ont un retour (toast/visuel)
- Les mises à jour optimistes sont annulées en cas d'échec
Accessibilité
- Les états de chargement sont annoncés aux lecteurs d'écran
- Les messages d'erreur sont liés aux champs du formulaire
- La gestion du focus après les changements d'état
Intégration avec d'autres compétences
- angular-state-management : Utiliser les stores Signals pour l'état
- angular : Appliquer les motifs modernes (Signals, @defer)
- testing-patterns : Tester tous les états de l'interface