🎬

gsap

Baixo Risco ⚡ Contém scripts📁 Acesso ao sistema de arquivos⚙️ Comandos externos

Criar animações GSAP profissionais para vídeo

Escrever animações GSAP para composições de vídeo exige timing preciso e execução determinística. Esta skill fornece documentação completa do GSAP e efeitos prontos para usar em HyperFrames, permitindo criar animações suaves e profissionais sem precisar consultar múltiplas fontes.

Suporta: Claude Codex Code(CC)
🥉 73 Bronze
1

Baixar o ZIP da skill

2

Upload no Claude

Vá em Configurações → Capacidades → Skills → Upload skill

3

Ative e comece a usar

Testar

A utilizar "gsap". Animar elementos .card com efeito stagger, atraso de 0.1s entre cada card, deslizando da esquerda

Resultado esperado:

gsap.from('.card', {
x: -50,
opacity: 0,
stagger: 0.1,
duration: 0.5,
ease: 'power2.out'
});

A utilizar "gsap". Construir uma timeline onde .logo aparece com fade-in primeiro, depois .headline desliza para cima, depois .subtitle aparece com fade-in após o headline completar

Resultado esperado:

const tl = gsap.timeline();
tl.to('.logo', { opacity: 1, duration: 0.4 })
.to('.headline', { y: 0, opacity: 1, duration: 0.5 }, '<')
.to('.subtitle', { opacity: 1, duration: 0.4 }, '+=0.2');

A utilizar "gsap". Digitar 'Welcome' a 12 caracteres por segundo com cursor '|' que pisca entre estados sólido e piscante

Resultado esperado:

const text = 'Welcome';
const cps = 12;
tl.call(() => cursor.classList.replace('cursor-blink', 'cursor-solid'), [], t);
tl.to('#typed', { text: { value: text }, duration: text.length / cps, ease: 'none' }, t);
tl.call(() => cursor.classList.replace('cursor-solid', 'cursor-blink'), [], t + text.length / cps);

Auditoria de Segurança

Baixo Risco
v1 • 4/27/2026

Static analysis flagged 171 potential issues, but evaluation determined all critical and high findings are false positives. The scanner misidentified HTML script tags as shell commands, FFT signal processing as weak cryptography, and generic variable names as credential access patterns. The Python audio extraction script uses subprocess to run ffmpeg for legitimate audio processing. No malicious behavior or user input injection vectors detected.

3
Arquivos analisados
699
Linhas analisadas
8
achados
1
Total de auditorias

Problemas de Alto Risco (2)

Static Analysis False Positive: Weak Cryptographic Algorithm
The static scanner flagged np.fft.rfft() and related operations as 'weak cryptographic algorithm'. This is incorrect - these are standard Fast Fourier Transform operations used for audio signal processing, not cryptography. FFT decomposes audio signals into frequency components for visualization.
Static Analysis False Positive: Credential Access Patterns
The scanner flagged variable names like 'samples', 'SAMPLE_RATE', and file references as 'Windows SAM database' access. This is pattern-matching noise - the skill has no access to Windows credentials. Variables are standard Python naming for audio sample data.
Problemas de Risco Médio (1)
Static Analysis False Positive: Ruby/Shell Command Execution
The static scanner flagged 139 instances of 'Ruby/shell backtick execution' in references/effects.md and SKILL.md. These are false positives - the scanner detected HTML script tags like '<script src="https://...">' and markdown code snippets as shell commands. These are legitimate CDN URL references and documentation code examples.
Problemas de Baixo Risco (2)
Python subprocess.run for FFmpeg
The extract-audio-data.py script uses subprocess.run() to invoke ffmpeg for audio decoding. This is a standard audio processing pattern with no injection risk - the command arguments are hardcoded except for the input path from command-line arguments.
XMLHttpRequest Usage for Audio Data Loading
The audio visualizer effect uses synchronous XMLHttpRequest to load audio data files. This is documented as intentional for HyperFrames deterministic timeline construction. No user-controlled input or security vulnerability.

Fatores de risco

⚡ Contém scripts (1)
📁 Acesso ao sistema de arquivos (1)
⚙️ Comandos externos (1)
Auditado por: claude

Pontuação de qualidade

64
Arquitetura
100
Manutenibilidade
87
Conteúdo
50
Comunidade
61
Segurança
91
Conformidade com especificações

O Que Você Pode Construir

Adicionar animações de entrada a sobreposições de vídeo

Criar animações de entrada com fade-in, slide ou scale para textos sobrepostos e elementos de UI em composições de vídeo.

Construir visualizadores reativos a áudio

Criar visualizadores de áudio baseados em canvas que respondem à música ou fala em planos de fundo de vídeo.

Sequenciar animações complexas de múltiplas etapas

Coordenar múltiplas animações com timing preciso usando timelines, labels e parâmetros de posição do GSAP.

Tente Estes Prompts

Animação tween básica
Use GSAP para animar o elemento #hero aparecendo com fade-in e deslizando para cima 100px. Duração de 0.6s com easing power2.out.
Sequência de timeline
Crie uma timeline GSAP que: 1) aplique fade-in em .title, 2) aplique fade-in em .subtitle 0.2s depois, 3) aplique scale em .button aos 0.5s. Use parâmetros de posição, não delay.
Efeito typewriter
Crie uma animação typewriter para #message que digita a 10 caracteres por segundo com um cursor piscando. O cursor deve piscar quando ocioso.
Frame de visualizador de áudio
Renderize o frame de áudio [FRAME] com barras usando o array AUDIO_DATA.frames[0].bands. Cada banda mapeia para um retângulo do canvas. O grave controla scale, o agudo controla opacity.

Melhores Práticas

  • Use propriedades de transform (x, y, scale, rotation) em vez de propriedades de layout para aceleração por GPU
  • Passe defaults para o construtor da timeline em vez de encadear com delay para melhor legibilidade
  • Armazene os valores de retorno de tween e timeline quando precisar controlar a reprodução programaticamente

Evitar

  • Não anime width, height, top ou left quando transforms podem alcançar o mesmo efeito
  • Não encadeie tweens com delay quando uma timeline com parâmetros de posição os sequencia melhor
  • Não crie tweens direcionados a elementos que ainda não existem no DOM

Perguntas Frequentes

O que é GSAP?
GSAP (GreenSock Animation Platform) é uma biblioteca JavaScript para animações de alta performance. Ela fornece controle preciso sobre timing, easing e sequenciamento que animações CSS não conseguem igualar.
Como criar uma timeline?
Use gsap.timeline() para criar uma timeline, depois encadeie tweens com .to() ou .from(). Tweens são adicionados sequencialmente por padrão, ou use parâmetros de posição como '<' ou '+=0.5' para sobreposição.
O que é o parâmetro de posição?
O terceiro argumento em um tween controla sua colocação na timeline. Use números para tempo absoluto, '+=0.5' para relativo ao fim, '<' para mesmo início que o anterior, ou um nome de label.
Como funcionam os efeitos typewriter?
O GSAP TextPlugin anima o conteúdo de texto caractere por caractere. Defina a duração baseada no comprimento do texto dividido por caracteres por segundo. Gerencie o estado do cursor separadamente com mudanças de classe.
Por que usar XHR síncrono para dados de áudio?
O HyperFrames lê window.__timelines de forma síncrona após o carregamento da página. Carregamento assíncrono de dados significa que a timeline não está pronta quando a captura inicia. Isso é intencional para renderização determinística de vídeo.
Quais formatos de áudio o extract-audio-data.py suporta?
O script usa ffmpeg para decodificação, então suporta qualquer formato de áudio que o ffmpeg manipule: MP3, WAV, AAC, OGG e arquivos de vídeo contendo áudio (MP4, WebM, MOV).

Detalhes do Desenvolvedor

Licença

MIT

Referência

main

Estrutura de arquivos