@intlayer/docs 9.1.3 → 9.2.0

package/docs/fr/analytics.md

@@ -0,0 +1,222 @@
+---
+createdAt: 2026-07-08
+updatedAt: 2026-07-08
+title: Analytique Intlayer | Suivre l'exposition du contenu et exécuter des tests A/B
+description: Découvrez comment @intlayer/analytics suit les vues de pages/locales et l'exposition du contenu, et comment l'utiliser pour exécuter des tests A/B sur votre contenu Intlayer.
+keywords:
+  - Analytique
+  - Tests A/B
+  - Audience
+  - Internationalisation
+  - Documentation
+  - Intlayer
+  - Next.js
+  - JavaScript
+  - React
+slugs:
+  - doc
+  - concept
+  - analytics
+history:
+  - version: 9.0.0
+    date: 2026-07-08
+    changes: "Init doc — package @intlayer/analytics, suivi au niveau du provider/node, tests A/B, dashboard"
+author: aymericzip
+---
+
+# Documentation Analytique Intlayer
+
+`@intlayer/analytics` est un package compagnon optionnel qui vous indique **quel contenu est réellement affiché** à vos visiteurs — quelle page, dans quelle locale, et quel élément de contenu traduit spécifique — afin que vous puissiez comprendre votre audience et exécuter des **tests A/B sur le contenu**.
+
+## Table des matières
+
+<TOC/>
+
+---
+
+## Ce qu'il suit
+
+`@intlayer/analytics` regroupe trois types d'événements anonymes en lots :
+
+| Événement          | Capturé où                                           | Ce qu'il vous indique                                                                                                                        |
+| ------------------ | ---------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `page_view`        | Niveau Provider (`IntlayerProvider`)                 | Quelle page et locale une session a consulté, lors du chargement initial, du changement de route ou du changement de locale.                 |
+| `content_exposure` | Niveau Nœud (`useIntlayer` / plugins d'interpréteur) | Quelle clé de dictionnaire / chemin de clé a été réellement résolu et affiché — et, si faisant partie d'une expérience, quelle **variante**. |
+| `conversion`       | Partout où vous appelez `useConversion()`            | Un objectif atteint (inscription, clic, achat…) attribué à la variante A/B à laquelle la session a été exposée.                              |
+
+Les événements sont collectés en mémoire et envoyés sous forme d'une **seule requête groupée (batch) environ toutes les 20 secondes** — jamais à chaque frappe au clavier ou rendu — donc l'analytique n'impacte jamais le temps de premier rendu et n'ajoute pas une requête par interaction.
+
+## Comment cela propulse les tests A/B sur le contenu
+
+Intlayer vous permet déjà de déclarer des [Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/index.md) de contenu (par exemple un dictionnaire `hero-banner` avec une variante `control` et une variante `black_friday`). `@intlayer/analytics` boucle la boucle :
+
+1. `getVariant(experimentKey, variants)` attribue de manière déterministe chaque session anonyme à une variante — une fonction pure de l'ID de session et de la clé d'expérience, donc l'attribution est **stable dans toute la session** et ne nécessite **aucun aller-retour serveur** avant le premier rendu (pas de scintillement, pas de décalage de mise en page).
+2. Chaque événement `content_exposure` transporte la `variant` qui a été affichée.
+3. `useConversion()` vous permet d'attribuer un objectif (par exemple `"cta_click"`) à cette variante.
+4. L'endpoint des résultats d'expérience du tableau de bord compare les taux de conversion par variante, y compris la signification statistique (un test z).
+
+## Installation
+
+`@intlayer/analytics` est une dépendance **peer, optionnelle** — jamais installée automatiquement par un package de framework. Ajoutez-la aux côtés de `intlayer` :
+
+```bash packageManager="npm"
+npm install @intlayer/analytics
+```
+
+```bash packageManager="yarn"
+yarn add @intlayer/analytics
+```
+
+```bash packageManager="pnpm"
+pnpm add @intlayer/analytics
+```
+
+```bash packageManager="bun"
+bun add @intlayer/analytics
+```
+
+Si vous ne l'installez pas, chaque point d'intégration se résout en une opération vide (no-op) — voir [Zéro coût quand non installé](#zero-cout-quand-non-installe) ci-dessous.
+
+## Configuration
+
+Analytics **réutilise le bloc de configuration `editor` existant** — il n'y a pas de schéma de configuration `analytics` séparé à remplir :
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    backendURL: "https://back.intlayer.org", // Également utilisé comme endpoint d'ingestion d'analytique
+    clientId: "your-client-id", // Aussi utilisé comme clé de projet analytique
+    clientSecret: "your-client-secret",
+  },
+};
+
+export default config;
+```
+
+- `editor.backendURL` — l'URL de base vers laquelle les événements analytiques sont envoyés (`POST {backendURL}/api/analytics/events`).
+- `editor.clientId` — la clé de projet publique attribuée à chaque événement ingéré. Elle agit également comme **interrupteur d'activation** : l'analytique reste complètement désactivée (et éliminée du code par tree-shaking, voir ci-dessous) jusqu'à ce que `clientId` soit configuré.
+
+Si vous auto-hébergez (self-host) Intlayer, l'analytique pointe automatiquement vers votre propre instance puisqu'elle partage `editor.backendURL`.
+
+## Support des frameworks
+
+Analytics est intégré dans le `IntlayerProvider` partagé de `react-intlayer`, il est donc disponible dès aujourd'hui partout où ce provider est utilisé :
+
+| Framework                                                | Statut                                                                                                           |
+| -------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| React                                                    | ✅ Disponible                                                                                                    |
+| Next.js (`next-intlayer`)                                | ✅ Disponible (via `react-intlayer`)                                                                             |
+| React Native / Expo (`react-native-intlayer`)            | ✅ Disponible (via `react-intlayer`)                                                                             |
+| Vue, Svelte, Angular, Solid, Preact, Lit, Astro, Vanilla | 🚧 Planifié — même client, liaisons au niveau du provider suivant le modèle de déploiement de `@intlayer/editor` |
+
+## Utilisation
+
+### Suivi automatique au niveau du provider
+
+Aucune modification de code n'est requise. Une fois que `@intlayer/analytics` est installé et que `editor.clientId` est configuré, `IntlayerProvider` effectue automatiquement les actions suivantes :
+
+- initialise le client d'analytique au montage (mount),
+- enregistre un `page_view` au chargement initial,
+- enregistre un `page_view` à chaque changement de locale,
+- démarre la boucle de flush d'environ 20s et vide tous les événements restants au démontage / fermeture d'onglet (via `navigator.sendBeacon`, avec un repli vers `fetch(..., { keepalive: true })`).
+
+### Suivi automatique au niveau des nœuds
+
+Chaque fois que `useIntlayer` résout un élément de contenu pour l'affichage, l'interpréteur signale un événement `content_exposure` pour ce(tte) `dictionaryKey` + chemin de clé + locale exacte — là encore, aucune modification de code n'est requise. Les expositions répétées du même nœud dans une fenêtre de flush sont fusionnées en un seul événement avec un `count`, donc une liste qui se re-rend 50 fois n'envoie pas 50 événements.
+
+### Suivi des conversions pour les tests A/B
+
+Utilisez `useConversion()` pour attribuer un objectif à la variante qu'une session a vue :
+
+```tsx fileName="CTAButton.tsx" codeFormat="tsx"
+import { useConversion } from "react-intlayer";
+
+const CTAButton = () => {
+  const trackConversion = useConversion();
+
+  return (
+    <button
+      onClick={() =>
+        trackConversion({
+          experimentKey: "homepage-hero",
+          variant: "black_friday",
+          goal: "cta_click",
+        })
+      }
+    >
+      Commencer
+    </button>
+  );
+};
+```
+
+### Résolution d'une variante côté client
+
+```tsx fileName="useHeroVariant.ts" codeFormat="tsx"
+import { getGlobalAnalyticsClient } from "@intlayer/analytics/client";
+
+const client = getGlobalAnalyticsClient();
+const variant = client?.getVariant("homepage-hero", [
+  "control",
+  "black_friday",
+]);
+```
+
+## Confidentialité & performance
+
+- **Anonyme par conception** : les sessions sont identifiées par un ID rotatif ; le backend ne stocke jamais qu'un **hash SHA-256** de cet ID — jamais l'ID brut, jamais une adresse IP.
+- **La localisation est approximative (coarse)** : uniquement un code pays, dérivé des en-têtes de géolocalisation CDN (`cf-ipcountry`, `x-vercel-ip-country`, …) — aucune IP n'est lue ou stockée.
+- **Les URL excluent les paramètres de recherche** par défaut, les chaînes de requête (query strings) ne sont donc jamais capturées.
+- **Échantillonnage (Sampling)** : `sampleRate` vous permet de conserver seulement une fraction des événements d'exposition de contenu sur les applications à fort trafic.
+- **En lots (Batched)** : une requête environ toutes les 20 secondes (`flushInterval`), ou plus tôt si le tampon se remplit (`maxBufferSize`) — jamais une requête par événement.
+
+### Zéro coût quand non installé
+
+`@intlayer/analytics` suit exactement le même modèle de dépendance optionnelle que `@intlayer/editor` :
+
+- chaque point d'intégration charge le package via un **`import()` dynamique enveloppé dans un `try/catch`** — une application qui n'installe jamais `@intlayer/analytics` ne paie aucun coût en taille de bundle ou à l'exécution, et ne voit jamais d'erreur ;
+- une variable d'environnement au moment de la compilation (`INTLAYER_ANALYTICS_ENABLED`), définie automatiquement à `'false'` par `@intlayer/config` chaque fois que `editor.clientId` n'est pas configuré, permet aux bundlers d'**éliminer le code mort (dead-code-eliminate)** de toute l'intégration ;
+- l'analytique est désactivée à l'intérieur de l'iframe de prévisualisation de l'éditeur/CMS Intlayer, afin que les sessions d'éditeur ne soient jamais comptées comme du vrai trafic.
+
+## Tableau de bord : Page Analytique
+
+Une fois que votre projet a collecté des événements, la page **Analytics** dans le [tableau de bord Intlayer](https://app.intlayer.org/analytics) (visible dans la barre latérale une fois qu'un projet est sélectionné) affiche :
+
+- **Utilisateurs actifs** — visiteurs uniques sur la fenêtre glissante sélectionnée (7 / 30 / 90 jours).
+- **Utilisateurs aujourd'hui** et **utilisateurs au cours des 7 derniers jours**.
+- **Pages vues** sur la fenêtre sélectionnée.
+- Un **graphique d'évolution** des visiteurs uniques quotidiens.
+- Des onglets de répartition par **Locales** et par **Emplacement (Location)**, classant votre audience par locale et par pays.
+
+## Référence API Backend
+
+Tous les endpoints de lecture nécessitent une authentification ; l'ingestion est publique et attribuée par `clientId` dans le corps (body).
+
+| Méthode | Endpoint                                    | Description                                                                     |
+| ------- | ------------------------------------------- | ------------------------------------------------------------------------------- |
+| `POST`  | `/api/analytics/events`                     | Ingérer un lot d'événements (public, attribué par `clientId` dans le body).     |
+| `GET`   | `/api/analytics/overview`                   | Totaux de pages/locales pour le projet authentifié.                             |
+| `GET`   | `/api/analytics/audience?days=30`           | Visiteurs uniques, pages vues, série quotidienne, répartitions locale + pays.   |
+| `GET`   | `/api/analytics/content-stats`              | Totaux d'exposition par contenu, groupés par clé de dictionnaire/chemin/locale. |
+| `GET`   | `/api/analytics/experiments/:experimentKey` | Taux de conversion par variante et signification statistique pour un test A/B.  |
+
+Vous pouvez également appeler ces endpoints de manière programmatique avec le [SDK CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_CMS.md) :
+
+```ts fileName="analytics.ts"
+import { createIntlayerCMS } from "@intlayer/api";
+import { analyticsEndpoint } from "@intlayer/api/analytics";
+
+const cms = createIntlayerCMS();
+
+const { data: audience } = await analyticsEndpoint(cms).getAudience(30);
+```
+
+## Liens utiles
+
+- [Dictionnaires dynamiques - Collections et variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dynamic_dictionaries/index.md)
+- [Intlayer CMS - SDK CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_CMS.md)
+- [Éditeur Visuel Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_visual_editor.md)
+- [Référence de configuration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/configuration.md)
+- [Guide d'auto-hébergement (Self-Hosting)](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/self_hosting.md)

package/docs/fr/autoFill.md

@@ -75,11 +75,30 @@ Dans v7, le comportement de la commande `fill` a été mis à jour :
 
 Lors de l'utilisation d'une option de chemin pour écrire dans un autre fichier, le mécanisme de remplissage fonctionne via une relation _maître-esclave_ entre les fichiers de déclaration de contenu. Le fichier principal (maître) sert de source de vérité, et lorsqu'il est mis à jour, Intlayer applique automatiquement ces modifications aux fichiers de déclaration dérivés (remplis) spécifiés par le chemin.
 
-# Traductions des fichiers de déclaration de contenu avec remplissage automatique
+### Personnalisation par locale
 
-**Les fichiers de déclaration de contenu avec remplissage automatique** sont un moyen d'accélérer votre flux de travail de développement.
+Vous pouvez également personnaliser le comportement pour chaque locale en utilisant un objet :
 
-Le mécanisme de remplissage automatique fonctionne via une relation _maître-esclave_ entre les fichiers de déclaration de contenu. Lorsque le fichier principal (maître) est mis à jour, Intlayer applique automatiquement ces modifications aux fichiers de déclaration dérivés (remplis automatiquement).
+```ts fileName="intlayer.config.ts"
+const config: IntlayerConfig = {
+  content: {
+    internationalization: {
+      locales: [Locales.ENGLISH, Locales.FRENCH, Locales.POLISH],
+      defaultLocale: Locales.ENGLISH,
+      requiredLocales: [Locales.ENGLISH], // Recommandé pour éviter Property 'pl' is missing in type '{ en: string; xxx } on your t function if
+    },
+  },
+  dictionary: {
+    fill: {
+      en: true, // Remplir et modifier le fichier courant pour l'anglais
+      fr: "./translations/fr.json", // Créer un fichier séparé pour le français
+      es: false, // Désactiver le remplissage pour l'espagnol
+    },
+  },
+};
+```
+
+Cela vous permet d'avoir différents comportements de remplissage pour différentes locales au sein du même projet.
 
 ```ts fileName="src/components/example/example.content.ts"
 import { Locales, type Dictionary } from "intlayer";
@@ -87,16 +106,16 @@ import { Locales, type Dictionary } from "intlayer";
 const exampleContent = {
   key: "example",
   locale: Locales.ENGLISH,
-  autoFill: "./example.content.json",
+  fill: "./example.content.json",
   content: {
-    contentExample: "Ceci est un exemple de contenu", // Exemple de contenu
+    contentExample: "This is an example of content",
   },
 } satisfies Dictionary;
 
 export default exampleContent;
 ```
 
-Voici un [fichier de déclaration de contenu par langue](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/per_locale_file.md) utilisant l'instruction `autoFill`.
+Voici un [fichier de déclaration de contenu par locale](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/per_locale_file.md) utilisant l'instruction `fill`.
 
 Ensuite, lorsque vous exécutez la commande suivante :
 
@@ -116,7 +135,7 @@ pnpm intlayer fill --file 'src/components/example/example.content.ts'
 bun x intlayer fill --file 'src/components/example/example.content.ts'
 ```
 
-Intlayer générera automatiquement le fichier de déclaration dérivé à `src/components/example/example.content.json`, en remplissant toutes les locales non déjà déclarées dans le fichier principal.
+Intlayer générera automatiquement le fichier de déclaration dérivé à `src/components/example/example.content.json`, en remplissant toutes les locales non déclarées dans le fichier principal.
 
 ```json5 fileName="src/components/example/example.content.json"
 {
@@ -133,7 +152,7 @@ Intlayer générera automatiquement le fichier de déclaration dérivé à `src/
 }
 ```
 
-Ensuite, les deux fichiers de déclaration seront fusionnés en un seul dictionnaire, accessible via le hook standard `useIntlayer("example")` (react) / composable (vue).
+Après cela, les deux fichiers de déclaration seront fusionnés en un seul dictionnaire, accessible à l'aide du hook `useIntlayer("example")` standard (react) / composable (vue).
 
 ## Configuration globale
 

package/docs/fr/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-07-11
+updatedAt: 2026-08-06
 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.1.3
+    date: 2026-08-06
+    changes: "Rendre `routing.enableProxy` tri-état : non défini (auto), `true`, `false`"
   - version: 9.0.0
     date: 2026-07-11
     changes: "Ajout de la configuration `analytics`"
@@ -235,6 +238,19 @@ const config: IntlayerConfig = {
      */
     mode: "prefix-no-default",
 
+    /**
+     * Active le proxy de routage des locales d'Intlayer (middleware).
+     * Gère la détection de la locale, les redirections et les réécritures en dev, preview et SSR.
+     * - non défini (auto) : les serveurs de dev et de preview gardent le routage
+     *   piloté par l'URL en ignorant la locale stockée dans les cookies et les en-têtes.
+     *   Les préfixes sont toujours résolus, la locale est toujours persistée et la
+     *   détection Accept-Language s'applique toujours. En production, se comporte comme `true`.
+     * - true : comportement complet dans tous les environnements.
+     * - false : aucun routage de locale.
+     * Par défaut : undefined (auto)
+     */
+    enableProxy: undefined,
+
     /**
      * Où stocker la locale sélectionnée par l'utilisateur.
      * Options : 'cookie', 'localStorage', 'sessionStorage', 'header', ou un tableau de ceux-ci.
@@ -716,13 +732,14 @@ Les analytics sont strictement optionnelles (opt-in) : rien n'est collecté à m
 
 Paramètres contrôlant le comportement du routage, y compris la structure des URL, le stockage des locales et la gestion du middleware.
 
-| Champ      | Description                                                                                                                                                                                                                      | Type                                                                                                                                                                                                         | Par défaut             | Exemple                                                                                                                                                                                       | Note                                                                                                                                                                                                                                                                                                                 |
-| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mode`     | Mode de routage d'URL pour la gestion des locales.                                                                                                                                                                               | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) ou `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: locale gérée par d'autres moyens. `'search-params'`: `/dashboard?locale=fr` | N'impacte pas la gestion des cookies ou du stockage des locales.                                                                                                                                                                                                                                                     |
-| `storage`  | Configuration pour stocker la locale sur le client.                                                                                                                                                                              | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                            | Voir le tableau des Options de Stockage ci-dessous.                                                                                                                                                                                                                                                                  |
-| `basePath` | Le chemin de base pour les URL de l'application.                                                                                                                                                                                 | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                   | Si l'application est sur `https://example.com/my-app`, basePath est `'/my-app'` et les URL deviennent `https://example.com/my-app/en`.                                                                                                                                                                               |
-| `rewrite`  | Règles de réécriture d'URL personnalisées qui surchargent le mode de routage par défaut pour des chemins spécifiques. Supporte les paramètres dynamiques `[param]`.                                                              | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Voir l'exemple ci-dessous                                                                                                                                                                     | • Les règles de réécriture ont la priorité sur le `mode`.<br/>• Fonctionne avec Next.js et Vite.<br/>• `getLocalizedUrl()` applique automatiquement les règles correspondantes.<br/>• Voir [Réécritures d'URL Personnalisées](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/custom_url_rewrites.md). |
-| `domains`  | Mappe les locales aux noms d'hôte de domaine pour le routage basé sur le domaine. Lorsqu'il est défini, les URL pour une locale utilisent ce domaine comme base (URL absolue) et aucun préfixe de locale n'est ajouté au chemin. | `Partial<Record<Locale, string>>`                                                                                                                                                                            | `undefined`            | `{ zh: 'intlayer.zh', fr: 'intlayer.org' }`                                                                                                                                                   | • Le protocole est défini par défaut sur `https://` lorsqu'il n'est pas inclus dans le nom d'hôte.<br/>• Le domaine lui-même identifie la locale, donc aucun préfixe `/zh/` n'est ajouté.<br/>• `getLocalizedUrl('/', 'zh')` renvoie `https://intlayer.zh/`.                                                         |
+| Champ         | Description                                                                                                                                                                                                                      | Type                                                                                                                                                                                                         | Par défaut             | Exemple                                                                                                                                                                                       | Note                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mode`        | Mode de routage d'URL pour la gestion des locales.                                                                                                                                                                               | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) ou `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: locale gérée par d'autres moyens. `'search-params'`: `/dashboard?locale=fr` | N'impacte pas la gestion des cookies ou du stockage des locales.                                                                                                                                                                                                                                                                                                                                                                |
+| `enableProxy` | Active le proxy de routage des locales d'Intlayer (middleware).                                                                                                                                                                  | `boolean` &#124; <br/> `undefined`                                                                                                                                                                           | `undefined` (auto)     | `true`                                                                                                                                                                                        | • Non défini (auto) : les serveurs de dev et de preview ignorent la locale stockée dans les cookies/en-têtes comme source de redirection ; les préfixes, la persistance et la détection `Accept-Language` s'appliquent toujours. En production, se comporte comme `true`.<br/>• `true` : comportement complet partout.<br/>• `false` : aucun routage de locale. Sur Next.js, le middleware `intlayerProxy` devient transparent. |
+| `storage`     | Configuration pour stocker la locale sur le client.                                                                                                                                                                              | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                            | Voir le tableau des Options de Stockage ci-dessous.                                                                                                                                                                                                                                                                                                                                                                             |
+| `basePath`    | Le chemin de base pour les URL de l'application.                                                                                                                                                                                 | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                   | Si l'application est sur `https://example.com/my-app`, basePath est `'/my-app'` et les URL deviennent `https://example.com/my-app/en`.                                                                                                                                                                                                                                                                                          |
+| `rewrite`     | Règles de réécriture d'URL personnalisées qui surchargent le mode de routage par défaut pour des chemins spécifiques. Supporte les paramètres dynamiques `[param]`.                                                              | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Voir l'exemple ci-dessous                                                                                                                                                                     | • Les règles de réécriture ont la priorité sur le `mode`.<br/>• Fonctionne avec Next.js et Vite.<br/>• `getLocalizedUrl()` applique automatiquement les règles correspondantes.<br/>• Voir [Réécritures d'URL Personnalisées](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/custom_url_rewrites.md).                                                                                                            |
+| `domains`     | Mappe les locales aux noms d'hôte de domaine pour le routage basé sur le domaine. Lorsqu'il est défini, les URL pour une locale utilisent ce domaine comme base (URL absolue) et aucun préfixe de locale n'est ajouté au chemin. | `Partial<Record<Locale, string>>`                                                                                                                                                                            | `undefined`            | `{ zh: 'intlayer.zh', fr: 'intlayer.org' }`                                                                                                                                                   | • Le protocole est défini par défaut sur `https://` lorsqu'il n'est pas inclus dans le nom d'hôte.<br/>• Le domaine lui-même identifie la locale, donc aucun préfixe `/zh/` n'est ajouté.<br/>• `getLocalizedUrl('/', 'zh')` renvoie `https://intlayer.zh/`.                                                                                                                                                                    |
 
 **Exemple de `rewrite`** :
 

package/docs/fr/dictionary/file.md

@@ -25,6 +25,8 @@ author: aymericzip
 
 # Contenu de fichier / Intégration de fichiers dans Intlayer
 
+Dans Intlayer, la fonction `file` permet d'intégrer le contenu de fichiers externes dans un dictionnaire. Cette approche garantit qu'Intlayer reconnaît le fichier source, permettant une intégration transparente avec l'Intlayer Visual Editor et le CMS.
+
 ## Comment fonctionne l'intégration de fichiers
 
 Dans Intlayer, la fonction `file` permet d'intégrer le contenu d'un fichier externe dans un dictionnaire. Cette approche garantit qu'Intlayer reconnaît le fichier source, permettant une intégration fluide avec l'éditeur visuel Intlayer et le CMS. Contrairement aux méthodes directes `import`, `require` ou de lecture de fichier via `fs`, l'utilisation de `file` associe le fichier au dictionnaire, ce qui permet à Intlayer de suivre et de mettre à jour dynamiquement le contenu lorsque le fichier est modifié.

package/docs/fr/dictionary/nesting.md

@@ -64,199 +64,52 @@ export default firstDictionary;
 }
 ```
 
-## Configuration de l'imbrication
+### Référencement avec Nest
 
-<Tabs group="framework">
-  <Tab label="React" value="react">
+Maintenant, créez un autre module de contenu qui utilise la fonction `nest` pour référencer le contenu ci-dessus. Vous pouvez référencer l'intégralité du contenu ou une valeur imbriquée spécifique :
 
-To use nested content in a React component, leverage the `useIntlayer` hook from the `react-intlayer` package. This hook retrieves the correct content based on the specified key. Here's an example of how to use it:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { useIntlayer } from "react-intlayer";
-
-const NestComponent: FC = () => {
-  const { fullNestedContent, partialNestedContent } = useIntlayer(
-    "key_of_my_second_dictionary"
-  );
+```typescript fileName="secondDictionary.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { nest, type Dictionary } from "intlayer";
 
-  return (
-    <div>
-      <p>Full Nested Content: {JSON.stringify(fullNestedContent)}</p>
-      <p>Partial Nested Value: {partialNestedContent}</p>
-    </div>
-  );
-};
-
-export default NestComponent;
-```
-
-  </Tab>
-  <Tab label="Next.js" value="nextjs">
-
-To use nested 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 NestComponent: FC = () => {
-  const { fullNestedContent, partialNestedContent } = useIntlayer(
-    "key_of_my_second_dictionary"
-  );
-
-  return (
-    <div>
-      <p>Full Nested Content: {JSON.stringify(fullNestedContent)}</p>
-      <p>Partial Nested Value: {partialNestedContent}</p>
-    </div>
-  );
-};
-
-export default NestComponent;
-```
-
-  </Tab>
-  <Tab label="Vue" value="vue">
-
-To use nested 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 { fullNestedContent, partialNestedContent } = useIntlayer(
-  "key_of_my_second_dictionary"
-);
-</script>
-
-<template>
-  <div>
-    <p>Full Nested Content: {{ JSON.stringify(fullNestedContent) }}</p>
-    <p>Partial Nested Value: {{ partialNestedContent }}</p>
-  </div>
-</template>
-```
-
-  </Tab>
-  <Tab label="Svelte" value="svelte">
-
-To use nested 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("key_of_my_second_dictionary");
-</script>
-
-<div>
-  <p>Full Nested Content: {JSON.stringify($content.fullNestedContent)}</p>
-  <p>Partial Nested Value: {$content.partialNestedContent}</p>
-</div>
-```
-
-  </Tab>
-  <Tab label="Preact" value="preact">
-
-To use nested 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 NestComponent: FC = () => {
-  const { fullNestedContent, partialNestedContent } = useIntlayer(
-    "key_of_my_second_dictionary"
-  );
-
-  return (
-    <div>
-      <p>Full Nested Content: {JSON.stringify(fullNestedContent)}</p>
-      <p>Partial Nested Value: {partialNestedContent}</p>
-    </div>
-  );
-};
-
-export default NestComponent;
-```
-
-  </Tab>
-  <Tab label="Solid" value="solid">
-
-To use nested 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 NestComponent: Component = () => {
-  const { fullNestedContent, partialNestedContent } = useIntlayer(
-    "key_of_my_second_dictionary"
-  );
-
-  return (
-    <div>
-      <p>Full Nested Content: {JSON.stringify(fullNestedContent)}</p>
-      <p>Partial Nested Value: {partialNestedContent}</p>
-    </div>
-  );
-};
-
-export default NestComponent;
-```
-
-  </Tab>
-  <Tab label="Angular" value="angular">
-
-To use nested 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";
+const myNestingContent = {
+  key: "key_of_my_second_dictionary",
+  content: {
+    // Référence l'intégralité du dictionnaire :
+    fullNestedContent: nest("key_of_my_first_dictionary"),
+    // Référence une valeur imbriquée spécifique :
+    partialNestedContent: nest(
+      "key_of_my_first_dictionary",
+      "subContent.contentNumber"
+    ),
+  },
+} satisfies Dictionary;
 
-@Component({
-  selector: "app-nest",
-  template: `
-    <div>
-      <p>
-        Full Nested Content: {{ JSON.stringify(content().fullNestedContent) }}
-      </p>
-      <p>Partial Nested Value: {{ content().partialNestedContent }}</p>
-    </div>
-  `,
-})
-export class NestComponent {
-  content = useIntlayer("key_of_my_second_dictionary");
-  JSON = JSON;
-}
+export default myNestingContent;
 ```
 
-  </Tab>
-  <Tab label="Vanilla JS" value="vanilla">
-
-To use nested 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("key_of_my_second_dictionary").onChange(
-  (newContent) => {
-    document.getElementById("nested")!.textContent =
-      newContent.partialNestedContent;
+```json fileName="secondDictionary.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "key_of_my_second_dictionary",
+  "content": {
+    "fullNestedContent": {
+      "nodeType": "nested",
+      "nested": {
+        "dictionaryKey": "key_of_my_first_dictionary"
+      }
+    },
+    "partialNestedContent": {
+      "nodeType": "nested",
+      "nested": {
+        "dictionaryKey": "key_of_my_first_dictionary",
+        "path": "subContent.contentNumber"
+      }
+    }
   }
-);
-
-// Initial render
-document.getElementById("nested")!.textContent = content.partialNestedContent;
+}
 ```
 
-  </Tab>
-</Tabs>
+En tant que deuxième paramètre, vous pouvez spécifier un chemin vers une valeur imbriquée dans ce contenu. Lorsqu'aucun chemin n'est fourni, l'intégralité du contenu du dictionnaire référencé est retournée.
 
 ## Utilisation de l'imbrication avec React Intlayer