@intlayer/docs 9.3.3 → 9.4.0

package/docs/fr/cli/ci.md

@@ -128,6 +128,8 @@ bun x intlayer ci fill --verbose --mode complete
 
 ### Utilisation dans les pipelines CI/CD
 
+L'exécution de `intlayer init` crée deux workflows GitHub Actions prêts à l'emploi pour vous (voir [Scaffolded GitHub Actions](#scaffolded-github-actions) ci-dessous). L'exemple ici montre la configuration équivalente en utilisant la commande `ci` pour un monorepo, où les credentials sont injectés par projet depuis `INTLAYER_PROJECT_CREDENTIALS`.
+
 Dans votre configuration CI/CD (par exemple, GitHub Actions, GitLab CI), définissez `INTLAYER_PROJECT_CREDENTIALS` comme secret :
 
 ```yaml

package/docs/fr/cli/doc-review.md

@@ -91,7 +91,13 @@ Pour la plupart des cas d'utilisation,
 
 - **`--log`** : Mode journalisation uniquement. Ne traduit pas avec l'IA ; à la place, journalise les blocs qui nécessitent une attention (avec les numéros de ligne et le contenu) pour les locales de base et cibles, afin d'aider un autre agent à générer les traductions.
 
-  > Exemple : `npx intlayer doc review --log`
+Je suis prêt à effectuer l'audit de traduction. Cependant, je n'ai pas encore reçu :
+
+> Exemple: `npx intlayer doc review --mode report`
+
+> Exemple : `npx intlayer doc review --log`
+
+Quel que soit le mode, l'exécution se termine par une synthèse listant les documents alignés avec leur document de base et ceux qui ont encore des blocs à modifier.
 
 **Options de sortie des entrées :**
 

package/docs/fr/cli/fill.md

@@ -39,14 +39,6 @@ bun x intlayer fill
 
 Cette commande analyse vos fichiers de déclaration de contenu pour détecter d’éventuels problèmes tels que des traductions manquantes, des incohérences structurelles ou des incompatibilités de types. Si elle trouve des problèmes, **intlayer fill** proposera ou appliquera des mises à jour pour garder vos dictionnaires cohérents et complets.
 
-Points clés :
-
-- Divise les grands fichiers JSON en morceaux pour rester dans les limites de la fenêtre de contexte du modèle d'IA.
-- Réessaie la traduction si le format de sortie est incorrect.
-- Intègre le contexte spécifique à l'application et au fichier pour améliorer la précision de la traduction.
-- Préserve les traductions existantes en ne les écrasant pas.
-- Traite les fichiers, les morceaux et les locales en parallèle à l'aide d'un système de file d'attente pour augmenter la vitesse.
-
 ## Points clés :
 
 - Divise les fichiers JSON volumineux en chunks pour rester dans les limites de la fenêtre contextuelle du modèle d'IA.

package/docs/fr/cli/index.md

@@ -127,6 +127,8 @@ Pour voir comment configurer les locales disponibles ou d'autres paramètres, re
 
 - **[Connexion](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/cli/login.md)** - S'authentifier auprès du CMS Intlayer et obtenir les identifiants d'accès
 
+> `intlayer login` génère une **clé d'accès** (`clientId` / `clientSecret`) que chaque commande authentifiée utilise. Le secret est une credential côté serveur et n'atteint jamais votre client bundle — voir [Keeping the access key safe](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/cli/login.md#keeping-the-access-key-safe).
+
 ### Commandes principales
 
 - **[Build de dictionnaires](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/cli/build.md)** - Construisez vos dictionnaires à partir des fichiers de déclaration de contenu

package/docs/fr/cli/list_projects.md

@@ -52,8 +52,6 @@ Cette commande recherche et liste tous les projets Intlayer en trouvant les rép
 
   > Exemple : `npx intlayer projects list --base-dir /path/to/workspace`
 
-  > Exemple : `npx intlayer projects list --base-dir /path/to/workspace`
-
 - **`--git-root`** : Rechercher à partir du répertoire racine git au lieu du répertoire de base. Ceci est utile pour trouver tous les projets Intlayer dans un monorepo ou un dépôt git.
 
   > Exemple : `npx intlayer projects list --git-root`

package/docs/fr/cli/login.md

@@ -122,6 +122,34 @@ INTLAYER_CLIENT_SECRET=your_client_secret
 }
 ```
 
+## Conserver la clé d'accès en sécurité
+
+`intlayer login` émet une **clé d'accès** : une paire `clientId` / `clientSecret` que chaque commande authentifiée (`push`, `pull`, `fill`, `configuration push`, `live`, …) utilise pour s'authentifier.
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    clientId: process.env.INTLAYER_CLIENT_ID,
+    clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+  },
+};
+
+export default config;
+```
+
+> **`clientSecret` est une credential côté serveur.** Elle accorde un accès API complet avec portée projet — lecture et écriture de vos dictionnaires, votre projet et votre organisation. Conservez-la dans `.env` (ignorée par git) ou votre stockage secret CI, et ne l'insérez jamais en dur dans le fichier de configuration.
+
+Intlayer force cela plutôt que de simplement le documenter :
+
+- `clientSecret` est **supprimée de la configuration que votre bundler inline**, elle ne peut donc pas atteindre un bundle navigateur quel que soit l'intégration de framework que vous utilisez. Elle n'est lue que côté serveur, au runtime, depuis l'environnement.
+- `clientId` est différente : c'est la **clé publique** du projet, sûre à déployer, et utilisée par [`@intlayer/analytics`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/analytics.md#how-events-are-authenticated) pour obtenir un token à courte durée de vie, réservé à l'ingestion.
+
+Commenter `clientId` suffit pour désactiver tout comportement authentifié — récupération de dictionnaire distant, accès CMS, analytics — même quand les variables d'environnement sont toujours définies.
+
+Pour les pipelines CI, préférez la [`commande ci`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/cli/ci.md), qui injecte les credentials pour la durée d'une seule exécution au lieu de les persister.
+
 ## Configuration manuelle
 
 Si le navigateur ne s'ouvre pas automatiquement, vous pouvez visiter manuellement l'URL affichée dans le terminal.

package/docs/fr/compiler.md

@@ -40,6 +40,12 @@ Le **Intlayer Compiler** est un outil puissant conçu pour automatiser le proces
 
 ## Pourquoi utiliser le Intlayer Compiler ?
 
+- **Automation** : Élimine la copie-collage manuelle du contenu dans les dictionnaires.
+
+- **Speed** : Extraction de contenu optimisée garantissant que votre processus de build reste rapide.
+
+- **Developer Experience** : Gardez les déclarations de contenu là où elles sont utilisées, améliorant ainsi la maintenabilité.
+
 - **Automatisation** : Élimine le copier-coller manuel du contenu dans les dictionnaires.
 - **Rapidité** : Extraction de contenu optimisée garantissant que votre processus de build reste rapide.
 - **Expérience développeur** : Gardez les déclarations de contenu là où elles sont utilisées, améliorant ainsi la maintenabilité.
@@ -54,6 +60,8 @@ Bien que le compilateur offre une excellente expérience "fonctionne tout seul",
 - **Ambiguïté heuristique** : Le compilateur doit deviner ce qui est du contenu destiné aux utilisateurs par rapport à la logique de l'application (par exemple, `className="active"`, codes de statut, identifiants de produits). Dans des bases de code complexes, cela peut conduire à de faux positifs ou à des chaînes manquées qui nécessitent des annotations manuelles et des exceptions.
 - **Extraction statique uniquement** : L'extraction basée sur le compilateur repose sur l'analyse statique. Les chaînes qui n'existent qu'à l'exécution (codes d'erreur API, champs CMS, etc.) ne peuvent pas être découvertes ou traduites par le compilateur seul, vous avez donc toujours besoin d'une stratégie i18n d'exécution complémentaire.
 
+- **Extraction statique uniquement** : L'extraction basée sur le compilateur repose sur l'analyse statique. Les chaînes qui n'existent qu'à l'exécution (codes d'erreur API, champs CMS, etc.) ne peuvent pas être découvertes ou traduites par le compilateur seul, vous avez donc besoin d'une stratégie i18n runtime complémentaire.
+
 Pour une comparaison architecturale plus approfondie, consultez l'article de blog [Compiler vs. Declarative i18n](https://github.com/aymericzip/intlayer/blob/main/docs/blog/fr/compiler_vs_declarative_i18n.md).
 
 Comme alternative, pour automatiser votre processus i18n tout en gardant un contrôle total de votre contenu, Intlayer fournit également une commande d'auto-extraction `intlayer extract` (voir la [documentation CLI](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/cli/extract.md)), ou la commande `Intlayer: extract content to Dictionary` de l'extension Intlayer VS Code (voir la [documentation de l'extension VS Code](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/vs_code_extension.md)).
@@ -94,12 +102,18 @@ export default defineConfig({
 });
 ```
 
+> Le plugin autonome `intlayerCompiler()` est toujours exporté pour les configurations avancées. L'enregistrer aux côtés de `intlayer()` est sûr — le compilateur se déduplique lui-même et s'exécute une seule fois.
+
 See complete tutorial: [Intlayer Compiler with Vite+React](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_with_vite+react_compiler.md)
 
 #### Support des frameworks
 
 Le plugin Vite détecte et gère automatiquement différents types de fichiers :
 
+- **React / JSX / TSX** : Géré nativement.
+
+- **Vue** : Requires `@intlayer/vue-compiler`.
+
 - **React / JSX / TSX** : Pris en charge nativement.
 - **Vue** : Nécessite `@intlayer/vue-compiler`.
 - **Svelte** : Nécessite `@intlayer/svelte-compiler`.

package/docs/fr/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-08-06
+updatedAt: 2026-08-22
 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: 9.3.3
+    date: 2026-08-22
+    changes: "Activer les analytics par défaut dès que `@intlayer/analytics` est installé"
   - version: 9.1.3
     date: 2026-08-06
     changes: "Rendre `routing.enableProxy` tri-état : non défini (auto), `true`, `false`"
@@ -380,8 +383,8 @@ const config: IntlayerConfig = {
   analytics: {
     /**
      * Indique si la collecte des analytics est activée (pages vues, expositions de contenu, événements A/B).
-     * Nécessite que `editor.clientId` soit défini pour l'attribution.
-     * Par défaut : false
+     * Nécessite que `@intlayer/analytics` soit installé et que `editor.clientId` soit défini pour l'attribution.
+     * Par défaut : true
      */
     enabled: true,
 
@@ -736,19 +739,17 @@ Définit les paramètres liés à l'éditeur intégré, y compris le port du ser
 | `liveSyncPort`               | Le port du serveur de synchronisation en direct.                                                                                                                                     | `number`                          | `4000`                              | `4000`                                                                                          |                                                                                                                                                                                                                                                                        |
 | `liveSyncURL`                | L'URL du serveur de synchronisation en direct.                                                                                                                                       | `string`                          | `'http://localhost:{liveSyncPort}'` | `'https://example.com'`                                                                         | Pointe vers localhost par défaut ; peut être changé pour un serveur de synchronisation en direct distant.                                                                                                                                                              |
 
----
-
 ### Configuration des Analytics (Analytics Configuration)
 
 Définit les paramètres liés aux analytics Intlayer : la collecte du contenu réellement affiché aux utilisateurs (pages vues, expositions de contenu) et l'alimentation des tests A/B sur le contenu.
 
-Les analytics sont strictement optionnelles (opt-in) : rien n'est collecté à moins que `analytics.enabled` soit explicitement défini sur `true` **et** qu'une clé de projet (`editor.clientId`) soit configurée pour l'attribution. Lorsqu'elles sont désactivées (par défaut), l'intégralité de l'intégration analytics est éliminée du bundle de votre application (dead-code elimination).
+Les analytics sont désactivables (opt-out) : elles sont activées par défaut et commencent à collecter dès que le paquet `@intlayer/analytics` est installé **et** qu'une clé de projet (`editor.clientId`) est configurée pour l'attribution. Définissez `analytics.enabled` sur `false` — ou n'installez pas le paquet — et l'intégralité de l'intégration analytics est éliminée du bundle de votre application (dead-code elimination).
 
-| Champ           | Description                                                                            | Type      | Par défaut | Exemple | Note                                                                                                                                    |
-| --------------- | -------------------------------------------------------------------------------------- | --------- | ---------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------- |
-| `enabled`       | Active la collecte des analytics (pages vues, expositions de contenu, événements A/B). | `boolean` | `false`    | `true`  | Nécessite que `editor.clientId` soit défini pour l'attribution ; sinon les analytics restent désactivées même si `enabled` vaut `true`. |
-| `flushInterval` | Millisecondes entre les envois groupés automatiques vers le backend.                   | `number`  | `20000`    | `10000` |                                                                                                                                         |
-| `sampleRate`    | Fraction des sessions à enregistrer, de `0` (aucune) à `1` (toutes).                   | `number`  | `1`        | `0.5`   | L'échantillonnage est déterministe par session, donc une session enregistrée rapporte tous ses événements (pas d'entonnoirs partiels).  |
+| Champ           | Description                                                                            | Type      | Par défaut | Exemple | Note                                                                                                                                                                               |
+| --------------- | -------------------------------------------------------------------------------------- | --------- | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `enabled`       | Active la collecte des analytics (pages vues, expositions de contenu, événements A/B). | `boolean` | `true`     | `false` | Nécessite que `@intlayer/analytics` soit installé et que `editor.clientId` soit défini pour l'attribution ; sinon les analytics restent désactivées même si `enabled` vaut `true`. |
+| `flushInterval` | Millisecondes entre les envois groupés automatiques vers le backend.                   | `number`  | `20000`    | `10000` |                                                                                                                                                                                    |
+| `sampleRate`    | Fraction des sessions à enregistrer, de `0` (aucune) à `1` (toutes).                   | `number`  | `1`        | `0.5`   | L'échantillonnage est déterministe par session, donc une session enregistrée rapporte tous ses événements (pas d'entonnoirs partiels).                                             |
 
 ---
 
@@ -984,10 +985,15 @@ Ces paramètres sont destinés aux cas d'utilisation avancés et à la configura
 | `configDir`               | Répertoire des fichiers de configuration compilés. | `string` | `'.intlayer/config'`              |         |      |
 | `cacheDir`                | Répertoire des fichiers de cache.                  | `string` | `'.intlayer/cache'`               |         |      |
 
----
-
 ### Configuration du Dictionnaire (Dictionary Configuration)
 
+Paramètres qui contrôlent les opérations du dictionnaire, y compris le comportement de remplissage automatique et la génération de contenu.
+
+Cette configuration de dictionnaire sert deux objectifs principaux :
+
+1. **Valeurs par défaut** : Définir les valeurs par défaut lors de la création de fichiers de déclaration de contenu
+2. **Comportement de secours** : Fournir des valeurs de secours lorsque des champs spécifiques ne sont pas définis, ce qui vous permet de définir le comportement de l'opération dictionnaire globalement
+
 Paramètres contrôlant les opérations de dictionnaire, y compris le comportement de remplissage automatique et la génération de contenu.
 
 | Champ                       | Description                                                                                                                                                      | Type                                                                                                            | Par défaut   | Exemple                                                                                     | Note                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
@@ -1029,8 +1035,6 @@ Paramètres pour personnaliser la sortie des logs d'Intlayer.
 | `mode`   | Indique le mode du logger. | `'default'` &#124; <br/> `'verbose'` &#124; <br/> `'disabled'` | `'default'`     | `'verbose'`             | • `'verbose'`: log plus d'infos pour le débogage.<br/>• `'disabled'`: désactive complètement le logger. |
 | `prefix` | Le préfixe du logger.      | `string`                                                       | `'[intlayer] '` | `'[my custom prefix] '` |                                                                                                         |
 
----
-
 ### Configuration AI
 
 Paramètres qui contrôlent les fonctionnalités IA d'Intlayer, y compris le fournisseur, le modèle et la clé API.
@@ -1070,8 +1074,6 @@ Intlayer supporte plusieurs fournisseurs d'IA pour une flexibilité accrue. Les
 | `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.). |
 
----
-
 ### Configuration de Build
 
 Paramètres qui contrôlent comment Intlayer optimise et construit l'internationalisation de votre application.
@@ -1109,8 +1111,6 @@ Paramètres qui contrôlent le compilateur Intlayer, qui extrait les dictionnair
 | `noMetadata`          | Si `true`, le compilateur omet les métadonnées du dictionnaire (clé, wrapper de contenu) de la sortie.                                                                                                                                                                                                                       | `boolean`                                                                                                       | `false`     | `false` → `{"key":"ma-clé","content":{"key":"valeur"}}` <br/> `true` → `{"key":"valeur"}`                                                                | • Utile pour les sorties JSON i18next ou ICU MessageFormat.<br/>• Fonctionne bien avec le plugin `loadJSON`.                                                                                                                                                                                                      |
 | `dictionaryKeyPrefix` | Préfixe de clé de dictionnaire                                                                                                                                                                                                                                                                                               | `string`                                                                                                        | `''`        |                                                                                                                                                          | Ajoute un préfixe optionnel aux clés de dictionnaire extraites                                                                                                                                                                                                                                                    |
 
----
-
 ### Schémas Personnalisés (Custom Schemas)
 
 | Champ     | Description                                                                       | Type                        |

package/docs/fr/custom_domains.md

@@ -138,6 +138,38 @@ getMultilingualUrls("/about", { currentDomain: "intlayer.org" });
 
 Ces URLs absolues sont prêtes à être utilisées dans les balises `<link rel="alternate" hreflang="...">` pour le SEO.
 
+## Inférence de type
+
+`routing.domains` est sérialisé dans l'augmentation de module générée, donc
+`getLocalizedUrl` et `getLocalizedPath` affinent leur type de retour à l'URL exacte
+qu'une locale routée par domaine résout — la suppression du préfixe incluse.
+
+```ts
+// routing: { mode: 'prefix-no-default', domains: { en: 'intlayer.org', zh: 'intlayer.zh' } }
+
+getLocalizedUrl("/about", "zh");
+//     ^? "https://intlayer.zh/about" | "/about"
+
+getLocalizedPath("/about", "zh");
+//     ^? "/about"   (jamais une origine, et pas de préfixe /zh/)
+```
+
+Le type URL est l'**union** des deux valeurs que la fonction peut retourner : l'URL
+absolue sur le domaine de la locale, et celle relative qu'elle retourne quand la
+page en cours de rendu vit déjà sur ce domaine. `getLocalizedPath` n'a pas cette
+ambiguïté — elle n'émet jamais une origine — donc elle reste un littéral unique.
+
+Les locales qui partagent un domaine conservent également leur préfixe normal dans le type :
+
+```ts
+getLocalizedUrl("/about", "fr");
+//     ^? "https://intlayer.org/fr/about" | "/fr/about"
+```
+
+> Régénérez les types (`npx intlayer build`, ou n'importe quelle exécution de dev server) après
+> avoir modifié `routing.domains` — l'affinement provient du
+> `__RoutingRegistry` généré, pas du fichier de configuration lui-même.
+
 ## Comportement du Proxy
 
 ### Next.js
@@ -170,6 +202,8 @@ GET intlayer.zh/about
 
 Le plugin Vite `intlayerProxy` applique la même logique pendant le développement :
 
+> Depuis Intlayer v9, `intlayerProxy()` est intégré directement dans le plugin `intlayer()` et activé par défaut via l'option `routing.enableProxy` (`true` par défaut). L'enregistrer séparément comme indiqué ci-dessous est maintenant optionnel — il est conservé pour la compatibilité rétroactive et pour les configurations qui ont besoin de contrôler l'ordre des plugins. Définissez `routing.enableProxy: false` pour refuser. Voir les [notes de version v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/fr/custom_url_rewrites.md

@@ -248,7 +248,7 @@ Pour faire en sorte que la barre d'adresse du navigateur reflète toujours l'URL
 
 <Tabs group='framework'>
   <Tab label="Next.js" value="nextjs">
-  
+
     ```tsx
     'use client';
 
@@ -263,7 +263,7 @@ Pour faire en sorte que la barre d'adresse du navigateur reflète toujours l'URL
   </Tab>
 
   <Tab label="React Router" value="reactrouter">
-  
+
     ```tsx
     'use client';
 
@@ -279,7 +279,7 @@ Pour faire en sorte que la barre d'adresse du navigateur reflète toujours l'URL
   </Tab>
 
   <Tab label="Vue" value="vue">
-  
+
     ```vue
     <script setup>
     import { useRewriteURL } from "vue-intlayer";
@@ -291,7 +291,7 @@ Pour faire en sorte que la barre d'adresse du navigateur reflète toujours l'URL
 
   </Tab>
   <Tab label="Solid" value="solid">
-  
+
     ```tsx
     import { useRewriteURL } from "solid-intlayer";
 
@@ -303,7 +303,7 @@ Pour faire en sorte que la barre d'adresse du navigateur reflète toujours l'URL
 
   </Tab>
   <Tab label="Svelte" value="svelte">
-  
+
     ```svelte
     <script>
     import { useRewriteURL } from "svelte-intlayer";
@@ -340,6 +340,8 @@ export function middleware(request: NextRequest) {
 
 Pour SolidJS, Vue et Svelte, le plugin Vite `intlayerProxy` gère les réécritures pendant le développement.
 
+> Depuis Intlayer v9, `intlayerProxy()` est intégré directement dans le plugin `intlayer()` et activé par défaut via l'option `routing.enableProxy` (`true` par défaut). Son enregistrement séparé comme montré ci-dessous est désormais optionnel — il est conservé pour la compatibilité rétroactive et pour les configurations qui ont besoin de contrôler l'ordre des plugins. Définissez `routing.enableProxy: false` pour refuser. Voir les [notes de publication v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/fr/dictionary/condition.md

@@ -23,209 +23,8 @@ author: aymericzip
 
 ## Comment Fonctionne la Condition
 
-<Tabs group="framework">
-  <Tab label="React" value="react">
-
-To utilize conditional content within a React component, import and use the `useIntlayer` hook from the `react-intlayer` package. This hook fetches the content for the specified key and allows you to pass in a condition to select the appropriate output.
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { useIntlayer } from "react-intlayer";
-
-const ConditionalComponent: FC = () => {
-  const { myCondition } = useIntlayer("my_key");
-
-  return (
-    <div>
-      <p>
-        {
-          /* Output: my content when it's true */
-          myCondition(true)
-        }
-      </p>
-      <p>
-        {
-          /* Output: my content when it's false */
-          myCondition(false)
-        }
-      </p>
-      <p>
-        {
-          /* Output: my content when the condition fails */
-          myCondition("")
-        }
-      </p>
-      <p>
-        {
-          /* Output: my content when the condition fails */
-          myCondition(undefined)
-        }
-      </p>
-    </div>
-  );
-};
-
-export default ConditionalComponent;
-```
-
-  </Tab>
-  <Tab label="Next.js" value="nextjs">
-
 To utilize conditional content in Next.js Client Components, retrieve it via the `useIntlayer` hook. Here's an example:
 
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-"use client";
-
-import type { FC } from "react";
-import { useIntlayer } from "next-intlayer";
-
-const ConditionalComponent: FC = () => {
-  const { myCondition } = useIntlayer("my_key");
-
-  return (
-    <div>
-      <p>{myCondition(true)}</p>
-      <p>{myCondition(false)}</p>
-    </div>
-  );
-};
-
-export default ConditionalComponent;
-```
-
-  </Tab>
-  <Tab label="Vue" value="vue">
-
-To utilize conditional content in Vue components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```vue fileName="**/*.vue"
-<script setup lang="ts">
-import { useIntlayer } from "vue-intlayer";
-
-const { myCondition } = useIntlayer("my_key");
-</script>
-
-<template>
-  <div>
-    <p>{{ myCondition(true) }}</p>
-    <p>{{ myCondition(false) }}</p>
-  </div>
-</template>
-```
-
-  </Tab>
-  <Tab label="Svelte" value="svelte">
-
-To utilize conditional content in Svelte components, retrieve it via the `useIntlayer` hook. The store is accessed with `$`. Here's an example:
-
-```svelte fileName="**/*.svelte"
-<script lang="ts">
-import { useIntlayer } from "svelte-intlayer";
-
-const content = useIntlayer("my_key");
-</script>
-
-<div>
-  <p>{$content.myCondition(true)}</p>
-  <p>{$content.myCondition(false)}</p>
-</div>
-```
-
-  </Tab>
-  <Tab label="Preact" value="preact">
-
-To utilize conditional content in Preact components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "preact";
-import { useIntlayer } from "preact-intlayer";
-
-const ConditionalComponent: FC = () => {
-  const { myCondition } = useIntlayer("my_key");
-
-  return (
-    <div>
-      <p>{myCondition(true)}</p>
-      <p>{myCondition(false)}</p>
-    </div>
-  );
-};
-
-export default ConditionalComponent;
-```
-
-  </Tab>
-  <Tab label="Solid" value="solid">
-
-To utilize conditional content in SolidJS components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { Component } from "solid-js";
-import { useIntlayer } from "solid-intlayer";
-
-const ConditionalComponent: Component = () => {
-  const { myCondition } = useIntlayer("my_key");
-
-  return (
-    <div>
-      <p>{myCondition(true)}</p>
-      <p>{myCondition(false)}</p>
-    </div>
-  );
-};
-
-export default ConditionalComponent;
-```
-
-  </Tab>
-  <Tab label="Angular" value="angular">
-
-To utilize conditional content in Angular components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```typescript fileName="app.component.ts" codeFormat="typescript"
-import { Component } from "@angular/core";
-import { useIntlayer } from "angular-intlayer";
-
-@Component({
-  selector: "app-conditional",
-  template: `
-    <div>
-      <p>{{ content().myCondition(true) }}</p>
-      <p>{{ content().myCondition(false) }}</p>
-    </div>
-  `,
-})
-export class ConditionalComponent {
-  content = useIntlayer("my_key");
-}
-```
-
-  </Tab>
-  <Tab label="Vanilla JS" value="vanilla">
-
-To utilize conditional content with `vanilla-intlayer`, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```typescript fileName="**/*.ts" codeFormat={["typescript", "esm"]}
-import { installIntlayer, useIntlayer } from "vanilla-intlayer";
-
-installIntlayer();
-
-const content = useIntlayer("my_key").onChange((newContent) => {
-  document.getElementById("true-content")!.textContent =
-    newContent.myCondition(true);
-  document.getElementById("false-content")!.textContent =
-    newContent.myCondition(false);
-});
-
-// Initial render
-document.getElementById("true-content")!.textContent =
-  content.myCondition(true);
-document.getElementById("false-content")!.textContent =
-  content.myCondition(false);
-```
-
-  </Tab>
-</Tabs>
 ## Configuration du Contenu Conditionnel
 
 Pour configurer le contenu conditionnel dans votre projet Intlayer, créez un module de contenu qui inclut vos définitions conditionnelles. Voici des exemples dans différents formats.