Localization

using Flowery.Localization;

// Switch to German
FloweryLocalization.SetCulture("de");

// Switch to Mandarin
FloweryLocalization.SetCulture("zh-CN");

using Flowery.Localization;

var codes = FloweryLocalization.SupportedLanguages;
var current = FloweryLocalization.CurrentCultureName;

for (var i = 0; i < codes.Count; i++)
{
    var code = codes[i];
    if (FloweryLocalization.LanguageDisplayNames.TryGetValue(code, out var name))
    {
        // Use code and name in your UI
    }
}

<ScrollViewer DataContext="{x:Bind Localization, Mode=OneWay}">
    <TextBlock Text="{Binding [Gallery_DataInput_Variants]}" />
</ScrollViewer>

<TextBlock Text="{Binding [Gallery_DataInput_Variants], Source={x:Bind Localization}}" />

// In your page/control that uses {Binding [Key]} with a Localization DataContext.
Loaded += (_, _) => FloweryLocalization.CultureChanged += OnCultureChanged;
Unloaded += (_, _) => FloweryLocalization.CultureChanged -= OnCultureChanged;

private void OnCultureChanged(object? sender, string cultureName)
{
    RootElement.DataContext = null;
    RootElement.DataContext = Localization;
}

<daisy:DaisyDateTimeline Locale="de-DE" />

using System.Globalization;

timeline.Locale = CultureInfo.GetCultureInfo(FloweryLocalization.CurrentCultureName);

<ItemGroup>
  <EmbeddedResource Include="Localization\\en.json" />
  <EmbeddedResource Include="Localization\\de.json" />
  <EmbeddedResource Include="Localization\\ja.json" />
  <!-- Add all other languages -->
</ItemGroup>

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Text.Json;
using System.Text.Json.Serialization;

public class MyAppLocalization : INotifyPropertyChanged
{
    private static CultureInfo _currentCulture = CultureInfo.CurrentUICulture;
    private static readonly Dictionary<string, Dictionary<string, string>> _translations = new();
    private static readonly Lazy<MyAppLocalization> _instance = new(() => new MyAppLocalization());

    public static MyAppLocalization Instance => _instance.Value;
    public static event EventHandler<CultureInfo>? CultureChanged;
    public event PropertyChangedEventHandler? PropertyChanged;

    static MyAppLocalization()
    {
        // Load all translations at startup - use library's centralized list
        foreach (var lang in Flowery.Localization.FloweryLocalization.SupportedLanguages)
            LoadTranslation(lang);

        // Sync with Flowery library culture changes
        Flowery.Localization.FloweryLocalization.CultureChanged += (s, c) => SetCulture(c);
    }

    // Indexer for XAML binding
    public string this[string key] => GetString(key);

    public static void SetCulture(CultureInfo culture)
    {
        if (_currentCulture.Name == culture.Name) return;
        _currentCulture = culture;
        CultureChanged?.Invoke(null, culture);
        Instance.PropertyChanged?.Invoke(Instance, new PropertyChangedEventArgs("Item"));
        Instance.PropertyChanged?.Invoke(Instance, new PropertyChangedEventArgs("Item[]"));
    }

    public static string GetString(string key)
    {
        // Try exact culture (e.g., "de-DE")
        if (_translations.TryGetValue(_currentCulture.Name, out var exact) && exact.TryGetValue(key, out var v1))
            return v1;

        // Try language only (e.g., "de")
        var lang = _currentCulture.TwoLetterISOLanguageName;
        if (_translations.TryGetValue(lang, out var langDict) && langDict.TryGetValue(key, out var v2))
            return v2;

        // Fallback to English
        if (_translations.TryGetValue("en", out var en) && en.TryGetValue(key, out var v3))
            return v3;

        return key; // Return key if not found
    }

    private static void LoadTranslation(string langCode)
    {
        var assembly = Assembly.GetExecutingAssembly();
        var resourceName = $"YourApp.Localization.{langCode}.json";

        using var stream = assembly.GetManifestResourceStream(resourceName);
        if (stream == null) return;

        using var reader = new StreamReader(stream);
        var json = reader.ReadToEnd();

        // Use source generator for AOT compatibility
        var dict = JsonSerializer.Deserialize(json, LocalizationJsonContext.Default.DictionaryStringString);
        if (dict != null) _translations[langCode] = dict;
    }
}

// REQUIRED: JSON Source Generator for AOT/WASM compatibility
[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata)]
[JsonSerializable(typeof(Dictionary<string, string>))]
internal partial class LocalizationJsonContext : JsonSerializerContext { }

<ItemGroup>
  <Content Include="Assets\\Fonts\\NotoSansJP-Regular.otf" />
  <Content Include="Assets\\Fonts\\NotoSansSC-Regular.otf" />
  <Content Include="Assets\\Fonts\\NotoSansKR-Regular.otf" />
</ItemGroup>

<Application.Resources>
    <FontFamily x:Key="NotoSansFamily">ms-appx:///Assets/Fonts/NotoSansJP-Regular.otf#Noto Sans JP</FontFamily>
</Application.Resources>

<Application.Resources>
    <Style TargetType="TextBlock">
        <Setter Property="FontFamily" Value="{StaticResource NotoSansFamily}" />
    </Style>
    <Style TargetType="TextBox">
        <Setter Property="FontFamily" Value="{StaticResource NotoSansFamily}" />
    </Style>
    <!-- Add other text controls as needed -->
</Application.Resources>

// In your app's localization setup or App startup:
FloweryLocalization.CustomResolver = MyAppLocalization.GetString;

public class MainViewModel : ViewModelBase
{
    public MainViewModel()
    {
        FloweryLocalization.CultureChanged += (s, culture) =>
        {
            OnPropertyChanged(nameof(Greeting));
        };
    }

    public string Greeting => FloweryLocalization.GetString("Greeting_Text");
}