euv_ui/hook/i18n/

impl.rs

use super::*;

/// Returns the process-wide messages lock, initialising it
/// on first call.
///
/// All i18n reads and writes route through this helper so
/// the lazy-init logic stays in one place.
fn messages_lock() -> &'static RwLock<HashMap<String, HashMap<String, String>>> {
    I18N_MESSAGES.get_or_init(|| RwLock::new(HashMap::new()))
}

/// 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| 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| 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| 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 {
        let active: String = self.get_locale().get();
        let fallback: String = self.get_fallback_locale().get();
        let guard: std::sync::RwLockReadGuard<'static, HashMap<String, HashMap<String, String>>> =
            messages_lock().read().unwrap_or_else(|e| e.into_inner());
        if let Some(message) = guard
            .get(&active)
            .and_then(|m: &HashMap<String, String>| m.get(key))
        {
            return message.clone();
        }
        if let Some(message) = guard
            .get(&fallback)
            .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| 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 {
        let active: String = self.get_locale().get();
        let guard: std::sync::RwLockReadGuard<'static, HashMap<String, HashMap<String, String>>> =
            messages_lock().read().unwrap_or_else(|e| e.into_inner());
        guard
            .get(&active)
            .map(|m: &HashMap<String, String>| m.len())
            .unwrap_or_default()
    }
}