Communitygithub.com

503496348-ops/mischief-production

Produktionsreife Animationsmuster für React / Next.js – Button, Modal, Toast, Stagger, Seitenübergänge, Exit-Animationen, Scroll und Layout – basierend auf motion-foundations-Token und Springs.

Was ist mischief-production?

Diese Skill-Sammlung stellt eine vollständige Bibliothek produktionsreifer UI-Animationsmuster für React- und Next.js-Anwendungen bereit. Sie deckt die häufigsten Anforderungen ab: Button-Feedback, modale Dialoge, Toast-Benachrichtigungen, gestaffelte Listeneingänge, Seitenübergänge im Next.js App Router, Scroll-Reveal-Effekte und Layout-Animationen wie expandierende Karten und Akkordeons. Der wesentliche Vorteil liegt in der strikten Einhaltung von Best Practices: Alle Muster importieren ihre Animationswerte aus `motion-foundations` (keine hartcodierten Zahlen), verwenden `AnimatePresence` mit korrekt gesetzten `key`- und `exit`-Props und beachten Accessibility-Richtlinien (z. B. Fokusfallen bei Modals). Die Skill enthält klare Entscheidungsleitfäden, wann `layout` vs. `layoutId` oder `mode="wait"` vs. `mode="sync"` verwendet werden sollte, sowie ausführliche Code-Beispiele für jede Komponente. Das Skill unterstützt Entwickler dabei, konsistente, SSR-sichere und zugängliche Animationen zu implementieren, ohne gängige Anti-Patterns (fehlende Exit-Animationen, falsche Schlüssel oder zu große Stagger-Intervalle) zu reproduzieren. Es ist eng mit den Skills `motion-foundations` (für Token-Definitionen) und `motion-advanced` (für komplexere Interaktionen) verknüpft.

Funktioniert mit~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/503496348-ops/mischief-production/tree/HEAD/skills/ecc-motion-patterns

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Motion Patterns

Kopierfertige Muster für die häufigsten UI-Animationen. Jedes Muster baut auf den Tokens und Springs von motion-foundations auf. Definiere keine neuen Dauer- oder Easing-Werte – importiere sie.

Wann aktivieren

  • Animation eines Buttons, einer Karte, eines Modals oder einer Toast-Benachrichtigung
  • Aufbau von Listeneingängen mit Staffelung
  • Einrichten von Seitenübergängen im Next.js App Router
  • Hinzufügen von Eingangs- oder Ausgangsanimationen für bedingte Inhalte
  • Implementierung von Scroll-Reveal, scroll-verknüpften Fortschrittsanzeigen oder Sticky-Story-Abschnitten
  • Erstellen von expandierenden Karten, Akkordeons oder Shared-Element-Übergängen

Ausgaben

Diese Skill produziert:

  • Zugängliche, SSR-sichere Animationen für alle Standard-UI-Komponenten
  • Mit AnimatePresence umschlossene bedingte Renderings mit korrektem Exit-Verhalten
  • Page-Transition-Wrapper-Komponente für den Next.js App Router
  • Scroll-Reveal- und scroll-verknüpfte Muster mit useScroll + useTransform
  • Layout-Animationen (layout, layoutId) für expandierende und überblendende Elemente

Prinzipien

  • Jedes Muster importiert aus motion-foundations. Keine rohen Zahlen.
  • Jedes bedingte Rendering wird mit AnimatePresence und einem key umschlossen.
  • Exit-Animationen werden immer zusammen mit Eingangs-Animationen definiert – nie als nachträglicher Einfall.
  • layout wird nur für kleine, isolierte Verschiebungen verwendet. Große Teilbäume erhalten explizite Transformationen.

Regeln

  1. Umschließe bedingte Renderings immer mit AnimatePresence und einem key auf dem direkten Kind. Ohne einen Key werden Exit-Animationen nie ausgelöst.
  2. Definiere immer exit, wenn du initial + animate definierst. Eine Animation ohne Exit ist unvollständig.
  3. Verwende mode="wait" für Seitenübergänge. Die Eingabe darf erst starten, wenn die Ausgabe abgeschlossen ist.
  4. Verwende layout niemals auf Teilbäumen mit mehr als ~5 Kindern oder tief verschachteltem DOM. Verwende stattdessen explizite x/y-Transformationen.
  5. Der Staffelungsintervall muss zwischen 0.05s und 0.10s liegen. Darunter wirkt es mechanisch; darüber wirkt es träge.
  6. Modals müssen immer enthalten: Fokusfalle, Escape-Taste zum Schließen, Scroll-Sperre, role="dialog", aria-modal="true".
  7. Scroll-Reveals verwenden viewport={{ once: true }}. Wiederholtes Einblenden beim Rausscrollen lenkt ab, informiert nicht.
  8. Alle Token-Werte werden aus motion-foundations importiert. Keine Inline-Zahlen.

Entscheidungsleitfaden

Das richtige Muster auswählen

SituationMuster
Element erscheint / verschwindetAnimatePresence
Liste von Elementen, die nacheinander ladenStagger-Varianten
Navigation zwischen RoutenPage-Transition-Wrapper
Element ändert die Größe an Ort und Stellelayout-Prop
Gleiches Element bewegt sich über SeitenkontextelayoutId
Element erscheint beim Scrollen in den ViewportwhileInView
Wert an Scroll-Position gebundenuseScroll + useTransform

Wann mode="wait" vs. mode="sync" verwenden

ModusVerwenden, wenn
waitSeitenübergänge, Inhaltswechsel (eines nach dem anderen)
syncGestapelte Benachrichtigungen, Listenelemente (Überlappung ist in Ordnung)
popLayoutElemente aus einer umfließenden Liste entfernt werden

Kernkonzepte

AnimatePresence-Vertrag

Drei Dinge müssen immer wahr sein:

  1. AnimatePresence umschließt das bedingte Element
  2. Das direkte Kind hat einen key
  3. Das Kind hat eine exit-Prop

Fehlt eines davon, schlägt die Exit-Animation still fehl.

layout vs. layoutId

  • layout – animiert die eigene Größen-/Positionsänderung des Elements an Ort und Stelle
  • layoutId – verknüpft zwei separate Elemente und überblendet zwischen ihnen bei unterschiedlichen Renderings

Verwende layout="position" auf Text innerhalb eines expandierenden Containers, um zu verhindern, dass der Text-Umbruch animiert wird.

Code-Beispiele

Button-Feedback

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

<motion.button
  whileHover={{ scale: motionTokens.scale.pop }}
  whileTap={{ scale: motionTokens.scale.press }}
  transition={springs.snappy}
/>

Stagger-Liste

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

const container = {
  hidden: {},
  visible: {
    transition: {
      staggerChildren: 0.08,   // innerhalb der 0.05–0.10 Regel
      delayChildren: 0.1,
    },
  },
}

const item = {
  hidden:  { opacity: 0, y: motionTokens.distance.md },
  visible: { opacity: 1, y: 0, transition: springs.gentle },
}

<motion.ul variants={container} initial="hidden" animate="visible">
  {items.map((i) => (
    <motion.li key={i.id} variants={item} />
  ))}
</motion.ul>

Modal

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

// Am Aufrufort umschließen:
// <AnimatePresence>{isOpen && <Modal key="modal" />}</AnimatePresence>

export function Modal({ onClose }: { onClose: () => void }) {
  return (
    <>
      {/* Overlay */}
      <motion.div
        className="fixed inset-0 bg-black/50"
        initial={{ opacity: 0 }}
        animate={{ opacity: 1 }}
        exit={{ opacity: 0 }}
        onClick={onClose}
      />

      {/* Panel – Barrierefreiheitsanforderungen: Fokusfalle, Escape zum Schließen,
          Scroll-Sperre, role="dialog", aria-modal="true" */}
      <motion.div
        role="dialog"
        aria-modal="true"
        className="fixed inset-x-4 top-1/2 -translate-y-1/2 rounded-xl bg-white p-6"
        initial={{
          opacity: 0,
          scale: motionTokens.scale.press,
          y: motionTokens.distance.sm,
        }}
        animate={{ opacity: 1, scale: 1, y: 0 }}
        exit={{
          opacity: 0,
          scale: motionTokens.scale.press,
          y: motionTokens.distance.sm,
        }}
        transition={springs.gentle}
      />
    </>
  )
}

Toast-Stapel

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

<AnimatePresence mode="sync">
  {toasts.map((t) => (
    <motion.div
      key={t.id}
      layout
      initial={{
        opacity: 0,
        x: motionTokens.distance.xl,
        scale: motionTokens.scale.subtle,
      }}
      animate={{ opacity: 1, x: 0, scale: 1 }}
      exit={{
        opacity: 0,
        x: motionTokens.distance.xl,
        scale: motionTokens.scale.subtle,
      }}
      transition={springs.snappy}
    />
  ))}
</AnimatePresence>

Seitenübergang (Next.js App Router)

// components/page-transition.tsx
"use client"
import { motion, AnimatePresence } from "motion/react"
import { usePathname } from "next/navigation"
import { motionTokens } from "@/lib/motion-tokens"

const variants = {
  initial: { opacity: 0, y: motionTokens.distance.sm },
  enter:   { opacity: 1, y: 0 },
  exit:    { opacity: 0, y: -motionTokens.distance.sm },
}

export function PageTransition({ children }: { children: React.ReactNode }) {
  const pathname = usePathname()
  return (
    <AnimatePresence mode="wait">
      <motion.div
        key={pathname}
        variants={variants}
        initial="initial"
        animate="enter"
        exit="exit"
        transition={{
          duration: motionTokens.duration.normal,
          ease: motionTokens.easing.smooth,
        }}
      >
        {children}
      </motion.div>
    </AnimatePresence>
  )
}

Scroll-Reveal

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

<motion.div
  initial={{ opacity: 0, y: motionTokens.distance.lg }}
  whileInView={{ opacity: 1, y: 0 }}
  viewport={{ once: true, margin: "-80px" }}   // once: true – Regel 7
  transition={{ duration: motionTokens.duration.slow, ease: motionTokens.easing.smooth }}
/>

Scroll-Fortschrittsbalken

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

export function ScrollProgress() {
  const { scrollYProgress } = useScroll()
  return (
    <motion.div
      className="fixed top-0 left-0 h-1 bg-indigo-500 origin-left w-full"
      style={{ scaleX: scrollYProgress }}
    />
  )
}

Expandierende Karte

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

export function ExpandingCard({ title, body }: { title: string; body: string }) {
  const [expanded, setExpanded] = useState(false)

  return (
    <motion.div layout onClick={() => setExpanded(!expanded)} className="cursor-pointer">
      {/* layout="position" verhindert, dass der Text-Umbruch animiert wird */}
      <motion.h2 layout="position" className="font-semibold">
        {title}
      </motion.h2>

      <AnimatePresence>
        {expanded && (
          <motion.p
            key="body"
            initial={{ opacity: 0 }}
            animate={{ opacity: 1 }}
            exit={{ opacity: 0 }}
            transition={{ duration: motionTokens.duration.fast }}
          >
            {body}
          </motion.p>
        )}
      </AnimatePresence>
    </motion.div>
  )
}

Shared-Element-Überblendung

// Quellkontext
<motion.img layoutId="hero-image" src={src} className="w-16 h-16 rounded" />

// Zielkontext (gleiche layoutId – motion übernimmt den Übergang)
<motion.img layoutId="hero-image" src={src} className="w-full rounded-xl" />

Akkordeon

<motion.div
  initial={false}
  animate={{ opacity: open ? 1 : 0, scaleY: open ? 1 : 0 }}
  style={{ transformOrigin: "top", overflow: "hidden" }}
  transition={{
    duration: motionTokens.duration.normal,
    ease: motionTokens.easing.smooth,
  }}
> {children}
</motion.div>

Durchgehendes Beispiel

Eine gestaffelte Liste, die beim Mounten erscheint, bedingte Darstellung handhabt und reduzierte Bewegung respektiert – kombiniert Tokens, Springs, AnimatePresence und den Barrierefreiheits-Hook aus motion-foundations:

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

const containerVariants = {
  hidden: {},
  visible: {
    transition: { staggerChildren: 0.08, delayChildren: 0.1 },
  },
}

function ListItem({ label, onRemove }: { label: string; onRemove: () => void }) {
  const safe = useSafeMotion(motionTokens.distance.sm)
  return (
    <motion.li
      variants={{
        hidden:  safe.initial,
        visible: safe.animate,
      }}
      exit={safe.exit}
      transition={springs.gentle}
      className="flex items-center justify-between p-3 rounded-lg bg-white shadow-sm"
    >
      <span>{label}</span>
      <button onClick={onRemove}>Entfernen</button>
    </motion.li>
  )
}

export function AnimatedList({ items, onRemove }: {
  items: { id: string; label: string }[]
  onRemove: (id: string) => void
}) {
  return (
    <motion.ul
      variants={containerVariants}
      initial="hidden"
      animate="visible"
      className="space-y-2"
    >
      <AnimatePresence mode="popLayout">
        {items.map((item) => (
          <ListItem
            key={item.id}
            label={item.label}
            onRemove={() => onRemove(item.id)}
          />
        ))}
      </AnimatePresence>
    </motion.ul>
  )
}

Einschränkungen / Nicht-Ziele

Diese Skill deckt nicht ab:

  • Token- und Spring-Definitionen → siehe motion-foundations
  • Drag-Interaktionen, Wischgesten, sortierbare Listen → siehe motion-advanced
  • Text-Animationen (Wort-/Zeichen-Enthüllung, Zähler) → siehe motion-advanced
  • SVG-Pfadzeichnung oder Morphing → siehe motion-advanced
  • Benutzerdefinierte Animations-Hooks → siehe motion-advanced
  • CSS-Only-Übergänge, die nicht motion/react verwenden

Anti-Patterns

Anti-PatternVerletzte RegelLösung
AnimatePresence-Kind ohne keyRegel 1Füge einen stabilen key zum direkten Kind hinzu
initial + animate ohne exitRegel 2Definiere immer alle drei zusammen
Seitenübergang ohne mode="wait"Regel 3Füge mode="wait" zu AnimatePresence hinzu
layout auf einer 50-Elemente-ListeRegel 4Verwende mode="popLayout" oder explizite Transformationen
staggerChildren: 0.2 auf einer 10-Elemente-ListeRegel 5Begrenzen auf 0.08–0.10
Modal ohne FokusfalleRegel 6Füge focus-trap-react oder Radix Dialog hinzu
whileInView ohne viewport={{ once: true }}Regel 7Wiederholte Eingänge lenken ab, informieren nicht
transition={{ duration: 0.3 }} inlineRegel 8Verwende motionTokens.duration.normal

Verwandte Skills

  • motion-foundations — definiert alle Tokens, Springs, den useSafeMotion-Hook und SSR-Guards, die jedes Muster hier importiert. Muss zuerst eingerichtet werden.
  • motion-advanced — erweitert diese Muster um Drag, Gesten, SVG, Text, benutzerdefinierte Hooks und imperative Sequenzierung. Definiert keine Muster aus dieser Skill neu.

Individual skills in this repo

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

503496348-ops/mischief-production

Use this skill when inspecting Blender characters, rigs, poses, animation retargeting, ground contact, facing direction, or model-vs-motion alignment where screenshots alone are not enough.

503496348-ops/mischief-production

Build reusable Manim explainers for technical concepts, graphs, system diagrams, and product walkthroughs, then hand off to the wider HCP video stack if needed. Use when the user wants a clean animated explainer rather than a generic talking-head script.

503496348-ops/mischief-production

Advanced motion patterns for React / Next.js — drag & drop, gestures, text animations, SVG path drawing, custom hooks, imperative sequences (useAnimate), loaders, and the full API decision tree. Requires motion-foundations.

503496348-ops/mischief-production

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.

503496348-ops/mischief-production

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

503496348-ops/mischief-production

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

503496348-ops/mischief-production

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.

Verwandte Skills