fn preflight_check(&self, locale: &str) -> Result<bool, ClientError> {
        // Check if we've already cached
        let mut cached_translator = self.cached_translator.borrow_mut();
        if cached_translator.is_some() && cached_translator.as_ref().unwrap().get_locale() == locale
        {
            Ok(false)
        } else {
            // Check if the locale is supported and we're actually using i18n
            if self.locales.is_supported(locale) && self.locales.using_i18n {
                // We're clear to fetch a translator for this locale
                Ok(true)
            } else if !self.locales.using_i18n {
                // If we aren't even using i18n, then it would be pointless to fetch
                // translations
                let translator = Translator::new("xx-XX".to_string(), "".to_string()).unwrap();
                // Cache that translator
                *cached_translator = Some(translator);
                // Now return that
                Ok(false)
            } else {
                // This is an internal total invariant (due to `match_route`)
                panic!("locale not supported (this is a bug)");
            }
        }
    }
An internal preflight check performed before getting a translator. This
consists of making sure the locale is supported, and that the app is
actually using i18n. If i18n is not being used, then this will
return a dummy translator on its own, and no further computation should
be performed. If you need to fetch a translator after calling this, then
you should be sure to cache it.

This will return `false` if the caller needs to take no further action
to set this translator, or `true` if it shoudl go ahead.

# Panics

This will panic if the given locale is not supported.
packages/perseus/src/i18n/client_translations_manager.rs