Communitygithub.com

Motions avancées

Patrons de mouvement avancés pour React / Next.js — glisser-déposer, gestes, animations de texte, dessin de chemins SVG, hooks personnalisés, séquences impératives (useAnimate), chargeurs et l'arbre de décision complet de l'API. Nécessite motion-foundations.

Qu'est-ce que Motions avancées ?

Cette compétence fournit des patrons d'animation complexes, interactifs et basés sur la physique pour les applications React et Next.js. Elle est conçue pour les développeurs qui ont déjà configuré 'motion-foundations' et qui ont besoin d'aller au-delà des simples patrons de mouvement. La compétence couvre un large éventail de scénarios, allant des interactions de glissement (comme les feuilles à glisser pour rejeter, les listes réorganisables) et des gestes tactiles (glissement, appui long), aux animations de texte avancées (révélation mot par mot, machine à écrire, compteur numérique) et aux animations SVG (dessin de chemin, morphing d'icônes, cercle de progression). Elle propose également des hooks personnalisés tels que `useScrollReveal` et `useHoverScale`, ainsi que des séquences d'animation impératives avec `useAnimate`. Elle inclut des composants de chargement (spinners, shimmer, barres de progression) et un arbre de décision pour choisir la bonne API selon le besoin. Les principes clés incluent l'utilisation de `useMotionValue` et `useTransform` pour des calculs réactifs sans re-rendus, et `useSpring` pour des animations physiques naturelles. La compétence insiste sur les bonnes pratiques : tester les interactions de glissement sur des appareils tactiles, mettre en pause les animations infinies lorsque l'onglet est caché, définir des seuils de glissement explicites, éviter de recréer les MotionValues lors des rendus, importer toutes les valeurs de token depuis `motion-foundations` et nettoyer les écouteurs d'événements dans les hooks personnalisés. Les exemples de code dans la SKILL.md sont directement utilisables et incluent des commentaires expliquant les règles appliquées.

Compatible avec~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/Cody-W-Tucker/skills/tree/HEAD/skills/motion-advanced

Demander à votre IA préférée

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

Documentation

Motion Avancée

Patrons d'animation complexes, interactifs et basés sur la physique. Nécessite d'abord la configuration de motion-foundations. À utiliser lorsque motion-patterns ne suffit pas.

Quand activer

  • Création de feuilles à glisser pour rejeter, de gestes de glissement ou de listes réorganisables
  • Animation de texte mot par mot, caractère par caractère, ou comme compteur en direct
  • Dessin de chemins SVG, morphing d'icônes ou animation de progression circulaire
  • Écriture d'un hook d'animation personnalisé (useScrollReveal, bouton magnétique, suiveur de curseur)
  • Séquençage d'animations multi-étapes de manière impérative avec useAnimate
  • Création de spinners, de squelettes shimmer, d'indicateurs d'impulsion ou d'états de chargement de boutons

Produits

Cette compétence produit :

  • Interactions de glissement : cartes glissables, feuilles à glisser pour rejeter, listes Reorder.Group
  • Hooks de gestes : détection de glissement, appui long, contour de pincement
  • Composants d'animation de texte : révélation de mots, machine à écrire de caractères, compteur numérique
  • Animations SVG : dessin de chemin, morphing d'icône, anneau de progression de trait
  • Hooks personnalisés : useScrollReveal, useHoverScale, useNavigationDirection, useInViewOnce
  • Séquences impératives via useAnimate avec async/await sécurisé contre les interruptions
  • Composants de chargement : spinner, shimmer, point d'impulsion, barre de progression, état de chargement de bouton

Principes

  • Le mouvement basé sur la physique (useSpring, springs.*) semble toujours plus naturel que celui basé sur la durée pour la manipulation directe.
  • useMotionValue + useTransform calcule des valeurs dérivées sans déclencher de re-rendus.
  • Les séquences useAnimate sont impératives et sécurisées contre les interruptions — appeler animate() en cours d'exécution annule automatiquement l'animation précédente.
  • Les valeurs de mouvement (useMotionValue, useSpring) sont sûres pour le SSR et ne provoquent pas d'erreurs d'hydratation.

Règles

  1. Les interactions de glissement doivent être testées sur des appareils tactiles, pas seulement avec la souris. La propriété drag fonctionne sur les deux, mais la sensation et le seuil diffèrent.
  2. Les animations infinies doivent se mettre en pause lorsque document.visibilityState === "hidden". Les onglets en arrière-plan ne doivent pas consommer de GPU/CPU.
  3. Le seuil de glissement doit être explicite. Ne déduisez jamais l'intention uniquement de la vélocité ; combinez les vérifications de offset et de velocity.
  4. La référence de portée useAnimate doit être attachée à un élément DOM monté. Appeler animate() avant le montage échoue silencieusement.
  5. Les valeurs de mouvement ne doivent pas être recréées lors du rendu. useMotionValue(0) à l'intérieur du corps d'un composant est correct ; new MotionValue(0) dans un rendu ne l'est pas.
  6. Toutes les valeurs de token sont importées de motion-foundations. Pas de nombres en ligne.
  7. Les hooks personnalisés doivent gérer le nettoyage. Chaque window.addEventListener nécessite un removeEventListener correspondant dans le retour du useEffect.
  8. Le morphing SVG nécessite des nombres de commandes de chemin égaux. Les chemins avec des structures de commandes différentes se cassent au lieu d'interpoler.

Aide à la décision

Choisir la bonne API avancée

ScénarioAPI
Glissement avec physique au relâchementdrag + dragTransition: springs.release
Liste ordonnée à glisser pour réorganiserReorder.Group + Reorder.Item
Rejeter lors du décalage de glissementdrag="y" + vérification du décalage onDragEnd
Glissement gauche/droitedrag="x" + vérification du décalage onDragEnd
Appui longHook useLongPress
Valeur lissée dans le tempsuseSpring
Valeur dérivée d'une autreuseTransform
Séquence multi-étapesuseAnimate avec async/await
Animation impérative uniqueanimate() de motion
Texte apparaissant mot par motStagger sur des spans inline-block
Dessin SVGpathLength 0 → 1
Morphing SVGInterpolation d'attribut d (commandes égales)
Progression circulaireInterpolation strokeDashoffset

Quand utiliser useSpring vs une transition spring

useSpringtransition: springs.*
Utiliser pourSuiveur de curseur, valeurs suivies par le pointeurChangements d'état discrets
Mises à jourContinues, à chaque imageDéclenchées par un changement d'état
InterruptionLisse — la physique reprend à partir de la vélocitéRedémarre à partir de la valeur actuelle

Concepts de base

useMotionValue + useTransform

Calcul réactif sans re-rendus :

const x = useMotionValue(0)
const opacity = useTransform(x, [-200, 0, 200], [0, 1, 0])
// l'opacité se met à jour à chaque image lorsque x change — pas de setState, pas de re-rendu

useAnimate

Retourne [scope, animate]. La référence de portée doit être attachée à un élément DOM. Les appels à animate() sont sécurisés contre les interruptions — appeler en cours d'exécution annule la précédente.

const [scope, animate] = useAnimate()

async function play() {
  await animate(".step-1", { opacity: 1 }, { duration: 0.3 })
  await animate(".step-2", { x: 0 },       { duration: 0.4 })
        animate(".step-3", { scale: 1 },    { duration: 0.25 })  // tire et oublie
}

return <div ref={scope}>...</div>

Exemples de code

Carte glissable

"use client"
import { motion } from "motion/react"
import { springs, motionTokens } from "@/lib/motion-tokens"

<motion.div
  drag
  dragConstraints={{ left: -100, right: 100, top: -100, bottom: 100 }}
  dragElastic={0.1}
  whileDrag={{
    scale: motionTokens.scale.pop,
    boxShadow: "0 16px 40px rgba(0,0,0,0.2)",
  }}
  dragTransition={springs.release}
/>

Feuille à glisser pour rejeter

"use client"
import { motion, useMotionValue, useTransform } from "motion/react"

export function BottomSheet({ onClose }: { onClose: () => void }) {
  const y = useMotionValue(0)
  const opacity = useTransform(y, [0, 200], [1, 0])

  return (
    <motion.div
      drag="y"
      dragConstraints={{ top: 0 }}
      style={{ y, opacity }}
      onDragEnd={(_, info) => {
        // Règle 3 : combiner décalage + vélocité
        if (info.offset.y > 120 || info.velocity.y > 500) onClose()
      }}
    />
  )
}

Liste réorganisable

"use client"
import { Reorder } from "motion/react"

export function SortableList() {
  const [items, setItems] = useState(initialItems)
  return (
    <Reorder.Group axis="y" values={items} onReorder={setItems}>
      {items.map((item) => (
        <Reorder.Item key={item.id} value={item}>
          {item.label}
        </Reorder.Item>
      ))}
    </Reorder.Group>
  )
}

Détection de glissement

"use client"
import { motion } from "motion/react"

const OFFSET_THRESHOLD  = 50
const VELOCITY_THRESHOLD = 300

<motion.div
  drag="x"
  dragConstraints={{ left: 0, right: 0 }}
  onDragEnd={(_, info) => {
    const swipedRight = info.offset.x > OFFSET_THRESHOLD  || info.velocity.x > VELOCITY_THRESHOLD
    const swipedLeft  = info.offset.x < -OFFSET_THRESHOLD || info.velocity.x < -VELOCITY_THRESHOLD
    if (swipedRight) onSwipeRight()
    if (swipedLeft)  onSwipeLeft()
  }}
/>

Hook d'appui long

import { useRef } from "react"

export function useLongPress(callback: () => void, ms = 600) {
  const timerRef = useRef<ReturnType<typeof setTimeout>>()
  return {
    onPointerDown:  () => { timerRef.current = setTimeout(callback, ms) },
    onPointerUp:    () => clearTimeout(timerRef.current),
    onPointerLeave: () => clearTimeout(timerRef.current),
  }
}

Révélation mot par mot

"use client"
import { motion } from "motion/react"
import { springs } from "@/lib/motion-tokens"

export function AnimatedText({ text }: { text: string }) {
  return (
    <motion.p
      variants={{ visible: { transition: { staggerChildren: 0.05 } } }}
      initial="hidden"
      animate="visible"
    >
      {text.split(" ").map((word, i) => (
        <motion.span
          key={i}
          className="inline-block mr-1"
          variants={{
            hidden:  { opacity: 0, y: 12 },
            visible: { opacity: 1, y: 0, transition: springs.gentle },
          }}
        >
          {word}
        </motion.span>
      ))}
    </motion.p>
  )
}

Compteur numérique

"use client"
import { useRef, useEffect } from "react"
import { animate } from "motion"
import { motionTokens } from "@/lib/motion-tokens"

export function Counter({ to }: { to: number }) {
  const nodeRef = useRef<HTMLSpanElement>(null)

  useEffect(() => {
    const controls = animate(0, to, {
      duration: motionTokens.duration.crawl,
      ease: motionTokens.easing.smooth,
      onUpdate: (v) => {
        if (nodeRef.current) nodeRef.current.textContent = Math.round(v).toString()
      },
    })
    return controls.stop   // Règle 7 : nettoyage
  }, [to])

  return <span ref={nodeRef} />
}

Dessin de chemin SVG

"use client"
import { motion } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

<motion.path
  d="M 0 100 Q 50 0 100 100"
  initial={{ pathLength: 0, opacity: 0 }}
  animate={{ pathLength: 1, opacity: 1 }}
  transition={{ duration: motionTokens.duration.slow, ease: motionTokens.easing.smooth }}
/>

Anneau de progression de trait

"use client"
import { motion } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

const CIRCUMFERENCE = 2 * Math.PI * 40   // r=40

export function ProgressRing({ progress }: { progress: number }) {
  return (
    <svg width="100" height="100" viewBox="0 0 100 100">
      <circle cx="50" cy="50" r="40" fill="none" stroke="#e5e7eb" strokeWidth="8" />
      <motion.circle
        cx="50" cy="50" r="40"
        fill="none" stroke="#6366f1" strokeWidth="8"
        strokeLinecap="round"
        strokeDasharray={CIRCUMFERENCE}
        animate={{ strokeDashoffset: CIRCUMFERENCE - (progress / 100) * CIRCUMFERENCE }}
        transition={{ duration: motionTokens.duration.normal, ease: motionTokens.easing.smooth }}
        style={{ rotate: -90, transformOrigin: "center" }}
      />
    </svg>
  )
}

Hook useScrollReveal

"use client"
import { useRef } from "react"
import { useScroll, useTransform } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

export function useScrollReveal() {
  const ref = useRef(null)
  const { scrollYProgress } = useScroll({ target: ref, offset: ["start end", "end start"] })
  const opacity = useTransform(scrollYProgress, [0, 0.3], [0, 1])
  const y       = useTransform(scrollYProgress, [0, 0.3], [motionTokens.distance.lg, 0])
  return { ref, style: { opacity, y } }
}

// Utilisation
const { ref, style } = useScrollReveal()
<motion.section ref={ref} style={style} />

Suiveur de curseur

"use client"
import { useEffect } from "react"
import { motion, useMotionValue, useSpring } from "motion/react"
import { springs } from "@/lib/motion-tokens"

export function CursorFollower() {
  const x = useMotionValue(-100)
  const y = useMotionValue(-100)
  const sx = useSpring(x, springs.gentle)
  const sy = useSpring(y, springs.gentle)

  useEffect(() => {
    const move = (e: MouseEvent) => { x.set(e.clientX); y.set(e.clientY) }
    window.addEventListener("mousemove", move)
    return () => window.removeEventListener("mousemove", move)   // Règle 7
  }, [])

  return (
    <motion.div
      className="fixed top-0 left-0 w-6 h-6 rounded-full bg-indigo-500
                 pointer-events-none -translate-x-1/2 -translate-y-1/2 z-50"
      style={{ x: sx, y: sy }}
    />
  )
}

Squelette shimmer

"use client"
import { useEffect } from "react"
import { motion, useAnimation } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

export function ShimmerSkeleton({ className = "" }: { className?: string }) {
  const controls = useAnimation()

  useEffect(() => {
    const play = () =>
      controls.start({
        x: ["-100%", "100%"],
        transition: {
          repeat: Infinity,
          duration: motionTokens.duration.crawl,
          ease: motionTokens.easing.linear,
        },
      })

    const handleVisibility = () => {
      if (document.visibilityState === "hidden") controls.stop()
      else void play()
    }

    void play()
    document.addEventListener("visibilitychange", handleVisibility)
    return () => {
      controls.stop()
      document.removeEventListener("visibilitychange", handleVisibility)
    }
  }, [controls])

  return (
    <div className={`relative overflow-hidden bg-gray-200 rounded ${className}`}>
      <motion.div
        className="absolute inset-0 bg-gradient-to-r from-transparent via-white/60 to-transparent"
        initial={{ x: "-100%" }}
        animate={controls}
      />
    </div>
  )
}

État de chargement de bouton

"use client"
import { motion, AnimatePresence } from "motion/react"
import { motionTokens, springs } from "@/lib/motion-tokens"

export function LoadingButton({
  loading,
  label,
  onClick,
}: {
  loading: boolean
  label: string
  onClick: () => void
}) {
  return (
    <motion.button
      onClick={onClick}
      animate={{ opacity: loading ? 0.7 : 1 }}
      whileTap={loading ? {} : { scale: motionTokens.scale.press }}
      transition={springs.snappy}
      disabled={loading}
    >
      <AnimatePresence mode="wait">
        {loading ? (
          <motion.span
            key="loading"
            initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}
            transition={{ duration: motionTokens.duration.fast }}
          >
            …
          </motion.span>
        ) : (
          <motion.span
            key="label"
            initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}
            transition={{ duration: motionTokens.duration.fast }}
          >
            {label}
          </motion.span>
        )}
      </AnimatePresence>
    </motion.button>
  )
}

Animation infinie avec pause de visibilité

"use client"
import { useEffect } from "react"
import { motion, useAnimation } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

export function PulseDot() {
  const controls = useAnimation()

  useEffect(() => {
    const pulse = () =>
      controls.start({
        scale: [1, 1.4, 1],
        opacity: [1, 0.6, 1],
        transition: { repeat: Infinity, duration: motionTokens.duration.crawl },
      })

    // Règle 2 : mettre en pause lorsque l'onglet est caché
    const handleVisibility = () => {
      if (document.visibilityState === "hidden") controls.stop()
      else void pulse()
    }

    void pulse()
    document.addEventListener("visibilitychange", handleVisibility)
    return () => {
      controls.stop()
      document.removeEventListener("visibilitychange", handleVisibility)
    }
  }, [controls])

  return <motion.div className="w-4 h-4 rounded-full bg-indigo-500" animate={controls} />
}

Individual skills in this repo

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

Cody-W-Tucker/skills

Landing page quality assessment for paid advertising campaigns. Evaluates message match, page speed, mobile experience, trust signals, form optimization, and conversion rate potential. Use when user says landing page, post-click experience, landing page audit, conversion rate, or landing page optimization.

Cody-W-Tucker/skills

TikTok Ads deep analysis covering creative quality, tracking, bidding, campaign structure, and TikTok Shop. Evaluates 28 checks with emphasis on creative-first strategy, safe zone compliance, and Smart+ campaigns. Use when user says TikTok Ads, TikTok marketing, TikTok Shop, Spark Ads, Smart+, or TikTok campaign.

Cody-W-Tucker/skills

YouTube Ads specific analysis covering campaign types, creative quality, audience targeting, and measurement. Evaluates video ad performance across skippable, non-skippable, bumper, Shorts, Demand Gen, and Connected TV formats. Covers VAC→Demand Gen migration, Shorts creative requirements, and CTV shoppable ads. Use when user says YouTube Ads, video ads, pre-roll, bumper ads, YouTube campaign, Shorts ads, or CTV ads.

Cody-W-Tucker/skills

Craft the story that makes investors say \"I want in.\" Master the narrative structure that Reid Hoffman, Sequoia, and top founders use to raise capital. Use when: **Preparing to fundraise** to develop your story before the deck; **Investor meetings** to structure conversations that convert; **Pitch practice** to refine your narrative arc; **Cold outreach** to write compelling investor emails; **Pivoting** to reframe your story after a change

Cody-W-Tucker/skills

Identify the best GTM motions and tools across 7 motion types: Inbound, Outbound, Paid Digital, Community, Partners, ABM, and PLG. Use when selecting marketing channels, choosing between inbound and outbound strategy, or planning cross-channel campaigns.

Cody-W-Tucker/skills

Produce a print-grade single-page kami (紙 / 纸) document — warm parchment canvas, ink-blue accent, serif at one weight, no italic, no cool grays. The output reads like a professional white paper or studio one-pager, not an app UI. Multilingual by design (EN · zh-CN · ja). One self-contained HTML file, zero dependencies.

Cody-W-Tucker/skills

Optimize landing pages for maximum conversions using proven frameworks from Unbounce and Oli Gardner—apply the \"one goal, one message, one action\" principle with data-driven design, copy, and CTA best practices. Use when: **Create a new landing page** for a campaign; **Optimize an existing landing page** that isn't converting; **Review landing page design** before launch; **Improve form conversion rates** on lead gen pages; **A/B test landing page elements** systematically

Cody-W-Tucker/skills

Motion tokens, spring presets, performance rules, device adaptation, accessibility enforcement, and SSR safety for React / Next.js using motion/react. Foundation layer — all other motion skills depend on this.

Cody-W-Tucker/skills

A single-frame motion-design composition with looping CSS animations — rotating type ring, animated globe, ticking timer, parallax labels. Renders as a hero video poster you can hand straight to HyperFrames or any keyframe-based exporter. Use when the brief asks for "motion design", "animated hero", "loop", "video poster", "title card", or pairs Open Claude Design with HyperFrames for a kinetic export.

Cody-W-Tucker/skills

Production-ready animation patterns for React / Next.js — button, modal, toast, stagger, page transitions, exit animations, scroll, and layout — built on motion-foundations tokens and springs.

Cody-W-Tucker/skills

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

Cody-W-Tucker/skills

Produce a single-file slide deck in the Atelier Zero visual language (warm-paper background, italic-serif emphasis spans, coral terminating dots, surreal collage plates) — Open Design's brand deck recipe. The deck uses **horizontal magazine-style swipe pagination** (←/→, wheel, swipe), a per-slide chrome strip with brand mark and slide counter, an ESC overview grid, a coral progress bar, and inherits the canonical stylesheet + 16-slot image library from the sister `open-design-landing` skill.

Cody-W-Tucker/skills

Produce a world-class single-page editorial landing site in the Atelier Zero visual language (Monocle / Apartamento / Études editorial collage) — the same aesthetic Open Design uses for its own marketing surface. The agent fills a typed `inputs.json` from a brand brief, optionally generates 16 collage assets via gpt-image-2, then runs a pure-function composer that emits a self-contained HTML file; a separate path can mirror the Astro marketing site in `apps/landing-page/`. Drop-in scroll-reveal motion and a Headroom-style sticky nav are wired automatically.

Cody-W-Tucker/skills

Best practices for Remotion - Video creation in React. 29 domain-specific rules covering 3D, animations, audio, captions, charts, transitions, and more.

Cody-W-Tucker/skills

Single-page SaaS landing with hero, features, social proof, pricing, and CTA. Respects the active DESIGN.md color/typography/layout tokens. Trigger keywords: "saas landing", "marketing page", "product landing".

Cody-W-Tucker/skills

Single-page SaaS landing with hero, features, social proof, pricing, and CTA. Respects the active DESIGN.md color/typography/layout tokens. Trigger keywords: "saas landing", "marketing page", "product landing".

Cody-W-Tucker/skills

Master April Dunford's 8-step sales narrative from \"Sales Pitch\" (2023). Transform your positioning into a compelling story that wins enterprise deals. Use when: Structuring B2B sales presentations and demos; Creating pitch decks for complex products; Training sales teams on narrative-driven selling; Converting positioning strategy into sales conversations; Winning against entrenched competitors

Cody-W-Tucker/skills

Swiss-style user-research narrative template in warm-paper editorial aesthetics. Use when users ask for a premium research deck or story-first live artifact with minimalist typography, high-clarity layout, subtle motion, donut breakdowns, and keyboard/click navigation across slides in a single HTML file.

Cody-W-Tucker/skills

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

Cody-W-Tucker/skills

Download YouTube videos with customizable quality and format options. Use this skill when the user asks to download, save, or grab YouTube videos. Supports various quality settings (best, 1080p, 720p, 480p, 360p), multiple formats (mp4, webm, mkv), and audio-only downloads as MP3.

Skills associés