@intlayer/docs 9.0.0-canary.2 → 9.0.0-canary.20

package/docs/fr/packages/vue-intlayer/usePathname.md

@@ -0,0 +1,109 @@
+---
+createdAt: 2026-06-22
+updatedAt: 2026-06-22
+title: Documentation de la fonction usePathname | vue-intlayer
+description: Découvrez comment utiliser la fonction usePathname du package vue-intlayer
+keywords:
+  - usePathname
+  - pathname
+  - locale
+  - Intlayer
+  - Internationalisation
+  - Documentation
+  - Vue
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - vue-intlayer
+  - usePathname
+history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Ajout de l'utilitaire usePathname"
+  - version: 8.2.0
+    date: 2026-06-22
+    changes: "Initialisation de l'historique"
+author: aymericzip
+---
+
+# Intégration Vue : Documentation de `usePathname`
+
+La fonction `usePathname` retourne le chemin de l'URL actuelle (pathname) du navigateur sans le segment de la locale, sous la forme d'une `ComputedRef<string>` de Vue. C'est utile pour construire une navigation qui prend en compte la locale — par exemple, pour déterminer quel élément de navigation est actif — sans avoir à retirer le préfixe de locale manuellement.
+
+## Importer `usePathname` dans Vue
+
+```typescript
+import { usePathname } from "vue-intlayer";
+```
+
+## Vue d'ensemble
+
+`usePathname` crée une référence calculée (computed ref) Vue qui lit `window.location.pathname`, supprime le préfixe de la locale via `getPathWithoutLocale`, et met à jour sa valeur chaque fois que le navigateur déclenche un événement `popstate` (navigation retour/avance). La valeur peut être utilisée directement dans vos templates Vue ou vos fonctions setup.
+
+## Utilisation
+
+```vue fileName="src/components/NavItem.vue"
+<script setup lang="ts">
+import { usePathname } from "vue-intlayer";
+
+const props = defineProps<{
+  href: string;
+  label: string;
+}>();
+
+const pathname = usePathname();
+</script>
+
+<template>
+  <a :href="href" :aria-current="pathname === href ? 'page' : undefined">
+    {{ label }}
+  </a>
+</template>
+```
+
+## Valeur retournée
+
+| Type                  | Description                                                                                 |
+| --------------------- | ------------------------------------------------------------------------------------------- |
+| `ComputedRef<string>` | Une référence calculée Vue contenant le chemin (pathname) actuel sans le préfixe de locale. |
+
+## Comportement
+
+- **Suppression de la locale** : Retire le segment de locale au début de l'URL (par ex. `/fr/dashboard` → `/dashboard`).
+- **Réactif** : Met à jour la valeur à chaque événement `popstate` (navigation arrière / avant dans le navigateur).
+- **Compatible SSR** : Renvoie `""` lorsque `window` n'est pas disponible.
+- **Nettoyage (Cleanup)** : L'écouteur `popstate` est automatiquement ajouté lors de l'initialisation et n'a pas besoin de nettoyage manuel par composant dans la plupart des cas, grâce à la gestion du cycle de vie globale de Vue.
+
+## Exemple
+
+```vue fileName="src/components/Sidebar.vue"
+<script setup lang="ts">
+import { usePathname } from "vue-intlayer";
+
+const links = [
+  { href: "/dashboard", label: "Tableau de bord" },
+  { href: "/settings", label: "Paramètres" },
+];
+
+const pathname = usePathname();
+</script>
+
+<template>
+  <nav>
+    <a
+      v-for="link in links"
+      :key="link.href"
+      :href="link.href"
+      :style="{ fontWeight: pathname === link.href ? 'bold' : 'normal' }"
+    >
+      {{ link.label }}
+    </a>
+  </nav>
+</template>
+```
+
+## Fonctions liées
+
+- [`useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/vue-intlayer/useLocale.md) — locale actuelle + commutateur de locale
+- [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/intlayer/getPathWithoutLocale.md) — l'utilitaire sous-jacent utilisé par ce hook

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

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-03-13
-updatedAt: 2025-12-13
+updatedAt: 2026-06-21
 title: Plugin Sync JSON
 description: Synchronisez les dictionnaires Intlayer avec des fichiers JSON i18n tiers (i18next, next-intl, react-intl, vue-i18n, et plus). Conservez votre i18n existant tout en utilisant Intlayer pour gérer, traduire et tester vos messages.
 keywords:
@@ -24,6 +24,9 @@ slugs:
   - sync-json
 youtubeVideo: https://www.youtube.com/watch?v=MpGMxniDHNg
 history:
+  - version: 9.0.0
+    date: 2026-06-21
+    changes: "Ajout de l'option splitKeys (un dictionnaire par clé de namespace de premier niveau) pour les layouts de fichiers uniques next-intl / react-intl"
   - version: 7.5.0
     date: 2025-12-13
     changes: "Ajout du support des formats ICU et i18next"
@@ -62,7 +65,62 @@ pnpm add -D @intlayer/sync-json-plugin
 npm i -D @intlayer/sync-json-plugin
 ```
 
-## Démarrage rapide
+## Plugins
+
+Ce package fournit deux plugins :
+
+- `loadJSON` : Charge les fichiers JSON dans les dictionnaires Intlayer.
+  - Ce plugin est utilisé pour charger les fichiers JSON d'une source et sera chargé dans les dictionnaires Intlayer. Il peut scanner l'ensemble de la codebase et rechercher des fichiers JSON spécifiques.
+    Ce plugin peut être utilisé
+    - si vous utilisez une bibliothèque i18n qui impose un emplacement spécifique pour le chargement de vos JSON (ex: `next-intl`, `i18next`, `react-intl`, `vue-i18n`, etc.), mais que vous souhaitez placer votre déclaration de contenu où vous le souhaitez dans votre codebase.
+    - Il peut également être utilisé si vous souhaitez récupérer vos messages d'une source distante (ex: un CMS, une API, etc.) et stocker vos messages dans des fichiers JSON.
+
+  > En coulisses, ce plugin scannera l'ensemble de la codebase et recherchera des fichiers JSON spécifiques pour les charger dans les dictionnaires Intlayer.
+  > Notez que ce plugin n'écrira pas la sortie et les traductions dans les fichiers JSON.
+
+- `syncJSON` : Synchronise les fichiers JSON avec les dictionnaires Intlayer.
+  - Ce plugin est utilisé pour synchroniser les fichiers JSON avec les dictionnaires Intlayer. Il peut scanner l'emplacement donné et charger les JSON qui correspondent au modèle pour des fichiers JSON spécifiques. Ce plugin est utile si vous souhaitez bénéficier des avantages d'Intlayer tout en utilisant une autre bibliothèque i18n.
+
+## Utilisation des deux plugins
+
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON, syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  // Gardez vos fichiers JSON actuels synchronisés avec les dictionnaires Intlayer
+  plugins: [
+    /**
+     * Chargera tous les fichiers JSON dans le dossier src qui correspondent au modèle {key}.i18n.json
+     */
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      locale: Locales.ENGLISH,
+      priority: 1, // Garantit que ces fichiers JSON ont la priorité sur les fichiers à `./locales/en/${key}.json`
+      format: "intlayer", // Format du contenu JSON
+    }),
+    /**
+     * Chargera et écrira la sortie et les traductions dans les fichiers JSON du répertoire locales
+     */
+    syncJSON({
+      source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      priority: 0,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
+```
+
+## Plugin `syncJSON`
+
+### Démarrage rapide
 
 Ajoutez le plugin à votre `intlayer.config.ts` et pointez-le vers votre structure JSON existante.
 
@@ -81,6 +139,7 @@ const config: IntlayerConfig = {
     syncJSON({
       // Mise en page par locale, par namespace (par exemple, next-intl, i18next avec namespaces)
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      format: "icu",
     }),
   ],
 };
@@ -91,14 +150,27 @@ export default config;
 Alternative : un seul fichier par locale (courant avec les configurations i18next/react-intl) :
 
 ```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+import { Locales, type IntlayerConfig } from "intlayer";
+import { syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  plugins: [
+    syncJSON({
+      format: "i18next",
+      source: ({ locale }) => `./locales/${locale}.json`,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
 ```
 
-### Comment ça fonctionne
+#### Comment ça fonctionne
 
 - Lecture : le plugin découvre les fichiers JSON à partir de votre générateur `source` et les charge comme des dictionnaires Intlayer.
 - Écriture : après les builds et les remplissages, il écrit les JSON localisés aux mêmes emplacements (avec une nouvelle ligne finale pour éviter les problèmes de formatage).
@@ -112,6 +184,7 @@ syncJSON({
   location?: string, // étiquette optionnelle, par défaut : "plugin"
   priority?: number, // priorité optionnelle pour la résolution des conflits, par défaut : 0
   format?: 'intlayer' | 'icu' | 'i18next', // formateur optionnel, utilisé pour la compatibilité avec le runtime Intlayer
+  splitKeys?: boolean, // optionnel, divise un fichier unique en un dictionnaire par clé de premier niveau (détection automatique)
 });
 ```
 
@@ -136,17 +209,49 @@ syncJSON({
 }),
 ```
 
-## Sources JSON multiples et priorité
+#### `splitKeys` (boolean)
+
+Contrôle si un fichier JSON unique dont les **clés de premier niveau sont des namespaces** doit devenir un dictionnaire par clé de premier niveau, au lieu d'un seul dictionnaire contenant tout le fichier.
+
+Cela correspond au modèle de namespace de bibliothèques comme `next-intl` et `react-intl`, où un fichier `messages/{locale}.json` regroupe plusieurs namespaces par ses clés de premier niveau, chacun étant adressé indépendamment (par exemple, `useTranslations('Hero')` se résout au dictionnaire `Hero`).
+
+- `undefined` (par défaut) : **détection automatique** — le fichier est divisé lorsque le modèle `source` n'a pas de segment `{key}` (un fichier contient tous les namespaces), et conservé comme un seul dictionnaire sinon (un fichier par clé).
+- `true` : divise toujours chaque clé de premier niveau en son propre dictionnaire.
+- `false` : ne divise jamais ; le fichier entier devient un seul dictionnaire.
+
+Étant donné un fichier `messages/{locale}.json` unique :
+
+```json fileName="messages/en.json"
+{
+  "Hero": { "title": "Full-stack developer" },
+  "Nav": { "work": "Work", "about": "About" },
+  "About": { "lead": "I build apps end to end." }
+}
+```
+
+```ts fileName="intlayer.config.ts"
+syncJSON({
+  format: "icu",
+  source: ({ locale }) => `./messages/${locale}.json`,
+  // splitKeys: true, // implicite car le modèle n'a pas de segment `{key}`
+}),
+```
+
+Cela produit trois dictionnaires — `Hero`, `Nav`, et `About` — de sorte que `useTranslations('Hero')` (next-intl) se résout correctement. Lors de la réécriture, tous les namespaces sont réassemblés dans le même fichier par locale.
+
+> Lorsque vous conservez le segment `{key}` explicite dans votre `source` (par exemple, `./locales/${locale}/${key}.json`), chaque fichier est déjà un namespace, donc la division est désactivée par défaut.
+
+### Sources JSON multiples et priorité
 
 Vous pouvez ajouter plusieurs plugins `syncJSON` pour synchroniser différentes sources JSON. Cela est utile lorsque vous avez plusieurs bibliothèques i18n ou différentes structures JSON dans votre projet.
 
-### Système de priorité
+#### Système de priorité
 
 Lorsque plusieurs plugins ciblent la même clé de dictionnaire, le paramètre `priority` détermine quel plugin a la priorité :
 
 - Les nombres de priorité plus élevés l'emportent sur les plus faibles
 - La priorité par défaut des fichiers `.content` est `0`
-- La priorité par défaut des fichiers de contenu des plugins est `-1`
+- La priorité par défaut des plugins est `0`
 - Les plugins avec la même priorité sont traités dans l'ordre où ils apparaissent dans la configuration
 
 ```ts fileName="intlayer.config.ts"
@@ -189,73 +294,140 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-### Résolution des conflits
+## Load JSON plugin
 
-Lorsque la même clé de traduction existe dans plusieurs sources JSON :
+### Démarrage rapide
 
-1. Le plugin avec la priorité la plus élevée détermine la valeur finale
-2. Les sources de priorité inférieure sont utilisées comme secours pour les clés manquantes
-3. Cela vous permet de maintenir les traductions héritées tout en migrant progressivement vers de nouvelles structures
+Ajoutez le plugin à votre `intlayer.config.ts` pour ingérer les fichiers JSON existants comme dictionnaires Intlayer. Ce plugin est en lecture seule (pas d'écriture sur le disque) :
 
-## Intégrations
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-Voici des mappages courants. Gardez votre runtime intact ; ajoutez uniquement le plugin.
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  plugins: [
+    // Ingérer les messages JSON situés n'importe où dans votre arborescence source
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      // Charger une seule locale par instance de plugin (par défaut à la defaultLocale de la config)
+      locale: Locales.ENGLISH,
+      priority: 0,
+    }),
+  ],
+};
 
-### i18next
+export default config;
+```
 
-Disposition typique des fichiers : `./public/locales/{locale}/{namespace}.json` ou `./locales/{locale}/{namespace}.json`.
+Alternative : disposition par locale, toujours en lecture seule (seule la locale sélectionnée est chargée) :
 
 ```ts fileName="intlayer.config.ts"
-import { syncJSON } from "@intlayer/sync-json-plugin";
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-export default {
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
   plugins: [
-    syncJSON({
-      format: "i18next",
+    loadJSON({
+      // Seuls les fichiers pour Locales.FRENCH seront chargés à partir de ce modèle
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      locale: Locales.FRENCH,
     }),
   ],
 };
+
+export default config;
 ```
 
-### next-intl
+### How it works
 
-Messages JSON par locale (souvent `./messages/{locale}.json`) ou par namespace.
+- Discover : construit un glob à partir de votre générateur `source` et collecte les fichiers JSON correspondants.
+- Ingest : charge chaque fichier JSON comme un dictionnaire Intlayer avec la `locale` fournie.
+- Read‑only : n'écrit ni ne formate les fichiers de sortie ; utilisez `syncJSON` si vous avez besoin d'une synchronisation aller-retour.
+- Auto‑fill ready : définit un modèle `fill` afin que `intlayer content fill` puisse remplir les clés manquantes.
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale, key }) => `./messages/${locale}/${key}.json`,
-  }),
-];
+### API
+
+```ts
+loadJSON({
+  // Construisez les chemins vers votre JSON. `locale` est optionnel si votre structure n'a pas de segment de locale
+  source: ({ key, locale }) => string,
+
+  // Locale cible pour les dictionnaires chargés par cette instance de plugin
+  // Par défaut à configuration.internationalization.defaultLocale
+  locale?: Locale,
+
+  // Étiquette optionnelle pour identifier la source
+  location?: string, // par défaut : "plugin"
+
+  // Priorité utilisée pour la résolution des conflits avec d'autres sources
+  priority?: number, // par défaut : 0
+
+  // Formateur optionnel pour le contenu JSON
+  format?: 'intlayer' | 'icu' | 'i18next', // par défaut : 'intlayer'
+
+  // Divise un fichier unique en un dictionnaire par clé de premier niveau (détection automatique)
+  splitKeys?: boolean,
+});
 ```
 
-Voir aussi : `docs/fr/intlayer_with_next-intl.md`.
+#### `format` ('intlayer' | 'icu' | 'i18next')
 
-### react-intl
+Spécifie le formateur à utiliser pour le contenu du dictionnaire lors du chargement des fichiers JSON. Cela permet d'utiliser différentes syntaxes de formatage de messages compatibles avec diverses bibliothèques i18n.
 
-Un seul JSON par locale est courant :
+- `'intlayer'` : Le formateur Intlayer par défaut (par défaut).
+- `'icu'` : Utilise le formatage de messages ICU (compatible avec des bibliothèques comme react-intl, vue-i18n).
+- `'i18next'` : Utilise le formatage de messages i18next (compatible avec i18next, next-i18next, Solid-i18next).
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+**Exemple :**
+
+```ts
+loadJSON({
+  source: ({ key }) => `./src/**/${key}.i18n.json`,
+  locale: Locales.ENGLISH,
+  format: "icu", // Utiliser le formatage ICU pour la compatibilité
+}),
 ```
 
-### vue-i18n
+#### `splitKeys` (boolean)
 
-Soit un seul fichier par locale, soit par namespace :
+Même comportement que dans [`syncJSON`](#splitkeys-boolean) : lorsqu'un fichier JSON unique regroupe plusieurs namespaces par ses clés de premier niveau, chaque clé de premier niveau devient son propre dictionnaire.
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ key, locale }) => `./src/locales/${locale}/${key}.json`,
-  }),
-];
+- `undefined` (par défaut) : **détection automatique** — divise lorsque le modèle `source` n'a pas de segment `{key}`, dictionnaire unique sinon.
+- `true` / `false` : force ou désactive la division.
+
+```ts
+loadJSON({
+  source: ({ locale }) => `./messages/${locale}.json`,
+  format: "icu",
+  // splitKeys auto-enabled: `Hero`, `Nav`, `About`, … each become a dictionary
+}),
 ```
 
+### Behavior and conventions
+
+- Si votre masque `source` inclut un placeholder de locale, seuls les fichiers pour la `locale` sélectionnée sont ingérés.
+- S'il n'y a pas de segment `{key}` dans votre masque, chaque clé de premier niveau du fichier devient son propre dictionnaire par défaut (voir [`splitKeys`](#splitkeys-boolean)). Définissez `splitKeys: false` pour charger plutôt l'ensemble du fichier comme un seul dictionnaire `index`.
+- Les clés sont dérivées des chemins de fichiers en substituant le placeholder `{key}` dans votre générateur `source`.
+- Le plugin n'utilise que les fichiers découverts et ne fabrique pas de locales ou de clés manquantes.
+- Le chemin `fill` est inféré de votre `source` et utilisé pour mettre à jour les valeurs manquantes via la CLI lorsque vous l'activez.
+
+## Résolution des conflits
+
+Lorsque la même clé de traduction existe dans plusieurs sources JSON :
+
+1. Le plugin avec la priorité la plus élevée détermine la valeur finale
+2. Les sources de priorité inférieure sont utilisées comme secours pour les clés manquantes
+3. Cela vous permet de maintenir les traductions héritées tout en migrant progressivement vers de nouvelles structures
+
 ## CLI
 
 Les fichiers JSON synchronisés seront considérés comme d'autres fichiers `.content`. Cela signifie que toutes les commandes intlayer seront disponibles pour les fichiers JSON synchronisés. Cela inclut :

package/docs/fr/releases/v6.md

@@ -25,6 +25,10 @@ author: aymericzip
 
 Bienvenue dans Intlayer v6 ! Cette version se concentre sur les performances, l'expérience développeur et la fiabilité. Voici les points forts, avec des notes de migration et des exemples à copier-coller.
 
+## Table des matières
+
+<TOC levels={[2]} maxDepth={1} />
+
 ## Points forts
 
 - Nouvelle commande : `npx intlayer content test` pour détecter les traductions manquantes
@@ -295,6 +299,24 @@ Voir [CMS et synchronisation en direct](https://github.com/aymericzip/intlayer/b
 
 ---
 
+## Processus parallèle pour surveiller les fichiers sur turbopack
+
+Lors de l'utilisation de Turbopack sur Next.js 14 et versions ultérieures comme serveur de développement avec la commande `next dev --turbopack`, les modifications du dictionnaire ne seront pas détectées automatiquement par défaut.
+
+Cette limitation se produit parce que Turbopack ne peut pas exécuter les plugins webpack en parallèle pour surveiller les modifications dans vos fichiers de contenu.
+
+Pour contourner ce problème, nous avons utilisé la commande `intlayer watch` avec l'option `--with` pour exécuter simultanément le serveur de développement et l'observateur de build Intlayer.
+
+```json5 fileName="package.json"
+{
+  "scripts": {
+    "dev": "npx intlayer watch --with 'next dev --turbopack'",
+  },
+}
+```
+
+---
+
 ## Notes de migration
 
 - Supprimé : `dictionaryOutput` (précédemment `i18next` ou `next-intl`). Cela reviendra sous forme d'adaptateurs modulables dans les futures versions. Supprimez ce champ de votre configuration.
@@ -313,6 +335,12 @@ Voir [CMS et synchronisation en direct](https://github.com/aymericzip/intlayer/b
 
 ---
 
+## Notes de migration de v6 à v7
+
+Consultez les [notes de migration de v6 à v7](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/releases/v7.md) pour plus d'informations.
+
+---
+
 ## Liens utiles
 
 - [Référence CLI](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/cli/index.md)

package/docs/fr/releases/v7.md

@@ -25,6 +25,10 @@ author: aymericzip
 
 Bienvenue dans Intlayer v7 ! Cette version majeure introduit des améliorations significatives en termes de performance, de sécurité des types et d'expérience développeur. Voici les points forts, avec des notes de migration et des exemples pratiques.
 
+## Table of contents
+
+<TOC levels={[2]} maxDepth={1} />
+
 ## Points forts
 
 - Stratégie de mise en cache pour des builds plus rapides
@@ -261,6 +265,126 @@ Cela se traduit par des temps de téléchargement plus rapides et une meilleure
 
 ---
 
+## Formatage automatique du code : configuration de formatCommand
+
+v7 introduit l'option `formatCommand` dans la configuration de l'éditeur, vous permettant de formater automatiquement les fichiers de contenu lorsqu'ils sont écrits par Intlayer. Cela garantit un style de code et un formatage cohérents dans vos fichiers de déclaration de contenu.
+
+S'il n'est pas défini, Intlayer essaiera de détecter automatiquement la commande de formatage. En essayant de résoudre les commandes suivantes : prettier, biome, eslint.
+
+### Configuration
+
+L'option `formatCommand` accepte un modèle de chaîne où `{{file}}` sera remplacé par le chemin de fichier réel :
+
+```typescript fileName="intlayer.config.ts"
+export default {
+  content: {
+    formatCommand: 'bun x biome format "{{file}}" --write --log-level none',
+  },
+};
+```
+
+### Formatters supportés
+
+Vous pouvez utiliser n'importe quel formateur de code qui accepte les chemins de fichiers comme arguments :
+
+**Utilisation de Biome :**
+
+```typescript
+formatCommand: 'bun x biome format "{{file}}" --write --log-level none';
+```
+
+**Utilisation de Prettier :**
+
+```typescript
+formatCommand: 'npx prettier --write "{{file}}" --log-level silent';
+```
+
+**Utilisation d'ESLint :**
+
+```typescript
+formatCommand: 'npx eslint --fix "{{file}}" --quiet';
+```
+
+**Utilisation du formateur intégré de Bun :**
+
+```typescript
+formatCommand: 'bun format "{{file}}"';
+```
+
+### Avantages
+
+- **Formatage cohérent** : Tous les fichiers de contenu sont automatiquement formatés selon les directives de style de votre projet
+- **Expérience développeur** : Pas besoin de formater manuellement les fichiers après qu'Intlayer les ait écrits
+- **Cohérence d'équipe** : Assure que tous les membres de l'équipe ont le même formatage appliqué aux fichiers de contenu
+- **Intégration CI/CD** : Les fichiers de contenu maintiennent un formatage cohérent dans les workflows automatisés
+
+### Fonctionnement
+
+Lorsqu'Intlayer écrit ou met à jour un fichier de déclaration de contenu (`.content.ts`, `.content.js`, etc.), il exécute automatiquement la commande de format spécifiée sur le fichier. L'espace réservé `{{file}}` est remplacé par le chemin d'accès réel du fichier, et la commande est exécutée dans le répertoire de base du projet.
+
+---
+
+## Configuration du dictionnaire : Meilleure organisation et structure
+
+v7 introduit une nouvelle section de configuration `dictionary` dédiée qui offre une meilleure organisation des paramètres liés au dictionnaire et une gestion de contenu améliorée.
+
+### Nouvelle structure de configuration du dictionnaire
+
+La propriété `fill` a été déplacée de la section `content` vers une nouvelle section `dictionary`, offrant une séparation des responsabilités plus claire :
+
+**Configuration v6 :**
+
+```typescript fileName="intlayer.config.ts"
+export default {
+  content: {
+    autoFill: "./{{fileName}}.content.json",
+    contentDir: ["src"],
+  },
+};
+```
+
+**Configuration v7 :**
+
+```typescript fileName="intlayer.config.ts"
+export default {
+  content: {
+    contentDir: ["src"],
+  },
+  dictionary: {
+    fill: "./{{fileName}}.content.json",
+  },
+};
+```
+
+### Avantages de la nouvelle structure
+
+- **Organisation plus claire** : Les paramètres spécifiques au dictionnaire sont maintenant regroupés
+- **Meilleure séparation des préoccupations** : La découverte de contenu et les opérations de dictionnaire sont clairement séparées
+- **Maintenabilité améliorée** : Plus facile à comprendre et à modifier les configurations liées au dictionnaire
+- **Extensibilité future** : La section dictionnaire peut accueillir des paramètres supplémentaires spécifiques au dictionnaire
+- **Gestion complète du dictionnaire** : Inclut des propriétés comme `title`, `live`, `priority`, `tags`, `version`, et `description` pour créer et gérer de nouveaux dictionnaires
+
+### Utilisation de la configuration
+
+La configuration du dictionnaire sert deux objectifs principaux :
+
+1. **Valeurs par défaut** : Définir les valeurs par défaut lors de la création de fichiers de déclaration de contenu
+2. **Comportement de secours** : Fournir des valeurs de secours lorsque des champs spécifiques ne sont pas définis, vous permettant de définir le comportement du dictionnaire globalement
+
+La section dictionnaire inclut des propriétés complètes pour la gestion du dictionnaire :
+
+- **`fill`** : Comportement de remplissage automatique pour la génération de contenu
+- **`title`** : Titre par défaut pour les nouveaux dictionnaires
+- **`live`** : Configuration de synchronisation en direct pour les mises à jour en temps réel
+- **`priority`** : Paramètres de priorité pour la résolution du dictionnaire
+- **`tags`** : Tags par défaut pour l'organisation du contenu
+- **`version`** : Gestion des versions pour les mises à jour du dictionnaire
+- **`description`** : Description par défaut pour le nouveau contenu
+
+Pour plus d'informations sur les fichiers de déclaration de contenu et la façon dont les valeurs de configuration sont appliquées, consultez la [Documentation du fichier de contenu](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/content_file.md).
+
+---
+
 ## Commande fill : comportement mis à jour pour une meilleure gestion du contenu
 
 La version 7 introduit un comportement amélioré pour la commande `fill`, offrant une gestion du contenu plus prévisible et flexible :
@@ -408,6 +532,10 @@ Le système effectue automatiquement :
 - **`middleware.prefixDefault`** : Remplacé par `routing.mode`
 - **`middleware.noPrefix`** : Remplacé par `routing.mode`
 
+### Nouvelles configurations
+
+- **`editor.formatCommand`**: Nouvelle option pour le formatage automatique du code des fichiers de contenu
+
 ### Correspondance de migration
 
 #### Correspondance de configuration