tauri-plugin-sys-locale 0.1.2

Tauri plugin to read the operating system's current locale/language
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

# tauri-plugin-sys-locale

A Tauri v2 plugin that reads the current operating system locale/language.
Works cross-platform (Windows, macOS, Linux, and thanks to the
`sys-locale` crate also iOS/Android), without needing any custom native
Swift/Kotlin code.

## 1. Installation (Rust side)

In your Tauri app's `Cargo.toml` (`src-tauri/Cargo.toml`):

```toml
[dependencies]
tauri-plugin-sys-locale = tauri-plugin-sys-locale = "*"
```

In `src-tauri/src/main.rs`:

```rust
fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_sys_locale::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}
```

## 2. Enable the capability

In `src-tauri/capabilities/default.json` (or whichever capability file
applies), add the permission:

```json
{
  "identifier": "default",
  "windows": ["main"],
  "permissions": ["sys-locale:default"]
}
```

## 3. Installation (frontend side)

```bash
npm install tauri-plugin-sys-locale-api
```

## 4. Usage in the frontend

```ts
import { getLocale, getLocaleInfo } from "tauri-plugin-sys-locale-api";

const locale = await getLocale();
console.log(locale); // e.g. "de-DE"

const info = await getLocaleInfo();
console.log(info.language); // e.g. "de"
```

## 5. Using the functions directly from Rust (no JS/`invoke` needed)

The core logic lives in plain `pub fn`s in `src/api.rs` (not tagged with
`#[tauri::command]`), so you can call them from any Rust code — inside a
Tauri command, a background task, `setup()`, etc. — without going through
the frontend at all:

```rust
use tauri_plugin_sys_locale::api;

fn some_backend_logic() {
    match api::get_locale() {
        Ok(locale) => println!("System locale: {locale}"),
        Err(e) => eprintln!("Could not determine locale: {e}"),
    }

    // or with locale + language split apart:
    if let Ok(info) = api::get_locale_info() {
        println!("locale={}, language={}", info.locale, info.language);
    }
}
```

You can even call it directly inside `main.rs`, e.g. to set an initial
window title or pick a translation file before the app finishes starting:

```rust
fn main() {
    let locale = tauri_plugin_sys_locale::api::get_locale()
        .unwrap_or_else(|_| "en-US".into());
    println!("Starting app with locale: {locale}");

    tauri::Builder::default()
        .plugin(tauri_plugin_sys_locale::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}
```

The `commands.rs` module just wraps these same functions with
`#[tauri::command]` so the frontend can reach them via `invoke()` — both
paths call identical logic.

## Why `sys-locale` instead of custom native code?

The `sys-locale` crate already wraps the platform-specific APIs:

- Windows: `GetUserDefaultLocaleName`
- macOS/iOS: `NSLocale`
- Linux: environment variables (`LANG`, `LC_ALL`, ...)
- Android: JNI call to `Locale.getDefault()`

That means you don't need a separate `android/` or `ios/` directory with
Kotlin/Swift code, unlike many other Tauri plugins.

## Building the JS bindings

```bash
npm install
npm run build
```

This compiles `guest-js/index.ts` into `dist-js/index.js`,
`dist-js/index.cjs`, and the corresponding `.d.ts` type declarations.