Communitygithub.com

Hownameee/short-videos

Structurer le balisage Remotion pour le rendre interactif

Qu'est-ce que short-videos ?

Ce skill permet aux développeurs utilisant Remotion d'écrire du balisage de manière à ce que le Studio Remotion reconnaisse la structure du code et le rende interactif. Il explique comment utiliser les composants interactifs avec leurs propres timelines, comment exposer les propriétés modifiables via un schéma d'interactivité, et comment enregistrer des compositions connectées pour éditer chaque élément individuellement. Le skill couvre également les bonnes pratiques comme l'utilisation de noms descriptifs, le maintien des styles CSS en ligne, et l'animation via `interpolate()`. Il est compatible avec tous les outils supportant les skills AI (comme Claude Code, Cursor, Codex) et fonctionne avec Remotion Studio. La documentation fournie (SKILL.md) détaille chaque aspect avec des exemples concrets en TypeScript/React, ce qui facilite l'adoption des meilleures pratiques pour créer des vidéos interactives et facilement éditables dans Remotion.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Hownameee/short-videos/tree/HEAD/.agent/skills/remotion-interactivity

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Aperçu

Depuis le README du skill

short-videos preview

Documentation

En écrivant le balisage Remotion d'une manière spécifique, le Studio Remotion est capable de reconnaître la structure du code et le rend interactif :

  • Permettre la sélection d'éléments en cliquant dessus
  • Permettre le glisser-déposer, le redimensionnement et la rotation
  • Modifier les styles CSS
  • Rendre les images clés et les valeurs d'easing modifiables

Si le balisage est trop complexe pour que le Studio le rende interactif, les valeurs deviennent grisées.

Préférer les composants interactifs avec leurs propres timelines

Utilisez Interactive.withSchema({wrapInSequence: true}) pour les scènes personnalisées, cartes, titres et autres composants visuels dont les propriétés doivent être modifiables par instance. Exposez les contrôles de contenu et d'apparence significatifs dans un InteractivitySchema. Gardez les détails d'implémentation décoratifs à l'intérieur du composant.

Le composant doit accepter style et le transmettre à une racine visuelle. Conservez une racine partagée lorsque les transformations, le recadrage ou l'opacité doivent affecter toutes ses couches. Aplatissez les wrappers internes redondants lorsque leurs styles peuvent être déplacés sur un élément existant sans modifier la mise en page ou l'animation.

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: 'Texte'},
  accentColor: {
    type: 'color',
    default: '#0b84f3',
    description: 'Couleur d\'accentuation',
  },
} as const satisfies InteractivitySchema;

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

La transmission du style injecté à l'intérieur du composant est requise ; conservez les styles modifiables en ligne au point d'appel du composant.

Choisir les champs du schéma

Chaque clé du schéma est une propriété que le Studio peut lire et modifier au point d'appel. Les propriétés qui ne sont pas dans le schéma fonctionnent toujours, mais ne sont pas modifiables dans le Studio. Les clés peuvent utiliser la notation par points, comme style.color.

TypeUtilisation pourImages clés
text-contentTexte, comme un titreNon
numberNombres, avec min, max, step, integer optionnelsOui
booleanInterrupteurs On/OffOui (maintien)
colorChaînes de couleur CSSOui
enumUn choix entre variants, chacun avec son propre schéma imbriquéOptionnel (maintien)
arrayListes de nombres, couleurs, énumérations, etc.Non
assetSources média, avec assetType optionnelNon
font-familyFamille de police CSSNon
font-weightGraisse de policeOui
translate, scale, rotation-css, rotation-degrees, transform-originTransformationsOui
uv-coordinateUn point normalisé [x, y] sur l'élémentOui
svg-pathDonnées de chemin SVGOui
remotion-captionsDonnées Caption[]Non
hiddenUne valeur gardée hors des contrôles—

Chaque champ a besoin d'une valeur default et devrait avoir une description, que le Studio affiche comme étiquette. Définissez keyframable: false pour afficher un contrôle statique.

Exposez le contenu et l'apparence par instance, comme le texte et une couleur d'accentuation. N'ajoutez pas de champs pour style.translate, style.scale, style.rotate, style.transformOrigin et style.opacity : wrapInSequence: true les ajoute déjà.

Pour rendre les propriétés CSS de la racine modifiables par instance, étendez les fragments de schéma intégrés :

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

Également disponibles : Interactive.borderSchema et Interactive.captionsSchema pour les composants qui acceptent des sous-titres. Voir InteractivitySchema pour toutes les options.

Enregistrer les composants réutilisables comme compositions connectées

Enregistrez les scènes substantielles et les composants réutilisables avec leurs propres couches ou animations en tant que compositions autonomes. Le Studio les appelle compositions connectées : elles peuvent être ouvertes dans leur propre timeline tout en partageant la même implémentation de composant avec la vidéo parente.

Enregistrez la même référence de composant exporté que celle que le parent rend. Pour l'exemple ci-dessus, utilisez component={LowerThird}, pas LowerThirdInner ou un wrapper en ligne. Avec wrapInSequence: true, aucun <Sequence> supplémentaire n'est nécessaire pour la connexion.

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 Produit',
      accentColor: '#0b84f3',
    }}
  />
);

Choisissez un ID unique, des valeurs par défaut en ligne représentatives, et des dimensions, fps et durée adaptés à l'aperçu du composant. Les valeurs par défaut d'enregistrement ne copient pas automatiquement les propriétés d'une instance parente. Voir les compositions connectées pour les détails d'enregistrement et d'extraction.

Mettre le timing directement sur le composant

Évitez un <Sequence> séparé autour d'un composant qui accepte déjà des propriétés de timing. Les composants interactifs intégrés et les composants personnalisés créés avec wrapInSequence: true peuvent recevoir name, from, durationInFrames, trimBefore, playbackRate et premountFor directement.

<LowerThird
  name="Tiers inférieur"
  from={30}
  durationInFrames={90}
  accentColor="#0b84f3"
>
  Jane Doe, Designer Produit
</LowerThird>

Lors de la suppression d'une séquence redondante, déplacez son timing et son nom vers l'enfant. Préservez tout timing enfant existant ; ne réécrivez pas et n'appliquez pas deux fois les décalages. Un appel useCurrentFrame() à l'intérieur du composant lit son image locale, tandis qu'une expression de style au point d'appel utilise toujours l'image de l'appelant. Préservez cette distinction lors du déplacement des styles d'animation.

Conservez un <Sequence> lorsqu'il fournit un timing partagé pour plusieurs frères, surcharge les dimensions pour useVideoConfig(), ou encapsule un composant qui ne gère pas le timing. Conservez <Series.Sequence> pour la mise en page consécutive et <TransitionSeries.Sequence> pour les transitions ; les propriétés from directes ne remplacent pas ces comportements.

Donner à chaque élément modifiable son propre nœud JSX

Le Studio édite le nœud source JSX qui a créé un élément. Si plusieurs éléments d'exécution proviennent du même nœud JSX, ils partagent une cible d'édition de source unique.

Pour chaque enregistrement de composition, clip, scène, couche ou séquence qui doit être modifiable indépendamment, écrivez un nœud JSX séparé et conservez ses propriétés modifiables sur ce nœud. Cela s'applique à <Composition>, <Still>, les composants média intégrés, <Sequence>, <Series.Sequence>, <TransitionSeries.Sequence> et les composants personnalisés.

Par exemple, créez une timeline modifiable comme ceci :

<Series>
  <Series.Sequence name="Introduction" durationInFrames={90}>
    <Introduction />
  </Series.Sequence>
  <Series.Sequence name="Démo" durationInFrames={150}>
    <Demo />
  </Series.Sequence>
</Series>

Un .map() ou une autre boucle programmatique créerait plusieurs éléments d'exécution à partir d'un seul nœud source JSX. Cela est approprié pour une sortie répétée qui est intentionnellement contrôlée comme un modèle unique, comme des barres de visualisation ou des particules. Ce n'est pas approprié lorsque les instances ont besoin d'IDs ou de noms, propriétés, métadonnées, timing, ordre, suppression ou duplication indépendants dans le Studio.

Rendre un élément HTML interactif en utilisant Interactive

Chaque élément HTML et SVG (sauf <Img>, il est déjà interactif) comme <div> peut être rendu interactif en utilisant Interactive :

<Interactive.Div
  name="Carte de vœux"
  style={{fontSize: 80, padding: 24}}
>
  Bonjour
</Interactive.Div>

Cela permet de définir les styles et les images clés dans le Studio. Soyez raisonnables, si un composant a de nombreux éléments, la timeline pourrait devenir désordonnée.

Préférer le texte en ligne

Si le texte est fixe et utilisé une seule fois, écrivez-le directement à l'intérieur de l'élément interactif au lieu de l'extraire dans une constante.

// 👍 La copie fixe reste modifiable
<Interactive.Div name="Titre">
  Bonnes pratiques Remotion
</Interactive.Div>

Utilisez une propriété ou une variable uniquement lorsque le texte est dynamique ou réutilisé.

Donner aux éléments interactifs un nom descriptif

Ajoutez une propriété name aux éléments pour les rendre facilement identifiables. Évitez les noms calculés, codez-les en dur.

<>
  <Interactive.Div name="Titre héros" style={{fontSize: 80}}>
    Jour de lancement
  </Interactive.Div>
  <Img name="Avatar" src="https://remotion.media/image.jpeg" />
  <Video name="Arrière-plan" src="https://remotion.media/video.mp4" />
  <Interactive.Div name="Titre">
    Jour de lancement
  </Interactive.Div>
</>

Garder tous les styles CSS en ligne

La meilleure façon est de simplement passer un objet simple à style - pas de référence à des constantes, pas de décomposition d'objets, pas de calculs.

<Interactive.Div
  style={{
    fontSize: 80,
    color: 'red',
  }}
>
  Bonjour le monde !
</Interactive.Div>
const baseStyle = useMemo(() => {
  return {
    fontSize: 12 // ❌ Les styles non en ligne ne sont pas pris en charge
  }
}, []);

<Interactive.Div
  style={{
    ...baseStyle, // ❌ La décomposition n'est pas prise en charge
    color: ROUGE, // ❌ La référence à des constantes n'est pas prise en charge
    scale: frame * 10 // ❌ Les calculs ne sont pas pris en charge
  }}
>
  Bonjour le monde !
</Interactive.Div>

Animer en utilisant interpolate()

Écrivez les animations sous forme d'appels interpolate() en ligne sur la propriété qui change. La plage de sortie, l'easing, l'extrapolation et la propriété output doivent utiliser des valeurs codées en dur.

La plage d'entrée peut également utiliser durationInFrames, fps, width et height déstructurés directement depuis useVideoConfig(). Les identifiants simples comme durationInFrames, la multiplication par un nombre comme 2 * fps ou fps * 2, et la soustraction d'un nombre comme durationInFrames - 1 sont pris en charge.

const {fps, durationInFrames} = useVideoConfig();

// 👍 Les valeurs en ligne peuvent être normalisées et animées par images clés
<Interactive.Div
  name="Carte produit"
  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]); // ❌ Les calculs doivent être directement dans le balisage

<Interactive.Div
  name="Carte produit"
  style={{
    translate: translateY, // ❌ Seuls les appels interpolate() en ligne sont pris en charge
    rotate: interpolate(frame, [start, start + 10], [0, Math.PI]), // ❌ Impossible d'utiliser des calculs avec des variables arbitraires, impossible d'utiliser des constantes
    scale: interpolate(touteVariable, [0, 30], [0, 1]) // ❌ Peut seulement interpréter la variable `frame`.
  }}
/>

Garder les chemins SVG

…

[version tronquée pour la traduction]

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.

Skills associés