Communitygithub.com

Hownameee/short-videos

Estrutura marcação Remotion para interatividade

O que é short-videos?

Esta skill define as melhores práticas para estruturar código Remotion de forma que o Remotion Studio possa reconhecer e tornar interativos os elementos da interface. Ela é essencial para desenvolvedores que criam vídeos programaticamente com Remotion e desejam permitir que usuários editem propriedades como estilos CSS, animações, texto e cores diretamente no Studio, sem precisar mexer no código fonte. A skill cobre como usar o componente `Interactive` para transformar elementos HTML e SVG em elementos interativos, como criar componentes reutilizáveis com `Interactive.withSchema()` e `wrapInSequence: true`, e como registrar composições conectadas para que cada cena ou componente tenha sua própria linha do tempo editável. Ela suporta as plataformas Remotion Studio e é compatível com qualquer versão do Remotion que inclua a API de interatividade. Além disso, a skill explica como manter estilos CSS inline, animar com `interpolate()` diretamente na marcação, e dar nomes descritivos aos elementos para facilitar a edição no Studio. O resultado é um fluxo de trabalho mais produtivo, onde o código permanece limpo e os designers podem ajustar parâmetros visualmente.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Hownameee/short-videos/tree/HEAD/.agent/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

short-videos preview

Documentação

Ao escrever a marcação 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 girar
  • Editando os estilos CSS
  • Tornando keyframes e valores de easing editáveis

Se a marcação for muito complexa para o Studio tornar interativa, os valores ficarão acinzentados.

Prefira componentes interativos com suas próprias linhas do tempo

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 de implementação decorativos dentro do componente.

O componente deve aceitar style e repassá-lo a 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 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. As chaves podem usar notação de ponto, como style.color.

TipoUse paraCom keyframe
text-contentTexto, como um títuloNão
numberNúmeros, com min, max, step, integer opcionaisSim
booleanInterruptores liga/desligaSim (segurado)
colorStrings de cor CSSSim
enumUma escolha entre variants, cada uma com seu próprio schema aninhadoOpt-in (segurado)
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 normalizado [x, y] no elementoSim
svg-pathDados de caminho SVGSim
remotion-captionsDados Caption[]Não
hiddenUm valor mantido fora dos controles—

Todo 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 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 linha do tempo enquanto compartilham a mesma implementação de componente com o vídeo 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, Product Designer',
      accentColor: '#0b84f3',
    }}
  />
);

Escolha um ID único, valores padrão inline representativos e dimensões, fps e duração adequados para 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 tempo diretamente no componente

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

<LowerThird
  name="Lower third"
  from={30}
  durationInFrames={90}
  accentColor="#0b84f3"
>
  Jane Doe, Product Designer
</LowerThird>

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

Mantenha um <Sequence> quando ele fornece tempo compartilhado para vários irmãos, substitui dimensões para useVideoConfig() ou envolve um componente que não lida com tempo. 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 independente seu próprio nó JSX

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

Para cada registro de composição, clipe, cena, camada ou sequência que deve ser editável por conta própria, 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 linha do tempo 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 de um nó fonte JSX. 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 independentes, props, metadados, tempo, ordenação, exclusão ou duplicação no Studio.

Torne um elemento HTML interativo usando Interactive

Todo elemento HTML e SVG (exceto <Img>, já é interativo) como <div> pode ser tornado 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 linha do tempo 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 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.

<>
  <Interactive.Div name="Título principal" style={{fontSize: 80}}>
    Dia de 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 de lançamento
  </Interactive.Div>
</>

Mantenha todos os estilos CSS inline

A melhor maneira é simplesmente passar um objeto puro para style - sem referir-se 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, // ❌ Referir-se a constantes não é suportado
    scale: frame * 10 // ❌ Matemática não é suportada
  }}
>
  Olá Mundo!
</Interactive.Div>

Anime 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.

O intervalo de entrada pode adicionalmente usar durationInFrames, fps, width e height desestruturados diretamente de useVideoConfig(). Identificadores simples como durationInFrames, multiplicação por 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 na marcação

<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: interpolate(anyVariable, [0, 30], [0, 1]) // ❌ Só pode interpretar a variável `frame`.
  }}
/>

Mantenha os caminhos SVG

…

Individual skills in this repo

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

Hownameee/short-videos

Generate, revise or troubleshoot local Kokoro narration, pronunciation and scene word timing. Reuse verified unchanged clips; inspect the Python environment before setup changes. Exclude research, visuals, music composition and publishing.

Hownameee/short-videos

Router for all Remotion skills

Hownameee/short-videos

Transcribing, displaying and animating captions

Hownameee/short-videos

Remotion Map animation knowledge

Hownameee/short-videos

Content, animation and effects best practices

Hownameee/short-videos

Upgrade Remotion, and related packages

Hownameee/short-videos

>- Run Phase 1 of the shared short-video workflow: turn a raw topic or prompt into a sourced research pack and 2–4 distinct video directions, each with a defensible tension hook, promise, payoff, beats, visual approach, duration range, and risks. Use whenever the user asks for video ideas, angles, research, facts, hooks, topic analysis, or choices before scriptwriting. Stop for the user's direction choice and do not silently continue into script or production.

Hownameee/short-videos

Produce an approved short video or correct an existing video's background sound, emotion, captions, mix or export. Generate only changed narration, render and review a current preview, run technical and editorial QC, then export. Exclude script-only and general audio-advice requests.

Hownameee/short-videos

>- Run Phase 2 of the shared short-video workflow: convert an explicitly selected direction and its research into a reviewable beat sheet, narration, flexible scene timing, on-screen text, visual plan, captions, music and SFX cues, pronunciation notes, payoff, takeaway, and contextual CTA. Use whenever a user asks to write, revise, preview, or approve a short-video script. Stop for script approval and do not generate TTS or render video yet.

Hownameee/short-videos

>- Design and review a coherent visual system for short-form video before and during Remotion implementation. Use for video art direction, scene UI, typography, layout, color, diagrams, captions, motion, transitions, platform safe areas, or visual-quality review. Use Remotion skills separately for API, timeline, media, Studio, and rendering behavior; do not use this skill for narration-only or research-only work.

Hownameee/short-videos

Coordinate prompt-to-short-video discovery, scripting and production. Resume existing projects and route soundtrack or mix corrections directly to production. Preserve direction choice and script approval; exclude general audio advice.

Habilidades Relacionadas