euv-core 0.18.21

A declarative, cross-platform UI framework for Rust with virtual DOM, reactive signals, and HTML 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

use super::*;

#[test]
fn inner_html_static_carries_string_payload() {
    let attr: AttributeValue = AttributeValue::InnerHtml(String::from("<svg/>"));
    match &attr {
        AttributeValue::InnerHtml(s) => assert_eq!(s, "<svg/>"),
        _ => panic!("expected AttributeValue::InnerHtml"),
    }
    let cloned: AttributeValue = attr.clone();
    match cloned {
        AttributeValue::InnerHtml(s) => assert_eq!(s, "<svg/>"),
        _ => panic!("cloned value lost its InnerHtml variant"),
    }
}

#[test]
fn inner_html_signal_carries_signal_payload() {
    let signal: Signal<String> = Signal::create(String::from("<b>hi</b>"));
    let attr: AttributeValue = AttributeValue::InnerHtmlSignal(signal);
    match &attr {
        AttributeValue::InnerHtmlSignal(s) => {
            assert_eq!(s.get(), "<b>hi</b>");
        }
        _ => panic!("expected AttributeValue::InnerHtmlSignal"),
    }
}

#[test]
fn debug_names_inner_html_variant() {
    let static_attr: AttributeValue = AttributeValue::InnerHtml(String::from("payload"));
    let formatted: String = format!("{static_attr:?}");
    assert!(
        formatted.contains("InnerHtml"),
        "Debug output must name the variant, got: {formatted}",
    );
    let signal: Signal<String> = Signal::create(String::from("hidden-signal-value"));
    let reactive_attr: AttributeValue = AttributeValue::InnerHtmlSignal(signal);
    let formatted: String = format!("{reactive_attr:?}");
    assert!(
        formatted.contains("InnerHtmlSignal"),
        "Debug output must name the variant, got: {formatted}",
    );
    assert!(
        !formatted.contains("hidden-signal-value"),
        "Debug output leaked the signal payload: {formatted}",
    );
}

#[test]
fn inner_html_adapter_from_str_copies_payload() {
    let adapter: InnerHtmlAdapter<&str> = InnerHtmlAdapter::new("<i>copied</i>");
    let attr: AttributeValue = adapter.into();
    match attr {
        AttributeValue::InnerHtml(s) => assert_eq!(s, "<i>copied</i>"),
        _ => panic!("InnerHtmlAdapter<&str> did not produce InnerHtml"),
    }
}

#[test]
fn inner_html_adapter_from_string_passes_through() {
    let payload: String = String::from("<b>kept</b>");
    let adapter: InnerHtmlAdapter<String> = InnerHtmlAdapter::new(payload);
    let attr: AttributeValue = adapter.into();
    match attr {
        AttributeValue::InnerHtml(s) => assert_eq!(s, "<b>kept</b>"),
        _ => panic!("InnerHtmlAdapter<String> did not produce InnerHtml"),
    }
}

#[test]
fn inner_html_adapter_from_signal_produces_signal_variant() {
    let signal: Signal<String> = Signal::create(String::from("<div/>"));
    let adapter: InnerHtmlAdapter<Signal<String>> = InnerHtmlAdapter::new(signal);
    let attr: AttributeValue = adapter.into();
    match attr {
        AttributeValue::InnerHtmlSignal(s) => {
            assert_eq!(s.get(), "<div/>");
        }
        _ => panic!("InnerHtmlAdapter<Signal<String>> did not produce InnerHtmlSignal"),
    }
}

#[test]
fn existing_variants_still_construct() {
    let text: AttributeValue = AttributeValue::Text(String::from("ok"));
    assert!(matches!(text, AttributeValue::Text(_)));
    let signal: AttributeValue = AttributeValue::Signal(Signal::create(String::from("ok")));
    assert!(matches!(signal, AttributeValue::Signal(_)));
    let dynamic: AttributeValue = AttributeValue::Dynamic(String::from("ok"));
    assert!(matches!(dynamic, AttributeValue::Dynamic(_)));
}