@intlayer/docs 9.1.3 → 9.3.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/bundle_optimization.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-11-25
-updatedAt: 2026-06-07
+updatedAt: 2026-08-09
 title: Optimisation de la taille et des performances du bundle i18n
 description: Réduisez la taille du bundle de votre application en optimisant le contenu d'internationalisation (i18n). Apprenez à exploiter le tree shaking et le lazy loading pour les dictionnaires avec Intlayer.
 keywords:
@@ -16,6 +16,12 @@ slugs:
   - concept
   - bundle-optimization
 history:
+  - version: 9.2.1
+    date: 2026-08-09
+    changes: "`purge` et `minify` fonctionnent désormais sur Next.js via `@intlayer/swc` — aucun `babel.config.js` requis"
+  - version: 8.12.0
+    date: 2026-06-24
+    changes: "Liste des plugins Babel dans l'ordre de pipeline requis (extract → purge → minify → optimize) dans les tableaux de référence"
   - version: 8.12.0
     date: 2026-06-07
     changes: "Ajout de `intlayerPurgeBabelPlugin` et `intlayerMinifyBabelPlugin` pour Babel/Webpack; clarification du pipeline de plugins"
@@ -191,12 +197,14 @@ L'optimisation de build d'Intlayer est divisée en plusieurs plugins distincts,
 
 Ceux-ci sont utilisés directement dans `babel.config.js` pour les configurations basées sur Webpack (Next.js avec Babel, CRA, Webpack personnalisé, etc.).
 
+Le tableau ci-dessous les liste dans leur ordre de pipeline requis (le même ordre dans lequel ils doivent apparaître dans `babel.config.js`) :
+
 | Plugin                        | Ce qu'il fait                                                                                                                                |
 | :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------- |
 | `intlayerExtractBabelPlugin`  | Analyse les fichiers `.content.ts` et écrit les dictionnaires compilés dans `.intlayer/`                                                     |
-| `intlayerOptimizeBabelPlugin` | Réécrit `useIntlayer('key')` → `useDictionary(hash)` et injecte l'`import` du dictionnaire correspondant                                     |
 | `intlayerPurgeBabelPlugin`    | Analyse tous les fichiers sources, supprime les **champs de contenu inutilisés** des fichiers de dictionnaire compilés `.intlayer/**/*.json` |
 | `intlayerMinifyBabelPlugin`   | **Renomme les clés des champs de contenu** par de courts alias alphabétiques (`title` → `a`) dans les fichiers JSON et le code source        |
+| `intlayerOptimizeBabelPlugin` | Réécrit `useIntlayer('key')` → `useDictionary(hash)` et injecte l'`import` du dictionnaire correspondant                                     |
 
 > **L'ordre des plugins a de l'importance.** Dans votre `babel.config.js`, les plugins de purge et de minification doivent apparaître **avant** le plugin d'optimisation. La passe d'optimisation remplace `useIntlayer('key')` par un appel opaque `useDictionary(hash)`, effaçant l'information de la clé du dictionnaire dont les passes de purge et de minification ont besoin pour identifier les champs utilisés.
 
@@ -205,9 +213,9 @@ Chaque plugin Babel dispose d'un helper d'options correspondant qui lit votre `i
 | Helper d'options             | Utilisé avec                  |
 | :--------------------------- | :---------------------------- |
 | `getExtractPluginOptions()`  | `intlayerExtractBabelPlugin`  |
-| `getOptimizePluginOptions()` | `intlayerOptimizeBabelPlugin` |
 | `getPurgePluginOptions()`    | `intlayerPurgeBabelPlugin`    |
 | `getMinifyPluginOptions()`   | `intlayerMinifyBabelPlugin`   |
+| `getOptimizePluginOptions()` | `intlayerOptimizeBabelPlugin` |
 
 ### Plugins Vite (`vite-intlayer`)
 
@@ -220,6 +228,20 @@ Les utilisateurs de Vite **ne configurent jamais ceux-ci directement**. Ils sont
 | Minification de dict.   | Identique à la passe d'écriture JSON de `intlayerMinifyBabelPlugin`                                  |
 | Transformation Babel    | Identique au renommage de code source de `intlayerMinifyBabelPlugin` + `intlayerOptimizeBabelPlugin` |
 
+### Plugin SWC (`@intlayer/swc`)
+
+Les utilisateurs de Next.js **ne configurent jamais ceux-ci directement** non plus. Depuis la **v9.2.1**, `withIntlayer()` dans `next.config.ts` exécute l'ensemble du pipeline — purge, minification et réécriture des imports — à partir des seuls drapeaux `build.purge` et `build.minify`.
+
+Le travail est réparti en deux, car un plugin SWC Wasm transforme un fichier à la fois, sans accès au système de fichiers :
+
+| Passe                                         | Où elle s'exécute           | Ce qu'elle fait                                                                                        |
+| :-------------------------------------------- | :-------------------------- | :----------------------------------------------------------------------------------------------------- |
+| Analyse d'usage + purge/minification JSON     | Node, dans `withIntlayer()` | Lit chaque fichier source de composant, réécrit `.intlayer/**/*.json`, produit les tables de renommage |
+| Réécriture du source (`content.title` → `.a`) | `@intlayer/swc` (Wasm)      | Applique les tables de renommage aux accès de propriétés correspondants dans votre code                |
+| Réécriture des imports (`useIntlayer` → dict) | `@intlayer/swc` (Wasm)      | Identique à `intlayerOptimizeBabelPlugin`                                                              |
+
+Déterminer _quels_ champs sont inutilisés et _quel_ alias attribuer à chacun nécessite un état inter-fichiers et des E/S fichier ; cette moitié s'exécute donc dans Node, et le plugin SWC ne reçoit que les tables résultantes.
+
 ## Configuration par plateforme
 
 <Tabs>
@@ -227,10 +249,12 @@ Les utilisateurs de Vite **ne configurent jamais ceux-ci directement**. Ils sont
 
 ### Next.js
 
-Next.js nécessite le plugin `@intlayer/swc` pour la passe d'optimisation (réécriture d'import), car Next.js utilise SWC pour les builds.
+Next.js nécessite le plugin `@intlayer/swc`, car Next.js utilise SWC pour les builds. Depuis la **v9.2.1**, ce seul paquet couvre tout le pipeline — optimisation (réécriture des imports), purge et minification.
 
 > Ce plugin n'est pas installé par défaut car les plugins SWC sont encore expérimentaux pour Next.js. Cela pourrait changer à l'avenir.
 
+> **Next.js 16.1.0 est la version minimale.** C'est la première version construite sur l'ABI de plugin Wasm de SWC compatible en avant ; les versions antérieures rejettent le plugin. `withIntlayer` lit votre version de Next.js et n'enregistre tout simplement pas le plugin en dessous de 16.1.0 — ces builds réussissent quand même, ils s'exécutent simplement sans l'optimisation du bundle.
+
 <Tabs>
  <Tab value="npm">
 
@@ -265,33 +289,40 @@ intlayer-swc-plugin = "*"
 
 Une fois installé, Intlayer détectera et utilisera automatiquement le plugin.
 
-Pour les passes de **purge et de minification** (suppression de champs et renommage de champs), installez `@intlayer/babel` en parallèle et ajoutez les plugins Babel. Parce que Next.js utilise SWC pour la transformation mais évalue toujours `babel.config.js` pour la configuration des plugins, les plugins Babel s'exécutent en tant que pré-passe avant SWC.
+Les passes de **purge et de minification** (suppression et renommage de champs) ne nécessitent aucun paquet supplémentaire ni `babel.config.js`. Enveloppez votre configuration avec `withIntlayer` et activez les drapeaux dans `intlayer.config.ts` :
 
-```bash packageManager="npm"
-npm install -D @intlayer/babel
+```typescript fileName="next.config.ts"
+import { withIntlayer } from "next-intlayer/server";
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {/* votre configuration */};
+
+export default withIntlayer(nextConfig);
 ```
 
-```javascript fileName="babel.config.js"
-const {
-  intlayerPurgeBabelPlugin,
-  intlayerMinifyBabelPlugin,
-  getPurgePluginOptions,
-  getMinifyPluginOptions,
-} = require("@intlayer/babel");
+```typescript fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
 
-module.exports = {
-  presets: ["next/babel"],
-  plugins: [
-    // Purge : supprime les champs de contenu inutilisés de .intlayer/**/*.json
-    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
-    // Minify : renomme les clés de champ de contenu dans le JSON + code source
-    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
-    // Note : intlayerOptimizeBabelPlugin n'est PAS nécessaire ici car
-    // @intlayer/swc gère la réécriture useIntlayer → useDictionary.
-  ],
+const config: IntlayerConfig = {
+  build: {
+    purge: true, // supprime les champs de contenu inutilisés des JSON groupés
+    minify: true, // renomme les clés de champs avec de courts alias
+  },
 };
+
+export default config;
 ```
 
+Pendant `next build`, `withIntlayer` analyse vos sources, réécrit les dictionnaires compilés et transmet les tables de renommage de champs résultantes à `@intlayer/swc`, qui met à jour les accès de propriétés correspondants dans votre code.
+
+> Utilisez la version asynchrone `withIntlayer`, pas `withIntlayerSync`. La variante synchrone n'exécute pas le pipeline d'analyse : la purge et la minification n'ont donc aucun effet avec elle.
+
+> La purge et la minification ne s'exécutent que lors de `next build` — le pipeline d'optimisation est désactivé pendant `next dev`.
+
+> Elles sont également désactivées lorsque des appelants d'adaptateurs de compatibilité sont configurés (`swcExtraCallers`, définis par les paquets de compatibilité tels que `@intlayer/next-intl` ou `@intlayer/react-i18next`) : ces sites d'appel sont invisibles pour l'analyseur d'usage, et purger supprimerait donc des champs que le code lit encore. La réécriture des imports reste active.
+
+**Les versions antérieures (avant 9.2.1)** nécessitaient `@intlayer/babel` et un `babel.config.js` déclarant `intlayerPurgeBabelPlugin` et `intlayerMinifyBabelPlugin`. Ce fichier n'est plus nécessaire et peut être supprimé.
+
  </Tab>
  <Tab value="vite">
 
@@ -447,6 +478,8 @@ export default config;
 
 > La minification est ignorée lorsque `optimize` est `false` ou lorsque `editor.enabled` est `true` (l'éditeur visuel requiert les noms de champs originaux pour permettre l'édition).
 
+> Sur Next.js, la minification est également ignorée lorsque `@intlayer/swc` n'est pas installé ou ne peut pas être chargé (Next.js inférieur à 16.1.0). Le plugin est la moitié qui réécrit les accès dans le source : renommer les dictionnaires sans lui laisserait votre code lire des noms de champs qui n'existent plus.
+
 > La minification est également ignorée pour les dictionnaires chargés via `importMode: 'fetch'` car leur JSON est servi depuis une API distante en utilisant les noms de champs originaux — renommer les clés côté client briserait le contrat serveur/client.
 
 ### Purge (suppression des champs inutilisés)
@@ -475,7 +508,7 @@ export default config;
 { "title": "…", "subtitle": "…" }
 ```
 
-> La purge est ignorée lorsque `optimize` est `false` ou lorsque `editor.enabled` est `true`.
+> La purge est ignorée lorsque `optimize` est `false` ou lorsque `editor.enabled` est `true`. Sur Next.js, elle est en outre ignorée lorsque `@intlayer/swc` est indisponible, ainsi que lorsque des appelants d'adaptateurs de compatibilité sont configurés.
 
 > La purge est également ignorée de manière conservative lorsqu'un fichier source ne peut pas être analysé, ou lorsque le résultat de `useIntlayer` est assigné à une variable et transmis de manières que l'analyseur statique ne peut pas suivre (par ex. propagation dans un objet, passé en tant que prop sans déstructuration). Dans ces cas, le dictionnaire complet est conservé.
 

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é.