@intlayer/docs 9.0.0-canary.6 → 9.0.0-canary.8

package/docs/fr/intlayer_with_tanstack+solid.md

@@ -228,11 +228,15 @@ export default defineConfig({
     tanstackStart({
       router: {
         routeFileIgnorePattern:
-          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5)$",
+          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5|md|mdx|yaml|yml)$",
       },
     }),
     solidPlugin({ ssr: true }),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -568,22 +572,25 @@ Vous pouvez également utiliser `intlayerProxy` pour ajouter un routage côté s
 
 > Notez que pour utiliser `intlayerProxy` en production, vous devez déplacer le package `vite-intlayer` de `devDependencies` vers `dependencies`.
 
-```typescript {7,14-17} fileName="vite.config.ts"
+```typescript fileName="vite.config.ts"
 import { tanstackStart } from "@tanstack/solid-start/plugin/vite";
 import solid from "vite-plugin-solid";
 import { nitro } from "nitro/vite";
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // Le proxy doit être placé avant le serveur si vous utilisez Nitro
     nitro(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
     tanstackStart({
       router: {
         routeFileIgnorePattern:
-          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5)$",
+          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5|md|mdx|yaml|yml)$",
       },
     }),
     solid(),
@@ -826,9 +833,9 @@ bun x intlayer extract
  </Tab>
  <Tab value='Babel compiler'>
 
-Mettez à jour votre `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
 
-> Depuis Intlayer v9, le compilateur est directement intégré au plugin `intlayer()` et s'active automatiquement dès que `compiler.enabled` est défini avec un chemin `compiler.output`. Enregistrer `intlayerCompiler()` séparément comme indiqué ci-dessous est désormais facultatif — il se déduplique de lui-même s'il est également ajouté. Voir les [notes de version v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v9.md).
+Mettez à jour votre `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
 import { intlayer, intlayerCompiler } from "vite-intlayer";
@@ -843,12 +850,12 @@ export default defineConfig({
     tanstackStart({
       router: {
         routeFileIgnorePattern:
-          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5)$",
+          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5|md|mdx|yaml|yml)$",
       },
     }),
     solidPlugin({ ssr: true }),
     intlayer(),
-    intlayerCompiler(),
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_tanstack.md

@@ -242,11 +242,15 @@ import { intlayer } from "vite-intlayer";
 const config = defineConfig({
   plugins: [
     nitro(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
     tanstackStart({
       router: {
         routeFileIgnorePattern:
-          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5)$",
+          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5|md|mdx|yaml|yml)$",
       },
     }),
     viteReact(),
@@ -650,22 +654,25 @@ Vous pouvez également utiliser `intlayerProxy` pour ajouter un routage côté s
 
 > Notez que pour utiliser `intlayerProxy` en production, vous devez déplacer le paquet `vite-intlayer` de `devDependencies` vers `dependencies`.
 
-```typescript {7,14-17} fileName="vite.config.ts"
+```typescript fileName="vite.config.ts"
 import { tanstackStart } from "@tanstack/react-start/plugin/vite";
 import viteReact from "@vitejs/plugin-react";
 import { nitro } from "nitro/vite";
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // Le proxy doit être placé avant le serveur si vous utilisez Nitro
     nitro(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
     tanstackStart({
       router: {
         routeFileIgnorePattern:
-          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5)$",
+          ".content.(ts|tsx|js|mjs|cjs|jsx|json|jsonc|json5|md|mdx|yaml|yml)$",
       },
     }),
     viteReact(),
@@ -906,6 +913,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -915,7 +924,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+lit.md

@@ -205,7 +205,13 @@ import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [intlayer()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 
@@ -474,12 +480,15 @@ Tout d'abord, ajoutez `intlayerProxy` à votre configuration Vite :
 
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // should be placed first
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+preact.md

@@ -829,6 +829,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -838,7 +840,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+react.md

@@ -504,14 +504,17 @@ En parallèle, vous pouvez également utiliser le `intlayerProxy` pour ajouter u
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react-swc";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // should be placed first
     react(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -816,6 +819,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -825,7 +830,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+react_compiler.md

@@ -213,11 +213,18 @@ Ajoutez le plugin intlayer dans votre configuration.
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react-swc";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [react(), intlayer(), intlayerCompiler()],
+  plugins: [
+    react(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/fr/intlayer_with_vite+solid.md

@@ -596,6 +596,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -605,7 +607,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+svelte.md

@@ -458,14 +458,17 @@ En parallèle, vous pouvez également utiliser le `intlayerProxy` pour ajouter u
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { svelte } from "@sveltejs/vite-plugin-svelte";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // should be placed first
     svelte(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -597,6 +600,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -606,7 +611,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+vanilla.md

@@ -205,7 +205,13 @@ import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [intlayer()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 
@@ -466,12 +472,15 @@ Tout d'abord, ajoutez `intlayerProxy` à votre config Vite :
 
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // doit être placé en premier
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -603,6 +612,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -612,7 +623,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/intlayer_with_vite+vue.md

@@ -620,14 +620,17 @@ Parallèlement, vous pouvez également utiliser le `intlayerProxy` pour ajouter
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // should be placed first
     vue(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -952,6 +955,8 @@ bun x intlayer extract
  </Tab>
  <Tab value='Compilateur Babel'>
 
+> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
+
 Mettez à jour votre fichier `vite.config.ts` pour inclure le plugin `intlayerCompiler` :
 
 ```ts fileName="vite.config.ts"
@@ -961,7 +966,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Ajoute le plugin du compilateur
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/fr/packages/@intlayer_babel/export.md

@@ -0,0 +1,131 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: "Documentation du package @intlayer/babel"
+description: Plugins Babel pour Intlayer afin de gérer l'extraction de contenu, l'optimisation des importations, la purge des champs inutilisés et le masquage des noms de champs lors de la construction.
+keywords:
+  - "@intlayer/babel"
+  - babel
+  - plugin
+  - internationalisation
+  - i18n
+  - compilateur
+  - optimiser
+  - purger
+  - minifier
+slugs:
+  - doc
+  - packages
+  - "@intlayer/babel"
+  - export
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Documentation unifiée de toutes les exportations"
+author: aymericzip
+---
+
+# Package @intlayer/babel
+
+Le package `@intlayer/babel` fournit un ensemble de plugins Babel spécialisés pour Intlayer. Ces plugins couvrent l'ensemble du cycle de construction : extraction des déclarations de contenu, réécriture des appels `useIntlayer` / `getIntlayer` en importations de dictionnaires optimisés, purge des champs inutilisés et minification des noms de champs.
+
+## Installation
+
+```bash
+npm install @intlayer/babel
+```
+
+## Exportations
+
+Importation :
+
+```ts
+import { ... } from "@intlayer/babel";
+```
+
+---
+
+### Plugins
+
+| Fonction / Classe              | Description                                                                                                                                                                                                                  |
+| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `intlayerExtractBabelPlugin`   | Plugin Babel qui extrait le contenu traduisible des fichiers sources et injecte automatiquement les hooks `useIntlayer` / `getIntlayer`. Conçu pour être utilisé avec Next.js et les outils de construction basés sur Babel. |
+| `intlayerOptimizeBabelPlugin`  | Plugin Babel qui transforme les appels `useIntlayer` et `getIntlayer` et réécrit leurs importations en importations de dictionnaires JSON optimisées (statiques, dynamiques ou via fetch).                                   |
+| `intlayerPurgeBabelPlugin`     | Plugin Babel qui analyse les fichiers sources et réécrit les fichiers JSON des dictionnaires compilés pour supprimer les champs inutilisés (`build.purge`) ou les renommer en alias courts (`build.minify`).                 |
+| `intlayerMinifyBabelPlugin`    | Plugin Babel qui réécrit les fichiers sources pour utiliser les alias de champs courts attribués pendant la phase de minification (par exemple, `content.title` ← `content.a`). Dépend de `intlayerPurgeBabelPlugin`.        |
+| `makeFieldRenameBabelPlugin`   | Fonction factory qui produit un plugin Babel pour renommer les accès aux champs de contenu des dictionnaires dans les fichiers sources selon la `dictionaryKeyToFieldRenameMap` renseignée dans le `PruneContext`.           |
+| `makeUsageAnalyzerBabelPlugin` | Fonction factory qui produit un plugin Babel pour analyser l'utilisation de `useIntlayer` / `getIntlayer` dans le code source et regrouper les données d'utilisation des champs dans le `PruneContext` partagé.              |
+| `getSharedPruneContext`        | Fonction utilitaire qui renvoie l'objet `PruneContext` partagé pour le répertoire de base spécifié, ou `null` si le contexte n'a pas encore été initialisé.                                                                  |
+
+---
+
+### Utilitaires de configuration des plugins
+
+| Fonction                   | Description                                                                                                                                                  |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `getExtractPluginOptions`  | Charge la configuration Intlayer et renvoie les `ExtractPluginOptions` prêtes à l'emploi avec `intlayerExtractBabelPlugin`.                                  |
+| `getOptimizePluginOptions` | Charge la configuration Intlayer et les dictionnaires compilés, et renvoie les `OptimizePluginOptions` prêtes à l'emploi avec `intlayerOptimizeBabelPlugin`. |
+| `getPurgePluginOptions`    | Charge la configuration Intlayer et renvoie les `PurgePluginOptions` prêtes à l'emploi avec `intlayerPurgeBabelPlugin`.                                      |
+| `getMinifyPluginOptions`   | Charge la configuration Intlayer et renvoie les `MinifyPluginOptions` prêtes à l'emploi avec `intlayerMinifyBabelPlugin`.                                    |
+
+---
+
+### Types
+
+| Type                    | Description                                                                                                                                |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `CompilerMode`          | Mode du compilateur : `'dev'` pour le développement avec support HMR, ou `'build'` pour les builds de production.                          |
+| `ExtractPluginOptions`  | Options pour `intlayerExtractBabelPlugin` : liste des fichiers, configuration, callback `onExtract`, etc.                                  |
+| `ExtractResult`         | Résultat de l'extraction : clé de dictionnaire, chemin du fichier, contenu et locale.                                                      |
+| `OptimizePluginOptions` | Options pour `intlayerOptimizeBabelPlugin` : chemins des dictionnaires, mode d'importation, carte des modes par dictionnaire, etc.         |
+| `PurgePluginOptions`    | Options pour `intlayerPurgeBabelPlugin` : répertoire de base, drapeaux purge/minify/optimize, liste des fichiers de composants.            |
+| `MinifyPluginOptions`   | Options pour `intlayerMinifyBabelPlugin` : répertoire de base, drapeaux minify/optimize/editorEnabled.                                     |
+| `PruneContext`          | État partagé entre les plugins d'analyse et de purge : cartes d'utilisation des champs, cartes de renommage, etc.                          |
+| `DictionaryFieldUsage`  | Résultat de l'utilisation des champs pour un seul dictionnaire : `Set<string>` ou `'all'` lorsque l'analyse statique n'est pas concluante. |
+| `NestedRenameEntry`     | Nœud dans l'arbre de renommage : le `shortName` et la carte des enfants.                                                                   |
+| `NestedRenameMap`       | Un niveau dans l'arbre de renommage : `Map<string, NestedRenameEntry>`.                                                                    |
+| `CompatCallerConfig`    | Configuration pour un analyseur d'utilisation compatible pour les packages compat-adapter (nom de l'appelant et options de traitement).    |
+| `ScriptBlock`           | Bloc de script extrait d'un fichier SFC (Vue ou Svelte) : contenu, décalage de début et décalage de fin.                                   |
+
+---
+
+### Fonctions utilitaires
+
+| Fonction                          | Description                                                                                                                                                                                       |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `generateShortFieldName`          | Convertit un entier (en commençant par zéro) en un identifiant alphabétique court : `0` → `'a'`, `25` → `'z'`, `26` → `'aa'`, etc.                                                                |
+| `buildNestedRenameMapFromContent` | Construit de manière récursive une `NestedRenameMap` à partir de la valeur du contenu d'un dictionnaire compilé, en respectant les structures de nœuds Intlayer (translation, enumeration, etc.). |
+| `createPruneContext`              | Crée un nouvel objet `PruneContext` vide initialisé avec les valeurs par défaut.                                                                                                                  |
+| `extractScriptBlocks`             | Extrait les blocs `<script>` des fichiers SFC (Vue / Svelte) pour une analyse Babel ultérieure.                                                                                                   |
+| `BABEL_PARSER_OPTIONS`            | Constante représentant les options du parseur Babel couvrant les frameworks pris en charge (React/Vue/Svelte/Angular/...).                                                                        |
+| `INTLAYER_CALLER_NAMES`           | Liste constante des noms d'appelants originaux d'Intlayer : `['useIntlayer', 'getIntlayer']`.                                                                                                     |
+
+---
+
+## Exemple d'utilisation
+
+```js
+// babel.config.js
+const {
+  intlayerExtractBabelPlugin,
+  intlayerPurgeBabelPlugin,
+  intlayerMinifyBabelPlugin,
+  intlayerOptimizeBabelPlugin,
+  getExtractPluginOptions,
+  getPurgePluginOptions,
+  getMinifyPluginOptions,
+  getOptimizePluginOptions,
+} = require("@intlayer/babel");
+
+module.exports = {
+  presets: ["next/babel"],
+  plugins: [
+    [intlayerExtractBabelPlugin, getExtractPluginOptions()],
+    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
+    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
+    [intlayerOptimizeBabelPlugin, getOptimizePluginOptions()],
+  ],
+};
+```
+
+> **Note :** Le plugin `intlayerPurgeBabelPlugin` doit être déclaré **avant** `intlayerMinifyBabelPlugin`, car ce dernier lit la carte de renommage construite par le premier. De plus, ils doivent tous deux être précédés par `intlayerOptimizeBabelPlugin` afin que celui-ci puisse voir les clés de dictionnaire avant que les appels à `useIntlayer` ne soient réécrits.

package/docs/fr/packages/vite-intlayer/intlayerCompiler.md

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentation du plugin Vite intlayerCompiler | vite-intlayer
+description: Plugin Vite qui extrait les déclarations de contenu Intlayer en ligne des fichiers de composants et les écrit dans des fichiers JSON de dictionnaire lors du build ou de la phase de transformation.
+keywords:
+  - intlayerCompiler
+  - vite
+  - plugin
+  - compilateur
+  - contenu
+  - dictionnaire
+  - internationalisation
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Intégré dans intlayer() ; initialisation de la doc"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+`intlayerCompiler` est un plugin Vite qui scanne les fichiers sources des composants à la recherche de **déclarations de contenu Intlayer en ligne** — du contenu défini directement à l'intérieur d'un composant plutôt que dans un fichier `.content.ts` séparé — et les écrit dans des fichiers JSON de dictionnaire pendant la phase de transformation.
+
+> **Depuis Intlayer v9**, `intlayerCompiler` est automatiquement inclus dans le plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/vite-intlayer/intlayer.md) lorsque `compiler.enabled` est à `true` et que `compiler.output` est défini dans votre configuration Intlayer. Vous n'avez besoin de l'enregistrer séparément que si vous souhaitez un contrôle total sur la configuration spécifique au compilateur.
+
+## Utilisation
+
+### En tant que partie de `intlayer()` (recommandé, v9+)
+
+Activez le compilateur via votre configuration Intlayer :
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // où les dictionnaires extraits sont écrits
+  },
+});
+```
+
+Ensuite, utilisez le plugin standard sans enregistrement supplémentaire :
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Autonome (si nécessaire)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Options
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Option           | Type                      | Description                                                                                                   |
+| ---------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Surcharges de configuration Intlayer transmises à `getConfiguration()`.                                       |
+| `compilerConfig` | `Partial<CompilerConfig>` | Surcharges pour la section de configuration spécifique au compilateur (ex. `enabled`, `output`, `filesList`). |
+
+### Exemple
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## Comment ça fonctionne
+
+### Phase de transformation
+
+Pour chaque fichier source qui correspond à `compiler.filesList`, le plugin du compilateur :
+
+1. Passe le contenu du fichier via `extractContent` de `@intlayer/babel`.
+2. Appelle `onExtract` pour chaque déclaration trouvée, ce qui écrit le JSON du dictionnaire résultant dans `compiler.output`.
+3. Renvoie le code source transformé avec les déclarations en ligne remplacées par des appels standard `useIntlayer('key')` / `getIntlayer('key')`.
+
+Types de fichiers pris en charge : `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+Lorsqu'un fichier de composant est enregistré en mode développement, le compilateur :
+
+1. Détecte le changement de fichier via le hook `handleHotUpdate` de Vite.
+2. Extrait à nouveau le contenu du fichier mis à jour.
+3. Écrit le JSON du dictionnaire mis à jour.
+4. Déclenche un rechargement complet de la page (`server.ws.send({ type: 'full-reload' })`).
+
+Un debounce de 500 ms empêche l'écriture du dictionnaire elle-même (qui déclenche également un événement de modification de fichier) de provoquer une boucle d'extraction infinie.
+
+### Dédoublonnage
+
+`intlayerCompiler` utilise le même mécanisme de dédoublonnage `createPrimaryInstanceGuard` que les autres plugins intégrés. Lorsque `intlayer()` (qui intègre le compilateur) et un appel manuel à `intlayerCompiler()` sont tous deux présents, seule la première instance enregistrée s'exécute — aucun dictionnaire n'est écrit deux fois.