m/
Все статьи

7 возможностей CSS

7 возможностей CSS, которые убирают !important навсегда (и ещё 8, которые вы возможно пропустили)

У любого продукта, дожившего до шестого года, stylesheet выглядит примерно так:

reset из боилерплейта 2016 года. Дизайн-система. Стили от четырёх команд. Утилиты, за которые никто не отвечает. И page-overrides.css — потому что на странице инвойсов одна кнопка должна быть красной.

Когда мы посмотрели внутрь, там было 14 000 строк и 380 объявлений !important.

Удалить ничего было нельзя: единственный способ узнать, несёт ли правило нагрузку — убрать его и неделю наблюдать за продом.

Хорошая новость: переписывать ничего не нужно. Современный CSS позволяет записать приоритет явно, вместо того чтобы драться за вес селектора.


Главная мысль, которую все пропускают

Каскад сортирует объявления не по специфичности. Он сортирует так:

Происхождение → Важность → Слой → Специфичность → Близость области → Порядок появления

Специфичность — третий критерий, а не первый. Мы годами воевали на третьей позиции, когда инструменты победы — на второй.

Специфичность локальна: прочитали селектор — знаете вес. Слои глобальны: победитель зависит от порядка в начале файла.

Одна строка решает архитектуру всего бандла:

@layer reset, tokens, base, layout, components, utilities, overrides, legacy;

Читайте её как стек от слабого к сильному. Что угодно в legacy побеждает что угодно в components — каким бы монструозным ни был селектор там.

Правило с низкой специфичностью в сильном слое побеждает правило с высокой специфичностью в слабом.


@layer: приоритет как записанное решение

До — четыре команды, четыре копии одного цвета:

.btn--primary { background: #0b5fff; }
.toolbar .btn--primary { background: #0b5fff; }
#app .toolbar .btn--primary { background: #0b5fff; }      /* «чтобы точно сработало» */
.settings .toolbar .btn--primary { background: #0b5fff !important; }

Ни одна не объясняет, что было сломано. Следующий разработчик добавит пятую.

После — одно правило, одно место изменения:

@layer components {
    .btn--primary {
        background: var(--brand-600);
        &:hover { background: var(--brand-700); }
    }
}

Арендатор с другим брендом переопределяет --brand-600 в tokens — и все кнопки следуют за ним. Странице, которой действительно нужно исключение, есть куда идти: слой overrides, объявленный позже.

В ходе миграции счётчик !important упал с 380 до 41. Но важнее другое: вопрос «почему кнопка красная?» теперь укладывается в комментарий на ревью.

Две ловушки:

  • Неслойный CSS побеждает любой слой. Затесавшийся <style> в шаблоне перебьёт весь стек. Начните с аудита неслойных правил.
  • !important переворачивает порядок слоёв: среди важных объявлений выигрывает более ранний слой. Это отдельный каскад внутри каскада.

@import ... layer(): подключаем легаси без правок

Порядок импортов — это архитектура, которая нигде не записана, пока кто-нибудь не поменяет две строки местами и не сломает страницу инвойсов.

Теперь приоритет записан:

@layer reset, tokens, base, layout, components, utilities, overrides, legacy;

@import url("vendor/normalize.css") layer(reset);
@import url("tokens/semantic.css") layer(tokens);
@import url("design-system/index.css") layer(base);
@import url("legacy/app.css") layer(legacy);   // не редактируем, только подключаем
@import url("legacy/pages.css") layer(legacy);

Два импорта в один слой сохраняют относительный порядок. Легаси-файлы не трогаем вообще — записан только их приоритет.

@import блокирует отрисовку (round trips) и некоторые сборщики теряют layer() при разворачивании. Для миграции терпимо, навсегда — нет.


Нативный nesting: компонент без дерева префиксов

Раньше вложенность жила в Sass и терялась при сборке. Структуру держало соглашение об именах — и файл settings-page.css, который никто не удаляет после редизайна настроек.

Теперь правила компонента — один блок:

@layer components {
  .card {
    padding: 20px;
    border: 1px solid var(--border);
    border-radius: 12px;

    & .title { margin-block: 0 8px; font-size: 1.125rem; }
    & .meta { color: var(--ink-500); }
    &:has(.badge--overdue) { border-color: var(--danger-500); }
  }
}

Поиск по .card возвращает компонент вместе с исключениями. Ревью показывает дифф в контексте.

Важно понимать: вложенность — это синтаксис, а не архитектура. & .title внутри .card — всё тот же .card .title с весом 0-2-0. Вложенность «для красоты» оставляет долг по специфичности на месте. Держите глубину 2–3 уровня.


@scope: стили, которые останавливаются на границе

Классическая проблема: панель оформляет свои строки, но не должна трогать строки вложенной таблицы. Раньше — два правила, где второе существует только для отмены первого, и имя страницы в селекторе.

/* После: корень области — .panel, граница — .table */
@layer components {
  @scope (.panel) to (.table) {
    :scope { border: 1px solid var(--border); border-radius: 8px; }
    .row > .cell { padding: 8px 12px; }
  }
}

Правила действуют в любой панели на любой странице и останавливаются на первой вложенной таблице. Правило-отмена исчезает, потому что отменять нечего.

Близость области — слабый критерий каскада: сильнее порядка появления, но слабее специфичности и слоёв. @scope не заставит проиграть #app .panel .cell. Поддержка свежая — используйте как улучшение с запасным вариантом.


:where(): нулевая специфичность как решение

Сброс должен быть полом, а не потолком. Раньше для этого нужен был !important или трюки вида :not(#\9).

@layer base {
  :where(h1, h2, h3, h4) { margin-block: 0; line-height: 1.25; }
  :where(ul, ol) { padding-inline-start: 1.25em; }
}

Вес 0-0-0: любой класс в более позднем слое побеждает сброс. Без единого !important.

Но помните: 0-0-0 проигрывает даже голому селектору типа (:where(ul) перебивается ul). И не заворачивайте в :where() стили :focus-visible — компонент с outline: none молча их снимет.


@supports: один бандл вместо двух

@layer components {
  .invoice-row { border-inline-start: 3px solid transparent; }

  @supports selector(:has(*)) {
    .invoice-row:has(.badge--overdue) {
      border-inline-start-color: var(--danger-600);
    }
  }
}

Базовое правило полноценно само по себе. Улучшение живёт внутри проверки и не может сломать базу. Никакого разбора user-agent.


revert-layer: отмена без !important

@layer overrides {
  .print-sheet .card {
    box-shadow: revert-layer;  /* вернуться к решению components */
    border: revert-layer;
    border-radius: 0;          /* а это — наше осознанное исключение */
  }
}

Переопределение становится вычитающим: «всё, как в дизайн-системе, только не тень». Вместо параллельно поддерживаемой второй копии значений.

Это не unset и не initial:

  • unset — наследовать либо начальное значение
  • initial — значение из спецификации
  • revert-layer — значение из предыдущего слоя. В самом нижнем слое откатится к стилям браузера.

А вот что добавилось сверх этого драфта

:has() — родительский селектор, который все ждали 20 лет

/* форма с ошибкой подсвечивает сама себя */
.field:has(input:invalid) {
  border-color: var(--danger-500);
}

/* карточка меняет раскладку, если в ней нет картинки */
.card:not(:has(img)) { grid-template-columns: 1fr; }

Это не просто удобство. Это меняет модель мышления: раньше состояние ребёнка требовало класса на родителе из JS. Теперь CSS видит дерево целиком.

Container Queries — компонент реагирует на свой контейнер, а не на viewport

Медиазапросы отвечают на вопрос «какой экран?». Компоненту правильный вопрос — «сколько места мне дали?»

.sidebar { container-type: inline-size; }

@container (min-width: 400px) {
  .card { grid-template-columns: 120px 1fr; }
  .card .title { font-size: 1.25rem; }
}

Одна и та же карточка раскладывается горизонтально в широком сайдбаре и вертикально в узкой колонке. Без единого класса-модификатора и без JS.

Scroll-driven Animations — анимации на чистом CSS, без скролл-листенеров

@keyframes reveal {
  from { opacity: 0; transform: translateY(30px); }
  to   { opacity: 1; transform: none; }
}

.section {
  animation: reveal linear both;
  animation-timeline: view();
  animation-range: entry 0% entry 60%;
}

Элемент проявляется по мере входа во вьюпорт — на compositor thread, без jank от JS-скролла. Параллакс, прогресс-бары чтения, sticky-хедеры: всё это раньше было килобайтами JavaScript.

View Transitions — плавные переходы между состояниями страницы

::view-transition-old(root) { animation: fade-out 0.2s ease; }
::view-transition-new(root) { animation: fade-in 0.2s ease; }
document.startViewTransition(() => updateDOM());

Браузер делает снимки состояния «до» и «после» и анимирует между ними. То, для чего раньше нужны были SPA-фреймворки и сложные FLIP-техники — теперь платформа.

Anchor Positioning — поповеры, привязанные к своему якорю

.tooltip {
  position-anchor: --trigger;
  position: absolute;
  bottom: anchor(top);
  left: anchor(center);
  translate: -50% -8px;
}

Тултип сам следует за кнопкой при ресайзе, скролле, изменении зума. Расстояние до границы экрана считается нативно. Прощайте библиотеки позиционирования.

color-mix() и oklch() — цвета, которые можно считать

.btn--primary:hover {
  background: color-mix(in oklch, var(--brand-600) 85%, black);
}

Получить «на 15% темнее» раньше требовало препроцессора или ручного подбора. oklch даёт равномерную шкалу яркости — color-mix на ней ведёт себя предсказуемо, в отличие от старого mix() в sRGB.

text-wrap: balance — заголовки без висячих слов

h2, h3 { text-wrap: balance; }

Браузер подбирает разбиение строк так, чтобы последняя строка не была обидно короткой. То, ради чего верстальщики вставляли &nbsp; вручную.

Subgrid — дочерняя сетка повторяет родительскую

.grid { display: grid; grid-template-columns: 1fr 2fr 1fr; }
.card {
  display: grid;
  grid-template-rows: subgrid;
  grid-row: span 3;
}

Карточки в ряду выравнивают свои внутренние зоны по общим дорожкам. Весь класс хаков с выравниванием однообразных карточек уходит в историю.

Отдельные transform-свойства

.card {
    translate: 0 -4px;
    rotate: 2deg;
    scale: 1.02;
}

Каждое свойство анимируется независимо и не отменяет остальные — в отличие от монолитного transform, где любая анимация перезаписывала всё объявление.


Бонус: как CSS на самом деле решает конфликты

Раз уж мы убираем !important, стоит один раз понять всю цепочку. Для каждого элемента браузер собирает все применимые объявления и сортирует:

1. Происхождение и важность. Авторские стили → пользовательские → агентские. !important меняет порядок на обратный — поэтому это атомная бомба: вы выпрыгиваете из одной системы приоритетов в другую.

2. Слои. Сначала объявленный слой проигрывает. Среди !important — наоборот, выигрывает ранний.

3. Специфичность — считается как тройка (ID, класс/атрибут/псевдокласс, тип/псевдоэлемент). Сравнение лексикографическое: один ID бьёт любое число классов. Отсюда же правило «универсальный селектор и комбинаторы не добавляют вес».

4. Близость области (@scope) — побеждает более локальная область видимости при равном всём вышеперечисленном.

5. Порядок появления — последний в документе побеждает.

Ключевой вывод этой статьи: шаги 1–2 вы решаете архитектурно, один раз. Шаги 3–5 — это та самая война специфичности, в которой современный CSS предлагает больше не воевать.

Наследование — отдельный механизм: если для свойства нет ни одного выигравшего объявления, берётся значение родителя. Отсюда работают кастомные свойства (--brand-600 течёт вниз по дереву) и отсюда же боль: color наследуется, border — нет, а width вообще считается от containing block, а не от родителя.


План миграции, который откатывается

  1. Заморозьте legacy/ — CI падает при изменениях без метки.
  2. Выпустите только инструкцию порядка слоёв. Одна строка. Цель — нулевая визуальная разница. Это делает всё остальное обратимым.
  3. Перенесите reset и base — они и так были слабейшими, понижение незаметно.
  4. Затем tokens — до того, как компоненты начнут ссылаться на переменные.
  5. По одному компоненту на PR, удаляя его правила из legacy в том же PR. Пока удаление не влилось, легаси выигрывает по слою — это страховка, а не баг.
  6. Утилиты — последними.
  7. Замкните цикл: удалите пустой слой, overrides — последний, включите линт против !important.

Прогресс измерим двумя числами, и оба должны только уменьшаться: строки в legacy/ и количество !important.


А вы уже мигрировали на cascade layers? Что остановило или помогло? Расскажите в комментариях — соберу типичные ловушки в отдельный пост.

Репост, если коллегам пора выкинуть !important из кода.

#CSS #Frontend #WebDevelopment #CSSArchitecture #FrontendDevelopment #WebPerf #CodeQuality