Home / Uncategorized / Quando CSS moderno complica mais do que simplifica: container queries, :has() e cascade

Quando CSS moderno complica mais do que simplifica: container queries, :has() e cascade

Em 3 de novembro de 2026, a Smashing Magazine publicou um artigo do Gabriel Shoyombo chamado Modern CSS Might Make Your Front-End More Complex. A tese é direta: trocar JavaScript por CSS moderno pode reduzir o tamanho do diff e ao mesmo tempo aumentar o número de interações que você precisa entender para mexer no sistema sem quebrar nada. O artigo trabalha quatro cenários concretos (container queries convivendo com ResizeObserver, container-type alterando layout do entorno, :has() vazando especificidade, e custo de recálculo em listas grandes) e é sobre esses quatro mecanismos que eu quero escrever aqui.

O fato e por que ele importa

A tese do artigo não é que CSS moderno é ruim. É que um feature de CSS pode simplificar um arquivo e complicar a aplicação inteira quando você não entende como ele conversa com o que já existia. Em interface, isso tem um nome específico: simplicidade local contra complexidade de sistema. O diff do pull request só mostra a primeira. A segunda só aparece em produção, quando alguém move o breakpoint e descobre que existia um segundo dono daquele comportamento.

Como funciona cada um dos quatro mecanismos

1. Container query e o ResizeObserver que ninguém apagou

Container queries nasceram para resolver um problema real: estilizar um componente com base no tamanho dele mesmo, não da viewport. Você declara container-type: inline-size no elemento pai e usa @container (width > 480px) nos filhos. Container size queries aplicam estilos com base nas dimensões do container, e para usar isso você precisa declarar um contexto de contenção com container-type com valor size, inline-size ou normal.

O código substituto típico é um ResizeObserver que observa o elemento e alterna uma classe. O problema não é a substituição em si. O problema é que o ResizeObserver normalmente vive em outro arquivo, e um seletor como .card--wide .card__title vive em um terceiro. Quando o PR adiciona a regra @container e remove só a regra do body, o observer continua rodando e a regra do título continua respondendo ao valor antigo. O componente passa a ter dois donos para o mesmo estado, e o sistema não tem como te avisar disso.

2. container-type carrega mais do que você pediu

Quando você escreve container-type: inline-size, o navegador não só habilita a consulta de tamanho. Ele aplica contenção de layout, estilo e inline-size ao elemento. Isso tem três consequências que não têm nada a ver com a query:

  • O elemento estabelece um novo block formatting context, então margens de filhos não colapsam mais através dele.
  • Floats externos deixam de atravessar o elemento, e floats internos ficam contidos.
  • O inline-size do elemento deixa de depender diretamente do conteúdo dele.

Esse terceiro ponto é o que faz cards sumirem. Se o elemento tirava a largura do próprio conteúdo (porque era inline-block, width: fit-content, item de flex sem crescer, etc.), ao aplicar container-type: inline-size ele colapsa para 0. A largura do container precisa ser definida explicitamente ou pelo contexto, como blocos que esticam na largura total do pai, containers flex ou grid.

3. :has() e nesting pegam peso emprestado

:is(), :has() e :not() não são contados como pseudo-classes no cálculo de especificidade. Eles mesmos não adicionam peso. Mas os seletores passados como parâmetro entram no cálculo: o peso é o do argumento mais específico.

Em prática: .card:has(img) p tem especificidade 0-1-2, porque :has(img) conta como o img de dentro mais o .card por fora, e aí vem o p. Um .comment p tem 0-1-1 e perde. Pior: a regra do card atinge qualquer parágrafo descendente de qualquer card que tenha qualquer imagem em qualquer lugar da árvore. Se um usuário posta um comentário com avatar, o card inteiro em volta perde margem.

Nesting nativo tem o mesmo comportamento. A especificidade do seletor de aninhamento & é calculada usando a maior especificidade da lista de seletores associada, idêntico a como funciona com :is(). Se você aninhar dentro de .card, #featured, qualquer regra lá dentro passa a pesar como se tivesse um ID, mesmo que o #featured nunca apareça perto do elemento.

O escape é :where(), que sempre contribui com 0-0-0 para a especificidade. Você mantém a lista de seletores e joga o peso fora.

4. Cascade layers só resolvem quando os dois lados estão em layer

Uma regra em @layer components com especificidade 0-4-0 perde para uma regra sem layer com .title (0-1-0). A razão é cascade order, não especificidade. Declarações normais fora de qualquer layer têm precedência sobre declarações normais em layer. Ou seja: enquanto você tiver CSS legado sem layer, o CSS legado ganha de qualquer coisa que você empacotar dentro de @layer, independentemente de como você escreve a regra nova.

O que isso significa na prática

O caso mais perigoso dos quatro é o :has() porque parece inocente no code review. Veja o exemplo:

<article class="card">
 <p>Corpo do card.</p>
 <div class="comment">
 <img src="avatar.png" alt="">
 <p>Comentário.</p>
 </div>
</article>

<style>
/* Intenção: zerar margem do corpo quando o card tem imagem hero */
.card:has(img) p { margin: 0; }

/* Componente de comentário, em outro arquivo */
.comment p { margin-block: 8px; }
</style>

O que acontece: o parágrafo do comentário perde a margem, porque o img do avatar satisfaz o :has(img), e porque 0-1-2 vence 0-1-1. O conserto é restringir onde a regra olha:

/* Só imagem filha direta do card, só parágrafo filho direto do card */
.card:has(> img) > p { margin: 0; }

O combinator > faz duas coisas ao mesmo tempo: impede que o :has() encontre uma imagem profunda dentro de outro componente, e impede que o p final case com parágrafos que não são imediatamente do card. É literalmente a diferença entre uma regra que fala o idioma do componente e uma regra que grita pela árvore inteira.

O segundo exemplo prático é container-type num card dentro de um flex row. Antes:

.toolbar { display: flex; gap: 8px; }
.tag-card { padding: 4px 8px; background: #eee; }

Depois, com a intenção de habilitar container query interna:

.tag-card {
 padding: 4px 8px;
 background: #eee;
 container-type: inline-size; /* card some */
}

O card vira 0px de largura. A correção é empurrar o container-type para um wrapper que já tem largura própria, ou dar largura explícita ao card. É aqui que entra a tese que eu uso em quase tudo que escrevo sobre interface: sistema bom declara onde ele para. container-type declara mal: o nome só fala do que ele habilita, não do que ele desliga.

Aliás, em design system e style guide de interface, isto é exatamente o tipo de armadilha que precisa virar regra documentada: onde container-type pode ser aplicado, em qual nível do componente, e com qual fallback de largura. Sem isso, o componente funciona isolado no Storybook e some no dashboard.

Onde quebra

Performance de :has() em DOM grande. Certos usos de :has() podem impactar performance da página significativamente durante atualizações dinâmicas do DOM. Ancorar :has() a seletores muito gerais degrada performance porque qualquer mudança no DOM dentro da subárvore inteira do elemento selecionado faz o navegador precisar reavaliar a condição. A recomendação oficial é ancorar em elementos específicos como .container ou .gallery para reduzir o escopo, e usar combinadores de filho ou irmão para limitar o escopo do seletor interno.

O benchmark do artigo original mostrou algo mais perturbador: duas regras :has() que são baratas sozinhas podem custar caro quando convivem na mesma folha de estilo. No teste dele, uma única mudança de classe em uma linha disparou restyle em 5.001 elementos, levando cerca de 7ms. Eu não reproduzi esse teste aqui e não sei dizer se o comportamento é específico de Chrome 153 no macOS ou se é padrão. O autor registrou isso como issue no Chromium, então trate como observação de um navegador e um ambiente, não como regra geral.

Layers pela metade. Introduzir @layer num codebase antigo sem migrar o legado para dentro de alguma layer não resolve conflito, só adiciona uma camada mental de ordenação. Se você não consegue converter o legado inteiro de uma vez, documente qual pedaço já está em layer e qual não está. Senão você vai gastar duas horas descobrindo que a regra nova perdeu para uma regra sem layer e com menos especificidade.

Migração parcial é o padrão, não a exceção. O cenário realista não é trocar ResizeObserver por container query num PR limpo. É um PR que adiciona @container, remove uma regra, esquece outra e não encontra o observer que vive em outro arquivo. A regra prática é mapear antes de migrar: quantos lugares leem esse estado, quantos lugares escrevem, quais seletores mencionam a classe antiga. Se não fizer isso, você tem dois donos para um comportamento.

O que não dá para afirmar ainda

Os números de performance do benchmark do artigo original são de uma máquina, um navegador (Chrome 153) e um sistema operacional. Não dá para generalizar para Firefox, Safari, mobile ou máquinas mais lentas. O próprio autor diz que não testou outros browsers e registrou o comportamento específico como issue no Chromium.

Também não dá para dizer que CSS moderno piora sistemas em média. O que dá para dizer é que cada um desses quatro mecanismos tem um comportamento colateral documentado na spec ou na MDN que não está no nome da propriedade. Se você usa sem ler a documentação, você descobre por bug report.

Como testar isso você mesmo

Um teste de 10 minutos que ensina mais que ler qualquer artigo:

  1. Faça um HTML com um card dentro de um flex row com gap, e três outros cards ao lado. O card tem um <p> interno e um <img> em um descendente.
  2. Meça a largura do card no DevTools.
  3. Adicione container-type: inline-size ao card. Meça de novo. Veja se colapsou para 0.
  4. Agora adicione uma regra .card:has(img) p { margin: 0 } e verifique no painel Styles do DevTools quais parágrafos a regra está atingindo. Deve atingir até os parágrafos de componentes aninhados que você não esperava.
  5. Troque por .card:has(> img) > p e observe o escopo encolher.
  6. Coloque a regra dentro de @layer components e crie uma outra regra fora de qualquer layer com especificidade menor. Veja a regra fora da layer vencer.

Esses seis passos cobrem três dos quatro cenários do artigo original. O quarto, o de performance com listas de milhares de linhas, precisa de um fixture maior e de uma trace no painel Performance do Chrome com CSS selector stats habilitado nas configurações. Se você for medir, meça antes e depois da mudança, não só depois. O custo real de uma interação só aparece quando você tem com o que comparar.

Fonte original: Gabriel Shoyombo, Modern CSS Might Make Your Front-End More Complex, Smashing Magazine, 3 de novembro de 2026.

Deixe um Comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *