Skip to main content

light_fw_core/
vdom.rs

1//! Виртуальное дерево интерфейса и его сравнение.
2//!
3//! Каждая отрисовка компонента строит новое дерево [`VElement`]; функция
4//! [`diff`] сравнивает его с предыдущим и возвращает список точечных
5//! изменений ([`Op`]). Неизменившиеся узлы не попадают ни в один оп —
6//! именно это обеспечивает перерисовку только изменившихся элементов.
7
8use std::collections::{BTreeSet, HashMap, HashSet};
9
10use crate::collection::Collection;
11use crate::component::WindowConfig;
12use crate::control::WindowCommand;
13use std::sync::{Mutex, OnceLock};
14
15#[cfg(feature = "image-support")]
16use std::sync::{
17    Arc,
18    atomic::{AtomicU64, Ordering},
19};
20
21/// Интернирует динамический ключ узла и возвращает стабильную ссылку.
22///
23/// Используется директивами `v-for`, где ключ строится во время выполнения
24/// (базовый путь плюс индекс элемента). Одинаковые строки получают один и тот
25/// же `&'static str`, поэтому сопоставление узлов между отрисовками остаётся
26/// корректным. Набор ключей ограничен позициями шаблона и максимальной
27/// длиной списка.
28pub fn intern_key(key: &str) -> &'static str {
29    fn pool() -> &'static Mutex<HashMap<String, &'static str>> {
30        static POOL: OnceLock<Mutex<HashMap<String, &'static str>>> = OnceLock::new();
31        POOL.get_or_init(|| Mutex::new(HashMap::new()))
32    }
33    let mut pool = pool()
34        .lock()
35        .unwrap_or_else(|poisoned| poisoned.into_inner());
36    if let Some(existing) = pool.get(key) {
37        return existing;
38    }
39    let leaked: &'static str = Box::leak(key.to_owned().into_boxed_str());
40    pool.insert(leaked.to_owned(), leaked);
41    leaked
42}
43
44/// Кнопка мыши, связанная с событием нажатия или отпускания.
45#[derive(Debug, Clone, Copy, PartialEq, Eq)]
46pub enum MouseButton {
47    /// Левая кнопка.
48    Left,
49    /// Правая кнопка.
50    Right,
51    /// Средняя кнопка.
52    Middle,
53}
54
55/// Данные о клавише, связанные с событием `@keydown`/`@keyup`.
56#[derive(Debug, Clone, PartialEq, Eq)]
57pub struct KeyInfo {
58    /// Текстовая подпись клавиши (например, `"a"`, `"Enter"`, `"ArrowLeft"`).
59    pub key: String,
60    /// Зажата ли клавиша Shift.
61    pub shift: bool,
62    /// Зажата ли клавиша Ctrl (Control).
63    pub ctrl: bool,
64    /// Зажата ли клавиша Alt.
65    pub alt: bool,
66}
67
68impl KeyInfo {
69    /// Создаёт данные о клавише с указанными модификаторами.
70    pub fn new(key: impl Into<String>, shift: bool, ctrl: bool, alt: bool) -> Self {
71        Self {
72            key: key.into(),
73            shift,
74            ctrl,
75            alt,
76        }
77    }
78}
79
80/// Событие, которое бэкенд доставляет узлу по его ключу.
81#[derive(Debug, Clone, PartialEq)]
82pub enum Event {
83    /// Клик по кнопке.
84    Click,
85    /// Двойной клик.
86    Dblclick,
87    /// Нажатие кнопки мыши (не левой — обрабатывается как клик/меню).
88    Mousedown(MouseButton),
89    /// Отпускание кнопки мыши.
90    Mouseup(MouseButton),
91    /// Курсор вошёл в пределы элемента.
92    Mouseenter,
93    /// Курсор покинул пределы элемента.
94    Mouseleave,
95    /// Перемещение курсора над элементом (координаты относительно узла).
96    Mousemove {
97        /// Координата X относительно левого-верхнего угла узла.
98        x: f32,
99        /// Координата Y относительно левого-верхнего угла узла.
100        y: f32,
101    },
102    /// Нажатие клавиши клавиатуры.
103    Keydown(KeyInfo),
104    /// Отпускание клавиши клавиатуры.
105    Keyup(KeyInfo),
106    /// Текстовое поле ввело новое значение целиком.
107    TextChange(String),
108}
109
110/// Размер узла по одной оси (атрибуты `width`/`height`/`left`/`top`).
111#[derive(Debug, Clone, Copy, PartialEq, Default)]
112pub enum Size {
113    /// Размер по содержимому (значение по умолчанию).
114    #[default]
115    Auto,
116    /// Абсолютный размер в логических пикселях.
117    Px(f32),
118    /// Размер в процентах от родительского элемента (`0`–`100`).
119    Percent(f32),
120}
121
122impl Size {
123    /// Разрешает размер относительно родителя: `available` — доступный размер
124    /// по этой оси, `content` — размер по содержимому (для [`Size::Auto`]).
125    pub fn resolve(self, content: f32, available: f32) -> f32 {
126        let value = match self {
127            Size::Auto => content,
128            Size::Px(value) => value,
129            Size::Percent(percent) => available * percent / 100.0,
130        };
131        value.max(0.0)
132    }
133}
134
135/// Выравнивание узла внутри родителя по оси (`position-x`, `position-y`).
136///
137/// Для `position-x` значения `left`/`right`/`center` отображаются на
138/// [`Align::Start`]/[`Align::End`]/[`Align::Center`]; для `position-y` так же
139/// `top`/`bottom`/`center`.
140#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
141pub enum Align {
142    /// Прижать к началу оси (`left` для X, `top` для Y).
143    #[default]
144    Start,
145    /// Центрировать по оси.
146    Center,
147    /// Прижать к концу оси (`right` для X, `bottom` для Y).
148    End,
149}
150
151/// Смещение узла относительно его выравнивания
152/// (`position-offset-x`, `position-offset-y`).
153///
154/// В отличие от [`Size`] допускает отрицательные значения.
155#[derive(Debug, Clone, Copy, PartialEq)]
156pub enum Offset {
157    /// Смещение в пикселях (может быть отрицательным).
158    Px(f32),
159    /// Смещение в процентах от размера родителя по оси (может быть
160    /// отрицательным).
161    Percent(f32),
162}
163
164impl Offset {
165    /// Разрешает смещение относительно доступного размера `available`.
166    pub fn resolve(self, available: f32) -> f32 {
167        match self {
168            Offset::Px(value) => value,
169            Offset::Percent(percent) => available * percent / 100.0,
170        }
171    }
172}
173
174impl Default for Offset {
175    fn default() -> Self {
176        Offset::Px(0.0)
177    }
178}
179
180/// Режим переполнения контейнера по оси (`overflow`, `overflow-x`,
181/// `overflow-y`).
182///
183/// `Visible` не создаёт прокрутку и не обрезает содержимое. `Hidden` обрезает
184/// содержимое по границам контейнера. `Auto` обрезает содержимое и включает
185/// прокрутку, если оно не помещается. `Scroll` резервирует полосу прокрутки
186/// всегда, но в текущей реализации отрисовывается так же, как `Auto`.
187#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
188pub enum Overflow {
189    /// Содержимое может выходить за границы контейнера.
190    #[default]
191    Visible,
192    /// Содержимое обрезается по границам контейнера.
193    Hidden,
194    /// Содержимое обрезается, прокрутка появляется при переполнении.
195    Auto,
196    /// Содержимое обрезается, полоса прокрутки резервируется всегда.
197    Scroll,
198}
199
200impl Overflow {
201    /// Обрезает ли режим содержимое по границам контейнера.
202    pub const fn clips(self) -> bool {
203        !matches!(self, Overflow::Visible)
204    }
205
206    /// Разрешена ли прокрутка по оси.
207    pub const fn scrollable(self) -> bool {
208        matches!(self, Overflow::Auto | Overflow::Scroll)
209    }
210}
211
212/// Режим переноса текста (`white-space`).
213///
214/// `Normal` переносит текст по словам, если он не помещается в доступную
215/// ширину. `NoWrap` оставляет текст одной строкой; при нехватке места он
216/// обрезается многоточием.
217#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
218pub enum WhiteSpace {
219    /// Переносить текст по словам (значение по умолчанию).
220    #[default]
221    Normal,
222    /// Не переносить текст; переполнение обрезается с `…`.
223    Nowrap,
224}
225
226/// Участие узла в нормальном потоке (`position`).
227#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
228pub enum Position {
229    /// Обычный поток: узел занимает место у соседей.
230    #[default]
231    Flow,
232    /// Абсолютное позиционирование относительно content box родителя: узел не
233    /// занимает места в потоке и не влияет на размер родителя.
234    Absolute,
235}
236
237/// Отступы по четырём сторонам (`padding-*`, `margin-*`).
238///
239/// Значения — в логических пикселях. Атрибут без суффикса (`padding`/`margin`)
240/// задаёт сразу все четыре стороны; атрибуты с суффиксом
241/// (`padding-top`, `margin-left`, …) переопределяют отдельные стороны.
242#[derive(Debug, Clone, Copy, PartialEq, Default)]
243pub struct Edges {
244    /// Отступ сверху (`*-top`).
245    pub top: f32,
246    /// Отступ справа (`*-right`).
247    pub right: f32,
248    /// Отступ снизу (`*-bottom`).
249    pub bottom: f32,
250    /// Отступ слева (`*-left`).
251    pub left: f32,
252}
253
254impl Edges {
255    /// Нулевые отступы со всех сторон.
256    pub const ZERO: Self = Self {
257        top: 0.0,
258        right: 0.0,
259        bottom: 0.0,
260        left: 0.0,
261    };
262
263    /// Одинаковый отступ со всех сторон.
264    pub const fn all(value: f32) -> Self {
265        Self {
266            top: value,
267            right: value,
268            bottom: value,
269            left: value,
270        }
271    }
272
273    /// Суммарный отступ по горизонтали (`left` + `right`).
274    pub const fn horizontal(self) -> f32 {
275        self.left + self.right
276    }
277
278    /// Суммарный отступ по вертикали (`top` + `bottom`).
279    pub const fn vertical(self) -> f32 {
280        self.top + self.bottom
281    }
282
283    /// Все ли стороны нулевые.
284    pub const fn is_zero(self) -> bool {
285        self.top == 0.0 && self.right == 0.0 && self.bottom == 0.0 && self.left == 0.0
286    }
287
288    /// Масштабирует каждую сторону на `factor` (для HiDPI).
289    pub const fn scaled(self, factor: f32) -> Self {
290        Self {
291            top: self.top * factor,
292            right: self.right * factor,
293            bottom: self.bottom * factor,
294            left: self.left * factor,
295        }
296    }
297
298    /// Покомпонентная сумма двух наборов отступов.
299    pub const fn plus(self, other: Self) -> Self {
300        Self {
301            top: self.top + other.top,
302            right: self.right + other.right,
303            bottom: self.bottom + other.bottom,
304            left: self.left + other.left,
305        }
306    }
307}
308
309/// Возможность изменения размера текстового поля (`resize`).
310#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
311pub enum Resize {
312    /// Размер фиксирован.
313    #[default]
314    None,
315    /// Можно менять только ширину.
316    Horizontal,
317    /// Можно менять только высоту.
318    Vertical,
319    /// Можно менять ширину и высоту.
320    Both,
321}
322
323/// Тип кнопки (`type`) и её поведение при клике внутри формы.
324#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
325pub enum ButtonType {
326    /// Отправка формы (по умолчанию): запускает валидацию `required`.
327    #[default]
328    Submit,
329    /// Обычная кнопка: валидация не запускается.
330    Button,
331    /// Сброс формы: валидация не запускается.
332    Reset,
333}
334
335/// Форма указателя мыши (`cursor`).
336///
337/// Используется как значение атрибута `cursor`/`:cursor` и как результат
338/// автоматического выбора курсора для узла (см. `light::window`). Имена
339/// соответствуют CSS-значениям: `pointer`, `not-allowed`, `ew-resize` и т. д.
340#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
341pub enum Cursor {
342    /// Системный курсор по умолчанию (`default`).
343    #[default]
344    Default,
345    /// Указатель на ссылку или кнопку (`pointer`) — «рука».
346    Pointer,
347    /// Ввод текста (`text`) — I-beam.
348    Text,
349    /// Действие запрещено (`not-allowed`).
350    NotAllowed,
351    /// Ожидание (`wait`).
352    Wait,
353    /// Идёт фоновая работа, но взаимодействие доступно (`progress`).
354    Progress,
355    /// Доступна справка (`help`).
356    Help,
357    /// Перекрестие для выбора области (`crosshair`).
358    Crosshair,
359    /// Объект можно перемещать (`move`).
360    Move,
361    /// Объект можно захватить (`grab`).
362    Grab,
363    /// Объект захвачен (`grabbing`).
364    Grabbing,
365    /// Изменение ширины (`ew-resize`).
366    EwResize,
367    /// Изменение высоты (`ns-resize`).
368    NsResize,
369    /// Изменение по диагонали ↗↙ (`nesw-resize`).
370    NeswResize,
371    /// Изменение по диагонали ↘↖ (`nwse-resize`).
372    NwseResize,
373}
374
375impl Cursor {
376    /// Разбирает значение атрибута `cursor` (регистр не важен).
377    ///
378    /// Неизвестное значение возвращает `None` — вызывающая сторона сама решает,
379    /// использовать ли курсор по роли элемента.
380    pub fn from_name(name: &str) -> Option<Self> {
381        match name.trim().to_ascii_lowercase().as_str() {
382            "default" => Some(Self::Default),
383            "pointer" => Some(Self::Pointer),
384            "text" => Some(Self::Text),
385            "not-allowed" => Some(Self::NotAllowed),
386            "wait" => Some(Self::Wait),
387            "progress" => Some(Self::Progress),
388            "help" => Some(Self::Help),
389            "crosshair" => Some(Self::Crosshair),
390            "move" => Some(Self::Move),
391            "grab" => Some(Self::Grab),
392            "grabbing" => Some(Self::Grabbing),
393            "ew-resize" => Some(Self::EwResize),
394            "ns-resize" => Some(Self::NsResize),
395            "nesw-resize" => Some(Self::NeswResize),
396            "nwse-resize" => Some(Self::NwseResize),
397            _ => None,
398        }
399    }
400}
401
402/// Визуальный индикатор обязательного поля (`required-indicator`).
403#[derive(Debug, Clone, Copy, PartialEq, Default)]
404pub enum RequiredIndicator {
405    /// Красная звёздочка `*` (по умолчанию): после подписи у флажка/радио/списка
406    /// или в правом верхнем углу текстового поля.
407    #[default]
408    Asterisk,
409    /// Индикатор не рисуется — разработчик добавляет пометку сам.
410    None,
411    /// Акцентная полоса слева от поля заданным цветом (`0xRRGGBBAA`).
412    Accent(u32),
413}
414
415fn size_or_auto_impl(value: &str) -> Option<Size> {
416    let value = value.trim();
417    if value.is_empty() || value.eq_ignore_ascii_case("auto") {
418        return Some(Size::Auto);
419    }
420    if let Some(percent) = value.strip_suffix('%') {
421        return percent.trim().parse::<f32>().ok().map(Size::Percent);
422    }
423    let number = value.strip_suffix("px").unwrap_or(value).trim();
424    number.parse::<f32>().ok().map(Size::Px)
425}
426
427/// Разбирает значение размера (`width`/`height`) во время выполнения.
428///
429/// Правила совпадают со временем компиляции шаблонов: `auto`/пусто —
430/// [`Size::Auto`], `50%` — [`Size::Percent`], `120` или `120px` — [`Size::Px`].
431/// Некорректное значение в debug-сборке вызывает `debug_assert!`, а в release
432/// возвращает [`Size::Auto`].
433pub fn parse_size_or_auto(value: &str) -> Size {
434    size_or_auto_impl(value).unwrap_or_else(|| {
435        debug_assert!(false, "invalid size value: \"{value}\"");
436        Size::Auto
437    })
438}
439
440fn offset_impl(value: &str) -> Option<Offset> {
441    let value = value.trim();
442    if let Some(percent) = value.strip_suffix('%') {
443        return percent.trim().parse::<f32>().ok().map(Offset::Percent);
444    }
445    let number = value.strip_suffix("px").unwrap_or(value).trim();
446    number.parse::<f32>().ok().map(Offset::Px)
447}
448
449/// Разбирает значение смещения (`position-offset-x`/`position-offset-y`) во
450/// время выполнения: `-8` и `12px` — [`Offset::Px`], `10%` — [`Offset::Percent`]
451/// (знак допускается). Некорректное значение в debug-сборке вызывает
452/// `debug_assert!`, а в release возвращает [`Offset::default`].
453pub fn parse_offset(value: &str) -> Offset {
454    offset_impl(value).unwrap_or_else(|| {
455        debug_assert!(false, "invalid offset value: \"{value}\"");
456        Offset::default()
457    })
458}
459
460fn align_impl(value: &str, start: &str, end: &str) -> Option<Align> {
461    match value.trim().to_ascii_lowercase().as_str() {
462        value if value == start => Some(Align::Start),
463        "center" => Some(Align::Center),
464        value if value == end => Some(Align::End),
465        _ => None,
466    }
467}
468
469/// Разбирает `position-x` (`left`/`center`/`right`). Некорректное значение в
470/// debug-сборке вызывает `debug_assert!`, а в release возвращает
471/// [`Align::Start`].
472pub fn parse_align_x(value: &str) -> Align {
473    align_impl(value, "left", "right").unwrap_or_else(|| {
474        debug_assert!(false, "invalid position-x value: \"{value}\"");
475        Align::Start
476    })
477}
478
479/// Разбирает `position-y` (`top`/`center`/`bottom`). Некорректное значение в
480/// debug-сборке вызывает `debug_assert!`, а в release возвращает
481/// [`Align::Start`].
482pub fn parse_align_y(value: &str) -> Align {
483    align_impl(value, "top", "bottom").unwrap_or_else(|| {
484        debug_assert!(false, "invalid position-y value: \"{value}\"");
485        Align::Start
486    })
487}
488
489/// Разбирает `justify-content` (`start`/`center`/`end`). Некорректное значение в
490/// debug-сборке вызывает `debug_assert!`, а в release возвращает
491/// [`Align::Start`].
492pub fn parse_justify(value: &str) -> Align {
493    align_impl(value, "start", "end").unwrap_or_else(|| {
494        debug_assert!(false, "invalid justify-content value: \"{value}\"");
495        Align::Start
496    })
497}
498
499/// Разбирает `align-items` (`start`/`center`/`end`). Некорректное значение
500/// не прерывает работу приложения: печатается warning в stderr и
501/// возвращается [`Align::Start`].
502pub fn parse_align_items(value: &str) -> Align {
503    match align_impl(value, "start", "end") {
504        Some(align) => align,
505        None => {
506            eprintln!("warning: invalid align-items value: {value:?}, using 'start'");
507            Align::Start
508        }
509    }
510}
511
512fn overflow_impl(value: &str) -> Option<Overflow> {
513    match value.trim().to_ascii_lowercase().as_str() {
514        "visible" => Some(Overflow::Visible),
515        "hidden" => Some(Overflow::Hidden),
516        "auto" => Some(Overflow::Auto),
517        "scroll" => Some(Overflow::Scroll),
518        _ => None,
519    }
520}
521
522/// Разбирает `overflow`/`overflow-x`/`overflow-y` (`visible`, `hidden`,
523/// `auto`, `scroll`). Некорректное значение в debug-сборке вызывает
524/// `debug_assert!`, а в release возвращает [`Overflow::Visible`].
525pub fn parse_overflow(value: &str) -> Overflow {
526    overflow_impl(value).unwrap_or_else(|| {
527        debug_assert!(false, "invalid overflow value: \"{value}\"");
528        Overflow::Visible
529    })
530}
531
532fn white_space_impl(value: &str) -> Option<WhiteSpace> {
533    match value.trim().to_ascii_lowercase().as_str() {
534        "normal" | "wrap" => Some(WhiteSpace::Normal),
535        "nowrap" | "no-wrap" => Some(WhiteSpace::Nowrap),
536        _ => None,
537    }
538}
539
540/// Разбирает `white-space` (`normal`/`wrap` или `nowrap`). Некорректное
541/// значение в debug-сборке вызывает `debug_assert!`, а в release возвращает
542/// [`WhiteSpace::Normal`].
543pub fn parse_white_space(value: &str) -> WhiteSpace {
544    white_space_impl(value).unwrap_or_else(|| {
545        debug_assert!(false, "invalid white-space value: \"{value}\"");
546        WhiteSpace::Normal
547    })
548}
549
550fn position_impl(value: &str) -> Option<Position> {
551    match value.trim().to_ascii_lowercase().as_str() {
552        "flow" | "static" | "relative" => Some(Position::Flow),
553        "absolute" => Some(Position::Absolute),
554        _ => None,
555    }
556}
557
558/// Разбирает `position` (`flow`/`static`/`relative` или `absolute`).
559/// Некорректное значение в debug-сборке вызывает `debug_assert!`, а в release
560/// возвращает [`Position::Flow`].
561pub fn parse_position(value: &str) -> Position {
562    position_impl(value).unwrap_or_else(|| {
563        debug_assert!(false, "invalid position value: \"{value}\"");
564        Position::Flow
565    })
566}
567
568fn px_impl(value: &str) -> Option<f32> {
569    let value = value.trim();
570    let number = value.strip_suffix("px").unwrap_or(value).trim();
571    number.parse::<f32>().ok()
572}
573
574/// Разбирает значение в пикселях (`12`, `12px`). Некорректное значение в
575/// debug-сборке вызывает `debug_assert!`, а в release возвращает `0.0`.
576pub fn parse_px(value: &str) -> f32 {
577    px_impl(value).unwrap_or_else(|| {
578        debug_assert!(false, "invalid pixel value: \"{value}\"");
579        0.0
580    })
581}
582
583fn color_impl(value: &str) -> Option<u32> {
584    let raw = value.trim();
585    let digits = raw
586        .strip_prefix('#')
587        .or_else(|| raw.strip_prefix("0x"))
588        .unwrap_or(raw);
589    if digits.is_empty() || !digits.chars().all(|c| c.is_ascii_hexdigit()) {
590        return None;
591    }
592    let byte = |text: &str| u8::from_str_radix(text, 16).ok();
593    let (r, g, b, a) = match digits.len() {
594        3 => (
595            byte(&digits[0..1])? * 17,
596            byte(&digits[1..2])? * 17,
597            byte(&digits[2..3])? * 17,
598            0xFF,
599        ),
600        4 => (
601            byte(&digits[0..1])? * 17,
602            byte(&digits[1..2])? * 17,
603            byte(&digits[2..3])? * 17,
604            byte(&digits[3..4])? * 17,
605        ),
606        6 => (
607            byte(&digits[0..2])?,
608            byte(&digits[2..4])?,
609            byte(&digits[4..6])?,
610            0xFF,
611        ),
612        8 => (
613            byte(&digits[0..2])?,
614            byte(&digits[2..4])?,
615            byte(&digits[4..6])?,
616            byte(&digits[6..8])?,
617        ),
618        _ => return None,
619    };
620    Some(((r as u32) << 24) | ((g as u32) << 16) | ((b as u32) << 8) | a as u32)
621}
622
623/// Разбирает цвет (`#RGB`, `#RGBA`, `#RRGGBB`, `#RRGGBBAA`, `0xRRGGBB`,
624/// `0xRRGGBBAA`) в `0xRRGGBBAA`. Возвращает `None` для некорректного значения
625/// (в debug-сборке дополнительно вызывает `debug_assert!`).
626pub fn parse_color(value: &str) -> Option<u32> {
627    let parsed = color_impl(value);
628    debug_assert!(
629        parsed.is_some(),
630        "invalid color value: \"{value}\" (#RGB, #RGBA, #RRGGBB, #RRGGBBAA)"
631    );
632    parsed
633}
634
635/// Разбирает булев атрибут: истина для `true`/`1`/`yes`/`on`.
636pub fn parse_bool(value: &str) -> bool {
637    matches!(value.trim(), "true" | "1" | "yes" | "on")
638}
639
640fn required_indicator_impl(value: &str) -> Option<RequiredIndicator> {
641    match value.trim() {
642        "" | "*" => Some(RequiredIndicator::Asterisk),
643        "none" => Some(RequiredIndicator::None),
644        other => color_impl(other).map(RequiredIndicator::Accent),
645    }
646}
647
648/// Разбирает `required-indicator`: `none`, `*` (по умолчанию) или цвет
649/// (`#RRGGBB`). Некорректное значение в debug-сборке вызывает `debug_assert!`,
650/// а в release возвращает [`RequiredIndicator::Asterisk`].
651pub fn parse_required_indicator(value: &str) -> RequiredIndicator {
652    required_indicator_impl(value).unwrap_or_else(|| {
653        debug_assert!(false, "invalid required-indicator value: \"{value}\"");
654        RequiredIndicator::Asterisk
655    })
656}
657
658fn button_type_impl(value: &str) -> Option<ButtonType> {
659    match value.trim().to_ascii_lowercase().as_str() {
660        "" | "submit" => Some(ButtonType::Submit),
661        "button" => Some(ButtonType::Button),
662        "reset" => Some(ButtonType::Reset),
663        _ => None,
664    }
665}
666
667/// Разбирает тип кнопки (`submit`/`button`/`reset`). Некорректное значение в
668/// debug-сборке вызывает `debug_assert!`, а в release возвращает
669/// [`ButtonType::Submit`].
670pub fn parse_button_type(value: &str) -> ButtonType {
671    button_type_impl(value).unwrap_or_else(|| {
672        debug_assert!(false, "invalid button type value: \"{value}\"");
673        ButtonType::Submit
674    })
675}
676
677fn resize_impl(value: &str) -> Option<Resize> {
678    match value.trim().to_ascii_lowercase().as_str() {
679        "" | "none" => Some(Resize::None),
680        "horizontal" => Some(Resize::Horizontal),
681        "vertical" => Some(Resize::Vertical),
682        "both" => Some(Resize::Both),
683        _ => None,
684    }
685}
686
687/// Разбирает режим изменения размера поля
688/// (`none`/`horizontal`/`vertical`/`both`). Некорректное значение в debug-сборке
689/// вызывает `debug_assert!`, а в release возвращает [`Resize::None`].
690pub fn parse_resize(value: &str) -> Resize {
691    resize_impl(value).unwrap_or_else(|| {
692        debug_assert!(false, "invalid resize value: \"{value}\"");
693        Resize::None
694    })
695}
696
697/// Стиль узла: размеры, выравнивание, отступы, цвета и рамка.
698///
699/// Все размеры — в логических пикселях; `width`/`height` и смещения можно
700/// задавать в процентах от родительского элемента (`50%`). По умолчанию
701/// `padding`, `margin`, `border-size` и смещения равны `0`, а выравнивание —
702/// по началу оси.
703#[derive(Debug, Clone, Copy, PartialEq)]
704pub struct Style {
705    /// Ширина (`width`).
706    pub width: Size,
707    /// Высота (`height`).
708    pub height: Size,
709    /// Минимальная ширина (`min-width`), по умолчанию не ограничена.
710    pub min_width: Option<Size>,
711    /// Минимальная высота (`min-height`), по умолчанию не ограничена.
712    pub min_height: Option<Size>,
713    /// Максимальная ширина (`max-width`), по умолчанию не ограничена.
714    pub max_width: Option<Size>,
715    /// Максимальная высота (`max-height`), по умолчанию не ограничена.
716    pub max_height: Option<Size>,
717    /// Доля свободного места по main-оси контейнера (`flex-grow`/`flex`).
718    /// `0` — не растягиваться, `1` — забрать всё свободное место.
719    pub flex_grow: f32,
720    /// Доля переполнения по main-оси, которую узел отдаёт при сжатии
721    /// (`flex-shrink`/`flex`). По умолчанию `1`, как в CSS; `0` — не сжиматься.
722    pub flex_shrink: f32,
723    /// Участие в нормальном потоке (`position`).
724    pub position: Position,
725    /// Переполнение по горизонтали (`overflow-x`).
726    pub overflow_x: Overflow,
727    /// Переполнение по вертикали (`overflow-y`).
728    pub overflow_y: Overflow,
729    /// Режим переноса текста (`white-space`). `None` наследует значение
730    /// родителя; у корня действует [`WhiteSpace::Normal`].
731    pub white_space: Option<WhiteSpace>,
732    /// Выравнивание по горизонтали (`position-x`).
733    pub align_x: Align,
734    /// Выравнивание по вертикали (`position-y`).
735    pub align_y: Align,
736    /// Горизонтальное смещение (`position-offset-x`).
737    pub offset_x: Offset,
738    /// Вертикальное смещение (`position-offset-y`).
739    pub offset_y: Offset,
740    /// Выравнивание **содержимого** по main-оси контейнера (`justify-content`):
741    /// у `Column` — вертикаль, у `Row` — горизонталь. По умолчанию — начало оси.
742    pub justify_content: Align,
743    /// Выравнивание **содержимого** по cross-оси контейнера (`align-items`):
744    /// у `Column` — горизонталь, у `Row` — вертикаль. По умолчанию — начало оси.
745    pub align_items: Align,
746    /// Внутренние отступы (`padding`/`padding-*`), по умолчанию `0`.
747    pub padding: Edges,
748    /// Внешние отступы (`margin`/`margin-*`), по умолчанию `0`.
749    pub margin: Edges,
750    /// Цвет фона (`background`, `0xRRGGBBAA`).
751    pub background: Option<u32>,
752    /// Цвет текста (`font-color`, `0xRRGGBBAA`).
753    pub font_color: Option<u32>,
754    /// Размер шрифта (`font-size`, px).
755    pub font_size: Option<f32>,
756    /// Цвет рамки (`border-color`, `0xRRGGBBAA`).
757    pub border_color: Option<u32>,
758    /// Толщина рамки (`border-size`, px).
759    pub border_size: f32,
760    /// Видимость узла (`visible`): скрытые узлы не занимают места в раскладке
761    /// и не получают событий.
762    pub visible: bool,
763    /// Обязательное поле (`required`): рисуется индикатор и запускается
764    /// проверка при отправке формы.
765    pub required: bool,
766    /// Поле не прошло валидацию (`invalid`): рисуется красная рамка,
767    /// в дерево доступности попадает `aria-invalid`.
768    pub invalid: bool,
769    /// Как показывать обязательность поля (`required-indicator`).
770    pub required_indicator: RequiredIndicator,
771    /// Порядок отрисовки и хит-теста (больше z — выше).
772    pub z: i32,
773}
774
775impl Default for Style {
776    fn default() -> Self {
777        Self {
778            width: Size::Auto,
779            height: Size::Auto,
780            min_width: None,
781            min_height: None,
782            max_width: None,
783            max_height: None,
784            flex_grow: 0.0,
785            flex_shrink: 1.0,
786            position: Position::Flow,
787            overflow_x: Overflow::Visible,
788            overflow_y: Overflow::Visible,
789            white_space: None,
790            align_x: Align::Start,
791            align_y: Align::Start,
792            offset_x: Offset::Px(0.0),
793            offset_y: Offset::Px(0.0),
794            justify_content: Align::Start,
795            align_items: Align::Start,
796            padding: Edges::ZERO,
797            margin: Edges::ZERO,
798            background: None,
799            font_color: None,
800            font_size: None,
801            border_color: None,
802            border_size: 0.0,
803            visible: true,
804            required: false,
805            invalid: false,
806            required_indicator: RequiredIndicator::Asterisk,
807            z: 0,
808        }
809    }
810}
811
812impl Style {
813    /// Отступ содержимого узла от его границ по каждой стороне:
814    /// `padding` + `border_size`.
815    pub fn inset(&self) -> Edges {
816        self.padding.plus(Edges::all(self.border_size))
817    }
818
819    /// Разрешает ширину с учётом `min-width`/`max-width`.
820    pub fn resolve_width(&self, content: f32, available: f32) -> f32 {
821        let mut value = self.width.resolve(content, available);
822        if let Some(min) = self.min_width {
823            value = value.max(min.resolve(content, available));
824        }
825        if let Some(max) = self.max_width {
826            value = value.min(max.resolve(content, available));
827        }
828        value.max(0.0)
829    }
830
831    /// Разрешает высоту с учётом `min-height`/`max-height`.
832    pub fn resolve_height(&self, content: f32, available: f32) -> f32 {
833        let mut value = self.height.resolve(content, available);
834        if let Some(min) = self.min_height {
835            value = value.max(min.resolve(content, available));
836        }
837        if let Some(max) = self.max_height {
838            value = value.min(max.resolve(content, available));
839        }
840        value.max(0.0)
841    }
842}
843
844/// Вариант выпадающего списка (`<option>` внутри `<select>`).
845#[derive(Debug, Clone, PartialEq)]
846pub struct SelectOption {
847    /// Отображаемая подпись.
848    pub label: String,
849    /// Значение, записываемое в `v-model` при выборе.
850    pub value: String,
851}
852
853#[cfg(feature = "image-support")]
854static NEXT_IMAGE_ID: AtomicU64 = AtomicU64::new(1);
855
856/// Изображение, загруженное во время выполнения (например, из файла).
857///
858/// Хранит закодированный PNG и его размеры. Внутренние данные используют
859/// [`Arc`], поэтому клонирование значения дешёвое — это важно для состояния
860/// компонентов и повторных отрисовок.
861#[cfg(feature = "image-support")]
862#[derive(Clone, PartialEq)]
863pub struct ImageData {
864    pub(crate) key: Arc<str>,
865    pub(crate) bytes: Arc<[u8]>,
866    pub(crate) width: u32,
867    pub(crate) height: u32,
868}
869
870#[cfg(all(feature = "image-support", feature = "devtools"))]
871impl serde::Serialize for ImageData {
872    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
873        // Сериализуем только метаданные (размеры), не сырые байты PNG —
874        // в снимок DevTools нецелесообразно включать многомегабайтные данные.
875        use serde::ser::SerializeStruct;
876        let mut state = serializer.serialize_struct("ImageData", 3)?;
877        state.serialize_field("width", &self.width)?;
878        state.serialize_field("height", &self.height)?;
879        state.serialize_field("key", &*self.key)?;
880        state.end()
881    }
882}
883
884#[cfg(feature = "image-support")]
885impl ImageData {
886    /// Загружает PNG с разумными ограничениями: не более 8 МиБ и 4096 px
887    /// по каждой стороне.
888    pub fn from_png(bytes: Vec<u8>) -> crate::Result<Self> {
889        Self::from_png_limited(bytes, 8 * 1024 * 1024, 4096)
890    }
891
892    /// Загружает PNG с явными ограничениями по размеру файла и стороне.
893    ///
894    /// Файл проверяется по сигнатуре и IHDR до выделения буфера декодера,
895    /// затем полностью декодируется для проверки целостности.
896    pub fn from_png_limited(
897        bytes: Vec<u8>,
898        max_bytes: usize,
899        max_dimension: u32,
900    ) -> crate::Result<Self> {
901        if bytes.len() > max_bytes {
902            return Err(crate::Error::Image(format!(
903                "файл слишком большой: {} байт (максимум {max_bytes})",
904                bytes.len()
905            )));
906        }
907        const SIGNATURE: &[u8; 8] = b"\x89PNG\r\n\x1a\n";
908        if bytes.len() < 24 || &bytes[..8] != SIGNATURE || &bytes[12..16] != b"IHDR" {
909            return Err(crate::Error::Image(
910                "файл не является PNG с корректным заголовком IHDR".to_owned(),
911            ));
912        }
913        let width = u32::from_be_bytes(bytes[16..20].try_into().unwrap_or_default());
914        let height = u32::from_be_bytes(bytes[20..24].try_into().unwrap_or_default());
915        if width == 0 || height == 0 || width > max_dimension || height > max_dimension {
916            return Err(crate::Error::Image(format!(
917                "недопустимое разрешение {width}x{height} (максимум {max_dimension} px)"
918            )));
919        }
920
921        let mut decoder = png::Decoder::new(std::io::Cursor::new(bytes.as_slice()));
922        decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
923        let mut reader = decoder
924            .read_info()
925            .map_err(|error| crate::Error::Image(error.to_string()))?;
926        let mut buffer = vec![0; reader.output_buffer_size()];
927        reader
928            .next_frame(&mut buffer)
929            .map_err(|error| crate::Error::Image(error.to_string()))?;
930
931        let id = NEXT_IMAGE_ID.fetch_add(1, Ordering::Relaxed);
932        Ok(Self {
933            key: Arc::from(format!("runtime-image-{id}")),
934            bytes: Arc::from(bytes),
935            width,
936            height,
937        })
938    }
939
940    /// Ширина изображения в пикселях.
941    pub fn width(&self) -> u32 {
942        self.width
943    }
944
945    /// Высота изображения в пикселях.
946    pub fn height(&self) -> u32 {
947        self.height
948    }
949}
950
951#[cfg(feature = "image-support")]
952impl std::fmt::Debug for ImageData {
953    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
954        formatter
955            .debug_struct("ImageData")
956            .field("key", &self.key)
957            .field("bytes", &self.bytes.len())
958            .field("width", &self.width)
959            .field("height", &self.height)
960            .finish()
961    }
962}
963
964/// Тип элемента интерфейса.
965///
966/// Тип узла статичен: он задаётся позицией в шаблоне и не меняется между
967/// отрисовками (структурные изменения — это появление/исчезновение узла).
968#[derive(Debug, Clone, PartialEq)]
969pub enum NodeKind {
970    /// Контейнер, раскладывающий детей вертикально (`<div>` по умолчанию).
971    Column,
972    /// Контейнер, раскладывающий детей горизонтально (`direction="horizontal"`).
973    Row,
974    /// Титульная полоса окна (`<titlebar>`): горизонтальный контейнер, за
975    /// который перетаскивается безрамочное окно. Его текст задаёт заголовок.
976    TitleBar,
977    /// Корневой узел окна (`<window>`). Контейнер клиентской области; несёт
978    /// настройки системного окна в поле [`VElement::window`].
979    Window,
980    /// Текстовый узел.
981    Text {
982        /// Отображаемый текст.
983        content: String,
984    },
985    /// Изображение (`<image>`), встроенное в бинарник на этапе компиляции.
986    #[cfg(feature = "image-support")]
987    Image {
988        /// Путь к файлу из атрибута `src` (используется как ключ кэша и имя).
989        src: &'static str,
990        /// Содержимое PNG-файла.
991        data: &'static [u8],
992        /// Ширина исходного изображения в пикселях.
993        width: u32,
994        /// Высота исходного изображения в пикселях.
995        height: u32,
996        /// Альтернативный текст (`alt`) для дерева доступности.
997        alt: String,
998    },
999    /// Изображение, загруженное во время выполнения.
1000    #[cfg(feature = "image-support")]
1001    RuntimeImage {
1002        /// Данные изображения и уникальный ключ кэша.
1003        image: ImageData,
1004        /// Альтернативный текст (`alt`) для дерева доступности.
1005        alt: String,
1006    },
1007    /// Кнопка-контейнер: содержимое (`children`) выкладывается горизонтально и
1008    /// центрируется по обеим осям. Подпись собирается из текста детей.
1009    Button {
1010        /// Заблокирована ли кнопка (`:disabled`).
1011        disabled: bool,
1012        /// Тип кнопки (`type`): влияет на запуск валидации формы.
1013        button_type: ButtonType,
1014    },
1015    /// Текстовое поле (`<text>`); при `multiline` — многострочное
1016    /// (аналог HTML `<textarea>`).
1017    TextField {
1018        /// Текущее значение (`v-model`).
1019        value: String,
1020        /// Подсказка, когда значение пусто (`placeholder`).
1021        placeholder: String,
1022        /// Заблокировано ли поле (`:disabled`).
1023        disabled: bool,
1024        /// Многострочный режим (`textarea`).
1025        multiline: bool,
1026        /// Возможность изменения размера (`resize`).
1027        resize: Resize,
1028        /// Скрывать ли вводимый текст (`<password>`): значение отображается
1029        /// точками, но хранится как есть.
1030        masked: bool,
1031    },
1032    /// Флажок (`<checkbox>`): переключает булево значение `v-model`.
1033    #[cfg(feature = "elements-checkbox")]
1034    Checkbox {
1035        /// Подпись рядом с флажком.
1036        label: String,
1037        /// Отмечен ли флажок (`v-model`).
1038        checked: bool,
1039        /// Заблокирован ли флажок (`:disabled`).
1040        disabled: bool,
1041    },
1042    /// Переключатель (`<radio>`): выбирает одно значение из группы,
1043    /// объединённой общим `v-model`.
1044    #[cfg(feature = "elements-radio")]
1045    Radio {
1046        /// Подпись рядом с переключателем.
1047        label: String,
1048        /// Значение, записываемое в `v-model` при выборе.
1049        value: String,
1050        /// Совпадает ли текущее значение `v-model` с полем `value` варианта
1051        /// [`NodeKind::Radio`].
1052        selected: bool,
1053        /// Заблокирован ли переключатель (`:disabled`).
1054        disabled: bool,
1055    },
1056    /// Выпадающий список (`<select>`).
1057    #[cfg(feature = "elements-select")]
1058    Select {
1059        /// Текущее выбранное значение (`v-model`).
1060        value: String,
1061        /// Варианты списка (`<option>`).
1062        options: Vec<SelectOption>,
1063        /// Заблокирован ли список (`:disabled`).
1064        disabled: bool,
1065    },
1066}
1067
1068/// Узел виртуального дерева.
1069///
1070/// `key` — стабильный путь к узлу от корня (назначается макросом по позиции
1071/// в шаблоне): он переживает между отрисовками и служит идентичностью узла
1072/// при сравнении деревьев.
1073#[derive(Debug, Clone, PartialEq)]
1074pub struct VElement {
1075    /// Стабильный путь-идентификатор узла (`""` — корень).
1076    pub key: &'static str,
1077    /// Тип элемента.
1078    pub kind: NodeKind,
1079    /// Размеры узла из атрибутов `width`/`height`.
1080    pub style: Style,
1081    /// Имя HTML-тега источника (`"div"`, `"button"`, …). Для программно
1082    /// созданных узлов и текстовых сегментов — пустая строка.
1083    pub tag: &'static str,
1084    /// Атрибуты элемента `(имя, значение)` без директив и обработчиков.
1085    ///
1086    /// Динамические привязки (`:disabled="locked"`) хранятся под именем без
1087    /// двоеточия со строковым значением на момент отрисовки.
1088    pub attrs: Vec<(&'static str, String)>,
1089    /// Настройки системного окна — только у корневого узла с типом
1090    /// [`NodeKind::Window`]; у остальных узлов — `None`.
1091    pub window: Option<WindowConfig>,
1092    /// Дочерние узлы (пусто для текста и поля).
1093    pub children: Vec<VElement>,
1094}
1095
1096impl VElement {
1097    /// Создаёт узел с пустым списком детей.
1098    pub fn leaf(key: &'static str, kind: NodeKind) -> Self {
1099        Self {
1100            key,
1101            kind,
1102            style: Style::default(),
1103            tag: "",
1104            attrs: Vec::new(),
1105            window: None,
1106            children: Vec::new(),
1107        }
1108    }
1109
1110    /// Создаёт контейнер с детьми.
1111    pub fn container(key: &'static str, kind: NodeKind, children: Vec<VElement>) -> Self {
1112        Self {
1113            key,
1114            kind,
1115            style: Style::default(),
1116            tag: "",
1117            attrs: Vec::new(),
1118            window: None,
1119            children,
1120        }
1121    }
1122
1123    /// Задаёт размеры узла (атрибуты `width`/`height`).
1124    pub fn with_style(mut self, style: Style) -> Self {
1125        self.style = style;
1126        self
1127    }
1128
1129    /// Задаёт настройки системного окна (для корневого узла [`NodeKind::Window`]).
1130    pub fn with_window(mut self, config: WindowConfig) -> Self {
1131        self.window = Some(config);
1132        self
1133    }
1134
1135    /// Настройки системного окна, если узел — окно.
1136    pub fn window_config(&self) -> Option<&WindowConfig> {
1137        self.window.as_ref()
1138    }
1139
1140    /// Задаёт имя HTML-тега источника.
1141    pub fn with_tag(mut self, tag: &'static str) -> Self {
1142        self.tag = tag;
1143        self
1144    }
1145
1146    /// Добавляет один атрибут элемента.
1147    pub fn with_attr(mut self, name: &'static str, value: impl Into<String>) -> Self {
1148        self.attrs.push((name, value.into()));
1149        self
1150    }
1151
1152    /// Задаёт список атрибутов элемента.
1153    pub fn with_attrs(mut self, attrs: Vec<(&'static str, String)>) -> Self {
1154        self.attrs = attrs;
1155        self
1156    }
1157
1158    /// Значение атрибута по имени, если он задан.
1159    pub fn attr(&self, name: &str) -> Option<&str> {
1160        self.attrs
1161            .iter()
1162            .find(|(key, _)| *key == name)
1163            .map(|(_, value)| value.as_str())
1164    }
1165
1166    /// JSON-представление узла для инструментов разработки (DevTools).
1167    ///
1168    /// Содержит имя HTML-тега (`tag`), ключ узла (`key`), атрибуты (`attrs`,
1169    /// пары `[имя, значение]`) и рекурсивно собранные дети (`children`).
1170    /// Ключ нужен инспектору: по нему клиент формирует команду `CLICK <key>`.
1171    /// Тип узла (`kind`) и стиль намеренно не сериализуются — их полный разбор
1172    /// требует перебора вариантов с условной компиляцией и вынесен в отдельную
1173    /// задачу. Метод доступен всегда (0.15.1): без фичи `devtools` его просто
1174    /// никто из библиотеки не вызывает, а `serde_json` больше не опционален.
1175    pub fn to_json(&self) -> serde_json::Value {
1176        let children: Vec<_> = self.children.iter().map(VElement::to_json).collect();
1177        serde_json::json!({
1178            "tag": self.tag,
1179            "key": self.key,
1180            "attrs": &self.attrs,
1181            "children": children,
1182        })
1183    }
1184
1185    /// Ищет узел по ключу (обход в глубину).
1186    pub fn get(&self, key: &str) -> Option<&VElement> {
1187        if self.key == key {
1188            return Some(self);
1189        }
1190        self.children.iter().find_map(|child| child.get(key))
1191    }
1192
1193    /// Первый узел поддерева с указанным именем HTML-тега.
1194    pub fn find_by_tag(&self, tag: &str) -> Option<&VElement> {
1195        if self.tag == tag {
1196            return Some(self);
1197        }
1198        self.children
1199            .iter()
1200            .find_map(|child| child.find_by_tag(tag))
1201    }
1202
1203    /// Первый узел поддерева с атрибутом `name`, равным `value`.
1204    pub fn find_by_attr(&self, name: &str, value: &str) -> Option<&VElement> {
1205        if self.attr(name) == Some(value) {
1206            return Some(self);
1207        }
1208        self.children
1209            .iter()
1210            .find_map(|child| child.find_by_attr(name, value))
1211    }
1212
1213    /// Ищет узел по ключу для изменения (обход в глубину).
1214    pub fn get_mut(&mut self, key: &str) -> Option<&mut VElement> {
1215        if self.key == key {
1216            return Some(self);
1217        }
1218        self.children
1219            .iter_mut()
1220            .find_map(|child| child.get_mut(key))
1221    }
1222
1223    /// Текстовое содержимое узла для поиска (только у текстовых узлов).
1224    pub fn content(&self) -> Option<&str> {
1225        match &self.kind {
1226            NodeKind::Text { content } => Some(content),
1227            _ => None,
1228        }
1229    }
1230
1231    /// Все узлы поддерева (включая сам узел) в порядке обхода в глубину.
1232    ///
1233    /// Возвращается [`Collection`], поэтому результат можно сразу фильтровать
1234    /// и преобразовывать цепочкой методов.
1235    pub fn descendants(&self) -> Collection<&VElement> {
1236        let mut nodes = Collection::new();
1237        self.collect_descendants(&mut nodes);
1238        nodes
1239    }
1240
1241    fn collect_descendants<'a>(&'a self, out: &mut Collection<&'a VElement>) {
1242        out.push(self);
1243        for child in &self.children {
1244            child.collect_descendants(out);
1245        }
1246    }
1247
1248    /// Ищет первый узел с заданным текстовым содержимым.
1249    pub fn find_by_content(&self, content: &str) -> Option<&VElement> {
1250        if self.content() == Some(content) {
1251            return Some(self);
1252        }
1253        self.children
1254            .iter()
1255            .find_map(|child| child.find_by_content(content))
1256    }
1257
1258    /// Ищет первый узел, содержимое которого содержит подстроку `needle`.
1259    pub fn find_containing(&self, needle: &str) -> Option<&VElement> {
1260        if self
1261            .content()
1262            .is_some_and(|content| content.contains(needle))
1263        {
1264            return Some(self);
1265        }
1266        self.children
1267            .iter()
1268            .find_map(|child| child.find_containing(needle))
1269    }
1270
1271    /// Первый узел титульной полосы (`<titlebar>`), если он есть.
1272    fn find_titlebar(&self) -> Option<&VElement> {
1273        if matches!(self.kind, NodeKind::TitleBar) {
1274            return Some(self);
1275        }
1276        self.children.iter().find_map(VElement::find_titlebar)
1277    }
1278
1279    /// Собирает простой текст поддерева, пропуская интерактивные элементы.
1280    fn collect_plain_text(&self, out: &mut String) {
1281        match &self.kind {
1282            NodeKind::Text { content } => out.push_str(content),
1283            NodeKind::Button { .. } | NodeKind::TextField { .. } => {}
1284            #[cfg(feature = "elements-checkbox")]
1285            NodeKind::Checkbox { .. } => {}
1286            #[cfg(feature = "elements-radio")]
1287            NodeKind::Radio { .. } => {}
1288            #[cfg(feature = "elements-select")]
1289            NodeKind::Select { .. } => {}
1290            _ => {
1291                for child in &self.children {
1292                    child.collect_plain_text(out);
1293                }
1294            }
1295        }
1296    }
1297
1298    /// ТЗ 0.16.0: публичная версия [`collect_plain_text`] — собирает текст
1299    /// поддерева (пропуская интерактивные элементы) в переданную строку.
1300    ///
1301    /// Используется командой `FIND` DevTools для поиска кнопки по подписи:
1302    /// текст кнопки = конкатенация текстовых потомков, без вложенных
1303    /// кнопок/полей.
1304    pub fn collect_plain_text_public(&self, out: &mut String) {
1305        self.collect_plain_text(out)
1306    }
1307
1308    /// Заголовок окна, выведенный из текста первого `<titlebar>`.
1309    ///
1310    /// Интерактивные элементы (кнопки управления) в заголовок не попадают.
1311    /// Возвращает `None`, если титульной полосы нет или её текст пуст.
1312    pub fn titlebar_text(&self) -> Option<String> {
1313        let bar = self.find_titlebar()?;
1314        let mut text = String::new();
1315        bar.collect_plain_text(&mut text);
1316        let trimmed = text.trim();
1317        if trimmed.is_empty() {
1318            None
1319        } else {
1320            Some(trimmed.to_owned())
1321        }
1322    }
1323}
1324
1325/// Общий интерфейс любого элемента дерева: чтение и изменение свойств плюс
1326/// отправка действий оконному бэкенду.
1327///
1328/// Это «базовый класс» для узлов интерфейса: конкретный элемент — [`VElement`],
1329/// который реализует этот трейт. Операции над окном описаны в [`VWindow`].
1330pub trait VNode {
1331    /// Стабильный ключ узла.
1332    fn key(&self) -> &'static str;
1333    /// Тип элемента.
1334    fn kind(&self) -> &NodeKind;
1335    /// Изменяемый тип элемента.
1336    fn kind_mut(&mut self) -> &mut NodeKind;
1337    /// Стиль узла.
1338    fn style(&self) -> &Style;
1339    /// Изменяемый стиль узла.
1340    fn style_mut(&mut self) -> &mut Style;
1341    /// Имя HTML-тега источника.
1342    fn tag(&self) -> &'static str;
1343    /// Атрибуты элемента.
1344    fn attrs(&self) -> &[(&'static str, String)];
1345    /// Дочерние узлы.
1346    fn children(&self) -> &[VElement];
1347
1348    /// Значение атрибута по имени.
1349    fn attr(&self, name: &str) -> Option<&str> {
1350        self.attrs()
1351            .iter()
1352            .find(|(key, _)| *key == name)
1353            .map(|(_, value)| value.as_str())
1354    }
1355
1356    /// Текст узла (для [`NodeKind::Text`]).
1357    fn text(&self) -> Option<&str> {
1358        match self.kind() {
1359            NodeKind::Text { content } => Some(content),
1360            _ => None,
1361        }
1362    }
1363
1364    /// Задаёт текст узла (для [`NodeKind::Text`]).
1365    fn set_text(&mut self, value: impl Into<String>) {
1366        if let NodeKind::Text { content } = self.kind_mut() {
1367            *content = value.into();
1368        }
1369    }
1370
1371    /// Виден ли узел.
1372    fn visible(&self) -> bool {
1373        self.style().visible
1374    }
1375
1376    /// Показывает или скрывает узел.
1377    fn set_visible(&mut self, value: bool) {
1378        self.style_mut().visible = value;
1379    }
1380
1381    /// Заблокирован ли узел.
1382    fn disabled(&self) -> bool {
1383        match self.kind() {
1384            NodeKind::Button { disabled, .. } | NodeKind::TextField { disabled, .. } => *disabled,
1385            #[cfg(feature = "elements-checkbox")]
1386            NodeKind::Checkbox { disabled, .. } => *disabled,
1387            #[cfg(feature = "elements-radio")]
1388            NodeKind::Radio { disabled, .. } => *disabled,
1389            #[cfg(feature = "elements-select")]
1390            NodeKind::Select { disabled, .. } => *disabled,
1391            _ => false,
1392        }
1393    }
1394
1395    /// Блокирует или разблокирует узел.
1396    fn set_disabled(&mut self, value: bool) {
1397        match self.kind_mut() {
1398            NodeKind::Button { disabled, .. } | NodeKind::TextField { disabled, .. } => {
1399                *disabled = value;
1400            }
1401            #[cfg(feature = "elements-checkbox")]
1402            NodeKind::Checkbox { disabled, .. } => *disabled = value,
1403            #[cfg(feature = "elements-radio")]
1404            NodeKind::Radio { disabled, .. } => *disabled = value,
1405            #[cfg(feature = "elements-select")]
1406            NodeKind::Select { disabled, .. } => *disabled = value,
1407            _ => {}
1408        }
1409    }
1410
1411    /// Текущее значение (поля ввода или списка).
1412    fn value(&self) -> Option<&str> {
1413        match self.kind() {
1414            NodeKind::TextField { value, .. } => Some(value),
1415            #[cfg(feature = "elements-select")]
1416            NodeKind::Select { value, .. } => Some(value),
1417            _ => None,
1418        }
1419    }
1420
1421    /// Задаёт текущее значение.
1422    fn set_value(&mut self, new_value: impl Into<String>) {
1423        let new_value = new_value.into();
1424        match self.kind_mut() {
1425            NodeKind::TextField { value, .. } => {
1426                *value = new_value;
1427            }
1428            #[cfg(feature = "elements-select")]
1429            NodeKind::Select { value, .. } => {
1430                *value = new_value;
1431            }
1432            _ => {}
1433        }
1434    }
1435
1436    /// Отмечен ли флажок.
1437    fn checked(&self) -> bool {
1438        #[cfg(feature = "elements-checkbox")]
1439        {
1440            matches!(self.kind(), NodeKind::Checkbox { checked: true, .. })
1441        }
1442        #[cfg(not(feature = "elements-checkbox"))]
1443        {
1444            false
1445        }
1446    }
1447
1448    /// Ставит или снимает флажок.
1449    fn set_checked(&mut self, value: bool) {
1450        #[cfg(feature = "elements-checkbox")]
1451        if let NodeKind::Checkbox { checked, .. } = self.kind_mut() {
1452            *checked = value;
1453        }
1454        #[cfg(not(feature = "elements-checkbox"))]
1455        let _ = value;
1456    }
1457
1458    /// Выбран ли переключатель.
1459    fn selected(&self) -> bool {
1460        #[cfg(feature = "elements-radio")]
1461        {
1462            matches!(self.kind(), NodeKind::Radio { selected: true, .. })
1463        }
1464        #[cfg(not(feature = "elements-radio"))]
1465        {
1466            false
1467        }
1468    }
1469
1470    /// Выбирает или снимает переключатель.
1471    fn set_selected(&mut self, value: bool) {
1472        #[cfg(feature = "elements-radio")]
1473        if let NodeKind::Radio { selected, .. } = self.kind_mut() {
1474            *selected = value;
1475        }
1476        #[cfg(not(feature = "elements-radio"))]
1477        let _ = value;
1478    }
1479
1480    /// Варианты выпадающего списка.
1481    fn options(&self) -> &[SelectOption] {
1482        match self.kind() {
1483            #[cfg(feature = "elements-select")]
1484            NodeKind::Select { options, .. } => options,
1485            _ => &[],
1486        }
1487    }
1488
1489    /// Задаёт варианты выпадающего списка.
1490    fn set_options(&mut self, value: Vec<SelectOption>) {
1491        #[cfg(feature = "elements-select")]
1492        if let NodeKind::Select { options, .. } = self.kind_mut() {
1493            *options = value;
1494        }
1495        #[cfg(not(feature = "elements-select"))]
1496        let _ = value;
1497    }
1498
1499    /// Отправляет действие оконному бэкенду для окна, событие которого
1500    /// обрабатывается в данный момент.
1501    fn act(&self, command: WindowCommand) {
1502        crate::control::request(command);
1503    }
1504}
1505
1506/// Операции над окном — расширение интерфейса узла [`VNode`].
1507///
1508/// Реализуется корневым узлом [`NodeKind::Window`]; методы отправляют команду
1509/// активному окну (см. [`crate::control`]).
1510pub trait VWindow: VNode {
1511    /// Настройки системного окна, если узел — окно.
1512    fn config(&self) -> Option<&WindowConfig>;
1513
1514    /// Закрывает окно.
1515    fn close(&self) {
1516        self.act(WindowCommand::Close);
1517    }
1518
1519    /// Сворачивает окно.
1520    fn minimize(&self) {
1521        self.act(WindowCommand::Minimize);
1522    }
1523
1524    /// Разворачивает окно.
1525    fn maximize(&self) {
1526        self.act(WindowCommand::Maximize);
1527    }
1528
1529    /// Возвращает окно в обычный размер.
1530    fn restore(&self) {
1531        self.act(WindowCommand::Restore);
1532    }
1533
1534    /// Переключает развёрнутость окна.
1535    fn toggle_maximize(&self) {
1536        self.act(WindowCommand::ToggleMaximize);
1537    }
1538
1539    /// Показывает скрытое окно.
1540    fn show(&self) {
1541        self.act(WindowCommand::Show);
1542    }
1543
1544    /// Скрывает окно.
1545    fn hide(&self) {
1546        self.act(WindowCommand::Hide);
1547    }
1548
1549    /// Открывает дочернее модальное окно поверх текущего.
1550    fn open_modal(&self) {
1551        self.act(WindowCommand::OpenModal);
1552    }
1553
1554    /// Открывает ещё одно главное окно приложения.
1555    fn open_window(&self) {
1556        self.act(WindowCommand::OpenWindow);
1557    }
1558
1559    /// Открывает (или фокусирует) окно с идентификатором `id`.
1560    fn open(&self, id: &str) {
1561        self.act(WindowCommand::Open(id.to_owned()));
1562    }
1563
1564    /// Закрывает окно с идентификатором `id` вместе с потомками.
1565    fn close_window(&self, id: &str) {
1566        self.act(WindowCommand::CloseWindow(id.to_owned()));
1567    }
1568
1569    /// Показывает окно с идентификатором `id`.
1570    fn show_window(&self, id: &str) {
1571        self.act(WindowCommand::ShowWindow(id.to_owned()));
1572    }
1573
1574    /// Скрывает окно с идентификатором `id`.
1575    fn hide_window(&self, id: &str) {
1576        self.act(WindowCommand::HideWindow(id.to_owned()));
1577    }
1578
1579    /// Развёрнуто ли окно в данный момент.
1580    fn is_maximized(&self) -> bool {
1581        crate::control::is_maximized()
1582    }
1583}
1584
1585impl VNode for VElement {
1586    fn key(&self) -> &'static str {
1587        self.key
1588    }
1589
1590    fn kind(&self) -> &NodeKind {
1591        &self.kind
1592    }
1593
1594    fn kind_mut(&mut self) -> &mut NodeKind {
1595        &mut self.kind
1596    }
1597
1598    fn style(&self) -> &Style {
1599        &self.style
1600    }
1601
1602    fn style_mut(&mut self) -> &mut Style {
1603        &mut self.style
1604    }
1605
1606    fn tag(&self) -> &'static str {
1607        self.tag
1608    }
1609
1610    fn attrs(&self) -> &[(&'static str, String)] {
1611        &self.attrs
1612    }
1613
1614    fn children(&self) -> &[VElement] {
1615        &self.children
1616    }
1617}
1618
1619impl VWindow for VElement {
1620    fn config(&self) -> Option<&WindowConfig> {
1621        self.window.as_ref()
1622    }
1623}
1624
1625/// Точечное изменение одного узла между отрисовками.
1626#[derive(Debug, Clone, PartialEq)]
1627pub enum Op {
1628    /// Изменилось содержимое текстового узла.
1629    SetContent {
1630        /// Ключ узла.
1631        key: &'static str,
1632        /// Новый текст.
1633        content: String,
1634    },
1635    /// Изменилась подпись кнопки.
1636    SetLabel {
1637        /// Ключ узла.
1638        key: &'static str,
1639        /// Новая подпись.
1640        label: String,
1641    },
1642    /// Изменился флаг disabled (кнопки или поля).
1643    SetDisabled {
1644        /// Ключ узла.
1645        key: &'static str,
1646        /// Новое значение.
1647        disabled: bool,
1648    },
1649    /// Изменилось значение текстового поля.
1650    SetValue {
1651        /// Ключ узла.
1652        key: &'static str,
1653        /// Новое значение.
1654        value: String,
1655    },
1656    /// Изменился placeholder текстового поля.
1657    SetPlaceholder {
1658        /// Ключ узла.
1659        key: &'static str,
1660        /// Новый placeholder.
1661        placeholder: String,
1662    },
1663    /// Изменился режим скрытия текста (`<password>`).
1664    SetMasked {
1665        /// Ключ узла.
1666        key: &'static str,
1667        /// Скрывать ли текст.
1668        masked: bool,
1669    },
1670    /// Изменилось состояние флажка.
1671    SetChecked {
1672        /// Ключ узла.
1673        key: &'static str,
1674        /// Новое состояние.
1675        checked: bool,
1676    },
1677    /// Изменилось состояние переключателя.
1678    SetSelected {
1679        /// Ключ узла.
1680        key: &'static str,
1681        /// Новое состояние.
1682        selected: bool,
1683    },
1684    /// Изменился набор пунктов выпадающего списка.
1685    SetOptions {
1686        /// Ключ узла.
1687        key: &'static str,
1688        /// Новые пункты.
1689        options: Vec<SelectOption>,
1690    },
1691    /// Узел добавлен вместе с поддеревом.
1692    Insert {
1693        /// Ключ узла.
1694        key: &'static str,
1695    },
1696    /// Узел удалён вместе с поддеревом.
1697    Remove {
1698        /// Ключ узла.
1699        key: &'static str,
1700    },
1701    /// Тип узла несовместим с прежним — узел заменён целиком.
1702    Replace {
1703        /// Ключ узла.
1704        key: &'static str,
1705    },
1706}
1707
1708impl Op {
1709    /// Ключ затронутого узла.
1710    pub fn key(&self) -> &'static str {
1711        match self {
1712            Self::SetContent { key, .. }
1713            | Self::SetLabel { key, .. }
1714            | Self::SetDisabled { key, .. }
1715            | Self::SetValue { key, .. }
1716            | Self::SetPlaceholder { key, .. }
1717            | Self::SetMasked { key, .. }
1718            | Self::SetChecked { key, .. }
1719            | Self::SetSelected { key, .. }
1720            | Self::SetOptions { key, .. }
1721            | Self::Insert { key }
1722            | Self::Remove { key }
1723            | Self::Replace { key } => key,
1724        }
1725    }
1726}
1727
1728/// Результат сравнения двух деревьев.
1729#[derive(Debug, Clone, Default, PartialEq)]
1730pub struct Patch {
1731    /// Список точечных изменений в порядке обхода.
1732    pub ops: Vec<Op>,
1733    /// Ключи узлов, содержимое которых изменилось (для перерисовки их областей).
1734    pub changed: BTreeSet<&'static str>,
1735}
1736
1737impl Patch {
1738    /// Истина, если изменений нет.
1739    pub fn is_empty(&self) -> bool {
1740        self.ops.is_empty()
1741    }
1742}
1743
1744/// Сравнивает новое дерево со старым и возвращает точечные изменения.
1745///
1746/// Узлы сопоставляются по стабильным ключам: изменившиеся свойства дают
1747/// операции `Set*`, добавленные/удалённые — `Insert`/`Remove`. Узлы, у которых
1748/// ничего не поменялось, не порождают никаких операций.
1749pub fn diff(old: &VElement, new: &VElement) -> Patch {
1750    let mut patch = Patch::default();
1751    diff_node(old, new, &mut patch);
1752    patch
1753}
1754
1755fn diff_node(old: &VElement, new: &VElement, patch: &mut Patch) {
1756    if old.key != new.key {
1757        debug_assert!(false, "diff_node вызван для разных ключей");
1758        patch.ops.push(Op::Replace { key: new.key });
1759        patch.changed.insert(new.key);
1760        return;
1761    }
1762    if !kind_compatible(&old.kind, &new.kind) {
1763        patch.ops.push(Op::Replace { key: new.key });
1764        patch.changed.insert(new.key);
1765        return;
1766    }
1767    if old.style != new.style {
1768        patch.changed.insert(new.key);
1769    }
1770    if old.attrs != new.attrs {
1771        patch.changed.insert(new.key);
1772    }
1773    diff_kind(&old.kind, &new.kind, new.key, patch);
1774    diff_children(old, new, patch);
1775}
1776
1777/// Совместимы ли типы узлов: контейнер с контейнером, текст с текстом и т. д.
1778fn kind_compatible(a: &NodeKind, b: &NodeKind) -> bool {
1779    match (a, b) {
1780        (NodeKind::Column, NodeKind::Column)
1781        | (NodeKind::Row, NodeKind::Row)
1782        | (NodeKind::TitleBar, NodeKind::TitleBar)
1783        | (NodeKind::Window, NodeKind::Window)
1784        | (NodeKind::Text { .. }, NodeKind::Text { .. })
1785        | (NodeKind::Button { .. }, NodeKind::Button { .. })
1786        | (NodeKind::TextField { .. }, NodeKind::TextField { .. }) => true,
1787        #[cfg(feature = "image-support")]
1788        (NodeKind::Image { src: src_a, .. }, NodeKind::Image { src: src_b, .. }) => src_a == src_b,
1789        #[cfg(feature = "image-support")]
1790        (NodeKind::RuntimeImage { image: a, .. }, NodeKind::RuntimeImage { image: b, .. }) => {
1791            a.key == b.key
1792        }
1793        #[cfg(feature = "elements-checkbox")]
1794        (NodeKind::Checkbox { .. }, NodeKind::Checkbox { .. }) => true,
1795        #[cfg(feature = "elements-radio")]
1796        (NodeKind::Radio { .. }, NodeKind::Radio { .. }) => true,
1797        #[cfg(feature = "elements-select")]
1798        (NodeKind::Select { .. }, NodeKind::Select { .. }) => true,
1799        _ => false,
1800    }
1801}
1802
1803fn diff_kind(old: &NodeKind, new: &NodeKind, key: &'static str, patch: &mut Patch) {
1804    match (old, new) {
1805        (NodeKind::Text { content: a }, NodeKind::Text { content: b }) => {
1806            if a != b {
1807                patch.ops.push(Op::SetContent {
1808                    key,
1809                    content: b.clone(),
1810                });
1811                patch.changed.insert(key);
1812            }
1813        }
1814        #[cfg(feature = "image-support")]
1815        (
1816            NodeKind::Image {
1817                data: data_a,
1818                alt: alt_a,
1819                ..
1820            },
1821            NodeKind::Image {
1822                data: data_b,
1823                alt: alt_b,
1824                ..
1825            },
1826        ) => {
1827            if data_a != data_b || alt_a != alt_b {
1828                patch.changed.insert(key);
1829            }
1830        }
1831        #[cfg(feature = "image-support")]
1832        (
1833            NodeKind::RuntimeImage {
1834                image: image_a,
1835                alt: alt_a,
1836            },
1837            NodeKind::RuntimeImage {
1838                image: image_b,
1839                alt: alt_b,
1840            },
1841        ) => {
1842            if image_a != image_b || alt_a != alt_b {
1843                patch.changed.insert(key);
1844            }
1845        }
1846        (
1847            NodeKind::Button {
1848                disabled: disabled_a,
1849                button_type: type_a,
1850            },
1851            NodeKind::Button {
1852                disabled: disabled_b,
1853                button_type: button_type_b,
1854            },
1855        ) => {
1856            if disabled_a != disabled_b {
1857                patch.ops.push(Op::SetDisabled {
1858                    key,
1859                    disabled: *disabled_b,
1860                });
1861                patch.changed.insert(key);
1862            }
1863            if type_a != button_type_b {
1864                patch.changed.insert(key);
1865            }
1866        }
1867        (
1868            NodeKind::TextField {
1869                value: value_a,
1870                placeholder: placeholder_a,
1871                disabled: disabled_a,
1872                multiline: multiline_a,
1873                resize: resize_a,
1874                masked: masked_a,
1875            },
1876            NodeKind::TextField {
1877                value: value_b,
1878                placeholder: placeholder_b,
1879                disabled: disabled_b,
1880                multiline: multiline_b,
1881                resize: resize_b,
1882                masked: masked_b,
1883            },
1884        ) => {
1885            if value_a != value_b {
1886                patch.ops.push(Op::SetValue {
1887                    key,
1888                    value: value_b.clone(),
1889                });
1890                patch.changed.insert(key);
1891            }
1892            if placeholder_a != placeholder_b {
1893                patch.ops.push(Op::SetPlaceholder {
1894                    key,
1895                    placeholder: placeholder_b.clone(),
1896                });
1897                patch.changed.insert(key);
1898            }
1899            if disabled_a != disabled_b {
1900                patch.ops.push(Op::SetDisabled {
1901                    key,
1902                    disabled: *disabled_b,
1903                });
1904                patch.changed.insert(key);
1905            }
1906            if multiline_a != multiline_b {
1907                patch.changed.insert(key);
1908            }
1909            if resize_a != resize_b {
1910                patch.changed.insert(key);
1911            }
1912            if masked_a != masked_b {
1913                patch.ops.push(Op::SetMasked {
1914                    key,
1915                    masked: *masked_b,
1916                });
1917                patch.changed.insert(key);
1918            }
1919        }
1920        #[cfg(feature = "elements-checkbox")]
1921        (
1922            NodeKind::Checkbox {
1923                label: label_a,
1924                checked: checked_a,
1925                disabled: disabled_a,
1926            },
1927            NodeKind::Checkbox {
1928                label: label_b,
1929                checked: checked_b,
1930                disabled: disabled_b,
1931            },
1932        ) => {
1933            if label_a != label_b {
1934                patch.ops.push(Op::SetLabel {
1935                    key,
1936                    label: label_b.clone(),
1937                });
1938                patch.changed.insert(key);
1939            }
1940            if checked_a != checked_b {
1941                patch.ops.push(Op::SetChecked {
1942                    key,
1943                    checked: *checked_b,
1944                });
1945                patch.changed.insert(key);
1946            }
1947            if disabled_a != disabled_b {
1948                patch.ops.push(Op::SetDisabled {
1949                    key,
1950                    disabled: *disabled_b,
1951                });
1952                patch.changed.insert(key);
1953            }
1954        }
1955        #[cfg(feature = "elements-radio")]
1956        (
1957            NodeKind::Radio {
1958                label: label_a,
1959                value: value_a,
1960                selected: selected_a,
1961                disabled: disabled_a,
1962            },
1963            NodeKind::Radio {
1964                label: label_b,
1965                value: value_b,
1966                selected: selected_b,
1967                disabled: disabled_b,
1968            },
1969        ) => {
1970            if label_a != label_b {
1971                patch.ops.push(Op::SetLabel {
1972                    key,
1973                    label: label_b.clone(),
1974                });
1975                patch.changed.insert(key);
1976            }
1977            if value_a != value_b {
1978                patch.changed.insert(key);
1979            }
1980            if selected_a != selected_b {
1981                patch.ops.push(Op::SetSelected {
1982                    key,
1983                    selected: *selected_b,
1984                });
1985                patch.changed.insert(key);
1986            }
1987            if disabled_a != disabled_b {
1988                patch.ops.push(Op::SetDisabled {
1989                    key,
1990                    disabled: *disabled_b,
1991                });
1992                patch.changed.insert(key);
1993            }
1994        }
1995        #[cfg(feature = "elements-select")]
1996        (
1997            NodeKind::Select {
1998                value: value_a,
1999                options: options_a,
2000                disabled: disabled_a,
2001            },
2002            NodeKind::Select {
2003                value: value_b,
2004                options: options_b,
2005                disabled: disabled_b,
2006            },
2007        ) => {
2008            if value_a != value_b {
2009                patch.ops.push(Op::SetValue {
2010                    key,
2011                    value: value_b.clone(),
2012                });
2013                patch.changed.insert(key);
2014            }
2015            if options_a != options_b {
2016                patch.ops.push(Op::SetOptions {
2017                    key,
2018                    options: options_b.clone(),
2019                });
2020                patch.changed.insert(key);
2021            }
2022            if disabled_a != disabled_b {
2023                patch.ops.push(Op::SetDisabled {
2024                    key,
2025                    disabled: *disabled_b,
2026                });
2027                patch.changed.insert(key);
2028            }
2029        }
2030        (NodeKind::Column, NodeKind::Column)
2031        | (NodeKind::Row, NodeKind::Row)
2032        | (NodeKind::TitleBar, NodeKind::TitleBar)
2033        | (NodeKind::Window, NodeKind::Window) => {}
2034        _ => debug_assert!(false, "несовместимые типы должны фильтроваться раньше"),
2035    }
2036}
2037
2038fn diff_children(old: &VElement, new: &VElement, patch: &mut Patch) {
2039    let old_by_key: HashMap<&'static str, &VElement> = old
2040        .children
2041        .iter()
2042        .map(|child| (child.key, child))
2043        .collect();
2044    let mut matched = HashSet::new();
2045    for new_child in &new.children {
2046        match old_by_key.get(new_child.key) {
2047            Some(old_child) => {
2048                matched.insert(new_child.key);
2049                diff_node(old_child, new_child, patch);
2050            }
2051            None => {
2052                patch.ops.push(Op::Insert { key: new_child.key });
2053                patch.changed.insert(new_child.key);
2054            }
2055        }
2056    }
2057    for old_child in &old.children {
2058        if !matched.contains(old_child.key) {
2059            patch.ops.push(Op::Remove { key: old_child.key });
2060            patch.changed.insert(old_child.key);
2061        }
2062    }
2063}
2064
2065#[cfg(test)]
2066mod tests {
2067    use super::*;
2068
2069    #[test]
2070    fn parse_align_items_accepts_center() {
2071        assert_eq!(parse_align_items("center"), Align::Center);
2072        assert_eq!(parse_align_items("start"), Align::Start);
2073        assert_eq!(parse_align_items("end"), Align::End);
2074    }
2075
2076    #[test]
2077    fn invalid_align_items_returns_start_not_panic() {
2078        let result = std::panic::catch_unwind(|| {
2079            // Некорректное значение не должно вызывать panic (в debug-сборке —
2080            // раньше это был `debug_assert!`); ожидается warning в stderr и
2081            // возврат значения по умолчанию.
2082            parse_align_items("ыефке")
2083        });
2084        assert!(
2085            result.is_ok(),
2086            "parse_align_items panicked on invalid value"
2087        );
2088        assert_eq!(result.unwrap(), Align::Start);
2089    }
2090}