Communitygithub.com

Implementar Movimento

Traduz movimentos e animações do Figma para código de aplicação pronto para produção.

O que é Implementar Movimento?

Esta skill automatiza a conversão de animações e transições do Figma em código executável, utilizando motion.dev, keyframes CSS ou bibliotecas específicas de framework, como Framer Motion. Ela usa duas ferramentas principais: `get_motion_context`, que fornece o inventário completo de nós animados, trechos de código pré-gerados e dicas de temporização; e `get_design_context`, que revela a estrutura estática do design (layout, estilos, ativos e marcadores de movimento). A skill mescla esses dois contextos combinando node IDs: para cada nó animado retornado por `get_motion_context`, a skill encontra o elemento correspondente no contexto de design, aplicando a animação diretamente ou adaptando (por exemplo, convertendo um `<div>` em `motion.div`). Ela suporta plataformas como Figma (via MCP), React, e qualquer stack frontend, e inclui tratamento de casos especiais como transformações intercaladas (onde uma transformação base estática e uma animação convivem em elementos separados) e movimento em SVGs. A skill também prioriza o uso direto dos snippets de código gerados pelo Figma, evitando recriação manual de animações. Ideal para implementações de movimento rápidas e precisas a partir de designs do Figma.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/0n6k4v-Coder/skills/tree/HEAD/figma/ebentley-figma/skills/figma-implement-motion

Perguntar na sua IA favorita

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

Documentação

O que Implementar Movimento faz?

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, trechos de código pré-computados (CSS @keyframes + motion.dev), bindings de keyframe de fallback quando trechos não estão disponíveis e dicas de coordenação de timeline recursiva. Fonte da verdade para dados de animação e quais node IDs animam.
  • get_design_context — a estrutura do design: layout, dimensionamento, ativos, estilos, dicas de Code Connect, contexto de screenshot 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 comum (div, p, span, etc.) ou um elemento de movimento (motion.div); não insere os valores de animação.

Os dois são ligados pelo node id, e esse é todo o fluxo de trabalho. get_motion_context informa quais nós animam e fornece os valores de keyframe, easing, temporização e trechos. 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 comum. Quando o contexto de design reutilizou um componente do Figma, o nó de movimento pode também 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 (trechos mais faixas de keyframe de fallback, incluindo movimento criado por preset resolvido nessas formas). Fluxos de variantes interativos mais amplos podem ainda precisar de tratamento de estado específico do produto em código.

Pré-requisitos

  • Servidor MCP do Figma conectado e acessível.
  • Node ID extraído 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 da Ferramenta

Para implementação de movimento, use ambas as ferramentas com papéis distintos:

SituaçãoFerramentaPorquê
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_contextFeito sob medida para movimento e a fonte da verdade para temporização, easing, trechos e keyframes.
Um nó tem marcadores de movimento (data-motion-keys, data-motion-wrapper-for)Marcadores para posicionamento dividido, get_motion_context para valoresMarcadores divididos informam quais faixas vão em qual elemento; os keyframes/easing/temporização 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 de descendentes em uma chamada.

Fluxo de Trabalho Obrigatório

Etapa 1: Confirmar que o contexto estático do 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. Se não, chame-o normalmente agora.

Use-o como a estrutura de registro — hierarquia, dimensionamento, estilos, ativos, dicas de Code Connect, contexto de screenshot 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 faixa de fallback.
  • keyframeBindings — faixas de keyframe vinculadas, incluindo movimento derivado de preset resolvido em dados de faixa, incluídas apenas como dados de fallback quando ambos os formatos de trecho estão ausentes.
  • fallbackNodeId — id de fallback opcional para corresponder ao 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 procurar se a busca exata por nodeId falhar.

Respostas recursivas podem também incluir timelineCohorts: grupos de node IDs animados que compartilham uma raiz de timeline, duração e modo de reprodução (once, loop ou boomerang). Use cohorts para manter animações escalonadas ou multinó sincronizadas em vez de inferir temporização compartilhada da ordem de irmãos.

Detalhes de implementação que importam para LLMs:

  • Quando trechos existem, keyframeBindings brutos, timelineDurationMs, motionSummary e transformOrigin padrão podem ser removidos para manter o payload pequeno. keyframeBindings ausente não é um sinal de que não há animação.
  • Respostas recursivas deduplicam trechos exatamente duplicados. Um trecho 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 trechos CSS vs motion.dev dos clientFrameworks; se a resposta contém apenas um formato de trecho, 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 por get_motion_context.nodes, não por tags visíveis motion.* no JSX estático. Cada nó retornado é animado. Corresponda cada nó de movimento de volta a 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 do screenshot apenas após ambos os ids falharem.
  • Correspondência exata de id prevalece 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 existe no contexto de design, aplique movimento lá e ignore o fallback. Isso é crítico para animação de instância raiz: uma instância pode girar ou mover-se diferentemente 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, chaveada por data-node-id. O data-node-id correspondente é a âncora estrutural, nem sempre o elemento DOM final que recebe movimento. Use a forma do trecho e 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 pode já emitir motion.{tag} com valores removidos, ou pode emitir um elemento estrutural comum (div, p, span, raiz de componente, etc.). Se for comum e o trecho visa 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, filhos dentro do corpo desse componente frequentemente têm ids de componente subjacente (4002:3957) enquanto o contexto de movimento relata ids de instância viva (I4005:6111;30:8005). Neste caso, use fallbackNodeId para encontrar o data-node-id do corpo do componente, mas mantenha o movimento com escopo na instância renderizada que você está implementando. Se houver várias instâncias e apenas uma tiver movimento de raiz diferente, a correspondência exata de id mantém esse movimento por instância separado.
  • Nós divididos carregam um marcador data-motion-keys / data-motion-wrapper-for — veja Tratamento de transformações intercaladas abaixo.
  • Preserve wrappers display: contents — a menos que o próprio grupo anime. Wrappers de grupo transparentes a layout vêm como contents (Tailwind contents), geralmente junto com um absolute/inset-[…] morto (estes não fazem 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 reparentaliza os filhos para uma caixa menor, então eles renderizam 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 comuns (não motion) — raízes de instância de componente (<div> de posicionamento comum), 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 tem nenhum elemento na saída (por exemplo, uma máscara animada achatada em um mask-image estático), não o descarte silenciosamente — deixe um comentário // TODO: <nodeId> movimento não suportado e mencione-o em seu resumo.
  • Se um nó aparece 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 conflito entre contexto de design e movimento (temporização/easing/valores animados), prefira get_motion_context.
  • Movimento SVG ao nível de caminho: faça inline do SVG e anime o <path> real. Quando get_motion_context visa o caminho de um vetor (PATH_TRIM, motion.path, stroke-dasharray) mas o contexto de design o renderiza como <img>, faça inline do SVG e aplique o trecho 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", wrapper+camadas de caminho, path-trim CSS).

Tratamento de 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-transform-estática > interno — colapsá-lo quebra o dimensionamento e a transformação base.

  • Coloque faixas por data-motion-keys. As data-motion-keys do wrapper (faixas 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 em cima dessa transformação de layout estática.
  • 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 trecho 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° aplicam duas vezes e o elemento fica em 90° em repouso. Faixas 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. Essas utilidades 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 ambas forem necessárias, 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 em código

  • motion.dev presente nos trechos? 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), caso em que adapte o trecho a ela. Carregue referências/recomendacoes-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 tem biblioteca de movimento React.
  • Sem trechos? Use keyframeBindings ou motionSummary como dados de fallback para construir chamadas equivalentes a motion.dev ou keyframes CSS. Normalmente trechos estão presentes; faça isso apenas quando ambos os formatos de trecho estiverem genuinamente ausentes.

Etapa 5: Validar

  • Leia as importações/convenções de movimento existentes do componente antes de adicionar novas. Se o usuário já usa Framer Motion / React Spring / anime.js, adapte-se em vez de forçar motion.dev.
  • Verifique pontualmente se uma animação funciona de ponta a ponta (recarregue, observe, itere) antes de agrupar mudanças em muitos nós.
  • Carregue referências/pegadinhas.md

Individual skills in this repo

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

Habilidades Relacionadas