Communitygithub.com

FerroxLabs/murage

Expertise en animations web couvrant les transitions CSS, Web Animations API, Framer Motion, GSAP, animations liées au défilement, animations de mise en page, physique des ressorts, préférences de mouvement réduit et budgets de performance.

Qu'est-ce que murage ?

Ce skill fournit une expertise complète en conception et implémentation d'animations web performantes et accessibles. Il guide le choix de l'outil d'animation approprié (CSS transitions, CSS @keyframes, Framer Motion, GSAP, View Transitions API) en fonction de la complexité du besoin, allant des simples effets de survol aux chronologies complexes. Il détaille les implémentations pratiques avec des extraits de code pour chaque outil, couvre les principes de conception d'animations (durée, easing, décalage), les techniques d'optimisation des performances (maintien de 60 ips, animation uniquement des propriétés transform et opacity), et l'accessibilité via la préférence de mouvement réduit. Le skill est structuré pour une consultation rapide, incluant une matrice de décision, des exemples de code immédiatement utilisables, et une checklist d'architecture pour garantir que toutes les animations respectent des normes professionnelles. Il est conçu pour être utilisé avec des agents comme Claude Code, Cursor, ou Codex afin de fournir des conseils d'expert en animation web.

Compatible avec~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/FerroxLabs/murage/tree/HEAD/skills-library/animation-designer

Demander à votre IA préférée

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

Documentation

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

Individual skills in this repo

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

FerroxLabs/murage

Writes board-level narrative updates that complement financial reports with strategic context, competitive positioning, key risks, and forward-looking guidance for board of directors audiences. Use when the user needs to write a board update, board meeting narrative, or director-level briefing. Do NOT use for stakeholder updates to management (use `stakeholder-update`), investor emails (use `investor-update-email`), or full business reports (use `business-report`).

FerroxLabs/murage

>- End-to-end workflow for building a professional photography portfolio from niche selection through shooting, editing, website creation, and client acquisition. Covers gear decisions, shooting technique, post-processing workflow, portfolio curation, online presence, and the transition from hobbyist to working photographer. Use when the user wants to build photography portfolio or needs a structured multi-step process for this goal. Do NOT use when the request is a single-step task or requires professional advice beyond educational guidance.

FerroxLabs/murage

>- End-to-end workflow for creating a high-converting SaaS landing page from copywriting through design, development, SEO optimization, and analytics setup. Covers persuasion frameworks, responsive design, performance optimization, and conversion tracking to turn visitors into customers. Use when the user wants to build saas landing page or needs a structured multi-step process for this goal. Do NOT use when the request is a single-step task or requires professional advice beyond educational guidance.

FerroxLabs/murage

Calculates startup burn rate (gross and net), projects cash runway in months, and builds scenario analysis for different spending and revenue trajectories. Use when the user asks about burn rate, cash runway, how long their money will last, or startup cash management. Do NOT use for personal savings calculations (use budget-planning), full financial modeling (use financial-model-structure), or fundraising narrative (use fundraising-narrative).

FerroxLabs/murage

The user is asking \"how long do we have,\" \"can we afford this hire,\" or \"are we running out.\" Load whenever cash, burn, or time-to-zero shows up — or when a spending decision is on the table and the user doesn't know how many months it costs.

FerroxLabs/murage

Professional corporate video production guidance covering training videos, promotional content, testimonials, and product demos. Includes client brief templates, script approval workflows, achieving professional quality on budget, brand compliance, stakeholder management, and delivery specifications. Use when the user asks about corporate video or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

FerroxLabs/murage

Helps artists, designers, and creative professionals curate, organize, and present their work through compelling portfolios across digital platforms, personal websites, and print formats for career advancement. Use when the user asks about creative portfolio builder, related techniques, best practices, or needs guidance in this domain. Do NOT use when the request is outside the scope of creative portfolio builder or requires a different specialized skill.

FerroxLabs/murage

Cross-discipline creative portfolio assessment evaluating artistic cohesion, technical skill, presentation quality, and market positioning. Produces a scored evaluation with recommendations for strengthening creative identity and professional opportunity. Use when the user asks about creative portfolio evaluator, related techniques, best practices, or needs guidance in this domain. Do NOT use when the request is outside the scope of creative portfolio evaluator or requires a different specialized skill.

FerroxLabs/murage

Professional design portfolio evaluation assessing design process, craft quality, range of work, presentation, and industry alignment. Produces a scored review with recommendations for strengthening design practice and career positioning. Use when the user asks about design portfolio reviewer, related techniques, best practices, or needs guidance in this domain. Do NOT use when the request is outside the scope of design portfolio reviewer or requires a different specialized skill.

FerroxLabs/murage

Teaches specific named emotional regulation techniques (the STOP technique, urge surfing, cognitive reframing, emotional labeling, opposite action, and physiological soothing) with step-by-step sequences. Gathers the user's emotional challenges and triggers, then produces a personalized regulation toolkit with technique instructions and a situation-response plan. Use when the user asks about managing emotions, controlling anger, handling frustration, emotional regulation strategies, or building emotional resilience. Do NOT use for clinical emotional dysregulation treatment, personality disorder management, or replacing professional mental health support.

FerroxLabs/murage

Structures a fundraising narrative for startup investors covering traction, market size, business model, use of funds, and milestone targets using standard VC pitch structure. Use when the user asks about fundraising pitch, investor narrative, raising capital, pitch deck story, or investment memo. Do NOT use for sales pitch decks (use sales-pitch-deck), personal loan applications, grant proposals (use grant-proposal-writing), or financial model creation (use financial-model-structure).

FerroxLabs/murage

Interactive storytelling for games covering branching narratives, dialogue trees, environmental storytelling, lore design, character writing for games, quest design, player agency, world-building for interactive media, and narrative integration with game mechanics. Use when the user asks about game narrative writer or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

FerroxLabs/murage

Writes Instagram captions with a hook line, story body, hashtag strategy, and platform-optimized call-to-action. Use when the user wants to write an Instagram caption, create Instagram content, or draft text to accompany an Instagram post or reel. Do NOT use for LinkedIn posts (use `linkedin-post`), Twitter threads (use `twitter-thread`), or blog posts (use `blog-post-writing`).

FerroxLabs/murage

Produces conversion-optimized landing page copy with hero section, problem statement, solution, social proof, and CTA sections using conversion copywriting methodology. Use when the user asks to write landing page copy, create a product page, write a sales page, draft conversion copy, or write landing page text for a website. Also useful when asked to write website copy or create a page that converts visitors. Do NOT use for ad copy (use paid-ad-copy), product descriptions for e-commerce listings (use product-description), or full website content strategy (use seo-content-strategy).

FerroxLabs/murage

Guides the user through launching a professional art or creative portfolio from curation through outreach, chaining 5 atomic skills across career-development, design-creative, and writing categories. Covers physical vs. digital portfolio, platform selection, fine art vs. commercial positioning, and curated vs. comprehensive approaches. Use when the user wants to create and launch a portfolio to attract clients, galleries, or employers. Do NOT use for building a job search portfolio in non-creative fields (use land-new-job workflow), personal brand content strategy (use build-personal-brand workflow), or creating the artwork itself.

FerroxLabs/murage

>- Complete YouTube channel launch workflow from niche selection and channel strategy through video production, editing, monetization setup, community building, and personal brand development for sustainable channel growth. Use when the user wants to launch youtube channel or needs a structured multi-step process for this goal. Do NOT use when the request is a single-step task or requires professional advice beyond educational guidance.

FerroxLabs/murage

Run a section-by-section conversion teardown of one landing page — hero, value proposition, social proof, features, objection handling, CTA and footer — plus form, mobile and page-speed audits, ending in prioritised fixes split into quick wins, strategic and long-term, with A/B test hypotheses. Use when one page has traffic and is not converting. Do NOT use for a whole-site marketing audit (use market-audit), for the copy voice and awareness-stage decisions behind it (use copy-awareness-stages) or for the visual system it should sit inside (use mira-visual-system).

FerroxLabs/murage

Comprehensive motion graphics guidance covering title design, lower thirds, animated explainers, kinetic typography, logo animation, After Effects and Apple Motion workflows, design principles for motion, storyboarding for motion, and building a motion design practice. Use when the user asks about motion graphics or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

FerroxLabs/murage

Game narrative design covering branching dialogue systems, world lore construction, environmental storytelling techniques, character arc design for interactive media, player agency and consequence systems, quest narrative structure, narrative documentation, and integration with game mechanics. Use when the user asks about narrative designer or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

FerroxLabs/murage

Comprehensive animation guidance covering the 12 principles of animation, 2D and 3D production pipelines, tools (Blender, After Effects, Procreate, Toon Boom), frame rates, rigging, motion graphics vs character animation, and building an animation practice from concept to final render. Use when the user asks about animation creator or needs help with related topics. Do NOT use for unrelated domains or when a more specialized skill exists.

Skills associés