Communitygithub.com

bardu-rgb/reels

Structurez le balisage Remotion pour le rendre interactif

Qu'est-ce que reels ?

Cette compétence permet de structurer le balisage Remotion de manière à ce que le Studio Remotion puisse reconnaître la structure du code et le rendre interactif. Elle permet de sélectionner des éléments en cliquant dessus, de les faire glisser, de les redimensionner, de les faire pivoter, d'éditer les styles CSS et de modifier les images clés et les courbes d'easing. Le balisage doit être écrit d'une manière spécifique pour garantir cette interactivité ; si le balisage est trop complexe, les valeurs deviennent grisées dans le Studio. La compétence fournit des directives pour utiliser `Interactive.withSchema()` afin de créer des composants réutilisables avec leurs propres chronologies, de choisir des champs de schéma pour exposer les propriétés éditables, et d'enregistrer des compositions connectées. Elle couvre également les bonnes pratiques pour l'édition en ligne des styles, l'utilisation de `interpolate()` pour les animations et la création d'éléments interactifs avec des noms descriptifs.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/bardu-rgb/reels/tree/HEAD/.agents/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

reels 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 :

  • Permet de sélectionner des éléments en cliquant dessus
  • Permet le glisser-déposer, le redimensionnement et la rotation
  • Édition des 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.

Privilégier les composants interactifs avec leurs propres chronologies

Utilisez Interactive.withSchema({wrapInSequence: true}) pour les scènes, cartes, titres personnalisés 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,
});

Transmettre le style injecté à l'intérieur du composant est obligatoire ; gardez les styles modifiables en ligne sur le site 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 éditer sur le site 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 et plusNon
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 [x, y] normalisé sur l'élémentOui
svg-pathDonnées de chemin SVGOui
remotion-captionsDonnées Caption[]Non
hiddenUne valeur conservée hors des contrôles—

Chaque champ a besoin d'une valeur default et doit 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, étalez 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 les légendes. 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 animation en tant que compositions autonomes. Le Studio appelle ces compositions connectées : elles peuvent être ouvertes dans leur propre chronologie tout en partageant la même implémentation de composant avec la vidéo parente.

Définissez les styles requis et chargez les polices à l'intérieur du composant pour qu'il fonctionne sans son parent. Voir l'indépendance du parent.

Enregistrez la même référence de composant exportée que celle rendue par le parent. 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, Product Designer',
      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 compositions connectées pour les détails d'enregistrement et d'extraction.

Placer 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="Lower third"
  from={30}
  durationInFrames={90}
  accentColor="#0b84f3"
>
  Jane Doe, Product Designer
</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 remplacez 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 sur le site 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, remplace les dimensions pour useVideoConfig(), ou enveloppe un composant qui ne gère pas le timing. Conservez <Series.Sequence> pour la disposition consécutive et <TransitionSeries.Sequence> pour les transitions ; les propriétés from directes ne remplacent pas ces comportements.

Donner à chaque élément modifiable indépendant 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 seule cible d'édition source.

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 chronologie modifiable comme ceci :

<Series>
  <Series.Sequence name="Introduction" durationInFrames={90}>
    <Introduction />
  </Series.Sequence>
  <Series.Sequence name="Demo" 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. C'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'ID ou de noms, de propriétés, de métadonnées, de timing, d'ordre, de suppression ou de duplication indépendants dans le Studio.

Rendre un élément HTML interactif à l'aide d'Interactive

Tous les éléments HTML et SVG (sauf <Img>, qui est déjà interactif) comme <div> peuvent être rendus interactifs à l'aide d'Interactive :

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

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

Privilégier 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">
  Meilleures 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 du 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 du lancement
  </Interactive.Div>
</>

Garder tous les styles CSS en ligne

La meilleure façon est de simplement passer un objet simple à style - sans référence à des constantes, sans étalement d'objets, sans mathématiques.

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

<Interactive.Div
  style={{
    ...baseStyle, // ❌ L'étalement n'est pas pris en charge
    color: RED, // ❌ La référence à des constantes n'est pas prise en charge
    scale: frame * 10 // ❌ Les mathématiques ne sont pas prises en charge
  }}
>
  Hello World!
</Interactive.Div>

Animer à l'aide d'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 à partir de useVideoConfig(). Les identifiants simples tels que durationInFrames, la multiplication par un nombre tel que 2 * fps ou fps * 2, et la soustraction d'un nombre tel que durationInFrames - 1 sont pris en charge.

const {fps, durationInFrames} = useVideoConfig();

// 👍 Les valeurs en ligne peuvent être standardisées et imagées
<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 mathématiques 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 mathématiques avec des variables arbitraires, impossible d'utiliser des constantes
    scale
  }}
/>

Utiliser la mise en page Remotion

Utilisez @remotion/layout-utils pour les compositions de mise en page cohérentes. Voir @remotion/layout-utils.

Résumé

  1. Utilisez Interactive.withSchema({wrapInSequence: true}) pour les composants avec des propriétés modifiables par instance.
  2. Transmettez style et étalez-le sur la racine visuelle.
  3. Choisissez les champs de schéma pour exposer le contenu et l'apparence.
  4. Enregistrez les compositions connectées pour les composants réutilisables.
  5. Placez le timing directement sur le composant, pas dans une <Sequence> séparée.
  6. Donnez à chaque élément modifiable indépendant son propre nœud JSX.
  7. Utilisez Interactive.Div pour les éléments HTML.
  8. Gardez les styles en ligne.
  9. Utilisez interpolate() pour les animations.

Individual skills in this repo

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

Skills associés