Communitygithub.com

Implementar Movimento do Figma

Traduz movimentos e animações do Figma para código de produção pronto para uso. Use ao implementar animação/movimento de um design do Figma — quando o usuário menciona 'implementar este movimento', 'adicionar animação do Figma', 'animar este componente', fornece uma URL do Figma cujo nó está animado, ou quando `get_design_context` retorna dados de movimento ou instrui você a chamar `get_motion_context`.

O que é Implementar Movimento do Figma?

Esta skill orienta a tradução de animações e transições do Figma em código executável (motion.dev, keyframes CSS ou bibliotecas específicas de framework). Ela se baseia em duas ferramentas principais: `get_motion_context`, que fornece o inventário completo de nós animados, snippets de código, fallbacks de keyframes e dicas de coordenação de timeline; e `get_design_context`, que fornece a estrutura estática do design (layout, tamanhos, ativos, estilos). O fluxo de trabalho essencial é unir os dados de animação de `get_motion_context` com a estrutura de `get_design_context` usando IDs de nós correspondentes. A skill cobre animações como emitidas pelo `get_motion_context` e não se destina a criar/editar animações dentro do próprio Figma. Ela suporta a geração de código para motion.dev, CSS vanilla e bibliotecas como Framer Motion, React Spring ou GSAP, adaptando-se automaticamente ao stack do projeto. Os desenvolvedores devem usar esta skill quando precisarem implementar animações de um design Figma em um repositório de código real.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Devin-AXIS/iPolloWork/tree/HEAD/examples/plugin-packages/figma/skills/figma-implement-motion

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Implementar Movimento

Visão Geral

Esta skill guia a tradução de animações e transições do Figma em código executável (motion.dev, keyframes CSS ou bibliotecas específicas de framework).

O Figma expõe movimento através de duas ferramentas:

  • get_motion_context — ferramenta de movimento autoritativa. Retorna o inventário completo de nós animados, snippets de código pré-computados (CSS @keyframes + motion.dev), bindings de keyframes de fallback quando snippets não estão disponíveis e dicas de coordenação de timeline recursiva (timelineCohorts). Fonte da verdade para dados de animação e quais IDs de nós animam.
  • get_design_context — a estrutura do design: layout, dimensionamento, ativos, estilos, dicas de Code Connect, contexto de captura de tela e, às vezes, marcadores de posicionamento de movimento em elementos animados (data-node-id, e em nós divididos data-motion-keys / data-motion-wrapper-for / data-motion-transform-template). Pode renderizar um nó animado como um elemento simples (div, p, span, etc.) ou um elemento de movimento (motion.div); não incorpora os valores de animação.

Os dois são vinculados pelo ID do nó, e esse é todo o fluxo de trabalho. get_motion_context informa quais nós animam e fornece os valores de keyframe, easing, timing e snippets. get_design_context informa a aparência desses nós e onde eles estão. Para cada nó em get_motion_context.nodes, encontre o data-node-id correspondente no contexto de design e mescle o movimento nessa estrutura — adicionando ou envolvendo um motion.{tag} quando o elemento estrutural for simples. Quando o contexto de design reutilizou um componente do Figma, o nó de movimento também pode incluir fallbackNodeId; use-o apenas como fallback após tentar o nodeId exato.

Limites da Skill

  • Use esta skill quando a entrega for código de movimento no repositório do usuário.
  • Se o usuário pedir para criar/editar animações dentro do próprio Figma, mude para figma-use e siga essa skill.
  • Esta skill atualmente cobre animações conforme emitidas por get_motion_context (snippets mais trilhas de keyframes de fallback, incluindo movimento criado por preset resolvido nessas formas). Fluxos de variantes interativos mais amplos ainda podem precisar de tratamento de estado específico do produto no código.

Pré-requisitos

  • Servidor MCP do Figma conectado e acessível.
  • ID do nó analisado da URL do Figma fornecida pelo usuário. Formato da URL: https://figma.com/design/:fileKey/:fileName?node-id=1-2 — extraia fileKey (o segmento após /design/) e nodeId (o valor do parâmetro de consulta node-id, ex.: 42-15).
  • Base de código alvo. O formato de saída do movimento se adapta ao stack (veja Recomendações de Framework).

Escolha de Ferramenta

Para implementação de movimento, use ambas as ferramentas com funções distintas:

SituaçãoFerramentaPor que
Entender estrutura estática, ativos, estilos, Code Connect ou layout visualget_design_contextFornece a referência de código do componente/página e URLs de ativos necessários para posicionar nós animados corretamente.
Buscar dados de animação para qualquer nóget_motion_contextProjetado especificamente para movimento e é a fonte da verdade para timing, easing, snippets e keyframes.
Um nó tem marcadores de movimento (data-motion-keys, data-motion-wrapper-for)Marcadores para posicionamento dividido, get_motion_context para valoresMarcadores de divisão informam quais trilhas vão em qual elemento; os keyframes/easing/timing e o inventário de nós animados vêm de get_motion_context.

get_motion_context aceita recursive: true (limitado a 500 nós) quando você precisa do movimento dos descendentes em uma única chamada.

Fluxo de Trabalho Obrigatório

Etapa 1: Confirmar que o contexto de design está disponível

get_design_context(fileKey=":fileKey", nodeId="<node-id>")

Se get_design_context já foi chamado para este nó, reutilize essa saída. Caso contrário, chame-o agora normalmente.

Use-o como a estrutura de registro — hierarquia, dimensionamento, estilos, ativos, dicas de Code Connect, contexto de captura de tela e quaisquer marcadores de posicionamento de movimento que ele incluir (Etapa 3). O inventário de nós animados e os valores de animação vêm de get_motion_context (Etapa 2).

Etapa 2: Buscar dados de movimento autoritativos

get_motion_context(fileKey=":fileKey", nodeId="<node-id>", recursive=true)

Forma da resposta (uma entrada por nó animado):

  • codeSnippets — strings CSS @keyframes e motion.dev pré-geradas. Use-as diretamente. Não as regenere a partir de dados de trilhas de fallback.
  • keyframeBindings — trilhas de keyframes vinculadas, incluindo movimento derivado de preset resolvido em dados de trilha, incluídas apenas como dados de fallback quando ambos os formatos de snippet estão ausentes.
  • motionSummary — descrição em linguagem natural de uma linha por campo da animação. Presente apenas quando não há snippet (a geração de código de movimento apenas com bindings de keyframes não pôde expressar como CSS/motion.dev). Construa a partir dele quando presente; ignore-o sempre que um snippet existir.
  • fallbackNodeId — ID de fallback opcional para correspondência de contexto de design componentizado. Se nodeId for um ID qualificado por instância como I4005:6111;30:8005, o D2R pode renderizar o corpo do componente reutilizável com o ID do componente subjacente, como 4002:3957. Nesse caso, fallbackNodeId é o data-node-id a ser procurado se a busca exata por nodeId falhar.

Respostas recursivas também incluem timelineCohorts — um array de nível superior (não por nó) de nós compartilhando uma timeline: { rootNodeId, durationMs, loopMode: 'once' | 'loop' | 'boomerang', memberNodeIds[] }. Para movimento coordenado de vários nós, conduza todos os memberNodeIds de um ciclo de vida compartilhado usando durationMs (÷1000 para segundos) e loopMode — não infira timing a partir da ordem dos irmãos.

Detalhes de implementação importantes para LLMs:

  • Quando um snippet existe, motionSummary, timelineDurationMs e transformOrigin podem ser omitidos para reduzir o payload — o snippet já carrega duração + transform-origin (motion.dev duration / style={{ transformOrigin }}, ou CSS animation / transform-origin) e o cohort carrega durationMs. Um campo ausente nunca significa "sem animação."
  • Respostas recursivas deduplicam snippets exatamente duplicados. Um snippet pode ser substituído por um comentário apontando para o primeiro nó com movimento idêntico; reutilize o mesmo componente, variante, classe ou constantes em vez de escrever uma segunda animação.
  • O servidor MCP infere snippets CSS vs motion.dev a partir de clientFrameworks; se a resposta contiver apenas um formato de snippet, adapte esse formato ao stack do usuário em vez de assumir que o outro formato falhou.

Etapa 3: Mesclar contexto estático e de movimento

  • Comece de get_motion_context.nodes, não de tags motion.* visíveis no JSX estático. Cada nó retornado está animado. Corresponda cada nó de movimento de volta ao get_design_context pelo nodeId / data-node-id exato primeiro. Se e somente se não houver correspondência exata, tente fallbackNodeId / data-node-id. Recorra ao nome/tipo do nó e à posição da captura de tela somente depois que ambos os IDs falharem.
  • Correspondência de ID exata vence sobre fallbackNodeId. fallbackNodeId aponta para o ID do componente subjacente que o D2R pode emitir dentro de um componente reutilizável. É compartilhado por cada instância desse componente. Se o nodeId exato existir no contexto de design, aplique o movimento lá e ignore o fallback. Isso é crítico para animação de instância raiz: uma instância pode girar ou mover-se de forma diferente de outra instância do mesmo componente, e aplicar esse movimento ao corpo do componente compartilhado animaria todas as instâncias incorretamente.
  • Aplique cada nó de movimento à estrutura de contexto de design correspondente, indexada por data-node-id. O data-node-id correspondente é a âncora estrutural, nem sempre o elemento DOM final que recebe o movimento. Use a forma do snippet e os marcadores de posicionamento para decidir se o movimento vai nesse elemento exato, em um wrapper, em um elemento interno ou em um caminho SVG inline. get_design_context já pode emitir motion.{tag} com valores removidos, ou pode emitir um elemento estrutural simples (div, p, span, raiz de componente, etc.). Se for simples e o snippet alvejar o próprio elemento, converta-o para o motion.{tag} apropriado ou adicione um wrapper de movimento preservando o texto, filhos, classes/estilos, atributos e data-node-id do nó. Carregue referências/exemplos-e-antiexemplos.md para ver exemplos desta etapa de mesclagem.
  • Movimento de filho componentizado geralmente corresponde por fallback. Quando o contexto de design extrai uma instância do Figma em um componente React reutilizável, os filhos dentro do corpo desse componente geralmente têm IDs de componente subjacentes (4002:3957) enquanto o contexto de movimento relata IDs de instância ativa (I4005:6111;30:8005). Neste caso, use fallbackNodeId para encontrar o data-node-id do corpo do componente, mas mantenha o movimento escopo da instância renderizada que você está implementando. Se houver várias instâncias e apenas uma tiver movimento raiz diferente, a correspondência de ID exata mantém esse movimento por instância separado.
  • Nós divididos carregam um marcador data-motion-keys / data-motion-wrapper-for — veja Lidando com transformações intercaladas abaixo.
  • Preserve wrappers display: contents — a menos que o próprio grupo anime. Wrappers de grupo transparentes de layout vêm como contents (Tailwind contents), geralmente junto com um absolute/inset-[…] morto (que não faz nada em uma caixa contents). Para um grupo estático, mantenha display: contents e deixe os filhos se posicionarem contra o ancestral real mais próximo — converter o inset do wrapper em uma caixa posicionada reposiciona os filhos para uma caixa menor, fazendo com que eles renderizem muito pequenos / deslocados para dentro. Para um grupo animado (o próprio nó do grupo tem movimento), display: contents não pode carregar uma transformação — substitua-o por um wrapper posicionado real e aplique o movimento do grupo lá. Carregue referências/pegadinhas.md antes de implementar este caso.
  • get_motion_context é o inventário completo de nós animados. Alguns nós animados renderizam como elementos simples (não motion) — raízes de instância de componente ( <div> de posicionamento simples ), texto (<p>), máscaras — que ainda carregam um data-node-id. Percorra cada nó na resposta de movimento e aplique seu movimento ao elemento com o data-node-id correspondente, envolvendo ou convertendo conforme necessário. Se um nó animado não tiver nenhum elemento na saída (por exemplo, uma máscara animada achatada em uma mask-image estática), não o descarte silenciosamente — deixe um comentário // TODO: movimento <nodeId> não suportado e destaque-o em seu resumo.
  • Se um nó aparecer no contexto de movimento, mas não no JSX estático, adicione o elemento necessário para representá-lo — o código do contexto de design é uma referência, não um inventário de animação completo.
  • Em caso de conflito entre contexto de design e movimento (timing/easing/valores animados), prefira get_motion_context.
  • Movimento SVG em nível de caminho: incorpore o SVG e anime o <path> real. Quando get_motion_context alveja o caminho de um vetor (PATH_TRIM, motion.path, stroke-dasharray) mas o contexto de design o renderiza como um <img>, incorpore o SVG e aplique o snippet ao <path>, mantendo o wrapper de layout. Carregue referências/movimento-svg-e-caminho.md para o guia completo para este caso (motion.path, pathLength="1", camadas wrapper+caminho, corte de caminho CSS).

Lidando com transformações intercaladas

Um nó com ambas uma transformação base estática e transformações animadas é dividido entre elementos aninhados para que as duas componham corretamente em vez de lutar: um motion.div sem ID carregando data-motion-wrapper-for="<nodeId>" (o wrapper EXTERNO) envolve um div de transformação estática (ex.: rotate-45 + dimensionamento hypot() — ou o próprio wrapper carrega data-motion-transform-template="<css>") que envolve o nó INTERNO (data-node-id). Mantenha o aninhamento wrapper > div de transformação estática > interno — colapsá-lo quebra o dimensionamento e a transformação base.

  • Coloque trilhas por data-motion-keys. As data-motion-keys do wrapper (trilhas de transformação — x/y/rotate/scaleX/scaleY/skewX) vão no wrapper EXTERNO; as data-motion-keys do elemento interno vão no elemento INTERNO.
  • Reaplique um data-motion-transform-template. Se o wrapper carregar um, defina transformTemplate={(_, generated) => "<css> " + generated} para que a transformação animada componha sobre essa transformação de layout estático.
  • Desloque a transformação animada pela base estática (evite rotação dupla). get_motion_context fornece a transformação absoluta do nó, que já inclui qualquer base estática que esses divs aplicam. Um snippet rotate de [45, 125, 125] sobre uma base rotate-45 significa que o wrapper anima o deslocamento [0, 80, 80] (= absoluto − 45), não o absoluto — senão os 45° são aplicados duas vezes e o elemento fica em 90° em repouso. Trilhas sem base estática (ex.: x/y começando em 0) passam inalteradas. Veja o exemplo de transformação intercalada.
  • Mantenha transformações de layout separadas das transformações do Motion. Para cada elemento motion.* que anima rotate, scale ou skew, verifique se ele também não depende de transformações de layout do Tailwind como -translate-x-1/2 ou -translate-y-1/2 para centralização/posicionamento. Esses utilitários compartilham a propriedade CSS transform que o Motion.dev escreve inline, então a transformação do Motion pode apagar a tradução de layout. Se ambos forem necessários, divida o elemento em um wrapper de layout estático carregando a transformação de centralização/posicionamento e um elemento motion.* interno carregando rotate/scale/opacity animados, ou codifique o deslocamento de layout no próprio Motion (x: "-50%") e mantenha-o presente para cada keyframe.

Etapa 4: Aplicar o movimento no código

  • motion.dev presente nos snippets? Use o código motion.dev textualmente para alvos React. Importe de motion/react — a menos que a base de código já use outra biblioteca de movimento (Framer Motion, React Spring, GSAP), nesse caso adapte o snippet a ela. Carregue referências/recomendações-de-framework.md ao adaptar para outro stack ou escolher uma biblioteca.
  • Keyframes CSS presentes? Use para alvos vanilla/não React, ou quando a base de código não tiver biblioteca de movimento React.
  • Nenhum snippet (apenas bindings de keyframes)? Construa motion.dev/CSS equivalente a partir de keyframeBindings. Cada binding tem duration, easing e array keyframes. Construa string CSS @keyframes ou opção motion.dev transition a partir deles.
  • Adaptação de framework e camada de componente. Para alvos React, coloque o movimento no elemento renderizado correto — converta div para motion.div, ou adicione um wrapper motion.div se o elemento precisar permanecer estático. Use initial, animate, transition para motion.dev; para CSS, aplique animation com o nome @keyframes gerado. Verifique se os estilos iniciais da animação correspondem ao estado estático para evitar "pulo" no carregamento.
  • Movimento coordenado (cohorts de timeline). Quando o movimento de vários nós compartilha uma timeline:
    • Calcule duração: durationMs / 1000 para segundos.
    • Defina loopMode conforme apropriado (once = sem loop, loop = repetir, boomerang = ida e volta).
    • Use os mesmos valores initial e animate para todos os membros (a menos que o snippet especifique o contrário), mas defina atrasos de início diferentes se o cohort especificar offset por nó. Se não houver deslocamentos, inicie todos juntos.
  • Imports e dependências. motion.dev: import { motion } from "motion/react". Framer Motion: import { motion } from "framer-motion". GSAP: use gsap.to(...). React Spring: use useSpring. CSS: adicione a tag <style> ou importe o arquivo CSS.
  • Teste e itere. Após aplicar o movimento, verifique se a animação corresponde ao design do Figma. Se não, ajuste valores, easing ou timing. Use o console do navegador ou extensões React DevTools para depurar.

Referências

Individual skills in this repo

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

Devin-AXIS/iPolloWork

Create deterministic animation and transitions for the active iPollo Video project.

Devin-AXIS/iPolloWork

Inspect, validate, preview, and render the active iPollo Video project with its bundled HyperFrames CLI.

Devin-AXIS/iPolloWork

Apply the core composition, timing, media, and determinism contract used by iPollo Video.

Devin-AXIS/iPolloWork

Plan visual direction, typography, pacing, audio, and composition for iPollo Video projects.

Devin-AXIS/iPolloWork

Build seek-safe keyframe animation for the active iPollo Video timeline.

Devin-AXIS/iPolloWork

Reuse approved HyperFrames blocks and components inside the active iPollo Video project.

Devin-AXIS/iPolloWork

Route video creation and editing through the active iPollo Video project and its built-in HyperFrames runtime.

Devin-AXIS/iPolloWork

Create or edit the active iPolloWork video's visual assets, installed recipes, editable composition and seek-safe motion; use for assembly or local picture/text/theme changes.

Devin-AXIS/iPolloWork

Add or revise music, sound effects and their mix in the active iPolloWork video, using authorized sources, real editable tracks and measured event cues.

Devin-AXIS/iPolloWork

Write or revise the active iPolloWork video's native STORYBOARD.md, with source coverage, content-led sequence and provisional timing; use for script-only work.

Devin-AXIS/iPolloWork

Route the active iPolloWork video request to its current storyboard, compose, voiceover or soundtrack work, preserving the client-owned delivery flow.

Devin-AXIS/iPolloWork

Add or revise scene-bound narration or speech-linked captions in the active iPolloWork video using actual voice settings, measured audio and alignment.

Devin-AXIS/iPolloWork

Create product launch and promotional videos through the active iPollo Video workflow.

Devin-AXIS/iPolloWork

Develop or update reusable visual components for iPolloWork Video, including maps, charts, rankings, diagrams, openings and endings. Use for component authoring rules, manifests, editable variables, shared data forms, inherited design themes, AI editing slots and seekable HyperFrames timelines. Not for producing a whole video, authoring a full-project template, or packaging a DeepSeek host plugin.

Devin-AXIS/iPolloWork

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.

Devin-AXIS/iPolloWork

Plan and create short videos using the installed short-video-studio workspace app. Manage its creative canvas, scripts, storyboards, characters and local assets, generate images or video through connected Work channels, and hand off editable tracks to Work Video Studio.

Devin-AXIS/iPolloWork

Find, generate, process, and reuse media through the active iPollo Video session's media services.

Habilidades Relacionadas