Communitygithub.com

bardu-rgb/reels

Estrutura o markup do Remotion para interatividade no Remotion Studio.

O que é reels?

Este skill define as melhores práticas para estruturar o markup do Remotion de forma que o Remotion Studio possa reconhecer e tornar o código interativo. Ele permite que itens sejam selecionados clicando, arrastados, redimensionados, rotacionados e que estilos CSS, keyframes e easing sejam editados diretamente. O foco principal é o uso de componentes interativos com seus próprios timelines, utilizando `Interactive.withSchema({wrapInSequence: true})` para componentes visuais, e propagando estilos inline através de `style`. Para elementos individuais, como divisórias e imagens, o `Interactive` (ex: `Interactive.Div`) torna o elemento editável no Studio. O skill também recomenda o registro de componentes reutilizáveis como composições conectadas, a colocação de timing diretamente no componente (como `from` e `durationInFrames`), e a criação de um nó JSX separado para cada item editável. Por fim, orienta a manter todos os estilos CSS inline e usar `interpolate()` diretamente nas propriedades para animações, evitando constantes, spreads e matemática complexa no markup para garantir máxima interatividade.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/bardu-rgb/reels/tree/HEAD/.agents/skills/remotion-interactivity

Perguntar na sua IA favorita

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

Prévia

Do README da skill

reels preview

Documentação

Ao escrever o markup do Remotion de uma forma específica, o Remotion Studio consegue reconhecer a estrutura do código e torná-lo interativo:

  • Permitindo que itens sejam selecionados clicando neles
  • Permitindo arrastar e soltar, redimensionar e rotacionar
  • Editando os estilos CSS
  • Tornando keyframes e valores de easing editáveis

Se o markup for muito complexo para o Studio torná-lo interativo, os valores ficarão acinzentados.

Prefira componentes interativos com suas próprias timelines

Use Interactive.withSchema({wrapInSequence: true}) para cenas personalizadas, cartões, títulos e outros componentes visuais cujas props devem ser editáveis por instância. Exponha controles de conteúdo e aparência significativos em um InteractivitySchema. Mantenha os detalhes decorativos de implementação dentro do componente.

O componente deve aceitar style e repassá-lo para uma raiz visual. Mantenha uma raiz compartilhada quando transformações, corte ou opacidade devem afetar todas as suas camadas. Achate wrappers internos redundantes quando seus estilos podem ser movidos para um elemento existente sem alterar o layout ou a animação.

import type React from 'react';
import {Interactive, type InteractivitySchema} from 'remotion';

type LowerThirdProps = {
  readonly children: string;
  readonly accentColor: string;
  readonly style?: React.CSSProperties;
};

const LowerThirdInner: React.FC<LowerThirdProps> = ({
  children,
  accentColor,
  style,
}) => {
  return (
    <Interactive.Div
      style={{
        position: 'absolute',
        left: 80,
        bottom: 80,
        display: 'flex',
        alignItems: 'center',
        gap: 20,
        backgroundColor: 'white',
        borderRadius: 16,
        padding: '20px 32px',
        color: 'black',
        fontFamily: 'Helvetica, Arial, sans-serif',
        fontSize: 48,
        fontWeight: 600,
        ...style,
      }}
    >
      <div
        style={{
          width: 8,
          alignSelf: 'stretch',
          borderRadius: 4,
          backgroundColor: accentColor,
        }}
      />
      {children}
    </Interactive.Div>
  );
};

const lowerThirdSchema = {
  children: {type: 'text-content', default: '', description: 'Texto'},
  accentColor: {
    type: 'color',
    default: '#0b84f3',
    description: 'Cor de destaque',
  },
} as const satisfies InteractivitySchema;

export const LowerThird = Interactive.withSchema({
  Component: LowerThirdInner,
  componentName: '<LowerThird>',
  schema: lowerThirdSchema,
  wrapInSequence: true,
});

Repassar o style injetado dentro do componente é obrigatório; mantenha os estilos editáveis inline no local de chamada do componente.

Escolha os campos do schema

Cada chave no schema é uma prop que o Studio pode ler e editar no local de chamada. Props que não estão no schema ainda funcionam, mas não são editáveis no Studio. Chaves podem usar notação de ponto, como style.color.

TipoUso paraCom keyframe
text-contentTexto, como um títuloNão
numberNúmeros, com min, max, step, integer opcionaisSim
booleanInterruptores liga/desligaSim (hold)
colorStrings de cor CSSSim
enumUma escolha entre variants, cada uma com seu próprio schemaOpt-in (hold)
arrayListas de números, cores, enums e maisNão
assetFontes de mídia, com assetType opcionalNão
font-familyFamília de fonte CSSNão
font-weightPeso da fonteSim
translate, scale, rotation-css, rotation-degrees, transform-originTransformaçõesSim
uv-coordinateUm ponto [x, y] normalizado no elementoSim
svg-pathDados de caminho SVGSim
remotion-captionsDados Caption[]Não
hiddenUm valor mantido fora dos controles—

Cada campo precisa de um default e deve ter um description, que o Studio mostra como rótulo. Defina keyframable: false para mostrar um controle estático.

Exponha conteúdo e aparência por instância, como o texto e uma cor de destaque. Não adicione campos para style.translate, style.scale, style.rotate, style.transformOrigin e style.opacity: wrapInSequence: true já os adiciona.

Para tornar as propriedades CSS da raiz editáveis por instância, espalhe os fragmentos de schema integrados:

const cardSchema = {
  ...Interactive.textSchema, // style.color, style.fontSize, style.fontWeight, ...
  ...Interactive.backgroundSchema, // style.backgroundColor
  ...Interactive.borderRadiusSchema, // style.borderRadius, ...
} as const satisfies InteractivitySchema;

Também disponível: Interactive.borderSchema e Interactive.captionsSchema para componentes que aceitam legendas. Veja InteractivitySchema para todas as opções.

Registre componentes reutilizáveis como composições conectadas

Registre cenas substanciais e componentes reutilizáveis com suas próprias camadas ou animação como composições independentes. O Studio chama essas composições conectadas: elas podem ser abertas em sua própria timeline enquanto compartilham a mesma implementação de componente com o vídeo pai.

Defina estilos obrigatórios e carregue fontes dentro do componente para que funcione sem seu pai. Veja independência do pai.

Registre a mesma referência de componente exportada que o pai renderiza. Para o exemplo acima, use component={LowerThird}, não LowerThirdInner ou um wrapper inline. Com wrapInSequence: true, nenhum <Sequence> extra é necessário para a conexão.

import {Composition} from 'remotion';
import {LowerThird} from './LowerThird';

export const RemotionRoot = () => (
  <Composition
    id="LowerThird"
    component={LowerThird}
    width={1280}
    height={720}
    fps={30}
    durationInFrames={30}
    defaultProps={{
      children: 'Jane Doe, Designer de Produto',
      accentColor: '#0b84f3',
    }}
  />
);

Escolha um ID único, padrões inline representativos, e dimensões, fps e duração adequados para pré-visualizar o componente. Os padrões de registro não copiam automaticamente props de uma instância pai. Veja composições conectadas para detalhes de registro e extração.

Coloque o timing diretamente no componente

Evite um <Sequence> separado em torno de um componente que já aceita props de timing. Componentes interativos integrados e componentes personalizados feitos com wrapInSequence: true podem receber name, from, durationInFrames, trimBefore, playbackRate e premountFor diretamente.

<LowerThird
  name="Terço inferior"
  from={30}
  durationInFrames={90}
  accentColor="#0b84f3"
>
  Jane Doe, Designer de Produto
</LowerThird>

Ao remover uma sequência redundante, mova seu timing e nome para o filho. Preserve qualquer timing filho existente; não sobrescreva ou aplique deslocamentos duplicados. Uma chamada useCurrentFrame() dentro do componente lê seu frame local, enquanto uma expressão de estilo no local de chamada ainda usa o frame do chamador. Preserve essa distinção ao mover estilos de animação.

Mantenha um <Sequence> quando ele fornecer timing compartilhado para vários irmãos, substituir dimensões para useVideoConfig(), ou envolver um componente que não lida com timing. Mantenha <Series.Sequence> para layout consecutivo e <TransitionSeries.Sequence> para transições; props from diretas não substituem esses comportamentos.

Dê a cada item editável individual seu próprio nó JSX

O Studio edita o nó JSX fonte que criou um item. Se vários itens em tempo de execução vêm do mesmo nó JSX, eles compartilham um único alvo de edição de fonte.

Para cada registro de composição, clipe, cena, camada ou sequência que deve ser editável por si só, escreva um nó JSX separado e mantenha suas props editáveis nesse nó. Isso se aplica a <Composition>, <Still>, componentes de mídia integrados, <Sequence>, <Series.Sequence>, <TransitionSeries.Sequence> e componentes personalizados.

Por exemplo, crie uma timeline editável assim:

<Series>
  <Series.Sequence name="Introdução" durationInFrames={90}>
    <Introduction />
  </Series.Sequence>
  <Series.Sequence name="Demonstração" durationInFrames={150}>
    <Demo />
  </Series.Sequence>
</Series>

Um .map() ou outro loop programático criaria vários itens em tempo de execução a partir de um único nó JSX fonte. Isso é apropriado para saída repetida que é intencionalmente controlada como um modelo, como barras de visualização ou partículas. Não é apropriado quando as instâncias precisam de IDs ou nomes, props, metadados, timing, ordenação, exclusão ou duplicação independentes no Studio.

Torne um elemento HTML interativo usando Interactive

Todo elemento HTML e SVG (exceto <Img>, que já é interativo) como <div> pode se tornar interativo usando Interactive:

<Interactive.Div
  name="Cartão de saudação"
  style={{fontSize: 80, padding: 24}}
>
  Olá
</Interactive.Div>

Isso permite que estilos e keyframes sejam definidos no Studio. Seja sensato; se um componente tiver muitos elementos, a timeline pode ficar bagunçada.

Prefira texto inline

Se o texto é fixo e usado apenas uma vez, escreva-o diretamente dentro do elemento interativo em vez de extraí-lo para uma constante.

// 👍 Cópia fixa permanece editável
<Interactive.Div name="Título">
  Melhores Práticas do Remotion
</Interactive.Div>

Use uma prop ou variável apenas quando o texto for dinâmico ou reutilizado.

Dê aos elementos interativos um nome descritivo

Adicione uma prop name aos elementos para torná-los facilmente identificáveis. Evite nomes computados; codifique-os manualmente.

<>
  <Interactive.Div name="Título herói" style={{fontSize: 80}}>
    Dia do lançamento
  </Interactive.Div>
  <Img name="Avatar" src="https://remotion.media/image.jpeg" />
  <Video name="Fundo" src="https://remotion.media/video.mp4" />
  <Interactive.Div name="Título">
    Dia do lançamento
  </Interactive.Div>
</>

Mantenha todos os estilos CSS inline

A melhor maneira é simplesmente passar um objeto simples para style - sem referências a constantes, sem espalhamento de objetos, sem matemática.

<Interactive.Div
  style={{
    fontSize: 80,
    color: 'red',
  }}
>
  Olá Mundo!
</Interactive.Div>
const baseStyle = useMemo(() => {
  return {
    fontSize: 12 // ❌ Estilos não inline não são suportados
  }
}, []);

<Interactive.Div
  style={{
    ...baseStyle, // ❌ Espalhamento não é suportado
    color: RED, // ❌ Referenciar constantes não é suportado
    scale: frame * 10 // ❌ Matemática não é suportada
  }}
>
  Olá Mundo!
</Interactive.Div>

Animar usando interpolate()

Escreva animações como chamadas interpolate() inline na propriedade que muda.
O intervalo de saída, easing, extrapolação e a propriedade output devem usar valores codificados manualmente.

O intervalo de entrada pode adicionalmente usar durationInFrames, fps, width e height desestruturados diretamente de useVideoConfig(). Identificadores simples como durationInFrames, multiplicação com um número como 2 * fps ou fps * 2, e subtração de um número como durationInFrames - 1 são suportados.

const {fps, durationInFrames} = useVideoConfig();

// 👍 Valores inline podem ser padronizados e com keyframe
<Interactive.Div
  name="Cartão de produto"
  style={{
    color: 'white',
    fontSize: 80,
    scale: interpolate(frame, [0, fps], [0, 1], {
      easing: Easing.spring({damping: 200}),
      output: 'perceptual-scale',
      extrapolateLeft: 'clamp',
      extrapolateRight: 'clamp'
    }),
    rotate: interpolate(frame, [0, 1 * fps], ['0deg', '20deg'], {
      easing: Easing.spring({damping: 200}),
      extrapolateLeft: 'clamp',
      extrapolateRight: 'clamp'
    }),
    translate: interpolate(
      frame,
      [durationInFrames - 30, durationInFrames],
      ['0px 0px', '0px 120px'],
      {
        easing: Easing.spring({damping: 200}),
        output: 'perceptual-scale',
        extrapolateLeft: 'clamp',
        extrapolateRight: 'clamp'
      }
    ),
  }}
/>
const translateY = interpolate(frame, [0, 30], [0, 120]); // ❌ A matemática deve estar diretamente no markup

<Interactive.Div
  name="Cartão de produto"
  style={{
    translate: translateY, // ❌ Apenas chamadas interpolate() inline são suportadas
    rotate: interpolate(frame, [start, start + 10], [0, Math.PI]), // ❌ Não é possível usar matemática com variáveis arbitrárias, não é possível usar constantes
    scale

…

[truncado para tradução]

Individual skills in this repo

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

Habilidades Relacionadas