Vue d’ensemble

Cette version ajoute la prise en charge des valeurs de contexte pouvant être dérivées dans gt-react. Lorsqu’on traduit du contenu, il n’existe pas toujours de mappage un à un entre le texte source et les traductions correspondantes : une même expression anglaise peut nécessiter plusieurs traductions dans une autre langue. La dérivation du contexte résout ce problème en vous permettant de générer plusieurs entrées de traduction à partir d’une seule chaîne de caractères source.

Contexte : fonctionnement des traductions avec GT

Dans le système de traduction de GT, vous placez les chaînes de caractères traduisibles dans gt() :

import { useGT } from 'gt-react';

function Greeting() {
  const gt = useGT();
  return <p>{gt("Hello, world!")}</p>;
}

Chaque appel à gt() crée une entrée source — un élément de texte à traduire. En général, une entrée source produit une traduction par langue.

Qu’est-ce que derive ?

La fonction derive() indique à la CLI de GT d’enregistrer plusieurs entrées de traduction à partir d’un seul appel à gt(), selon différentes valeurs à l’exécution. Au lieu d’écrire des appels gt() distincts pour chaque variante, vous utilisez derive() pour exprimer toutes les variantes au même endroit, et la CLI génère les entrées source appropriées au build.

Par exemple, l’anglais ne marque pas le genre dans "The boy/girl is playing,", alors que l’espagnol le fait ("El niño está jugando" vs "La niña está jugando"). Avec derive(), vous pouvez gérer cela dans un seul appel à gt() :

const subject = isBoy ? "boy" : "girl";
gt(`The ${derive(subject)} is playing.`);

Le CLI détecte l’appel à derive() et enregistre deux entrées source — l’une pour "The boy is playing." et l’autre pour "The girl is playing." — chacune avec sa propre traduction, avec l’accord grammatical correct en espagnol.

Le problème : les mappages de un à plusieurs

Considérez trois cas de figure montrant comment les entrées source sont associées aux entrées de traduction :

Cas 1 : mappage un à un

Chaque entrée source correspond à une seule entrée de traduction. C’est le cas le plus simple.

Cas 2 : mappage de plusieurs vers un

Plusieurs entrées source fusionnent en une seule traduction. Par exemple, l’anglais a des formes du pluriel, mais le mandarin n’en a pas :

Cas 3 : mappage de un à plusieurs

Une seule entrée source nécessite plusieurs traductions. Par exemple, en espagnol, les adjectifs s’accordent en genre, contrairement à l’anglais :

C’était le cas qui n’était pas pris en charge avant cette version. GT partait auparavant du principe d’un mappage un à un entre les entrées source et les traductions.

Solution : derive avec $context

L’option $context de GT vous permet de lever l’ambiguïté entre plusieurs entrées de traduction pour un même texte source. Combinée à derive(), vous pouvez l’exprimer directement au point d’appel :

import { useGT, derive } from 'gt-react';

function StatusMessage({ isMasculine }) {
  const gt = useGT();

  return (
    <p>
      {gt("I am tired", {
        $context: derive(
          isMasculine ? "inflect as masculine" : "inflect as feminine"
        )
      })}
    </p>
  );
}

Au moment du build, la CLI détecte l’appel à derive() et enregistre deux entrées source distinctes, chacune produisant sa propre traduction :

"I am tired" ($context: "inflect as masculine") → "Estoy cansado"
"I am tired" ($context: "inflect as feminine")  → "Estoy cansada"

À l’exécution, la bonne traduction est sélectionnée en fonction de la valeur de isMasculine.

Sans derive(), vous devriez faire deux appels distincts :

// Sans derive — plus verbeux, texte source dupliqué
const message = isMasculine
  ? gt("I am tired", { $context: "inflect as masculine" })
  : gt("I am tired", { $context: "inflect as feminine" });

derive() permet d’obtenir le même résultat avec moins de redondance et clarifie l’intention.

Pourquoi ne pas simplement utiliser une condition ?

Comme les chaînes de caractères de contenu, les valeurs $context doivent être statiques — la CLI doit pouvoir les résoudre au build. Vous ne pouvez pas passer directement une expression évaluée à l’exécution comme $context, car la CLI ne saurait pas quelles valeurs elle peut prendre. derive() résout ce problème en remontant la pile d’appels pour déterminer toutes les chaînes de caractères statiques possibles qui pourraient être passées, ce qui permet à la CLI d’enregistrer une entrée source pour chacune d’elles.

En résumé

La dérivation du contexte comble une lacune fondamentale du modèle de traduction : l’incapacité à représenter des mappages de un à plusieurs entre les entrées source et les entrées de traduction. En combinant derive() avec $context, un seul appel à gt() peut produire plusieurs traductions, désambiguïsées à l’exécution.

Liens connexes

• référence API de derive() pour les chaînes de caractères
• référence API de derive() pour les composants
• derive() en Python
• tutoriel derive() (Python)