euv_ui/hook/i18n/

impl.rs

use super::*;

/// Implements [`HookContextI18nExt`] for [`HookContext`].
impl HookContextI18nExt for HookContext {
    /// Returns a fresh [`I18n`] bound to the current component scope.
    ///
    /// # Returns
    ///
    /// - `I18n` - A `I18n` value.
    fn i18n() -> I18n {
        HookContext::use_hook(|| {
            I18n::new(
                Signal::create(String::from("en")),
                Signal::create(String::from("en")),
            )
        })
    }
}

/// Inherent implementation of [`I18n`].
impl I18n {
    /// Sets the active locale to `locale`. Triggers a
    /// reactive update so any reactive `t(key)` read
    /// re-evaluates.
    ///
    /// Named `change_locale` (not `set_locale`) to avoid
    /// colliding with the `set_locale` getter generated by
    /// `#[derive(Data)]` on the struct field.
    ///
    /// # Arguments
    ///
    /// - `&str` - Shared reference to a `str`.
    pub fn change_locale(&self, locale: &str) {
        self.get_locale().set(locale.to_string());
    }

    /// Sets the fallback locale. Trigger a reactive
    /// update for any `t(key)` whose key is missing in
    /// the active locale — they may now resolve to a
    /// different fallback value.
    ///
    /// Named `change_fallback_locale` (not
    /// `set_fallback_locale`) for the same reason as
    /// `change_locale`.
    ///
    /// # Arguments
    ///
    /// - `&str` - Shared reference to a `str`.
    pub fn change_fallback_locale(&self, locale: &str) {
        self.get_fallback_locale().set(locale.to_string());
    }

    /// Adds a batch of `(key, message)` entries to the
    /// translation table for `locale`. Existing entries
    /// for that locale are overwritten (last-write-wins).
    ///
    /// OPT 22 (tail): writes through the process-wide
    /// [`I18N_MESSAGES`] lock instead of cloning the whole
    /// table out of a `Signal` and re-setting it.
    ///
    /// # Arguments
    ///
    /// - `&str` - Shared reference to a `str`.
    /// - `&[MessageEntry]` - Shared reference to a `[MessageEntry]`.
    pub fn add_messages(&self, locale: &str, entries: &[MessageEntry]) {
        let mut guard: std::sync::RwLockWriteGuard<
            'static,
            HashMap<String, HashMap<String, String>>,
        > = messages_lock().write().unwrap_or_else(
            |e: std::sync::PoisonError<
                std::sync::RwLockWriteGuard<'static, HashMap<String, HashMap<String, String>>>,
            >| e.into_inner(),
        );
        let entry_map: &mut HashMap<String, String> = guard.entry(locale.to_string()).or_default();
        for (key, value) in entries {
            entry_map.insert((*key).to_string(), (*value).to_string());
        }
    }

    /// Removes every entry for `locale`. After this
    /// call, `t(key)` for any key will skip this locale
    /// in its lookup chain.
    ///
    /// OPT 22 (tail): see `add_messages` — writes through
    /// the static lock.
    ///
    /// # Arguments
    ///
    /// - `&str` - Shared reference to a `str`.
    pub fn remove_locale(&self, locale: &str) {
        let mut guard: std::sync::RwLockWriteGuard<
            'static,
            HashMap<String, HashMap<String, String>>,
        > = messages_lock().write().unwrap_or_else(
            |e: std::sync::PoisonError<
                std::sync::RwLockWriteGuard<'static, HashMap<String, HashMap<String, String>>>,
            >| e.into_inner(),
        );
        guard.remove(locale);
    }

    /// Removes a single message from a locale. After this
    /// call, `t(key)` for this key in this locale will
    /// fall back to `fallback_locale`.
    ///
    /// OPT 22 (tail): see `add_messages` — writes through
    /// the static lock.
    ///
    /// # Arguments
    ///
    /// - `&str` - Shared reference to a `str`.
    /// - `&str` - Shared reference to a `str`.
    pub fn remove_message(&self, locale: &str, key: &str) {
        let mut guard: std::sync::RwLockWriteGuard<
            'static,
            HashMap<String, HashMap<String, String>>,
        > = messages_lock().write().unwrap_or_else(
            |e: std::sync::PoisonError<
                std::sync::RwLockWriteGuard<'static, HashMap<String, HashMap<String, String>>>,
            >| e.into_inner(),
        );
        if let Some(entry_map) = guard.get_mut(locale) {
            entry_map.remove(key);
        }
    }

    /// Translates `key` to a string under the active
    /// locale, falling back to `fallback_locale` if the
    /// active locale has no entry. Returns `key` itself
    /// if neither locale has an entry (debug-friendly).
    ///
    /// This is the reactive read — calling it inside a
    /// render closure subscribes that closure to locale
    /// changes. The messages table itself is not reactive
    /// (it lives behind [`I18N_MESSAGES`]).
    ///
    /// OPT 22 (tail): previously the read cloned the
    /// entire translation table out of a `Signal` on every
    /// call (a `HashMap<String, HashMap<String, String>>`
    /// per `t()`). Now the read takes the read guard and
    /// clones at most a single `String` (the message
    /// itself) before dropping the guard.
    ///
    /// # Arguments
    ///
    /// - `&str` - Shared reference to a `str`.
    ///
    /// # Returns
    ///
    /// - `String` - A `String` value.
    pub fn t(&self, key: &str) -> String {
        // Borrow both locale signals via `Signal::with` instead of paying
        // two `String` clones per call (per `t()` per render).
        self.get_locale().with(|active: &String| {
            self.get_fallback_locale().with(|fallback: &String| {
                let guard: std::sync::RwLockReadGuard<
                    'static,
                    HashMap<String, HashMap<String, String>>,
                > = messages_lock().read().unwrap_or_else(
                    |e: std::sync::PoisonError<
                        std::sync::RwLockReadGuard<
                            'static,
                            HashMap<String, HashMap<String, String>>,
                        >,
                    >| e.into_inner(),
                );
                if let Some(message) = guard
                    .get(active.as_str())
                    .and_then(|m: &HashMap<String, String>| m.get(key))
                {
                    return message.clone();
                }
                if let Some(message) = guard
                    .get(fallback.as_str())
                    .and_then(|m: &HashMap<String, String>| m.get(key))
                {
                    return message.clone();
                }
                key.to_string()
            })
        })
    }

    /// Translates `key` and substitutes `{name}`-style
    /// placeholders from `vars`.
    ///
    /// Placeholders that are present in `vars` are
    /// replaced with their corresponding value.
    /// Placeholders that are missing from `vars` are left
    /// as the literal `{name}` token — matching the
    /// i18next default behavior. No escaping is
    /// supported; add it when a real use case shows up.
    ///
    /// # Arguments
    ///
    /// - `&str` - Shared reference to a `str`.
    /// - `&HashMap<&'static str, &'static str>` - Shared reference to a `HashMap<&'static str, &'static str>`.
    ///
    /// # Returns
    ///
    /// - `String` - A `String` value.
    pub fn t_with(&self, key: &str, vars: &HashMap<&'static str, &'static str>) -> String {
        let template: String = self.t(key);
        interpolate(&template, vars)
    }

    /// Returns the number of locales currently registered
    /// (i.e. the number of distinct keys in the messages
    /// map's outer level).
    ///
    /// OPT 22 (tail): borrows through [`I18N_MESSAGES`]
    /// read guard instead of cloning the whole table.
    ///
    /// # Returns
    ///
    /// - `usize` - Count of registered locales.
    pub fn locale_count(&self) -> usize {
        let guard: std::sync::RwLockReadGuard<'static, HashMap<String, HashMap<String, String>>> =
            messages_lock().read().unwrap_or_else(
                |e: std::sync::PoisonError<
                    std::sync::RwLockReadGuard<'static, HashMap<String, HashMap<String, String>>>,
                >| e.into_inner(),
            );
        guard.len()
    }

    /// Returns the number of messages registered for the
    /// active locale.
    ///
    /// OPT 22 (tail): borrows through [`I18N_MESSAGES`]
    /// read guard instead of cloning the whole table.
    ///
    /// # Returns
    ///
    /// - `usize` - Count of currently-registered messages.
    pub fn active_message_count(&self) -> usize {
        self.get_locale().with(|active: &String| {
            let guard: std::sync::RwLockReadGuard<
                'static,
                HashMap<String, HashMap<String, String>>,
            > = messages_lock().read().unwrap_or_else(
                |e: std::sync::PoisonError<
                    std::sync::RwLockReadGuard<'static, HashMap<String, HashMap<String, String>>>,
                >| e.into_inner(),
            );
            guard
                .get(active.as_str())
                .map(|m: &HashMap<String, String>| m.len())
                .unwrap_or_default()
        })
    }
}

/// `I18n` is `Copy` because every remaining field is a
/// `Signal`, which is already `Copy` — the registry hands
/// out cheap `usize` addresses for any `T: Clone + PartialEq
/// + 'static`.
impl Copy for I18n {}