@intlayer/docs 8.9.4 → 8.9.6-canary.0

package/docs/fr/benchmark/vue.md

@@ -0,0 +1,160 @@
+---
+createdAt: 2026-04-20
+updatedAt: 2026-04-21
+title: La meilleure solution i18n pour Vue en 2026 - Rapport de Benchmark
+description: Comparez les bibliothèques d'internationalisation (i18n) pour Vue comme vue-i18n, fluent-vue et Intlayer. Rapport de performance détaillé sur la taille du bundle, les fuites et la réactivité.
+keywords:
+  - benchmark
+  - i18n
+  - intl
+  - vue
+  - performance
+  - intlayer
+slugs:
+  - doc
+  - benchmark
+  - vue
+author: Aymeric PINEAU
+applicationTemplate: https://github.com/intlayer-org/benchmark-i18n-vue-template
+history:
+  - version: 8.7.12
+    date: 2026-01-06
+    changes: "Initialisation du benchmark"
+---
+
+# Bibliothèques i18n Vue — Rapport de Benchmark 2026
+
+Cette page est un rapport de benchmark pour les solutions i18n sur Vue.
+
+## Table des Matières
+
+<Toc/>
+
+## Benchmark Interactif
+
+<I18nBenchmark framework="vite-vue" vertical/>
+
+## Référence des résultats :
+
+<iframe 
+  src="https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-vite_vue.md" 
+  width="100%" 
+  height="600px"
+  style="border:none;">
+</iframe>
+
+> https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-vite_vue.md
+
+Voir le dépôt complet du benchmark [ici](https://github.com/intlayer-org/benchmark-i18n/tree/main).
+
+## Introduction
+
+Les solutions d'internationalisation figurent parmi les dépendances les plus lourdes d'une application Vue. Le risque principal est d'embarquer du contenu inutile : les traductions d'autres pages et d'autres locales dans le bundle d'une seule route.
+
+À mesure que votre application grandit, ce problème peut rapidement faire exploser la quantité de JavaScript envoyée au client et ralentir la navigation.
+
+En pratique, pour les implémentations les moins optimisées, une page internationalisée peut finir par être plusieurs fois plus lourde que la version sans i18n.
+
+L'autre impact concerne l'expérience développeur (DX) : la façon dont vous déclarez le contenu, les types, l'organisation des namespaces, le chargement dynamique et la réactivité lors du changement de langue.
+
+## TL;DR
+
+- **Intlayer** : La solution la plus légère (v8.7.12) avec découpage (scoping) et chargement dynamique natifs.
+- **vue-i18n** : Le standard de l'industrie avec un riche écosystème, mais peut être nettement plus lourd et difficile à optimiser pour le code-splitting dans les grandes applications.
+- **fluent-vue** : Organisation innovante des messages mais manque de sécurité de type et s'avère extrêmement lourd.
+
+## Testez votre application
+
+Pour repérer rapidement les problèmes de fuite i18n, j'ai mis en place un scanner gratuit disponible [ici](https://intlayer.org/i18n-seo-scanner).
+
+<iframe src="https://intlayer.org/i18n-seo-scanner" width="100%" height="600px" style="border:none;"/>
+
+## Le problème
+
+Deux leviers sont essentiels pour limiter le coût d'une application multilingue :
+
+- Découper le contenu par page / namespace afin de ne pas charger des dictionnaires entiers quand on n'en a pas besoin
+- Charger la bonne locale dynamiquement, uniquement quand nécessaire
+
+Comprendre les limitations techniques de ces approches :
+
+**Chargement dynamique**
+
+Sans chargement dynamique, la plupart des solutions gardent les messages en mémoire dès le premier rendu, ce qui ajoute un surcoût important pour les applications ayant beaucoup de routes et de langues.
+
+Avec le chargement dynamique, vous acceptez un compromis : moins de JS initial, mais parfois une requête supplémentaire lors du changement de langue.
+
+**Découpage du contenu (Splitting)**
+
+Les syntaxes basées sur `const { t } = useI18n()` + `t('a.b.c')` sont très pratiques mais encouragent souvent la conservation de gros objets JSON au runtime. Ce modèle rend le tree-shaking difficile à moins que la bibliothèque ne propose une réelle stratégie de découpage par page.
+
+## Méthodologie
+
+Pour ce benchmark, nous avons comparé les bibliothèques suivantes :
+
+- `Base App` (Pas de bibliothèque i18n)
+- `vue-intlayer` (v8.7.12)
+- `vue-i18n` (v11.4.0)
+- `fluent-vue` (v3.8.2)
+
+Le framework utilisé est `Vue` avec une application multilingue de **10 pages** et **10 langues**.
+
+Nous avons comparé **quatre stratégies de chargement** :
+
+| Stratégie                | Sans namespaces (global)                          | Avec namespaces (scoped)                                             |
+| :----------------------- | :------------------------------------------------ | :------------------------------------------------------------------- |
+| **Chargement statique**  | **Static** : Tout en mémoire au démarrage.        | **Scoped static** : Divisé par namespace ; tout chargé au démarrage. |
+| **Chargement dynamique** | **Dynamic** : Chargement à la demande par locale. | **Scoped dynamic** : Chargement granulaire par namespace et locale.  |
+
+## Résumé des stratégies
+
+- **Static** : Simple ; pas de latence réseau après le chargement initial. Inconvénient : taille de bundle importante.
+- **Dynamic** : Réduit le poids initial (lazy-loading). Idéal lorsque vous avez de nombreuses locales.
+- **Scoped static** : Organise bien le code (séparation logique) sans requêtes réseau supplémentaires complexes.
+- **Scoped dynamic** : Meilleure approche pour le _code splitting_ et la performance. Minimise la mémoire en ne chargeant que ce dont la vue actuelle et la locale active ont besoin.
+
+### Ce que j'ai mesuré :
+
+J'ai fait tourner la même application multilingue dans un vrai navigateur pour chaque stack, puis j'ai noté ce qui passait réellement sur le réseau et combien de temps cela prenait. Les tailles sont indiquées **après compression web normale**, car c'est plus proche de ce que les gens téléchargent réellement.
+
+- **Taille de la bibliothèque d'internationalisation** : Après bundling, tree-shaking et minification, la taille de la bibliothèque i18n est la taille du code des providers + composables dans un composant vide. Cela n'inclut pas le chargement des fichiers de traduction. Cela montre à quel point la bibliothèque est "coûteuse" avant même que votre contenu n'entre en jeu.
+
+- **JavaScript par page** : Pour chaque route du benchmark, quelle quantité de scripts le navigateur récupère pour cette visite, en moyenne sur les pages du test (et sur les locales). Les pages lourdes sont des pages lentes.
+
+- **Fuite des autres locales (Leakage)** : C'est le contenu de la même page mais dans une autre langue qui serait chargé par erreur dans la page auditée. Ce contenu est inutile et doit être évité (ex: contenu de la page `/fr/about` dans le bundle de la page `/en/about`).
+
+- **Fuite des autres routes** : Même idée pour les **autres écrans** de l'application : si leurs textes sont embarqués alors que vous n'avez ouvert qu'une seule page (ex: contenu de la page `/en/about` dans le bundle de la page `/en/contact`). Un score élevé indique un faible découpage ou des bundles trop larges.
+
+- **Taille moyenne du bundle d'un composant** : Les éléments UI communs sont mesurés **un par un**, au lieu d'être cachés dans un seul chiffre global d'application. Cela montre si l'internationalisation gonfle discrètement les composants du quotidien. Par exemple, si votre composant se re-rend, il chargera toutes ces données depuis la mémoire. Attacher un JSON géant à n'importe quel composant revient à connecter un grand entrepôt de données inutilisées qui ralentira les performances de vos composants.
+
+- **Réactivité du changement de langue** : Je change la langue via le contrôle de l'application et je mesure le temps nécessaire pour que la page ait clairement basculé, ce qu'un visiteur remarquerait.
+
+- **Travail de rendu après un changement de langue** : Un indicateur plus précis : quel effort l'interface a fourni pour se redessiner dans la nouvelle langue une fois le changement lancé. Utile lorsque le temps "ressenti" et le coût du framework divergent.
+
+- **Temps de chargement initial de la page** : De la navigation jusqu'au moment où le navigateur considère la page comme entièrement chargée pour les scénarios testés. Utile pour comparer les démarrages à froid.
+
+- **Temps d'hydratation (Hydration)** : Temps que le client passe à transformer le HTML du serveur en interface interactive. Un tiret dans les tableaux signifie que l'implémentation n'a pas fourni de chiffre d'hydratation fiable dans ce test.
+
+## Résultats en détail
+
+### 1 — Solutions à éviter
+
+> Aucune solution claire à éviter dans l'écosystème Vue.
+
+### 2 — Solutions acceptables
+
+**(vue-i18n)** (`vue-i18n@11.4.0`) :
+
+- **vue-i18n** est sans conteste la bibliothèque i18n la plus utilisée pour Vue, elle possède énormément de fonctionnalités et un immense écosystème. Mais sous le capot, la solution est assez lourde. Même si vue-i18n intègre le lazy loading des messages, il lui manque une fonctionnalité de découpage (scoping). Dans le cas d'une application Vue SPA classique, cela ne pose pas de problème, mais pour une application Nuxt utilisant @nuxt/i18n, cela conduit à inclure les messages de toutes les pages dans une seule. Pour une grosse application Nuxt de plus de 10 pages, cela peut devenir vraiment problématique.
+
+Le paquet est très lourd (~24.3 Ko, soit environ 9× `vue-intlayer`).
+
+**(fluent-vue)** (`fluent-vue@0.5.0`) :
+
+- **fluent-vue** propose une tentative d'innovation via le format .ftl. L'organisation des messages est excellente, plus facile pour débuter. Mais en pratique, le manque de sécurité de type augmente le risque d'erreur et peut vite devenir chronophage à déboguer. De plus, cette solution charge les messages via un plugin vite qui force le chargement de tout le contenu dans toutes les langues dans chaque page. Enfin, c'est une solution extrêmement lourde (~92.7 Ko, soit environ 34× `vue-intlayer`).
+
+### 3 — Recommandations
+
+**(Intlayer)** (`vue-intlayer@8.7.12`) :
+
+Je ne jugerai pas personnellement `vue-intlayer` par souci d'objectivité, puisqu'il s'agit de ma propre solution.

package/docs/fr/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-04-08
+updatedAt: 2026-05-12
 title: Configuration
 description: Apprenez à configurer Intlayer pour votre application. Comprenez les différents paramètres et options disponibles pour personnaliser Intlayer selon vos besoins.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 8.9.4
+    date: 2026-05-12
+    changes: "Ajout du support pour le fournisseur LM Studio"
   - version: 8.7.0
     date: 2026-04-08
     changes: "Ajout des options `prune` et `minify` à la configuration de build"
@@ -350,7 +353,7 @@ const config: IntlayerConfig = {
   ai: {
     /**
      * Fournisseur d'IA à utiliser.
-     * Options : 'openai', 'anthropic', 'mistral', 'deepseek', 'gemini', 'ollama', 'openrouter', 'alibaba', 'fireworks', 'groq', 'huggingface', 'bedrock', 'googlevertex', 'togetherai'
+     * Options : 'openai', 'anthropic', 'mistral', 'deepseek', 'gemini', 'ollama', 'openrouter', 'alibaba', 'fireworks', 'groq', 'huggingface', 'bedrock', 'googlevertex', 'togetherai', 'lmstudio'
      * Par défaut : 'openai'
      */
     provider: "openai",
@@ -919,16 +922,17 @@ Intlayer supporte plusieurs fournisseurs d'IA pour une flexibilité accrue. Les
 - **Groq**
 - **Amazon Bedrock**
 - **Together.ai**
-
-| Champ                | Description                                                                                                                                   | Type                                                                                                                                                                                                                                                                                                                                                                                           | Par défaut  | Exemple                                                       | Note                                                                                                                                                                                                              |
-| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `provider`           | Le fournisseur à utiliser pour les fonctionnalités IA d'Intlayer.                                                                             | `'openai'` &#124; <br/> `'anthropic'` &#124; <br/> `'mistral'` &#124; <br/> `'deepseek'` &#124; <br/> `'gemini'` &#124; <br/> `'ollama'` &#124; <br/> `'openrouter'` &#124; <br/> `'alibaba'` &#124; <br/> `'fireworks'` &#124; <br/> `'groq'` &#124; <br/> `'huggingface'` &#124; <br/> `'bedrock'` &#124; <br/> `'googleaistudio'` &#124; <br/> `'googlevertex'` &#124; <br/> `'togetherai'` | `undefined` | `'anthropic'`                                                 | Les différents fournisseurs nécessitent des clés API différentes et ont des tarifs variés.                                                                                                                        |
-| `model`              | Le modèle à utiliser pour les fonctionnalités IA.                                                                                             | `string`                                                                                                                                                                                                                                                                                                                                                                                       | Aucun       | `'gpt-4o-2024-11-20'`                                         | Le modèle spécifique varie selon le fournisseur.                                                                                                                                                                  |
-| `temperature`        | Contrôle le caractère aléatoire des réponses de l'IA.                                                                                         | `number`                                                                                                                                                                                                                                                                                                                                                                                       | Aucun       | `0.1`                                                         | Température plus élevée = plus créatif et moins prévisible.                                                                                                                                                       |
-| `apiKey`             | Votre clé API pour le fournisseur sélectionné.                                                                                                | `string`                                                                                                                                                                                                                                                                                                                                                                                       | Aucun       | `process.env.OPENAI_API_KEY`                                  | Garder secret ; stocker dans les variables d'environnement.                                                                                                                                                       |
-| `applicationContext` | Contexte supplémentaire sur votre application pour aider l'IA à générer des traductions plus précises (domaine, audience, ton, terminologie). | `string`                                                                                                                                                                                                                                                                                                                                                                                       | Aucun       | `'Mon contexte d'application'`                                | Peut être utilisé pour ajouter des règles (ex: `"Vous ne devez pas transformer les urls"`).                                                                                                                       |
-| `baseURL`            | L'URL de base pour l'API IA.                                                                                                                  | `string`                                                                                                                                                                                                                                                                                                                                                                                       | Aucun       | `'https://api.openai.com/v1'` <br/> `'http://localhost:5000'` | Peut pointer vers un point de terminaison d'API IA local ou personnalisé.                                                                                                                                         |
-| `dataSerialization`  | Format de sérialisation des données pour les fonctionnalités IA.                                                                              | `'json'` &#124; <br/> `'toon'`                                                                                                                                                                                                                                                                                                                                                                 | `undefined` | `'toon'`                                                      | • `'json'`: standard, fiable ; utilise plus de tokens.<br/>• `'toon'`: moins de tokens, moins cohérent.<br/>• Des paramètres supplémentaires sont passés au modèle comme contexte (effort de raisonnement, etc.). |
+- **LM Studio**
+
+| Champ                | Description                                                                                                                                   | Type                                                                                                                                                                                                                                                                                                                                                                                                                     | Par défaut  | Exemple                                                       | Note                                                                                                                                                                                                              |
+| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `provider`           | Le fournisseur à utiliser pour les fonctionnalités IA d'Intlayer.                                                                             | `'openai'` &#124; <br/> `'anthropic'` &#124; <br/> `'mistral'` &#124; <br/> `'deepseek'` &#124; <br/> `'gemini'` &#124; <br/> `'ollama'` &#124; <br/> `'openrouter'` &#124; <br/> `'alibaba'` &#124; <br/> `'fireworks'` &#124; <br/> `'groq'` &#124; <br/> `'huggingface'` &#124; <br/> `'bedrock'` &#124; <br/> `'googleaistudio'` &#124; <br/> `'googlevertex'` &#124; <br/> `'togetherai'` &#124; <br/> `'lmstudio'` | `undefined` | `'anthropic'`                                                 | Les différents fournisseurs nécessitent des clés API différentes et ont des tarifs variés.                                                                                                                        |
+| `model`              | Le modèle à utiliser pour les fonctionnalités IA.                                                                                             | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | Aucun       | `'gpt-4o-2024-11-20'`                                         | Le modèle spécifique varie selon le fournisseur.                                                                                                                                                                  |
+| `temperature`        | Contrôle le caractère aléatoire des réponses de l'IA.                                                                                         | `number`                                                                                                                                                                                                                                                                                                                                                                                                                 | Aucun       | `0.1`                                                         | Température plus élevée = plus créatif et moins prévisible.                                                                                                                                                       |
+| `apiKey`             | Votre clé API pour le fournisseur sélectionné.                                                                                                | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | Aucun       | `process.env.OPENAI_API_KEY`                                  | Garder secret ; stocker dans les variables d'environnement.                                                                                                                                                       |
+| `applicationContext` | Contexte supplémentaire sur votre application pour aider l'IA à générer des traductions plus précises (domaine, audience, ton, terminologie). | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | Aucun       | `'Mon contexte d'application'`                                | Peut être utilisé pour ajouter des règles (ex: `"Vous ne devez pas transformer les urls"`).                                                                                                                       |
+| `baseURL`            | L'URL de base pour l'API IA.                                                                                                                  | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | Aucun       | `'https://api.openai.com/v1'` <br/> `'http://localhost:5000'` | Peut pointer vers un point de terminaison d'API IA local ou personnalisé.                                                                                                                                         |
+| `dataSerialization`  | Format de sérialisation des données pour les fonctionnalités IA.                                                                              | `'json'` &#124; <br/> `'toon'`                                                                                                                                                                                                                                                                                                                                                                                           | `undefined` | `'toon'`                                                      | • `'json'`: standard, fiable ; utilise plus de tokens.<br/>• `'toon'`: moins de tokens, moins cohérent.<br/>• Des paramètres supplémentaires sont passés au modèle comme contexte (effort de raisonnement, etc.). |
 
 ---
 

package/docs/fr/dictionary/content_file.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-02-07
-updatedAt: 2026-01-28
+updatedAt: 2026-05-12
 title: Fichier de Contenu
 description: Apprenez à personnaliser les extensions pour vos fichiers de déclaration de contenu. Suivez cette documentation pour implémenter efficacement des conditions dans votre projet.
 keywords:
@@ -12,6 +12,9 @@ slugs:
   - concept
   - content
 history:
+  - version: 8.9.0
+    date: 2026-05-12
+    changes: "Ajouter le type de nœud de contenu `plural`"
   - version: 8.0.0
     date: 2026-01-28
     changes: "Ajout du type de nœud de contenu `html`"
@@ -63,6 +66,7 @@ import { type ReactNode } from "react";
 import {
   t,
   enu,
+  plural,
   cond,
   nest,
   md,
@@ -82,6 +86,7 @@ interface Content {
   };
   multilingualContent: string;
   quantityContent: string;
+  pluralContent: string;
   conditionalContent: string;
   markdownContent: never;
   htmlContent: never;
@@ -117,6 +122,10 @@ export default {
       ">5": "Quelques voitures",
       ">19": "Beaucoup de voitures",
     }),
+    pluralContent: plural({
+      one: "One car",
+      other: "{{count}} cars",
+    }),
     conditionalContent: cond({
       true: "La validation est activée",
       false: "La validation est désactivée",
@@ -171,6 +180,13 @@ export default {
         ">5": "Quelques voitures",
         ">19": "Beaucoup de voitures",
       },
+      "pluralContent": {
+        "nodeType": "plural",
+        "plural": {
+          "one": "One car",
+          "other": "{{count}} cars",
+        },
+      },
     },
     "conditionalContent": {
       "nodeType": "condition",
@@ -218,6 +234,7 @@ Les nœuds de contenu sont les éléments de base du contenu du dictionnaire. Il
 - **Valeurs primitives** : chaînes de caractères, nombres, booléens, null, undefined
 - **Nœuds typés** : Types de contenu spéciaux comme les traductions, conditions, markdown, etc.
 - **Fonctions** : Contenu dynamique pouvant être évalué à l'exécution [voir Récupération de fonctions](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/function_fetching.md)
+- **Contenu Pluriel**: Voir Contenu Pluriel [Voir Contenu Pluriel](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/plural.md)
 - **Contenu imbriqué** : Références à d'autres dictionnaires
 
 #### Types de contenu
@@ -536,6 +553,8 @@ multilingualContent: t({
 });
 ```
 
+> Voir [Contenu de traduction (`t`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/translation.md) pour plus d'informations.
+
 ### Contenu conditionnel (`cond`)
 
 Contenu qui change en fonction de conditions booléennes :
@@ -549,6 +568,8 @@ conditionalContent: cond({
 });
 ```
 
+> Voir [Contenu conditionnel (`cond`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/condition.md) pour plus d'informations.
+
 ### Contenu d'énumération (`enu`)
 
 Contenu qui varie en fonction de valeurs énumérées :
@@ -563,6 +584,23 @@ statusContent: enu({
 });
 ```
 
+> Voir [Contenu d'énumération (`enu`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/enumeration.md) pour plus d'informations.
+
+### Contenu Pluriel (`plural`)
+
+Contenu qui varie selon les règles de pluriel :
+
+```typescript
+import { plural } from "intlayer";
+
+pluralContent: plural({
+  one: "One car",
+  other: "{{count}} cars",
+});
+```
+
+> Voir [Contenu Pluriel Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/plural.md) pour plus d'informations.
+
 ### Contenu d'insertion (`insert`)
 
 Contenu qui peut être inséré dans un autre contenu :
@@ -573,6 +611,8 @@ import { insert } from "intlayer";
 insertionContent: insert("Ce texte peut être inséré n'importe où");
 ```
 
+> Voir [Contenu d'insertion (`insert`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/insertion.md) pour plus d'informations.
+
 ### Contenu imbriqué (`nest`)
 
 Références à d'autres dictionnaires :
@@ -583,6 +623,8 @@ import { nest } from "intlayer";
 nestedContent: nest("about-page");
 ```
 
+> Voir [Contenu imbriqué (`nest`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/nesting.md) pour plus d'informations.
+
 ### Contenu Markdown (`md`)
 
 Contenu riche au format Markdown :
@@ -595,6 +637,8 @@ markdownContent: md(
 );
 ```
 
+> Voir [Contenu Markdown (`md`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/markdown.md) pour plus d'informations.
+
 ### Contenu HTML (`html`)
 
 Contenu HTML riche pouvant utiliser des balises standard ou des composants personnalisés :
@@ -612,6 +656,8 @@ localizedHtmlContent: t({
 });
 ```
 
+> Voir [Contenu HTML (`html`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/html.md) pour plus d'informations.
+
 ### Contenu selon le genre (`gender`)
 
 Contenu qui varie selon le genre :
@@ -626,6 +672,8 @@ genderContent: gender({
 });
 ```
 
+> Voir [Contenu selon le genre (`gender`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/gender.md) pour plus d'informations.
+
 ### Contenu de fichier (`file`)
 
 Références à des fichiers externes :
@@ -636,6 +684,8 @@ import { file } from "intlayer";
 fileContent: file("./path/to/content.txt");
 ```
 
+> Voir [Contenu de fichier (`file`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/file.md) pour plus d'informations.
+
 ## Création de fichiers de contenu
 
 ### Structure de base d’un fichier de contenu

package/docs/fr/plugins/sync-po.md

@@ -160,30 +160,9 @@ syncPO({
   source: ({ key, locale }) => string, // requis
   location?: string, // étiquette optionnelle, défaut : "sync-po::path/to/source"
   priority?: number, // priorité optionnelle pour la résolution de conflits, défaut : 0
-  format?: 'icu' | 'i18next' | 'vue-i18n', // optionnel, nécessaire uniquement lorsque vos valeurs msgstr utilisent une syntaxe d'interpolation spécifique
 });
 ```
 
-#### `format` ('icu' | 'i18next' | 'vue-i18n')
-
-Les fichiers PO sont toujours des fichiers Gettext Portable Object — c'est fixe. Cette option décrit uniquement la **syntaxe d'interpolation** utilisée à l'intérieur des valeurs `msgstr`, afin qu'Intlayer puisse les convertir dans son propre format au moment de l'analyse (via `formatDictionary`) et inversement lors de l'écriture de la sortie.
-
-- `undefined` _(défaut)_ : les valeurs `msgstr` sont traitées comme des chaînes de caractères simples — pas de transformation. Utilisez ceci pour la plupart des fichiers PO.
-- `'icu'` : les valeurs `msgstr` utilisent la syntaxe de message ICU (ex : `{count, plural, one {# item} other {# items}}`).
-- `'i18next'` : les valeurs `msgstr` utilisent la syntaxe d'interpolation i18next (ex : `{{variable}}`).
-- `'vue-i18n'` : les valeurs `msgstr` utilisent la syntaxe Vue I18n.
-
-> La transformation est appliquée par `formatDictionary` de `@intlayer/chokidar` au chargement, et inversée avec `formatDictionaryOutput` à l'écriture. Pour les règles complexes comme les pluriels ICU, la fidélité de l'aller-retour n'est pas garantie.
-
-**Exemple — les fichiers PO contiennent une interpolation de style i18next :**
-
-```ts
-syncPO({
-  source: ({ key, locale }) => `./locales/${locale}/${key}.po`,
-  format: "i18next",
-}),
-```
-
 ### Sources PO multiples et priorité
 
 Vous pouvez ajouter plusieurs plugins `syncPO` pour synchroniser différentes sources PO. Ceci est utile lorsque vous avez plusieurs sources de traduction ou différentes structures PO dans votre projet.

package/docs/hi/benchmark/nextjs.md

@@ -61,6 +61,13 @@ i18n लाइब्रेरीज़ का एक अन्य प्रभ
 
 Intlayer इन सभी आयामों में अनुकूलन करने का प्रयास करता है।
 
+## TL;DR
+
+- **Intlayer** और **next-translate**: Next.js परफॉरमेंस के लिए सर्वोत्तम विकल्प, जो सबसे छोटा फुटप्रिंट और बेहतरीन स्टेटिक रेंडरिंग सपोर्ट प्रदान करते हैं।
+- **next-intl**: वर्तमान में सबसे ट्रेंडी विकल्प, लेकिन बड़ेप्लिकेशन्स के लिए अनुकूलित करना भारी और जटिल है।
+- **next-i18next**: लोकप्रिय और प्लगइन्स से भरपूर, लेकिन बंडल का आकार काफी अधिक है (~3 गुना Intlayer)।
+- **इनसे बचें**: गंभीर परफॉरमेंस समस्याओं, वेंडर लॉक-इन और बिल्ड को रोकने वाले बग्स के कारण **gt-next** और **lingo.dev** से बचें।
+
 ## अपने ऐप का परीक्षण करें
 
 इन समस्याओं को उजागर करने के लिए, मैंने एक मुफ़्त स्कैनर बनाया है जिसे आप [यहाँ](https://intlayer.org/i18n-seo-scanner) आज़मा सकते हैं।
@@ -99,14 +106,14 @@ Intlayer इन सभी आयामों में अनुकूलन क
 इस बेंचमार्क के लिए, हमने निम्नलिखित लाइब्रेरीज़ की तुलना की है:
 
 - `Base App` (कोई i18n लाइब्रेरी नहीं)
-- `next-intlayer` (v8.7.5)
+- `next-intlayer` (v8.7.12)
 - `next-i18next` (v16.0.5)
 - `next-intl` (v4.9.1)
 - `@lingui/core` (v5.3.0)
 - `next-translate` (v3.1.2)
 - `next-international` (v1.3.1)
 - `@inlang/paraglide-js` (v2.15.1)
-- `tolgee` (v7.0.0)
+- `@tolgee/react` (v7.0.0)
 - `@lingo.dev/compiler` (v0.4.0)
 - `wuchale` (v0.22.11)
 - `gt-next` (v6.16.5)
@@ -161,10 +168,10 @@ Intlayer इन सभी आयामों में अनुकूलन क
 
 **(General Translation)** (`gt-next@6.16.5`):
 
-- 110kb ऐप के लिए, `gt-react` 440kb से अधिक अतिरिक्त डेटा जोड़ता है।
+- 110kb ऐप के लिए, `gt-next` 440kb से अधिक अतिरिक्त डेटा जोड़ता है।
 - जनरल ट्रांसलेशन के साथ पहले ही बिल्ड पर `Quota Exceeded, please upgrade your plan` संदेश।
 - अनुवाद रेंडर नहीं होते हैं; मुझे एरर मिलता है `Error: <T> used on the client-side outside of <GTProvider>` , जो लाइब्रेरी में एक बग लगता है।
-- **gt-tanstack-start-react** को लागू करने के दौरान, मुझे लाइब्रेरी के साथ एक [इश्यू](https://github.com/generaltranslation/gt/issues/1210#event-24510646961) भी मिला: `does not provide an export named 'printAST' - @formatjs/icu-messageformat-parser` एरर, जिससे एप्लिकेशन क्रैश हो रहा था। इस समस्या की रिपोर्ट करने के बाद, मेंटेनर ने इसे 24 घंटों के भीतर ठीक कर दिया।
+- **gt-next** को लागू करने के दौरान, मुझे लाइब्रेरी के साथ एक [इश्यू](https://github.com/generaltranslation/gt/issues/1210#event-24510646961) भी मिला: `does not provide an export named 'printAST' - @formatjs/icu-messageformat-parser` एरर, जिससे एप्लिकेशन क्रैश हो रहा था। इस समस्या की रिपोर्ट करने के बाद, मेंटेनर ने इसे 24 घंटों के भीतर ठीक कर दिया।
 - लाइब्रेरी Next.js पेजों के स्टेटिक रेंडरिंग को ब्लॉक करती है।
 
 **(Lingo.dev)** (`@lingo.dev/compiler@0.4.0`):
@@ -186,9 +193,11 @@ Intlayer इन सभी आयामों में अनुकूलन क
 व्यक्तिगत रूप से मुझे हर पुश से पहले JS फ़ाइलों को दोबारा उत्पन्न करना पसंद नहीं है, जो PR के माध्यम से लगातार मर्ज संघर्ष का जोखिम पैदा करता है। यह टूल Next.js की तुलना में Vite पर अधिक केंद्रित लगता है।
 अंत में, अन्य समाधानों की तुलना में, Paraglide सामग्री रेंडर करने के लिए वर्तमान लोकेल को पुनः प्राप्त करने के लिए स्टोर (उदा. React context) का उपयोग नहीं करता है। पार्स किए गए प्रत्येक नोड के लिए, यह localStorage / कुकी आदि से लोकेल का अनुरोध करेगा। यह अनावश्यक तर्क के निष्पादन की ओर ले जाता है जो कंपोनेंट रिएक्टिविटी को प्रभावित करता है।
 
+> Paraglide पर नोट: यह समाधान इम्पोर्ट के लिए आपके कोडबेस में कोड इंजेक्ट करता है, जिसके परिणामस्वरूप बेंचमार्क रिपोर्ट में 'लाइब्रेरी आकार' मीट्रिक लगभग 0 है। कोड जेनरेशन एक अच्छी चीज़ है, क्योंकि उपयोग किया जाने वाला फंक्शन केवल आवश्यक लॉजिक (सभी प्रीफ़िक्स बनाम कोई प्रीफ़िक्स नहीं, कुकीज़ बनाम स्टोरेज, आदि) शामिल करेगा। इसकी तुलना में, Intlayer बिल्ड में एनवायरनमेंट वेरिएबल इंजेक्शन के माध्यम से यह फ़िल्टरिंग करता है ताकि बंडलर को लॉजिक के आधार पर सामग्री को ट्री-शेक करने के लिए मजबूर किया जा सके। इसके कारण, paraglide और intlayer अंत में i18next या next-intl की तुलना में 6 से 10 गुना हल्के समाधान साबित होते हैं।
+
 ### 3 — स्वीकार्य समाधान
 
-**(Tolgee)** (`tolgee@7.0.0`):
+**(Tolgee)** (`@tolgee/react@7.0.0`):
 
 `Tolgee` पहले उल्लेखित कई मुद्दों को संबोधित करता है। मुझे लगा कि इसे अपनाना समान उपकरणों की तुलना में कठिन है। यह टाइप सेफ्टी (type safety) प्रदान नहीं करता है, जिससे कंपाइल समय पर गायब कीज़ को पकड़ना भी कठिन हो जाता है। गायब-की पहचान जोड़ने के लिए मुझे Tolgee के फंक्शन्स को अपने फंक्शन्स के साथ रैप करना पड़ा।
 
@@ -216,7 +225,7 @@ Intlayer इन सभी आयामों में अनुकूलन क
 
 यदि आप `t()` स्टाइल की API पसंद करते हैं, तो `next-translate` मेरी मुख्य सिफारिश है। यह `next-translate-plugin` के माध्यम से सुंदर ढंग से काम करता है, जो Webpack / Turbopack लोडर के माध्यम से `getStaticProps` में नेमस्पेस लोड करता है। यह यहाँ सबसे हल्का विकल्प भी है (~2.5kb)। नेमस्पेसिंग के पार, कॉन्फ़िगरेशन में प्रति पेज या रूट नेमस्पेस परिभाषित करना अच्छी तरह से सोचा गया है और **next-intl** या **next-i18next** जैसे मुख्य विकल्पों की तुलना में बनाए रखना आसान है। वर्जन `3.1.2` में, मैंने पाया कि स्टेटिक रेंडरिंग काम नहीं करती थी; Next.js डायनेमिक रेंडरिंग पर वापस चला गया।
 
-**(Intlayer)** (`next-intlayer@8.7.5`):
+**(Intlayer)** (`next-intlayer@8.7.12`):
 
 निष्पक्षता के लिए मैं व्यक्तिगत रूप से मेरे स्वयं के समाधान `next-intlayer` पर निर्णय नहीं दूँगा।