euv-ui 0.18.22

Reusable UI component library for the euv framework, providing buttons, cards, modals, inputs, and more.
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

use super::*;

/// Interpolates `{name}`-style placeholders in `template` from the
/// supplied `vars` map.
///
/// Walks the template once and replaces every `{key}` segment whose
/// key is present in `vars`. Placeholders whose key is missing are
/// left as the literal `{key}` token — matching the i18next
/// default behaviour. No escaping is performed: callers that need
/// it must escape themselves.
///
/// Returns the interpolated `String`. Empty / no-placeholder
/// templates round-trip unchanged.
///
/// # Arguments
///
/// - `&str` - The template containing `{key}` placeholders.
/// - `&HashMap<&'static str, &'static str>` - The variable map. A
///   static-borrowed key list is enough because the typical
///   consumer (`I18n::t_with`) builds the map inline.
///
/// # Returns
///
/// - `String` - The interpolated string.
pub(crate) fn interpolate(template: &str, vars: &HashMap<&'static str, &'static str>) -> String {
    let mut result: String = String::new();
    let bytes: &[u8] = template.as_bytes();
    let mut cursor: usize = 0_usize;
    while cursor < bytes.len() {
        if bytes[cursor] == b'{'
            && cursor + 1_usize < bytes.len()
            && bytes[cursor + 1_usize] != b'{'
        {
            // Look for the matching `}`.
            if let Some(close_rel) = template[cursor + 1_usize..].find('}') {
                let close: usize = cursor + 1_usize + close_rel;
                let key: &str = &template[cursor + 1_usize..close];
                if let Some(value) = vars.get(key) {
                    result.push_str(value);
                } else {
                    // Preserve the original `{key}` placeholder.
                    result.push('{');
                    result.push_str(key);
                    result.push('}');
                }
                cursor = close + 1_usize;
                continue;
            }
        }
        // Append the current char and move on. Works for ASCII;
        // multi-byte UTF-8 falls through as-is because `result.push`
        // re-encodes the byte at the cursor position.
        if let Some(ch) = template[cursor..].chars().next() {
            result.push(ch);
            cursor += ch.len_utf8();
        } else {
            break;
        }
    }
    result
}

/// Obtains the i18n handle registered against the current hook context slot.
///
/// Behaves like `HookContext::use_hook`: the same `I18n` is returned
/// on every render at the same hook index, preserving the locale,
/// fallback locale, and message table across renders.
///
/// The initial `locale` defaults to `"en"`; pass `init_locale` to
/// change it on the first render. Call [`I18n::add_messages`] to
/// register translations under each locale tag.
///
/// # Arguments
///
/// - `&str` - The initial locale tag. Defaults to `"en"` if the
///   empty string is supplied (so a wrapper can pass `""` to adopt
///   the default).
///
/// # Returns
///
/// - `I18n` - The i18n handle.
///   Returns the factory result directly when no hook context is
///   active (e.g. when called outside a render cycle).
pub fn use_i18n(init_locale: &str) -> I18n {
    let locale: &str = if init_locale.is_empty() {
        "en"
    } else {
        init_locale
    };
    HookContext::use_hook(move || {
        I18n::new(
            Signal::create(locale.to_string()),
            Signal::create(String::from("en")),
            Signal::create(HashMap::new()),
        )
    })
}

/// Registers a translation `key -> message` under `locale` on the
/// supplied i18n handle.
///
/// Pair with [`use_i18n`]: the typical pattern is to call this in
/// an `App::use_cleanup`-style mount phase so the same translations
/// stay registered across renders.
///
/// The `&'static` lifetime bound matches the internal
/// `MessageEntry` type alias (`(&'static str, &'static str)`);
/// in practice the call site passes an array literal that the
/// compiler naturally satisfies from string-literal promotion.
///
/// # Arguments
///
/// - `I18n` - The i18n handle obtained from `use_i18n()`.
/// - `&str` - The locale tag (e.g. `"en"`, `"zh-CN"`).
/// - `&[(&'static str, &'static str)]` - The `(key, message)` pairs.
///   Internally forwarded as `&[MessageEntry]`.
///
/// # Panics
///
/// This function does not panic.
pub fn i18n_register(handle: I18n, locale: &str, entries: &[(&'static str, &'static str)]) {
    handle.add_messages(locale, entries);
}