Variables type-safe

Sécurité des types avec les variables

typed-locale offre une sécurité des types pour ces variables. Lorsque vous utilisez une traduction qui inclut des variables, TypeScript s'assurera que vous fournissez toutes les variables nécessaires et qu'elles sont du type correct.

Voici comment vous utiliseriez ces traductions :

import {createTranslator} from 'typed-locale';

const translator = createTranslator(en);

const greeting = translator(t => t.hello);
console.log(greeting); // Sortie : 'Hello'

const nameGreeting = translator(t => t.helloName({name: 'Alice'}));
console.log(nameGreeting); // Sortie : 'Hello, Alice'

const userInfo = translator(t => t.userAge({name: 'Bob', age: 30}));
console.log(userInfo); // Sortie : 'Bob is 30 years old'

Vérification des types

Le système de types détectera les erreurs si vous essayez d'utiliser une traduction incorrectement :

// Ceci provoquera une erreur TypeScript car 'name' est manquant
translator(t => t.helloName());

// Ceci provoquera une erreur TypeScript car 'age' n'est pas attendu
translator(t => t.helloName({name: 'Charlie', age: 25}));

// Ceci provoquera une erreur TypeScript car 'age' devrait être un nombre
translator(t => t.userAge({name: 'David', age: '35'}));

Avantages des variables type-safe

Détection précoce des erreurs : TypeScript détectera les erreurs liées aux variables lors de la compilation, évitant ainsi les erreurs d'exécution.
Amélioration de l'expérience développeur : Vous obtenez des suggestions d'autocomplétion pour les variables requises.
Support de refactoring : Si vous changez le nom d'une variable dans vos traductions, TypeScript vous aidera à trouver et mettre à jour tous les usages.
Documentation : Les types servent de documentation inline, montrant exactement quelles variables chaque traduction attend.

Utilisation avancée : Objets imbriqués et tableaux

typed-locale prend également en charge des structures plus complexes, y compris les objets imbriqués et les tableaux. Le système de types inférera et appliquera correctement la structure de ces traductions plus complexes.

Par exemple :

export const en = {
  user: {
    profile: {
      greeting: 'Welcome back, {{name}}!',
      stats: 'You have {{postCount}} posts and {{followerCount}} followers',
    },
    preferences: {
      theme: 'Your current theme is {{theme}}',
    },
  },
  listItems: 'Your items are: {{items}}',
} as const;

const translator = createTranslator(en);

const profileGreeting = translator(t => t.user.profile.greeting({name: 'Eve'}));
console.log(profileGreeting); // Sortie : 'Welcome back, Eve!'

const userStats = translator(t => t.user.profile.stats({postCount: 10, followerCount: 100}));
console.log(userStats); // Sortie : 'You have 10 posts and 100 followers'

const userTheme = translator(t => t.user.preferences.theme({theme: 'dark'}));
console.log(userTheme); // Sortie : 'Your current theme is dark'

const itemList = translator(t => t.listItems({items: ['apple', 'banana', 'orange'].join(', ')}));
console.log(itemList); // Sortie : 'Your items are: apple, banana, orange'

En tirant parti du système de types de TypeScript, typed-locale fournit une manière robuste et type-safe de gérer les variables dans vos traductions, rendant vos efforts d'internationalisation plus fiables et maintenables.