Show HN: Перенести agent с JavaScript 2019 на веб‑прим
Browsers now natively support CSS.highlights, <dialog> + showModal() and field-sizing, letting you replace 50‑line JS hacks with modern web primitives.
Почему старый JavaScript устарел
Почему старый JavaScript устарел
В 2019 году для создания интерактивных UI‑элементов часто использовались небольшие скрипты:
- ручное добавление
<span>‑ов для выделения текста; - собственные реализации модальных окон на базе
<div>и обработчиков событий.
С появлением нативных веб‑примитивов эти подходы стали избыточными.
CSS.highlights вместо span‑ов
Современный псевдо‑элемент ::highlights (часть спецификации CSS Highlights) позволяет стилизовать выделенный пользователем текст непосредственно в CSS, без необходимости динамически создавать и вставлять <span>‑ы через JavaScript.
Пример старого решения (JavaScript):
jsfunction highlightSelection() {
const sel = window.getSelection();
if (!sel.rangeCount) return;
const range = sel.getRangeAt(0);
const span = document.createElement('span');
span.style.background = 'yellow';
range.surroundContents(span);
}
document.addEventListener('mouseup', highlightSelection);
Новое решение (только CSS):
css/* CSS */
::highlights {
background: #ff0; /* желтый фон выделенного текста */
color: #000; /* сохраняем читаемость */
}
Таким образом, весь код, отвечающий за визуальное оформление выделения, сводится к нескольким строкам в стилях, а JavaScript‑логика полностью устраняется.
Для более детального описания возможности см. Show HN: Modern Web Primitives Replace 2019 JavaScript.
Dialog и showModal() для модальных окон
Раньше для модального диалога писали собственный HTML‑шаблон и управляли им через классы и события. Сейчас в браузерах есть элемент <dialog> и метод showModal(), которые обеспечивают стандартное поведение (затемнение фона, фокус на элементе, закрытие по Esc и т.п.) без написания лишних скриптов.
Пример старого модального окна (JavaScript):
html<div id="modal" class="modal hidden">
<div class="content">…</div>
<button id="close">Close</button>
</div>
jsconst modal = document.getElementById('modal');
const closeBtn = document.getElementById('close');
closeBtn.addEventListener('click', () => {
modal.classList.add('hidden');
});
function openModal() {
modal.classList.remove('hidden');
}
Новое решение (HTML + JS):
html<dialog id="myDialog">
<form method="dialog">
<button type="submit">Close</button>
</form>
</dialog>
jsconst dialog = document.getElementById('myDialog');
// Открываем модальное окно
dialog.showModal();
// При необходимости можно закрыть программно
// dialog.close();
Элемент <dialog> автоматически обрабатывает фокус, закрытие по клавише Esc и отображение полупрозрачного фона. Если поддержка native <dialog> недоступна, полифилл можно подключить, но в большинстве современных браузеров (Chrome, Edge, Firefox) он работает без дополнительного кода.
Поле ввода с правильным размером – ещё одна новинка, позволяющая задавать размеры полей в процентах от ширины/высоты окна (field-sizing: fill;), что упрощает адаптивный дизайн модального окна.
Подробнее о возможности
<dialog>иshowModal()смотрите в соответствующей статье Show HN: Modern Web Primitives Replace 2019 JavaScript.
Если вам нужны практические примеры настройки или полифиллов, дайте знать — подготовлю дополнительные команды и конфиги.
Три современных веб‑примитива
Три современных веб‑примитива
Когда мы говорим о переносе логики агента с устаревшего JavaScript-стека на современные веб-примитивы, важно понимать: задача не в том, чтобы просто переписать код, а в том, чтобы избавиться от лишних слоев абстракции. В 2019 году для решения базовых задач интерфейса нам приходилось писать десятки строк кода, которые просто имитировали поведение браузера. Сейчас браузер делает это нативно.
С практической точки зрения, использование встроенных возможностей вместо JS-хаков даёт две вещи: предсказуемость поведения и снижение нагрузки на основной поток. Если вы посмотрите наш предыдущий разбор Show HN: Modern Web Primitives Replace 2019 JavaScript, вы увидите, что концепция замены сложных скриптов на декларативные свойства CSS становится стандартом.
field-sizing для авторасширения textarea
Раньше для создания текстового поля, которое растёт вместе с контентом (autorgrow), нам приходилось вешать слушатель события input и вручную пересчитывать scrollHeight, чтобы обновить высоту элемента. Это классический пример «костыля», который часто приводил к микро-лагам при быстром наборе текста.
Теперь для этого существует свойство field-sizing: content. Оно заставляет элемент подстраиваться под содержимое автоматически.
css/* Вместо сложного JS-скрипта теперь достаточно одной строки */
textarea {
field-sizing: content;
min-height: 3em;
max-height: 200px; /* Ограничиваем рост, чтобы не сломать верстку */
width: 100%;
}
С точки зрения системного инженера, это переход от императивного управления (когда вы говорите браузеру: «измерь, вычисли и примени») к декларативному (вы просто описываете конечное состояние). Это делает интерфейс агента более отзывчивым, так как расчеты происходят на уровне движка рендеринга, а не в интерпретаторе JavaScript.
CSS.highlights для выделения текста
Еще одна проблема, которая раньше требовала тяжелых библиотек вроде Prism.js или написания сложных регулярных выражений на JS, — это подсветка синтаксиса или выделение ключевых фрагментов текста. Традиционный подход подразумевал оборачивание каждого токена в <span>, что раздувало DOM-дерево и замедляло работу браузера.
Технология CSS Custom Highlight API позволяет выделять части текста без изменения структуры DOM. Мы создаём объект Highlight, наполняем его диапазонами (Range), и браузер сам отрисовывает выделение.
Пример реализации логики выделения в коде агента:
javascript// 1. Создаём диапазон текста, который нужно выделить
const textNode = document.querySelector('#log-output').firstChild;
const range = new Range();
range.setStart(textNode, 10); // Начало выделения
range.setEnd(textNode, 25); // Конец выделения
// 2. Создаём объект Highlight и добавляем в него диапазон
const myHighlight = new Highlight(range);
// 3. Регистрируем его в CSS Custom Highlight API
CSS.highlights.set('syntax-error', myHighlight);
В CSS это выглядит максимально просто:
css/* Применяем стиль к зарегистрированному имени выделения */
::highlight(syntax-error) {
background-color: #ffcccc;
color: #cc0000;
text-decoration: underline;
}
Если вы занимаетесь анализом данных или работаете с логами, как это описано в материалах про анализ бинарников и приложений, такой подход критически важен. При отображении больших объёмов текстовой информации (например, дампов памяти или логов системы) отсутствие лишних DOM-узлов напрямую влияет на производительность и стабильность интерфейса вашего инструмента.
Как мигрировать код
Как мигрировать код
Переход с устаревшего JavaScript-стека на современные веб-примитивы — это не просто замена одних строк кода другими. С практической точки зрения, это процесс очистки логики приложения от управления интерфейсом, которое теперь браузер берёт на себя. Если раньше мы писали сложные функции для управления состоянием модальных окон или динамическим изменением размеров полей ввода, то теперь задача сводится к правильному описанию структуры в HTML и CSS.
При миграции важно соблюдать предсказуемость: мы не просто удаляем код, а переносим ответственность за визуальное состояние на нативные механизмы. Это делает систему более устойчивой к изменениям в сторонних библиотеках.
Рефакторинг без сторонних библиотек
Основная цель рефакторинга — избавиться от «костылей», которые в 2019 году казались единственным выходом. Рассмотрим типичный пример: управление модальным окном. Раньше для этого требовался JS-скрипт, который отслеживал клики, управлял классами is-visible и следил за фокусом.
Вместо этого мы используем элемент <dialog> и метод .showModal(). Это позволяет браузеру самостоятельно обрабатывать блокировку взаимодействия с фоном и закрытие окна по клавише Esc.
Пример того, как выглядит переход от JS-хака к нативному решению:
Было (JS-подход 2019 года):
javascript// Сложная логика управления состоянием
const modal = document.querySelector('.modal-overlay');
const openBtn = document.querySelector('.open-btn');
openBtn.addEventListener('click', () => {
modal.classList.add('active');
document.body.style.overflow = 'hidden'; // Блокируем скролл вручную
});
// И еще куча кода для обработки клика вне окна...
Стало (современный подход):
html<!-- Чистый HTML без лишних обёрток -->
<button id="openModal" class="open-btn">Открыть настройки</button>
<dialog id="settingsDialog" class="modal">
<form method="dialog">
<h2>Настройки агента</h2>
<p>Выберите параметры конфигурации.</p>
<button value="cancel">Отмена</button>
<button value="confirm">Применить</button>
</form>
</dialog>
<script>
const dialog = document.querySelector('#settingsDialog');
const openBtn = document.querySelector('#openModal');
// Мы управляем только моментом открытия, остальное делает браузер
openBtn.addEventListener('click', () => dialog.showModal());
</script>
Также стоит обратить внимание на field-sizing: content. Если ваш агент использует формы для ввода длинных конфигурационных строк, вам больше не нужны библиотеки для автоматического изменения высоты textarea. Просто добавьте свойство в CSS:
csstextarea {
field-sizing: content;
min-height: 40px;
width: 100%;
}
Такой подход делает интерфейс предсказуемым: элемент растёт ровно настолько, насколько это необходимо контенту, без лишних вычислений в основном потоке (main thread). Подробнее о том, какие именно инструменты заменяют старые подходы, можно прочитать в материале Show HN: Modern Web Primitives Replace 2019 JavaScript.
Тестирование нативных возможностей
Когда мы переходим на нативные примитивы, стратегия тестирования меняется. Нам больше не нужно проверять, правильно ли JS-функция добавила класс или изменила style.display. Теперь фокус смещается на проверку того, что браузер корректно интерпретирует новые свойства.
Во-первых, необходимо убедиться, что новые элементы не ломают доступность (Accessibility). Элемент <dialog> автоматически управляет фокусом, но важно проверить, как это работает в связке с вашими кастомными стилями.
Во-вторых, при работе с CLI-инструментами или агентами, которые управляют веб-интерфейсами, тестирование должно включать проверку состояния DOM после выполнения действий. Если вы используете Playwright или Cypress, тесты должны выглядеть примерно так:
javascript// Пример теста на Playwright для проверки нативного диалога
test('модальное окно открывается и закрывается нативно', async ({ page }) => {
await page.goto('/agent-settings');
// Проверяем открытие
await page.click('#openModal');
const dialog = page.locator('dialog');
await expect(dialog).toBeVisible();
// Проверяем нативное закрытие через Esc
await page.keyboard.press('Escape');
await expect(dialog).not.toBeVisible();
});
Если ваш проект связан с глубоким анализом поведения приложений, например, при использовании методов, описанных в Reverse Engineer with Agents: From App Behavior to Binaries, тестирование нативных примитивов становится критически важным. Ошибки в рендеринге или поведении стандартных элементов могут исказить результаты автоматизированного анализа.
При миграции всегда начинайте с малого: замените один компонент, убедитесь, что его поведение соответствует спецификации, и только потом переходите к следующему. Это обеспечит стабильность системы на каждом этапе обновления.
Практические рекомендации
Проверка поддержки браузеров
Когда мы переходим от громоздких JS-скриптов к нативным веб-примитивам, первым делом нужно оценить риски. Использование CSS.highlights или <dialog> — это отличный способ сократить кодовую базу, но если ваш агент должен работать в специфических окружениях (например, внутри кастомных WebView или старых версий браузеров на терминалах), предсказуемость поведения становится критичной.
Я всегда рекомендую начинать не с написания кода, а с проверки матрицы совместимости. Для новых API, таких как field-sizing: content, важно понимать, какие именно версии движков их поддерживают.
Чтобы не гадать, используйте Can I Use, но для автоматизации процесса в рамках разработки агента можно использовать пакет browserslist. Это позволит вам синхронизировать поддержку функций в CSS, JS и автопрефиксах.
Сначала добавьте конфигурацию в ваш package.json:
json{
"browserslist": [
"last 2 versions",
"not dead",
"not ie 11"
]
}
Если вы разрабатываете CLI-инструмент, который отрисовывает веб-интерфейс (например, через локальный веб-сервер), добавьте простую проверку в ваш основной JS-файл. Это позволит агенту корректно сообщить пользователю, если окружение не подходит:
javascript// Проверка поддержки нативного диалогового окна
const supportsDialog = (() => {
try {
return !!document.createElement('dialog');
} catch (e) {
return false;
}
})();
if (!supportsDialog) {
console.error('Ошибка: Ваш браузер не поддерживает нативный элемент <dialog>.');
// Здесь можно либо вызвать fallback-метод, либо завершить работу
}
Такой подход избавляет от ситуации, когда интерфейс агента «разваливается» без внятного объяснения причин.
Оптимизация производительности
С точки зрения системного инженера, оптимизация — это не только уменьшение веса бандла, но и снижение нагрузки на основной поток (Main Thread). Перенос логики с JavaScript на нативные CSS-примитивы — это, по сути, перенос вычислений из интерпретируемого кода в оптимизированный движок браузера.
Когда мы заменяем 50 строк JS-кода, которые вручную вычисляли высоту текстового поля или позицию подсветки, на field-sizing: content или CSS.highlights, мы получаем два преимущества:
- Снижение частоты перерисовок (Repaints/Reflows). Браузер лучше понимает, как изменить геометрию элемента, если это описано нативным свойством, чем если вы постоянно меняете
style.heightчерез скрипт. - Предсказуемость рендеринга. Нативные примитивы работают синхронно с циклом отрисовки браузера.
Если ваш агент занимается сложным анализом, как это описано в материалах про Reverse engineering с AI-агентами, интерфейс не должен «фризить» при обработке данных.
Для контроля нагрузки я советую использовать Chrome DevTools (вкладка Performance) для сравнения старой версии на JS и новой на примитивах. Если вы видите длинные «красные полосы» (Long Tasks) в профиле, значит, JS всё ещё делает слишком много лишней работы.
Пример того, как нативная подсветка текста через CSS.highlights работает эффективнее, чем ручное оборачивание каждого слова в <span>:
css/* Вместо создания сотен DOM-узлов через JS, мы используем один объект Highlight */
::highlight(text-segment) {
background-color: rgba(255, 255, 0, 0.4);
text-decoration: underline;
}
Это позволяет избежать тяжелых операций манипуляции DOM, которые обычно и становятся узким местом при работе с большими логами или бинарными данными в веб-интерфейсе. Подробнее о том, как современные подходы меняют работу с данными, можно почитать в статье Show HN: Modern Web Primitives Replace 2019 JavaScript.
Часто задаваемые вопросы
Повлияет ли переход на нативные примитивы на доступность интерфейса?
Использование элемента <dialog> вместо самописных <div> значительно улучшает доступность (accessibility), так как браузер автоматически обрабатывает фокус и взаимодействие с экранными дикторами. С практической точки зрения, вам не нужно вручную реализовывать закрытие окна по клавише Esc или управление фокусом внутри модального окна — это уже заложено в стандарт.
Можно ли использовать CSS Highlights для стилизации выделения текста в старых браузерах?
Спецификация CSS Highlights пока не имеет полной поддержки во всех версиях браузеров, поэтому предсказуемость интерфейса может пострадать. Если ваша аудитория использует устаревшие версии ПО, стоит оставить JS-fallback или использовать прогрессивное улучшение: сначала подключайте современные стили, а если браузер их не понимает, используйте старый метод с <span>.
Не станет ли использование <dialog> менее гибким по сравнению с кастомными решениями?
Гибкость зависит от того, насколько глубоко вы кастомизируете поведение элементов, но нативные примитивы дают отличную базу. Вы всё так же можете стилизовать <dialog> через CSS и управлять его состоянием, однако теперь вам не нужно тратить время на решение базовых проблем вроде блокировки прокрутки страницы под модальным окном.
Как обеспечить корректную работу выделения текста, если нужно стилизовать не всё выделение сразу?
Если вам требуется сложная логика, когда выделяются только определённые фрагменты, одного CSS будет недостаточно. В таких случаях стоит использовать CSS Custom Highlight API, который позволяет программно создавать объекты Highlight и привязывать их к конкретным диапазонам текста, сохраняя при этом преимущество в производительности по сравнению с манипуляциями с DOM-деревом.