use icu_provider::DataLocale;
// Public re-exports of dependencies required at runtime, so macro-generated code
// can find all the dependencies it expects as long as this crate exists
pub use icu_locid::{self, langid, LanguageIdentifier};
pub use icu_plurals::{self, PluralRuleType, PluralRules};
pub use locale_select;
pub trait Localize {
    const CANONICAL_LOCALE: LanguageIdentifier;
    fn localize(&self) -> String;
}
/// Select which locale to use, falling back to the canonical locale if nothing matches
pub fn select_locale(
    available_locales: &[LanguageIdentifier],
    canonical_locale: &LanguageIdentifier,
) -> LanguageIdentifier {
    locale_select::match_locales(available_locales, canonical_locale)
}
pub fn plural_rules(
    locale: &LanguageIdentifier,
    rule_type: PluralRuleType,
) -> Result<PluralRules, icu_plurals::Error> {
    let data_locale = DataLocale::from(locale);
    PluralRules::try_new(&data_locale, rule_type)
}

[package]
name = "fluent_embed_runtime"
version = "0.1.0"
edition = "2021"
[lints]
workspace = true
[dependencies]
icu_locid = "1.4.0"
icu_plurals = "1.4.0"
icu_provider = "1.4.0"
locale_select = { path = "../locale_select" }

    let canonical_locale = group.canonical_locale().id.clone().to_string();

        impl #ident {
            // TODO: most of this shouldn't be generated on every call

        impl ::fluent_embed_runtime::Localize for #ident {
            const CANONICAL_LOCALE: ::fluent_embed_runtime::icu_locid::LanguageIdentifier =
                ::fluent_embed_runtime::icu_locid::langid!(#canonical_locale);

                                    parse_quote!(::icu_plurals::PluralCategory::#ident)

                                    parse_quote!(::fluent_embed_runtime::icu_plurals::PluralCategory::#ident)

    let canonical_locale = group.canonical_locale().id.to_string();

        // Find the appropriate locale to use
        let additional_locales = [#(::icu_locid::langid!(#additional_locales)),*];
        let canonical_locale = ::icu_locid::langid!(#canonical_locale);
        let locale = ::locale_select::match_locales(&additional_locales, &canonical_locale);

        // Create a list of available locales to choose from
        let available_locales = [
            // The canonical locale will always be available
            Self::CANONICAL_LOCALE,
            // Any additional locales that contain this message
            #(::fluent_embed_runtime::langid!(#additional_locales)),*
        ];
        let locale = ::fluent_embed_runtime::select_locale(&available_locales, &Self::CANONICAL_LOCALE);

        let plural_rule_type = ::icu_plurals::PluralRuleType::Cardinal;
        let plural_rules = ::icu_plurals::PluralRules::try_new(&locale.clone().into(), plural_rule_type).unwrap();

        // TODO: only generate this when needed in message
        const plural_rule_type: ::fluent_embed_runtime::PluralRuleType =
            ::fluent_embed_runtime::PluralRuleType::Cardinal;
        let plural_rules = ::fluent_embed_runtime::plural_rules(&locale, plural_rule_type).unwrap();

        // Handle any additional locales

        // Fall back to the canonical locale, if no other valid locale was matched

use fluent_embed_runtime::Localize;

icu_locid = "1.4.0"
icu_plurals = "1.4.0"
locale_select = { path = "../locale_select" }

fluent_embed_runtime = { path = "../fluent_embed_runtime" }

members = ["fluent_embed", "output-macros", "cli_macros", "locale_select"]

members = ["fluent_embed", "output-macros", "cli_macros", "locale_select", "fluent_embed_runtime"]

 "icu_locid",
 "icu_plurals",
 "locale_select",

 "fluent_embed_runtime",

]
[[package]]
name = "fluent_embed_runtime"
version = "0.1.0"
dependencies = [
 "icu_locid",
 "icu_plurals",
 "icu_provider",
 "locale_select",

version = "1.13.1"

version = "1.13.2"

checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"

checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"