Pluralisation

Typed-locale offre un support intégré pour la pluralisation, vous permettant de gérer différentes formes d'une phrase en fonction d'un compteur. C'est particulièrement utile pour les langues qui ont des règles différentes pour les formes singulières et plurielles.

Utilisation de la fonction `plural`

Pour définir une phrase pluralisée, utilisez la fonction plural dans votre objet de traduction :

import {plural} from 'typed-locale';

export const fr = {
  youHaveMessages: plural({
    none: "Vous n'avez aucun message",
    one: 'Vous avez 1 message',
    other: 'Vous avez {{count}} messages',
  }),
} as const;

La fonction plural accepte un objet avec les propriétés suivantes :

none (optionnel) : Utilisé lorsque le compteur est zéro.
one (optionnel) : Utilisé lorsque le compteur est un.
other (obligatoire) : Utilisé pour tous les autres cas.

Utilisation des traductions pluralisées

Lors de l'utilisation d'une traduction pluralisée, vous devez fournir un paramètre count :

const translator = createTranslator(fr);

console.log(translator(t => t.youHaveMessages({count: 0}))); // Sortie : 'Vous n'avez aucun message'
console.log(translator(t => t.youHaveMessages({count: 1}))); // Sortie : 'Vous avez 1 message'
console.log(translator(t => t.youHaveMessages({count: 5}))); // Sortie : 'Vous avez 5 messages'

Sécurité des types

Le système de pluralisation dans typed-locale est entièrement type-safe. TypeScript s'assurera que vous fournissez le paramètre count requis et vous empêchera d'utiliser des clés inexistantes.

Pluralisation avec d'autres variables

Vous pouvez combiner la pluralisation avec d'autres variables dans vos traductions :

export const fr = {
  userMessages: plural({
    none: "{{name}} n'a aucun message",
    one: '{{name}} a 1 message',
    other: '{{name}} a {{count}} messages',
  }),
} as const;

const translator = createTranslator(fr);

console.log(translator(t => t.userMessages({count: 3, name: 'Alice'})));
// Sortie : 'Alice a 3 messages'

Gestion des règles de pluralisation complexes

Bien que les cas de base none, one et other couvrent de nombreuses langues, certaines langues ont des règles de pluralisation plus complexes. Pour ces cas, vous devrez peut-être utiliser le cas other et gérer les règles spécifiques dans la logique de votre application.

Par exemple :

export const ru = {
  apples: plural({
    one: '{{count}} яблоко',
    other: '{{count}} яблок',
  }),
} as const;

const translator = createTranslator(ru);

function getRussianApples(count: number) {
  const phrase = translator(t => t.apples({count}));
  // Appliquer les règles de pluralisation spécifiques au russe
  if (count % 10 === 1 && count % 100 !== 11) {
    return phrase;
  } else if ([2, 3, 4].includes(count % 10) && ![12, 13, 14].includes(count % 100)) {
    return phrase.replace('яблок', 'яблока');
  } else {
    return phrase;
  }
}

console.log(getRussianApples(1)); // Sortie : '1 яблоко'
console.log(getRussianApples(2)); // Sortie : '2 яблока'
console.log(getRussianApples(5)); // Sortie : '5 яблок'
console.log(getRussianApples(21)); // Sortie : '21 яблоко'

Cette approche vous permet de gérer des règles de pluralisation complexes tout en bénéficiant de la sécurité des types et de la structure de typed-locale.