euv 0.1.1

A declarative, cross-platform UI framework for Rust with virtual DOM, reactive signals, and RSX macros for WebAssembly.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use crate::*;

/// Represents the type of an HTML tag or a component.
///
/// Distinguishes between standard HTML elements and user-defined components.
#[derive(Clone)]
pub enum Tag {
    /// A standard HTML element identified by its tag name.
    Element(String),
    /// A custom component type.
    Component(String),
}

/// Represents the name of an HTML attribute or DOM property.
///
/// Covers common HTML attributes, accessibility attributes, and custom data attributes.
#[derive(Clone)]
pub enum Attribute {
    /// The accesskey attribute.
    AccessKey,
    /// The action attribute for forms.
    Action,
    /// The alt attribute for images.
    Alt,
    /// The aria-label accessibility attribute.
    AriaLabel,
    /// The autocomplete attribute.
    AutoComplete,
    /// The autofocus attribute.
    AutoFocus,
    /// The checked attribute for checkboxes/radios.
    Checked,
    /// The class attribute.
    Class,
    /// The cols attribute for textareas.
    Cols,
    /// The contenteditable attribute.
    ContentEditable,
    /// The data-* custom attribute.
    Data(String),
    /// The dir attribute.
    Dir,
    /// The disabled attribute.
    Disabled,
    /// The draggable attribute.
    Draggable,
    /// The enctype attribute for forms.
    EncType,
    /// The for attribute for labels.
    For,
    /// The form attribute.
    Form,
    /// The height attribute.
    Height,
    /// The hidden attribute.
    Hidden,
    /// The href attribute for links.
    Href,
    /// The id attribute.
    Id,
    /// The lang attribute.
    Lang,
    /// The max attribute.
    Max,
    /// The maxlength attribute.
    MaxLength,
    /// The method attribute for forms.
    Method,
    /// The min attribute.
    Min,
    /// The minlength attribute.
    MinLength,
    /// The multiple attribute for selects.
    Multiple,
    /// The name attribute.
    Name,
    /// The pattern attribute for inputs.
    Pattern,
    /// The placeholder attribute.
    Placeholder,
    /// The readonly attribute.
    ReadOnly,
    /// The required attribute.
    Required,
    /// The rows attribute for textareas.
    Rows,
    /// The selected attribute for options.
    Selected,
    /// The size attribute.
    Size,
    /// The spellcheck attribute.
    SpellCheck,
    /// The src attribute for media/images.
    Src,
    /// The step attribute.
    Step,
    /// The style attribute.
    Style,
    /// The tabindex attribute.
    TabIndex,
    /// The target attribute for links/forms.
    Target,
    /// The title attribute.
    Title,
    /// The type attribute for inputs.
    Type,
    /// The value attribute.
    Value,
    /// The width attribute.
    Width,
    /// A custom attribute with an arbitrary name.
    Other(String),
}

/// Represents the value of an HTML attribute.
///
/// Attributes can be static text, reactive signals, event handlers, dynamic expressions,
/// or CSS class references.
#[derive(Clone)]
pub enum AttributeValue {
    /// A static string value.
    Text(String),
    /// A dynamic signal-backed value.
    Signal(Signal<String>),
    /// An event handler callback.
    Event(crate::event::NativeEventHandler),
    /// A dynamic expression value of any type (for component props).
    Dynamic(String),
    /// A CSS class reference created by the `class!` macro.
    Css(CssClass),
}

/// Represents a node in the virtual DOM tree.
///
/// The core enum representing elements, text, fragments, and empty nodes.
#[derive(Clone, Default)]
pub enum VirtualNode {
    /// An element node with a tag, attributes, and children.
    Element {
        /// The tag type of this element.
        tag: Tag,
        /// The attributes attached to this element.
        attributes: Vec<AttributeEntry>,
        /// The child nodes.
        children: Vec<VirtualNode>,
        /// An optional key for diffing.
        key: Option<String>,
    },
    /// A text node.
    Text(TextNode),
    /// A fragment of multiple nodes without a wrapper element.
    Fragment(Vec<VirtualNode>),
    /// A dynamic node that re-renders based on signal changes.
    Dynamic(DynamicNode),
    /// An empty placeholder node.
    #[default]
    Empty,
}