{"id":821,"date":"2026-11-04T18:33:44","date_gmt":"2026-11-04T21:33:44","guid":{"rendered":"https:\/\/yellowkode.com\/blog\/css-moderno-complica-container-queries-has-cascade\/"},"modified":"2026-11-04T18:33:44","modified_gmt":"2026-11-04T21:33:44","slug":"css-moderno-complica-container-queries-has-cascade","status":"publish","type":"post","link":"https:\/\/yellowkode.com\/blog\/css-moderno-complica-container-queries-has-cascade\/","title":{"rendered":"Quando CSS moderno complica mais do que simplifica: container queries, :has() e cascade"},"content":{"rendered":"<p>Em 3 de novembro de 2026, a Smashing Magazine publicou um artigo do Gabriel Shoyombo chamado <em>Modern CSS Might Make Your Front-End More Complex<\/em>. A tese \u00e9 direta: trocar JavaScript por CSS moderno pode reduzir o tamanho do diff e ao mesmo tempo aumentar o n\u00famero de intera\u00e7\u00f5es que voc\u00ea precisa entender para mexer no sistema sem quebrar nada. O artigo trabalha quatro cen\u00e1rios concretos (container queries convivendo com ResizeObserver, <code>container-type<\/code> alterando layout do entorno, <code>:has()<\/code> vazando especificidade, e custo de rec\u00e1lculo em listas grandes) e \u00e9 sobre esses quatro mecanismos que eu quero escrever aqui.<\/p>\n<h2>O fato e por que ele importa<\/h2>\n<p>A tese do artigo n\u00e3o \u00e9 que CSS moderno \u00e9 ruim. \u00c9 que um feature de CSS pode simplificar um arquivo e complicar a aplica\u00e7\u00e3o inteira quando voc\u00ea n\u00e3o entende como ele conversa com o que j\u00e1 existia. Em interface, isso tem um nome espec\u00edfico: simplicidade local contra complexidade de sistema. O diff do pull request s\u00f3 mostra a primeira. A segunda s\u00f3 aparece em produ\u00e7\u00e3o, quando algu\u00e9m move o breakpoint e descobre que existia um segundo dono daquele comportamento.<\/p>\n<h2>Como funciona cada um dos quatro mecanismos<\/h2>\n<h3>1. Container query e o ResizeObserver que ningu\u00e9m apagou<\/h3>\n<p>Container queries nasceram para resolver um problema real: estilizar um componente com base no tamanho dele mesmo, n\u00e3o da viewport. Voc\u00ea declara <code>container-type: inline-size<\/code> no elemento pai e usa <code>@container (width > 480px)<\/code> nos filhos. Container size queries aplicam estilos com base nas dimens\u00f5es do container, e para usar isso voc\u00ea precisa declarar um contexto de conten\u00e7\u00e3o com container-type com valor size, inline-size ou normal.<\/p>\n<p>O c\u00f3digo substituto t\u00edpico \u00e9 um <code>ResizeObserver<\/code> que observa o elemento e alterna uma classe. O problema n\u00e3o \u00e9 a substitui\u00e7\u00e3o em si. O problema \u00e9 que o <code>ResizeObserver<\/code> normalmente vive em outro arquivo, e um seletor como <code>.card--wide .card__title<\/code> vive em um terceiro. Quando o PR adiciona a regra <code>@container<\/code> e remove s\u00f3 a regra do body, o observer continua rodando e a regra do t\u00edtulo continua respondendo ao valor antigo. O componente passa a ter dois donos para o mesmo estado, e o sistema n\u00e3o tem como te avisar disso.<\/p>\n<h3>2. container-type carrega mais do que voc\u00ea pediu<\/h3>\n<p>Quando voc\u00ea escreve <code>container-type: inline-size<\/code>, o navegador n\u00e3o s\u00f3 habilita a consulta de tamanho. Ele aplica conten\u00e7\u00e3o de layout, estilo e inline-size ao elemento. Isso tem tr\u00eas consequ\u00eancias que n\u00e3o t\u00eam nada a ver com a query:<\/p>\n<ul>\n<li>O elemento estabelece um novo block formatting context, ent\u00e3o margens de filhos n\u00e3o colapsam mais atrav\u00e9s dele.<\/li>\n<li>Floats externos deixam de atravessar o elemento, e floats internos ficam contidos.<\/li>\n<li>O inline-size do elemento deixa de depender diretamente do conte\u00fado dele.<\/li>\n<\/ul>\n<p>Esse terceiro ponto \u00e9 o que faz cards sumirem. Se o elemento tirava a largura do pr\u00f3prio conte\u00fado (porque era <code>inline-block<\/code>, <code>width: fit-content<\/code>, item de flex sem crescer, etc.), ao aplicar <code>container-type: inline-size<\/code> 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.<\/p>\n<h3>3. :has() e nesting pegam peso emprestado<\/h3>\n<p><code>:is()<\/code>, <code>:has()<\/code> e <code>:not()<\/code> n\u00e3o s\u00e3o contados como pseudo-classes no c\u00e1lculo de especificidade. Eles mesmos n\u00e3o adicionam peso. Mas os seletores passados como par\u00e2metro entram no c\u00e1lculo: o peso \u00e9 o do argumento mais espec\u00edfico.<\/p>\n<p>Em pr\u00e1tica: <code>.card:has(img) p<\/code> tem especificidade 0-1-2, porque <code>:has(img)<\/code> conta como o <code>img<\/code> de dentro mais o <code>.card<\/code> por fora, e a\u00ed vem o <code>p<\/code>. Um <code>.comment p<\/code> tem 0-1-1 e perde. Pior: a regra do card atinge qualquer par\u00e1grafo descendente de qualquer card que tenha qualquer imagem em qualquer lugar da \u00e1rvore. Se um usu\u00e1rio posta um coment\u00e1rio com avatar, o card inteiro em volta perde margem.<\/p>\n<p>Nesting nativo tem o mesmo comportamento. A especificidade do seletor de aninhamento &#038; \u00e9 calculada usando a maior especificidade da lista de seletores associada, id\u00eantico a como funciona com <code>:is()<\/code>. Se voc\u00ea aninhar dentro de <code>.card, #featured<\/code>, qualquer regra l\u00e1 dentro passa a pesar como se tivesse um ID, mesmo que o <code>#featured<\/code> nunca apare\u00e7a perto do elemento.<\/p>\n<p>O escape \u00e9 <code>:where()<\/code>, que sempre contribui com 0-0-0 para a especificidade. Voc\u00ea mant\u00e9m a lista de seletores e joga o peso fora.<\/p>\n<h3>4. Cascade layers s\u00f3 resolvem quando os dois lados est\u00e3o em layer<\/h3>\n<p>Uma regra em <code>@layer components<\/code> com especificidade 0-4-0 perde para uma regra sem layer com <code>.title<\/code> (0-1-0). A raz\u00e3o \u00e9 cascade order, n\u00e3o especificidade. Declara\u00e7\u00f5es normais fora de qualquer layer t\u00eam preced\u00eancia sobre declara\u00e7\u00f5es normais em layer. Ou seja: enquanto voc\u00ea tiver CSS legado sem layer, o CSS legado ganha de qualquer coisa que voc\u00ea empacotar dentro de <code>@layer<\/code>, independentemente de como voc\u00ea escreve a regra nova.<\/p>\n<h2>O que isso significa na pr\u00e1tica<\/h2>\n<p>O caso mais perigoso dos quatro \u00e9 o <code>:has()<\/code> porque parece inocente no code review. Veja o exemplo:<\/p>\n<pre><code>&lt;article class=\"card\"&gt;\n &lt;p&gt;Corpo do card.&lt;\/p&gt;\n &lt;div class=\"comment\"&gt;\n &lt;img src=\"avatar.png\" alt=\"\"&gt;\n &lt;p&gt;Coment\u00e1rio.&lt;\/p&gt;\n &lt;\/div&gt;\n&lt;\/article&gt;\n\n&lt;style&gt;\n\/* Inten\u00e7\u00e3o: zerar margem do corpo quando o card tem imagem hero *\/\n.card:has(img) p { margin: 0; }\n\n\/* Componente de coment\u00e1rio, em outro arquivo *\/\n.comment p { margin-block: 8px; }\n&lt;\/style&gt;<\/code><\/pre>\n<p>O que acontece: o par\u00e1grafo do coment\u00e1rio perde a margem, porque o <code>img<\/code> do avatar satisfaz o <code>:has(img)<\/code>, e porque 0-1-2 vence 0-1-1. O conserto \u00e9 restringir onde a regra olha:<\/p>\n<pre><code>\/* S\u00f3 imagem filha direta do card, s\u00f3 par\u00e1grafo filho direto do card *\/\n.card:has(&gt; img) &gt; p { margin: 0; }<\/code><\/pre>\n<p>O combinator <code>&gt;<\/code> faz duas coisas ao mesmo tempo: impede que o <code>:has()<\/code> encontre uma imagem profunda dentro de outro componente, e impede que o <code>p<\/code> final case com par\u00e1grafos que n\u00e3o s\u00e3o imediatamente do card. \u00c9 literalmente a diferen\u00e7a entre uma regra que fala o idioma do componente e uma regra que grita pela \u00e1rvore inteira.<\/p>\n<p>O segundo exemplo pr\u00e1tico \u00e9 container-type num card dentro de um flex row. Antes:<\/p>\n<pre><code>.toolbar { display: flex; gap: 8px; }\n.tag-card { padding: 4px 8px; background: #eee; }<\/code><\/pre>\n<p>Depois, com a inten\u00e7\u00e3o de habilitar container query interna:<\/p>\n<pre><code>.tag-card {\n padding: 4px 8px;\n background: #eee;\n container-type: inline-size; \/* card some *\/\n}<\/code><\/pre>\n<p>O card vira 0px de largura. A corre\u00e7\u00e3o \u00e9 empurrar o <code>container-type<\/code> para um wrapper que j\u00e1 tem largura pr\u00f3pria, ou dar largura expl\u00edcita ao card. \u00c9 aqui que entra a tese que eu uso em quase tudo que escrevo sobre interface: sistema bom declara onde ele para. <code>container-type<\/code> declara mal: o nome s\u00f3 fala do que ele habilita, n\u00e3o do que ele desliga.<\/p>\n<p>Ali\u00e1s, em design system e style guide de interface, isto \u00e9 exatamente o tipo de armadilha que precisa virar regra documentada: onde <code>container-type<\/code> pode ser aplicado, em qual n\u00edvel do componente, e com qual fallback de largura. Sem isso, o componente funciona isolado no Storybook e some no dashboard.<\/p>\n<h2>Onde quebra<\/h2>\n<p><strong>Performance de :has() em DOM grande.<\/strong> Certos usos de <code>:has()<\/code> podem impactar performance da p\u00e1gina significativamente durante atualiza\u00e7\u00f5es din\u00e2micas do DOM. Ancorar <code>:has()<\/code> a seletores muito gerais degrada performance porque qualquer mudan\u00e7a no DOM dentro da sub\u00e1rvore inteira do elemento selecionado faz o navegador precisar reavaliar a condi\u00e7\u00e3o. A recomenda\u00e7\u00e3o oficial \u00e9 ancorar em elementos espec\u00edficos como .container ou .gallery para reduzir o escopo, e usar combinadores de filho ou irm\u00e3o para limitar o escopo do seletor interno.<\/p>\n<p>O benchmark do artigo original mostrou algo mais perturbador: duas regras <code>:has()<\/code> que s\u00e3o baratas sozinhas podem custar caro quando convivem na mesma folha de estilo. No teste dele, uma \u00fanica mudan\u00e7a de classe em uma linha disparou restyle em 5.001 elementos, levando cerca de 7ms. Eu n\u00e3o reproduzi esse teste aqui e n\u00e3o sei dizer se o comportamento \u00e9 espec\u00edfico de Chrome 153 no macOS ou se \u00e9 padr\u00e3o. O autor registrou isso como issue no Chromium, ent\u00e3o trate como observa\u00e7\u00e3o de um navegador e um ambiente, n\u00e3o como regra geral.<\/p>\n<p><strong>Layers pela metade.<\/strong> Introduzir <code>@layer<\/code> num codebase antigo sem migrar o legado para dentro de alguma layer n\u00e3o resolve conflito, s\u00f3 adiciona uma camada mental de ordena\u00e7\u00e3o. Se voc\u00ea n\u00e3o consegue converter o legado inteiro de uma vez, documente qual peda\u00e7o j\u00e1 est\u00e1 em layer e qual n\u00e3o est\u00e1. Sen\u00e3o voc\u00ea vai gastar duas horas descobrindo que a regra nova perdeu para uma regra sem layer e com menos especificidade.<\/p>\n<p><strong>Migra\u00e7\u00e3o parcial \u00e9 o padr\u00e3o, n\u00e3o a exce\u00e7\u00e3o.<\/strong> O cen\u00e1rio realista n\u00e3o \u00e9 trocar <code>ResizeObserver<\/code> por container query num PR limpo. \u00c9 um PR que adiciona <code>@container<\/code>, remove uma regra, esquece outra e n\u00e3o encontra o observer que vive em outro arquivo. A regra pr\u00e1tica \u00e9 mapear antes de migrar: quantos lugares leem esse estado, quantos lugares escrevem, quais seletores mencionam a classe antiga. Se n\u00e3o fizer isso, voc\u00ea tem dois donos para um comportamento.<\/p>\n<h2>O que n\u00e3o d\u00e1 para afirmar ainda<\/h2>\n<p>Os n\u00fameros de performance do benchmark do artigo original s\u00e3o de uma m\u00e1quina, um navegador (Chrome 153) e um sistema operacional. N\u00e3o d\u00e1 para generalizar para Firefox, Safari, mobile ou m\u00e1quinas mais lentas. O pr\u00f3prio autor diz que n\u00e3o testou outros browsers e registrou o comportamento espec\u00edfico como issue no Chromium.<\/p>\n<p>Tamb\u00e9m n\u00e3o d\u00e1 para dizer que CSS moderno piora sistemas em m\u00e9dia. O que d\u00e1 para dizer \u00e9 que cada um desses quatro mecanismos tem um comportamento colateral documentado na spec ou na MDN que n\u00e3o est\u00e1 no nome da propriedade. Se voc\u00ea usa sem ler a documenta\u00e7\u00e3o, voc\u00ea descobre por bug report.<\/p>\n<h2>Como testar isso voc\u00ea mesmo<\/h2>\n<p>Um teste de 10 minutos que ensina mais que ler qualquer artigo:<\/p>\n<ol>\n<li>Fa\u00e7a um HTML com um card dentro de um flex row com <code>gap<\/code>, e tr\u00eas outros cards ao lado. O card tem um <code>&lt;p&gt;<\/code> interno e um <code>&lt;img&gt;<\/code> em um descendente.<\/li>\n<li>Me\u00e7a a largura do card no DevTools.<\/li>\n<li>Adicione <code>container-type: inline-size<\/code> ao card. Me\u00e7a de novo. Veja se colapsou para 0.<\/li>\n<li>Agora adicione uma regra <code>.card:has(img) p { margin: 0 }<\/code> e verifique no painel Styles do DevTools quais par\u00e1grafos a regra est\u00e1 atingindo. Deve atingir at\u00e9 os par\u00e1grafos de componentes aninhados que voc\u00ea n\u00e3o esperava.<\/li>\n<li>Troque por <code>.card:has(&gt; img) &gt; p<\/code> e observe o escopo encolher.<\/li>\n<li>Coloque a regra dentro de <code>@layer components<\/code> e crie uma outra regra fora de qualquer layer com especificidade menor. Veja a regra fora da layer vencer.<\/li>\n<\/ol>\n<p>Esses seis passos cobrem tr\u00eas dos quatro cen\u00e1rios 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 <em>CSS selector stats<\/em> habilitado nas configura\u00e7\u00f5es. Se voc\u00ea for medir, me\u00e7a antes e depois da mudan\u00e7a, n\u00e3o s\u00f3 depois. O custo real de uma intera\u00e7\u00e3o s\u00f3 aparece quando voc\u00ea tem com o que comparar.<\/p>\n<p>Fonte original: Gabriel Shoyombo, <em>Modern CSS Might Make Your Front-End More Complex<\/em>, Smashing Magazine, 3 de novembro de 2026.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Como container-type, :has() e nesting simplificam um arquivo e complicam o sistema. Mecanismo, exemplos de c\u00f3digo e onde cada um quebra.<\/p>\n","protected":false},"author":2,"featured_media":820,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-821","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/posts\/821","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/comments?post=821"}],"version-history":[{"count":0,"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/posts\/821\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/media\/820"}],"wp:attachment":[{"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/media?parent=821"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/categories?post=821"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/yellowkode.com\/blog\/wp-json\/wp\/v2\/tags?post=821"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}