Slang

https://pub.dev/packages/slang
Admin
Slang is a localization and internationalization (i18n) solution that uses JSON, YAML, CSV, or ARB...
Tokens:27,546
Snippets:354
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Namespace File Structure Example

Source: https://pub.dev/packages/slang

Example of how to organize namespace files in a flat directory structure.

```text
i18n/
 └── widgets_en.i18n.json
 └── widgets_fr.i18n.json
 └── errorDialogs_en.i18n.json <-- camel case for multiple words
 └── errorDialogs_fr.i18n.json
```

--------------------------------

### Install slang_mcp globally

Source: https://pub.dev/packages/slang_mcp/install

Use the Dart pub global activate command to install the package as an executable.

```bash
dart pub global activate slang_mcp
```

--------------------------------

### Compact CSV Example

Source: https://pub.dev/packages/slang

A concrete example of a compact CSV file with multiple locales.

```csv
key,en,de-DE
welcome.title,Welcome $name,Willkommen $name
welcome.button,Start,Start
```

```text
assets/
 └── i18n/
      └── strings.i18n.csv <-- contains all locales
```

--------------------------------

### Namespace Folder Structure Example

Source: https://pub.dev/packages/slang

Namespaces can also be organized into different folders.

```text
i18n/
 └── widgets/
      └── widgets_en.i18n.json
      └── widgets_fr.i18n.json
 └── errorDialogs/
      └── errorDialogs_en.i18n.json
      └── errorDialogs_fr.i18n.json
```

--------------------------------

### Example English translation file

Source: https://pub.dev/packages/slang

A sample JSON translation file for English.

```json
// File: en.i18n.json
{
  "hello": "Hello $name",
  "save": "Save",
  "login": {
    "success": "Logged in successfully",
    "fail": "Logged in failed"
  }
}
```

--------------------------------

### JSON translation file example

Source: https://pub.dev/packages/slang

The default file format for translation strings.

```json
{
  "welcome": {
    "title": "Welcome $name"
  }
}
```

--------------------------------

### Example German translation file

Source: https://pub.dev/packages/slang

A sample JSON translation file for German.

```json
// File: de.i18n.json
{
  "hello": "Hallo $name",
  "save": "Speichern",
  "login": {
    "success": "Login erfolgreich",
    "fail": "Login fehlgeschlagen"
  }
}
```

--------------------------------

### Install slang MCP server from source

Source: https://pub.dev/packages/slang_mcp

Clone the repository and activate the package globally using dart pub.

```bash
dart pub global activate --source path .
```

--------------------------------

### Wildcard Locale File Structure

Source: https://pub.dev/packages/slang

Example of using wildcard syntax for locale files.

```text
i18n/
 └── de.json
 └── en.json
 └── fr.json
 └── [de,fr,ja].json
 └── [any]-FR.json
```

--------------------------------

### YAML translation file example

Source: https://pub.dev/packages/slang

YAML provides a compact syntax with support for multiline strings and comments.

```yaml
welcome:
  title: Welcome $name # some comment
```

--------------------------------

### Region Extensions Configuration

Source: https://pub.dev/packages/slang

Example of how language-only locales fallback to region-specific locales.

```text
en.json
en-US.json -> en.json
en-GB.json -> en.json
fr.json -> en.json (depends on fallback_strategy)
fr-CA.json -> fr.json (always) -> en.json (depends on fallback_strategy)
```

--------------------------------

### Example directory structure for i18n files

Source: https://pub.dev/packages/slang

Common directory structure for storing translation files.

```text
lib/
 └── i18n/
      └── en.i18n.json
      └── de.i18n.json
      └── zh-CN.i18n.json <-- example for country code
```

--------------------------------

### Pluralization detection example

Source: https://pub.dev/packages/slang

Example of a JSON node that is not treated as a pluralization due to an unknown keyword.

```json
{
  "fake": {
    "one": "One apple",
    "two": "Two apples",
    "three": "Three apples" // unknown key word 'three', 'fake' is not a pluralization
  }
}
```

--------------------------------

### Accessing Root and Namespaced Translations

Source: https://pub.dev/packages/slang

Example of accessing both root and namespaced translations.

```dart
String a = t.appName; // from _default namespace
String b = t.widgets.welcomeCard.title; // from widgets namespace
```

--------------------------------

### ARB input and JSON result

Source: https://pub.dev/packages/slang

An example of an ARB input file and the resulting JSON output after migration.

```json
{
  "@@locale": "en_US",
  "@@context": "HomePage",
  "title_bar": "My Cool Home",
  "@title_bar": {
    "type": "text",
    "context": "HomePage",
    "description": "Page title."
  },
  "FOO_123": "Your pending cost is {COST}",
  "foo456": "Hello {0}",
  "pageHomeInboxCount" : "{count, plural, zero{You have no new messages} one{You have 1 new message} other{You have {count} new messages}}",
  "@pageHomeInboxCount" : {
    "placeholders": {
      "count": {}
    }
  }
}
```

```json
{
  "@@locale": "en_US",
  "@@context": "HomePage",
  "title": {
    "bar": "My Cool Home",
    "@bar": "Page title."
  },
  "foo123": "Your pending cost is {cost}",
  "foo456": "Hello {arg0}",
  "page": {
    "home": {
      "inbox": {
        "count(param=count)": {
          "zero": "You have no new messages",
          "one": "You have 1 new message",
          "other": "You have {count} new messages"
        }
      }
    }
  }
}
```

--------------------------------

### Generated Comment Output

Source: https://pub.dev/packages/slang

Example of how comments appear in the generated Dart file.

```dart
/// The submit button shown at the bottom
String get button => 'Submit';
```

--------------------------------

### Invoke slang_mcp executable

Source: https://pub.dev/packages/slang_mcp/install

Run the installed slang_mcp executable from the command line.

```bash
$ slang_mcp
```

--------------------------------

### Use Riverpod for translation injection

Source: https://pub.dev/packages/slang

Example of managing translation instances using the Riverpod library.

```dart
final english = AppLocale.en.buildSync();
final german = AppLocale.de.buildSync();
final translationProvider = StateProvider<Translations>((ref) => german); // set it

// access the current instance
final t = ref.watch(translationProvider);
String a = t.welcome.title; // get translation
AppLocale locale = t.$meta.locale; // get locale
```

--------------------------------

### Nested Namespace Structure

Source: https://pub.dev/packages/slang

Example of deeply nested namespaces using directory locales.

```text
i18n/
 └── en/
      └── widgets/
           └── welcomeCard.json
           └── profileCard.json
      └── errorDialogs/
           └── login.json
           └── network.json
```

--------------------------------

### Initialize and Use slang in Flutter

Source: https://pub.dev/packages/slang/example

This example demonstrates how to initialize the TranslationProvider, set the device locale, and access translations within a Flutter application.

```dart
import 'package:example/i18n/strings.g.dart';
import 'package:flutter/material.dart';
import 'package:flutter_localizations/flutter_localizations.dart';

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  LocaleSettings.useDeviceLocale(); // initialize with the right locale
  runApp(TranslationProvider(
    // wrap with TranslationProvider
    child: MyApp(),
  ));
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      locale: TranslationProvider.of(context).flutterLocale,
      supportedLocales: AppLocaleUtils.supportedLocales,
      localizationsDelegates: [
        ...GlobalMaterialLocalizations.delegates,
      ],
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  int _counter = 0;

  @override
  void initState() {
    super.initState();

    LocaleSettings.getLocaleStream().listen((event) {
      print('locale changed: $event');
    });
  }

  @override
  Widget build(BuildContext context) {
    // get t variable, will trigger rebuild on locale change
    // otherwise just call t directly (if locale is not changeable)
    final t = Translations.of(context);

    return Scaffold(
      appBar: AppBar(
        title: Text(t.mainScreen.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text(t.mainScreen.counter(n: _counter)),
            Row(
              mainAxisAlignment: MainAxisAlignment.center,

              // lets loop over all supported locales
              children: AppLocale.values.map((locale) {
                // active locale
                AppLocale activeLocale = LocaleSettings.currentLocale;

                // typed version is preferred to avoid typos
                bool active = activeLocale == locale;

                return Padding(
                  padding: const EdgeInsets.all(8.0),
                  child: OutlinedButton(
                    style: OutlinedButton.styleFrom(
                      backgroundColor: active ? Colors.blue.shade100 : null,
                    ),
                    onPressed: () {
                      // locale change, will trigger a rebuild (no setState needed)
                      LocaleSettings.setLocale(locale);
                    },
                    child: Text(t.locales[locale.languageTag]!),
                  ),
                );
              }).toList(),
            ),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () {
          setState(() => _counter++);
        },
        tooltip: context.t.mainScreen.tapMe, // using extension method
        child: Icon(Icons.add),
      ),
    );
  }
}
```

--------------------------------

### Configure Dart-only usage

Source: https://pub.dev/packages/slang

Setup for using the library in a non-Flutter Dart project.

```yaml
# pubspec.yaml
dependencies:
  slang: <version>
```

```yaml
# Config
flutter_integration: false # set this
```

--------------------------------

### Get translation statistics

Source: https://pub.dev/packages/slang

Retrieve the number of keys, translations, words, and characters.

```bash
dart run slang stats
```

```text
[en]
 - 9 keys (including intermediate keys)
 - 6 translations (leaves only)
 - 15 words
 - 82 characters (ex. [,.?!'¿¡])
```

--------------------------------

### Define English Translations

Source: https://pub.dev/packages/slang

Example of base English translations.

```json
// English
{
  "hello": "Hello",
  "bye": "Bye"
}
```

--------------------------------

### Enable auto rebuild

Source: https://pub.dev/packages/slang

Start the watch process to rebuild automatically. Note that the build_runner watch function is not maintained.

```bash
dart run slang watch
```

--------------------------------

### Example of sanitized key input

Source: https://pub.dev/packages/slang

Input key that will be automatically sanitized by the slang package.

```json
{
  "continue": "Continue"
}
```

--------------------------------

### CSV translation file example

Source: https://pub.dev/packages/slang

CSV format allows combining multiple locales into one file.

```csv
welcome.title,Welcome $name
pages.0.title,First Page
pages.1.title,Second Page
```

--------------------------------

### Format translations with DateFormat and NumberFormat

Source: https://pub.dev/packages/slang/changelog

Example of using DateFormat and NumberFormat within translation strings.

```text
Hello {name}, today is {today: yMd}. You have {money: currency(symbol: '€')}.
```

--------------------------------

### ARB translation file example

Source: https://pub.dev/packages/slang

ARB is the default format for Flutter projects, supporting placeholders and pluralization.

```json
{
  "@@locale": "en",
  "welcomeTitle": "Welcome {name}",
  "@welcomeTitle": {
    "placeholders": {
      "name": {}
    }
  },
  "inboxPageCount": "You have {count, plural, one {1 message} other {{count} messages}}",
  "@inboxPageCount": {
    "description": "The number of messages in the user's inbox",
    "placeholders": {
      "count": {
        "type": "int"
      }
    }
  }
}
```

--------------------------------

### Run configuration tool

Source: https://pub.dev/packages/slang

Convenience command to configure the project.

```bash
dart run slang configure
```

--------------------------------

### Configure .mcp.json

Source: https://pub.dev/packages/slang_mcp

Register the slang_mcp server by adding it to the .mcp.json file in your project root.

```json
// .mcp.json
{
  "mcpServers": {
    "slang_mcp": {
      "command": "slang_mcp"
    }
  }
}
```

--------------------------------

### Configure input and output directories in slang.yaml

Source: https://pub.dev/packages/slang

Alternative configuration method for specifying translation directories using a dedicated slang.yaml file.

```yaml
input_directory: assets/i18n
output_directory: lib/i18n # defaulting to lib/gen if input is outside of lib/
```

--------------------------------

### Usage of GenderContext

Source: https://pub.dev/packages/slang

Example of calling the generated translation function with the context parameter.

```dart
String a = t.greet(name: 'Maria', context: GenderContext.female);
```

--------------------------------

### Configure slang.yaml for standalone usage

Source: https://pub.dev/packages/slang

Use slang.yaml to define configuration without build_runner to reduce boilerplate.

```yaml
base_locale: fr
fallback_strategy: base_locale
input_directory: lib/i18n
input_file_pattern: .i18n.json
output_directory: lib/i18n
output_file_name: translations.g.dart
lazy: true
locale_handling: true
flutter_integration: true
namespaces: false
translate_var: t
enum_name: AppLocale
class_name: Translations
translation_class_visibility: private
key_case: snake
key_map_case: camel
param_case: pascal
sanitization:
  enabled: true
  prefix: k
  case: camel
string_interpolation: double_braces
flat_map: false
translation_overrides: false
timestamp: true
statistics: true
maps:
  - error.codes
  - category
  - iconNames
pluralization:
  auto: cardinal
  default_parameter: n
  cardinal:
    - someKey.apple
  ordinal:
    - someKey.place
contexts:
  GenderContext:
    default_parameter: gender
    generate_enum: true
interfaces:
  PageData: onboarding.pages.*
  PageData2:
    attributes:
      - String title
      - String? content
obfuscation:
  enabled: false
  secret: somekey
format:
  enabled: true
  width: 150
autodoc:
  enabled: true
  locales:
    - en
    - fr
imports:
  - 'package:my_package/path_to_enum.dart'
generate_enum: true
```

--------------------------------

### Apply WIP Changes via CLI

Source: https://pub.dev/packages/slang

Run this command to update translation files and Dart code after prototyping.

```bash
dart run slang wip apply
```

--------------------------------

### Configure input and output directories in build.yaml

Source: https://pub.dev/packages/slang

Specify the input and output directories for translation files within the build.yaml configuration file.

```yaml
targets:
  $default:
    sources:
      - "custom-directory/**" # optional; only assets/* and lib/* are scanned by build_runner
    builders:
      slang_build_runner:
        options:
          input_directory: assets/i18n
          output_directory: lib/i18n # defaulting to lib/gen if input is outside of lib/
```

--------------------------------

### Configure Recasing

Source: https://pub.dev/packages/slang

Define key and parameter casing in your configuration.

```json
{
  "must_be_camel_case": "The parameter is in {snakeCase}",
  "my_map(map)": {
    "this_should_be_in_pascal": "hi"
  }
}
```

```yaml
# Config
key_case: camel
key_map_case: pascal
param_case: snake
```

```dart
String a = t.mustBeCamelCase(snake_case: 'nice');
String b = t.myMap['ThisShouldBeInPascal'];
```

--------------------------------

### Configure build.yaml for slang_build_runner

Source: https://pub.dev/packages/slang_build_runner

Define the builder options in build.yaml, replacing the standard slang.yaml configuration.

```yaml
# build.yaml
targets:
  $default:
    builders:
      slang_build_runner:
        options:
          base_locale: en
```

--------------------------------

### General migration command

Source: https://pub.dev/packages/slang

The general syntax for migrating from other i18n solutions.

```bash
dart run slang migrate <type> <source> <destination>
```

--------------------------------

### Initialize specific locale

Source: https://pub.dev/packages/slang

Set a specific locale manually, for example from stored user preferences.

```dart
@override
void initState() {
  super.initState();
  String storedLocale = loadFromStorage(); // your logic here
  LocaleSettings.setLocaleRaw(storedLocale);
}
```

--------------------------------

### Configure dependencies in pubspec.yaml

Source: https://pub.dev/packages/slang_gpt

Add slang and slang_gpt to your project dependencies.

```yaml
# pubspec.yaml
dependencies:
  slang: <version>

dev_dependencies:
  slang_gpt: <version>
```

--------------------------------

### Register with Claude Code

Source: https://pub.dev/packages/slang_mcp

Add the MCP server to your project using the Claude CLI. Ensure you are in the directory containing your build.yaml or slang.yaml file.

```bash
# Claude Code
cd my_flutter_app/
claude mcp add --transport stdio slang_mcp -- slang_mcp
```

--------------------------------

### Run full translation

Source: https://pub.dev/packages/slang_gpt

Use the --full flag to translate all keys, overriding the default behavior of only translating missing keys.

```bash
dart run slang_gpt --target=fr --full --api-key=<api-key>
```

--------------------------------

### Add Comments in JSON

Source: https://pub.dev/packages/slang

Use keys starting with @ to add comments in JSON translation files.

```json
{
  "@@locale": "en", // fully ignored
  "mainScreen": {
    "button": "Submit",

    // ignored as translation but rendered as a comment
    "@button": "The submit button shown at the bottom",

    // ARB style is also possible, the description will be rendered as a comment
    "@button2": {
      "context": "HomePage",
      "description": "The submit button shown at the bottom"
    },
  }
}
```

--------------------------------

### Run slang_gpt translation

Source: https://pub.dev/packages/slang_gpt

Execute the translation process using the CLI, specifying the target language and your API key.

```bash
dart run slang_gpt --target=fr --api-key=<api-key>
```

--------------------------------

### Define French Translations with Fallback

Source: https://pub.dev/packages/slang

Example of French translations where missing keys fall back to English.

```json
// French
{
  "hello": "Salut",
  // "bye" is missing, fallback to English version
}
```

--------------------------------

### Configure Auto Documentation

Source: https://pub.dev/packages/slang

Enable and configure auto-generated documentation in your configuration.

```yaml
# Config
autodoc:
  enabled: true # enable this feature
  locales: # only generate these locales
    - en 
    - de
```

--------------------------------

### Prototyping with Path Extension

Source: https://pub.dev/packages/slang

Extend $wip with a path to maintain structure while prototyping.

```dart
t.$wip.welcome.name('Hello $name'); // still returns the same
```

--------------------------------

### Enable Namespaces Configuration

Source: https://pub.dev/packages/slang

To use namespaces, you must enable the feature in your configuration file.

```yaml
namespaces: true # enable this feature
output_directory: lib/i18n # optional
output_file_name: translations.g.dart # set file name (mandatory)
```

--------------------------------

### Configure Map Paths for Casing

Source: https://pub.dev/packages/slang

Ensure map paths are cased correctly in the configuration.

```yaml
# Config
key_case: camel
maps:
   - myMap # all paths must be cased accordingly
```

--------------------------------

### Add dependency to pubspec.yaml

Source: https://pub.dev/packages/slang_flutter/install

Manually add the dependency to your pubspec.yaml file. Running this will trigger an implicit flutter pub get.

```yaml
dependencies:
  slang_flutter: ^4.19.0
```

--------------------------------

### Run build_runner command

Source: https://pub.dev/packages/slang_build_runner

Execute the build command to generate files with build_runner.

```bash
dart run build_runner build --delete-conflicting-outputs
```

--------------------------------

### Apply WIP Operations

Source: https://pub.dev/packages/slang

Applies changes to translation files when using the Prototyping feature.

```bash
dart run slang wip apply [--source-dirs=dir1,dir2]
```

--------------------------------

### Configure slang_gpt in build.yaml or slang.yaml

Source: https://pub.dev/packages/slang_gpt

Add the gpt configuration block to your build or slang configuration file to define the model and app description.

```yaml
# existing config
base_locale: fr
fallback_strategy: base_locale
input_directory: lib/i18n
input_file_pattern: .i18n.json
output_directory: lib/i18n

# add this
gpt:
  model: gpt-4
  description: |
    "River Adventure" is a game where you need to cross a river by jumping on stones.
    The game is over when you either fall into the water or reach the other side.
```

--------------------------------

### Configure input directory and file pattern

Source: https://pub.dev/packages/slang

Set the input directory and file pattern for translation files. It is recommended to specify the directory before omitting the .i18n extension.

```yaml
# Config
input_directory: assets/i18n
input_file_pattern: .i18n.json # must end with .json, .yaml, .csv, or .arb
```

--------------------------------

### Apply and translate WIP translations workflow

Source: https://pub.dev/packages/slang_mcp

Prototype new features using WIP strings in Dart, then prompt the LLM to apply and translate them.

```dart
class LoginPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Column(
        children: [
          TextButton(
            onPressed: () {},
            child: Text(context.t.$wip.loginPage.loginButton('Login')),
          ),
          TextButton(
            onPressed: () {},
            child: Text(context.t.$wip.loginPage.forgotPasswordButton('Forgot Password')),
          ),
        ],
      ),
    );
  }
}
```

```text
Apply my new WIP strings and translate
```

--------------------------------

### Configure code formatting

Source: https://pub.dev/packages/slang

Enable automatic code formatting for the generated output.

```yaml
# Config
format:
  enabled: true
  width: 150 # optional
```

--------------------------------

### Root Namespace Configuration

Source: https://pub.dev/packages/slang

Use the _default namespace to include translations in the root.

```text
i18n/
 └── _default_en.i18n.json
 └── _default_fr.i18n.json
 └── widgets_en.i18n.json
 └── widgets_fr.i18n.json
```

--------------------------------

### Configure pubspec.yaml dependencies

Source: https://pub.dev/packages/slang_build_runner

Add slang to dependencies and build_runner along with slang_build_runner to dev_dependencies.

```yaml
# pubspec.yaml
dependencies:
  slang: <version>

dev_dependencies:
  build_runner: <version>
  slang_build_runner: <version>
```

--------------------------------

### Migrate ARB to JSON

Source: https://pub.dev/packages/slang

Transform ARB files to a compatible JSON format while retaining descriptions.

```bash
dart run slang migrate arb source.arb destination.json
```

--------------------------------

### Prototyping with $wip

Source: https://pub.dev/packages/slang

Use $wip on the t variable to prototype translations without key paths or code generation.

```dart
String name = 'Tom';
t.$wip('Hello $name'); // => e.g. 'Hello Tom'
```

--------------------------------

### Initialize locale using device settings

Source: https://pub.dev/packages/slang

Initialize the app to use the device's current locale.

```dart
void main() {
  WidgetsFlutterBinding.ensureInitialized(); // add this
  LocaleSettings.useDeviceLocale(); // and this
  runApp(MyApp());
}
```

--------------------------------

### Accessing translations with slang

Source: https://pub.dev/packages/slang

Demonstrates various ways to access translations, including simple keys, parameters, pluralization, custom contexts, and dynamic keys.

```dart
final t = Translations.of(context); // there is also a static getter without context

String a = t.mainScreen.title;                         // simple use case
String b = t.game.end.highscore(score: 32.6);          // with parameters
String c = t.$wip('Password Forgotten');               // fast prototyping
String d = t.items(n: 2);                              // with pluralization
String e = t.greet(name: 'Tom', context: Gender.male); // with custom context
String f = t.greet(today: DateTime.now());             // with L10n
String g = t.intro.step[4];                            // with index
String h = t.error.type['WARNING'];                    // with dynamic key
String i = t['mainScreen.title'];                      // with fully dynamic key
TextSpan j = t.greet(name: TextSpan(text: 'Tom'));     // with RichText

PageData page0 = t.onboarding.pages[0];                // with interfaces
PageData page1 = t.onboarding.pages[1];
String k = page1.title; // type-safe call
```

--------------------------------

### Use LocaleSettings and AppLocaleUtils

Source: https://pub.dev/packages/slang_flutter

Manage device locales and retrieve supported locales for MaterialApp configuration.

```dart
// use current device locale, and listen to it when the user changes it in device settings
LocaleSettings.useDeviceLocale();

// get current device locale
AppLocale locale = AppLocaleUtils.findDeviceLocale();

// get supported locales (handy for MaterialApp)
List<Locale> locales = AppLocaleUtils.supportedLocales;
```

--------------------------------

### Add Comments in YAML

Source: https://pub.dev/packages/slang

Use standard YAML comments for documentation.

```yaml
mainScreen:
  button: Submit # The submit button shown at the bottom
```

--------------------------------

### Configure iOS Info.plist

Source: https://pub.dev/packages/slang

Add supported locales to the iOS Info.plist file.

```xml
File: ios/Runner/Info.plist

<key>CFBundleLocalizations</key>
<array>
   <string>en</string>
   <string>de</string>
</array>
```

--------------------------------

### Add dependency via CLI

Source: https://pub.dev/packages/slang_flutter/install

Run this command in your terminal to add the slang_flutter package to your Flutter project.

```bash
$ flutter pub add slang_flutter
```

--------------------------------

### dart run slang configure

Source: https://pub.dev/packages/slang

Updates configuration files, including CFBundleLocalizations for iOS and macOS.

```APIDOC
## dart run slang configure

### Description
Updates configuration files for locales.

### Parameters
- **--source-dirs** (string) - Optional - Comma-separated list of source directories to search in.
```

--------------------------------

### slang CLI commands

Source: https://pub.dev/packages/slang

Common CLI commands for managing translations, including generation, analysis, normalization, configuration, and migration.

```bash
dart run slang                               # generate dart file
dart run slang analyze                       # unused and missing translations
dart run slang normalize                     # sort translations according to base locale
dart run slang configure                     # automatically update CFBundleLocalizations
dart run slang edit move loginPage authPage  # move or rename translations
dart run slang migrate arb src.arb dest.json # migrate arb to json
```

--------------------------------

### Directory Locale Configuration

Source: https://pub.dev/packages/slang

Configuration for using directory locales.

```yaml
# Config
input_directory: assets/i18n
input_file_pattern: .json
```

--------------------------------

### Synchronize locales across multiple packages

Source: https://pub.dev/packages/slang

Use LocaleSettings to synchronize locales between different packages that use Slang.

```dart
import 'package:my_package1/gen/strings.g.dart' as package1;
import 'package:my_package2/gen/strings.g.dart' as package2;

void main() {
  final t1 = package1.Translations.of(context);
  final t2 = package2.Translations.of(context);

  // this changes the locale for all packages to Spanish
  package1.LocaleSettings.setLocale(AppLocale.es);
  
  String spanishTitle = t2.title; // this will be in Spanish
  
  // this changes the locale for all packages to English
  package2.LocaleSettings.setLocale(AppLocale.en);
  
  String englishTitle = t1.title; // this will be in English
}
```

--------------------------------

### Add slang dependencies

Source: https://pub.dev/packages/slang_flutter

Add the slang and slang_flutter packages to your pubspec.yaml file.

```yaml
dependencies:
  slang: <version>
  slang_flutter: <version>
```

--------------------------------

### Configure Fallback Strategy

Source: https://pub.dev/packages/slang

Set the fallback strategy in your configuration to handle missing translations by falling back to the base locale.

```yaml
# Config
base_locale: en
fallback_strategy: base_locale # add this
```

--------------------------------

### Define translation file naming convention

Source: https://pub.dev/packages/slang

Translation files should follow the <locale>.<extension> format.

```text
<locale>.<extension>
```

--------------------------------

### Add slang_gpt with Flutter

Source: https://pub.dev/packages/slang_gpt/install

Run this command in your terminal to add the package to a Flutter project.

```bash
$ flutter pub add slang_gpt
```

--------------------------------

### Add slang dependency via CLI

Source: https://pub.dev/packages/slang/install

Use these commands to add the slang package to your project using the Dart or Flutter CLI.

```bash
$ dart pub add slang
```

```bash
$ flutter pub add slang
```

--------------------------------

### Configure Global Pluralization

Source: https://pub.dev/packages/slang

Specify cardinal and ordinal keys in the global configuration file.

```yaml
# Config
pluralization: # Applies to all locales!
  auto: off
  cardinal:
    - someKey.apple
  ordinal:
    - someKey.place
```

--------------------------------

### Run Slang Generation

Source: https://pub.dev/packages/slang

The primary command to generate Dart files from your translation resources.

```bash
dart run slang
```

--------------------------------

### Manual locale handling

Source: https://pub.dev/packages/slang

Build and access translations manually without global initialization.

```dart
final english = AppLocale.en.build();
final german = AppLocale.de.build();

// read
String a = german.login.success;
```

--------------------------------

### Namespace File Naming Convention

Source: https://pub.dev/packages/slang

Namespaces follow a specific naming pattern using the namespace and locale.

```text
<namespace>_<locale>.<extension>
```

--------------------------------

### Configure obfuscation

Source: https://pub.dev/packages/slang

Enable string obfuscation to hinder reverse engineering of translation strings.

```yaml
# Config
obfuscation:
  enabled: true
  secret: somekey # set this if you want deterministic obfuscation
```

--------------------------------

### Configure build.yaml for build_runner

Source: https://pub.dev/packages/slang

Use build.yaml when working with build_runner; this file is also recognized by the dart run slang command.

```yaml
targets:
  $default:
    builders:
      slang_build_runner:
        options:
          base_locale: fr
          fallback_strategy: base_locale
          input_directory: lib/i18n
          input_file_pattern: .i18n.json
          output_directory: lib/i18n
          output_file_name: translations.g.dart
          lazy: true
          locale_handling: true
          flutter_integration: true
          namespaces: false
          translate_var: t
          enum_name: AppLocale
          class_name: Translations
          translation_class_visibility: private
          key_case: snake
          key_map_case: camel
          param_case: pascal
          sanitization:
            enabled: true
            prefix: k
            case: camel
          string_interpolation: double_braces
          flat_map: false
          translation_overrides: false
          timestamp: true
          statistics: true
          maps:
            - error.codes
            - category
            - iconNames
          pluralization:
            auto: cardinal
            default_parameter: n
            cardinal:
              - someKey.apple
            ordinal:
              - someKey.place
          contexts:
            GenderContext:
              default_parameter: gender
              generate_enum: true
          interfaces:
            PageData: onboarding.pages.*
            PageData2:
              attributes:
                - String title
                - String? content
          obfuscation:
            enabled: false
            secret: somekey
          format:
            enabled: true
            width: 150
          autodoc:
            enabled: true
            locales:
              - en
              - fr
          imports:
            - 'package:my_package/path_to_enum.dart'
          generate_enum: true
```

--------------------------------

### dart run slang apply

Source: https://pub.dev/packages/slang

Applies missing translations from the _missing_translations file to original files.

```APIDOC
## dart run slang apply

### Description
Adds missing translations to original files.

### Parameters
- **--locale** (string) - Optional - Apply only one specific locale.
- **--outdir** (string) - Optional - Path of analysis output.
- **--preserve-order** (flag) - Optional - Keep existing key order.
```

--------------------------------

### apply-wip-translations

Source: https://pub.dev/packages/slang_mcp

Applies WIP translations from the source code to translation files and triggers a regeneration of output files.

```APIDOC
## apply-wip-translations

### Description
Applies WIP translations from source code to translation files and regenerates the output.

### Parameters
- None
```

--------------------------------

### Add slang_gpt with Dart

Source: https://pub.dev/packages/slang_gpt/install

Run this command in your terminal to add the package to a Dart project.

```bash
$ dart pub add slang_gpt
```

--------------------------------

### Wrap TranslationProvider for auto-rebuilds

Source: https://pub.dev/packages/slang

Wrap multiple TranslationProvider widgets to ensure the UI automatically rebuilds when the locale changes across packages.

```dart
import 'package:my_package1/gen/strings.g.dart' as package1;
import 'package:my_package2/gen/strings.g.dart' as package2;

void main() {
  final widget = package1.TranslationProvider(
    child: package2.TranslationProvider(
      child: MaterialApp(
        home: Scaffold(
          body: Builder(builder: (context) {
            final t1 = package1.Translations.of(context);
            final t2 = package2.Translations.of(context);
            return Column(
              children: [
                Text(t1.title),
                Text(t2.title),
              ],
            );
          }),
          floatingActionButton: FloatingActionButton(
            onPressed: () {
              // this changes the locale for all packages
              // does not matter which package you call it on
              package1.LocaleSettings.setLocale(AppLocale.en);
            },
          ),
        ),
      ),
    ),
  );
  
  runApp(widget);
}
```

--------------------------------

### Configure custom dependency injection

Source: https://pub.dev/packages/slang

Disable default locale handling to use custom dependency injection solutions.

```yaml
# Config
locale_handling: false # remove unused t variable, LocaleSettings, etc.
translation_class_visibility: public
```

--------------------------------

### List support in translations

Source: https://pub.dev/packages/slang

Lists and nested structures are supported without extra configuration.

```json
{
  "niceList": [
    "hello",
    "nice",
    [
      "first item in nested list",
      "second item in nested list"
    ],
    {
      "wow": "WOW!",
      "ok": "OK!"
    },
    {
      "a map entry": "access via key",
      "another entry": "access via second key"
    }
  ]
}
```

```dart
String a = t.niceList[1]; // "nice"
String b = t.niceList[2][0]; // "first item in nested list"
String c = t.niceList[3].ok; // "OK!"
String d = t.niceList[4]['a map entry']; // "access via key"
```

--------------------------------

### Import slang_flutter

Source: https://pub.dev/packages/slang_flutter/install

Add this import statement to your Dart files to use the library.

```dart
import 'package:slang_flutter/slang_flutter.dart';
```

--------------------------------

### Configure Slang Locales

Source: https://pub.dev/packages/slang

Updates configuration files like CFBundleLocalizations for iOS and macOS. You can optionally specify source directories.

```bash
dart run slang configure [--source-dirs=dir1,dir2]
```

```bash
dart run slang configure --source-dirs=dir1,dir2
```

--------------------------------

### Updated Translation File

Source: https://pub.dev/packages/slang

The translation file after applying WIP changes.

```json
{
  "welcome": {
    "name": "Hello $name" // added automatically
  }
}
```

--------------------------------

### Link Translations with Absolute Paths

Source: https://pub.dev/packages/slang

Use the @: prefix followed by an absolute path to reference another translation key.

```json
{
  "fields": {
    "name": "my name is {firstName}",
    "age": "I am {age} years old"
  },
  "introduce": "Hello, @:fields.name and @:fields.age"
}
```

```dart
String s = t.introduce(firstName: 'Tom', age: 27); // Hello, my name is Tom and I am 27 years old.
```

--------------------------------

### Add dependency via Flutter CLI

Source: https://pub.dev/packages/slang_build_runner/install

Run this command in your terminal to add the package to a Flutter project.

```bash
$ flutter pub add slang_build_runner
```

--------------------------------

### Configure Flutter localization support

Source: https://pub.dev/packages/slang

Add flutter_localizations to pubspec.yaml and wrap the app with TranslationProvider.

```yaml
# File: pubspec.yaml
dependencies:
  flutter:
    sdk: flutter
  flutter_localizations: # add this
    sdk: flutter
```

```dart
void main() {
  WidgetsFlutterBinding.ensureInitialized();
  runApp(TranslationProvider(child: MyApp())); // Wrap your app with TranslationProvider
}
```

```dart
MaterialApp(
  locale: TranslationProvider.of(context).flutterLocale, // use provider
  supportedLocales: AppLocaleUtils.supportedLocales,
  localizationsDelegates: GlobalMaterialLocalizations.delegates,
  child: YourFirstScreen(),
)
```

--------------------------------

### Directory Locale Namespace Structure

Source: https://pub.dev/packages/slang

Using directory locales allows for nested namespaces.

```text
i18n/
 └── en/
      └── widgets_en.i18n.json
      └── errorDialogs_en.i18n.json
 └── fr/
      └── widgets_fr.i18n.json
      └── errorDialogs.i18n.json <-- directory locale will be used
```

--------------------------------

### Configure key sanitization

Source: https://pub.dev/packages/slang

Enable and customize key sanitization to ensure all keys are valid Dart identifiers.

```yaml
# Config
sanitization:
  enabled: true
  prefix: k
  case: camel
```

--------------------------------

### MIT License text

Source: https://pub.dev/packages/slang_flutter/license

The legal terms and conditions for using the slang_flutter software.

```text
MIT License

Copyright (c) 2020-2026 Tien Do Nam

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```
Tokens:
Raw