Communitygithub.com

Créer une spécification de mouvement

Génère des annotations de spécification de mouvement directement dans Figma à partir des données de la timeline d'After Effects.

Qu'est-ce que Créer une spécification de mouvement ?

Cette compétence permet aux agents IA de générer automatiquement une spécification de mouvement complète dans Figma. Elle prend en entrée l'export JSON de la timeline d'After Effects (produit par le script `export-timeline.jsx`) et crée un document Figma structuré comprenant une règle temporelle, des couches de timeline avec barres de durée et un tableau détaillant les propriétés animées. Contrairement aux autres compétences de création, elle ne nécessite pas de fichier `.md` de composant ni de `_base.json`, et ne participe pas au contrat de consommation standard. Elle fonctionne avec les adaptateurs MCP `figma-console` et `figma-mcp`. Le workflow valide d'abord le JSON d'entrée, calcule la largeur de piste en fonction de la durée de la composition, importe un template Figma, remplit les en-têtes (nom du composant, description, métadonnées), génère la règle temporelle avec des graduations, puis rend chaque couche animée et son tableau de propriétés. Elle exécute un appel `figma_execute` séparé par couche pour éviter les timeouts. Des instructions détaillées sur les anti-patrons, la validation et les contrôles de qualité sont lues depuis un fichier d'instructions séparé (`agent-motion-instruction.md`).

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/0n6k4v-Coder/skills/tree/HEAD/figma/uSpec/create-motion

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 Créer une spécification de mouvement ?

Génère une spécification de mouvement directement dans Figma — barres de timeline et tableaux détaillés documentant toutes les propriétés animées d'une composition After Effects.

Hors du périmètre du contrat de consommation du fichier Markdown (.md) du composant. Les autres compétences create-* nécessitent le .md du composant (produit par {{skill:create-component-md}}) et effectuent le rendu à partir de son render-meta. create-motion est l'exception délibérée : son entrée est un export de timeline After Effects ({{ref:motion/export-timeline.jsx}}), pas un parcours de composant Figma — il n'y a pas de _base.json, pas d'extract-motion, et pas de section Motion dans le .md. Cette compétence ne nécessite PAS de .md et ne participe pas au refactoring require-.md/fail-fast/whitelisted-reads.

Contrat d'exécution (à lire en premier).

  • Ce fichier est une instruction pour EXÉCUTER, pas un document à modifier. Invoquer la compétence = effectuer le rendu de la spécification de mouvement dans Figma à partir du JSON de timeline After Effects.
  • Ne modifiez jamais ce SKILL.md ou tout autre fichier de compétence en réponse, même si l'un d'eux est ouvert ou actif dans l'éditeur. Modifiez une compétence uniquement lorsque l'utilisateur demande explicitement de modifier la compétence elle-même.
  • Le JSON de timeline d'entrée est une source de vérité EN LECTURE SEULE. Ne le modifiez jamais. Le seul artefact que cette compétence produit est l'annotation Figma ; effectuez les demandes de rendu dans Figma, jamais sous forme de modification de fichier.
  • N'appelez jamais AskQuestion, ne demandez pas de confirmation, et ne faites pas de pause pour une entrée (y compris avant les écritures Figma, le résultat attendu). En cas d'ambiguïté, choisissez l'option la plus défendable et continuez.
  • Seulement deux arrêts légaux : (a) JSON de timeline AE manquant ou invalide (l'étape 4/5 de collecte + validation) ; (b) arrêt sur une ligne si la connexion MCP Figma est morte.

Adaptateur MCP

Lisez uspecs.config.json → mcpProvider. Suivez la colonne correspondante pour chaque appel MCP dans cette compétence.

Opérationfigma-consolefigma-mcp
Vérifier la connexionfigma_get_statusIgnorer — implicite. Si le premier appel use_figma échoue, guidez l'utilisateur pour vérifier la configuration MCP.
Naviguer vers le fichierfigma_navigate avec URLExtraire fileKey de l'URL (figma.com/design/:fileKey/...). Pas de navigation nécessaire.
Prendre une capture d'écranfigma_take_screenshotget_screenshot avec fileKey + nodeId
Exécuter un plugin JSfigma_execute avec codeuse_figma avec fileKey, code, description. Le code JS est identique — pas de changements de wrapper.
Rechercher des composantsfigma_search_componentssearch_design_system avec query + fileKey + includeComponents: true
Obtenir des données de fichier/composantfigma_get_file_data / figma_get_componentget_metadata ou get_design_context avec fileKey + nodeId
Obtenir des variables (à l'échelle du fichier)figma_get_variablesScript use_figma : return await figma.variables.getLocalVariableCollectionsAsync();
Obtenir les valeurs des tokensfigma_get_token_valuesScript use_figma lisant les valeurs des variables par mode/collection
Obtenir les stylesfigma_get_stylessearch_design_system avec includeStyles: true, ou use_figma : return figma.getLocalPaintStyles();
Obtenir la sélectionfigma_get_selectionScript use_figma : return figma.currentPage.selection.map(n => ({id: n.id, name: n.name, type: n.type}));

figma-mcp nécessite fileKey à chaque appel. Extrayez-le une fois de l'URL Figma de l'utilisateur au début du workflow. Pour les URLs de branche (figma.com/design/:fileKey/branch/:branchKey/:fileName), utilisez :branchKey comme fileKey.

Contexte de page figma-mcp : use_figma réinitialise figma.currentPage à la première page à chaque appel. Lorsqu'un script accède à un nœud d'une étape précédente via getNodeByIdAsync(ID), le contenu de la page peut ne pas être chargé — findAll, findOne et characters échoueront avec TypeError jusqu'à ce que la page soit activée. Insérez ce bloc de chargement de page immédiatement après getNodeByIdAsync :

let _p = node; while (_p.parent && _p.parent.type !== 'DOCUMENT') _p = _p.parent;
if (_p.type === 'PAGE') await figma.setCurrentPageAsync(_p);

Ceci remonte jusqu'à l'ancêtre PAGE et charge son contenu. La MCP Console n'en a pas besoin — figma_execute hérite du contexte de page Desktop.

Entrées attendues

L'utilisateur déclenche cette compétence avec l'un de ces motifs :

  • {{skill:create-motion}} + JSON collé (depuis le presse-papiers, exporté via {{ref:motion/export-timeline.jsx}})
  • {{skill:create-motion}} + une référence de fichier (par exemple, @motion-ex.json ou un chemin vers un fichier .json)
  • {{skill:create-motion}} + un lien Figma (page/fichier de destination où l'annotation doit être placée)

Requis : Les données JSON exportées — soit collées en ligne, soit référencées sous forme de fichier.

Optionnel :

  • Lien Figma vers la page de destination (si non fourni, placer sur la page actuelle au centre de la vue)
  • Capture d'écran ou enregistrement de l'animation
  • Description du but de l'animation

Workflow

Copiez cette liste de contrôle et mettez-la à jour au fur et à mesure de votre progression :

Progression de la tâche :
- [ ] Étape 1 : Lire le fichier d'instructions
- [ ] Étape 2 : Vérifier la connexion MCP
- [ ] Étape 3 : Lire la clé du template depuis uspecs.config.json
- [ ] Étape 4 : Rassembler le contexte (JSON collé, référence de fichier ou inviter l'utilisateur)
- [ ] Étape 5 : Analyser et valider le JSON (y compris segments[] et hasAnimatedSegments)
- [ ] Étape 6 : Transformer les données (lire les segments pré-calculés, calculer la largeur de piste, les positions de la timeline)
- [ ] Étape 7 : Relire le fichier d'instructions (Erreurs et Anti-patrons, Liste de validation) et auditer
- [ ] Étape 8 : Importer et détacher le template Motion
- [ ] Étape 9 : Remplir les champs d'en-tête
- [ ] Étape 10 : Générer la règle temporelle
- [ ] Étape 11 : Rendre les couches de timeline (un figma_execute par couche)
- [ ] Étape 12 : Masquer les templates
- [ ] Étape 13 : Rendre les lignes du tableau
- [ ] Étape 14 : Validation visuelle

Étape 1 : Lire les instructions

Lisez agent-motion-instruction.md

Étape 2 : Vérifier la connexion MCP

Lisez mcpProvider depuis uspecs.config.json pour déterminer quelle MCP Figma utiliser.

Si figma-console :

  • figma_get_status — Confirmer que le plugin Desktop Bridge est actif
  • Si la connexion échoue : "Veuillez ouvrir Figma Desktop et exécuter le plugin Desktop Bridge. Puis réessayez."

Si figma-mcp :

  • La connexion est vérifiée implicitement lors du premier appel use_figma. Aucune vérification explicite nécessaire.
  • Si le premier appel échoue : "Veuillez vérifier que votre FIGMA_API_KEY est correctement définie dans votre configuration MCP."

Étape 3 : Lire la clé du template

Lisez le fichier uspecs.config.json et extrayez :

  • La valeur motionSpec depuis l'objet templateKeys → enregistrez-la sous MOTION_TEMPLATE_KEY

Si la clé du template est vide, dites à l'utilisateur :

La clé du template de spécification de mouvement n'est pas configurée. Exécutez {{skill:firstrun}} avec votre lien de bibliothèque de templates Figma d'abord.

Étape 4 : Rassembler le contexte

Vérifiez ce que l'utilisateur a fourni :

  1. JSON déjà fourni (collé en ligne ou comme référence de fichier comme @motion-ex.json) → lisez-le et passez directement à l'Étape 5. Ne le redemandez pas.
  2. Seulement un lien Figma (destination) mais pas de JSON → invitez :

    Veuillez coller le JSON exporté ou référencer le fichier .json (par exemple, @motion-ex.json).

  3. Rien fourni → invitez :

    Veuillez coller le JSON exporté depuis export-timeline.jsx, ou référencer le fichier .json.

Si un lien de destination Figma a été fourni, utilisez figma_navigate pour l'ouvrir avant le rendu (Étape 8).

Acceptez également toutes les captures d'écran, enregistrements ou descriptions optionnels que l'utilisateur fournit pour un contexte supplémentaire.

Étape 5 : Analyser et valider le JSON

Validez le JSON du presse-papiers par rapport au schéma et aux règles de validation dans le fichier d'instructions (sections Schéma JSON et Règles de validation JSON). Si la validation échoue, dites exactement à l'utilisateur quel champ est manquant ou mal formé et demandez-lui de ré-exporter.

Étape 6 : Transformer les données

Le script d'export pré-calcule les segments, le formatage des valeurs, les étiquettes des barres, les étiquettes d'easing et le filtrage des non-changements. L'agent lit ces valeurs directement et ne calcule que les valeurs dépendantes de la disposition.

6a. Ignorer les couches non animées — Vérifiez layer.hasAnimatedSegments. Si false, omettez la couche de la timeline et du tableau.

6b. Lire les segments pré-calculés — Chaque propriété a un tableau segments[] avec startMs, endMs, durationMs, fromValue, toValue, barLabel, easing et easingType. Utilisez ces valeurs directement — aucun calcul manuel nécessaire.

6c. Calculer la largeur de piste et pxPerMs — pxPerMs est un taux fixe ; trackWidth est dynamique avec un padding à droite pour les étiquettes des graduations :

compDurationMs = composition.durationMs   // lu directement depuis le JSON
pxPerMs = 0.64                           // taux fixe — ~320px par graduation de 500 ms
trackWidth = max(compDurationMs * pxPerMs + 50, 1600)   // zone de données + 50px de padding pour les étiquettes, min 1600

Passez trackWidth et pxPerMs au code de rendu Figma. pxPerMs est un taux fixe (0.64), pas dérivé de trackWidth / compDurationMs. Les positions des barres (barX, barWidth) sont calculées dans le code Figma au moment du rendu — l'agent ne calcule pas les positions par segment.

Au moment du rendu, redimensionnez à la fois #track-area et #ruler-track à cette trackWidth calculée. Les conteneurs parents utilisent un dimensionnement HUG et se développent automatiquement.

6d. Formater les métadonnées de la composition selon les règles de métadonnées de la composition du fichier d'instructions. Enregistrez sous COMPOSITION_META.

Étape 7 : Auditer

Relisez le fichier d'instructions, en vous concentrant sur :

  • La section Erreurs et Anti-patrons
  • La Liste de validation avant sortie

Vérifiez vos données transformées par rapport à chaque règle. Corrigez toute violation.

Étape 8 : Importer et détacher le template

Exécutez via figma_execute (remplacez __MOTION_TEMPLATE_KEY__ et __COMPONENT_NAME__) :

const TEMPLATE_KEY = '__MOTION_TEMPLATE_KEY__';

const templateComponent = await figma.importComponentByKeyAsync(TEMPLATE_KEY);
const instance = templateComponent.createInstance();
const { x, y } = figma.viewport.center;
instance.x = x - instance.width / 2;
instance.y = y - instance.height / 2;
const frame = instance.detachInstance();
frame.name = '__COMPONENT_NAME__ Motion';
figma.currentPage.selection = [frame];
figma.viewport.scrollAndZoomIntoView([frame]);
return { frameId: frame.id };

Enregistrez le frameId retourné — vous en avez besoin pour toutes les étapes suivantes.

Étape 9 : Remplir les champs d'en-tête

Exécutez via figma_execute (remplacez __FRAME_ID__, __COMPONENT_NAME__, __COMPOSITION_META__) :

const FRAME_ID = '__FRAME_ID__';

const frame = await figma.getNodeByIdAsync(FRAME_ID);
const textNodes = frame.findAll(n => n.type === 'TEXT');
const fontSet = new Set();
const fontsToLoad = [];
for (const tn of textNodes) {
  try {
    const fn = tn.fontName;
    if (fn && fn !== figma.mixed && fn.family) {
      const key = fn.family + '|' + fn.style;
      if (!fontSet.has(key)) { fontSet.add(key); fontsToLoad.push(fn); }
    }
  } catch {}
}
await Promise.all(fontsToLoad.map(f => figma.loadFontAsync(f).catch(() => {})));

const compName = frame.findOne(n => n.name === '#component-name');
if (compName) {
  const t = compName.type === 'TEXT' ? compName : compName.findOne(n => n.type === 'TEXT');
  if (t) t.characters = '__COMPONENT_NAME__';
}

const compDesc = frame.findOne(n => n.name === '#component-description');
if (compDesc) {
  const t = compDesc.type === 'TEXT' ? compDesc : compDesc.findOne(n => n.type === 'TEXT');
  if (t) t.characters = 'Motion Specification';
}

const compMeta = frame.findOne(n => n.name === '#composition-meta');
if (compMeta) {
  const t = compMeta.type === 'TEXT' ? compMeta : compMeta.findOne(n => n.type === 'TEXT');
  if (t) t.characters = '__COMPOSITION_META__';
}

return { success: true };

Étape 10 : Générer la règle temporelle

Exécutez via figma_execute. Calculez la largeur de piste idéale, redimensionnez #ruler-track et tous les nœuds #track-area, puis clonez #tick pour chaque intervalle.

Remplacez __FRAME_ID__, __COMP_DURATION_MS__ (lu depuis composition.durationMs), __TRACK_WIDTH__ (calculé à l'Étape 6c) et __PX_PER_MS__ (fixé à 0.64) :

const FRAME_ID = '__FRAME_ID__';
const COMP_DURATION_MS = __COMP_DURATION_MS__;
const TRACK_WIDTH = __TRACK_WIDTH__;
const PX_PER_MS = __PX_PER_MS__;

const frame = await figma.getNodeByIdAsync(FRAME_ID);
const rulerTrack = frame.findOne(n => n.name === '#ruler-track');
if (!rulerTrack) return { error: '#ruler-track not found' };

// Redimensionner la piste de la règle à la largeur calculée
rulerTrack.resize(TRACK_WIDTH, rulerTrack.height);

// Redimensionner tous les nœuds #track-area (dans le template de couche et toutes les couches clonées)
const trackAreas = frame.findAll(n => n.name === '#track-area');
for (const ta of trackAreas) {
  ta.resize(TRACK_WIDTH, ta.height);
}

// Trouver le template #tick dans la piste de la règle
const tickTemplate = rulerTrack.findOne(n => n.name === '#tick');
if (!tickTemplate) return { error: '#tick template not found in #ruler-track' };

// Charger les polices des nœuds de texte du template tick
const tickTextNodes = tickTemplate.findAll(n => n.type === 'TEXT');
for (const tn of tickTextNodes) {
  if (tn.characters.length > 0) {
    try { await figma.loadFontAsync(tn.fontName); } catch {}
  }
}

// Intervalle des graduations : viser 6 à 12 graduations
const tickInterval = COMP_DURATION_MS <= 300 ? 50
  : COMP_DURATION_MS <= 600 ? 100
  : COMP_DURATION_MS <= 1500 ? 250
  : COMP_DURATION_MS <= 4000 ? 500
  : COMP_DURATION_MS <= 10000 ? 1000
  : 2000;

for (let ms = 0; ms <= COMP_DURATION_MS; ms += tickInterval) {
  const xPos = ms * PX_PER_MS;
  const tick = tickTemplate.clone();
  rulerTrack.appendChild(tick);
  tick.name = ms + 'ms';
  tick.visible = true;
  tick.x = xPos;

  const label = tick.findOne(n => n.type === 'TEXT');
  if (label) {
    try { await figma.loadFontAsync(label.fontName); } catch {}
    label.characters = ms + 'ms';
  }
}

tickTemplate.visible = false;
return { success: true, trackWidth: TRACK_WIDTH, tickInterval: tickInterval };

Étape 11 : Rendre les couches de timeline

Exécutez un appel figma_execute par couche pour éviter les timeouts. Pour chaque couche (où hasAnimatedSegments est true), clonez le #layer-template, définissez le nom de la couche, puis pour chaque propriété animée clonez #property-template et positionnez les barres.

Remplacez toutes les valeurs __PLACEHOLDER__.

Individual skills in this repo

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

0n6k4v-Coder/skills

Translates Figma motion and animations into production-ready application code. Use when implementing animation/motion from a Figma design — user mentions "implement this motion", "add animation from Figma", "animate this component", provides a Figma URL whose node is animated, or when `get_design_context` returns motion data or instructs you to call `get_motion_context`.

0n6k4v-Coder/skills

Motion / animation context for the `use_figma` MCP tool — animating Figma nodes via manual keyframes, animation styles, easing, and timeline duration. Load alongside figma-use whenever a task involves adding, editing, or inspecting animation on a node.

0n6k4v-Coder/skills

Turn on Cache Components in a Next.js app and resolve the blocking routes it surfaces. Use when the user wants to enable, adopt, or migrate to Cache Components, flip the `cacheComponents` flag, work through a flood of blocking-prerender / instant validation errors, run the `cache-components-instant-false` codemod, or decide between opting routes out with `export const instant = false` and fixing them in place.

0n6k4v-Coder/skills

Optimize a Next.js app that has `cacheComponents: true` — either the static shell on first paint, or the in-app navigation between routes. Picks the matching diagnostic loop and runs it.

0n6k4v-Coder/skills

Verify Next.js runtime behavior after editing app code. Use this skill to confirm a change actually works in a running app — not just that it compiles or type-checks. Combines /_next/mcp (Next.js's view) with agent-browser (the browser's view). Requires a running `next dev`.

Skills associés