Concepteur d'Animations
Objectif
Concevoir et implémenter des animations web performantes et utiles qui améliorent l'expérience utilisateur sans sacrifier les performances ou l'accessibilité. Ce skill couvre les outils d'animation, les modèles et le cadre de décision pour choisir l'approche appropriée.
Sélection de l'Outil d'Animation
Matrice de Décision
BESOIN D'ANIMATION OUTIL RECOMMANDÉ
--------------------------------------------------------------
Effets simples de survol/pointage Transitions CSS
Séquences d'images clés (chargement...) CSS @keyframes
Animations d'entrée/sortie de composants Framer Motion (React)
Vue <Transition> (Vue)
Révélations déclenchées par le défilement Animations CSS liées au défilement
(ou Intersection Observer)
Séquences chronologiques complexes GSAP
Animations de chemin SVG GSAP ou CSS
Mouvement basé sur la physique/ressort Framer Motion (spring)
Animations de mise en page (position/taille) Framer Motion (layoutId)
Animations gestuelles (glisser, pincer) Framer Motion (drag)
Transitions d'éléments partagés View Transitions API
Animations de visualisation de données Transitions D3 ou GSAP
Micro-interactions (icônes, bascules) CSS ou Lottie
Transitions CSS
Fondamentaux
/* Raccourci de transition : propriété durée fonction-timing délai */
.bouton {
background: var(--couleur-marque);
transition: background 200ms ease-out, transform 150ms ease-out;
}
.bouton:hover {
background: var(--couleur-marque-survol);
transform: scale(1.02);
}
/* Propriétés individuelles */
.carte {
transition-property: transform, box-shadow, opacity;
transition-duration: 200ms, 300ms, 200ms;
transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
}
/* Fonctions de timing nommées */
--ease-in: cubic-bezier(0.4, 0, 1, 1); /* Accélération */
--ease-out: cubic-bezier(0, 0, 0.2, 1); /* Décélération */
--ease-in-out: cubic-bezier(0.4, 0, 0.2, 1); /* Standard */
--ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1); /* Dépassement */
Modèles de Transition Courants
/* Apparition/Disparition en fondu */
.fade-entrer { opacity: 0; }
.fade-entrer-actif { opacity: 1; transition: opacity 300ms ease-out; }
.fade-sortir { opacity: 1; }
.fade-sortir-actif { opacity: 0; transition: opacity 200ms ease-in; }
/* Glissement vers le haut depuis le bas */
.glisser-haut {
transform: translateY(20px);
opacity: 0;
transition: transform 300ms ease-out, opacity 200ms ease-out;
}
.glisser-haut.actif {
transform: translateY(0);
opacity: 1;
}
/* Effet de scintillement pour squelettes de chargement */
@keyframes scintillement {
0% { background-position: -200% 0; }
100% { background-position: 200% 0; }
}
.squelette {
background: linear-gradient(90deg, #e0e0e0 25%, #f0f0f0 50%, #e0e0e0 75%);
background-size: 200% 100%;
animation: scintillement 1.5s ease-in-out infini;
}
CSS @keyframes
/* Spinner */
@keyframes tourner {
to { transform: rotate(360deg); }
}
.spinner {
animation: tourner 1s linear infini;
border: 3px solid var(--couleur-bordure);
border-top-color: var(--couleur-marque);
border-radius: 50%;
width: 24px; height: 24px;
}
/* Pulsation (indicateur d'attention) */
@keyframes pulsation {
0%, 100% { opacity: 1; }
50% { opacity: 0.5; }
}
.point-notification {
# ... (condensé) ...
.element-liste:nth-child(2) { animation-delay: calc(1 * 50ms); }
.element-liste:nth-child(3) { animation-delay: calc(2 * 50ms); }
/* Ou avec un attribut style : style="--i: 3" */
.element-liste {
animation-delay: calc(var(--i) * 50ms);
}
Animations CSS Liées au Défilement
/* Animer en fonction de la position de défilement */
@keyframes reveler {
from {
opacity: 0;
transform: translateY(40px) scale(0.95);
}
to {
opacity: 1;
transform: translateY(0) scale(1);
}
}
/* Déclencher lorsque l'élément entre dans la zone d'affichage */
.reveler-au-defilement {
animation: reveler linear both;
animation-timeline: view();
animation-range: entree 0% entree 50%;
}
# ... (condensé) ...
to { transform: translateY(-50px); }
}
.element-parallaxe {
animation: parallaxe linear;
animation-timeline: scroll();
}
Framer Motion (React)
Modèles de Base
import { motion, AnimatePresence } from 'framer-motion';
// Animation d'entrée
function Carte() {
return (
<motion.div
initial={{ opacity: 0, y: 20 }}
animate={{ opacity: 1, y: 0 }}
transition={{ duration: 0.3, ease: 'easeOut' }}
>
<h2>Contenu de la carte</h2>
</motion.div>
);
}
// Animation de sortie (nécessite AnimatePresence)
function Modal({ estOuvert, fermer }: ModalProps) {
return (
# ... (condensé) ...
<motion.li key={element.id} variants={variantesElement}>
{element.nom}
</motion.li>
))}
</motion.ul>
);
}
Physique des Ressorts
// Animation ressort (mouvement naturel basé sur la physique)
<motion.div
animate={{ x: 100 }}
transition={{
type: 'spring',
stiffness: 300, // Plus élevé = plus rapide
damping: 20, // Plus élevé = moins de rebond
mass: 1, // Plus élevé = plus d'inertie
}}
/> .// Préréglages
const preReglagesRessort = {
rapide: { type: 'spring', stiffness: 400, damping: 25 },
rebondissant: { type: 'spring', stiffness: 300, damping: 10 },
doux: { type: 'spring', stiffness: 120, damping: 14 },
lent: { type: 'spring', stiffness: 60, damping: 20 },
};
// Quand utiliser ressort vs easing :
// Ressort : éléments interactifs, glisser, modifications de mise en page (semble naturel)
// Easing : transitions simples, entrée/sortie (semble prédictible)
Animations de Mise en Page
// Animation de mise en page automatique
function CarteExtensible({ developpe }: { developpe: boolean }) {
return (
<motion.div layout className={developpe ? 'carte-developpee' : 'carte-reduite'}>
<motion.h2 layout="position">Titre</motion.h2>
{developpe && (
<motion.p
initial={{ opacity: 0 }}
animate={{ opacity: 1 }}
exit={{ opacity: 0 }}
>
Contenu développé ici.
</motion.p>
)}
</motion.div>
);
}
# ... (condensé) ...
{element.titre}
</motion.div>
))}
</div>
</LayoutGroup>
);
}
Animations Gestuelles
// Glisser
<motion.div
drag
dragConstraints={{ top: -100, bottom: 100, left: -100, right: 100 }}
dragElastic={0.2}
whileDrag={{ scale: 1.1, cursor: 'saisir' }}
/> .// Survol et tap
<motion.bouton
whileHover={{ scale: 1.05 }}
whileTap={{ scale: 0.95 }}
transition={preReglagesRessort.rapide}
>
Cliquez-moi
</motion.bouton> .// Déclenché par le défilement (avec useInView)
# ... (condensé) ...
animate={estVisible ? { opacity: 1, y: 0 } : {}}
transition={{ duration: 0.6, ease: 'easeOut' }}
>
{enfants}
</motion.div>
);
}
GSAP (Chronologies Complexes)
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
// Séquence chronologique
const tl = gsap.timeline({ defaults: { ease: 'power2.out', duration: 0.5 } });
tl.from('.hero-titre', { y: 60, opacity: 0 })
.from('.hero-sous-titre', { y: 40, opacity: 0 }, '-=0.3') // Chevauchement de 0.3s
.from('.hero-cta', { scale: 0.8, opacity: 0 }, '-=0.2')
.from('.hero-image', { x: 100, opacity: 0 }, '-=0.4');
// Animation déclenchée par le défilement
gsap.from('.carte-fonctionnalite', {
scrollTrigger: {
trigger: '.section-fonctionnalites',
start: 'haut 80%',
# ... (condensé) ...
const ctx = gsap.context(() => {
// Toutes les animations GSAP ici
gsap.from('.element', { opacity: 0, y: 20, stagger: 0.1 });
}, refConteneur);
return () => ctx.revert(); // Nettoyer toutes les animations
}, []);
Préférences de Mouvement Réduit
Implémentation
/* CSS : Respecter globalement la préférence utilisateur */
@media (prefers-reduced-motion: reduce) {
*,
*::avant,
*::après {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
scroll-behavior: auto !important;
}
}
// React : Hook useReducedMotion
function useReducedMotion(): boolean {
const [reduit, setReduit] = useState(false);
useEffect(() => {
const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
setReduit(mq.matches);
const gestionnaire = (e: MediaQueryListEvent) => setReduit(e.matches);
mq.addEventListener('change', gestionnaire);
return () => mq.removeEventListener('change', gestionnaire);
}, []);
return reduit;
}
// Utilisation
function CarteAnimee() {
const reduit = useReducedMotion();
# ... (condensé) ...
Contenu
</motion.div>
);
}
// Intégré dans Framer Motion (v6+)
import { useReducedMotion } from 'framer-motion';
Budget de Performance pour les Animations
CIBLE : Les animations doivent maintenir 60 ips (16.67 ms par image)
RÈGLES :
1. Animer uniquement transform et opacity (propriétés exclusives du compositeur)
2. Éviter d'animer width, height, top, left, margin, padding
3. Utiliser will-change avec parcimonie (ajoute une surcharge mémoire)
4. Limiter les animations simultanées à ~10-15 éléments
5. Utiliser requestAnimationFrame pour les animations pilotées par JS
6. Délestez les gestionnaires de défilement (ou utilisez les animations CSS liées au défilement)
7. Évitez d'animer des éléments qui déclenchent une mise en page dans d'autres éléments
MESURE :
- Chrome DevTools > Performance > Graphique des images
- Cible : Aucune image dépassant 16 ms
- Vérifier les thrashings de mise en page (indicateurs de reflow forcé)
TECHNIQUES D'OPTIMISATION :
- Utiliser transform: translateZ(0) ou will-change pour promouvoir les couches
- Utiliser contain: layout paint pour les conteneurs animés
- Utiliser content-visibility: auto pour le contenu animé hors écran
- Mettre en pause les animations lorsqu'elles ne sont pas visibles (Intersection Observer)
Principes de Conception d'Animations
1. OBJECTIF : Chaque animation doit servir une fonction
- Guider l'attention
- Montrer les relations (parent-enfant, avant-après)
- Fournir un retour (clic, survol, succès, erreur)
- Maintenir l'orientation spatiale (d'où vient le contenu)
- Réduire le temps d'attente perçu
2. DIRECTIVES DE DURÉE :
Micro-interactions (survol, bascule) : 100-200 ms
Animations d'entrée : 200-400 ms
Animations de sortie : 150-300 ms (plus rapide que l'entrée)
Transitions de page : 300-500 ms
Séquences complexes : 500-1000 ms au total
3. EASING :
Entrée : ease-out (décélération -- apparaît rapidement, se stabilise)
Sortie : ease-in (accélération -- commence lentement, part rapidement)
Mouvement : ease-in-out (mouvement naturel)
Continu : linear (spinners, progression)
4. DÉCALAGE :
30-80 ms entre les éléments de la liste (plus rapide pour plus d'éléments)
Durée totale maximale du décalage : ~500 ms (même pour 20+ éléments)
Checklist d'Architecture d'Animation
- Outil d'animation sélectionné en fonction de la complexité des besoins
- Transitions CSS utilisées pour les effets simples de survol/pointage
- CSS @keyframes utilisé pour les animations en boucle et de chargement
- Framer Motion ou équivalent utilisé pour les animations d'entrée/sortie/mise en page
- GSAP réservé aux séquences chronologiques complexes
- Toutes les animations maintiennent 60 ips (vérifié dans DevTools)
- Seules transform et opacity sont animées (aucune propriété de mise en page)
- prefers-reduced-motion respecté globalement
- Les durées d'animation suivent les directives UX (100-500 ms)
- Le timing de décalage est plafonné à une durée totale raisonnable
- Chaque animation a un objectif clair (pas décoratif)
- Physique des ressorts utilisée pour les animations interactives/gestuelles
- Les animations liées au défilement utilisent l'API CSS là où elle est prise en charge
- Les animations GSAP sont nettoyées lors du démontage du composant
- will-change utilisé uniquement pendant l'animation active
Quand Utiliser
Utilisez ce skill lorsque :
- Vous concevez ou implémentez des solutions de conception d'animations
- Vous examinez ou améliorez des approches de conception d'animations existantes
- Vous prenez des décisions architecturales ou d'implémentation concernant la conception d'animations
- Vous apprenez les modèles et les meilleures pratiques de conception d'animations
- Vous résolvez des problèmes liés à la conception d'animations
N'utilisez PAS ce skill lorsque :
- La question concerne un domaine technologique fondamentalement différent
- Un skill frère plus spécifique couvre exactement le sujet nécessaire
- L'utilisateur a besoin d'un tutoriel pratique complet plutôt que de conseils d'expert
Format de Sortie
# Analyse de Conception d'Animations
## Évaluation du Contexte
[Résumé de la situation et contraintes]
## Approche Recommandée
[Recommandation principale avec justification]
## Étapes d'Implémentation
1. [Étape avec détails spécifiques]
2. [Étape avec détails spécifiques]
3. [Étape avec détails spécifiques]
## Compromis et Considérations
- [Compromis clé 1]
- [Compromis clé 2]
## Prochaines Étapes
- [Action immédiate]
- [Action de suivi]
Exemple
Entrée : « Aidez-moi à implémenter une conception d'animations pour une application de production à moyenne échelle »
Sortie : Une analyse structurée couvrant l'évaluation de l'état actuel, l'approche de conception d'animations recommandée avec des modèles spécifiques, une feuille de route d'implémentation avec des jalons, et des stratégies d'atténuation des risques adaptées à l'échelle et aux contraintes de l'application.
Cas Particuliers
- Intégration de systèmes existants : Lorsque la conception d'animations doit coexister avec des approches existantes, fournissez un chemin de migration progressif plutôt qu'une réécriture complète
- Décalage d'échelle : Lorsque la complexité de la solution dépasse l'échelle du projet, recommandez une approche plus simple et notez quand la revoir
- Lacunes de compétences de l'équipe : Lorsque l'équipe manque d'expérience avec l'approche recommandée, incluez des ressources d'apprentissage et des alternatives plus simples
- Exigences conflictuelles : Lorsque les contraintes sont en conflit (par exemple, performances vs maintenabilité), énoncez explicitement le compromis et recommandez en fonction des priorités énoncées