Communitygithub.com

Conception d'Interactions

Concevoir et implémenter des micro-interactions, du motion design, des transitions et des motifs de feedback utilisateur. À utiliser pour ajouter du polish aux interactions UI, implémenter des états de chargement ou créer des expériences utilisateur agréables.

Qu'est-ce que Conception d'Interactions ?

Cette compétence est dédiée à la conception et à l'implémentation d'interactions fluides et engageantes dans les interfaces utilisateur, en mettant l'accent sur le mouvement, le feedback et les transitions d'état réfléchies. Elle est idéale pour les développeurs et designers qui souhaitent ajouter du « polish » à leurs applications, que ce soit avec des micro-interactions (boutons, toggles), des animations de page, des états de chargement (squelettes, barres de progression) ou des interactions gestuelles (glisser-déposer, balayer pour ignorer). La compétence fournit des exemples de code concrets utilisant Framer Motion et CSS, ainsi que des directives de timing et d'assouplissement (easing) pour garantir des animations naturelles et performantes. Elle prend également en compte l'accessibilité avec la gestion de `prefers-reduced-motion` et les bonnes pratiques pour éviter les animations saccadées et la fatigue visuelle. Les principaux frameworks supportés incluent React avec Framer Motion, mais les concepts et les extraits CSS sont universels.

Compatible avec~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/itsmeyaw/skillset-website/tree/HEAD/.agents/skills/interaction-design

Demander à votre IA préférée

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

Documentation

Que fait Conception d'Interactions ?

Créez des interactions engageantes et intuitives grâce au mouvement, au feedback et à des transitions d'état réfléchies qui améliorent l'utilisabilité et ravissent les utilisateurs.

Quand Utiliser Cette Compétence

  • Ajouter des micro-interactions pour améliorer le feedback utilisateur
  • Implémenter des transitions fluides de pages et de composants
  • Concevoir des états de chargement et des écrans squelettes
  • Créer des interactions basées sur les gestes
  • Construire des systèmes de notifications et de toasts
  • Implémenter des interfaces glisser-déposer
  • Ajouter des animations déclenchées par le défilement
  • Concevoir des états de survol et de focus

Principes Fondamentaux

1. Mouvement Utile

Le mouvement doit communiquer, pas décorer :

  • Feedback : Confirmer que les actions de l'utilisateur ont eu lieu
  • Orientation : Montrer d'où viennent et où vont les éléments
  • Focus : Attirer l'attention sur les changements importants
  • Continuité : Maintenir le contexte pendant les transitions

2. Directives de Timing

DuréeCas d'utilisation
100-150 msMicro-feedback (survols, clics)
200-300 msPetites transitions (toggles, menus déroulants)
300-500 msTransitions moyennes (modales, changements de page)
500 ms+Animations complexes chorégraphiées

3. Fonctions d'Assouplissement

/* Assouplissements courants */
--ease-out: cubic-bezier(0.16, 1, 0.3, 1); /* Décélération - entrée */
--ease-in: cubic-bezier(0.55, 0, 1, 0.45); /* Accélération - sortie */
--ease-in-out: cubic-bezier(0.65, 0, 0.35, 1); /* Les deux - déplacement */
--spring: cubic-bezier(0.34, 1.56, 0.64, 1); /* Dépassement - ludique */

Démarrage Rapide : Micro-interaction de Bouton

import { motion } from "framer-motion";

export function BoutonInteractif({ enfants, onClick }) {
  return (
    <motion.button
      onClick={onClick}
      whileHover={{ scale: 1.02 }}
      whileTap={{ scale: 0.98 }}
      transition={{ type: "spring", stiffness: 400, damping: 17 }}
      className="px-4 py-2 bg-blue-600 text-white rounded-lg"
    >
      {enfants}
    </motion.button>
  );
}

Motifs d'Interaction

1. États de Chargement

Écrans Squelettes : Préserver la mise en page pendant le chargement

function SqueletteCarte() {
  return (
    <div className="animate-pulse">
      <div className="h-48 bg-gray-200 rounded-lg" />
      <div className="mt-4 h-4 bg-gray-200 rounded w-3/4" />
      <div className="mt-2 h-4 bg-gray-200 rounded w-1/2" />
    </div>
  );
}

Indicateurs de Progression : Afficher une progression déterminée

function BarreProgression({ progression }: { progression: number }) {
  return (
    <div className="h-2 bg-gray-200 rounded-full overflow-hidden">
      <motion.div
        className="h-full bg-blue-600"
        initial={{ width: 0 }}
        animate={{ width: `${progression}%` }}
        transition={{ ease: "easeOut" }}
      />
    </div>
  );
}

2. Transitions d'État

Toggle avec transition fluide :

function Toggle({ checked, onChange }) {
  return (
    <button
      role="switch"
      aria-checked={checked}
      onClick={() => onChange(!checked)}
      className={`
        relative w-12 h-6 rounded-full transition-colors duration-200
        ${checked ? "bg-blue-600" : "bg-gray-300"}
      `}
    >
      <motion.span
        className="absolute top-1 left-1 w-4 h-4 bg-white rounded-full shadow"
        animate={{ x: checked ? 24 : 0 }}
        transition={{ type: "spring", stiffness: 500, damping: 30 }}
      />
    </button>
  );
}

3. Transitions de Page

Animations de mise en page Framer Motion :

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

function TransitionPage({ enfants, key }) {
  return (
    <AnimatePresence mode="wait">
      <motion.div
        key={key}
        initial={{ opacity: 0, y: 20 }}
        animate={{ opacity: 1, y: 0 }}
        exit={{ opacity: 0, y: -20 }}
        transition={{ duration: 0.3 }}
      >
        {enfants}
      </motion.div>
    </AnimatePresence>
  );
}

4. Motifs de Feedback

Effet de vague au clic :

function BoutonVague({ enfants, onClick }) {
  const [vagues, setVagues] = useState([]);

  const handleClick = (e) => {
    const rect = e.currentTarget.getBoundingClientRect();
    const vague = {
      x: e.clientX - rect.left,
      y: e.clientY - rect.top,
      id: Date.now(),
    };
    setVagues((prev) => [...prev, vague]);
    setTimeout(() => {
      setVagues((prev) => prev.filter((r) => r.id !== vague.id));
    }, 600);
    onClick?.(e);
  };

  return (
    <button onClick={handleClick} className="relative overflow-hidden">
      {enfants}
      {vagues.map((vague) => (
        <span
          key={vague.id}
          className="absolute bg-white/30 rounded-full animate-ripple"
          style={{ left: vague.x, top: vague.y }}
        />
      ))}
    </button>
  );
}

5. Interactions Gestuelles

Balayer pour ignorer :

function CarteBalayable({ enfants, onDismiss }) {
  return (
    <motion.div
      drag="x"
      dragConstraints={{ left: 0, right: 0 }}
      onDragEnd={(_, info) => {
        if (Math.abs(info.offset.x) > 100) {
          onDismiss();
        }
      }}
      className="cursor-grab active:cursor-grabbing"
    >
      {enfants}
    </motion.div>
  );
}

Motifs d'Animation CSS

Animations avec Keyframes

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

@keyframes pulse {
  0%,
  100% {
    opacity: 1;
  }
  50% {
    opacity: 0.5;
  }
}

@keyframes spin {
  to {
    transform: rotate(360deg);
  }
}

.animate-fadeIn {
  animation: fadeIn 0.3s ease-out;
}
.animate-pulse {
  animation: pulse 2s ease-in-out infinite;
}
.animate-spin {
  animation: spin 1s linear infinite;
}

Transitions CSS

.carte {
  transition:
    transform 0.2s ease-out,
    box-shadow 0.2s ease-out;
}

.carte:hover {
  transform: translateY(-4px);
  box-shadow: 0 12px 24px rgba(0, 0, 0, 0.1);
}

Considérations d'Accessibilité

/* Respect des préférences de mouvement utilisateur */
@media (prefers-reduced-motion: reduce) {
  *,
  *::before,
  *::after {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
  }
}
function ComposantAnime() {
  const preferesReductionMouvement = window.matchMedia(
    "(prefers-reduced-motion: reduce)",
  ).matches;

  return (
    <motion.div
      animate={{ opacity: 1 }}
      transition={{ duration: preferesReductionMouvement ? 0 : 0.3 }}
    />
  );
}

Bonnes Pratiques

  1. Performance Avant Tout : Utilisez transform et opacity pour un 60 ips fluide
  2. Prise en Charge du Mouvement Réduit : Respectez toujours prefers-reduced-motion
  3. Timing Cohérent : Utilisez une échelle de timing cohérente dans toute l'application
  4. Physique Naturelle : Préférez les animations ressort (spring) aux animations linéaires
  5. Interruptible : Permettez aux utilisateurs d'annuler les animations longues
  6. Amélioration Progressive : Fonctionnez sans animations JS
  7. Test sur Appareils : Les performances varient considérablement

Problèmes Courants

  • Animations Saccadées : Évitez d'animer width, height, top, left
  • Sur-animation : Trop de mouvement provoque de la fatigue
  • Interactions Bloquantes : N'empêchez jamais la saisie utilisateur pendant les animations
  • Fuite de Mémoire : Nettoyez les écouteurs d'animation lors du démontage
  • Flash de Contenu : Utilisez will-change avec parcimonie pour l'optimisation

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Skills associés