Communitygithub.com

FrontLaxWeb

Design parallax scrolling, interactive micro-interactions, and premium gestures for landing pages and websites, in both React (Motion + Lenis) and vanilla HTML/CSS/JS (GSAP + Lenis).

O que é FrontLaxWeb?

FrontLaxWeb é um skill de agente de IA especializado em criar experiências web interativas e premium, focando em parallax, scroll interativo, micro-interações e gestos avançados. Ele funciona tanto com React (Motion + Lenis) quanto com HTML/CSS/JS puro (GSAP + Lenis), e é ideal para aprimorar hero sections, efeitos de scroll, reveals ao entrar no viewport, sticky/stacking cards, smooth scroll, tilt 3D, drag-and-drop com springs, menus e modais interrompíveis. O principal diferencial do skill é sua política de movimento inclusiva: as animações são mostradas para todos os visitantes, ajustando a amplitude do movimento (via variável CSS `--motion-gain`) em vez de desligá-lo completamente, mesmo para usuários com `prefers-reduced-motion: reduce` ou que solicitem `?motion=off`. Isso garante acessibilidade e performance, com um modo leve integrado que desativa efeitos pesados (Lenis, desfoques, 3D) em máquinas sem placa de vídeo, mantendo a experiência suave e interativa.

Funciona com✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/Mun1to/FrontLaxWeb/tree/main

Perguntar na sua IA favorita

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

Documentação

FrontLaxWeb: parallax e scroll interativo premium

Este arquivo é o "cérebro": o método. As receitas e snippets estão em plantillas/ e são lidos sob demanda. As rotas plantillas/, references/, Designs/ e Components/ são relativas à pasta deste arquivo.

O que este skill alcança

Converter uma landing comum em uma web-experiência: o scroll e o ponteiro se tornam o controle de uma animação contínua. Agnóstico de marca: recebe as cores/tokens de cada projeto.

Os 7 efeitos (o catálogo)

  1. Smooth scroll (alicerce): Lenis. Base para tudo parecer premium.
  2. Parallax de camadas: fundos lentos / frente rápida = profundidade.
  3. Animação ligada ao scroll: propriedades atreladas à % de scroll.
  4. Scroll-reveal: entrar/animação ao aparecer no viewport.
  5. Sticky / pin: algo "gruda" enquanto o resto muda (stacking cards).
  6. Micro-interações de ponteiro: tilt 3D, cursor personalizado, hover.
  7. Gestos com springs: arrastar, soltar, tap: física de mola interrompível em vez de transições CSS de duração fixa. Veja seção própria abaixo.

Gestos e springs (fundido do skill apple-design de Emil Kowalski, destilado da WWDC)

Terreno DIFERENTE do scroll/parallax acima: é a física de tocar e arrastar algo (um menu, um cartão deslizável, um modal, um slider). Os princípios mais acionáveis para web (dos 17 originais; o resumo está em references/recetas-y-matriz.md §4bis):

  • Interrompibilidade, o mais importante dos 17: qualquer animação deve poder ser agarrada e redirecionada no meio da transição. Para tudo que o usuário possa TOCAR, usar springs (parâmetros: damping + response/velocidade), nunca transition CSS de duração fixa: um spring sempre sabe animar a partir da sua posição ATUAL, uma transição fixa não.
  • Transferência de velocidade: ao soltar um gesto, a animação continua na velocidade do dedo (não começa do zero), evitando a "costura" visual. No Motion: dragMomentum + velocidade do PanInfo como velocidade inicial do spring.
  • Rubber-banding: em um limite, resistência progressiva, nunca um batente seco.
  • Consistência espacial: um painel que entra pela direita sai pela direita; ancora a origem (transform-origin) ao elemento que disparou a transição.
  • Materiais e profundidade: camadas translúcidas flutuantes (backdrop-filter: blur()) para hierarquia visual, nunca duas superfícies translúcidas empilhadas diretamente. Sem placa de vídeo, o modo leve remove o desfoque: seu fundo semitransparente precisa ser legível sozinho.
  • Confirmação cruzada (não é uma receita nova): a regra "Frame-Level Smoothness" deles é a MESMA que já tínhamos em Alicerces NÃO negociáveis (só transform/opacity): duas fontes independentes chegam à mesma regra, mais confiança nela.
  • Filosofia de fundo (os 8 fundamentos da Apple): Propósito, Agência, Responsabilidade, Familiaridade, Flexibilidade, Simplicidade, Ofício, Deleite (consequência de acertar os 7 anteriores). É ethos, não uma técnica implementável: use para justificar decisões de design ("isso tem propósito ou é ruído?"), não como checklist técnico.

✅ Tensão resolvida. O princípio #14 da Apple (com prefers-reduced-motion: reduce, substituir o movimento por transições de opacidade) colidia de frente com a política da casa ("tudo para todos", ignorar essa preferência). Uma terceira via venceu: o movimento não é desligado, sua amplitude é reduzida. O princípio 14 não é descartado nem copiado: é incorporado como o caso extremo do mesmo dial (--motion-gain: 0 produz exatamente uma web de apenas transições), então não há duas versões de cada efeito para manter. A mecânica completa está em "Política de Movimento da Casa" (seção própria, abaixo).

Alicerces NÃO negociáveis

  • Desempenho: animar SOMENTE transform e opacity (GPU). Nunca top/left/width/height/margin. Usar will-change com critério, requestAnimationFrame, e evitar layout thrashing.
  • Sem placa de vídeo, modo leve: toda web nasce com detecção de renderização por software e seu modo leve (sem Lenis, sem desfoques ou misturas, 3D com sua versão sem 3D). Seção própria abaixo.
  • Política de Movimento da Casa: OBRIGATÓRIA em todo projeto. Tem seção própria logo abaixo, porque é a regra mais desrespeitada por descuido.

POLÍTICA DE MOVIMENTO DA CASA (OBRIGATÓRIA)

Tudo para todos, com a amplitude certa. Ninguém vê uma web morta. O que muda conforme o visitante NÃO É SE há movimento, mas QUANTO percurso ele tem. Um único dial governa a web inteira: a variável CSS --motion-gain, definida em <html> por um script no <head>.

Situação--motion-gainO que o visitante vê
Padrão1A experiência completa.
Sistema com prefers-reduced-motion: reduce0.25O mesmo design com um quarto do percurso: o movimento é lido como acento, não como câmera.
URL com ?motion=off0Tudo que se movia sozinho fica parado, e a classe motion é removida. O que o visitante arrasta com o dedo continua respondendo: um cartão deslizável que não desliza não é uma interface sóbria, é uma foto quebrada. É a válvula para quem não quer movimento, não um modo de design.
URL com ?motion=full1 forçadoIgnora a preferência do sistema. Para revisar o trabalho de um computador com os efeitos de animação do Windows desativados.

0.25 é o valor da casa, ajustável por projeto se o efeito pedir, mas nunca 1: se com reduce nada muda, você não está aplicando a política.

As três regras do dial

  1. gain multiplica o percurso: pixels, escala, rotação, skew. Em efeitos contínuos (marquee, loops) multiplica a velocidade.
  2. gain nunca multiplica a opacidade. Uma transição não enjôa ninguém. Por isso, ao abaixar o dial, um efeito não quebra: degrada. A matriosca com gain: 0.25 continua contando a mesma história, mas na forma de uma transição encadeada em vez de um zoom de câmera. E é por isso que esta política não obriga a escrever uma segunda versão de cada efeito, que é exatamente o que o princípio 14 custava.
  3. gain não escala o movimento direcionado pelo usuário: arrastar, hover, tilt com o ponteiro, cursor lerp, springs de gesto. O sistema vestibular não protesta pelo que a pessoa mesma provoca. Escala apenas o movimento não solicitado: parallax, zoom ao scroll, matriosca, scrubbing de sequência, horizontal, velocity skew, marquee.

E sempre, além disso 4. Válvula visível. Além de ?motion=off, um controle acessível na interface (basta no rodapé). Uma válvula que existe apenas na URL não é encontrada por quem precisa. 5. Foco de teclado e âncoras intactos, e conteúdo legível sem JS (progressive enhancement).

Acessibilidade, com rigor (verificado contra WCAG, MDN e web.dev, 2026-08-19):

  • O que torna esta política CONFORME não é o dial, é a válvula. WCAG 2.3.3 (nível AAA) exige poder DESATIVAR o movimento, não apenas reduzi-lo; ?motion=off é esse mecanismo, e por isso é obrigatório e descobrível. Um dial que apenas encolhe, sem desligamento real, não cumpriria a letra de 2.3.3.
  • 0.25 sob reduce é um PONTO DE PARTIDA, não um absoluto. O que enjôa é o movimento de grande amplitude (parallax, zoom, translação de grande superfície), não a opacidade nem o deslocamento pequeno. Regra fina: sob reduce, esse movimento grande deve ser levado a ~zero ou substituído por uma transição, não deixado "menor, mas presente". Para um reveal de 16 px, 0.25 é suficiente; para um parallax de 300 px, 0.25 ainda enjôa e é preciso ir mais abaixo ou direto para opacidade. É exatamente o que respaldam MDN e web.dev: "remove, reduce OR replace".
  • WCAG 2.2.2 "Pause, Stop, Hide" (nível A, OBRIGATÓRIO, não AAA): toda animação automática em loop de mais de 5 s (marquee, vídeo de fundo, gradiente em movimento) DEVE ter um controle de pausa ou stop, e isso o dial NÃO substitui. Se você colocar um marquee infinito, inclua seu botão de pausa separado.

Interruptor central (copiar exatamente no <head>, antes de qualquer CSS de animação):

<script>
(function () {
  var h = document.documentElement;
  var q = new URLSearchParams(location.search).get('motion');
  var reduce = matchMedia('(prefers-reduced-motion: reduce)').matches;
  var gain = q === 'off' ? 0 : q === 'full' ? 1 : reduce ? 0.25 : 1;
  h.style.setProperty('--motion-gain', String(gain));
  h.classList.toggle('motion', gain > 0);   // compatibilidade: os estados animados dependem de html.motion
})();
</script>

No CSS, é usado dentro de calc(); no JS, é lido uma vez e multiplicado:

const GAIN = parseFloat(getComputedStyle(document.documentElement)
  .getPropertyValue('--motion-gain')) || 0;

SEM PLACA DE VÍDEO: O MODO LEVE (de série em toda web nova)

O caso. Em um computador com aceleração de hardware desligada (comum em muitos computadores antigos ou corporativos), três sites com scroll animado travavam e cloudflare.com era fluido. Medido com CPU 6x e sem placa de vídeo, a 1920x1080, contando o que chega à tela:

WebAntesCom o modo levecloudflare.com, igual
SaaS (Lenis, vidro, 3D)1,7 quadros/s, parada de 2,4 s27,5 e 0,13 s42,6 e 47 ms
Portfolio (Lenis, orbes com blur, 3D)4,6 e 372 ms24,8 e 84 ms45,3 e 49 ms
Produto (sem Lenis; nuvens com blur, granulado em overlay, demo de vidro)30,1 e 260 ms42,6 e 74 ms46,5 e 46 ms

Com placa de vídeo, o modo leve não é ativado e nada muda (verificado pixel a pixel nos três).

Por quê. Sem placa de vídeo, o processador faz o que a placa fazia: desfoques, misturas, 3D e composição de cada quadro. E com Lenis, o scroll é movido pelo NOSSO código a cada quadro: se a thread principal está a 5 quadros por segundo, a página se move a 5. O scroll do navegador é movido por outra thread e continua fluido mesmo que a principal esteja ocupada (por isso cloudflare.com funciona bem: seu código está a 2 quadros e sua tela a 86).

1. Detectar (plantillas/react/dibujoPorSoftware.ts, ou plantillas/vanilla/modo-ligero.js): solicitar um contexto com getContext("webgl2"|"webgl", { failIfMajorPerformanceCaveat: true }); null é renderização por software. Se der contexto, soltá-lo imediatamente (WEBGL_lose_context). Uma vez por visita e após o primeiro pintado, nunca antes do LCP. ?ligero=1 força e ?ligero=0 remove; dentro de um <iframe> de mesma origem, verificar também o endereço externo. Em jsdom e no pré-render, assumir que há placa de vídeo.

2. Apenas nesse caso:

  • (a) Não iniciar Lenis: scroll do navegador, e no lugar uma peça nativa com a mesma aparência (scrollTo com smooth, stop/start com overflow: hidden em <html> para menus, on("scroll"), animatedScroll). Isso é feito apenas por plantillas/react/useLenis.ts (e arrancarScroll() em vanilla). Âncoras e menus não têm um if cada um. Não depende de window.lenis: Lenis 1.3 já armazena seus dados lá.
  • (b) <html data-ligero> e o CSS de plantillas/vanilla/modo-ligero.css: backdrop-filter: none; um halo de filter: blur() se torna um radial-gradient que já nasce desfocado (em dobro de tamanho com a propriedade scale, que não interfere no transform do parallax); um mix-blend-mode (o granulado em overlay) se torna mistura normal com menos opacidade. Aparência quase igual e continua se movendo igual.
  • (c) 3D: CADA getContext WebGL da web é solicitado com failIfMajorPerformanceCaveat: true, e assim cai sozinho em sua versão sem 3D, que precisa existir (uma imagem, o logo plano ou, se era adorno de fundo, nada).
  • (d) As animações, NÃO. A política da casa não muda: animações para todos, ajusta-se a amplitude, não se desligam. E está medido: no SaaS da tabela, remover o fundo animado ou pausar as de CSS não mudava nada (de 28 para 29-30 quadros); no produto, as partículas e a luz do feixe, também não. O que pesa é (a), (b) e (c).

3. Medir, não supor (plantillas/medir-scroll-visible.mjs, executado de uma pasta com playwright-core): conta os quadros que chegam à tela com o scroll movido (emissão de tela do Chrome), não os requestAnimationFrame, que com scroll nativo mentem. Duas medições, sempre com cloudflare.com ao lado na mesma leva: SIN_GRAFICA=1 node medir-scroll-visible.mjs <url> 3 6 (um computador sem placa de vídeo) e sem SIN_GRAFICA com CPU 4 (um laptop normal). Chrome sem tela (o do Lighthouse) renderiza COM placa de vídeo: não serve para isso. Para encontrar o culpado, remover coisas uma a uma com CSS injetado (display: none, filter: none, mix-blend-mode: normal) e medir novamente: assim surgiram as nuvens do produto da tabela (de 0,8 s a 0,35 s até o primeiro quadro), seu granulado e sua demo, e assim se viu que seu vidro da capa e suas partículas não pesavam nada.

Desempenho com placa de vídeo: cinco regras para qualquer web com scroll animado

Medidas em duas webs reais (em uma, de 580 a 355 ms de trabalho em quadros lentos a CPU 4x). Nenhuma remove ou desacelera uma animação: removem trabalho que não era visível.

  1. Nada de getAnimations() em um animationend: obriga a recalcular os estilos de toda a página (~50 ms a 4x, frequentemente no meio do scroll). Contar os animationstart e animationend do elemento.
  2. Não pausar ao fazer scroll as animações que só movem transform/opacity: elas vão no compositor e não economizam nada, e pausar e retomar são dois recálculos grandes por cada scroll.
  3. Nada de montar seções "em um tempo livre" enquanto se faz scroll: Lenis deixa lacunas entre quadros e requestIdleCallback cai exatamente ali. Esperar o scroll parar.
  4. Nada de escrever estilos em cada quadro do scroll se não mudarem (--bn: 0 em cada tar...

[...truncado...]

Rascunho rápido (snippet mental para sair do branco)

// Exemplo: hero com parallax e scroll reveal
import { motion, useScroll, useTransform } from "motion/react";
import { useRef } from "react";

export function Hero() {
  const ref = useRef(null);
  const { scrollYProgress } = useScroll({ target: ref, offset: ["start start", "end start"] });
  const y = useTransform(scrollYProgress, [0, 1], ["0%", "50%"]);
  const opacity = useTransform(scrollYProgress, [0, 0.5], [1, 0]);

  return (
    <section ref={ref} className="hero">
      <motion.div style={{ y, opacity }}>
        <h1>Bem-vindo à experiência</h1>
      </motion.div>
    </section>
  );
}

Este skill é um assistente de design e desenvolvimento: ele não substitui o julgamento humano, mas acelera a aplicação de padrões comprovados. Use-o como base e refine com seu próprio toque.

Habilidades Relacionadas