Communitygithub.com

TheMystic07/OpenWalc - Conception d'Animations UI

Conception de mouvements et d'animations pour les interfaces utilisateur. À utiliser lors de la création de micro-interactions, transitions de pages, états de chargement ou toute animation UI sur le web et les plateformes mobiles.

Qu'est-ce que OpenWalc - Conception d'Animations UI ?

Ce skill fournit un guide complet pour créer des animations d'interface utilisateur intentionnelles et performantes. Il couvre les principes fondamentaux de l'animation (comme les 12 principes appliqués à l'UI), le timing et la durée, les fonctions d'easing, les motifs d'animation courants (micro-interactions, chargements, transitions), ainsi que des techniques avancées comme le FLIP. Le guide compare les bibliothèques JavaScript populaires (GSAP, Framer Motion, anime.js) et insiste sur l'importance de la performance en utilisant des propriétés accélérées par le GPU et en respectant les préférences d'accessibilité (réduction de mouvement). Il intègre des considérations spécifiques au mobile et propose des tokens d'animation pour une intégration cohérente dans un design system.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/TheMystic07/OpenWalc/tree/HEAD/.agent/skills/ui-animation

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Animation UI & Conception de Mouvement

Guide complet pour créer des animations intentionnelles et performantes dans les interfaces utilisateur.

Principes d'Animation

Les 12 Principes de l'Animation (Appliqués à l'UI)

PrincipeApplication UI
TimingLa durée reflète l'importance/la distance
EasingAccélération/décélération naturelle
AnticipationPréparation visuelle à une action
Rebond (Follow-through)L'élan continue après l'arrêt
Action SecondaireLes éléments de support réagissent
Mise en Scène (Staging)Attirer l'attention sur l'élément clé
Écrasement & ÉtirementInteractions rebondissantes et ludiques
ExagérationMettre l'accent sur un retour important
ArcTrajectoires courbes naturelles
Chevauchement (Overlap)Les éléments bougent à des vitesses différentes
Dessin SolideMaintenir un espace 3D cohérent
Attrait (Appeal)Mouvement engageant et agréable

Pourquoi Animer ?

OBJECTIFS FONCTIONNELS :
✓ Guider l'attention vers les changements importants
✓ Montrer les relations entre les éléments
✓ Fournir un retour d'information pour les actions
✓ Communiquer l'état du système
✓ Alléger la charge cognitive
✓ Créer une orientation spatiale

PAS POUR :
✗ La pure décoration
✗ Montrer ses compétences
✗ Rendre les choses « modernes »
✗ Distraire du contenu

Timing & Durée

Directives de Durée

INSTANT (0-100ms) :
└─→ Changements d'état des boutons
└─▸ Interrupteurs à bascule
└─→ Micro-feedbacks

RAPIDE (100-200ms) :
└─▸ Effets de survol
└─→ Fades simples
└─→ Petits mouvements

STANDARD (200-300ms) :
└─→ La plupart des transitions UI
└─→ Ouverture/fermeture de modale
└─→ Menus déroulants

LENT (300-500ms) :
└─→ Transitions complexes
└─→ Transitions de page
└─→ Mouvement d'éléments larges

DÉLIBÉRÉ (500ms+) :
└─→ Animations hero
└─→ Chargements squelettes
└─→ Séquences d'intégration

Timing Basé sur la Distance

Règle : Plus la distance est grande, plus la durée est longue

Petite (< 100px) :   150-200ms
Moyenne (100-300px) : 200-300ms
Grande (300-500px) :  300-400ms
Plein écran :         400-500ms

Formule :
durée = tempsDeBase + (distance × facteur)

Fonctions d'Easing

Easing Standards

LINÉAIRE
├────────────────────────────┤
Vitesse constante. Rarement naturel.
Utilisation : Barres de progression, aiguilles d'horloge

EASE-OUT (Décélération)
├═══════════────────────────┤
Début rapide, fin lente.
Utilisation : Éléments entrant à l'écran

EASE-IN (Accélération)
├────────────────═══════════┤
Début lent, fin rapide.
Utilisation : Éléments quittant l'écran

EASE-IN-OUT (Courbe en S)
├────═══════════════────────┤
Début et fin lents, milieu rapide.
Utilisation : Transitions à l'écran

EASE-OUT-BACK (Dépassement)
├═══════════────────────╗───┤
Dépasse, puis se stabilise.
Utilisation : Entrées ludiques, rebonds

Valeurs CSS d'Easing

/* Mots-clés intégrés */
linear: cubic-bezier(0, 0, 1, 1)
ease: cubic-bezier(0.25, 0.1, 0.25, 1)
ease-in: cubic-bezier(0.42, 0, 1, 1)
ease-out: cubic-bezier(0, 0, 0.58, 1)
ease-in-out: cubic-bezier(0.42, 0, 0.58, 1)

/* Standard Material Design */
standard: cubic-bezier(0.4, 0, 0.2, 1)
decelerate: cubic-bezier(0, 0, 0.2, 1)
accelerate: cubic-bezier(0.4, 0, 1, 1)

/* Personnalisé : Snappy */
snappy: cubic-bezier(0.5, 0, 0, 1)

/* Personnalisé : Rebondissant */
bouncy: cubic-bezier(0.68, -0.55, 0.27, 1.55)

/* Type ressort (utiliser des bibliothèques JS) */
spring: { stiffness: 300, damping: 20 }

Quand Utiliser Chacun

ScénarioEasingPourquoi
Élément entrantease-outArrive énergiquement, se stabilise
Élément sortantease-inGagne de l'élan pour sortir
Changement à l'écranease-in-outTransition d'état fluide
Attirer l'attentionbounce/springLudique, perceptible
Fond/subtilease-outDiscret

Modèles d'Animation

Micro-interactions

ÉTATS DES BOUTONS :
┌─────────────────────────────────────────┐
│ Repos → Survol : scale(1.02), 100ms     │
│ Survol → Actif : scale(0.98), 50ms      │
│ Actif → Repos : scale(1), 150ms ease-out│
└─────────────────────────────────────────┘

INTERRUPTEUR À BASCULE :
┌─────────────────────────────────────────┐
│ Curseur : translateX, 200ms ease-out    │
│ Piste : background-color, 200ms          │
│ État : léger rebond à la fin            │
└─────────────────────────────────────────┘

CASE À COCHER :
┌─────────────────────────────────────────┐
│ Coche : animation stroke-dashoffset      │
│ Arrière-plan : scale depuis le centre    │
│ 150ms                                   │
│ Ripple : cercle qui s'étend, 300ms       │
└─────────────────────────────────────────┘

États de Chargement

ÉCRANS SQUELETTES :
┌──────────────────────────┐
│ ▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░  │ Effet de scintillement
│ ▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░  │ Dégradé linéaire
│ ▓▓▓▓▓▓░░░░░░░░░░░░░░░░  │ Se déplaçant de gauche à droite
└──────────────────────────┘

CSS :
background: linear-gradient(
  90deg,
  #f0f0f0 25%,
  #e0e0e0 50%,
  #f0f0f0 75%
);
background-size: 200% 100%;
animation: shimmer 1.5s infinite;

SPINNER :
- Durée : 1-2 secondes par rotation
- Easing : linéaire (mouvement constant)
- Style : Correspondre à l'identité de marque

Transitions de Page

FONDU ENCHAÎNÉ :
├──────────────────────────────────────────┤
│ Ancienne page : opacity 1 → 0, 200ms    │
│ Nouvelle page : opacity 0 → 1, 200ms    │
│ Timing : séquentiel ou chevauchant       │
└──────────────────────────────────────────┘

GLISSEMENT :
├──────────────────────────────────────────┤
│ La direction suit la hiérarchie de navigation│
│ Avant : Glisser à gauche (nouveau depuis droite)│
│ Arrière : Glisser à droite (précédent depuis gauche)│
│ Durée : 300-400ms                        │
└──────────────────────────────────────────┘

ÉLÉMENT PARTAGÉ :
├──────────────────────────────────────────┤
│ L'élément se transforme entre les états  │
│ La position, la taille, border-radius    │
│ changent                                 │
│ Crée de la continuité entre les écrans   │
│ Durée : 300-500ms                        │
└──────────────────────────────────────────┘

Animations de Liste

ENTRÉE ÉCHELONNÉE :
┌─ Élément 1 ─────────────────┐  délai : 0ms
├─ Élément 2 ─────────────────┤  délai : 50ms
├─ Élément 3 ─────────────────┤  délai : 100ms
├─ Élément 4 ─────────────────┤  délai : 150ms
└─ Élément 5 ─────────────────┘  délai : 200ms

Durée totale maximale : 500ms
Échelonnage : 30-50ms par élément
Animation : translateY + opacity

RÉORDONNANCEMENT :
- Utiliser la technique FLIP
- Durée : 200-300ms
- Easing : ease-out

Performance

Propriétés Accélérées par le GPU

RAPIDE (Composition uniquement) :
✓ transform: translate, scale, rotate
✓ opacity
✓ filter (avec will-change)

LENT (Déclenche la mise en page/le rendu) :
✗ width, height
✗ margin, padding
✗ top, left, right, bottom
✗ border, border-radius
✗ font-size
✗ box-shadow (repeinture)

OPTIMISATION :
will-change: transform, opacity;
/* À utiliser avec parcimonie ! */

Directives de Performance

/* Bien : Accéléré par le GPU */
.animated-element {
  transform: translateX(0);
  transition: transform 300ms ease-out;
}
.animated-element.moved {
  transform: translateX(100px);
}

/* Mal : Secousses de mise en page */
.animated-element {
  left: 0;
  transition: left 300ms ease-out;
}
.animated-element.moved {
  left: 100px;
}

Technique FLIP

// Premièrement : Obtenir la position initiale
const first = element.getBoundingClientRect();

// Dernièrement : Appliquer le changement, obtenir la position finale
element.classList.add("moved");
const last = element.getBoundingClientRect();

// Inverser : Calculer le delta, appliquer la transformée inverse
const deltaX = first.left - last.left;
const deltaY = first.top - last.top;
element.style.transform = `translate(${deltaX}px, ${deltaY}px)`;

// Jouer : Supprimer la transformée avec la transition
requestAnimationFrame(() => {
  element.style.transition = "transform 300ms ease-out";
  element.style.transform = "";
});

Techniques d'Animation CSS

Animation par Images Clés

@keyframes fadeSlideIn {
  from {
    opacity: 0;
    transform: translateY(20px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

.element {
  animation: fadeSlideIn 300ms ease-out forwards;
}

/* Avec des étapes */
@keyframes typewriter {
  from {
    width: 0;
  }
  to {
    width: 100%;
  }
}

.typing-text {
  animation: typewriter 2s steps(20) forwards;
}

Transition

.button {
  background: var(--primary);
  transform: scale(1);
  transition:
    background 150ms ease-out,
    transform 100ms ease-out;
}

.button:hover {
  background: var(--primary-hover);
  transform: scale(1.02);
}

.button:active {
  transform: scale(0.98);
  transition-duration: 50ms;
}

Raccourci d'Animation

/* animation: name duration timing-function delay
              iteration-count direction fill-mode play-state */

animation: slideIn 300ms ease-out 100ms 1 normal forwards running;

/* Modèles courants */
animation: spin 1s linear infinite;
animation: pulse 2s ease-in-out infinite alternate;
animation: fadeIn 300ms ease-out forwards;

Bibliothèques JavaScript d'Animation

Comparaison

BibliothèqueMeilleur PourTaille du Bundle
CSSTransitions simples0 ko
Web Animations APINatif, performant0 ko
GSAPComplexe, précis~60 ko
Framer MotionÉcosystème React~50 ko
anime.jsTimeline, SVG~17 ko
Motion OneModerne, léger~18 ko
LottieExport After Effects~50 ko

Framer Motion (React)

import { motion, AnimatePresence } from "framer-motion";

// Animation de base
<motion.div
  initial={{ opacity: 0, y: 20 }}
  animate={{ opacity: 1, y: 0 }}
  exit={{ opacity: 0, y: -20 }}
  transition={{ duration: 0.3, ease: "easeOut" }}
>
  Contenu
</motion.div>;

// Variantes pour animations complexes
const containerVariants = {
  hidden: { opacity: 0 },
  visible: {
    opacity: 1,
    transition: {
      staggerChildren: 0.1,
    },
  },
};

const itemVariants = {
  hidden: { opacity: 0, y: 20 },
  visible: { opacity: 1, y: 0 },
};

<motion.ul variants={containerVariants} initial="hidden" animate="visible">
  {items.map((item) => (
    <motion.li key={item.id} variants={itemVariants}>
      {item.name}
    </motion.li>
  ))}
</motion.ul>;

GSAP

import { gsap } from "gsap";

// Interpolation de base
gsap.to(".element", {
  x: 100,
  opacity: 1,
  duration: 0.3,
  ease: "power2.out",
});

// Timeline
const tl = gsap.timeline();
tl.from(".header", { y: -100, duration: 0.5 })
  .from(".content", { opacity: 0, duration: 0.3 }, "-=0.2")
  .from(".button", { scale: 0.8, duration: 0.2 });

// ScrollTrigger
gsap.registerPlugin(ScrollTrigger);
gsap.to(".parallax", {
  y: -100,
  scrollTrigger: {
    trigger: ".section",
    start: "top center",
    end: "bottom center",
    scrub: true,
  },
});

Accessibilité

Respecter les Préférences Utilisateur

/* Réduire le mouvement pour les utilisateurs qui le préfèrent */
@media (prefers-reduced-motion: reduce) {
  *,
  *::before,
  *::after {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
  }
}

/* Ou fournir des alternatives plus simples */
@media (prefers-reduced-motion: reduce) {
  .animated-element {
    /* Remplacer le mouvement par l'opacité */
    animation: none;
    transition: opacity 200ms ease;
  }
}

Pratiques d'Animation Sûres

À ÉVITER pour les troubles vestibulaires :
✗ Effets de parallaxe
✗ Animations de zoom/d'échelle
✗ Éléments qui tournent/rotent
✗ Animations en lecture automatique
✗ Clignotements (>3 fois/seconde)

ALTERNATIVES SÛRES :
✓ Fonds d'opacité
✓ Transitions de couleur
✓ Changements de position subtils
✓ Animations initiées par l'utilisateur

Directives WCAG

2.2.2 Pause, Arrêter, Masquer :
- Le contenu mis à jour automatiquement peut être mis en pause
- Pas de limite de temps pour la lecture

2.3.1 Trois Flashs :
- Rien ne clignote plus de 3 fois par seconde

2.3.3 Animation des Interactions :
- Le mouvement peut être désactivé
- Les animations déclenchées respectent les préférences

Considérations Mobiles

Retour Tactile

/* Style de retour tactile iOS */
.button {
  -webkit-tap-highlight-color: transparent;
  touch-action: manipulation;
}

.button:active {
  opacity: 0.7;
  transition: opacity 50ms;
}

/* Effet d'onde */
.ripple {
  position: relative;
  overflow: hidden;
}

.ripple::after {
  content: "";
  position: absolute;
  background: rgba(255, 255, 255, 0.3);
  border-radius: 50%;
  transform: scale(0);
  animation: ripple 400ms ease-out;
}

Conventions de Plateforme

PlateformeStyle d'Animation
iOSPhysique ressort, 300-500ms, subtil
AndroidMouvement Material, 200-300ms, accentué
WebVariable, généralement 200-400ms

Intégration du Design System

Tokens d'Animation

:root {
  /* Durées */
  --duration-instant: 100ms;
  --duration-fast: 150ms;
  --duration-normal: 250ms;
  --duration-slow: 400ms;
  --duration-slower: 600ms;

  /* Easing */
  --ease-default: cubic-bezier(0.4, 0, 0.2, 1);
  --ease-in: cubic-bezier(0.4, 0, 1, 1);
  --ease-out: cubic-bezier(0, 0, 0.2, 1);
  --ease-bounce: cubic-bezier(0.68, -0.55, 0.27, 1.55);

  /* Combiné */
  --transition-default: var(--duration-normal) var(--ease-default);
  --transition-fast: var(--duration-fast) var(--ease-out);
}

/* Utilisation */
.element {
  transition: transform var(--transition-default);
}

Meilleures Pratiques

À FAIRE :

  • Animer avec un objectif (feedback, guidage)
  • Utiliser des propriétés accélérées par le GPU
  • Garder les durées sous 500ms
  • Adapter l'animation à la personnalité de la marque
  • Respecter prefers-reduced-motion
  • Tester sur des appareils bas de gamme
  • Utiliser un système de timing cohérent

À NE PAS FAIRE :

  • Animer uniquement pour la décoration
  • Bloquer l'interaction utilisateur
  • Utiliser des rebonds/dépassements excessifs
  • Créer des déclencheurs de mal des transports
  • Oublier les animations de sortie
  • Ignorer les métriques de performance

...

[tronqué pour la traduction]

Individual skills in this repo

This repo contains 2 individual skills — each has its own dedicated page.

Skills associés